1 /* GDB routines for manipulating the minimal symbol tables. 2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 3 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 Contributed by Cygnus Support, using pieces from other GDB modules. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 23 /* This file contains support routines for creating, manipulating, and 24 destroying minimal symbol tables. 25 26 Minimal symbol tables are used to hold some very basic information about 27 all defined global symbols (text, data, bss, abs, etc). The only two 28 required pieces of information are the symbol's name and the address 29 associated with that symbol. 30 31 In many cases, even if a file was compiled with no special options for 32 debugging at all, as long as was not stripped it will contain sufficient 33 information to build useful minimal symbol tables using this structure. 34 35 Even when a file contains enough debugging information to build a full 36 symbol table, these minimal symbols are still useful for quickly mapping 37 between names and addresses, and vice versa. They are also sometimes used 38 to figure out what full symbol table entries need to be read in. */ 39 40 41 #include "defs.h" 42 #include <ctype.h> 43 #include "gdb_string.h" 44 #include "symtab.h" 45 #include "bfd.h" 46 #include "filenames.h" 47 #include "symfile.h" 48 #include "objfiles.h" 49 #include "demangle.h" 50 #include "value.h" 51 #include "cp-abi.h" 52 #include "target.h" 53 #include "cp-support.h" 54 #include "language.h" 55 56 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE. 57 At the end, copy them all into one newly allocated location on an objfile's 58 symbol obstack. */ 59 60 #define BUNCH_SIZE 127 61 62 struct msym_bunch 63 { 64 struct msym_bunch *next; 65 struct minimal_symbol contents[BUNCH_SIZE]; 66 }; 67 68 /* Bunch currently being filled up. 69 The next field points to chain of filled bunches. */ 70 71 static struct msym_bunch *msym_bunch; 72 73 /* Number of slots filled in current bunch. */ 74 75 static int msym_bunch_index; 76 77 /* Total number of minimal symbols recorded so far for the objfile. */ 78 79 static int msym_count; 80 81 /* Compute a hash code based using the same criteria as `strcmp_iw'. */ 82 83 unsigned int 84 msymbol_hash_iw (const char *string) 85 { 86 unsigned int hash = 0; 87 88 while (*string && *string != '(') 89 { 90 while (isspace (*string)) 91 ++string; 92 if (*string && *string != '(') 93 { 94 hash = hash * 67 + *string - 113; 95 ++string; 96 } 97 } 98 return hash; 99 } 100 101 /* Compute a hash code for a string. */ 102 103 unsigned int 104 msymbol_hash (const char *string) 105 { 106 unsigned int hash = 0; 107 108 for (; *string; ++string) 109 hash = hash * 67 + *string - 113; 110 return hash; 111 } 112 113 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */ 114 void 115 add_minsym_to_hash_table (struct minimal_symbol *sym, 116 struct minimal_symbol **table) 117 { 118 if (sym->hash_next == NULL) 119 { 120 unsigned int hash 121 = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE; 122 123 sym->hash_next = table[hash]; 124 table[hash] = sym; 125 } 126 } 127 128 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table, 129 TABLE. */ 130 static void 131 add_minsym_to_demangled_hash_table (struct minimal_symbol *sym, 132 struct minimal_symbol **table) 133 { 134 if (sym->demangled_hash_next == NULL) 135 { 136 unsigned int hash = msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym)) 137 % MINIMAL_SYMBOL_HASH_SIZE; 138 139 sym->demangled_hash_next = table[hash]; 140 table[hash] = sym; 141 } 142 } 143 144 145 /* Return OBJFILE where minimal symbol SYM is defined. */ 146 struct objfile * 147 msymbol_objfile (struct minimal_symbol *sym) 148 { 149 struct objfile *objf; 150 struct minimal_symbol *tsym; 151 152 unsigned int hash 153 = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE; 154 155 for (objf = object_files; objf; objf = objf->next) 156 for (tsym = objf->msymbol_hash[hash]; tsym; tsym = tsym->hash_next) 157 if (tsym == sym) 158 return objf; 159 160 /* We should always be able to find the objfile ... */ 161 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 162 } 163 164 165 /* Look through all the current minimal symbol tables and find the 166 first minimal symbol that matches NAME. If OBJF is non-NULL, limit 167 the search to that objfile. If SFILE is non-NULL, the only file-scope 168 symbols considered will be from that source file (global symbols are 169 still preferred). Returns a pointer to the minimal symbol that 170 matches, or NULL if no match is found. 171 172 Note: One instance where there may be duplicate minimal symbols with 173 the same name is when the symbol tables for a shared library and the 174 symbol tables for an executable contain global symbols with the same 175 names (the dynamic linker deals with the duplication). 176 177 It's also possible to have minimal symbols with different mangled 178 names, but identical demangled names. For example, the GNU C++ v3 179 ABI requires the generation of two (or perhaps three) copies of 180 constructor functions --- "in-charge", "not-in-charge", and 181 "allocate" copies; destructors may be duplicated as well. 182 Obviously, there must be distinct mangled names for each of these, 183 but the demangled names are all the same: S::S or S::~S. */ 184 185 struct minimal_symbol * 186 lookup_minimal_symbol (const char *name, const char *sfile, 187 struct objfile *objf) 188 { 189 struct objfile *objfile; 190 struct minimal_symbol *msymbol; 191 struct minimal_symbol *found_symbol = NULL; 192 struct minimal_symbol *found_file_symbol = NULL; 193 struct minimal_symbol *trampoline_symbol = NULL; 194 195 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 196 unsigned int dem_hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE; 197 198 int needtofreename = 0; 199 const char *modified_name; 200 201 if (sfile != NULL) 202 sfile = lbasename (sfile); 203 204 /* For C++, canonicalize the input name. */ 205 modified_name = name; 206 if (current_language->la_language == language_cplus) 207 { 208 char *cname = cp_canonicalize_string (name); 209 210 if (cname) 211 { 212 modified_name = cname; 213 needtofreename = 1; 214 } 215 } 216 217 for (objfile = object_files; 218 objfile != NULL && found_symbol == NULL; 219 objfile = objfile->next) 220 { 221 if (objf == NULL || objf == objfile 222 || objf == objfile->separate_debug_objfile_backlink) 223 { 224 /* Do two passes: the first over the ordinary hash table, 225 and the second over the demangled hash table. */ 226 int pass; 227 228 for (pass = 1; pass <= 2 && found_symbol == NULL; pass++) 229 { 230 /* Select hash list according to pass. */ 231 if (pass == 1) 232 msymbol = objfile->msymbol_hash[hash]; 233 else 234 msymbol = objfile->msymbol_demangled_hash[dem_hash]; 235 236 while (msymbol != NULL && found_symbol == NULL) 237 { 238 int match; 239 240 if (pass == 1) 241 { 242 match = strcmp (SYMBOL_LINKAGE_NAME (msymbol), 243 modified_name) == 0; 244 } 245 else 246 { 247 match = SYMBOL_MATCHES_SEARCH_NAME (msymbol, 248 modified_name); 249 } 250 251 if (match) 252 { 253 switch (MSYMBOL_TYPE (msymbol)) 254 { 255 case mst_file_text: 256 case mst_file_data: 257 case mst_file_bss: 258 if (sfile == NULL 259 || filename_cmp (msymbol->filename, sfile) == 0) 260 found_file_symbol = msymbol; 261 break; 262 263 case mst_solib_trampoline: 264 265 /* If a trampoline symbol is found, we prefer to 266 keep looking for the *real* symbol. If the 267 actual symbol is not found, then we'll use the 268 trampoline entry. */ 269 if (trampoline_symbol == NULL) 270 trampoline_symbol = msymbol; 271 break; 272 273 case mst_unknown: 274 default: 275 found_symbol = msymbol; 276 break; 277 } 278 } 279 280 /* Find the next symbol on the hash chain. */ 281 if (pass == 1) 282 msymbol = msymbol->hash_next; 283 else 284 msymbol = msymbol->demangled_hash_next; 285 } 286 } 287 } 288 } 289 290 if (needtofreename) 291 xfree ((void *) modified_name); 292 293 /* External symbols are best. */ 294 if (found_symbol) 295 return found_symbol; 296 297 /* File-local symbols are next best. */ 298 if (found_file_symbol) 299 return found_file_symbol; 300 301 /* Symbols for shared library trampolines are next best. */ 302 if (trampoline_symbol) 303 return trampoline_symbol; 304 305 return NULL; 306 } 307 308 /* Look through all the current minimal symbol tables and find the 309 first minimal symbol that matches NAME and has text type. If OBJF 310 is non-NULL, limit the search to that objfile. Returns a pointer 311 to the minimal symbol that matches, or NULL if no match is found. 312 313 This function only searches the mangled (linkage) names. */ 314 315 struct minimal_symbol * 316 lookup_minimal_symbol_text (const char *name, struct objfile *objf) 317 { 318 struct objfile *objfile; 319 struct minimal_symbol *msymbol; 320 struct minimal_symbol *found_symbol = NULL; 321 struct minimal_symbol *found_file_symbol = NULL; 322 323 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 324 325 for (objfile = object_files; 326 objfile != NULL && found_symbol == NULL; 327 objfile = objfile->next) 328 { 329 if (objf == NULL || objf == objfile 330 || objf == objfile->separate_debug_objfile_backlink) 331 { 332 for (msymbol = objfile->msymbol_hash[hash]; 333 msymbol != NULL && found_symbol == NULL; 334 msymbol = msymbol->hash_next) 335 { 336 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 && 337 (MSYMBOL_TYPE (msymbol) == mst_text 338 || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc 339 || MSYMBOL_TYPE (msymbol) == mst_file_text)) 340 { 341 switch (MSYMBOL_TYPE (msymbol)) 342 { 343 case mst_file_text: 344 found_file_symbol = msymbol; 345 break; 346 default: 347 found_symbol = msymbol; 348 break; 349 } 350 } 351 } 352 } 353 } 354 /* External symbols are best. */ 355 if (found_symbol) 356 return found_symbol; 357 358 /* File-local symbols are next best. */ 359 if (found_file_symbol) 360 return found_file_symbol; 361 362 return NULL; 363 } 364 365 /* Look through all the current minimal symbol tables and find the 366 first minimal symbol that matches NAME and PC. If OBJF is non-NULL, 367 limit the search to that objfile. Returns a pointer to the minimal 368 symbol that matches, or NULL if no match is found. */ 369 370 struct minimal_symbol * 371 lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name, 372 struct objfile *objf) 373 { 374 struct objfile *objfile; 375 struct minimal_symbol *msymbol; 376 377 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 378 379 for (objfile = object_files; 380 objfile != NULL; 381 objfile = objfile->next) 382 { 383 if (objf == NULL || objf == objfile 384 || objf == objfile->separate_debug_objfile_backlink) 385 { 386 for (msymbol = objfile->msymbol_hash[hash]; 387 msymbol != NULL; 388 msymbol = msymbol->hash_next) 389 { 390 if (SYMBOL_VALUE_ADDRESS (msymbol) == pc 391 && strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0) 392 return msymbol; 393 } 394 } 395 } 396 397 return NULL; 398 } 399 400 /* Look through all the current minimal symbol tables and find the 401 first minimal symbol that matches NAME and is a solib trampoline. 402 If OBJF is non-NULL, limit the search to that objfile. Returns a 403 pointer to the minimal symbol that matches, or NULL if no match is 404 found. 405 406 This function only searches the mangled (linkage) names. */ 407 408 struct minimal_symbol * 409 lookup_minimal_symbol_solib_trampoline (const char *name, 410 struct objfile *objf) 411 { 412 struct objfile *objfile; 413 struct minimal_symbol *msymbol; 414 struct minimal_symbol *found_symbol = NULL; 415 416 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 417 418 for (objfile = object_files; 419 objfile != NULL && found_symbol == NULL; 420 objfile = objfile->next) 421 { 422 if (objf == NULL || objf == objfile 423 || objf == objfile->separate_debug_objfile_backlink) 424 { 425 for (msymbol = objfile->msymbol_hash[hash]; 426 msymbol != NULL && found_symbol == NULL; 427 msymbol = msymbol->hash_next) 428 { 429 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 && 430 MSYMBOL_TYPE (msymbol) == mst_solib_trampoline) 431 return msymbol; 432 } 433 } 434 } 435 436 return NULL; 437 } 438 439 /* Search through the minimal symbol table for each objfile and find 440 the symbol whose address is the largest address that is still less 441 than or equal to PC, and matches SECTION (which is not NULL). 442 Returns a pointer to the minimal symbol if such a symbol is found, 443 or NULL if PC is not in a suitable range. 444 Note that we need to look through ALL the minimal symbol tables 445 before deciding on the symbol that comes closest to the specified PC. 446 This is because objfiles can overlap, for example objfile A has .text 447 at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and 448 .data at 0x40048. 449 450 If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when 451 there are text and trampoline symbols at the same address. 452 Otherwise prefer mst_text symbols. */ 453 454 static struct minimal_symbol * 455 lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc, 456 struct obj_section *section, 457 int want_trampoline) 458 { 459 int lo; 460 int hi; 461 int new; 462 struct objfile *objfile; 463 struct minimal_symbol *msymbol; 464 struct minimal_symbol *best_symbol = NULL; 465 enum minimal_symbol_type want_type, other_type; 466 467 want_type = want_trampoline ? mst_solib_trampoline : mst_text; 468 other_type = want_trampoline ? mst_text : mst_solib_trampoline; 469 470 /* We can not require the symbol found to be in section, because 471 e.g. IRIX 6.5 mdebug relies on this code returning an absolute 472 symbol - but find_pc_section won't return an absolute section and 473 hence the code below would skip over absolute symbols. We can 474 still take advantage of the call to find_pc_section, though - the 475 object file still must match. In case we have separate debug 476 files, search both the file and its separate debug file. There's 477 no telling which one will have the minimal symbols. */ 478 479 gdb_assert (section != NULL); 480 481 for (objfile = section->objfile; 482 objfile != NULL; 483 objfile = objfile_separate_debug_iterate (section->objfile, objfile)) 484 { 485 /* If this objfile has a minimal symbol table, go search it using 486 a binary search. Note that a minimal symbol table always consists 487 of at least two symbols, a "real" symbol and the terminating 488 "null symbol". If there are no real symbols, then there is no 489 minimal symbol table at all. */ 490 491 if (objfile->minimal_symbol_count > 0) 492 { 493 int best_zero_sized = -1; 494 495 msymbol = objfile->msymbols; 496 lo = 0; 497 hi = objfile->minimal_symbol_count - 1; 498 499 /* This code assumes that the minimal symbols are sorted by 500 ascending address values. If the pc value is greater than or 501 equal to the first symbol's address, then some symbol in this 502 minimal symbol table is a suitable candidate for being the 503 "best" symbol. This includes the last real symbol, for cases 504 where the pc value is larger than any address in this vector. 505 506 By iterating until the address associated with the current 507 hi index (the endpoint of the test interval) is less than 508 or equal to the desired pc value, we accomplish two things: 509 (1) the case where the pc value is larger than any minimal 510 symbol address is trivially solved, (2) the address associated 511 with the hi index is always the one we want when the interation 512 terminates. In essence, we are iterating the test interval 513 down until the pc value is pushed out of it from the high end. 514 515 Warning: this code is trickier than it would appear at first. */ 516 517 /* Should also require that pc is <= end of objfile. FIXME! */ 518 if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo])) 519 { 520 while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc) 521 { 522 /* pc is still strictly less than highest address. */ 523 /* Note "new" will always be >= lo. */ 524 new = (lo + hi) / 2; 525 if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) || 526 (lo == new)) 527 { 528 hi = new; 529 } 530 else 531 { 532 lo = new; 533 } 534 } 535 536 /* If we have multiple symbols at the same address, we want 537 hi to point to the last one. That way we can find the 538 right symbol if it has an index greater than hi. */ 539 while (hi < objfile->minimal_symbol_count - 1 540 && (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) 541 == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1]))) 542 hi++; 543 544 /* Skip various undesirable symbols. */ 545 while (hi >= 0) 546 { 547 /* Skip any absolute symbols. This is apparently 548 what adb and dbx do, and is needed for the CM-5. 549 There are two known possible problems: (1) on 550 ELF, apparently end, edata, etc. are absolute. 551 Not sure ignoring them here is a big deal, but if 552 we want to use them, the fix would go in 553 elfread.c. (2) I think shared library entry 554 points on the NeXT are absolute. If we want 555 special handling for this it probably should be 556 triggered by a special mst_abs_or_lib or some 557 such. */ 558 559 if (MSYMBOL_TYPE (&msymbol[hi]) == mst_abs) 560 { 561 hi--; 562 continue; 563 } 564 565 /* If SECTION was specified, skip any symbol from 566 wrong section. */ 567 if (section 568 /* Some types of debug info, such as COFF, 569 don't fill the bfd_section member, so don't 570 throw away symbols on those platforms. */ 571 && SYMBOL_OBJ_SECTION (&msymbol[hi]) != NULL 572 && (!matching_obj_sections 573 (SYMBOL_OBJ_SECTION (&msymbol[hi]), section))) 574 { 575 hi--; 576 continue; 577 } 578 579 /* If we are looking for a trampoline and this is a 580 text symbol, or the other way around, check the 581 preceeding symbol too. If they are otherwise 582 identical prefer that one. */ 583 if (hi > 0 584 && MSYMBOL_TYPE (&msymbol[hi]) == other_type 585 && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type 586 && (MSYMBOL_SIZE (&msymbol[hi]) 587 == MSYMBOL_SIZE (&msymbol[hi - 1])) 588 && (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) 589 == SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])) 590 && (SYMBOL_OBJ_SECTION (&msymbol[hi]) 591 == SYMBOL_OBJ_SECTION (&msymbol[hi - 1]))) 592 { 593 hi--; 594 continue; 595 } 596 597 /* If the minimal symbol has a zero size, save it 598 but keep scanning backwards looking for one with 599 a non-zero size. A zero size may mean that the 600 symbol isn't an object or function (e.g. a 601 label), or it may just mean that the size was not 602 specified. */ 603 if (MSYMBOL_SIZE (&msymbol[hi]) == 0 604 && best_zero_sized == -1) 605 { 606 best_zero_sized = hi; 607 hi--; 608 continue; 609 } 610 611 /* If we are past the end of the current symbol, try 612 the previous symbol if it has a larger overlapping 613 size. This happens on i686-pc-linux-gnu with glibc; 614 the nocancel variants of system calls are inside 615 the cancellable variants, but both have sizes. */ 616 if (hi > 0 617 && MSYMBOL_SIZE (&msymbol[hi]) != 0 618 && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) 619 + MSYMBOL_SIZE (&msymbol[hi])) 620 && pc < (SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]) 621 + MSYMBOL_SIZE (&msymbol[hi - 1]))) 622 { 623 hi--; 624 continue; 625 } 626 627 /* Otherwise, this symbol must be as good as we're going 628 to get. */ 629 break; 630 } 631 632 /* If HI has a zero size, and best_zero_sized is set, 633 then we had two or more zero-sized symbols; prefer 634 the first one we found (which may have a higher 635 address). Also, if we ran off the end, be sure 636 to back up. */ 637 if (best_zero_sized != -1 638 && (hi < 0 || MSYMBOL_SIZE (&msymbol[hi]) == 0)) 639 hi = best_zero_sized; 640 641 /* If the minimal symbol has a non-zero size, and this 642 PC appears to be outside the symbol's contents, then 643 refuse to use this symbol. If we found a zero-sized 644 symbol with an address greater than this symbol's, 645 use that instead. We assume that if symbols have 646 specified sizes, they do not overlap. */ 647 648 if (hi >= 0 649 && MSYMBOL_SIZE (&msymbol[hi]) != 0 650 && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) 651 + MSYMBOL_SIZE (&msymbol[hi]))) 652 { 653 if (best_zero_sized != -1) 654 hi = best_zero_sized; 655 else 656 /* Go on to the next object file. */ 657 continue; 658 } 659 660 /* The minimal symbol indexed by hi now is the best one in this 661 objfile's minimal symbol table. See if it is the best one 662 overall. */ 663 664 if (hi >= 0 665 && ((best_symbol == NULL) || 666 (SYMBOL_VALUE_ADDRESS (best_symbol) < 667 SYMBOL_VALUE_ADDRESS (&msymbol[hi])))) 668 { 669 best_symbol = &msymbol[hi]; 670 } 671 } 672 } 673 } 674 return (best_symbol); 675 } 676 677 struct minimal_symbol * 678 lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section) 679 { 680 if (section == NULL) 681 { 682 /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to 683 force the section but that (well unless you're doing overlay 684 debugging) always returns NULL making the call somewhat useless. */ 685 section = find_pc_section (pc); 686 if (section == NULL) 687 return NULL; 688 } 689 return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0); 690 } 691 692 /* Backward compatibility: search through the minimal symbol table 693 for a matching PC (no section given). */ 694 695 struct minimal_symbol * 696 lookup_minimal_symbol_by_pc (CORE_ADDR pc) 697 { 698 return lookup_minimal_symbol_by_pc_section (pc, NULL); 699 } 700 701 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver. */ 702 703 int 704 in_gnu_ifunc_stub (CORE_ADDR pc) 705 { 706 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc); 707 708 return msymbol && MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc; 709 } 710 711 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */ 712 713 static CORE_ADDR 714 stub_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc) 715 { 716 error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without " 717 "the ELF support compiled in."), 718 paddress (gdbarch, pc)); 719 } 720 721 /* See elf_gnu_ifunc_resolve_name for its real implementation. */ 722 723 static int 724 stub_gnu_ifunc_resolve_name (const char *function_name, 725 CORE_ADDR *function_address_p) 726 { 727 error (_("GDB cannot resolve STT_GNU_IFUNC symbol \"%s\" without " 728 "the ELF support compiled in."), 729 function_name); 730 } 731 732 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */ 733 734 static void 735 stub_gnu_ifunc_resolver_stop (struct breakpoint *b) 736 { 737 internal_error (__FILE__, __LINE__, 738 _("elf_gnu_ifunc_resolver_stop cannot be reached.")); 739 } 740 741 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */ 742 743 static void 744 stub_gnu_ifunc_resolver_return_stop (struct breakpoint *b) 745 { 746 internal_error (__FILE__, __LINE__, 747 _("elf_gnu_ifunc_resolver_return_stop cannot be reached.")); 748 } 749 750 /* See elf_gnu_ifunc_fns for its real implementation. */ 751 752 static const struct gnu_ifunc_fns stub_gnu_ifunc_fns = 753 { 754 stub_gnu_ifunc_resolve_addr, 755 stub_gnu_ifunc_resolve_name, 756 stub_gnu_ifunc_resolver_stop, 757 stub_gnu_ifunc_resolver_return_stop, 758 }; 759 760 /* A placeholder for &elf_gnu_ifunc_fns. */ 761 762 const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns; 763 764 /* Find the minimal symbol named NAME, and return both the minsym 765 struct and its objfile. This only checks the linkage name. Sets 766 *OBJFILE_P and returns the minimal symbol, if it is found. If it 767 is not found, returns NULL. */ 768 769 struct minimal_symbol * 770 lookup_minimal_symbol_and_objfile (const char *name, 771 struct objfile **objfile_p) 772 { 773 struct objfile *objfile; 774 unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE; 775 776 ALL_OBJFILES (objfile) 777 { 778 struct minimal_symbol *msym; 779 780 for (msym = objfile->msymbol_hash[hash]; 781 msym != NULL; 782 msym = msym->hash_next) 783 { 784 if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0) 785 { 786 *objfile_p = objfile; 787 return msym; 788 } 789 } 790 } 791 792 return 0; 793 } 794 795 796 /* Return leading symbol character for a BFD. If BFD is NULL, 797 return the leading symbol character from the main objfile. */ 798 799 static int get_symbol_leading_char (bfd *); 800 801 static int 802 get_symbol_leading_char (bfd *abfd) 803 { 804 if (abfd != NULL) 805 return bfd_get_symbol_leading_char (abfd); 806 if (symfile_objfile != NULL && symfile_objfile->obfd != NULL) 807 return bfd_get_symbol_leading_char (symfile_objfile->obfd); 808 return 0; 809 } 810 811 /* Prepare to start collecting minimal symbols. Note that presetting 812 msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal 813 symbol to allocate the memory for the first bunch. */ 814 815 void 816 init_minimal_symbol_collection (void) 817 { 818 msym_count = 0; 819 msym_bunch = NULL; 820 msym_bunch_index = BUNCH_SIZE; 821 } 822 823 void 824 prim_record_minimal_symbol (const char *name, CORE_ADDR address, 825 enum minimal_symbol_type ms_type, 826 struct objfile *objfile) 827 { 828 int section; 829 830 switch (ms_type) 831 { 832 case mst_text: 833 case mst_text_gnu_ifunc: 834 case mst_file_text: 835 case mst_solib_trampoline: 836 section = SECT_OFF_TEXT (objfile); 837 break; 838 case mst_data: 839 case mst_file_data: 840 section = SECT_OFF_DATA (objfile); 841 break; 842 case mst_bss: 843 case mst_file_bss: 844 section = SECT_OFF_BSS (objfile); 845 break; 846 default: 847 section = -1; 848 } 849 850 prim_record_minimal_symbol_and_info (name, address, ms_type, 851 section, NULL, objfile); 852 } 853 854 /* Record a minimal symbol in the msym bunches. Returns the symbol 855 newly created. */ 856 857 struct minimal_symbol * 858 prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name, 859 CORE_ADDR address, 860 enum minimal_symbol_type ms_type, 861 int section, 862 asection *bfd_section, 863 struct objfile *objfile) 864 { 865 struct obj_section *obj_section; 866 struct msym_bunch *new; 867 struct minimal_symbol *msymbol; 868 869 /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into 870 the minimal symbols, because if there is also another symbol 871 at the same address (e.g. the first function of the file), 872 lookup_minimal_symbol_by_pc would have no way of getting the 873 right one. */ 874 if (ms_type == mst_file_text && name[0] == 'g' 875 && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0 876 || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0)) 877 return (NULL); 878 879 /* It's safe to strip the leading char here once, since the name 880 is also stored stripped in the minimal symbol table. */ 881 if (name[0] == get_symbol_leading_char (objfile->obfd)) 882 { 883 ++name; 884 --name_len; 885 } 886 887 if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0) 888 return (NULL); 889 890 if (msym_bunch_index == BUNCH_SIZE) 891 { 892 new = XCALLOC (1, struct msym_bunch); 893 msym_bunch_index = 0; 894 new->next = msym_bunch; 895 msym_bunch = new; 896 } 897 msymbol = &msym_bunch->contents[msym_bunch_index]; 898 SYMBOL_SET_LANGUAGE (msymbol, language_auto); 899 SYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile); 900 901 SYMBOL_VALUE_ADDRESS (msymbol) = address; 902 SYMBOL_SECTION (msymbol) = section; 903 SYMBOL_OBJ_SECTION (msymbol) = NULL; 904 905 /* Find obj_section corresponding to bfd_section. */ 906 if (bfd_section) 907 ALL_OBJFILE_OSECTIONS (objfile, obj_section) 908 { 909 if (obj_section->the_bfd_section == bfd_section) 910 { 911 SYMBOL_OBJ_SECTION (msymbol) = obj_section; 912 break; 913 } 914 } 915 916 MSYMBOL_TYPE (msymbol) = ms_type; 917 MSYMBOL_TARGET_FLAG_1 (msymbol) = 0; 918 MSYMBOL_TARGET_FLAG_2 (msymbol) = 0; 919 MSYMBOL_SIZE (msymbol) = 0; 920 921 /* The hash pointers must be cleared! If they're not, 922 add_minsym_to_hash_table will NOT add this msymbol to the hash table. */ 923 msymbol->hash_next = NULL; 924 msymbol->demangled_hash_next = NULL; 925 926 msym_bunch_index++; 927 msym_count++; 928 OBJSTAT (objfile, n_minsyms++); 929 return msymbol; 930 } 931 932 /* Record a minimal symbol in the msym bunches. Returns the symbol 933 newly created. */ 934 935 struct minimal_symbol * 936 prim_record_minimal_symbol_and_info (const char *name, CORE_ADDR address, 937 enum minimal_symbol_type ms_type, 938 int section, 939 asection *bfd_section, 940 struct objfile *objfile) 941 { 942 return prim_record_minimal_symbol_full (name, strlen (name), 1, 943 address, ms_type, section, 944 bfd_section, objfile); 945 } 946 947 /* Compare two minimal symbols by address and return a signed result based 948 on unsigned comparisons, so that we sort into unsigned numeric order. 949 Within groups with the same address, sort by name. */ 950 951 static int 952 compare_minimal_symbols (const void *fn1p, const void *fn2p) 953 { 954 const struct minimal_symbol *fn1; 955 const struct minimal_symbol *fn2; 956 957 fn1 = (const struct minimal_symbol *) fn1p; 958 fn2 = (const struct minimal_symbol *) fn2p; 959 960 if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2)) 961 { 962 return (-1); /* addr 1 is less than addr 2. */ 963 } 964 else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2)) 965 { 966 return (1); /* addr 1 is greater than addr 2. */ 967 } 968 else 969 /* addrs are equal: sort by name */ 970 { 971 char *name1 = SYMBOL_LINKAGE_NAME (fn1); 972 char *name2 = SYMBOL_LINKAGE_NAME (fn2); 973 974 if (name1 && name2) /* both have names */ 975 return strcmp (name1, name2); 976 else if (name2) 977 return 1; /* fn1 has no name, so it is "less". */ 978 else if (name1) /* fn2 has no name, so it is "less". */ 979 return -1; 980 else 981 return (0); /* Neither has a name, so they're equal. */ 982 } 983 } 984 985 /* Discard the currently collected minimal symbols, if any. If we wish 986 to save them for later use, we must have already copied them somewhere 987 else before calling this function. 988 989 FIXME: We could allocate the minimal symbol bunches on their own 990 obstack and then simply blow the obstack away when we are done with 991 it. Is it worth the extra trouble though? */ 992 993 static void 994 do_discard_minimal_symbols_cleanup (void *arg) 995 { 996 struct msym_bunch *next; 997 998 while (msym_bunch != NULL) 999 { 1000 next = msym_bunch->next; 1001 xfree (msym_bunch); 1002 msym_bunch = next; 1003 } 1004 } 1005 1006 struct cleanup * 1007 make_cleanup_discard_minimal_symbols (void) 1008 { 1009 return make_cleanup (do_discard_minimal_symbols_cleanup, 0); 1010 } 1011 1012 1013 1014 /* Compact duplicate entries out of a minimal symbol table by walking 1015 through the table and compacting out entries with duplicate addresses 1016 and matching names. Return the number of entries remaining. 1017 1018 On entry, the table resides between msymbol[0] and msymbol[mcount]. 1019 On exit, it resides between msymbol[0] and msymbol[result_count]. 1020 1021 When files contain multiple sources of symbol information, it is 1022 possible for the minimal symbol table to contain many duplicate entries. 1023 As an example, SVR4 systems use ELF formatted object files, which 1024 usually contain at least two different types of symbol tables (a 1025 standard ELF one and a smaller dynamic linking table), as well as 1026 DWARF debugging information for files compiled with -g. 1027 1028 Without compacting, the minimal symbol table for gdb itself contains 1029 over a 1000 duplicates, about a third of the total table size. Aside 1030 from the potential trap of not noticing that two successive entries 1031 identify the same location, this duplication impacts the time required 1032 to linearly scan the table, which is done in a number of places. So we 1033 just do one linear scan here and toss out the duplicates. 1034 1035 Note that we are not concerned here about recovering the space that 1036 is potentially freed up, because the strings themselves are allocated 1037 on the objfile_obstack, and will get automatically freed when the symbol 1038 table is freed. The caller can free up the unused minimal symbols at 1039 the end of the compacted region if their allocation strategy allows it. 1040 1041 Also note we only go up to the next to last entry within the loop 1042 and then copy the last entry explicitly after the loop terminates. 1043 1044 Since the different sources of information for each symbol may 1045 have different levels of "completeness", we may have duplicates 1046 that have one entry with type "mst_unknown" and the other with a 1047 known type. So if the one we are leaving alone has type mst_unknown, 1048 overwrite its type with the type from the one we are compacting out. */ 1049 1050 static int 1051 compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount, 1052 struct objfile *objfile) 1053 { 1054 struct minimal_symbol *copyfrom; 1055 struct minimal_symbol *copyto; 1056 1057 if (mcount > 0) 1058 { 1059 copyfrom = copyto = msymbol; 1060 while (copyfrom < msymbol + mcount - 1) 1061 { 1062 if (SYMBOL_VALUE_ADDRESS (copyfrom) 1063 == SYMBOL_VALUE_ADDRESS ((copyfrom + 1)) 1064 && strcmp (SYMBOL_LINKAGE_NAME (copyfrom), 1065 SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0) 1066 { 1067 if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown) 1068 { 1069 MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom); 1070 } 1071 copyfrom++; 1072 } 1073 else 1074 *copyto++ = *copyfrom++; 1075 } 1076 *copyto++ = *copyfrom++; 1077 mcount = copyto - msymbol; 1078 } 1079 return (mcount); 1080 } 1081 1082 /* Build (or rebuild) the minimal symbol hash tables. This is necessary 1083 after compacting or sorting the table since the entries move around 1084 thus causing the internal minimal_symbol pointers to become jumbled. */ 1085 1086 static void 1087 build_minimal_symbol_hash_tables (struct objfile *objfile) 1088 { 1089 int i; 1090 struct minimal_symbol *msym; 1091 1092 /* Clear the hash tables. */ 1093 for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++) 1094 { 1095 objfile->msymbol_hash[i] = 0; 1096 objfile->msymbol_demangled_hash[i] = 0; 1097 } 1098 1099 /* Now, (re)insert the actual entries. */ 1100 for (i = objfile->minimal_symbol_count, msym = objfile->msymbols; 1101 i > 0; 1102 i--, msym++) 1103 { 1104 msym->hash_next = 0; 1105 add_minsym_to_hash_table (msym, objfile->msymbol_hash); 1106 1107 msym->demangled_hash_next = 0; 1108 if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym)) 1109 add_minsym_to_demangled_hash_table (msym, 1110 objfile->msymbol_demangled_hash); 1111 } 1112 } 1113 1114 /* Add the minimal symbols in the existing bunches to the objfile's official 1115 minimal symbol table. In most cases there is no minimal symbol table yet 1116 for this objfile, and the existing bunches are used to create one. Once 1117 in a while (for shared libraries for example), we add symbols (e.g. common 1118 symbols) to an existing objfile. 1119 1120 Because of the way minimal symbols are collected, we generally have no way 1121 of knowing what source language applies to any particular minimal symbol. 1122 Specifically, we have no way of knowing if the minimal symbol comes from a 1123 C++ compilation unit or not. So for the sake of supporting cached 1124 demangled C++ names, we have no choice but to try and demangle each new one 1125 that comes in. If the demangling succeeds, then we assume it is a C++ 1126 symbol and set the symbol's language and demangled name fields 1127 appropriately. Note that in order to avoid unnecessary demanglings, and 1128 allocating obstack space that subsequently can't be freed for the demangled 1129 names, we mark all newly added symbols with language_auto. After 1130 compaction of the minimal symbols, we go back and scan the entire minimal 1131 symbol table looking for these new symbols. For each new symbol we attempt 1132 to demangle it, and if successful, record it as a language_cplus symbol 1133 and cache the demangled form on the symbol obstack. Symbols which don't 1134 demangle are marked as language_unknown symbols, which inhibits future 1135 attempts to demangle them if we later add more minimal symbols. */ 1136 1137 void 1138 install_minimal_symbols (struct objfile *objfile) 1139 { 1140 int bindex; 1141 int mcount; 1142 struct msym_bunch *bunch; 1143 struct minimal_symbol *msymbols; 1144 int alloc_count; 1145 1146 if (msym_count > 0) 1147 { 1148 /* Allocate enough space in the obstack, into which we will gather the 1149 bunches of new and existing minimal symbols, sort them, and then 1150 compact out the duplicate entries. Once we have a final table, 1151 we will give back the excess space. */ 1152 1153 alloc_count = msym_count + objfile->minimal_symbol_count + 1; 1154 obstack_blank (&objfile->objfile_obstack, 1155 alloc_count * sizeof (struct minimal_symbol)); 1156 msymbols = (struct minimal_symbol *) 1157 obstack_base (&objfile->objfile_obstack); 1158 1159 /* Copy in the existing minimal symbols, if there are any. */ 1160 1161 if (objfile->minimal_symbol_count) 1162 memcpy ((char *) msymbols, (char *) objfile->msymbols, 1163 objfile->minimal_symbol_count * sizeof (struct minimal_symbol)); 1164 1165 /* Walk through the list of minimal symbol bunches, adding each symbol 1166 to the new contiguous array of symbols. Note that we start with the 1167 current, possibly partially filled bunch (thus we use the current 1168 msym_bunch_index for the first bunch we copy over), and thereafter 1169 each bunch is full. */ 1170 1171 mcount = objfile->minimal_symbol_count; 1172 1173 for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next) 1174 { 1175 for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++) 1176 msymbols[mcount] = bunch->contents[bindex]; 1177 msym_bunch_index = BUNCH_SIZE; 1178 } 1179 1180 /* Sort the minimal symbols by address. */ 1181 1182 qsort (msymbols, mcount, sizeof (struct minimal_symbol), 1183 compare_minimal_symbols); 1184 1185 /* Compact out any duplicates, and free up whatever space we are 1186 no longer using. */ 1187 1188 mcount = compact_minimal_symbols (msymbols, mcount, objfile); 1189 1190 obstack_blank (&objfile->objfile_obstack, 1191 (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol)); 1192 msymbols = (struct minimal_symbol *) 1193 obstack_finish (&objfile->objfile_obstack); 1194 1195 /* We also terminate the minimal symbol table with a "null symbol", 1196 which is *not* included in the size of the table. This makes it 1197 easier to find the end of the table when we are handed a pointer 1198 to some symbol in the middle of it. Zero out the fields in the 1199 "null symbol" allocated at the end of the array. Note that the 1200 symbol count does *not* include this null symbol, which is why it 1201 is indexed by mcount and not mcount-1. */ 1202 1203 SYMBOL_LINKAGE_NAME (&msymbols[mcount]) = NULL; 1204 SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0; 1205 MSYMBOL_TARGET_FLAG_1 (&msymbols[mcount]) = 0; 1206 MSYMBOL_TARGET_FLAG_2 (&msymbols[mcount]) = 0; 1207 MSYMBOL_SIZE (&msymbols[mcount]) = 0; 1208 MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown; 1209 SYMBOL_SET_LANGUAGE (&msymbols[mcount], language_unknown); 1210 1211 /* Attach the minimal symbol table to the specified objfile. 1212 The strings themselves are also located in the objfile_obstack 1213 of this objfile. */ 1214 1215 objfile->minimal_symbol_count = mcount; 1216 objfile->msymbols = msymbols; 1217 1218 /* Try to guess the appropriate C++ ABI by looking at the names 1219 of the minimal symbols in the table. */ 1220 { 1221 int i; 1222 1223 for (i = 0; i < mcount; i++) 1224 { 1225 /* If a symbol's name starts with _Z and was successfully 1226 demangled, then we can assume we've found a GNU v3 symbol. 1227 For now we set the C++ ABI globally; if the user is 1228 mixing ABIs then the user will need to "set cp-abi" 1229 manually. */ 1230 const char *name = SYMBOL_LINKAGE_NAME (&objfile->msymbols[i]); 1231 1232 if (name[0] == '_' && name[1] == 'Z' 1233 && SYMBOL_DEMANGLED_NAME (&objfile->msymbols[i]) != NULL) 1234 { 1235 set_cp_abi_as_auto_default ("gnu-v3"); 1236 break; 1237 } 1238 } 1239 } 1240 1241 /* Now build the hash tables; we can't do this incrementally 1242 at an earlier point since we weren't finished with the obstack 1243 yet. (And if the msymbol obstack gets moved, all the internal 1244 pointers to other msymbols need to be adjusted.) */ 1245 build_minimal_symbol_hash_tables (objfile); 1246 } 1247 } 1248 1249 /* Sort all the minimal symbols in OBJFILE. */ 1250 1251 void 1252 msymbols_sort (struct objfile *objfile) 1253 { 1254 qsort (objfile->msymbols, objfile->minimal_symbol_count, 1255 sizeof (struct minimal_symbol), compare_minimal_symbols); 1256 build_minimal_symbol_hash_tables (objfile); 1257 } 1258 1259 /* Check if PC is in a shared library trampoline code stub. 1260 Return minimal symbol for the trampoline entry or NULL if PC is not 1261 in a trampoline code stub. */ 1262 1263 struct minimal_symbol * 1264 lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc) 1265 { 1266 struct obj_section *section = find_pc_section (pc); 1267 struct minimal_symbol *msymbol; 1268 1269 if (section == NULL) 1270 return NULL; 1271 msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1); 1272 1273 if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline) 1274 return msymbol; 1275 return NULL; 1276 } 1277 1278 /* If PC is in a shared library trampoline code stub, return the 1279 address of the `real' function belonging to the stub. 1280 Return 0 if PC is not in a trampoline code stub or if the real 1281 function is not found in the minimal symbol table. 1282 1283 We may fail to find the right function if a function with the 1284 same name is defined in more than one shared library, but this 1285 is considered bad programming style. We could return 0 if we find 1286 a duplicate function in case this matters someday. */ 1287 1288 CORE_ADDR 1289 find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc) 1290 { 1291 struct objfile *objfile; 1292 struct minimal_symbol *msymbol; 1293 struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc); 1294 1295 if (tsymbol != NULL) 1296 { 1297 ALL_MSYMBOLS (objfile, msymbol) 1298 { 1299 if ((MSYMBOL_TYPE (msymbol) == mst_text 1300 || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc) 1301 && strcmp (SYMBOL_LINKAGE_NAME (msymbol), 1302 SYMBOL_LINKAGE_NAME (tsymbol)) == 0) 1303 return SYMBOL_VALUE_ADDRESS (msymbol); 1304 1305 /* Also handle minimal symbols pointing to function descriptors. */ 1306 if (MSYMBOL_TYPE (msymbol) == mst_data 1307 && strcmp (SYMBOL_LINKAGE_NAME (msymbol), 1308 SYMBOL_LINKAGE_NAME (tsymbol)) == 0) 1309 { 1310 CORE_ADDR func; 1311 1312 func = gdbarch_convert_from_func_ptr_addr 1313 (get_objfile_arch (objfile), 1314 SYMBOL_VALUE_ADDRESS (msymbol), 1315 ¤t_target); 1316 1317 /* Ignore data symbols that are not function descriptors. */ 1318 if (func != SYMBOL_VALUE_ADDRESS (msymbol)) 1319 return func; 1320 } 1321 } 1322 } 1323 return 0; 1324 } 1325