1 /* Find a variable's value in memory, for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2016 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "symtab.h" 22 #include "gdbtypes.h" 23 #include "frame.h" 24 #include "value.h" 25 #include "gdbcore.h" 26 #include "inferior.h" 27 #include "target.h" 28 #include "floatformat.h" 29 #include "symfile.h" /* for overlay functions */ 30 #include "regcache.h" 31 #include "user-regs.h" 32 #include "block.h" 33 #include "objfiles.h" 34 #include "language.h" 35 #include "dwarf2loc.h" 36 37 /* Basic byte-swapping routines. All 'extract' functions return a 38 host-format integer from a target-format integer at ADDR which is 39 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... */ 46 you lose 47 #endif 48 49 LONGEST 50 extract_signed_integer (const gdb_byte *addr, int len, 51 enum bfd_endian byte_order) 52 { 53 LONGEST retval; 54 const unsigned char *p; 55 const unsigned char *startaddr = addr; 56 const unsigned char *endaddr = startaddr + len; 57 58 if (len > (int) sizeof (LONGEST)) 59 error (_("\ 60 That operation is not available on integers of more than %d bytes."), 61 (int) sizeof (LONGEST)); 62 63 /* Start at the most significant end of the integer, and work towards 64 the least significant. */ 65 if (byte_order == BFD_ENDIAN_BIG) 66 { 67 p = startaddr; 68 /* Do the sign extension once at the start. */ 69 retval = ((LONGEST) * p ^ 0x80) - 0x80; 70 for (++p; p < endaddr; ++p) 71 retval = (retval << 8) | *p; 72 } 73 else 74 { 75 p = endaddr - 1; 76 /* Do the sign extension once at the start. */ 77 retval = ((LONGEST) * p ^ 0x80) - 0x80; 78 for (--p; p >= startaddr; --p) 79 retval = (retval << 8) | *p; 80 } 81 return retval; 82 } 83 84 ULONGEST 85 extract_unsigned_integer (const gdb_byte *addr, int len, 86 enum bfd_endian byte_order) 87 { 88 ULONGEST retval; 89 const unsigned char *p; 90 const unsigned char *startaddr = addr; 91 const unsigned char *endaddr = startaddr + len; 92 93 if (len > (int) sizeof (ULONGEST)) 94 error (_("\ 95 That operation is not available on integers of more than %d bytes."), 96 (int) sizeof (ULONGEST)); 97 98 /* Start at the most significant end of the integer, and work towards 99 the least significant. */ 100 retval = 0; 101 if (byte_order == BFD_ENDIAN_BIG) 102 { 103 for (p = startaddr; p < endaddr; ++p) 104 retval = (retval << 8) | *p; 105 } 106 else 107 { 108 for (p = endaddr - 1; p >= startaddr; --p) 109 retval = (retval << 8) | *p; 110 } 111 return retval; 112 } 113 114 /* Sometimes a long long unsigned integer can be extracted as a 115 LONGEST value. This is done so that we can print these values 116 better. If this integer can be converted to a LONGEST, this 117 function returns 1 and sets *PVAL. Otherwise it returns 0. */ 118 119 int 120 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, 121 enum bfd_endian byte_order, LONGEST *pval) 122 { 123 const gdb_byte *p; 124 const gdb_byte *first_addr; 125 int len; 126 127 len = orig_len; 128 if (byte_order == BFD_ENDIAN_BIG) 129 { 130 for (p = addr; 131 len > (int) sizeof (LONGEST) && p < addr + orig_len; 132 p++) 133 { 134 if (*p == 0) 135 len--; 136 else 137 break; 138 } 139 first_addr = p; 140 } 141 else 142 { 143 first_addr = addr; 144 for (p = addr + orig_len - 1; 145 len > (int) sizeof (LONGEST) && p >= addr; 146 p--) 147 { 148 if (*p == 0) 149 len--; 150 else 151 break; 152 } 153 } 154 155 if (len <= (int) sizeof (LONGEST)) 156 { 157 *pval = (LONGEST) extract_unsigned_integer (first_addr, 158 sizeof (LONGEST), 159 byte_order); 160 return 1; 161 } 162 163 return 0; 164 } 165 166 167 /* Treat the bytes at BUF as a pointer of type TYPE, and return the 168 address it represents. */ 169 CORE_ADDR 170 extract_typed_address (const gdb_byte *buf, struct type *type) 171 { 172 if (TYPE_CODE (type) != TYPE_CODE_PTR 173 && TYPE_CODE (type) != TYPE_CODE_REF) 174 internal_error (__FILE__, __LINE__, 175 _("extract_typed_address: " 176 "type is not a pointer or reference")); 177 178 return gdbarch_pointer_to_address (get_type_arch (type), type, buf); 179 } 180 181 /* All 'store' functions accept a host-format integer and store a 182 target-format integer at ADDR which is LEN bytes long. */ 183 184 void 185 store_signed_integer (gdb_byte *addr, int len, 186 enum bfd_endian byte_order, LONGEST val) 187 { 188 gdb_byte *p; 189 gdb_byte *startaddr = addr; 190 gdb_byte *endaddr = startaddr + len; 191 192 /* Start at the least significant end of the integer, and work towards 193 the most significant. */ 194 if (byte_order == BFD_ENDIAN_BIG) 195 { 196 for (p = endaddr - 1; p >= startaddr; --p) 197 { 198 *p = val & 0xff; 199 val >>= 8; 200 } 201 } 202 else 203 { 204 for (p = startaddr; p < endaddr; ++p) 205 { 206 *p = val & 0xff; 207 val >>= 8; 208 } 209 } 210 } 211 212 void 213 store_unsigned_integer (gdb_byte *addr, int len, 214 enum bfd_endian byte_order, ULONGEST val) 215 { 216 unsigned char *p; 217 unsigned char *startaddr = (unsigned char *) addr; 218 unsigned char *endaddr = startaddr + len; 219 220 /* Start at the least significant end of the integer, and work towards 221 the most significant. */ 222 if (byte_order == BFD_ENDIAN_BIG) 223 { 224 for (p = endaddr - 1; p >= startaddr; --p) 225 { 226 *p = val & 0xff; 227 val >>= 8; 228 } 229 } 230 else 231 { 232 for (p = startaddr; p < endaddr; ++p) 233 { 234 *p = val & 0xff; 235 val >>= 8; 236 } 237 } 238 } 239 240 /* Store the address ADDR as a pointer of type TYPE at BUF, in target 241 form. */ 242 void 243 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) 244 { 245 if (TYPE_CODE (type) != TYPE_CODE_PTR 246 && TYPE_CODE (type) != TYPE_CODE_REF) 247 internal_error (__FILE__, __LINE__, 248 _("store_typed_address: " 249 "type is not a pointer or reference")); 250 251 gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr); 252 } 253 254 255 256 /* Return a `value' with the contents of (virtual or cooked) register 257 REGNUM as found in the specified FRAME. The register's type is 258 determined by register_type(). */ 259 260 struct value * 261 value_of_register (int regnum, struct frame_info *frame) 262 { 263 struct gdbarch *gdbarch = get_frame_arch (frame); 264 struct value *reg_val; 265 266 /* User registers lie completely outside of the range of normal 267 registers. Catch them early so that the target never sees them. */ 268 if (regnum >= gdbarch_num_regs (gdbarch) 269 + gdbarch_num_pseudo_regs (gdbarch)) 270 return value_of_user_reg (regnum, frame); 271 272 reg_val = value_of_register_lazy (frame, regnum); 273 value_fetch_lazy (reg_val); 274 return reg_val; 275 } 276 277 /* Return a `value' with the contents of (virtual or cooked) register 278 REGNUM as found in the specified FRAME. The register's type is 279 determined by register_type(). The value is not fetched. */ 280 281 struct value * 282 value_of_register_lazy (struct frame_info *frame, int regnum) 283 { 284 struct gdbarch *gdbarch = get_frame_arch (frame); 285 struct value *reg_val; 286 287 gdb_assert (regnum < (gdbarch_num_regs (gdbarch) 288 + gdbarch_num_pseudo_regs (gdbarch))); 289 290 /* We should have a valid (i.e. non-sentinel) frame. */ 291 gdb_assert (frame_id_p (get_frame_id (frame))); 292 293 reg_val = allocate_value_lazy (register_type (gdbarch, regnum)); 294 VALUE_LVAL (reg_val) = lval_register; 295 VALUE_REGNUM (reg_val) = regnum; 296 VALUE_FRAME_ID (reg_val) = get_frame_id (frame); 297 return reg_val; 298 } 299 300 /* Given a pointer of type TYPE in target form in BUF, return the 301 address it represents. */ 302 CORE_ADDR 303 unsigned_pointer_to_address (struct gdbarch *gdbarch, 304 struct type *type, const gdb_byte *buf) 305 { 306 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 307 308 return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); 309 } 310 311 CORE_ADDR 312 signed_pointer_to_address (struct gdbarch *gdbarch, 313 struct type *type, const gdb_byte *buf) 314 { 315 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 316 317 return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order); 318 } 319 320 /* Given an address, store it as a pointer of type TYPE in target 321 format in BUF. */ 322 void 323 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type, 324 gdb_byte *buf, CORE_ADDR addr) 325 { 326 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 327 328 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); 329 } 330 331 void 332 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type, 333 gdb_byte *buf, CORE_ADDR addr) 334 { 335 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 336 337 store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr); 338 } 339 340 /* See value.h. */ 341 342 enum symbol_needs_kind 343 symbol_read_needs (struct symbol *sym) 344 { 345 if (SYMBOL_COMPUTED_OPS (sym) != NULL) 346 return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym); 347 348 switch (SYMBOL_CLASS (sym)) 349 { 350 /* All cases listed explicitly so that gcc -Wall will detect it if 351 we failed to consider one. */ 352 case LOC_COMPUTED: 353 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method")); 354 355 case LOC_REGISTER: 356 case LOC_ARG: 357 case LOC_REF_ARG: 358 case LOC_REGPARM_ADDR: 359 case LOC_LOCAL: 360 return SYMBOL_NEEDS_FRAME; 361 362 case LOC_UNDEF: 363 case LOC_CONST: 364 case LOC_STATIC: 365 case LOC_TYPEDEF: 366 367 case LOC_LABEL: 368 /* Getting the address of a label can be done independently of the block, 369 even if some *uses* of that address wouldn't work so well without 370 the right frame. */ 371 372 case LOC_BLOCK: 373 case LOC_CONST_BYTES: 374 case LOC_UNRESOLVED: 375 case LOC_OPTIMIZED_OUT: 376 return SYMBOL_NEEDS_NONE; 377 } 378 return SYMBOL_NEEDS_FRAME; 379 } 380 381 /* See value.h. */ 382 383 int 384 symbol_read_needs_frame (struct symbol *sym) 385 { 386 return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME; 387 } 388 389 /* Private data to be used with minsym_lookup_iterator_cb. */ 390 391 struct minsym_lookup_data 392 { 393 /* The name of the minimal symbol we are searching for. */ 394 const char *name; 395 396 /* The field where the callback should store the minimal symbol 397 if found. It should be initialized to NULL before the search 398 is started. */ 399 struct bound_minimal_symbol result; 400 }; 401 402 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order. 403 It searches by name for a minimal symbol within the given OBJFILE. 404 The arguments are passed via CB_DATA, which in reality is a pointer 405 to struct minsym_lookup_data. */ 406 407 static int 408 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data) 409 { 410 struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data; 411 412 gdb_assert (data->result.minsym == NULL); 413 414 data->result = lookup_minimal_symbol (data->name, NULL, objfile); 415 416 /* The iterator should stop iff a match was found. */ 417 return (data->result.minsym != NULL); 418 } 419 420 /* Given static link expression and the frame it lives in, look for the frame 421 the static links points to and return it. Return NULL if we could not find 422 such a frame. */ 423 424 static struct frame_info * 425 follow_static_link (struct frame_info *frame, 426 const struct dynamic_prop *static_link) 427 { 428 CORE_ADDR upper_frame_base; 429 430 if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base)) 431 return NULL; 432 433 /* Now climb up the stack frame until we reach the frame we are interested 434 in. */ 435 for (; frame != NULL; frame = get_prev_frame (frame)) 436 { 437 struct symbol *framefunc = get_frame_function (frame); 438 439 /* Stacks can be quite deep: give the user a chance to stop this. */ 440 QUIT; 441 442 /* If we don't know how to compute FRAME's base address, don't give up: 443 maybe the frame we are looking for is upper in the stace frame. */ 444 if (framefunc != NULL 445 && SYMBOL_BLOCK_OPS (framefunc) != NULL 446 && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL 447 && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame) 448 == upper_frame_base)) 449 break; 450 } 451 452 return frame; 453 } 454 455 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical 456 rules, look for the frame that is actually hosting VAR and return it. If, 457 for some reason, we found no such frame, return NULL. 458 459 This kind of computation is necessary to correctly handle lexically nested 460 functions. 461 462 Note that in some cases, we know what scope VAR comes from but we cannot 463 reach the specific frame that hosts the instance of VAR we are looking for. 464 For backward compatibility purposes (with old compilers), we then look for 465 the first frame that can host it. */ 466 467 static struct frame_info * 468 get_hosting_frame (struct symbol *var, const struct block *var_block, 469 struct frame_info *frame) 470 { 471 const struct block *frame_block = NULL; 472 473 if (!symbol_read_needs_frame (var)) 474 return NULL; 475 476 /* Some symbols for local variables have no block: this happens when they are 477 not produced by a debug information reader, for instance when GDB creates 478 synthetic symbols. Without block information, we must assume they are 479 local to FRAME. In this case, there is nothing to do. */ 480 else if (var_block == NULL) 481 return frame; 482 483 /* We currently assume that all symbols with a location list need a frame. 484 This is true in practice because selecting the location description 485 requires to compute the CFA, hence requires a frame. However we have 486 tests that embed global/static symbols with null location lists. 487 We want to get <optimized out> instead of <frame required> when evaluating 488 them so return a frame instead of raising an error. */ 489 else if (var_block == block_global_block (var_block) 490 || var_block == block_static_block (var_block)) 491 return frame; 492 493 /* We have to handle the "my_func::my_local_var" notation. This requires us 494 to look for upper frames when we find no block for the current frame: here 495 and below, handle when frame_block == NULL. */ 496 if (frame != NULL) 497 frame_block = get_frame_block (frame, NULL); 498 499 /* Climb up the call stack until reaching the frame we are looking for. */ 500 while (frame != NULL && frame_block != var_block) 501 { 502 /* Stacks can be quite deep: give the user a chance to stop this. */ 503 QUIT; 504 505 if (frame_block == NULL) 506 { 507 frame = get_prev_frame (frame); 508 if (frame == NULL) 509 break; 510 frame_block = get_frame_block (frame, NULL); 511 } 512 513 /* If we failed to find the proper frame, fallback to the heuristic 514 method below. */ 515 else if (frame_block == block_global_block (frame_block)) 516 { 517 frame = NULL; 518 break; 519 } 520 521 /* Assuming we have a block for this frame: if we are at the function 522 level, the immediate upper lexical block is in an outer function: 523 follow the static link. */ 524 else if (BLOCK_FUNCTION (frame_block)) 525 { 526 const struct dynamic_prop *static_link 527 = block_static_link (frame_block); 528 int could_climb_up = 0; 529 530 if (static_link != NULL) 531 { 532 frame = follow_static_link (frame, static_link); 533 if (frame != NULL) 534 { 535 frame_block = get_frame_block (frame, NULL); 536 could_climb_up = frame_block != NULL; 537 } 538 } 539 if (!could_climb_up) 540 { 541 frame = NULL; 542 break; 543 } 544 } 545 546 else 547 /* We must be in some function nested lexical block. Just get the 548 outer block: both must share the same frame. */ 549 frame_block = BLOCK_SUPERBLOCK (frame_block); 550 } 551 552 /* Old compilers may not provide a static link, or they may provide an 553 invalid one. For such cases, fallback on the old way to evaluate 554 non-local references: just climb up the call stack and pick the first 555 frame that contains the variable we are looking for. */ 556 if (frame == NULL) 557 { 558 frame = block_innermost_frame (var_block); 559 if (frame == NULL) 560 { 561 if (BLOCK_FUNCTION (var_block) 562 && !block_inlined_p (var_block) 563 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block))) 564 error (_("No frame is currently executing in block %s."), 565 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block))); 566 else 567 error (_("No frame is currently executing in specified" 568 " block")); 569 } 570 } 571 572 return frame; 573 } 574 575 /* A default implementation for the "la_read_var_value" hook in 576 the language vector which should work in most situations. */ 577 578 struct value * 579 default_read_var_value (struct symbol *var, const struct block *var_block, 580 struct frame_info *frame) 581 { 582 struct value *v; 583 struct type *type = SYMBOL_TYPE (var); 584 CORE_ADDR addr; 585 enum symbol_needs_kind sym_need; 586 587 /* Call check_typedef on our type to make sure that, if TYPE is 588 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type 589 instead of zero. However, we do not replace the typedef type by the 590 target type, because we want to keep the typedef in order to be able to 591 set the returned value type description correctly. */ 592 check_typedef (type); 593 594 sym_need = symbol_read_needs (var); 595 if (sym_need == SYMBOL_NEEDS_FRAME) 596 gdb_assert (frame != NULL); 597 else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers) 598 error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var)); 599 600 if (frame != NULL) 601 frame = get_hosting_frame (var, var_block, frame); 602 603 if (SYMBOL_COMPUTED_OPS (var) != NULL) 604 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame); 605 606 switch (SYMBOL_CLASS (var)) 607 { 608 case LOC_CONST: 609 if (is_dynamic_type (type)) 610 { 611 /* Value is a constant byte-sequence and needs no memory access. */ 612 type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0); 613 } 614 /* Put the constant back in target format. */ 615 v = allocate_value (type); 616 store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type), 617 gdbarch_byte_order (get_type_arch (type)), 618 (LONGEST) SYMBOL_VALUE (var)); 619 VALUE_LVAL (v) = not_lval; 620 return v; 621 622 case LOC_LABEL: 623 /* Put the constant back in target format. */ 624 v = allocate_value (type); 625 if (overlay_debugging) 626 { 627 CORE_ADDR addr 628 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 629 SYMBOL_OBJ_SECTION (symbol_objfile (var), 630 var)); 631 632 store_typed_address (value_contents_raw (v), type, addr); 633 } 634 else 635 store_typed_address (value_contents_raw (v), type, 636 SYMBOL_VALUE_ADDRESS (var)); 637 VALUE_LVAL (v) = not_lval; 638 return v; 639 640 case LOC_CONST_BYTES: 641 if (is_dynamic_type (type)) 642 { 643 /* Value is a constant byte-sequence and needs no memory access. */ 644 type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0); 645 } 646 v = allocate_value (type); 647 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), 648 TYPE_LENGTH (type)); 649 VALUE_LVAL (v) = not_lval; 650 return v; 651 652 case LOC_STATIC: 653 if (overlay_debugging) 654 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 655 SYMBOL_OBJ_SECTION (symbol_objfile (var), 656 var)); 657 else 658 addr = SYMBOL_VALUE_ADDRESS (var); 659 break; 660 661 case LOC_ARG: 662 addr = get_frame_args_address (frame); 663 if (!addr) 664 error (_("Unknown argument list address for `%s'."), 665 SYMBOL_PRINT_NAME (var)); 666 addr += SYMBOL_VALUE (var); 667 break; 668 669 case LOC_REF_ARG: 670 { 671 struct value *ref; 672 CORE_ADDR argref; 673 674 argref = get_frame_args_address (frame); 675 if (!argref) 676 error (_("Unknown argument list address for `%s'."), 677 SYMBOL_PRINT_NAME (var)); 678 argref += SYMBOL_VALUE (var); 679 ref = value_at (lookup_pointer_type (type), argref); 680 addr = value_as_address (ref); 681 break; 682 } 683 684 case LOC_LOCAL: 685 addr = get_frame_locals_address (frame); 686 addr += SYMBOL_VALUE (var); 687 break; 688 689 case LOC_TYPEDEF: 690 error (_("Cannot look up value of a typedef `%s'."), 691 SYMBOL_PRINT_NAME (var)); 692 break; 693 694 case LOC_BLOCK: 695 if (overlay_debugging) 696 addr = symbol_overlayed_address 697 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), 698 SYMBOL_OBJ_SECTION (symbol_objfile (var), var)); 699 else 700 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); 701 break; 702 703 case LOC_REGISTER: 704 case LOC_REGPARM_ADDR: 705 { 706 int regno = SYMBOL_REGISTER_OPS (var) 707 ->register_number (var, get_frame_arch (frame)); 708 struct value *regval; 709 710 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) 711 { 712 regval = value_from_register (lookup_pointer_type (type), 713 regno, 714 frame); 715 716 if (regval == NULL) 717 error (_("Value of register variable not available for `%s'."), 718 SYMBOL_PRINT_NAME (var)); 719 720 addr = value_as_address (regval); 721 } 722 else 723 { 724 regval = value_from_register (type, regno, frame); 725 726 if (regval == NULL) 727 error (_("Value of register variable not available for `%s'."), 728 SYMBOL_PRINT_NAME (var)); 729 return regval; 730 } 731 } 732 break; 733 734 case LOC_COMPUTED: 735 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method")); 736 737 case LOC_UNRESOLVED: 738 { 739 struct minsym_lookup_data lookup_data; 740 struct minimal_symbol *msym; 741 struct obj_section *obj_section; 742 743 memset (&lookup_data, 0, sizeof (lookup_data)); 744 lookup_data.name = SYMBOL_LINKAGE_NAME (var); 745 746 gdbarch_iterate_over_objfiles_in_search_order 747 (symbol_arch (var), 748 minsym_lookup_iterator_cb, &lookup_data, 749 symbol_objfile (var)); 750 msym = lookup_data.result.minsym; 751 752 /* If we can't find the minsym there's a problem in the symbol info. 753 The symbol exists in the debug info, but it's missing in the minsym 754 table. */ 755 if (msym == NULL) 756 { 757 const char *flavour_name 758 = objfile_flavour_name (symbol_objfile (var)); 759 760 /* We can't get here unless we've opened the file, so flavour_name 761 can't be NULL. */ 762 gdb_assert (flavour_name != NULL); 763 error (_("Missing %s symbol \"%s\"."), 764 flavour_name, SYMBOL_LINKAGE_NAME (var)); 765 } 766 obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym); 767 /* Relocate address, unless there is no section or the variable is 768 a TLS variable. */ 769 if (obj_section == NULL 770 || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) 771 addr = MSYMBOL_VALUE_RAW_ADDRESS (msym); 772 else 773 addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result); 774 if (overlay_debugging) 775 addr = symbol_overlayed_address (addr, obj_section); 776 /* Determine address of TLS variable. */ 777 if (obj_section 778 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) 779 addr = target_translate_tls_address (obj_section->objfile, addr); 780 } 781 break; 782 783 case LOC_OPTIMIZED_OUT: 784 return allocate_optimized_out_value (type); 785 786 default: 787 error (_("Cannot look up value of a botched symbol `%s'."), 788 SYMBOL_PRINT_NAME (var)); 789 break; 790 } 791 792 v = value_at_lazy (type, addr); 793 return v; 794 } 795 796 /* Calls VAR's language la_read_var_value hook with the given arguments. */ 797 798 struct value * 799 read_var_value (struct symbol *var, const struct block *var_block, 800 struct frame_info *frame) 801 { 802 const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var)); 803 804 gdb_assert (lang != NULL); 805 gdb_assert (lang->la_read_var_value != NULL); 806 807 return lang->la_read_var_value (var, var_block, frame); 808 } 809 810 /* Install default attributes for register values. */ 811 812 struct value * 813 default_value_from_register (struct gdbarch *gdbarch, struct type *type, 814 int regnum, struct frame_id frame_id) 815 { 816 int len = TYPE_LENGTH (type); 817 struct value *value = allocate_value (type); 818 819 VALUE_LVAL (value) = lval_register; 820 VALUE_FRAME_ID (value) = frame_id; 821 VALUE_REGNUM (value) = regnum; 822 823 /* Any structure stored in more than one register will always be 824 an integral number of registers. Otherwise, you need to do 825 some fiddling with the last register copied here for little 826 endian machines. */ 827 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG 828 && len < register_size (gdbarch, regnum)) 829 /* Big-endian, and we want less than full size. */ 830 set_value_offset (value, register_size (gdbarch, regnum) - len); 831 else 832 set_value_offset (value, 0); 833 834 return value; 835 } 836 837 /* VALUE must be an lval_register value. If regnum is the value's 838 associated register number, and len the length of the values type, 839 read one or more registers in FRAME, starting with register REGNUM, 840 until we've read LEN bytes. 841 842 If any of the registers we try to read are optimized out, then mark the 843 complete resulting value as optimized out. */ 844 845 void 846 read_frame_register_value (struct value *value, struct frame_info *frame) 847 { 848 struct gdbarch *gdbarch = get_frame_arch (frame); 849 LONGEST offset = 0; 850 LONGEST reg_offset = value_offset (value); 851 int regnum = VALUE_REGNUM (value); 852 int len = type_length_units (check_typedef (value_type (value))); 853 854 gdb_assert (VALUE_LVAL (value) == lval_register); 855 856 /* Skip registers wholly inside of REG_OFFSET. */ 857 while (reg_offset >= register_size (gdbarch, regnum)) 858 { 859 reg_offset -= register_size (gdbarch, regnum); 860 regnum++; 861 } 862 863 /* Copy the data. */ 864 while (len > 0) 865 { 866 struct value *regval = get_frame_register_value (frame, regnum); 867 int reg_len = type_length_units (value_type (regval)) - reg_offset; 868 869 /* If the register length is larger than the number of bytes 870 remaining to copy, then only copy the appropriate bytes. */ 871 if (reg_len > len) 872 reg_len = len; 873 874 value_contents_copy (value, offset, regval, reg_offset, reg_len); 875 876 offset += reg_len; 877 len -= reg_len; 878 reg_offset = 0; 879 regnum++; 880 } 881 } 882 883 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */ 884 885 struct value * 886 value_from_register (struct type *type, int regnum, struct frame_info *frame) 887 { 888 struct gdbarch *gdbarch = get_frame_arch (frame); 889 struct type *type1 = check_typedef (type); 890 struct value *v; 891 892 if (gdbarch_convert_register_p (gdbarch, regnum, type1)) 893 { 894 int optim, unavail, ok; 895 896 /* The ISA/ABI need to something weird when obtaining the 897 specified value from this register. It might need to 898 re-order non-adjacent, starting with REGNUM (see MIPS and 899 i386). It might need to convert the [float] register into 900 the corresponding [integer] type (see Alpha). The assumption 901 is that gdbarch_register_to_value populates the entire value 902 including the location. */ 903 v = allocate_value (type); 904 VALUE_LVAL (v) = lval_register; 905 VALUE_FRAME_ID (v) = get_frame_id (frame); 906 VALUE_REGNUM (v) = regnum; 907 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1, 908 value_contents_raw (v), &optim, 909 &unavail); 910 911 if (!ok) 912 { 913 if (optim) 914 mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type)); 915 if (unavail) 916 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type)); 917 } 918 } 919 else 920 { 921 /* Construct the value. */ 922 v = gdbarch_value_from_register (gdbarch, type, 923 regnum, get_frame_id (frame)); 924 925 /* Get the data. */ 926 read_frame_register_value (v, frame); 927 } 928 929 return v; 930 } 931 932 /* Return contents of register REGNUM in frame FRAME as address. 933 Will abort if register value is not available. */ 934 935 CORE_ADDR 936 address_from_register (int regnum, struct frame_info *frame) 937 { 938 struct gdbarch *gdbarch = get_frame_arch (frame); 939 struct type *type = builtin_type (gdbarch)->builtin_data_ptr; 940 struct value *value; 941 CORE_ADDR result; 942 int regnum_max_excl = (gdbarch_num_regs (gdbarch) 943 + gdbarch_num_pseudo_regs (gdbarch)); 944 945 if (regnum < 0 || regnum >= regnum_max_excl) 946 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum, 947 regnum_max_excl); 948 949 /* This routine may be called during early unwinding, at a time 950 where the ID of FRAME is not yet known. Calling value_from_register 951 would therefore abort in get_frame_id. However, since we only need 952 a temporary value that is never used as lvalue, we actually do not 953 really need to set its VALUE_FRAME_ID. Therefore, we re-implement 954 the core of value_from_register, but use the null_frame_id. */ 955 956 /* Some targets require a special conversion routine even for plain 957 pointer types. Avoid constructing a value object in those cases. */ 958 if (gdbarch_convert_register_p (gdbarch, regnum, type)) 959 { 960 gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type)); 961 int optim, unavail, ok; 962 963 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type, 964 buf, &optim, &unavail); 965 if (!ok) 966 { 967 /* This function is used while computing a location expression. 968 Complain about the value being optimized out, rather than 969 letting value_as_address complain about some random register 970 the expression depends on not being saved. */ 971 error_value_optimized_out (); 972 } 973 974 return unpack_long (type, buf); 975 } 976 977 value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id); 978 read_frame_register_value (value, frame); 979 980 if (value_optimized_out (value)) 981 { 982 /* This function is used while computing a location expression. 983 Complain about the value being optimized out, rather than 984 letting value_as_address complain about some random register 985 the expression depends on not being saved. */ 986 error_value_optimized_out (); 987 } 988 989 result = value_as_address (value); 990 release_value (value); 991 value_free (value); 992 993 return result; 994 } 995 996