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, 2011 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
 325   return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 326 }
 327
 328 CORE_ADDR
 329 signed_pointer_to_address (struct gdbarch *gdbarch,
 330                            struct type *type, const gdb_byte *buf)
 331 {
 332   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 333
 334   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
 335 }
 336
 337 /* Given an address, store it as a pointer of type TYPE in target
 338    format in BUF.  */
 339 void
 340 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
 341                              gdb_byte *buf, CORE_ADDR addr)
 342 {
 343   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 344
 345   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 346 }
 347
 348 void
 349 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
 350                            gdb_byte *buf, CORE_ADDR addr)
 351 {
 352   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 353
 354   store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 355 }
 356 \f
 357 /* Will calling read_var_value or locate_var_value on SYM end
 358    up caring what frame it is being evaluated relative to?  SYM must
 359    be non-NULL.  */
 360 int
 361 symbol_read_needs_frame (struct symbol *sym)
 362 {
 363   switch (SYMBOL_CLASS (sym))
 364     {
 365       /* All cases listed explicitly so that gcc -Wall will detect it if
 366          we failed to consider one.  */
 367     case LOC_COMPUTED:
 368       /* FIXME: cagney/2004-01-26: It should be possible to
 369          unconditionally call the SYMBOL_COMPUTED_OPS method when available.
 370          Unfortunately DWARF 2 stores the frame-base (instead of the
 371          function) location in a function's symbol.  Oops!  For the
 372          moment enable this when/where applicable.  */
 373       return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
 374
 375     case LOC_REGISTER:
 376     case LOC_ARG:
 377     case LOC_REF_ARG:
 378     case LOC_REGPARM_ADDR:
 379     case LOC_LOCAL:
 380       return 1;
 381
 382     case LOC_UNDEF:
 383     case LOC_CONST:
 384     case LOC_STATIC:
 385     case LOC_TYPEDEF:
 386
 387     case LOC_LABEL:
 388       /* Getting the address of a label can be done independently of the block,
 389          even if some *uses* of that address wouldn't work so well without
 390          the right frame.  */
 391
 392     case LOC_BLOCK:
 393     case LOC_CONST_BYTES:
 394     case LOC_UNRESOLVED:
 395     case LOC_OPTIMIZED_OUT:
 396       return 0;
 397     }
 398   return 1;
 399 }
 400
 401 /* Given a struct symbol for a variable,
 402    and a stack frame id, read the value of the variable
 403    and return a (pointer to a) struct value containing the value.
 404    If the variable cannot be found, return a zero pointer.  */
 405
 406 struct value *
 407 read_var_value (struct symbol *var, struct frame_info *frame)
 408 {
 409   struct value *v;
 410   struct type *type = SYMBOL_TYPE (var);
 411   CORE_ADDR addr;
 412   int len;
 413
 414   if (SYMBOL_CLASS (var) == LOC_COMPUTED
 415       || SYMBOL_CLASS (var) == LOC_REGISTER)
 416     /* These cases do not use V.  */
 417     v = NULL;
 418   else
 419     {
 420       v = allocate_value (type);
 421       VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
 422     }
 423
 424   len = TYPE_LENGTH (type);
 425
 426   if (symbol_read_needs_frame (var))
 427     gdb_assert (frame);
 428
 429   switch (SYMBOL_CLASS (var))
 430     {
 431     case LOC_CONST:
 432       /* Put the constant back in target format.  */
 433       store_signed_integer (value_contents_raw (v), len,
 434                             gdbarch_byte_order (get_type_arch (type)),
 435                             (LONGEST) SYMBOL_VALUE (var));
 436       VALUE_LVAL (v) = not_lval;
 437       return v;
 438
 439     case LOC_LABEL:
 440       /* Put the constant back in target format.  */
 441       if (overlay_debugging)
 442         {
 443           CORE_ADDR addr
 444             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 445                                         SYMBOL_OBJ_SECTION (var));
 446
 447           store_typed_address (value_contents_raw (v), type, addr);
 448         }
 449       else
 450         store_typed_address (value_contents_raw (v), type,
 451                               SYMBOL_VALUE_ADDRESS (var));
 452       VALUE_LVAL (v) = not_lval;
 453       return v;
 454
 455     case LOC_CONST_BYTES:
 456       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
 457       VALUE_LVAL (v) = not_lval;
 458       return v;
 459
 460     case LOC_STATIC:
 461       if (overlay_debugging)
 462         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 463                                          SYMBOL_OBJ_SECTION (var));
 464       else
 465         addr = SYMBOL_VALUE_ADDRESS (var);
 466       break;
 467
 468     case LOC_ARG:
 469       addr = get_frame_args_address (frame);
 470       if (!addr)
 471         return 0;
 472       addr += SYMBOL_VALUE (var);
 473       break;
 474
 475     case LOC_REF_ARG:
 476       {
 477         struct value *ref;
 478         CORE_ADDR argref;
 479
 480         argref = get_frame_args_address (frame);
 481         if (!argref)
 482           return 0;
 483         argref += SYMBOL_VALUE (var);
 484         ref = value_at (lookup_pointer_type (type), argref);
 485         addr = value_as_address (ref);
 486         break;
 487       }
 488
 489     case LOC_LOCAL:
 490       addr = get_frame_locals_address (frame);
 491       addr += SYMBOL_VALUE (var);
 492       break;
 493
 494     case LOC_TYPEDEF:
 495       error (_("Cannot look up value of a typedef"));
 496       break;
 497
 498     case LOC_BLOCK:
 499       if (overlay_debugging)
 500         set_value_address (v, symbol_overlayed_address
 501           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)));
 502       else
 503         set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
 504       return v;
 505
 506     case LOC_REGISTER:
 507     case LOC_REGPARM_ADDR:
 508       {
 509         int regno = SYMBOL_REGISTER_OPS (var)
 510                       ->register_number (var, get_frame_arch (frame));
 511         struct value *regval;
 512
 513         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 514           {
 515             regval = value_from_register (lookup_pointer_type (type),
 516                                           regno,
 517                                           frame);
 518
 519             if (regval == NULL)
 520               error (_("Value of register variable not available."));
 521
 522             addr = value_as_address (regval);
 523             VALUE_LVAL (v) = lval_memory;
 524           }
 525         else
 526           {
 527             regval = value_from_register (type, regno, frame);
 528
 529             if (regval == NULL)
 530               error (_("Value of register variable not available."));
 531             return regval;
 532           }
 533       }
 534       break;
 535
 536     case LOC_COMPUTED:
 537       /* FIXME: cagney/2004-01-26: It should be possible to
 538          unconditionally call the SYMBOL_COMPUTED_OPS method when available.
 539          Unfortunately DWARF 2 stores the frame-base (instead of the
 540          function) location in a function's symbol.  Oops!  For the
 541          moment enable this when/where applicable.  */
 542       return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
 543
 544     case LOC_UNRESOLVED:
 545       {
 546         struct minimal_symbol *msym;
 547         struct obj_section *obj_section;
 548
 549         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
 550         if (msym == NULL)
 551           return 0;
 552         if (overlay_debugging)
 553           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 554                                            SYMBOL_OBJ_SECTION (msym));
 555         else
 556           addr = SYMBOL_VALUE_ADDRESS (msym);
 557
 558         obj_section = SYMBOL_OBJ_SECTION (msym);
 559         if (obj_section
 560             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 561           addr = target_translate_tls_address (obj_section->objfile, addr);
 562       }
 563       break;
 564
 565     case LOC_OPTIMIZED_OUT:
 566       VALUE_LVAL (v) = not_lval;
 567       set_value_optimized_out (v, 1);
 568       return v;
 569
 570     default:
 571       error (_("Cannot look up value of a botched symbol."));
 572       break;
 573     }
 574
 575   set_value_address (v, addr);
 576   set_value_lazy (v, 1);
 577   return v;
 578 }
 579
 580 /* Install default attributes for register values.  */
 581
 582 struct value *
 583 default_value_from_register (struct type *type, int regnum,
 584                              struct frame_info *frame)
 585 {
 586   struct gdbarch *gdbarch = get_frame_arch (frame);
 587   int len = TYPE_LENGTH (type);
 588   struct value *value = allocate_value (type);
 589
 590   VALUE_LVAL (value) = lval_register;
 591   VALUE_FRAME_ID (value) = get_frame_id (frame);
 592   VALUE_REGNUM (value) = regnum;
 593
 594   /* Any structure stored in more than one register will always be
 595      an integral number of registers.  Otherwise, you need to do
 596      some fiddling with the last register copied here for little
 597      endian machines.  */
 598   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 599       && len < register_size (gdbarch, regnum))
 600     /* Big-endian, and we want less than full size.  */
 601     set_value_offset (value, register_size (gdbarch, regnum) - len);
 602   else
 603     set_value_offset (value, 0);
 604
 605   return value;
 606 }
 607
 608 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 609
 610 struct value *
 611 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 612 {
 613   struct gdbarch *gdbarch = get_frame_arch (frame);
 614   struct type *type1 = check_typedef (type);
 615   struct value *v;
 616
 617   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 618     {
 619       /* The ISA/ABI need to something weird when obtaining the
 620          specified value from this register.  It might need to
 621          re-order non-adjacent, starting with REGNUM (see MIPS and
 622          i386).  It might need to convert the [float] register into
 623          the corresponding [integer] type (see Alpha).  The assumption
 624          is that gdbarch_register_to_value populates the entire value
 625          including the location.  */
 626       v = allocate_value (type);
 627       VALUE_LVAL (v) = lval_register;
 628       VALUE_FRAME_ID (v) = get_frame_id (frame);
 629       VALUE_REGNUM (v) = regnum;
 630       gdbarch_register_to_value (gdbarch,
 631                                  frame, regnum, type1, value_contents_raw (v));
 632     }
 633   else
 634     {
 635       int len = TYPE_LENGTH (type);
 636
 637       /* Construct the value.  */
 638       v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
 639
 640       /* Get the data.  */
 641       if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
 642                                      value_contents_raw (v)))
 643         set_value_optimized_out (v, 1);
 644     }
 645   return v;
 646 }
 647
 648 /* Return contents of register REGNUM in frame FRAME as address,
 649    interpreted as value of type TYPE.   Will abort if register
 650    value is not available.  */
 651
 652 CORE_ADDR
 653 address_from_register (struct type *type, int regnum, struct frame_info *frame)
 654 {
 655   struct value *value;
 656   CORE_ADDR result;
 657
 658   value = value_from_register (type, regnum, frame);
 659   gdb_assert (value);
 660
 661   result = value_as_address (value);
 662   release_value (value);
 663   value_free (value);
 664
 665   return result;
 666 }