1 /* Partial symbol tables.
3 Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
24 #include "gdb_assert.h"
26 #include "filenames.h"
33 #include "readline/readline.h"
34 #include "gdb_regex.h"
35 #include "dictionary.h"
37 #include "cp-support.h"
40 #define DEV_TTY "/dev/tty"
45 struct bcache *bcache;
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))
52 static struct partial_symbol *match_partial_symbol (struct partial_symtab *,
54 const char *, domain_enum,
55 symbol_compare_ftype *,
56 symbol_compare_ftype *);
58 static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
62 static char *psymtab_to_fullname (struct partial_symtab *ps);
64 static struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
66 struct obj_section *);
68 static struct partial_symbol *fixup_psymbol_section (struct partial_symbol
70 struct objfile *objfile);
72 static struct symtab *psymtab_to_symtab (struct partial_symtab *pst);
74 /* Ensure that the partial symbols for OBJFILE have been loaded. This
75 function always returns its argument, as a convenience. */
78 require_partial_symbols (struct objfile *objfile, int verbose)
80 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
82 objfile->flags |= OBJF_PSYMTABS_READ;
84 if (objfile->sf->sym_read_psymbols)
88 printf_unfiltered (_("Reading symbols from %s..."),
90 gdb_flush (gdb_stdout);
92 (*objfile->sf->sym_read_psymbols) (objfile);
95 if (!objfile_has_symbols (objfile))
98 printf_unfiltered (_("(no debugging symbols found)..."));
102 printf_unfiltered (_("done.\n"));
110 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
113 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
114 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
118 /* We want to make sure this file always requires psymtabs. */
120 #undef ALL_OBJFILE_PSYMTABS
122 /* Traverse all psymtabs in all objfiles. */
124 #define ALL_PSYMTABS(objfile, p) \
125 ALL_OBJFILES (objfile) \
126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
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. */
132 static struct partial_symtab *
133 lookup_partial_symtab (struct objfile *objfile, const char *name,
134 const char *full_path, const char *real_path)
136 struct partial_symtab *pst;
138 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
140 if (FILENAME_CMP (name, pst->filename) == 0)
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)
149 psymtab_to_fullname (pst);
150 if (pst->fullname != NULL
151 && FILENAME_CMP (full_path, pst->fullname) == 0)
157 if (real_path != NULL)
160 psymtab_to_fullname (pst);
161 if (pst->fullname != NULL)
163 rp = gdb_realpath (pst->fullname);
164 make_cleanup (xfree, rp);
166 if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
173 /* Now, search for a matching tail (only if name doesn't have any dirs). */
175 if (lbasename (name) == name)
176 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
178 if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
186 lookup_symtab_via_partial_symtab (struct objfile *objfile, const char *name,
187 const char *full_path, const char *real_path,
188 struct symtab **result)
190 struct partial_symtab *ps;
192 ps = lookup_partial_symtab (objfile, name, full_path, real_path);
197 error (_("Internal: readin %s pst for `%s' found when no symtab found."),
200 *result = PSYMTAB_TO_SYMTAB (ps);
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. */
207 static struct partial_symtab *
208 find_pc_sect_psymtab_closer (CORE_ADDR pc, struct obj_section *section,
209 struct partial_symtab *pst,
210 struct minimal_symbol *msymbol)
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;
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. */
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)
237 if (pc >= tpst->textlow && pc < tpst->texthigh)
239 struct partial_symbol *p;
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);
248 && SYMBOL_VALUE_ADDRESS (p)
249 == SYMBOL_VALUE_ADDRESS (msymbol))
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). */
257 this_addr = SYMBOL_VALUE_ADDRESS (p);
259 this_addr = tpst->textlow;
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
271 if (this_addr > best_addr)
273 best_addr = this_addr;
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. */
285 static struct partial_symtab *
286 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
287 struct obj_section *section,
288 struct minimal_symbol *msymbol)
290 struct partial_symtab *pst;
292 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
293 than the later used TEXTLOW/TEXTHIGH one. */
295 if (objfile->psymtabs_addrmap != NULL)
297 pst = addrmap_find (objfile->psymtabs_addrmap, pc);
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)
305 struct partial_symbol *p;
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);
313 || SYMBOL_VALUE_ADDRESS (p)
314 != SYMBOL_VALUE_ADDRESS (msymbol))
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
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
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. */
339 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
340 if (pc >= pst->textlow && pc < pst->texthigh)
342 struct partial_symtab *best_pst;
344 best_pst = find_pc_sect_psymtab_closer (pc, section, pst, msymbol);
345 if (best_pst != NULL)
352 static struct symtab *
353 find_pc_sect_symtab_from_partial (struct objfile *objfile,
354 struct minimal_symbol *msymbol,
355 CORE_ADDR pc, struct obj_section *section,
358 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
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. */
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);
374 /* Find which partial symbol within a psymtab matches PC and SECTION.
377 static struct partial_symbol *
378 find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
379 struct obj_section *section)
381 struct partial_symbol *best = NULL, *p, **pp;
384 gdb_assert (psymtab != NULL);
386 /* Cope with programs that start at address 0. */
387 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
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);
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)))
405 if (section) /* Match on a specific section. */
407 fixup_psymbol_section (p, psymtab->objfile);
408 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
411 best_pc = SYMBOL_VALUE_ADDRESS (p);
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);
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)))
429 if (section) /* Match on a specific section. */
431 fixup_psymbol_section (p, psymtab->objfile);
432 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
435 best_pc = SYMBOL_VALUE_ADDRESS (p);
443 static struct partial_symbol *
444 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
451 if (SYMBOL_OBJ_SECTION (psym))
454 gdb_assert (objfile);
456 switch (SYMBOL_CLASS (psym))
461 addr = SYMBOL_VALUE_ADDRESS (psym);
464 /* Nothing else will be listed in the minsyms -- no use looking
469 fixup_section (&psym->ginfo, addr, objfile);
474 static struct symtab *
475 lookup_symbol_aux_psymtabs (struct objfile *objfile,
476 int block_index, const char *name,
477 const domain_enum domain)
479 struct partial_symtab *ps;
480 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
482 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
484 if (!ps->readin && lookup_partial_symbol (ps, name, psymtab_index, domain))
486 struct symbol *sym = NULL;
487 struct symtab *stab = PSYMTAB_TO_SYMTAB (ps);
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). */
494 struct blockvector *bv = BLOCKVECTOR (stab);
495 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
497 sym = lookup_block_symbol (block, name, domain);
500 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
503 /* Keep looking through other psymtabs. */
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. */
518 static struct partial_symbol *
519 match_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)
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;
532 pst->objfile->global_psymbols.list + pst->globals_offset :
533 pst->objfile->static_psymbols.list + pst->statics_offset);
535 if (global && ordered_compare) /* Can use a binary search. */
537 do_linear_search = 0;
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
546 top = start + length - 1;
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)
560 gdb_assert (top == bottom);
562 while (top <= real_top
563 && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
565 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
566 SYMBOL_DOMAIN (*top), domain))
572 /* Can't use a binary search or else we found during the binary search that
573 we should also do a linear search. */
575 if (do_linear_search)
577 for (psym = start; psym < start + length; psym++)
579 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
580 SYMBOL_DOMAIN (*psym), domain)
581 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
590 pre_expand_symtabs_matching_psymtabs (struct objfile *objfile,
591 int kind, const char *name,
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
603 The caller is responsible for freeing the return result. */
606 psymtab_search_name (const char *name)
608 switch (current_language->la_language)
613 if (strchr (name, '('))
615 char *ret = cp_remove_params (name);
627 return xstrdup (name);
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. */
633 static struct partial_symbol *
634 lookup_partial_symbol (struct partial_symtab *pst, const char *name,
635 int global, domain_enum domain)
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;
642 struct cleanup *cleanup;
649 search_name = psymtab_search_name (name);
650 cleanup = make_cleanup (xfree, search_name);
652 pst->objfile->global_psymbols.list + pst->globals_offset :
653 pst->objfile->static_psymbols.list + pst->statics_offset);
655 if (global) /* This means we can use a binary search. */
657 do_linear_search = 0;
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
666 top = start + length - 1;
670 center = bottom + (top - bottom) / 2;
672 internal_error (__FILE__, __LINE__,
673 _("failed internal consistency check"));
674 if (!do_linear_search
675 && SYMBOL_LANGUAGE (*center) == language_java)
677 do_linear_search = 1;
679 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
689 if (!(top == bottom))
690 internal_error (__FILE__, __LINE__,
691 _("failed internal consistency check"));
693 while (top <= real_top
694 && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
696 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
697 SYMBOL_DOMAIN (*top), domain))
699 do_cleanups (cleanup);
706 /* Can't use a binary search or else we found during the binary search that
707 we should also do a linear search. */
709 if (do_linear_search)
711 for (psym = start; psym < start + length; psym++)
713 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
714 SYMBOL_DOMAIN (*psym), domain)
715 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
717 do_cleanups (cleanup);
723 do_cleanups (cleanup);
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
732 static struct symtab *
733 psymtab_to_symtab (struct partial_symtab *pst)
735 /* If it's been looked up before, return it. */
739 /* If it has not yet been read in, read it. */
742 struct cleanup *back_to = increment_reading_symtab ();
744 (*pst->read_symtab) (pst);
745 do_cleanups (back_to);
752 relocate_psymtabs (struct objfile *objfile,
753 struct section_offsets *new_offsets,
754 struct section_offsets *delta)
756 struct partial_symbol **psym;
757 struct partial_symtab *p;
759 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
761 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
762 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
765 for (psym = objfile->global_psymbols.list;
766 psym < objfile->global_psymbols.next;
769 fixup_psymbol_section (*psym, objfile);
770 if (SYMBOL_SECTION (*psym) >= 0)
771 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
772 SYMBOL_SECTION (*psym));
774 for (psym = objfile->static_psymbols.list;
775 psym < objfile->static_psymbols.next;
778 fixup_psymbol_section (*psym, objfile);
779 if (SYMBOL_SECTION (*psym) >= 0)
780 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
781 SYMBOL_SECTION (*psym));
785 static struct symtab *
786 find_last_source_symtab_from_partial (struct objfile *ofp)
788 struct partial_symtab *ps;
789 struct partial_symtab *cs_pst = 0;
791 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
793 const char *name = ps->filename;
794 int len = strlen (name);
796 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
797 || strcmp (name, "<<C++-namespaces>>") == 0)))
805 internal_error (__FILE__, __LINE__,
806 _("select_source_symtab: "
807 "readin pst found and no symtabs."));
810 return PSYMTAB_TO_SYMTAB (cs_pst);
816 forget_cached_source_info_partial (struct objfile *objfile)
818 struct partial_symtab *pst;
820 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
822 if (pst->fullname != NULL)
824 xfree (pst->fullname);
825 pst->fullname = NULL;
831 print_partial_symbols (struct gdbarch *gdbarch,
832 struct partial_symbol **p, int count, char *what,
833 struct ui_file *outfile)
835 fprintf_filtered (outfile, " %s partial symbols:\n", what);
838 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
839 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
841 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
843 fputs_filtered (", ", outfile);
844 switch (SYMBOL_DOMAIN (*p))
847 fputs_filtered ("undefined domain, ", outfile);
850 /* This is the usual thing -- don't print it. */
853 fputs_filtered ("struct domain, ", outfile);
856 fputs_filtered ("label domain, ", outfile);
859 fputs_filtered ("<invalid domain>, ", outfile);
862 switch (SYMBOL_CLASS (*p))
865 fputs_filtered ("undefined", outfile);
868 fputs_filtered ("constant int", outfile);
871 fputs_filtered ("static", outfile);
874 fputs_filtered ("register", outfile);
877 fputs_filtered ("pass by value", outfile);
880 fputs_filtered ("pass by reference", outfile);
882 case LOC_REGPARM_ADDR:
883 fputs_filtered ("register address parameter", outfile);
886 fputs_filtered ("stack parameter", outfile);
889 fputs_filtered ("type", outfile);
892 fputs_filtered ("label", outfile);
895 fputs_filtered ("function", outfile);
897 case LOC_CONST_BYTES:
898 fputs_filtered ("constant bytes", outfile);
901 fputs_filtered ("unresolved", outfile);
903 case LOC_OPTIMIZED_OUT:
904 fputs_filtered ("optimized out", outfile);
907 fputs_filtered ("computed at runtime", outfile);
910 fputs_filtered ("<invalid location>", outfile);
913 fputs_filtered (", ", outfile);
914 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
915 fprintf_filtered (outfile, "\n");
921 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
922 struct ui_file *outfile)
924 struct gdbarch *gdbarch = get_objfile_arch (objfile);
927 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
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 (",
934 gdb_print_host_address (objfile, outfile);
935 fprintf_unfiltered (outfile, ")\n");
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");
947 fprintf_filtered (outfile, " Relocate symbols by ");
948 for (i = 0; i < psymtab->objfile->num_sections; ++i)
951 fprintf_filtered (outfile, ", ");
953 fputs_filtered (paddress (gdbarch,
954 ANOFFSET (psymtab->section_offsets, i)),
957 fprintf_filtered (outfile, "\n");
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++)
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);
973 if (psymtab->n_global_syms > 0)
975 print_partial_symbols (gdbarch,
976 objfile->global_psymbols.list
977 + psymtab->globals_offset,
978 psymtab->n_global_syms, "Global", outfile);
980 if (psymtab->n_static_syms > 0)
982 print_partial_symbols (gdbarch,
983 objfile->static_psymbols.list
984 + psymtab->statics_offset,
985 psymtab->n_static_syms, "Static", outfile);
987 fprintf_filtered (outfile, "\n");
991 print_psymtab_stats_for_objfile (struct objfile *objfile)
994 struct partial_symtab *ps;
997 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1002 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1006 dump_psymtabs_for_objfile (struct objfile *objfile)
1008 struct partial_symtab *psymtab;
1010 if (objfile->psymtabs)
1012 printf_filtered ("Psymtabs:\n");
1013 for (psymtab = objfile->psymtabs;
1015 psymtab = psymtab->next)
1017 printf_filtered ("%s at ",
1019 gdb_print_host_address (psymtab, gdb_stdout);
1020 printf_filtered (", ");
1021 if (psymtab->objfile != objfile)
1023 printf_filtered ("NOT ON CHAIN! ");
1027 printf_filtered ("\n\n");
1031 /* Look through the partial symtabs for all symbols which begin
1032 by matching FUNC_NAME. Make sure we read that symbol table in. */
1035 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1037 struct partial_symtab *ps;
1039 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1044 if ((lookup_partial_symbol (ps, func_name, 1, VAR_DOMAIN)
1046 || (lookup_partial_symbol (ps, func_name, 0, VAR_DOMAIN)
1048 psymtab_to_symtab (ps);
1053 expand_partial_symbol_tables (struct objfile *objfile)
1055 struct partial_symtab *psymtab;
1057 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1059 psymtab_to_symtab (psymtab);
1064 read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
1066 struct partial_symtab *p;
1068 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1070 if (filename_cmp (filename, p->filename) == 0)
1071 PSYMTAB_TO_SYMTAB (p);
1076 map_symbol_filenames_psymtab (struct objfile *objfile,
1077 void (*fun) (const char *, const char *,
1081 struct partial_symtab *ps;
1083 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1085 const char *fullname;
1090 fullname = psymtab_to_fullname (ps);
1091 (*fun) (ps->filename, fullname, data);
1095 int find_and_open_source (const char *filename,
1096 const char *dirname,
1099 /* Finds the fullname that a partial_symtab represents.
1101 If this functions finds the fullname, it will save it in ps->fullname
1102 and it will also return the value.
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. */
1107 psymtab_to_fullname (struct partial_symtab *ps)
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);
1121 return ps->fullname;
1128 find_symbol_file_from_partial (struct objfile *objfile, const char *name)
1130 struct partial_symtab *pst;
1132 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1134 if (lookup_partial_symbol (pst, name, 1, VAR_DOMAIN))
1135 return pst->filename;
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. */
1146 map_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)
1151 struct dict_iterator iter;
1154 for (sym = dict_iter_match_first (BLOCK_DICT (block), name, match, &iter);
1155 sym != NULL; sym = dict_iter_match_next (name, match, &iter))
1157 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1158 SYMBOL_DOMAIN (sym), namespace))
1160 if (callback (block, sym, data))
1168 /* Psymtab version of map_matching_symbols. See its definition in
1169 the definition of quick_symbol_functions in symfile.h. */
1172 map_matching_symbols_psymtab (const char *name, domain_enum namespace,
1173 struct objfile *objfile, int global,
1174 int (*callback) (struct block *,
1175 struct symbol *, void *),
1177 symbol_compare_ftype *match,
1178 symbol_compare_ftype *ordered_compare)
1180 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1181 struct partial_symtab *ps;
1183 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1187 || match_partial_symbol (ps, global, name, namespace, match,
1190 struct symtab *s = PSYMTAB_TO_SYMTAB (ps);
1191 struct block *block;
1193 if (s == NULL || !s->primary)
1195 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1196 if (map_block (name, namespace, objfile, block,
1197 callback, data, match))
1199 if (callback (block, NULL, data))
1206 expand_symtabs_matching_via_partial (struct objfile *objfile,
1207 int (*file_matcher) (const char *,
1209 int (*name_matcher) (const char *,
1214 struct partial_symtab *ps;
1216 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1218 struct partial_symbol **psym;
1219 struct partial_symbol **bound, **gbound, **sbound;
1225 if (file_matcher && ! (*file_matcher) (ps->filename, data))
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;
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;
1241 if (bound == gbound && ps->n_static_syms != 0)
1243 psym = objfile->static_psymbols.list + ps->statics_offset;
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))
1264 PSYMTAB_TO_SYMTAB (ps);
1274 objfile_has_psyms (struct objfile *objfile)
1276 return objfile->psymtabs != NULL;
1279 const struct quick_symbol_functions psym_functions =
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,
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
1302 /* This compares two partial symbols by names, using strcmp_iw_ordered
1303 for the comparison. */
1306 compare_psymbols (const void *s1p, const void *s2p)
1308 struct partial_symbol *const *s1 = s1p;
1309 struct partial_symbol *const *s2 = s2p;
1311 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1312 SYMBOL_SEARCH_NAME (*s2));
1316 sort_pst_symbols (struct partial_symtab *pst)
1318 /* Sort the global list; don't sort the static list. */
1320 qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
1321 pst->n_global_syms, sizeof (struct partial_symbol *),
1325 /* Allocate and partially fill a partial symtab. It will be
1326 completely filled at the end of the symbol list.
1328 FILENAME is the name of the symbol-file we are reading from. */
1330 struct partial_symtab *
1331 start_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)
1337 struct partial_symtab *psymtab;
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;
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. */
1353 static unsigned long
1354 psymbol_hash (const void *addr, int length)
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);
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);
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. */
1376 psymbol_compare (const void *addr1, const void *addr2, int length)
1378 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1379 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
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);
1389 /* Initialize a partial symbol bcache. */
1391 struct psymbol_bcache *
1392 psymbol_bcache_init (void)
1394 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1395 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1399 /* Free a partial symbol bcache. */
1401 psymbol_bcache_free (struct psymbol_bcache *bcache)
1406 bcache_xfree (bcache->bcache);
1410 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1413 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1415 return bcache->bcache;
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. */
1423 static const struct partial_symbol *
1424 psymbol_bcache_full (struct partial_symbol *sym,
1425 struct psymbol_bcache *bcache,
1428 return bcache_full (sym,
1429 sizeof (struct partial_symbol),
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. */
1440 static const struct partial_symbol *
1441 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
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,
1449 struct partial_symbol psymbol;
1451 /* We must ensure that the entire 'value' field has been zeroed
1452 before assigning to it, because an assignment may not write the
1454 memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
1456 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1459 SYMBOL_VALUE (&psymbol) = val;
1463 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
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;
1471 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1473 /* Stash the partial symbol away in the cache. */
1474 return psymbol_bcache_full (&psymbol,
1475 objfile->psymbol_cache,
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(). */
1484 extend_psymbol_list (struct psymbol_allocation_list *listp,
1485 struct objfile *objfile)
1489 if (listp->size == 0)
1492 listp->list = (struct partial_symbol **)
1493 xmalloc (new_size * sizeof (struct partial_symbol *));
1497 new_size = listp->size * 2;
1498 listp->list = (struct partial_symbol **)
1499 xrealloc ((char *) listp->list,
1500 new_size * sizeof (struct partial_symbol *));
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;
1508 /* Helper function, adds partial symbol to the given partial symbol
1512 append_psymbol_to_list (struct psymbol_allocation_list *list,
1513 const struct partial_symbol *psym,
1514 struct objfile *objfile)
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++);
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. */
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
1537 const struct partial_symbol *
1538 add_psymbol_to_list (const char *name, int namelength, int copy_name,
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)
1546 const struct partial_symbol *psym;
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);
1554 /* Do not duplicate global partial symbols. */
1555 if (list == &objfile->global_psymbols
1559 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1560 append_psymbol_to_list (list, psym, objfile);
1564 /* Initialize storage for partial symbols. */
1567 init_psymbol_list (struct objfile *objfile, int total_symbols)
1569 /* Free any previously allocated psymbol lists. */
1571 if (objfile->global_psymbols.list)
1573 xfree (objfile->global_psymbols.list);
1575 if (objfile->static_psymbols.list)
1577 xfree (objfile->static_psymbols.list);
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. */
1584 objfile->global_psymbols.size = total_symbols / 10;
1585 objfile->static_psymbols.size = total_symbols / 10;
1587 if (objfile->global_psymbols.size > 0)
1589 objfile->global_psymbols.next =
1590 objfile->global_psymbols.list = (struct partial_symbol **)
1591 xmalloc ((objfile->global_psymbols.size
1592 * sizeof (struct partial_symbol *)));
1594 if (objfile->static_psymbols.size > 0)
1596 objfile->static_psymbols.next =
1597 objfile->static_psymbols.list = (struct partial_symbol **)
1598 xmalloc ((objfile->static_psymbols.size
1599 * sizeof (struct partial_symbol *)));
1603 struct partial_symtab *
1604 allocate_psymtab (const char *filename, struct objfile *objfile)
1606 struct partial_symtab *psymtab;
1608 if (objfile->free_psymtabs)
1610 psymtab = objfile->free_psymtabs;
1611 objfile->free_psymtabs = psymtab->next;
1614 psymtab = (struct partial_symtab *)
1615 obstack_alloc (&objfile->objfile_obstack,
1616 sizeof (struct partial_symtab));
1618 memset (psymtab, 0, sizeof (struct partial_symtab));
1619 psymtab->filename = obsavestring (filename, strlen (filename),
1620 &objfile->objfile_obstack);
1621 psymtab->symtab = NULL;
1623 /* Prepend it to the psymtab list for the objfile it belongs to.
1624 Psymtabs are searched in most recent inserted -> least recent
1627 psymtab->objfile = objfile;
1628 psymtab->next = objfile->psymtabs;
1629 objfile->psymtabs = psymtab;
1635 discard_psymtab (struct partial_symtab *pst)
1637 struct partial_symtab **prev_pst;
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. */
1646 /* First, snip it out of the psymtab chain. */
1648 prev_pst = &(pst->objfile->psymtabs);
1649 while ((*prev_pst) != pst)
1650 prev_pst = &((*prev_pst)->next);
1651 (*prev_pst) = pst->next;
1653 /* Next, put it on a free list for recycling. */
1655 pst->next = pst->objfile->free_psymtabs;
1656 pst->objfile->free_psymtabs = pst;
1662 maintenance_print_psymbols (char *args, int from_tty)
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;
1677 print-psymbols takes an output file name and optional symbol file name"));
1679 argv = gdb_buildargv (args);
1680 cleanups = make_cleanup_freeargv (argv);
1682 if (argv[0] != NULL)
1685 /* If a second arg is supplied, it is a source file name to match on. */
1686 if (argv[1] != NULL)
1692 filename = tilde_expand (filename);
1693 make_cleanup (xfree, filename);
1695 outfile = gdb_fopen (filename, FOPEN_WT);
1697 perror_with_name (filename);
1698 make_cleanup_ui_file_delete (outfile);
1701 ALL_PSYMTABS (objfile, ps)
1702 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1703 dump_psymtab (objfile, ps, outfile);
1705 do_cleanups (cleanups);
1708 /* List all the partial symbol tables whose names match REGEXP (optional). */
1710 maintenance_info_psymtabs (char *regexp, int from_tty)
1712 struct program_space *pspace;
1713 struct objfile *objfile;
1718 ALL_PSPACES (pspace)
1719 ALL_PSPACE_OBJFILES (pspace, objfile)
1721 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1722 struct partial_symtab *psymtab;
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;
1728 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1733 || re_exec (psymtab->filename))
1735 if (! printed_objfile_start)
1737 printf_filtered ("{ objfile %s ", objfile->name);
1739 printf_filtered ("((struct objfile *) %s)\n",
1740 host_address_to_string (objfile));
1741 printed_objfile_start = 1;
1744 printf_filtered (" { psymtab %s ", psymtab->filename);
1746 printf_filtered ("((struct partial_symtab *) %s)\n",
1747 host_address_to_string (psymtab));
1749 printf_filtered (" readin %s\n",
1750 psymtab->readin ? "yes" : "no");
1751 printf_filtered (" fullname %s\n",
1753 ? psymtab->fullname : "(null)");
1754 printf_filtered (" text addresses ");
1755 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1757 printf_filtered (" -- ");
1758 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1760 printf_filtered ("\n");
1761 printf_filtered (" globals ");
1762 if (psymtab->n_global_syms)
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);
1770 printf_filtered ("(none)\n");
1771 printf_filtered (" statics ");
1772 if (psymtab->n_static_syms)
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);
1780 printf_filtered ("(none)\n");
1781 printf_filtered (" dependencies ");
1782 if (psymtab->number_of_dependencies)
1786 printf_filtered ("{\n");
1787 for (i = 0; i < psymtab->number_of_dependencies; i++)
1789 struct partial_symtab *dep = psymtab->dependencies[i];
1791 /* Note the string concatenation there --- no comma. */
1792 printf_filtered (" psymtab %s "
1793 "((struct partial_symtab *) %s)\n",
1795 host_address_to_string (dep));
1797 printf_filtered (" }\n");
1800 printf_filtered ("(none)\n");
1801 printf_filtered (" }\n");
1805 if (printed_objfile_start)
1806 printf_filtered ("}\n");
1810 /* Check consistency of psymtabs and symtabs. */
1813 maintenance_check_symtabs (char *ignore, int from_tty)
1816 struct partial_symbol **psym;
1817 struct symtab *s = NULL;
1818 struct partial_symtab *ps;
1819 struct blockvector *bv;
1820 struct objfile *objfile;
1824 ALL_PSYMTABS (objfile, ps)
1826 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1828 s = PSYMTAB_TO_SYMTAB (ps);
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;
1837 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1838 SYMBOL_DOMAIN (*psym));
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");
1849 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1850 psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1851 length = ps->n_global_syms;
1854 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1855 SYMBOL_DOMAIN (*psym));
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");
1866 if (ps->texthigh < ps->textlow)
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");
1877 if (ps->texthigh == 0)
1879 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
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");
1899 expand_partial_symbol_names (int (*fun) (const char *, void *), void *data)
1901 struct objfile *objfile;
1903 ALL_OBJFILES (objfile)
1906 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
1912 map_partial_symbol_filenames (void (*fun) (const char *, const char *,
1916 struct objfile *objfile;
1918 ALL_OBJFILES (objfile)
1921 objfile->sf->qf->map_symbol_filenames (objfile, fun, data);