1/* Partial symbol tables. 2 3 Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20#include "defs.h" 21#include "symtab.h" 22#include "psympriv.h" 23#include "objfiles.h" 24#include "gdb_assert.h" 25#include "block.h" 26#include "filenames.h" 27#include "source.h" 28#include "addrmap.h" 29#include "gdbtypes.h" 30#include "bcache.h" 31#include "ui-out.h" 32#include "command.h" 33#include "readline/readline.h" 34#include "gdb_regex.h" 35#include "dictionary.h" 36#include "language.h" 37#include "cp-support.h" 38 39#ifndef DEV_TTY 40#define DEV_TTY "/dev/tty" 41#endif 42 43struct psymbol_bcache 44{ 45 struct bcache *bcache; 46}; 47 48/* A fast way to get from a psymtab to its symtab (after the first time). */ 49#define PSYMTAB_TO_SYMTAB(pst) \ 50 ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst)) 51 52static struct partial_symbol *match_partial_symbol (struct partial_symtab *, 53 int, 54 const char *, domain_enum, 55 symbol_compare_ftype *, 56 symbol_compare_ftype *); 57 58static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *, 59 const char *, int, 60 domain_enum); 61 62static char *psymtab_to_fullname (struct partial_symtab *ps); 63 64static struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *, 65 CORE_ADDR, 66 struct obj_section *); 67 68static struct partial_symbol *fixup_psymbol_section (struct partial_symbol 69 *psym, 70 struct objfile *objfile); 71 72static struct symtab *psymtab_to_symtab (struct partial_symtab *pst); 73 74/* Ensure that the partial symbols for OBJFILE have been loaded. This 75 function always returns its argument, as a convenience. */ 76 77struct objfile * 78require_partial_symbols (struct objfile *objfile, int verbose) 79{ 80 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0) 81 { 82 objfile->flags |= OBJF_PSYMTABS_READ; 83 84 if (objfile->sf->sym_read_psymbols) 85 { 86 if (verbose) 87 { 88 printf_unfiltered (_("Reading symbols from %s..."), 89 objfile->name); 90 gdb_flush (gdb_stdout); 91 } 92 (*objfile->sf->sym_read_psymbols) (objfile); 93 if (verbose) 94 { 95 if (!objfile_has_symbols (objfile)) 96 { 97 wrap_here (""); 98 printf_unfiltered (_("(no debugging symbols found)...")); 99 wrap_here (""); 100 } 101 102 printf_unfiltered (_("done.\n")); 103 } 104 } 105 } 106 107 return objfile; 108} 109 110/* Traverse all psymtabs in one objfile, requiring that the psymtabs 111 be read in. */ 112 113#define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \ 114 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \ 115 (p) != NULL; \ 116 (p) = (p)->next) 117 118/* We want to make sure this file always requires psymtabs. */ 119 120#undef ALL_OBJFILE_PSYMTABS 121 122/* Traverse all psymtabs in all objfiles. */ 123 124#define ALL_PSYMTABS(objfile, p) \ 125 ALL_OBJFILES (objfile) \ 126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p) 127 128/* Lookup the partial symbol table of a source file named NAME. 129 *If* there is no '/' in the name, a match after a '/' 130 in the psymtab filename will also work. */ 131 132static struct partial_symtab * 133lookup_partial_symtab (struct objfile *objfile, const char *name, 134 const char *full_path, const char *real_path) 135{ 136 struct partial_symtab *pst; 137 138 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) 139 { 140 if (FILENAME_CMP (name, pst->filename) == 0) 141 { 142 return (pst); 143 } 144 145 /* If the user gave us an absolute path, try to find the file in 146 this symtab and use its absolute path. */ 147 if (full_path != NULL) 148 { 149 psymtab_to_fullname (pst); 150 if (pst->fullname != NULL 151 && FILENAME_CMP (full_path, pst->fullname) == 0) 152 { 153 return pst; 154 } 155 } 156 157 if (real_path != NULL) 158 { 159 char *rp = NULL; 160 psymtab_to_fullname (pst); 161 if (pst->fullname != NULL) 162 { 163 rp = gdb_realpath (pst->fullname); 164 make_cleanup (xfree, rp); 165 } 166 if (rp != NULL && FILENAME_CMP (real_path, rp) == 0) 167 { 168 return pst; 169 } 170 } 171 } 172 173 /* Now, search for a matching tail (only if name doesn't have any dirs). */ 174 175 if (lbasename (name) == name) 176 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) 177 { 178 if (FILENAME_CMP (lbasename (pst->filename), name) == 0) 179 return (pst); 180 } 181 182 return (NULL); 183} 184 185static int 186lookup_symtab_via_partial_symtab (struct objfile *objfile, const char *name, 187 const char *full_path, const char *real_path, 188 struct symtab **result) 189{ 190 struct partial_symtab *ps; 191 192 ps = lookup_partial_symtab (objfile, name, full_path, real_path); 193 if (!ps) 194 return 0; 195 196 if (ps->readin) 197 error (_("Internal: readin %s pst for `%s' found when no symtab found."), 198 ps->filename, name); 199 200 *result = PSYMTAB_TO_SYMTAB (ps); 201 return 1; 202} 203 204/* Find which partial symtab contains PC and SECTION starting at psymtab PST. 205 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */ 206 207static struct partial_symtab * 208find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section, 209 struct partial_symtab *pst, 210 struct minimal_symbol *msymbol) 211{ 212 struct objfile *objfile = pst->objfile; 213 struct partial_symtab *tpst; 214 struct partial_symtab *best_pst = pst; 215 CORE_ADDR best_addr = pst->textlow; 216 217 /* An objfile that has its functions reordered might have 218 many partial symbol tables containing the PC, but 219 we want the partial symbol table that contains the 220 function containing the PC. */ 221 if (!(objfile->flags & OBJF_REORDERED) && 222 section == 0) /* Can't validate section this way. */ 223 return pst; 224 225 if (msymbol == NULL) 226 return (pst); 227 228 /* The code range of partial symtabs sometimes overlap, so, in 229 the loop below, we need to check all partial symtabs and 230 find the one that fits better for the given PC address. We 231 select the partial symtab that contains a symbol whose 232 address is closest to the PC address. By closest we mean 233 that find_pc_sect_symbol returns the symbol with address 234 that is closest and still less than the given PC. */ 235 for (tpst = pst; tpst != NULL; tpst = tpst->next) 236 { 237 if (pc >= tpst->textlow && pc < tpst->texthigh) 238 { 239 struct partial_symbol *p; 240 CORE_ADDR this_addr; 241 242 /* NOTE: This assumes that every psymbol has a 243 corresponding msymbol, which is not necessarily 244 true; the debug info might be much richer than the 245 object's symbol table. */ 246 p = find_pc_sect_psymbol (tpst, pc, section); 247 if (p != NULL 248 && SYMBOL_VALUE_ADDRESS (p) 249 == SYMBOL_VALUE_ADDRESS (msymbol)) 250 return tpst; 251 252 /* Also accept the textlow value of a psymtab as a 253 "symbol", to provide some support for partial 254 symbol tables with line information but no debug 255 symbols (e.g. those produced by an assembler). */ 256 if (p != NULL) 257 this_addr = SYMBOL_VALUE_ADDRESS (p); 258 else 259 this_addr = tpst->textlow; 260 261 /* Check whether it is closer than our current 262 BEST_ADDR. Since this symbol address is 263 necessarily lower or equal to PC, the symbol closer 264 to PC is the symbol which address is the highest. 265 This way we return the psymtab which contains such 266 best match symbol. This can help in cases where the 267 symbol information/debuginfo is not complete, like 268 for instance on IRIX6 with gcc, where no debug info 269 is emitted for statics. (See also the nodebug.exp 270 testcase.) */ 271 if (this_addr > best_addr) 272 { 273 best_addr = this_addr; 274 best_pst = tpst; 275 } 276 } 277 } 278 return best_pst; 279} 280 281/* Find which partial symtab contains PC and SECTION. Return 0 if 282 none. We return the psymtab that contains a symbol whose address 283 exactly matches PC, or, if we cannot find an exact match, the 284 psymtab that contains a symbol whose address is closest to PC. */ 285static struct partial_symtab * 286find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc, 287 struct obj_section *section, 288 struct minimal_symbol *msymbol) 289{ 290 struct partial_symtab *pst; 291 292 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity 293 than the later used TEXTLOW/TEXTHIGH one. */ 294 295 if (objfile->psymtabs_addrmap != NULL) 296 { 297 pst = addrmap_find (objfile->psymtabs_addrmap, pc); 298 if (pst != NULL) 299 { 300 /* FIXME: addrmaps currently do not handle overlayed sections, 301 so fall back to the non-addrmap case if we're debugging 302 overlays and the addrmap returned the wrong section. */ 303 if (overlay_debugging && msymbol && section) 304 { 305 struct partial_symbol *p; 306 307 /* NOTE: This assumes that every psymbol has a 308 corresponding msymbol, which is not necessarily 309 true; the debug info might be much richer than the 310 object's symbol table. */ 311 p = find_pc_sect_psymbol (pst, pc, section); 312 if (!p 313 || SYMBOL_VALUE_ADDRESS (p) 314 != SYMBOL_VALUE_ADDRESS (msymbol)) 315 goto next; 316 } 317 318 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as 319 PSYMTABS_ADDRMAP we used has already the best 1-byte 320 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into 321 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges 322 overlap. */ 323 324 return pst; 325 } 326 } 327 328 next: 329 330 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs 331 which still have no corresponding full SYMTABs read. But it is not 332 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB 333 so far. */ 334 335 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of 336 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying 337 debug info type in single OBJFILE. */ 338 339 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) 340 if (pc >= pst->textlow && pc < pst->texthigh) 341 { 342 struct partial_symtab *best_pst; 343 344 best_pst = find_pc_sect_psymtab_closer (pc, section, pst, msymbol); 345 if (best_pst != NULL) 346 return best_pst; 347 } 348 349 return NULL; 350} 351 352static struct symtab * 353find_pc_sect_symtab_from_partial (struct objfile *objfile, 354 struct minimal_symbol *msymbol, 355 CORE_ADDR pc, struct obj_section *section, 356 int warn_if_readin) 357{ 358 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section, 359 msymbol); 360 if (ps) 361 { 362 if (warn_if_readin && ps->readin) 363 /* Might want to error() here (in case symtab is corrupt and 364 will cause a core dump), but maybe we can successfully 365 continue, so let's not. */ 366 warning (_("\ 367(Internal error: pc %s in read in psymtab, but not in symtab.)\n"), 368 paddress (get_objfile_arch (ps->objfile), pc)); 369 return PSYMTAB_TO_SYMTAB (ps); 370 } 371 return NULL; 372} 373 374/* Find which partial symbol within a psymtab matches PC and SECTION. 375 Return 0 if none. */ 376 377static struct partial_symbol * 378find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc, 379 struct obj_section *section) 380{ 381 struct partial_symbol *best = NULL, *p, **pp; 382 CORE_ADDR best_pc; 383 384 gdb_assert (psymtab != NULL); 385 386 /* Cope with programs that start at address 0. */ 387 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0; 388 389 /* Search the global symbols as well as the static symbols, so that 390 find_pc_partial_function doesn't use a minimal symbol and thus 391 cache a bad endaddr. */ 392 for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset; 393 (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset) 394 < psymtab->n_global_syms); 395 pp++) 396 { 397 p = *pp; 398 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN 399 && SYMBOL_CLASS (p) == LOC_BLOCK 400 && pc >= SYMBOL_VALUE_ADDRESS (p) 401 && (SYMBOL_VALUE_ADDRESS (p) > best_pc 402 || (psymtab->textlow == 0 403 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0))) 404 { 405 if (section) /* Match on a specific section. */ 406 { 407 fixup_psymbol_section (p, psymtab->objfile); 408 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section)) 409 continue; 410 } 411 best_pc = SYMBOL_VALUE_ADDRESS (p); 412 best = p; 413 } 414 } 415 416 for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset; 417 (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset) 418 < psymtab->n_static_syms); 419 pp++) 420 { 421 p = *pp; 422 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN 423 && SYMBOL_CLASS (p) == LOC_BLOCK 424 && pc >= SYMBOL_VALUE_ADDRESS (p) 425 && (SYMBOL_VALUE_ADDRESS (p) > best_pc 426 || (psymtab->textlow == 0 427 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0))) 428 { 429 if (section) /* Match on a specific section. */ 430 { 431 fixup_psymbol_section (p, psymtab->objfile); 432 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section)) 433 continue; 434 } 435 best_pc = SYMBOL_VALUE_ADDRESS (p); 436 best = p; 437 } 438 } 439 440 return best; 441} 442 443static struct partial_symbol * 444fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile) 445{ 446 CORE_ADDR addr; 447 448 if (!psym) 449 return NULL; 450 451 if (SYMBOL_OBJ_SECTION (psym)) 452 return psym; 453 454 gdb_assert (objfile); 455 456 switch (SYMBOL_CLASS (psym)) 457 { 458 case LOC_STATIC: 459 case LOC_LABEL: 460 case LOC_BLOCK: 461 addr = SYMBOL_VALUE_ADDRESS (psym); 462 break; 463 default: 464 /* Nothing else will be listed in the minsyms -- no use looking 465 it up. */ 466 return psym; 467 } 468 469 fixup_section (&psym->ginfo, addr, objfile); 470 471 return psym; 472} 473 474static struct symtab * 475lookup_symbol_aux_psymtabs (struct objfile *objfile, 476 int block_index, const char *name, 477 const domain_enum domain) 478{ 479 struct partial_symtab *ps; 480 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0); 481 482 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) 483 { 484 if (!ps->readin && lookup_partial_symbol (ps, name, psymtab_index, domain)) 485 { 486 struct symbol *sym = NULL; 487 struct symtab *stab = PSYMTAB_TO_SYMTAB (ps); 488 489 /* Some caution must be observed with overloaded functions 490 and methods, since the psymtab will not contain any overload 491 information (but NAME might contain it). */ 492 if (stab->primary) 493 { 494 struct blockvector *bv = BLOCKVECTOR (stab); 495 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index); 496 497 sym = lookup_block_symbol (block, name, domain); 498 } 499 500 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0) 501 return stab; 502 503 /* Keep looking through other psymtabs. */ 504 } 505 } 506 507 return NULL; 508} 509 510/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search 511 the global block of PST if GLOBAL, and otherwise the static block. 512 MATCH is the comparison operation that returns true iff MATCH (s, 513 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is 514 non-null, the symbols in the block are assumed to be ordered 515 according to it (allowing binary search). It must be compatible 516 with MATCH. Returns the symbol, if found, and otherwise NULL. */ 517 518static struct partial_symbol * 519match_partial_symbol (struct partial_symtab *pst, int global, 520 const char *name, domain_enum domain, 521 symbol_compare_ftype *match, 522 symbol_compare_ftype *ordered_compare) 523{ 524 struct partial_symbol **start, **psym; 525 struct partial_symbol **top, **real_top, **bottom, **center; 526 int length = (global ? pst->n_global_syms : pst->n_static_syms); 527 int do_linear_search = 1; 528 529 if (length == 0) 530 return NULL; 531 start = (global ? 532 pst->objfile->global_psymbols.list + pst->globals_offset : 533 pst->objfile->static_psymbols.list + pst->statics_offset); 534 535 if (global && ordered_compare) /* Can use a binary search. */ 536 { 537 do_linear_search = 0; 538 539 /* Binary search. This search is guaranteed to end with center 540 pointing at the earliest partial symbol whose name might be 541 correct. At that point *all* partial symbols with an 542 appropriate name will be checked against the correct 543 domain. */ 544 545 bottom = start; 546 top = start + length - 1; 547 real_top = top; 548 while (top > bottom) 549 { 550 center = bottom + (top - bottom) / 2; 551 gdb_assert (center < top); 552 if (!do_linear_search 553 && (SYMBOL_LANGUAGE (*center) == language_java)) 554 do_linear_search = 1; 555 if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0) 556 top = center; 557 else 558 bottom = center + 1; 559 } 560 gdb_assert (top == bottom); 561 562 while (top <= real_top 563 && match (SYMBOL_SEARCH_NAME (*top), name) == 0) 564 { 565 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top), 566 SYMBOL_DOMAIN (*top), domain)) 567 return *top; 568 top++; 569 } 570 } 571 572 /* Can't use a binary search or else we found during the binary search that 573 we should also do a linear search. */ 574 575 if (do_linear_search) 576 { 577 for (psym = start; psym < start + length; psym++) 578 { 579 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym), 580 SYMBOL_DOMAIN (*psym), domain) 581 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0) 582 return *psym; 583 } 584 } 585 586 return NULL; 587} 588 589static void 590pre_expand_symtabs_matching_psymtabs (struct objfile *objfile, 591 int kind, const char *name, 592 domain_enum domain) 593{ 594 /* Nothing. */ 595} 596 597/* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do 598 not contain any method/function instance information (since this would 599 force reading type information while reading psymtabs). Therefore, 600 if NAME contains overload information, it must be stripped before searching 601 psymtabs. 602 603 The caller is responsible for freeing the return result. */ 604 605static char * 606psymtab_search_name (const char *name) 607{ 608 switch (current_language->la_language) 609 { 610 case language_cplus: 611 case language_java: 612 { 613 if (strchr (name, '(')) 614 { 615 char *ret = cp_remove_params (name); 616 617 if (ret) 618 return ret; 619 } 620 } 621 break; 622 623 default: 624 break; 625 } 626 627 return xstrdup (name); 628} 629 630/* Look, in partial_symtab PST, for symbol whose natural name is NAME. 631 Check the global symbols if GLOBAL, the static symbols if not. */ 632 633static struct partial_symbol * 634lookup_partial_symbol (struct partial_symtab *pst, const char *name, 635 int global, domain_enum domain) 636{ 637 struct partial_symbol **start, **psym; 638 struct partial_symbol **top, **real_top, **bottom, **center; 639 int length = (global ? pst->n_global_syms : pst->n_static_syms); 640 int do_linear_search = 1; 641 char *search_name; 642 struct cleanup *cleanup; 643 644 if (length == 0) 645 { 646 return (NULL); 647 } 648 649 search_name = psymtab_search_name (name); 650 cleanup = make_cleanup (xfree, search_name); 651 start = (global ? 652 pst->objfile->global_psymbols.list + pst->globals_offset : 653 pst->objfile->static_psymbols.list + pst->statics_offset); 654 655 if (global) /* This means we can use a binary search. */ 656 { 657 do_linear_search = 0; 658 659 /* Binary search. This search is guaranteed to end with center 660 pointing at the earliest partial symbol whose name might be 661 correct. At that point *all* partial symbols with an 662 appropriate name will be checked against the correct 663 domain. */ 664 665 bottom = start; 666 top = start + length - 1; 667 real_top = top; 668 while (top > bottom) 669 { 670 center = bottom + (top - bottom) / 2; 671 if (!(center < top)) 672 internal_error (__FILE__, __LINE__, 673 _("failed internal consistency check")); 674 if (!do_linear_search 675 && SYMBOL_LANGUAGE (*center) == language_java) 676 { 677 do_linear_search = 1; 678 } 679 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), 680 search_name) >= 0) 681 { 682 top = center; 683 } 684 else 685 { 686 bottom = center + 1; 687 } 688 } 689 if (!(top == bottom)) 690 internal_error (__FILE__, __LINE__, 691 _("failed internal consistency check")); 692 693 while (top <= real_top 694 && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name)) 695 { 696 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top), 697 SYMBOL_DOMAIN (*top), domain)) 698 { 699 do_cleanups (cleanup); 700 return (*top); 701 } 702 top++; 703 } 704 } 705 706 /* Can't use a binary search or else we found during the binary search that 707 we should also do a linear search. */ 708 709 if (do_linear_search) 710 { 711 for (psym = start; psym < start + length; psym++) 712 { 713 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym), 714 SYMBOL_DOMAIN (*psym), domain) 715 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name)) 716 { 717 do_cleanups (cleanup); 718 return (*psym); 719 } 720 } 721 } 722 723 do_cleanups (cleanup); 724 return (NULL); 725} 726 727/* Get the symbol table that corresponds to a partial_symtab. 728 This is fast after the first time you do it. In fact, there 729 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast 730 case inline. */ 731 732static struct symtab * 733psymtab_to_symtab (struct partial_symtab *pst) 734{ 735 /* If it's been looked up before, return it. */ 736 if (pst->symtab) 737 return pst->symtab; 738 739 /* If it has not yet been read in, read it. */ 740 if (!pst->readin) 741 { 742 struct cleanup *back_to = increment_reading_symtab (); 743 744 (*pst->read_symtab) (pst); 745 do_cleanups (back_to); 746 } 747 748 return pst->symtab; 749} 750 751static void 752relocate_psymtabs (struct objfile *objfile, 753 struct section_offsets *new_offsets, 754 struct section_offsets *delta) 755{ 756 struct partial_symbol **psym; 757 struct partial_symtab *p; 758 759 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p) 760 { 761 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 762 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); 763 } 764 765 for (psym = objfile->global_psymbols.list; 766 psym < objfile->global_psymbols.next; 767 psym++) 768 { 769 fixup_psymbol_section (*psym, objfile); 770 if (SYMBOL_SECTION (*psym) >= 0) 771 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, 772 SYMBOL_SECTION (*psym)); 773 } 774 for (psym = objfile->static_psymbols.list; 775 psym < objfile->static_psymbols.next; 776 psym++) 777 { 778 fixup_psymbol_section (*psym, objfile); 779 if (SYMBOL_SECTION (*psym) >= 0) 780 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, 781 SYMBOL_SECTION (*psym)); 782 } 783} 784 785static struct symtab * 786find_last_source_symtab_from_partial (struct objfile *ofp) 787{ 788 struct partial_symtab *ps; 789 struct partial_symtab *cs_pst = 0; 790 791 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps) 792 { 793 const char *name = ps->filename; 794 int len = strlen (name); 795 796 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0 797 || strcmp (name, "<<C++-namespaces>>") == 0))) 798 cs_pst = ps; 799 } 800 801 if (cs_pst) 802 { 803 if (cs_pst->readin) 804 { 805 internal_error (__FILE__, __LINE__, 806 _("select_source_symtab: " 807 "readin pst found and no symtabs.")); 808 } 809 else 810 return PSYMTAB_TO_SYMTAB (cs_pst); 811 } 812 return NULL; 813} 814 815static void 816forget_cached_source_info_partial (struct objfile *objfile) 817{ 818 struct partial_symtab *pst; 819 820 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) 821 { 822 if (pst->fullname != NULL) 823 { 824 xfree (pst->fullname); 825 pst->fullname = NULL; 826 } 827 } 828} 829 830static void 831print_partial_symbols (struct gdbarch *gdbarch, 832 struct partial_symbol **p, int count, char *what, 833 struct ui_file *outfile) 834{ 835 fprintf_filtered (outfile, " %s partial symbols:\n", what); 836 while (count-- > 0) 837 { 838 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p)); 839 if (SYMBOL_DEMANGLED_NAME (*p) != NULL) 840 { 841 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p)); 842 } 843 fputs_filtered (", ", outfile); 844 switch (SYMBOL_DOMAIN (*p)) 845 { 846 case UNDEF_DOMAIN: 847 fputs_filtered ("undefined domain, ", outfile); 848 break; 849 case VAR_DOMAIN: 850 /* This is the usual thing -- don't print it. */ 851 break; 852 case STRUCT_DOMAIN: 853 fputs_filtered ("struct domain, ", outfile); 854 break; 855 case LABEL_DOMAIN: 856 fputs_filtered ("label domain, ", outfile); 857 break; 858 default: 859 fputs_filtered ("<invalid domain>, ", outfile); 860 break; 861 } 862 switch (SYMBOL_CLASS (*p)) 863 { 864 case LOC_UNDEF: 865 fputs_filtered ("undefined", outfile); 866 break; 867 case LOC_CONST: 868 fputs_filtered ("constant int", outfile); 869 break; 870 case LOC_STATIC: 871 fputs_filtered ("static", outfile); 872 break; 873 case LOC_REGISTER: 874 fputs_filtered ("register", outfile); 875 break; 876 case LOC_ARG: 877 fputs_filtered ("pass by value", outfile); 878 break; 879 case LOC_REF_ARG: 880 fputs_filtered ("pass by reference", outfile); 881 break; 882 case LOC_REGPARM_ADDR: 883 fputs_filtered ("register address parameter", outfile); 884 break; 885 case LOC_LOCAL: 886 fputs_filtered ("stack parameter", outfile); 887 break; 888 case LOC_TYPEDEF: 889 fputs_filtered ("type", outfile); 890 break; 891 case LOC_LABEL: 892 fputs_filtered ("label", outfile); 893 break; 894 case LOC_BLOCK: 895 fputs_filtered ("function", outfile); 896 break; 897 case LOC_CONST_BYTES: 898 fputs_filtered ("constant bytes", outfile); 899 break; 900 case LOC_UNRESOLVED: 901 fputs_filtered ("unresolved", outfile); 902 break; 903 case LOC_OPTIMIZED_OUT: 904 fputs_filtered ("optimized out", outfile); 905 break; 906 case LOC_COMPUTED: 907 fputs_filtered ("computed at runtime", outfile); 908 break; 909 default: 910 fputs_filtered ("<invalid location>", outfile); 911 break; 912 } 913 fputs_filtered (", ", outfile); 914 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile); 915 fprintf_filtered (outfile, "\n"); 916 p++; 917 } 918} 919 920static void 921dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab, 922 struct ui_file *outfile) 923{ 924 struct gdbarch *gdbarch = get_objfile_arch (objfile); 925 int i; 926 927 fprintf_filtered (outfile, "\nPartial symtab for source file %s ", 928 psymtab->filename); 929 fprintf_filtered (outfile, "(object "); 930 gdb_print_host_address (psymtab, outfile); 931 fprintf_filtered (outfile, ")\n\n"); 932 fprintf_unfiltered (outfile, " Read from object file %s (", 933 objfile->name); 934 gdb_print_host_address (objfile, outfile); 935 fprintf_unfiltered (outfile, ")\n"); 936 937 if (psymtab->readin) 938 { 939 fprintf_filtered (outfile, 940 " Full symtab was read (at "); 941 gdb_print_host_address (psymtab->symtab, outfile); 942 fprintf_filtered (outfile, " by function at "); 943 gdb_print_host_address (psymtab->read_symtab, outfile); 944 fprintf_filtered (outfile, ")\n"); 945 } 946 947 fprintf_filtered (outfile, " Relocate symbols by "); 948 for (i = 0; i < psymtab->objfile->num_sections; ++i) 949 { 950 if (i != 0) 951 fprintf_filtered (outfile, ", "); 952 wrap_here (" "); 953 fputs_filtered (paddress (gdbarch, 954 ANOFFSET (psymtab->section_offsets, i)), 955 outfile); 956 } 957 fprintf_filtered (outfile, "\n"); 958 959 fprintf_filtered (outfile, " Symbols cover text addresses "); 960 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile); 961 fprintf_filtered (outfile, "-"); 962 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile); 963 fprintf_filtered (outfile, "\n"); 964 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n", 965 psymtab->number_of_dependencies); 966 for (i = 0; i < psymtab->number_of_dependencies; i++) 967 { 968 fprintf_filtered (outfile, " %d ", i); 969 gdb_print_host_address (psymtab->dependencies[i], outfile); 970 fprintf_filtered (outfile, " %s\n", 971 psymtab->dependencies[i]->filename); 972 } 973 if (psymtab->n_global_syms > 0) 974 { 975 print_partial_symbols (gdbarch, 976 objfile->global_psymbols.list 977 + psymtab->globals_offset, 978 psymtab->n_global_syms, "Global", outfile); 979 } 980 if (psymtab->n_static_syms > 0) 981 { 982 print_partial_symbols (gdbarch, 983 objfile->static_psymbols.list 984 + psymtab->statics_offset, 985 psymtab->n_static_syms, "Static", outfile); 986 } 987 fprintf_filtered (outfile, "\n"); 988} 989 990static void 991print_psymtab_stats_for_objfile (struct objfile *objfile) 992{ 993 int i; 994 struct partial_symtab *ps; 995 996 i = 0; 997 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) 998 { 999 if (ps->readin == 0) 1000 i++; 1001 } 1002 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i); 1003} 1004 1005static void 1006dump_psymtabs_for_objfile (struct objfile *objfile) 1007{ 1008 struct partial_symtab *psymtab; 1009 1010 if (objfile->psymtabs) 1011 { 1012 printf_filtered ("Psymtabs:\n"); 1013 for (psymtab = objfile->psymtabs; 1014 psymtab != NULL; 1015 psymtab = psymtab->next) 1016 { 1017 printf_filtered ("%s at ", 1018 psymtab->filename); 1019 gdb_print_host_address (psymtab, gdb_stdout); 1020 printf_filtered (", "); 1021 if (psymtab->objfile != objfile) 1022 { 1023 printf_filtered ("NOT ON CHAIN! "); 1024 } 1025 wrap_here (" "); 1026 } 1027 printf_filtered ("\n\n"); 1028 } 1029} 1030 1031/* Look through the partial symtabs for all symbols which begin 1032 by matching FUNC_NAME. Make sure we read that symbol table in. */ 1033 1034static void 1035read_symtabs_for_function (struct objfile *objfile, const char *func_name) 1036{ 1037 struct partial_symtab *ps; 1038 1039 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) 1040 { 1041 if (ps->readin) 1042 continue; 1043 1044 if ((lookup_partial_symbol (ps, func_name, 1, VAR_DOMAIN) 1045 != NULL) 1046 || (lookup_partial_symbol (ps, func_name, 0, VAR_DOMAIN) 1047 != NULL)) 1048 psymtab_to_symtab (ps); 1049 } 1050} 1051 1052static void 1053expand_partial_symbol_tables (struct objfile *objfile) 1054{ 1055 struct partial_symtab *psymtab; 1056 1057 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab) 1058 { 1059 psymtab_to_symtab (psymtab); 1060 } 1061} 1062 1063static void 1064read_psymtabs_with_filename (struct objfile *objfile, const char *filename) 1065{ 1066 struct partial_symtab *p; 1067 1068 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p) 1069 { 1070 if (filename_cmp (filename, p->filename) == 0) 1071 PSYMTAB_TO_SYMTAB (p); 1072 } 1073} 1074 1075static void 1076map_symbol_filenames_psymtab (struct objfile *objfile, 1077 void (*fun) (const char *, const char *, 1078 void *), 1079 void *data) 1080{ 1081 struct partial_symtab *ps; 1082 1083 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) 1084 { 1085 const char *fullname; 1086 1087 if (ps->readin) 1088 continue; 1089 1090 fullname = psymtab_to_fullname (ps); 1091 (*fun) (ps->filename, fullname, data); 1092 } 1093} 1094 1095int find_and_open_source (const char *filename, 1096 const char *dirname, 1097 char **fullname); 1098 1099/* Finds the fullname that a partial_symtab represents. 1100 1101 If this functions finds the fullname, it will save it in ps->fullname 1102 and it will also return the value. 1103 1104 If this function fails to find the file that this partial_symtab represents, 1105 NULL will be returned and ps->fullname will be set to NULL. */ 1106static char * 1107psymtab_to_fullname (struct partial_symtab *ps) 1108{ 1109 int r; 1110 1111 if (!ps) 1112 return NULL; 1113 1114 /* Don't check ps->fullname here, the file could have been 1115 deleted/moved/..., look for it again. */ 1116 r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname); 1117 1118 if (r >= 0) 1119 { 1120 close (r); 1121 return ps->fullname; 1122 } 1123 1124 return NULL; 1125} 1126 1127static const char * 1128find_symbol_file_from_partial (struct objfile *objfile, const char *name) 1129{ 1130 struct partial_symtab *pst; 1131 1132 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) 1133 { 1134 if (lookup_partial_symbol (pst, name, 1, VAR_DOMAIN)) 1135 return pst->filename; 1136 } 1137 return NULL; 1138} 1139 1140/* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME 1141 according to the function MATCH, call CALLBACK(BLOCK, s, DATA). 1142 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK 1143 ever returns non-zero, and otherwise returns 0. */ 1144 1145static int 1146map_block (const char *name, domain_enum namespace, struct objfile *objfile, 1147 struct block *block, 1148 int (*callback) (struct block *, struct symbol *, void *), 1149 void *data, symbol_compare_ftype *match) 1150{ 1151 struct dict_iterator iter; 1152 struct symbol *sym; 1153 1154 for (sym = dict_iter_match_first (BLOCK_DICT (block), name, match, &iter); 1155 sym != NULL; sym = dict_iter_match_next (name, match, &iter)) 1156 { 1157 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), 1158 SYMBOL_DOMAIN (sym), namespace)) 1159 { 1160 if (callback (block, sym, data)) 1161 return 1; 1162 } 1163 } 1164 1165 return 0; 1166} 1167 1168/* Psymtab version of map_matching_symbols. See its definition in 1169 the definition of quick_symbol_functions in symfile.h. */ 1170 1171static void 1172map_matching_symbols_psymtab (const char *name, domain_enum namespace, 1173 struct objfile *objfile, int global, 1174 int (*callback) (struct block *, 1175 struct symbol *, void *), 1176 void *data, 1177 symbol_compare_ftype *match, 1178 symbol_compare_ftype *ordered_compare) 1179{ 1180 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK; 1181 struct partial_symtab *ps; 1182 1183 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) 1184 { 1185 QUIT; 1186 if (ps->readin 1187 || match_partial_symbol (ps, global, name, namespace, match, 1188 ordered_compare)) 1189 { 1190 struct symtab *s = PSYMTAB_TO_SYMTAB (ps); 1191 struct block *block; 1192 1193 if (s == NULL || !s->primary) 1194 continue; 1195 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind); 1196 if (map_block (name, namespace, objfile, block, 1197 callback, data, match)) 1198 return; 1199 if (callback (block, NULL, data)) 1200 return; 1201 } 1202 } 1203} 1204 1205static void 1206expand_symtabs_matching_via_partial (struct objfile *objfile, 1207 int (*file_matcher) (const char *, 1208 void *), 1209 int (*name_matcher) (const char *, 1210 void *), 1211 domain_enum kind, 1212 void *data) 1213{ 1214 struct partial_symtab *ps; 1215 1216 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) 1217 { 1218 struct partial_symbol **psym; 1219 struct partial_symbol **bound, **gbound, **sbound; 1220 int keep_going = 1; 1221 1222 if (ps->readin) 1223 continue; 1224 1225 if (file_matcher && ! (*file_matcher) (ps->filename, data)) 1226 continue; 1227 1228 gbound = objfile->global_psymbols.list 1229 + ps->globals_offset + ps->n_global_syms; 1230 sbound = objfile->static_psymbols.list 1231 + ps->statics_offset + ps->n_static_syms; 1232 bound = gbound; 1233 1234 /* Go through all of the symbols stored in a partial 1235 symtab in one loop. */ 1236 psym = objfile->global_psymbols.list + ps->globals_offset; 1237 while (keep_going) 1238 { 1239 if (psym >= bound) 1240 { 1241 if (bound == gbound && ps->n_static_syms != 0) 1242 { 1243 psym = objfile->static_psymbols.list + ps->statics_offset; 1244 bound = sbound; 1245 } 1246 else 1247 keep_going = 0; 1248 continue; 1249 } 1250 else 1251 { 1252 QUIT; 1253 1254 if ((kind == ALL_DOMAIN 1255 || (kind == VARIABLES_DOMAIN 1256 && SYMBOL_CLASS (*psym) != LOC_TYPEDEF 1257 && SYMBOL_CLASS (*psym) != LOC_BLOCK) 1258 || (kind == FUNCTIONS_DOMAIN 1259 && SYMBOL_CLASS (*psym) == LOC_BLOCK) 1260 || (kind == TYPES_DOMAIN 1261 && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)) 1262 && (*name_matcher) (SYMBOL_NATURAL_NAME (*psym), data)) 1263 { 1264 PSYMTAB_TO_SYMTAB (ps); 1265 keep_going = 0; 1266 } 1267 } 1268 psym++; 1269 } 1270 } 1271} 1272 1273static int 1274objfile_has_psyms (struct objfile *objfile) 1275{ 1276 return objfile->psymtabs != NULL; 1277} 1278 1279const struct quick_symbol_functions psym_functions = 1280{ 1281 objfile_has_psyms, 1282 find_last_source_symtab_from_partial, 1283 forget_cached_source_info_partial, 1284 lookup_symtab_via_partial_symtab, 1285 lookup_symbol_aux_psymtabs, 1286 pre_expand_symtabs_matching_psymtabs, 1287 print_psymtab_stats_for_objfile, 1288 dump_psymtabs_for_objfile, 1289 relocate_psymtabs, 1290 read_symtabs_for_function, 1291 expand_partial_symbol_tables, 1292 read_psymtabs_with_filename, 1293 find_symbol_file_from_partial, 1294 map_matching_symbols_psymtab, 1295 expand_symtabs_matching_via_partial, 1296 find_pc_sect_symtab_from_partial, 1297 map_symbol_filenames_psymtab 1298}; 1299 1300 1301 1302/* This compares two partial symbols by names, using strcmp_iw_ordered 1303 for the comparison. */ 1304 1305static int 1306compare_psymbols (const void *s1p, const void *s2p) 1307{ 1308 struct partial_symbol *const *s1 = s1p; 1309 struct partial_symbol *const *s2 = s2p; 1310 1311 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1), 1312 SYMBOL_SEARCH_NAME (*s2)); 1313} 1314 1315void 1316sort_pst_symbols (struct partial_symtab *pst) 1317{ 1318 /* Sort the global list; don't sort the static list. */ 1319 1320 qsort (pst->objfile->global_psymbols.list + pst->globals_offset, 1321 pst->n_global_syms, sizeof (struct partial_symbol *), 1322 compare_psymbols); 1323} 1324 1325/* Allocate and partially fill a partial symtab. It will be 1326 completely filled at the end of the symbol list. 1327 1328 FILENAME is the name of the symbol-file we are reading from. */ 1329 1330struct partial_symtab * 1331start_psymtab_common (struct objfile *objfile, 1332 struct section_offsets *section_offsets, 1333 const char *filename, 1334 CORE_ADDR textlow, struct partial_symbol **global_syms, 1335 struct partial_symbol **static_syms) 1336{ 1337 struct partial_symtab *psymtab; 1338 1339 psymtab = allocate_psymtab (filename, objfile); 1340 psymtab->section_offsets = section_offsets; 1341 psymtab->textlow = textlow; 1342 psymtab->texthigh = psymtab->textlow; /* default */ 1343 psymtab->globals_offset = global_syms - objfile->global_psymbols.list; 1344 psymtab->statics_offset = static_syms - objfile->static_psymbols.list; 1345 return (psymtab); 1346} 1347 1348/* Calculate a hash code for the given partial symbol. The hash is 1349 calculated using the symbol's value, language, domain, class 1350 and name. These are the values which are set by 1351 add_psymbol_to_bcache. */ 1352 1353static unsigned long 1354psymbol_hash (const void *addr, int length) 1355{ 1356 unsigned long h = 0; 1357 struct partial_symbol *psymbol = (struct partial_symbol *) addr; 1358 unsigned int lang = psymbol->ginfo.language; 1359 unsigned int domain = PSYMBOL_DOMAIN (psymbol); 1360 unsigned int class = PSYMBOL_CLASS (psymbol); 1361 1362 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h); 1363 h = hash_continue (&lang, sizeof (unsigned int), h); 1364 h = hash_continue (&domain, sizeof (unsigned int), h); 1365 h = hash_continue (&class, sizeof (unsigned int), h); 1366 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h); 1367 1368 return h; 1369} 1370 1371/* Returns true if the symbol at addr1 equals the symbol at addr2. 1372 For the comparison this function uses a symbols value, 1373 language, domain, class and name. */ 1374 1375static int 1376psymbol_compare (const void *addr1, const void *addr2, int length) 1377{ 1378 struct partial_symbol *sym1 = (struct partial_symbol *) addr1; 1379 struct partial_symbol *sym2 = (struct partial_symbol *) addr2; 1380 1381 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value, 1382 sizeof (sym1->ginfo.value)) == 0 1383 && sym1->ginfo.language == sym2->ginfo.language 1384 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2) 1385 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2) 1386 && sym1->ginfo.name == sym2->ginfo.name); 1387} 1388 1389/* Initialize a partial symbol bcache. */ 1390 1391struct psymbol_bcache * 1392psymbol_bcache_init (void) 1393{ 1394 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache); 1395 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare); 1396 return bcache; 1397} 1398 1399/* Free a partial symbol bcache. */ 1400void 1401psymbol_bcache_free (struct psymbol_bcache *bcache) 1402{ 1403 if (bcache == NULL) 1404 return; 1405 1406 bcache_xfree (bcache->bcache); 1407 xfree (bcache); 1408} 1409 1410/* Return the internal bcache of the psymbol_bcache BCACHE. */ 1411 1412struct bcache * 1413psymbol_bcache_get_bcache (struct psymbol_bcache *bcache) 1414{ 1415 return bcache->bcache; 1416} 1417 1418/* Find a copy of the SYM in BCACHE. If BCACHE has never seen this 1419 symbol before, add a copy to BCACHE. In either case, return a pointer 1420 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return 1421 1 in case of new entry or 0 if returning an old entry. */ 1422 1423static const struct partial_symbol * 1424psymbol_bcache_full (struct partial_symbol *sym, 1425 struct psymbol_bcache *bcache, 1426 int *added) 1427{ 1428 return bcache_full (sym, 1429 sizeof (struct partial_symbol), 1430 bcache->bcache, 1431 added); 1432} 1433 1434/* Helper function, initialises partial symbol structure and stashes 1435 it into objfile's bcache. Note that our caching mechanism will 1436 use all fields of struct partial_symbol to determine hash value of the 1437 structure. In other words, having two symbols with the same name but 1438 different domain (or address) is possible and correct. */ 1439 1440static const struct partial_symbol * 1441add_psymbol_to_bcache (const char *name, int namelength, int copy_name, 1442 domain_enum domain, 1443 enum address_class class, 1444 long val, /* Value as a long */ 1445 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */ 1446 enum language language, struct objfile *objfile, 1447 int *added) 1448{ 1449 struct partial_symbol psymbol; 1450 1451 /* We must ensure that the entire 'value' field has been zeroed 1452 before assigning to it, because an assignment may not write the 1453 entire field. */ 1454 memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value)); 1455 1456 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */ 1457 if (val != 0) 1458 { 1459 SYMBOL_VALUE (&psymbol) = val; 1460 } 1461 else 1462 { 1463 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr; 1464 } 1465 SYMBOL_SECTION (&psymbol) = 0; 1466 SYMBOL_OBJ_SECTION (&psymbol) = NULL; 1467 SYMBOL_SET_LANGUAGE (&psymbol, language); 1468 PSYMBOL_DOMAIN (&psymbol) = domain; 1469 PSYMBOL_CLASS (&psymbol) = class; 1470 1471 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile); 1472 1473 /* Stash the partial symbol away in the cache. */ 1474 return psymbol_bcache_full (&psymbol, 1475 objfile->psymbol_cache, 1476 added); 1477} 1478 1479/* Increase the space allocated for LISTP, which is probably 1480 global_psymbols or static_psymbols. This space will eventually 1481 be freed in free_objfile(). */ 1482 1483static void 1484extend_psymbol_list (struct psymbol_allocation_list *listp, 1485 struct objfile *objfile) 1486{ 1487 int new_size; 1488 1489 if (listp->size == 0) 1490 { 1491 new_size = 255; 1492 listp->list = (struct partial_symbol **) 1493 xmalloc (new_size * sizeof (struct partial_symbol *)); 1494 } 1495 else 1496 { 1497 new_size = listp->size * 2; 1498 listp->list = (struct partial_symbol **) 1499 xrealloc ((char *) listp->list, 1500 new_size * sizeof (struct partial_symbol *)); 1501 } 1502 /* Next assumes we only went one over. Should be good if 1503 program works correctly. */ 1504 listp->next = listp->list + listp->size; 1505 listp->size = new_size; 1506} 1507 1508/* Helper function, adds partial symbol to the given partial symbol 1509 list. */ 1510 1511static void 1512append_psymbol_to_list (struct psymbol_allocation_list *list, 1513 const struct partial_symbol *psym, 1514 struct objfile *objfile) 1515{ 1516 if (list->next >= list->list + list->size) 1517 extend_psymbol_list (list, objfile); 1518 *list->next++ = (struct partial_symbol *) psym; 1519 OBJSTAT (objfile, n_psyms++); 1520} 1521 1522/* Add a symbol with a long value to a psymtab. 1523 Since one arg is a struct, we pass in a ptr and deref it (sigh). 1524 Return the partial symbol that has been added. */ 1525 1526/* NOTE: carlton/2003-09-11: The reason why we return the partial 1527 symbol is so that callers can get access to the symbol's demangled 1528 name, which they don't have any cheap way to determine otherwise. 1529 (Currenly, dwarf2read.c is the only file who uses that information, 1530 though it's possible that other readers might in the future.) 1531 Elena wasn't thrilled about that, and I don't blame her, but we 1532 couldn't come up with a better way to get that information. If 1533 it's needed in other situations, we could consider breaking up 1534 SYMBOL_SET_NAMES to provide access to the demangled name lookup 1535 cache. */ 1536 1537const struct partial_symbol * 1538add_psymbol_to_list (const char *name, int namelength, int copy_name, 1539 domain_enum domain, 1540 enum address_class class, 1541 struct psymbol_allocation_list *list, 1542 long val, /* Value as a long */ 1543 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */ 1544 enum language language, struct objfile *objfile) 1545{ 1546 const struct partial_symbol *psym; 1547 1548 int added; 1549 1550 /* Stash the partial symbol away in the cache. */ 1551 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class, 1552 val, coreaddr, language, objfile, &added); 1553 1554 /* Do not duplicate global partial symbols. */ 1555 if (list == &objfile->global_psymbols 1556 && !added) 1557 return psym; 1558 1559 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */ 1560 append_psymbol_to_list (list, psym, objfile); 1561 return psym; 1562} 1563 1564/* Initialize storage for partial symbols. */ 1565 1566void 1567init_psymbol_list (struct objfile *objfile, int total_symbols) 1568{ 1569 /* Free any previously allocated psymbol lists. */ 1570 1571 if (objfile->global_psymbols.list) 1572 { 1573 xfree (objfile->global_psymbols.list); 1574 } 1575 if (objfile->static_psymbols.list) 1576 { 1577 xfree (objfile->static_psymbols.list); 1578 } 1579 1580 /* Current best guess is that approximately a twentieth 1581 of the total symbols (in a debugging file) are global or static 1582 oriented symbols. */ 1583 1584 objfile->global_psymbols.size = total_symbols / 10; 1585 objfile->static_psymbols.size = total_symbols / 10; 1586 1587 if (objfile->global_psymbols.size > 0) 1588 { 1589 objfile->global_psymbols.next = 1590 objfile->global_psymbols.list = (struct partial_symbol **) 1591 xmalloc ((objfile->global_psymbols.size 1592 * sizeof (struct partial_symbol *))); 1593 } 1594 if (objfile->static_psymbols.size > 0) 1595 { 1596 objfile->static_psymbols.next = 1597 objfile->static_psymbols.list = (struct partial_symbol **) 1598 xmalloc ((objfile->static_psymbols.size 1599 * sizeof (struct partial_symbol *))); 1600 } 1601} 1602 1603struct partial_symtab * 1604allocate_psymtab (const char *filename, struct objfile *objfile) 1605{ 1606 struct partial_symtab *psymtab; 1607 1608 if (objfile->free_psymtabs) 1609 { 1610 psymtab = objfile->free_psymtabs; 1611 objfile->free_psymtabs = psymtab->next; 1612 } 1613 else 1614 psymtab = (struct partial_symtab *) 1615 obstack_alloc (&objfile->objfile_obstack, 1616 sizeof (struct partial_symtab)); 1617 1618 memset (psymtab, 0, sizeof (struct partial_symtab)); 1619 psymtab->filename = obsavestring (filename, strlen (filename), 1620 &objfile->objfile_obstack); 1621 psymtab->symtab = NULL; 1622 1623 /* Prepend it to the psymtab list for the objfile it belongs to. 1624 Psymtabs are searched in most recent inserted -> least recent 1625 inserted order. */ 1626 1627 psymtab->objfile = objfile; 1628 psymtab->next = objfile->psymtabs; 1629 objfile->psymtabs = psymtab; 1630 1631 return (psymtab); 1632} 1633 1634void 1635discard_psymtab (struct partial_symtab *pst) 1636{ 1637 struct partial_symtab **prev_pst; 1638 1639 /* From dbxread.c: 1640 Empty psymtabs happen as a result of header files which don't 1641 have any symbols in them. There can be a lot of them. But this 1642 check is wrong, in that a psymtab with N_SLINE entries but 1643 nothing else is not empty, but we don't realize that. Fixing 1644 that without slowing things down might be tricky. */ 1645 1646 /* First, snip it out of the psymtab chain. */ 1647 1648 prev_pst = &(pst->objfile->psymtabs); 1649 while ((*prev_pst) != pst) 1650 prev_pst = &((*prev_pst)->next); 1651 (*prev_pst) = pst->next; 1652 1653 /* Next, put it on a free list for recycling. */ 1654 1655 pst->next = pst->objfile->free_psymtabs; 1656 pst->objfile->free_psymtabs = pst; 1657} 1658 1659 1660 1661void 1662maintenance_print_psymbols (char *args, int from_tty) 1663{ 1664 char **argv; 1665 struct ui_file *outfile; 1666 struct cleanup *cleanups; 1667 char *symname = NULL; 1668 char *filename = DEV_TTY; 1669 struct objfile *objfile; 1670 struct partial_symtab *ps; 1671 1672 dont_repeat (); 1673 1674 if (args == NULL) 1675 { 1676 error (_("\ 1677print-psymbols takes an output file name and optional symbol file name")); 1678 } 1679 argv = gdb_buildargv (args); 1680 cleanups = make_cleanup_freeargv (argv); 1681 1682 if (argv[0] != NULL) 1683 { 1684 filename = argv[0]; 1685 /* If a second arg is supplied, it is a source file name to match on. */ 1686 if (argv[1] != NULL) 1687 { 1688 symname = argv[1]; 1689 } 1690 } 1691 1692 filename = tilde_expand (filename); 1693 make_cleanup (xfree, filename); 1694 1695 outfile = gdb_fopen (filename, FOPEN_WT); 1696 if (outfile == 0) 1697 perror_with_name (filename); 1698 make_cleanup_ui_file_delete (outfile); 1699 1700 immediate_quit++; 1701 ALL_PSYMTABS (objfile, ps) 1702 if (symname == NULL || filename_cmp (symname, ps->filename) == 0) 1703 dump_psymtab (objfile, ps, outfile); 1704 immediate_quit--; 1705 do_cleanups (cleanups); 1706} 1707 1708/* List all the partial symbol tables whose names match REGEXP (optional). */ 1709void 1710maintenance_info_psymtabs (char *regexp, int from_tty) 1711{ 1712 struct program_space *pspace; 1713 struct objfile *objfile; 1714 1715 if (regexp) 1716 re_comp (regexp); 1717 1718 ALL_PSPACES (pspace) 1719 ALL_PSPACE_OBJFILES (pspace, objfile) 1720 { 1721 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1722 struct partial_symtab *psymtab; 1723 1724 /* We don't want to print anything for this objfile until we 1725 actually find a symtab whose name matches. */ 1726 int printed_objfile_start = 0; 1727 1728 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab) 1729 { 1730 QUIT; 1731 1732 if (! regexp 1733 || re_exec (psymtab->filename)) 1734 { 1735 if (! printed_objfile_start) 1736 { 1737 printf_filtered ("{ objfile %s ", objfile->name); 1738 wrap_here (" "); 1739 printf_filtered ("((struct objfile *) %s)\n", 1740 host_address_to_string (objfile)); 1741 printed_objfile_start = 1; 1742 } 1743 1744 printf_filtered (" { psymtab %s ", psymtab->filename); 1745 wrap_here (" "); 1746 printf_filtered ("((struct partial_symtab *) %s)\n", 1747 host_address_to_string (psymtab)); 1748 1749 printf_filtered (" readin %s\n", 1750 psymtab->readin ? "yes" : "no"); 1751 printf_filtered (" fullname %s\n", 1752 psymtab->fullname 1753 ? psymtab->fullname : "(null)"); 1754 printf_filtered (" text addresses "); 1755 fputs_filtered (paddress (gdbarch, psymtab->textlow), 1756 gdb_stdout); 1757 printf_filtered (" -- "); 1758 fputs_filtered (paddress (gdbarch, psymtab->texthigh), 1759 gdb_stdout); 1760 printf_filtered ("\n"); 1761 printf_filtered (" globals "); 1762 if (psymtab->n_global_syms) 1763 { 1764 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n", 1765 host_address_to_string (psymtab->objfile->global_psymbols.list 1766 + psymtab->globals_offset), 1767 psymtab->n_global_syms); 1768 } 1769 else 1770 printf_filtered ("(none)\n"); 1771 printf_filtered (" statics "); 1772 if (psymtab->n_static_syms) 1773 { 1774 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n", 1775 host_address_to_string (psymtab->objfile->static_psymbols.list 1776 + psymtab->statics_offset), 1777 psymtab->n_static_syms); 1778 } 1779 else 1780 printf_filtered ("(none)\n"); 1781 printf_filtered (" dependencies "); 1782 if (psymtab->number_of_dependencies) 1783 { 1784 int i; 1785 1786 printf_filtered ("{\n"); 1787 for (i = 0; i < psymtab->number_of_dependencies; i++) 1788 { 1789 struct partial_symtab *dep = psymtab->dependencies[i]; 1790 1791 /* Note the string concatenation there --- no comma. */ 1792 printf_filtered (" psymtab %s " 1793 "((struct partial_symtab *) %s)\n", 1794 dep->filename, 1795 host_address_to_string (dep)); 1796 } 1797 printf_filtered (" }\n"); 1798 } 1799 else 1800 printf_filtered ("(none)\n"); 1801 printf_filtered (" }\n"); 1802 } 1803 } 1804 1805 if (printed_objfile_start) 1806 printf_filtered ("}\n"); 1807 } 1808} 1809 1810/* Check consistency of psymtabs and symtabs. */ 1811 1812void 1813maintenance_check_symtabs (char *ignore, int from_tty) 1814{ 1815 struct symbol *sym; 1816 struct partial_symbol **psym; 1817 struct symtab *s = NULL; 1818 struct partial_symtab *ps; 1819 struct blockvector *bv; 1820 struct objfile *objfile; 1821 struct block *b; 1822 int length; 1823 1824 ALL_PSYMTABS (objfile, ps) 1825 { 1826 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1827 1828 s = PSYMTAB_TO_SYMTAB (ps); 1829 if (s == NULL) 1830 continue; 1831 bv = BLOCKVECTOR (s); 1832 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); 1833 psym = ps->objfile->static_psymbols.list + ps->statics_offset; 1834 length = ps->n_static_syms; 1835 while (length--) 1836 { 1837 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym), 1838 SYMBOL_DOMAIN (*psym)); 1839 if (!sym) 1840 { 1841 printf_filtered ("Static symbol `"); 1842 puts_filtered (SYMBOL_LINKAGE_NAME (*psym)); 1843 printf_filtered ("' only found in "); 1844 puts_filtered (ps->filename); 1845 printf_filtered (" psymtab\n"); 1846 } 1847 psym++; 1848 } 1849 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1850 psym = ps->objfile->global_psymbols.list + ps->globals_offset; 1851 length = ps->n_global_syms; 1852 while (length--) 1853 { 1854 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym), 1855 SYMBOL_DOMAIN (*psym)); 1856 if (!sym) 1857 { 1858 printf_filtered ("Global symbol `"); 1859 puts_filtered (SYMBOL_LINKAGE_NAME (*psym)); 1860 printf_filtered ("' only found in "); 1861 puts_filtered (ps->filename); 1862 printf_filtered (" psymtab\n"); 1863 } 1864 psym++; 1865 } 1866 if (ps->texthigh < ps->textlow) 1867 { 1868 printf_filtered ("Psymtab "); 1869 puts_filtered (ps->filename); 1870 printf_filtered (" covers bad range "); 1871 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout); 1872 printf_filtered (" - "); 1873 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout); 1874 printf_filtered ("\n"); 1875 continue; 1876 } 1877 if (ps->texthigh == 0) 1878 continue; 1879 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)) 1880 { 1881 printf_filtered ("Psymtab "); 1882 puts_filtered (ps->filename); 1883 printf_filtered (" covers "); 1884 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout); 1885 printf_filtered (" - "); 1886 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout); 1887 printf_filtered (" but symtab covers only "); 1888 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout); 1889 printf_filtered (" - "); 1890 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout); 1891 printf_filtered ("\n"); 1892 } 1893 } 1894} 1895 1896 1897 1898void 1899expand_partial_symbol_names (int (*fun) (const char *, void *), void *data) 1900{ 1901 struct objfile *objfile; 1902 1903 ALL_OBJFILES (objfile) 1904 { 1905 if (objfile->sf) 1906 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun, 1907 ALL_DOMAIN, data); 1908 } 1909} 1910 1911void 1912map_partial_symbol_filenames (void (*fun) (const char *, const char *, 1913 void *), 1914 void *data) 1915{ 1916 struct objfile *objfile; 1917 1918 ALL_OBJFILES (objfile) 1919 { 1920 if (objfile->sf) 1921 objfile->sf->qf->map_symbol_filenames (objfile, fun, data); 1922 } 1923} 1924