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