1/* GDB routines for manipulating the minimal symbol tables. 2 Copyright (C) 1992-2023 Free Software Foundation, Inc. 3 Contributed by Cygnus Support, using pieces from other GDB modules. 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 21/* This file contains support routines for creating, manipulating, and 22 destroying minimal symbol tables. 23 24 Minimal symbol tables are used to hold some very basic information about 25 all defined global symbols (text, data, bss, abs, etc). The only two 26 required pieces of information are the symbol's name and the address 27 associated with that symbol. 28 29 In many cases, even if a file was compiled with no special options for 30 debugging at all, as long as was not stripped it will contain sufficient 31 information to build useful minimal symbol tables using this structure. 32 33 Even when a file contains enough debugging information to build a full 34 symbol table, these minimal symbols are still useful for quickly mapping 35 between names and addresses, and vice versa. They are also sometimes used 36 to figure out what full symbol table entries need to be read in. */ 37 38 39#include "defs.h" 40#include <ctype.h> 41#include "symtab.h" 42#include "bfd.h" 43#include "filenames.h" 44#include "symfile.h" 45#include "objfiles.h" 46#include "demangle.h" 47#include "value.h" 48#include "cp-abi.h" 49#include "target.h" 50#include "cp-support.h" 51#include "language.h" 52#include "cli/cli-utils.h" 53#include "gdbsupport/symbol.h" 54#include <algorithm> 55#include "safe-ctype.h" 56#include "gdbsupport/parallel-for.h" 57#include "inferior.h" 58 59#if CXX_STD_THREAD 60#include <mutex> 61#endif 62 63/* Return true if MINSYM is a cold clone symbol. 64 Recognize f.i. these symbols (mangled/demangled): 65 - _ZL3foov.cold 66 foo() [clone .cold] 67 - _ZL9do_rpo_vnP8functionP8edge_defP11bitmap_headbb.cold.138 68 do_rpo_vn(function*, edge_def*, bitmap_head*, bool, bool) \ 69 [clone .cold.138]. */ 70 71static bool 72msymbol_is_cold_clone (minimal_symbol *minsym) 73{ 74 const char *name = minsym->natural_name (); 75 size_t name_len = strlen (name); 76 if (name_len < 1) 77 return false; 78 79 const char *last = &name[name_len - 1]; 80 if (*last != ']') 81 return false; 82 83 const char *suffix = " [clone .cold"; 84 size_t suffix_len = strlen (suffix); 85 const char *found = strstr (name, suffix); 86 if (found == nullptr) 87 return false; 88 89 const char *start = &found[suffix_len]; 90 if (*start == ']') 91 return true; 92 93 if (*start != '.') 94 return false; 95 96 const char *p; 97 for (p = start + 1; p <= last; ++p) 98 { 99 if (*p >= '0' && *p <= '9') 100 continue; 101 break; 102 } 103 104 if (p == last) 105 return true; 106 107 return false; 108} 109 110/* See minsyms.h. */ 111 112bool 113msymbol_is_function (struct objfile *objfile, minimal_symbol *minsym, 114 CORE_ADDR *func_address_p) 115{ 116 CORE_ADDR msym_addr = minsym->value_address (objfile); 117 118 switch (minsym->type ()) 119 { 120 case mst_slot_got_plt: 121 case mst_data: 122 case mst_bss: 123 case mst_abs: 124 case mst_file_data: 125 case mst_file_bss: 126 case mst_data_gnu_ifunc: 127 { 128 struct gdbarch *gdbarch = objfile->arch (); 129 CORE_ADDR pc = gdbarch_convert_from_func_ptr_addr 130 (gdbarch, msym_addr, current_inferior ()->top_target ()); 131 if (pc != msym_addr) 132 { 133 if (func_address_p != NULL) 134 *func_address_p = pc; 135 return true; 136 } 137 return false; 138 } 139 case mst_file_text: 140 /* Ignore function symbol that is not a function entry. */ 141 if (msymbol_is_cold_clone (minsym)) 142 return false; 143 /* fallthru */ 144 default: 145 if (func_address_p != NULL) 146 *func_address_p = msym_addr; 147 return true; 148 } 149} 150 151/* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE. 152 At the end, copy them all into one newly allocated array. */ 153 154#define BUNCH_SIZE 127 155 156struct msym_bunch 157 { 158 struct msym_bunch *next; 159 struct minimal_symbol contents[BUNCH_SIZE]; 160 }; 161 162/* See minsyms.h. */ 163 164unsigned int 165msymbol_hash_iw (const char *string) 166{ 167 unsigned int hash = 0; 168 169 while (*string && *string != '(') 170 { 171 string = skip_spaces (string); 172 if (*string && *string != '(') 173 { 174 hash = SYMBOL_HASH_NEXT (hash, *string); 175 ++string; 176 } 177 } 178 return hash; 179} 180 181/* See minsyms.h. */ 182 183unsigned int 184msymbol_hash (const char *string) 185{ 186 unsigned int hash = 0; 187 188 for (; *string; ++string) 189 hash = SYMBOL_HASH_NEXT (hash, *string); 190 return hash; 191} 192 193/* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */ 194static void 195add_minsym_to_hash_table (struct minimal_symbol *sym, 196 struct minimal_symbol **table, 197 unsigned int hash_value) 198{ 199 if (sym->hash_next == NULL) 200 { 201 unsigned int hash = hash_value % MINIMAL_SYMBOL_HASH_SIZE; 202 203 sym->hash_next = table[hash]; 204 table[hash] = sym; 205 } 206} 207 208/* Add the minimal symbol SYM to an objfile's minsym demangled hash table, 209 TABLE. */ 210static void 211add_minsym_to_demangled_hash_table (struct minimal_symbol *sym, 212 struct objfile *objfile, 213 unsigned int hash_value) 214{ 215 if (sym->demangled_hash_next == NULL) 216 { 217 objfile->per_bfd->demangled_hash_languages.set (sym->language ()); 218 219 struct minimal_symbol **table 220 = objfile->per_bfd->msymbol_demangled_hash; 221 unsigned int hash_index = hash_value % MINIMAL_SYMBOL_HASH_SIZE; 222 sym->demangled_hash_next = table[hash_index]; 223 table[hash_index] = sym; 224 } 225} 226 227/* Worker object for lookup_minimal_symbol. Stores temporary results 228 while walking the symbol tables. */ 229 230struct found_minimal_symbols 231{ 232 /* External symbols are best. */ 233 bound_minimal_symbol external_symbol; 234 235 /* File-local symbols are next best. */ 236 bound_minimal_symbol file_symbol; 237 238 /* Symbols for shared library trampolines are next best. */ 239 bound_minimal_symbol trampoline_symbol; 240 241 /* Called when a symbol name matches. Check if the minsym is a 242 better type than what we had already found, and record it in one 243 of the members fields if so. Returns true if we collected the 244 real symbol, in which case we can stop searching. */ 245 bool maybe_collect (const char *sfile, objfile *objf, 246 minimal_symbol *msymbol); 247}; 248 249/* See declaration above. */ 250 251bool 252found_minimal_symbols::maybe_collect (const char *sfile, 253 struct objfile *objfile, 254 minimal_symbol *msymbol) 255{ 256 switch (msymbol->type ()) 257 { 258 case mst_file_text: 259 case mst_file_data: 260 case mst_file_bss: 261 if (sfile == NULL 262 || filename_cmp (msymbol->filename, sfile) == 0) 263 { 264 file_symbol.minsym = msymbol; 265 file_symbol.objfile = objfile; 266 } 267 break; 268 269 case mst_solib_trampoline: 270 271 /* If a trampoline symbol is found, we prefer to keep 272 looking for the *real* symbol. If the actual symbol 273 is not found, then we'll use the trampoline 274 entry. */ 275 if (trampoline_symbol.minsym == NULL) 276 { 277 trampoline_symbol.minsym = msymbol; 278 trampoline_symbol.objfile = objfile; 279 } 280 break; 281 282 case mst_unknown: 283 default: 284 external_symbol.minsym = msymbol; 285 external_symbol.objfile = objfile; 286 /* We have the real symbol. No use looking further. */ 287 return true; 288 } 289 290 /* Keep looking. */ 291 return false; 292} 293 294/* Walk the mangled name hash table, and pass each symbol whose name 295 matches LOOKUP_NAME according to NAMECMP to FOUND. */ 296 297static void 298lookup_minimal_symbol_mangled (const char *lookup_name, 299 const char *sfile, 300 struct objfile *objfile, 301 struct minimal_symbol **table, 302 unsigned int hash, 303 int (*namecmp) (const char *, const char *), 304 found_minimal_symbols &found) 305{ 306 for (minimal_symbol *msymbol = table[hash]; 307 msymbol != NULL; 308 msymbol = msymbol->hash_next) 309 { 310 const char *symbol_name = msymbol->linkage_name (); 311 312 if (namecmp (symbol_name, lookup_name) == 0 313 && found.maybe_collect (sfile, objfile, msymbol)) 314 return; 315 } 316} 317 318/* Walk the demangled name hash table, and pass each symbol whose name 319 matches LOOKUP_NAME according to MATCHER to FOUND. */ 320 321static void 322lookup_minimal_symbol_demangled (const lookup_name_info &lookup_name, 323 const char *sfile, 324 struct objfile *objfile, 325 struct minimal_symbol **table, 326 unsigned int hash, 327 symbol_name_matcher_ftype *matcher, 328 found_minimal_symbols &found) 329{ 330 for (minimal_symbol *msymbol = table[hash]; 331 msymbol != NULL; 332 msymbol = msymbol->demangled_hash_next) 333 { 334 const char *symbol_name = msymbol->search_name (); 335 336 if (matcher (symbol_name, lookup_name, NULL) 337 && found.maybe_collect (sfile, objfile, msymbol)) 338 return; 339 } 340} 341 342/* Look through all the current minimal symbol tables and find the 343 first minimal symbol that matches NAME. If OBJF is non-NULL, limit 344 the search to that objfile. If SFILE is non-NULL, the only file-scope 345 symbols considered will be from that source file (global symbols are 346 still preferred). Returns a pointer to the minimal symbol that 347 matches, or NULL if no match is found. 348 349 Note: One instance where there may be duplicate minimal symbols with 350 the same name is when the symbol tables for a shared library and the 351 symbol tables for an executable contain global symbols with the same 352 names (the dynamic linker deals with the duplication). 353 354 It's also possible to have minimal symbols with different mangled 355 names, but identical demangled names. For example, the GNU C++ v3 356 ABI requires the generation of two (or perhaps three) copies of 357 constructor functions --- "in-charge", "not-in-charge", and 358 "allocate" copies; destructors may be duplicated as well. 359 Obviously, there must be distinct mangled names for each of these, 360 but the demangled names are all the same: S::S or S::~S. */ 361 362struct bound_minimal_symbol 363lookup_minimal_symbol (const char *name, const char *sfile, 364 struct objfile *objf) 365{ 366 found_minimal_symbols found; 367 368 unsigned int mangled_hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 369 370 auto *mangled_cmp 371 = (case_sensitivity == case_sensitive_on 372 ? strcmp 373 : strcasecmp); 374 375 if (sfile != NULL) 376 sfile = lbasename (sfile); 377 378 lookup_name_info lookup_name (name, symbol_name_match_type::FULL); 379 380 for (objfile *objfile : current_program_space->objfiles ()) 381 { 382 if (found.external_symbol.minsym != NULL) 383 break; 384 385 if (objf == NULL || objf == objfile 386 || objf == objfile->separate_debug_objfile_backlink) 387 { 388 symbol_lookup_debug_printf ("lookup_minimal_symbol (%s, %s, %s)", 389 name, sfile != NULL ? sfile : "NULL", 390 objfile_debug_name (objfile)); 391 392 /* Do two passes: the first over the ordinary hash table, 393 and the second over the demangled hash table. */ 394 lookup_minimal_symbol_mangled (name, sfile, objfile, 395 objfile->per_bfd->msymbol_hash, 396 mangled_hash, mangled_cmp, found); 397 398 /* If not found, try the demangled hash table. */ 399 if (found.external_symbol.minsym == NULL) 400 { 401 /* Once for each language in the demangled hash names 402 table (usually just zero or one languages). */ 403 for (unsigned iter = 0; iter < nr_languages; ++iter) 404 { 405 if (!objfile->per_bfd->demangled_hash_languages.test (iter)) 406 continue; 407 enum language lang = (enum language) iter; 408 409 unsigned int hash 410 = (lookup_name.search_name_hash (lang) 411 % MINIMAL_SYMBOL_HASH_SIZE); 412 413 symbol_name_matcher_ftype *match 414 = language_def (lang)->get_symbol_name_matcher 415 (lookup_name); 416 struct minimal_symbol **msymbol_demangled_hash 417 = objfile->per_bfd->msymbol_demangled_hash; 418 419 lookup_minimal_symbol_demangled (lookup_name, sfile, objfile, 420 msymbol_demangled_hash, 421 hash, match, found); 422 423 if (found.external_symbol.minsym != NULL) 424 break; 425 } 426 } 427 } 428 } 429 430 /* External symbols are best. */ 431 if (found.external_symbol.minsym != NULL) 432 { 433 if (symbol_lookup_debug) 434 { 435 minimal_symbol *minsym = found.external_symbol.minsym; 436 437 symbol_lookup_debug_printf 438 ("lookup_minimal_symbol (...) = %s (external)", 439 host_address_to_string (minsym)); 440 } 441 return found.external_symbol; 442 } 443 444 /* File-local symbols are next best. */ 445 if (found.file_symbol.minsym != NULL) 446 { 447 if (symbol_lookup_debug) 448 { 449 minimal_symbol *minsym = found.file_symbol.minsym; 450 451 symbol_lookup_debug_printf 452 ("lookup_minimal_symbol (...) = %s (file-local)", 453 host_address_to_string (minsym)); 454 } 455 return found.file_symbol; 456 } 457 458 /* Symbols for shared library trampolines are next best. */ 459 if (found.trampoline_symbol.minsym != NULL) 460 { 461 if (symbol_lookup_debug) 462 { 463 minimal_symbol *minsym = found.trampoline_symbol.minsym; 464 465 symbol_lookup_debug_printf 466 ("lookup_minimal_symbol (...) = %s (trampoline)", 467 host_address_to_string (minsym)); 468 } 469 470 return found.trampoline_symbol; 471 } 472 473 /* Not found. */ 474 symbol_lookup_debug_printf ("lookup_minimal_symbol (...) = NULL"); 475 return {}; 476} 477 478/* See minsyms.h. */ 479 480struct bound_minimal_symbol 481lookup_bound_minimal_symbol (const char *name) 482{ 483 return lookup_minimal_symbol (name, NULL, NULL); 484} 485 486/* See gdbsupport/symbol.h. */ 487 488int 489find_minimal_symbol_address (const char *name, CORE_ADDR *addr, 490 struct objfile *objfile) 491{ 492 struct bound_minimal_symbol sym 493 = lookup_minimal_symbol (name, NULL, objfile); 494 495 if (sym.minsym != NULL) 496 *addr = sym.value_address (); 497 498 return sym.minsym == NULL; 499} 500 501/* Get the lookup name form best suitable for linkage name 502 matching. */ 503 504static const char * 505linkage_name_str (const lookup_name_info &lookup_name) 506{ 507 /* Unlike most languages (including C++), Ada uses the 508 encoded/linkage name as the search name recorded in symbols. So 509 if debugging in Ada mode, prefer the Ada-encoded name. This also 510 makes Ada's verbatim match syntax ("<...>") work, because 511 "lookup_name.name()" includes the "<>"s, while 512 "lookup_name.ada().lookup_name()" is the encoded name with "<>"s 513 stripped. */ 514 if (current_language->la_language == language_ada) 515 return lookup_name.ada ().lookup_name ().c_str (); 516 517 return lookup_name.c_str (); 518} 519 520/* See minsyms.h. */ 521 522void 523iterate_over_minimal_symbols 524 (struct objfile *objf, const lookup_name_info &lookup_name, 525 gdb::function_view<bool (struct minimal_symbol *)> callback) 526{ 527 /* The first pass is over the ordinary hash table. */ 528 { 529 const char *name = linkage_name_str (lookup_name); 530 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 531 auto *mangled_cmp 532 = (case_sensitivity == case_sensitive_on 533 ? strcmp 534 : strcasecmp); 535 536 for (minimal_symbol *iter = objf->per_bfd->msymbol_hash[hash]; 537 iter != NULL; 538 iter = iter->hash_next) 539 { 540 if (mangled_cmp (iter->linkage_name (), name) == 0) 541 if (callback (iter)) 542 return; 543 } 544 } 545 546 /* The second pass is over the demangled table. Once for each 547 language in the demangled hash names table (usually just zero or 548 one). */ 549 for (unsigned liter = 0; liter < nr_languages; ++liter) 550 { 551 if (!objf->per_bfd->demangled_hash_languages.test (liter)) 552 continue; 553 554 enum language lang = (enum language) liter; 555 const language_defn *lang_def = language_def (lang); 556 symbol_name_matcher_ftype *name_match 557 = lang_def->get_symbol_name_matcher (lookup_name); 558 559 unsigned int hash 560 = lookup_name.search_name_hash (lang) % MINIMAL_SYMBOL_HASH_SIZE; 561 for (minimal_symbol *iter = objf->per_bfd->msymbol_demangled_hash[hash]; 562 iter != NULL; 563 iter = iter->demangled_hash_next) 564 if (name_match (iter->search_name (), lookup_name, NULL)) 565 if (callback (iter)) 566 return; 567 } 568} 569 570/* See minsyms.h. */ 571 572bound_minimal_symbol 573lookup_minimal_symbol_linkage (const char *name, struct objfile *objf) 574{ 575 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 576 577 for (objfile *objfile : objf->separate_debug_objfiles ()) 578 { 579 for (minimal_symbol *msymbol = objfile->per_bfd->msymbol_hash[hash]; 580 msymbol != NULL; 581 msymbol = msymbol->hash_next) 582 { 583 if (strcmp (msymbol->linkage_name (), name) == 0 584 && (msymbol->type () == mst_data 585 || msymbol->type () == mst_bss)) 586 return {msymbol, objfile}; 587 } 588 } 589 590 return {}; 591} 592 593/* See minsyms.h. */ 594 595struct bound_minimal_symbol 596lookup_minimal_symbol_text (const char *name, struct objfile *objf) 597{ 598 struct minimal_symbol *msymbol; 599 struct bound_minimal_symbol found_symbol; 600 struct bound_minimal_symbol found_file_symbol; 601 602 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 603 604 for (objfile *objfile : current_program_space->objfiles ()) 605 { 606 if (found_symbol.minsym != NULL) 607 break; 608 609 if (objf == NULL || objf == objfile 610 || objf == objfile->separate_debug_objfile_backlink) 611 { 612 for (msymbol = objfile->per_bfd->msymbol_hash[hash]; 613 msymbol != NULL && found_symbol.minsym == NULL; 614 msymbol = msymbol->hash_next) 615 { 616 if (strcmp (msymbol->linkage_name (), name) == 0 && 617 (msymbol->type () == mst_text 618 || msymbol->type () == mst_text_gnu_ifunc 619 || msymbol->type () == mst_file_text)) 620 { 621 switch (msymbol->type ()) 622 { 623 case mst_file_text: 624 found_file_symbol.minsym = msymbol; 625 found_file_symbol.objfile = objfile; 626 break; 627 default: 628 found_symbol.minsym = msymbol; 629 found_symbol.objfile = objfile; 630 break; 631 } 632 } 633 } 634 } 635 } 636 /* External symbols are best. */ 637 if (found_symbol.minsym) 638 return found_symbol; 639 640 /* File-local symbols are next best. */ 641 return found_file_symbol; 642} 643 644/* See minsyms.h. */ 645 646struct minimal_symbol * 647lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name, 648 struct objfile *objf) 649{ 650 struct minimal_symbol *msymbol; 651 652 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 653 654 for (objfile *objfile : current_program_space->objfiles ()) 655 { 656 if (objf == NULL || objf == objfile 657 || objf == objfile->separate_debug_objfile_backlink) 658 { 659 for (msymbol = objfile->per_bfd->msymbol_hash[hash]; 660 msymbol != NULL; 661 msymbol = msymbol->hash_next) 662 { 663 if (msymbol->value_address (objfile) == pc 664 && strcmp (msymbol->linkage_name (), name) == 0) 665 return msymbol; 666 } 667 } 668 } 669 670 return NULL; 671} 672 673/* A helper function that makes *PC section-relative. This searches 674 the sections of OBJFILE and if *PC is in a section, it subtracts 675 the section offset and returns true. Otherwise it returns 676 false. */ 677 678static int 679frob_address (struct objfile *objfile, CORE_ADDR *pc) 680{ 681 struct obj_section *iter; 682 683 ALL_OBJFILE_OSECTIONS (objfile, iter) 684 { 685 if (*pc >= iter->addr () && *pc < iter->endaddr ()) 686 { 687 *pc -= iter->offset (); 688 return 1; 689 } 690 } 691 692 return 0; 693} 694 695/* Helper for lookup_minimal_symbol_by_pc_section. Convert a 696 lookup_msym_prefer to a minimal_symbol_type. */ 697 698static minimal_symbol_type 699msym_prefer_to_msym_type (lookup_msym_prefer prefer) 700{ 701 switch (prefer) 702 { 703 case lookup_msym_prefer::TEXT: 704 return mst_text; 705 case lookup_msym_prefer::TRAMPOLINE: 706 return mst_solib_trampoline; 707 case lookup_msym_prefer::GNU_IFUNC: 708 return mst_text_gnu_ifunc; 709 } 710 711 /* Assert here instead of in a default switch case above so that 712 -Wswitch warns if a new enumerator is added. */ 713 gdb_assert_not_reached ("unhandled lookup_msym_prefer"); 714} 715 716/* See minsyms.h. 717 718 Note that we need to look through ALL the minimal symbol tables 719 before deciding on the symbol that comes closest to the specified PC. 720 This is because objfiles can overlap, for example objfile A has .text 721 at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and 722 .data at 0x40048. */ 723 724bound_minimal_symbol 725lookup_minimal_symbol_by_pc_section (CORE_ADDR pc_in, struct obj_section *section, 726 lookup_msym_prefer prefer, 727 bound_minimal_symbol *previous) 728{ 729 int lo; 730 int hi; 731 int newobj; 732 struct minimal_symbol *msymbol; 733 struct minimal_symbol *best_symbol = NULL; 734 struct objfile *best_objfile = NULL; 735 struct bound_minimal_symbol result; 736 737 if (previous != nullptr) 738 { 739 previous->minsym = nullptr; 740 previous->objfile = nullptr; 741 } 742 743 if (section == NULL) 744 { 745 section = find_pc_section (pc_in); 746 if (section == NULL) 747 return {}; 748 } 749 750 minimal_symbol_type want_type = msym_prefer_to_msym_type (prefer); 751 752 /* We can not require the symbol found to be in section, because 753 e.g. IRIX 6.5 mdebug relies on this code returning an absolute 754 symbol - but find_pc_section won't return an absolute section and 755 hence the code below would skip over absolute symbols. We can 756 still take advantage of the call to find_pc_section, though - the 757 object file still must match. In case we have separate debug 758 files, search both the file and its separate debug file. There's 759 no telling which one will have the minimal symbols. */ 760 761 gdb_assert (section != NULL); 762 763 for (objfile *objfile : section->objfile->separate_debug_objfiles ()) 764 { 765 CORE_ADDR pc = pc_in; 766 767 /* If this objfile has a minimal symbol table, go search it 768 using a binary search. */ 769 770 if (objfile->per_bfd->minimal_symbol_count > 0) 771 { 772 int best_zero_sized = -1; 773 774 msymbol = objfile->per_bfd->msymbols.get (); 775 lo = 0; 776 hi = objfile->per_bfd->minimal_symbol_count - 1; 777 778 /* This code assumes that the minimal symbols are sorted by 779 ascending address values. If the pc value is greater than or 780 equal to the first symbol's address, then some symbol in this 781 minimal symbol table is a suitable candidate for being the 782 "best" symbol. This includes the last real symbol, for cases 783 where the pc value is larger than any address in this vector. 784 785 By iterating until the address associated with the current 786 hi index (the endpoint of the test interval) is less than 787 or equal to the desired pc value, we accomplish two things: 788 (1) the case where the pc value is larger than any minimal 789 symbol address is trivially solved, (2) the address associated 790 with the hi index is always the one we want when the iteration 791 terminates. In essence, we are iterating the test interval 792 down until the pc value is pushed out of it from the high end. 793 794 Warning: this code is trickier than it would appear at first. */ 795 796 if (frob_address (objfile, &pc) 797 && pc >= msymbol[lo].value_raw_address ()) 798 { 799 while (msymbol[hi].value_raw_address () > pc) 800 { 801 /* pc is still strictly less than highest address. */ 802 /* Note "new" will always be >= lo. */ 803 newobj = (lo + hi) / 2; 804 if ((msymbol[newobj].value_raw_address () >= pc) 805 || (lo == newobj)) 806 { 807 hi = newobj; 808 } 809 else 810 { 811 lo = newobj; 812 } 813 } 814 815 /* If we have multiple symbols at the same address, we want 816 hi to point to the last one. That way we can find the 817 right symbol if it has an index greater than hi. */ 818 while (hi < objfile->per_bfd->minimal_symbol_count - 1 819 && (msymbol[hi].value_raw_address () 820 == msymbol[hi + 1].value_raw_address ())) 821 hi++; 822 823 /* Skip various undesirable symbols. */ 824 while (hi >= 0) 825 { 826 /* Skip any absolute symbols. This is apparently 827 what adb and dbx do, and is needed for the CM-5. 828 There are two known possible problems: (1) on 829 ELF, apparently end, edata, etc. are absolute. 830 Not sure ignoring them here is a big deal, but if 831 we want to use them, the fix would go in 832 elfread.c. (2) I think shared library entry 833 points on the NeXT are absolute. If we want 834 special handling for this it probably should be 835 triggered by a special mst_abs_or_lib or some 836 such. */ 837 838 if (msymbol[hi].type () == mst_abs) 839 { 840 hi--; 841 continue; 842 } 843 844 /* If SECTION was specified, skip any symbol from 845 wrong section. */ 846 if (section 847 /* Some types of debug info, such as COFF, 848 don't fill the bfd_section member, so don't 849 throw away symbols on those platforms. */ 850 && msymbol[hi].obj_section (objfile) != nullptr 851 && (!matching_obj_sections 852 (msymbol[hi].obj_section (objfile), 853 section))) 854 { 855 hi--; 856 continue; 857 } 858 859 /* If we are looking for a trampoline and this is a 860 text symbol, or the other way around, check the 861 preceding symbol too. If they are otherwise 862 identical prefer that one. */ 863 if (hi > 0 864 && msymbol[hi].type () != want_type 865 && msymbol[hi - 1].type () == want_type 866 && (msymbol[hi].size () == msymbol[hi - 1].size ()) 867 && (msymbol[hi].value_raw_address () 868 == msymbol[hi - 1].value_raw_address ()) 869 && (msymbol[hi].obj_section (objfile) 870 == msymbol[hi - 1].obj_section (objfile))) 871 { 872 hi--; 873 continue; 874 } 875 876 /* If the minimal symbol has a zero size, save it 877 but keep scanning backwards looking for one with 878 a non-zero size. A zero size may mean that the 879 symbol isn't an object or function (e.g. a 880 label), or it may just mean that the size was not 881 specified. */ 882 if (msymbol[hi].size () == 0) 883 { 884 if (best_zero_sized == -1) 885 best_zero_sized = hi; 886 hi--; 887 continue; 888 } 889 890 /* If we are past the end of the current symbol, try 891 the previous symbol if it has a larger overlapping 892 size. This happens on i686-pc-linux-gnu with glibc; 893 the nocancel variants of system calls are inside 894 the cancellable variants, but both have sizes. */ 895 if (hi > 0 896 && msymbol[hi].size () != 0 897 && pc >= (msymbol[hi].value_raw_address () 898 + msymbol[hi].size ()) 899 && pc < (msymbol[hi - 1].value_raw_address () 900 + msymbol[hi - 1].size ())) 901 { 902 hi--; 903 continue; 904 } 905 906 /* Otherwise, this symbol must be as good as we're going 907 to get. */ 908 break; 909 } 910 911 /* If HI has a zero size, and best_zero_sized is set, 912 then we had two or more zero-sized symbols; prefer 913 the first one we found (which may have a higher 914 address). Also, if we ran off the end, be sure 915 to back up. */ 916 if (best_zero_sized != -1 917 && (hi < 0 || msymbol[hi].size () == 0)) 918 hi = best_zero_sized; 919 920 /* If the minimal symbol has a non-zero size, and this 921 PC appears to be outside the symbol's contents, then 922 refuse to use this symbol. If we found a zero-sized 923 symbol with an address greater than this symbol's, 924 use that instead. We assume that if symbols have 925 specified sizes, they do not overlap. */ 926 927 if (hi >= 0 928 && msymbol[hi].size () != 0 929 && pc >= (msymbol[hi].value_raw_address () 930 + msymbol[hi].size ())) 931 { 932 if (best_zero_sized != -1) 933 hi = best_zero_sized; 934 else 935 { 936 /* If needed record this symbol as the closest 937 previous symbol. */ 938 if (previous != nullptr) 939 { 940 if (previous->minsym == nullptr 941 || (msymbol[hi].value_raw_address () 942 > previous->minsym->value_raw_address ())) 943 { 944 previous->minsym = &msymbol[hi]; 945 previous->objfile = objfile; 946 } 947 } 948 /* Go on to the next object file. */ 949 continue; 950 } 951 } 952 953 /* The minimal symbol indexed by hi now is the best one in this 954 objfile's minimal symbol table. See if it is the best one 955 overall. */ 956 957 if (hi >= 0 958 && ((best_symbol == NULL) || 959 (best_symbol->value_raw_address () < 960 msymbol[hi].value_raw_address ()))) 961 { 962 best_symbol = &msymbol[hi]; 963 best_objfile = objfile; 964 } 965 } 966 } 967 } 968 969 result.minsym = best_symbol; 970 result.objfile = best_objfile; 971 return result; 972} 973 974/* See minsyms.h. */ 975 976struct bound_minimal_symbol 977lookup_minimal_symbol_by_pc (CORE_ADDR pc) 978{ 979 return lookup_minimal_symbol_by_pc_section (pc, NULL); 980} 981 982/* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver. */ 983 984bool 985in_gnu_ifunc_stub (CORE_ADDR pc) 986{ 987 bound_minimal_symbol msymbol 988 = lookup_minimal_symbol_by_pc_section (pc, NULL, 989 lookup_msym_prefer::GNU_IFUNC); 990 return msymbol.minsym && msymbol.minsym->type () == mst_text_gnu_ifunc; 991} 992 993/* See elf_gnu_ifunc_resolve_addr for its real implementation. */ 994 995static CORE_ADDR 996stub_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc) 997{ 998 error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without " 999 "the ELF support compiled in."), 1000 paddress (gdbarch, pc)); 1001} 1002 1003/* See elf_gnu_ifunc_resolve_name for its real implementation. */ 1004 1005static bool 1006stub_gnu_ifunc_resolve_name (const char *function_name, 1007 CORE_ADDR *function_address_p) 1008{ 1009 error (_("GDB cannot resolve STT_GNU_IFUNC symbol \"%s\" without " 1010 "the ELF support compiled in."), 1011 function_name); 1012} 1013 1014/* See elf_gnu_ifunc_resolver_stop for its real implementation. */ 1015 1016static void 1017stub_gnu_ifunc_resolver_stop (code_breakpoint *b) 1018{ 1019 internal_error (_("elf_gnu_ifunc_resolver_stop cannot be reached.")); 1020} 1021 1022/* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */ 1023 1024static void 1025stub_gnu_ifunc_resolver_return_stop (code_breakpoint *b) 1026{ 1027 internal_error (_("elf_gnu_ifunc_resolver_return_stop cannot be reached.")); 1028} 1029 1030/* See elf_gnu_ifunc_fns for its real implementation. */ 1031 1032static const struct gnu_ifunc_fns stub_gnu_ifunc_fns = 1033{ 1034 stub_gnu_ifunc_resolve_addr, 1035 stub_gnu_ifunc_resolve_name, 1036 stub_gnu_ifunc_resolver_stop, 1037 stub_gnu_ifunc_resolver_return_stop, 1038}; 1039 1040/* A placeholder for &elf_gnu_ifunc_fns. */ 1041 1042const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns; 1043 1044 1045 1046/* Return leading symbol character for a BFD. If BFD is NULL, 1047 return the leading symbol character from the main objfile. */ 1048 1049static int 1050get_symbol_leading_char (bfd *abfd) 1051{ 1052 if (abfd != NULL) 1053 return bfd_get_symbol_leading_char (abfd); 1054 if (current_program_space->symfile_object_file != NULL) 1055 { 1056 objfile *objf = current_program_space->symfile_object_file; 1057 if (objf->obfd != NULL) 1058 return bfd_get_symbol_leading_char (objf->obfd.get ()); 1059 } 1060 return 0; 1061} 1062 1063/* See minsyms.h. */ 1064 1065minimal_symbol_reader::minimal_symbol_reader (struct objfile *obj) 1066: m_objfile (obj), 1067 m_msym_bunch (NULL), 1068 /* Note that presetting m_msym_bunch_index to BUNCH_SIZE causes the 1069 first call to save a minimal symbol to allocate the memory for 1070 the first bunch. */ 1071 m_msym_bunch_index (BUNCH_SIZE), 1072 m_msym_count (0) 1073{ 1074} 1075 1076/* Discard the currently collected minimal symbols, if any. If we wish 1077 to save them for later use, we must have already copied them somewhere 1078 else before calling this function. */ 1079 1080minimal_symbol_reader::~minimal_symbol_reader () 1081{ 1082 struct msym_bunch *next; 1083 1084 while (m_msym_bunch != NULL) 1085 { 1086 next = m_msym_bunch->next; 1087 xfree (m_msym_bunch); 1088 m_msym_bunch = next; 1089 } 1090} 1091 1092/* See minsyms.h. */ 1093 1094void 1095minimal_symbol_reader::record (const char *name, CORE_ADDR address, 1096 enum minimal_symbol_type ms_type) 1097{ 1098 int section; 1099 1100 switch (ms_type) 1101 { 1102 case mst_text: 1103 case mst_text_gnu_ifunc: 1104 case mst_file_text: 1105 case mst_solib_trampoline: 1106 section = SECT_OFF_TEXT (m_objfile); 1107 break; 1108 case mst_data: 1109 case mst_data_gnu_ifunc: 1110 case mst_file_data: 1111 section = SECT_OFF_DATA (m_objfile); 1112 break; 1113 case mst_bss: 1114 case mst_file_bss: 1115 section = SECT_OFF_BSS (m_objfile); 1116 break; 1117 default: 1118 section = -1; 1119 } 1120 1121 record_with_info (name, address, ms_type, section); 1122} 1123 1124/* Convert an enumerator of type minimal_symbol_type to its string 1125 representation. */ 1126 1127static const char * 1128mst_str (minimal_symbol_type t) 1129{ 1130#define MST_TO_STR(x) case x: return #x; 1131 switch (t) 1132 { 1133 MST_TO_STR (mst_unknown); 1134 MST_TO_STR (mst_text); 1135 MST_TO_STR (mst_text_gnu_ifunc); 1136 MST_TO_STR (mst_slot_got_plt); 1137 MST_TO_STR (mst_data); 1138 MST_TO_STR (mst_bss); 1139 MST_TO_STR (mst_abs); 1140 MST_TO_STR (mst_solib_trampoline); 1141 MST_TO_STR (mst_file_text); 1142 MST_TO_STR (mst_file_data); 1143 MST_TO_STR (mst_file_bss); 1144 1145 default: 1146 return "mst_???"; 1147 } 1148#undef MST_TO_STR 1149} 1150 1151/* See minsyms.h. */ 1152 1153struct minimal_symbol * 1154minimal_symbol_reader::record_full (gdb::string_view name, 1155 bool copy_name, CORE_ADDR address, 1156 enum minimal_symbol_type ms_type, 1157 int section) 1158{ 1159 struct msym_bunch *newobj; 1160 struct minimal_symbol *msymbol; 1161 1162 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into 1163 the minimal symbols, because if there is also another symbol 1164 at the same address (e.g. the first function of the file), 1165 lookup_minimal_symbol_by_pc would have no way of getting the 1166 right one. */ 1167 if (ms_type == mst_file_text && name[0] == 'g' 1168 && (name == GCC_COMPILED_FLAG_SYMBOL 1169 || name == GCC2_COMPILED_FLAG_SYMBOL)) 1170 return (NULL); 1171 1172 /* It's safe to strip the leading char here once, since the name 1173 is also stored stripped in the minimal symbol table. */ 1174 if (name[0] == get_symbol_leading_char (m_objfile->obfd.get ())) 1175 name = name.substr (1); 1176 1177 if (ms_type == mst_file_text && startswith (name, "__gnu_compiled")) 1178 return (NULL); 1179 1180 symtab_create_debug_printf_v ("recording minsym: %-21s %18s %4d %.*s", 1181 mst_str (ms_type), hex_string (address), section, 1182 (int) name.size (), name.data ()); 1183 1184 if (m_msym_bunch_index == BUNCH_SIZE) 1185 { 1186 newobj = XCNEW (struct msym_bunch); 1187 m_msym_bunch_index = 0; 1188 newobj->next = m_msym_bunch; 1189 m_msym_bunch = newobj; 1190 } 1191 msymbol = &m_msym_bunch->contents[m_msym_bunch_index]; 1192 msymbol->set_language (language_auto, 1193 &m_objfile->per_bfd->storage_obstack); 1194 1195 if (copy_name) 1196 msymbol->m_name = obstack_strndup (&m_objfile->per_bfd->storage_obstack, 1197 name.data (), name.size ()); 1198 else 1199 msymbol->m_name = name.data (); 1200 1201 msymbol->set_value_address (address); 1202 msymbol->set_section_index (section); 1203 1204 msymbol->set_type (ms_type); 1205 1206 /* If we already read minimal symbols for this objfile, then don't 1207 ever allocate a new one. */ 1208 if (!m_objfile->per_bfd->minsyms_read) 1209 { 1210 m_msym_bunch_index++; 1211 m_objfile->per_bfd->n_minsyms++; 1212 } 1213 m_msym_count++; 1214 return msymbol; 1215} 1216 1217/* Compare two minimal symbols by address and return true if FN1's address 1218 is less than FN2's, so that we sort into unsigned numeric order. 1219 Within groups with the same address, sort by name. */ 1220 1221static inline bool 1222minimal_symbol_is_less_than (const minimal_symbol &fn1, 1223 const minimal_symbol &fn2) 1224{ 1225 if ((&fn1)->value_raw_address () < (&fn2)->value_raw_address ()) 1226 { 1227 return true; /* addr 1 is less than addr 2. */ 1228 } 1229 else if ((&fn1)->value_raw_address () > (&fn2)->value_raw_address ()) 1230 { 1231 return false; /* addr 1 is greater than addr 2. */ 1232 } 1233 else 1234 /* addrs are equal: sort by name */ 1235 { 1236 const char *name1 = fn1.linkage_name (); 1237 const char *name2 = fn2.linkage_name (); 1238 1239 if (name1 && name2) /* both have names */ 1240 return strcmp (name1, name2) < 0; 1241 else if (name2) 1242 return true; /* fn1 has no name, so it is "less". */ 1243 else if (name1) /* fn2 has no name, so it is "less". */ 1244 return false; 1245 else 1246 return false; /* Neither has a name, so they're equal. */ 1247 } 1248} 1249 1250/* Compact duplicate entries out of a minimal symbol table by walking 1251 through the table and compacting out entries with duplicate addresses 1252 and matching names. Return the number of entries remaining. 1253 1254 On entry, the table resides between msymbol[0] and msymbol[mcount]. 1255 On exit, it resides between msymbol[0] and msymbol[result_count]. 1256 1257 When files contain multiple sources of symbol information, it is 1258 possible for the minimal symbol table to contain many duplicate entries. 1259 As an example, SVR4 systems use ELF formatted object files, which 1260 usually contain at least two different types of symbol tables (a 1261 standard ELF one and a smaller dynamic linking table), as well as 1262 DWARF debugging information for files compiled with -g. 1263 1264 Without compacting, the minimal symbol table for gdb itself contains 1265 over a 1000 duplicates, about a third of the total table size. Aside 1266 from the potential trap of not noticing that two successive entries 1267 identify the same location, this duplication impacts the time required 1268 to linearly scan the table, which is done in a number of places. So we 1269 just do one linear scan here and toss out the duplicates. 1270 1271 Since the different sources of information for each symbol may 1272 have different levels of "completeness", we may have duplicates 1273 that have one entry with type "mst_unknown" and the other with a 1274 known type. So if the one we are leaving alone has type mst_unknown, 1275 overwrite its type with the type from the one we are compacting out. */ 1276 1277static int 1278compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount, 1279 struct objfile *objfile) 1280{ 1281 struct minimal_symbol *copyfrom; 1282 struct minimal_symbol *copyto; 1283 1284 if (mcount > 0) 1285 { 1286 copyfrom = copyto = msymbol; 1287 while (copyfrom < msymbol + mcount - 1) 1288 { 1289 if (copyfrom->value_raw_address () 1290 == (copyfrom + 1)->value_raw_address () 1291 && (copyfrom->section_index () 1292 == (copyfrom + 1)->section_index ()) 1293 && strcmp (copyfrom->linkage_name (), 1294 (copyfrom + 1)->linkage_name ()) == 0) 1295 { 1296 if ((copyfrom + 1)->type () == mst_unknown) 1297 (copyfrom + 1)->set_type (copyfrom->type ()); 1298 1299 copyfrom++; 1300 } 1301 else 1302 *copyto++ = *copyfrom++; 1303 } 1304 *copyto++ = *copyfrom++; 1305 mcount = copyto - msymbol; 1306 } 1307 return (mcount); 1308} 1309 1310static void 1311clear_minimal_symbol_hash_tables (struct objfile *objfile) 1312{ 1313 for (size_t i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++) 1314 { 1315 objfile->per_bfd->msymbol_hash[i] = 0; 1316 objfile->per_bfd->msymbol_demangled_hash[i] = 0; 1317 } 1318} 1319 1320/* This struct is used to store values we compute for msymbols on the 1321 background threads but don't need to keep around long term. */ 1322struct computed_hash_values 1323{ 1324 /* Length of the linkage_name of the symbol. */ 1325 size_t name_length; 1326 /* Hash code (using fast_hash) of the linkage_name. */ 1327 hashval_t mangled_name_hash; 1328 /* The msymbol_hash of the linkage_name. */ 1329 unsigned int minsym_hash; 1330 /* The msymbol_hash of the search_name. */ 1331 unsigned int minsym_demangled_hash; 1332}; 1333 1334/* Build (or rebuild) the minimal symbol hash tables. This is necessary 1335 after compacting or sorting the table since the entries move around 1336 thus causing the internal minimal_symbol pointers to become jumbled. */ 1337 1338static void 1339build_minimal_symbol_hash_tables 1340 (struct objfile *objfile, 1341 const std::vector<computed_hash_values>& hash_values) 1342{ 1343 int i; 1344 struct minimal_symbol *msym; 1345 1346 /* (Re)insert the actual entries. */ 1347 int mcount = objfile->per_bfd->minimal_symbol_count; 1348 for ((i = 0, 1349 msym = objfile->per_bfd->msymbols.get ()); 1350 i < mcount; 1351 i++, msym++) 1352 { 1353 msym->hash_next = 0; 1354 add_minsym_to_hash_table (msym, objfile->per_bfd->msymbol_hash, 1355 hash_values[i].minsym_hash); 1356 1357 msym->demangled_hash_next = 0; 1358 if (msym->search_name () != msym->linkage_name ()) 1359 add_minsym_to_demangled_hash_table 1360 (msym, objfile, hash_values[i].minsym_demangled_hash); 1361 } 1362} 1363 1364/* Add the minimal symbols in the existing bunches to the objfile's official 1365 minimal symbol table. In most cases there is no minimal symbol table yet 1366 for this objfile, and the existing bunches are used to create one. Once 1367 in a while (for shared libraries for example), we add symbols (e.g. common 1368 symbols) to an existing objfile. */ 1369 1370void 1371minimal_symbol_reader::install () 1372{ 1373 int mcount; 1374 struct msym_bunch *bunch; 1375 struct minimal_symbol *msymbols; 1376 int alloc_count; 1377 1378 if (m_objfile->per_bfd->minsyms_read) 1379 return; 1380 1381 if (m_msym_count > 0) 1382 { 1383 symtab_create_debug_printf ("installing %d minimal symbols of objfile %s", 1384 m_msym_count, objfile_name (m_objfile)); 1385 1386 /* Allocate enough space, into which we will gather the bunches 1387 of new and existing minimal symbols, sort them, and then 1388 compact out the duplicate entries. Once we have a final 1389 table, we will give back the excess space. */ 1390 1391 alloc_count = m_msym_count + m_objfile->per_bfd->minimal_symbol_count; 1392 gdb::unique_xmalloc_ptr<minimal_symbol> 1393 msym_holder (XNEWVEC (minimal_symbol, alloc_count)); 1394 msymbols = msym_holder.get (); 1395 1396 /* Copy in the existing minimal symbols, if there are any. */ 1397 1398 if (m_objfile->per_bfd->minimal_symbol_count) 1399 memcpy (msymbols, m_objfile->per_bfd->msymbols.get (), 1400 m_objfile->per_bfd->minimal_symbol_count 1401 * sizeof (struct minimal_symbol)); 1402 1403 /* Walk through the list of minimal symbol bunches, adding each symbol 1404 to the new contiguous array of symbols. Note that we start with the 1405 current, possibly partially filled bunch (thus we use the current 1406 msym_bunch_index for the first bunch we copy over), and thereafter 1407 each bunch is full. */ 1408 1409 mcount = m_objfile->per_bfd->minimal_symbol_count; 1410 1411 for (bunch = m_msym_bunch; bunch != NULL; bunch = bunch->next) 1412 { 1413 memcpy (&msymbols[mcount], &bunch->contents[0], 1414 m_msym_bunch_index * sizeof (struct minimal_symbol)); 1415 mcount += m_msym_bunch_index; 1416 m_msym_bunch_index = BUNCH_SIZE; 1417 } 1418 1419 /* Sort the minimal symbols by address. */ 1420 1421 std::sort (msymbols, msymbols + mcount, minimal_symbol_is_less_than); 1422 1423 /* Compact out any duplicates, and free up whatever space we are 1424 no longer using. */ 1425 1426 mcount = compact_minimal_symbols (msymbols, mcount, m_objfile); 1427 msym_holder.reset (XRESIZEVEC (struct minimal_symbol, 1428 msym_holder.release (), 1429 mcount)); 1430 1431 /* Attach the minimal symbol table to the specified objfile. 1432 The strings themselves are also located in the storage_obstack 1433 of this objfile. */ 1434 1435 if (m_objfile->per_bfd->minimal_symbol_count != 0) 1436 clear_minimal_symbol_hash_tables (m_objfile); 1437 1438 m_objfile->per_bfd->minimal_symbol_count = mcount; 1439 m_objfile->per_bfd->msymbols = std::move (msym_holder); 1440 1441#if CXX_STD_THREAD 1442 /* Mutex that is used when modifying or accessing the demangled 1443 hash table. */ 1444 std::mutex demangled_mutex; 1445#endif 1446 1447 std::vector<computed_hash_values> hash_values (mcount); 1448 1449 msymbols = m_objfile->per_bfd->msymbols.get (); 1450 /* Arbitrarily require at least 10 elements in a thread. */ 1451 gdb::parallel_for_each (10, &msymbols[0], &msymbols[mcount], 1452 [&] (minimal_symbol *start, minimal_symbol *end) 1453 { 1454 for (minimal_symbol *msym = start; msym < end; ++msym) 1455 { 1456 size_t idx = msym - msymbols; 1457 hash_values[idx].name_length = strlen (msym->linkage_name ()); 1458 if (!msym->name_set) 1459 { 1460 /* This will be freed later, by compute_and_set_names. */ 1461 gdb::unique_xmalloc_ptr<char> demangled_name 1462 = symbol_find_demangled_name (msym, msym->linkage_name ()); 1463 msym->set_demangled_name 1464 (demangled_name.release (), 1465 &m_objfile->per_bfd->storage_obstack); 1466 msym->name_set = 1; 1467 } 1468 /* This mangled_name_hash computation has to be outside of 1469 the name_set check, or compute_and_set_names below will 1470 be called with an invalid hash value. */ 1471 hash_values[idx].mangled_name_hash 1472 = fast_hash (msym->linkage_name (), 1473 hash_values[idx].name_length); 1474 hash_values[idx].minsym_hash 1475 = msymbol_hash (msym->linkage_name ()); 1476 /* We only use this hash code if the search name differs 1477 from the linkage name. See the code in 1478 build_minimal_symbol_hash_tables. */ 1479 if (msym->search_name () != msym->linkage_name ()) 1480 hash_values[idx].minsym_demangled_hash 1481 = search_name_hash (msym->language (), msym->search_name ()); 1482 } 1483 { 1484 /* To limit how long we hold the lock, we only acquire it here 1485 and not while we demangle the names above. */ 1486#if CXX_STD_THREAD 1487 std::lock_guard<std::mutex> guard (demangled_mutex); 1488#endif 1489 for (minimal_symbol *msym = start; msym < end; ++msym) 1490 { 1491 size_t idx = msym - msymbols; 1492 msym->compute_and_set_names 1493 (gdb::string_view (msym->linkage_name (), 1494 hash_values[idx].name_length), 1495 false, 1496 m_objfile->per_bfd, 1497 hash_values[idx].mangled_name_hash); 1498 } 1499 } 1500 }); 1501 1502 build_minimal_symbol_hash_tables (m_objfile, hash_values); 1503 } 1504} 1505 1506/* Check if PC is in a shared library trampoline code stub. 1507 Return minimal symbol for the trampoline entry or NULL if PC is not 1508 in a trampoline code stub. */ 1509 1510static struct minimal_symbol * 1511lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc) 1512{ 1513 bound_minimal_symbol msymbol 1514 = lookup_minimal_symbol_by_pc_section (pc, NULL, 1515 lookup_msym_prefer::TRAMPOLINE); 1516 1517 if (msymbol.minsym != NULL 1518 && msymbol.minsym->type () == mst_solib_trampoline) 1519 return msymbol.minsym; 1520 return NULL; 1521} 1522 1523/* If PC is in a shared library trampoline code stub, return the 1524 address of the `real' function belonging to the stub. 1525 Return 0 if PC is not in a trampoline code stub or if the real 1526 function is not found in the minimal symbol table. 1527 1528 We may fail to find the right function if a function with the 1529 same name is defined in more than one shared library, but this 1530 is considered bad programming style. We could return 0 if we find 1531 a duplicate function in case this matters someday. */ 1532 1533CORE_ADDR 1534find_solib_trampoline_target (frame_info_ptr frame, CORE_ADDR pc) 1535{ 1536 struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc); 1537 1538 if (tsymbol != NULL) 1539 { 1540 for (objfile *objfile : current_program_space->objfiles ()) 1541 { 1542 for (minimal_symbol *msymbol : objfile->msymbols ()) 1543 { 1544 /* Also handle minimal symbols pointing to function 1545 descriptors. */ 1546 if ((msymbol->type () == mst_text 1547 || msymbol->type () == mst_text_gnu_ifunc 1548 || msymbol->type () == mst_data 1549 || msymbol->type () == mst_data_gnu_ifunc) 1550 && strcmp (msymbol->linkage_name (), 1551 tsymbol->linkage_name ()) == 0) 1552 { 1553 CORE_ADDR func; 1554 1555 /* Ignore data symbols that are not function 1556 descriptors. */ 1557 if (msymbol_is_function (objfile, msymbol, &func)) 1558 return func; 1559 } 1560 } 1561 } 1562 } 1563 return 0; 1564} 1565 1566/* See minsyms.h. */ 1567 1568CORE_ADDR 1569minimal_symbol_upper_bound (struct bound_minimal_symbol minsym) 1570{ 1571 short section; 1572 struct obj_section *obj_section; 1573 CORE_ADDR result; 1574 struct minimal_symbol *iter, *msymbol; 1575 1576 gdb_assert (minsym.minsym != NULL); 1577 1578 /* If the minimal symbol has a size, use it. Otherwise use the 1579 lesser of the next minimal symbol in the same section, or the end 1580 of the section, as the end of the function. */ 1581 1582 if (minsym.minsym->size () != 0) 1583 return minsym.value_address () + minsym.minsym->size (); 1584 1585 /* Step over other symbols at this same address, and symbols in 1586 other sections, to find the next symbol in this section with a 1587 different address. */ 1588 1589 struct minimal_symbol *past_the_end 1590 = (minsym.objfile->per_bfd->msymbols.get () 1591 + minsym.objfile->per_bfd->minimal_symbol_count); 1592 msymbol = minsym.minsym; 1593 section = msymbol->section_index (); 1594 for (iter = msymbol + 1; iter != past_the_end; ++iter) 1595 { 1596 if ((iter->value_raw_address () 1597 != msymbol->value_raw_address ()) 1598 && iter->section_index () == section) 1599 break; 1600 } 1601 1602 obj_section = minsym.obj_section (); 1603 if (iter != past_the_end 1604 && (iter->value_address (minsym.objfile) 1605 < obj_section->endaddr ())) 1606 result = iter->value_address (minsym.objfile); 1607 else 1608 /* We got the start address from the last msymbol in the objfile. 1609 So the end address is the end of the section. */ 1610 result = obj_section->endaddr (); 1611 1612 return result; 1613} 1614