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