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