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