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