1 /* Partial symbol tables.
3 Copyright (C) 2009-2015 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/>. */
25 #include "filenames.h"
32 #include "readline/readline.h"
33 #include "gdb_regex.h"
34 #include "dictionary.h"
36 #include "cp-support.h"
40 #define DEV_TTY "/dev/tty"
45 struct bcache *bcache;
48 static struct partial_symbol *match_partial_symbol (struct objfile *,
49 struct partial_symtab *,
51 const char *, domain_enum,
52 symbol_compare_ftype *,
53 symbol_compare_ftype *);
55 static struct partial_symbol *lookup_partial_symbol (struct objfile *,
56 struct partial_symtab *,
60 static const char *psymtab_to_fullname (struct partial_symtab *ps);
62 static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
63 struct partial_symtab *,
65 struct obj_section *);
67 static void fixup_psymbol_section (struct partial_symbol *psym,
68 struct objfile *objfile);
70 static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
71 struct partial_symtab *pst);
73 /* Ensure that the partial symbols for OBJFILE have been loaded. This
74 function always returns its argument, as a convenience. */
77 require_partial_symbols (struct objfile *objfile, int verbose)
79 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
81 objfile->flags |= OBJF_PSYMTABS_READ;
83 if (objfile->sf->sym_read_psymbols)
87 printf_unfiltered (_("Reading symbols from %s..."),
88 objfile_name (objfile));
89 gdb_flush (gdb_stdout);
91 (*objfile->sf->sym_read_psymbols) (objfile);
94 if (!objfile_has_symbols (objfile))
97 printf_unfiltered (_("(no debugging symbols found)..."));
101 printf_unfiltered (_("done.\n"));
109 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
112 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
113 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
117 /* We want to make sure this file always requires psymtabs. */
119 #undef ALL_OBJFILE_PSYMTABS
121 /* Traverse all psymtabs in all objfiles. */
123 #define ALL_PSYMTABS(objfile, p) \
124 ALL_OBJFILES (objfile) \
125 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
127 /* Helper function for psym_map_symtabs_matching_filename that
128 expands the symtabs and calls the iterator. */
131 partial_map_expand_apply (struct objfile *objfile,
133 const char *real_path,
134 struct partial_symtab *pst,
135 int (*callback) (struct symtab *, void *),
138 struct compunit_symtab *last_made = objfile->compunit_symtabs;
140 /* Shared psymtabs should never be seen here. Instead they should
141 be handled properly by the caller. */
142 gdb_assert (pst->user == NULL);
144 /* Don't visit already-expanded psymtabs. */
148 /* This may expand more than one symtab, and we want to iterate over
150 psymtab_to_symtab (objfile, pst);
152 return iterate_over_some_symtabs (name, real_path, callback, data,
153 objfile->compunit_symtabs, last_made);
156 /* Psymtab version of map_symtabs_matching_filename. See its definition in
157 the definition of quick_symbol_functions in symfile.h. */
160 psym_map_symtabs_matching_filename (struct objfile *objfile,
162 const char *real_path,
163 int (*callback) (struct symtab *,
167 struct partial_symtab *pst;
168 const char *name_basename = lbasename (name);
170 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
172 /* We can skip shared psymtabs here, because any file name will be
173 attached to the unshared psymtab. */
174 if (pst->user != NULL)
177 /* Anonymous psymtabs don't have a file name. */
181 if (compare_filenames_for_search (pst->filename, name))
183 if (partial_map_expand_apply (objfile, name, real_path,
184 pst, callback, data))
189 /* Before we invoke realpath, which can get expensive when many
190 files are involved, do a quick comparison of the basenames. */
191 if (! basenames_may_differ
192 && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
195 if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
197 if (partial_map_expand_apply (objfile, name, real_path,
198 pst, callback, data))
203 /* If the user gave us an absolute path, try to find the file in
204 this symtab and use its absolute path. */
205 if (real_path != NULL)
207 gdb_assert (IS_ABSOLUTE_PATH (real_path));
208 gdb_assert (IS_ABSOLUTE_PATH (name));
209 if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
211 if (partial_map_expand_apply (objfile, name, real_path,
212 pst, callback, data))
222 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
223 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
225 static struct partial_symtab *
226 find_pc_sect_psymtab_closer (struct objfile *objfile,
227 CORE_ADDR pc, struct obj_section *section,
228 struct partial_symtab *pst,
229 struct bound_minimal_symbol msymbol)
231 struct partial_symtab *tpst;
232 struct partial_symtab *best_pst = pst;
233 CORE_ADDR best_addr = pst->textlow;
235 gdb_assert (!pst->psymtabs_addrmap_supported);
237 /* An objfile that has its functions reordered might have
238 many partial symbol tables containing the PC, but
239 we want the partial symbol table that contains the
240 function containing the PC. */
241 if (!(objfile->flags & OBJF_REORDERED) &&
242 section == 0) /* Can't validate section this way. */
245 if (msymbol.minsym == NULL)
248 /* The code range of partial symtabs sometimes overlap, so, in
249 the loop below, we need to check all partial symtabs and
250 find the one that fits better for the given PC address. We
251 select the partial symtab that contains a symbol whose
252 address is closest to the PC address. By closest we mean
253 that find_pc_sect_symbol returns the symbol with address
254 that is closest and still less than the given PC. */
255 for (tpst = pst; tpst != NULL; tpst = tpst->next)
257 if (pc >= tpst->textlow && pc < tpst->texthigh)
259 struct partial_symbol *p;
262 /* NOTE: This assumes that every psymbol has a
263 corresponding msymbol, which is not necessarily
264 true; the debug info might be much richer than the
265 object's symbol table. */
266 p = find_pc_sect_psymbol (objfile, tpst, pc, section);
268 && SYMBOL_VALUE_ADDRESS (p)
269 == BMSYMBOL_VALUE_ADDRESS (msymbol))
272 /* Also accept the textlow value of a psymtab as a
273 "symbol", to provide some support for partial
274 symbol tables with line information but no debug
275 symbols (e.g. those produced by an assembler). */
277 this_addr = SYMBOL_VALUE_ADDRESS (p);
279 this_addr = tpst->textlow;
281 /* Check whether it is closer than our current
282 BEST_ADDR. Since this symbol address is
283 necessarily lower or equal to PC, the symbol closer
284 to PC is the symbol which address is the highest.
285 This way we return the psymtab which contains such
286 best match symbol. This can help in cases where the
287 symbol information/debuginfo is not complete, like
288 for instance on IRIX6 with gcc, where no debug info
289 is emitted for statics. (See also the nodebug.exp
291 if (this_addr > best_addr)
293 best_addr = this_addr;
301 /* Find which partial symtab contains PC and SECTION. Return 0 if
302 none. We return the psymtab that contains a symbol whose address
303 exactly matches PC, or, if we cannot find an exact match, the
304 psymtab that contains a symbol whose address is closest to PC. */
305 static struct partial_symtab *
306 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
307 struct obj_section *section,
308 struct bound_minimal_symbol msymbol)
310 struct partial_symtab *pst;
312 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
313 than the later used TEXTLOW/TEXTHIGH one. */
315 if (objfile->psymtabs_addrmap != NULL)
317 pst = addrmap_find (objfile->psymtabs_addrmap, pc);
320 /* FIXME: addrmaps currently do not handle overlayed sections,
321 so fall back to the non-addrmap case if we're debugging
322 overlays and the addrmap returned the wrong section. */
323 if (overlay_debugging && msymbol.minsym && section)
325 struct partial_symbol *p;
327 /* NOTE: This assumes that every psymbol has a
328 corresponding msymbol, which is not necessarily
329 true; the debug info might be much richer than the
330 object's symbol table. */
331 p = find_pc_sect_psymbol (objfile, pst, pc, section);
333 || SYMBOL_VALUE_ADDRESS (p)
334 != BMSYMBOL_VALUE_ADDRESS (msymbol))
338 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
339 PSYMTABS_ADDRMAP we used has already the best 1-byte
340 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
341 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
350 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
351 which still have no corresponding full SYMTABs read. But it is not
352 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
355 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
356 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
357 debug info type in single OBJFILE. */
359 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
360 if (!pst->psymtabs_addrmap_supported
361 && pc >= pst->textlow && pc < pst->texthigh)
363 struct partial_symtab *best_pst;
365 best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
367 if (best_pst != NULL)
374 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
375 the definition of quick_symbol_functions in symfile.h. */
377 static struct compunit_symtab *
378 psym_find_pc_sect_compunit_symtab (struct objfile *objfile,
379 struct bound_minimal_symbol msymbol,
381 struct obj_section *section,
384 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
388 if (warn_if_readin && ps->readin)
389 /* Might want to error() here (in case symtab is corrupt and
390 will cause a core dump), but maybe we can successfully
391 continue, so let's not. */
393 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
394 paddress (get_objfile_arch (objfile), pc));
395 psymtab_to_symtab (objfile, ps);
396 return ps->compunit_symtab;
401 /* Find which partial symbol within a psymtab matches PC and SECTION.
404 static struct partial_symbol *
405 find_pc_sect_psymbol (struct objfile *objfile,
406 struct partial_symtab *psymtab, CORE_ADDR pc,
407 struct obj_section *section)
409 struct partial_symbol *best = NULL, *p, **pp;
412 gdb_assert (psymtab != NULL);
414 /* Cope with programs that start at address 0. */
415 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
417 /* Search the global symbols as well as the static symbols, so that
418 find_pc_partial_function doesn't use a minimal symbol and thus
419 cache a bad endaddr. */
420 for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
421 (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
422 < psymtab->n_global_syms);
426 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
427 && PSYMBOL_CLASS (p) == LOC_BLOCK
428 && pc >= SYMBOL_VALUE_ADDRESS (p)
429 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
430 || (psymtab->textlow == 0
431 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
433 if (section) /* Match on a specific section. */
435 fixup_psymbol_section (p, objfile);
436 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
440 best_pc = SYMBOL_VALUE_ADDRESS (p);
445 for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
446 (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
447 < psymtab->n_static_syms);
451 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
452 && PSYMBOL_CLASS (p) == LOC_BLOCK
453 && pc >= SYMBOL_VALUE_ADDRESS (p)
454 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
455 || (psymtab->textlow == 0
456 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
458 if (section) /* Match on a specific section. */
460 fixup_psymbol_section (p, objfile);
461 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
465 best_pc = SYMBOL_VALUE_ADDRESS (p);
474 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
481 if (SYMBOL_SECTION (psym) >= 0)
484 gdb_assert (objfile);
486 switch (PSYMBOL_CLASS (psym))
491 addr = SYMBOL_VALUE_ADDRESS (psym);
494 /* Nothing else will be listed in the minsyms -- no use looking
499 fixup_section (&psym->ginfo, addr, objfile);
502 /* Psymtab version of lookup_symbol. See its definition in
503 the definition of quick_symbol_functions in symfile.h. */
505 static struct compunit_symtab *
506 psym_lookup_symbol (struct objfile *objfile,
507 int block_index, const char *name,
508 const domain_enum domain)
510 struct partial_symtab *ps;
511 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
512 struct compunit_symtab *stab_best = NULL;
514 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
516 if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
517 psymtab_index, domain))
519 struct symbol *sym, *with_opaque = NULL;
520 struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps);
521 /* Note: While psymtab_to_symtab can return NULL if the partial symtab
522 is empty, we can assume it won't here because lookup_partial_symbol
524 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
525 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
527 sym = block_find_symbol (block, name, domain,
528 block_find_non_opaque_type_preferred,
531 /* Some caution must be observed with overloaded functions
532 and methods, since the index will not contain any overload
533 information (but NAME might contain it). */
536 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
538 if (with_opaque != NULL
539 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
542 /* Keep looking through other psymtabs. */
549 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
550 the global block of PST if GLOBAL, and otherwise the static block.
551 MATCH is the comparison operation that returns true iff MATCH (s,
552 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
553 non-null, the symbols in the block are assumed to be ordered
554 according to it (allowing binary search). It must be compatible
555 with MATCH. Returns the symbol, if found, and otherwise NULL. */
557 static struct partial_symbol *
558 match_partial_symbol (struct objfile *objfile,
559 struct partial_symtab *pst, int global,
560 const char *name, domain_enum domain,
561 symbol_compare_ftype *match,
562 symbol_compare_ftype *ordered_compare)
564 struct partial_symbol **start, **psym;
565 struct partial_symbol **top, **real_top, **bottom, **center;
566 int length = (global ? pst->n_global_syms : pst->n_static_syms);
567 int do_linear_search = 1;
572 objfile->global_psymbols.list + pst->globals_offset :
573 objfile->static_psymbols.list + pst->statics_offset);
575 if (global && ordered_compare) /* Can use a binary search. */
577 do_linear_search = 0;
579 /* Binary search. This search is guaranteed to end with center
580 pointing at the earliest partial symbol whose name might be
581 correct. At that point *all* partial symbols with an
582 appropriate name will be checked against the correct
586 top = start + length - 1;
590 center = bottom + (top - bottom) / 2;
591 gdb_assert (center < top);
592 if (!do_linear_search
593 && (SYMBOL_LANGUAGE (*center) == language_java))
594 do_linear_search = 1;
595 if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
600 gdb_assert (top == bottom);
602 while (top <= real_top
603 && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
605 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
606 SYMBOL_DOMAIN (*top), domain))
612 /* Can't use a binary search or else we found during the binary search that
613 we should also do a linear search. */
615 if (do_linear_search)
617 for (psym = start; psym < start + length; psym++)
619 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
620 SYMBOL_DOMAIN (*psym), domain)
621 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
629 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
630 not contain any method/function instance information (since this would
631 force reading type information while reading psymtabs). Therefore,
632 if NAME contains overload information, it must be stripped before searching
635 The caller is responsible for freeing the return result. */
638 psymtab_search_name (const char *name)
640 switch (current_language->la_language)
645 if (strchr (name, '('))
647 char *ret = cp_remove_params (name);
659 return xstrdup (name);
662 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
663 Check the global symbols if GLOBAL, the static symbols if not. */
665 static struct partial_symbol *
666 lookup_partial_symbol (struct objfile *objfile,
667 struct partial_symtab *pst, const char *name,
668 int global, domain_enum domain)
670 struct partial_symbol **start, **psym;
671 struct partial_symbol **top, **real_top, **bottom, **center;
672 int length = (global ? pst->n_global_syms : pst->n_static_syms);
673 int do_linear_search = 1;
675 struct cleanup *cleanup;
682 search_name = psymtab_search_name (name);
683 cleanup = make_cleanup (xfree, search_name);
685 objfile->global_psymbols.list + pst->globals_offset :
686 objfile->static_psymbols.list + pst->statics_offset);
688 if (global) /* This means we can use a binary search. */
690 do_linear_search = 0;
692 /* Binary search. This search is guaranteed to end with center
693 pointing at the earliest partial symbol whose name might be
694 correct. At that point *all* partial symbols with an
695 appropriate name will be checked against the correct
699 top = start + length - 1;
703 center = bottom + (top - bottom) / 2;
705 internal_error (__FILE__, __LINE__,
706 _("failed internal consistency check"));
707 if (!do_linear_search
708 && SYMBOL_LANGUAGE (*center) == language_java)
710 do_linear_search = 1;
712 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
722 if (!(top == bottom))
723 internal_error (__FILE__, __LINE__,
724 _("failed internal consistency check"));
726 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
727 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
728 while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
731 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
734 while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
736 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
737 SYMBOL_DOMAIN (*top), domain))
739 do_cleanups (cleanup);
746 /* Can't use a binary search or else we found during the binary search that
747 we should also do a linear search. */
749 if (do_linear_search)
751 for (psym = start; psym < start + length; psym++)
753 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
754 SYMBOL_DOMAIN (*psym), domain)
755 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
757 do_cleanups (cleanup);
763 do_cleanups (cleanup);
767 /* Get the symbol table that corresponds to a partial_symtab.
768 This is fast after the first time you do it.
769 The result will be NULL if the primary symtab has no symbols,
770 which can happen. Otherwise the result is the primary symtab
771 that contains PST. */
773 static struct compunit_symtab *
774 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
776 /* If it is a shared psymtab, find an unshared psymtab that includes
777 it. Any such psymtab will do. */
778 while (pst->user != NULL)
781 /* If it's been looked up before, return it. */
782 if (pst->compunit_symtab)
783 return pst->compunit_symtab;
785 /* If it has not yet been read in, read it. */
788 struct cleanup *back_to = increment_reading_symtab ();
790 (*pst->read_symtab) (pst, objfile);
791 do_cleanups (back_to);
794 return pst->compunit_symtab;
797 /* Psymtab version of relocate. See its definition in
798 the definition of quick_symbol_functions in symfile.h. */
801 psym_relocate (struct objfile *objfile,
802 const struct section_offsets *new_offsets,
803 const struct section_offsets *delta)
805 struct partial_symbol **psym;
806 struct partial_symtab *p;
808 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
810 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
811 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
814 for (psym = objfile->global_psymbols.list;
815 psym < objfile->global_psymbols.next;
818 fixup_psymbol_section (*psym, objfile);
819 if (SYMBOL_SECTION (*psym) >= 0)
820 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
821 SYMBOL_SECTION (*psym));
823 for (psym = objfile->static_psymbols.list;
824 psym < objfile->static_psymbols.next;
827 fixup_psymbol_section (*psym, objfile);
828 if (SYMBOL_SECTION (*psym) >= 0)
829 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
830 SYMBOL_SECTION (*psym));
834 /* Psymtab version of find_last_source_symtab. See its definition in
835 the definition of quick_symbol_functions in symfile.h. */
837 static struct symtab *
838 psym_find_last_source_symtab (struct objfile *ofp)
840 struct partial_symtab *ps;
841 struct partial_symtab *cs_pst = 0;
843 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
845 const char *name = ps->filename;
846 int len = strlen (name);
848 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
849 || strcmp (name, "<<C++-namespaces>>") == 0)))
857 internal_error (__FILE__, __LINE__,
858 _("select_source_symtab: "
859 "readin pst found and no symtabs."));
863 struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
867 return compunit_primary_filetab (cust);
873 /* Psymtab version of forget_cached_source_info. See its definition in
874 the definition of quick_symbol_functions in symfile.h. */
877 psym_forget_cached_source_info (struct objfile *objfile)
879 struct partial_symtab *pst;
881 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
883 if (pst->fullname != NULL)
885 xfree (pst->fullname);
886 pst->fullname = NULL;
892 print_partial_symbols (struct gdbarch *gdbarch,
893 struct partial_symbol **p, int count, char *what,
894 struct ui_file *outfile)
896 fprintf_filtered (outfile, " %s partial symbols:\n", what);
900 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
901 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
903 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
905 fputs_filtered (", ", outfile);
906 switch (SYMBOL_DOMAIN (*p))
909 fputs_filtered ("undefined domain, ", outfile);
912 /* This is the usual thing -- don't print it. */
915 fputs_filtered ("struct domain, ", outfile);
918 fputs_filtered ("label domain, ", outfile);
921 fputs_filtered ("<invalid domain>, ", outfile);
924 switch (PSYMBOL_CLASS (*p))
927 fputs_filtered ("undefined", outfile);
930 fputs_filtered ("constant int", outfile);
933 fputs_filtered ("static", outfile);
936 fputs_filtered ("register", outfile);
939 fputs_filtered ("pass by value", outfile);
942 fputs_filtered ("pass by reference", outfile);
944 case LOC_REGPARM_ADDR:
945 fputs_filtered ("register address parameter", outfile);
948 fputs_filtered ("stack parameter", outfile);
951 fputs_filtered ("type", outfile);
954 fputs_filtered ("label", outfile);
957 fputs_filtered ("function", outfile);
959 case LOC_CONST_BYTES:
960 fputs_filtered ("constant bytes", outfile);
963 fputs_filtered ("unresolved", outfile);
965 case LOC_OPTIMIZED_OUT:
966 fputs_filtered ("optimized out", outfile);
969 fputs_filtered ("computed at runtime", outfile);
972 fputs_filtered ("<invalid location>", outfile);
975 fputs_filtered (", ", outfile);
976 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
977 fprintf_filtered (outfile, "\n");
983 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
984 struct ui_file *outfile)
986 struct gdbarch *gdbarch = get_objfile_arch (objfile);
989 if (psymtab->anonymous)
991 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
996 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
999 fprintf_filtered (outfile, "(object ");
1000 gdb_print_host_address (psymtab, outfile);
1001 fprintf_filtered (outfile, ")\n\n");
1002 fprintf_unfiltered (outfile, " Read from object file %s (",
1003 objfile_name (objfile));
1004 gdb_print_host_address (objfile, outfile);
1005 fprintf_unfiltered (outfile, ")\n");
1007 if (psymtab->readin)
1009 fprintf_filtered (outfile,
1010 " Full symtab was read (at ");
1011 gdb_print_host_address (psymtab->compunit_symtab, outfile);
1012 fprintf_filtered (outfile, " by function at ");
1013 gdb_print_host_address (psymtab->read_symtab, outfile);
1014 fprintf_filtered (outfile, ")\n");
1017 fprintf_filtered (outfile, " Relocate symbols by ");
1018 for (i = 0; i < objfile->num_sections; ++i)
1021 fprintf_filtered (outfile, ", ");
1023 fputs_filtered (paddress (gdbarch,
1024 ANOFFSET (psymtab->section_offsets, i)),
1027 fprintf_filtered (outfile, "\n");
1029 fprintf_filtered (outfile, " Symbols cover text addresses ");
1030 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
1031 fprintf_filtered (outfile, "-");
1032 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
1033 fprintf_filtered (outfile, "\n");
1034 fprintf_filtered (outfile, " Address map supported - %s.\n",
1035 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1036 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
1037 psymtab->number_of_dependencies);
1038 for (i = 0; i < psymtab->number_of_dependencies; i++)
1040 fprintf_filtered (outfile, " %d ", i);
1041 gdb_print_host_address (psymtab->dependencies[i], outfile);
1042 fprintf_filtered (outfile, " %s\n",
1043 psymtab->dependencies[i]->filename);
1045 if (psymtab->user != NULL)
1047 fprintf_filtered (outfile, " Shared partial symtab with user ");
1048 gdb_print_host_address (psymtab->user, outfile);
1049 fprintf_filtered (outfile, "\n");
1051 if (psymtab->n_global_syms > 0)
1053 print_partial_symbols (gdbarch,
1054 objfile->global_psymbols.list
1055 + psymtab->globals_offset,
1056 psymtab->n_global_syms, "Global", outfile);
1058 if (psymtab->n_static_syms > 0)
1060 print_partial_symbols (gdbarch,
1061 objfile->static_psymbols.list
1062 + psymtab->statics_offset,
1063 psymtab->n_static_syms, "Static", outfile);
1065 fprintf_filtered (outfile, "\n");
1068 /* Psymtab version of print_stats. See its definition in
1069 the definition of quick_symbol_functions in symfile.h. */
1072 psym_print_stats (struct objfile *objfile)
1075 struct partial_symtab *ps;
1078 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1080 if (ps->readin == 0)
1083 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1086 /* Psymtab version of dump. See its definition in
1087 the definition of quick_symbol_functions in symfile.h. */
1090 psym_dump (struct objfile *objfile)
1092 struct partial_symtab *psymtab;
1094 if (objfile->psymtabs)
1096 printf_filtered ("Psymtabs:\n");
1097 for (psymtab = objfile->psymtabs;
1099 psymtab = psymtab->next)
1101 printf_filtered ("%s at ",
1103 gdb_print_host_address (psymtab, gdb_stdout);
1104 printf_filtered (", ");
1107 printf_filtered ("\n\n");
1111 /* Psymtab version of expand_symtabs_for_function. See its definition in
1112 the definition of quick_symbol_functions in symfile.h. */
1115 psym_expand_symtabs_for_function (struct objfile *objfile,
1116 const char *func_name)
1118 struct partial_symtab *ps;
1120 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1125 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1127 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1129 psymtab_to_symtab (objfile, ps);
1133 /* Psymtab version of expand_all_symtabs. See its definition in
1134 the definition of quick_symbol_functions in symfile.h. */
1137 psym_expand_all_symtabs (struct objfile *objfile)
1139 struct partial_symtab *psymtab;
1141 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1143 psymtab_to_symtab (objfile, psymtab);
1147 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1148 the definition of quick_symbol_functions in symfile.h. */
1151 psym_expand_symtabs_with_fullname (struct objfile *objfile,
1152 const char *fullname)
1154 struct partial_symtab *p;
1156 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1158 /* Anonymous psymtabs don't have a name of a source file. */
1162 /* psymtab_to_fullname tries to open the file which is slow.
1163 Don't call it if we know the basenames don't match. */
1164 if ((basenames_may_differ
1165 || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
1166 && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
1167 psymtab_to_symtab (objfile, p);
1171 /* Psymtab version of map_symbol_filenames. See its definition in
1172 the definition of quick_symbol_functions in symfile.h. */
1175 psym_map_symbol_filenames (struct objfile *objfile,
1176 symbol_filename_ftype *fun, void *data,
1179 struct partial_symtab *ps;
1181 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1183 const char *fullname;
1188 /* We can skip shared psymtabs here, because any file name will be
1189 attached to the unshared psymtab. */
1190 if (ps->user != NULL)
1193 /* Anonymous psymtabs don't have a file name. */
1199 fullname = psymtab_to_fullname (ps);
1202 (*fun) (ps->filename, fullname, data);
1206 /* Finds the fullname that a partial_symtab represents.
1208 If this functions finds the fullname, it will save it in ps->fullname
1209 and it will also return the value.
1211 If this function fails to find the file that this partial_symtab represents,
1212 NULL will be returned and ps->fullname will be set to NULL. */
1215 psymtab_to_fullname (struct partial_symtab *ps)
1217 gdb_assert (!ps->anonymous);
1219 /* Use cached copy if we have it.
1220 We rely on forget_cached_source_info being called appropriately
1221 to handle cases like the file being moved. */
1222 if (ps->fullname == NULL)
1224 int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1231 struct cleanup *back_to;
1233 /* rewrite_source_path would be applied by find_and_open_source, we
1234 should report the pathname where GDB tried to find the file. */
1236 if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1237 fullname = xstrdup (ps->filename);
1239 fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);
1241 back_to = make_cleanup (xfree, fullname);
1242 ps->fullname = rewrite_source_path (fullname);
1243 if (ps->fullname == NULL)
1244 ps->fullname = xstrdup (fullname);
1245 do_cleanups (back_to);
1249 return ps->fullname;
1252 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1253 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1254 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1255 ever returns non-zero, and otherwise returns 0. */
1258 map_block (const char *name, domain_enum domain, struct objfile *objfile,
1259 struct block *block,
1260 int (*callback) (struct block *, struct symbol *, void *),
1261 void *data, symbol_compare_ftype *match)
1263 struct block_iterator iter;
1266 for (sym = block_iter_match_first (block, name, match, &iter);
1267 sym != NULL; sym = block_iter_match_next (name, match, &iter))
1269 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1270 SYMBOL_DOMAIN (sym), domain))
1272 if (callback (block, sym, data))
1280 /* Psymtab version of map_matching_symbols. See its definition in
1281 the definition of quick_symbol_functions in symfile.h. */
1284 psym_map_matching_symbols (struct objfile *objfile,
1285 const char *name, domain_enum domain,
1287 int (*callback) (struct block *,
1288 struct symbol *, void *),
1290 symbol_compare_ftype *match,
1291 symbol_compare_ftype *ordered_compare)
1293 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1294 struct partial_symtab *ps;
1296 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1300 || match_partial_symbol (objfile, ps, global, name, domain, match,
1303 struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
1304 struct block *block;
1308 block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
1309 if (map_block (name, domain, objfile, block,
1310 callback, data, match))
1312 if (callback (block, NULL, data))
1318 /* A helper for psym_expand_symtabs_matching that handles
1319 searching included psymtabs. This returns 1 if a symbol is found,
1320 and zero otherwise. It also updates the 'searched_flag' on the
1321 various psymtabs that it searches. */
1324 recursively_search_psymtabs (struct partial_symtab *ps,
1325 struct objfile *objfile,
1326 enum search_domain kind,
1327 expand_symtabs_symbol_matcher_ftype *sym_matcher,
1330 struct partial_symbol **psym;
1331 struct partial_symbol **bound, **gbound, **sbound;
1333 int result = PST_SEARCHED_AND_NOT_FOUND;
1336 if (ps->searched_flag != PST_NOT_SEARCHED)
1337 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1339 /* Recurse into shared psymtabs first, because they may have already
1340 been searched, and this could save some time. */
1341 for (i = 0; i < ps->number_of_dependencies; ++i)
1345 /* Skip non-shared dependencies, these are handled elsewhere. */
1346 if (ps->dependencies[i]->user == NULL)
1349 r = recursively_search_psymtabs (ps->dependencies[i],
1350 objfile, kind, sym_matcher, data);
1353 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1358 gbound = (objfile->global_psymbols.list
1359 + ps->globals_offset + ps->n_global_syms);
1360 sbound = (objfile->static_psymbols.list
1361 + ps->statics_offset + ps->n_static_syms);
1364 /* Go through all of the symbols stored in a partial
1365 symtab in one loop. */
1366 psym = objfile->global_psymbols.list + ps->globals_offset;
1371 if (bound == gbound && ps->n_static_syms != 0)
1373 psym = objfile->static_psymbols.list + ps->statics_offset;
1384 if ((kind == ALL_DOMAIN
1385 || (kind == VARIABLES_DOMAIN
1386 && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
1387 && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
1388 || (kind == FUNCTIONS_DOMAIN
1389 && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
1390 || (kind == TYPES_DOMAIN
1391 && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1392 && (*sym_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1394 /* Found a match, so notify our caller. */
1395 result = PST_SEARCHED_AND_FOUND;
1402 ps->searched_flag = result;
1403 return result == PST_SEARCHED_AND_FOUND;
1406 /* Psymtab version of expand_symtabs_matching. See its definition in
1407 the definition of quick_symbol_functions in symfile.h. */
1410 psym_expand_symtabs_matching
1411 (struct objfile *objfile,
1412 expand_symtabs_file_matcher_ftype *file_matcher,
1413 expand_symtabs_symbol_matcher_ftype *symbol_matcher,
1414 expand_symtabs_exp_notify_ftype *expansion_notify,
1415 enum search_domain kind,
1418 struct partial_symtab *ps;
1420 /* Clear the search flags. */
1421 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1423 ps->searched_flag = PST_NOT_SEARCHED;
1426 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1433 /* We skip shared psymtabs because file-matching doesn't apply
1434 to them; but we search them later in the loop. */
1435 if (ps->user != NULL)
1445 match = (*file_matcher) (ps->filename, data, 0);
1448 /* Before we invoke realpath, which can get expensive when many
1449 files are involved, do a quick comparison of the basenames. */
1450 if (basenames_may_differ
1451 || (*file_matcher) (lbasename (ps->filename), data, 1))
1452 match = (*file_matcher) (psymtab_to_fullname (ps), data, 0);
1458 if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher, data))
1460 struct compunit_symtab *symtab =
1461 psymtab_to_symtab (objfile, ps);
1463 if (expansion_notify != NULL)
1464 expansion_notify (symtab, data);
1469 /* Psymtab version of has_symbols. See its definition in
1470 the definition of quick_symbol_functions in symfile.h. */
1473 psym_has_symbols (struct objfile *objfile)
1475 return objfile->psymtabs != NULL;
1478 const struct quick_symbol_functions psym_functions =
1481 psym_find_last_source_symtab,
1482 psym_forget_cached_source_info,
1483 psym_map_symtabs_matching_filename,
1488 psym_expand_symtabs_for_function,
1489 psym_expand_all_symtabs,
1490 psym_expand_symtabs_with_fullname,
1491 psym_map_matching_symbols,
1492 psym_expand_symtabs_matching,
1493 psym_find_pc_sect_compunit_symtab,
1494 psym_map_symbol_filenames
1499 /* This compares two partial symbols by names, using strcmp_iw_ordered
1500 for the comparison. */
1503 compare_psymbols (const void *s1p, const void *s2p)
1505 struct partial_symbol *const *s1 = s1p;
1506 struct partial_symbol *const *s2 = s2p;
1508 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1509 SYMBOL_SEARCH_NAME (*s2));
1513 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1515 /* Sort the global list; don't sort the static list. */
1517 qsort (objfile->global_psymbols.list + pst->globals_offset,
1518 pst->n_global_syms, sizeof (struct partial_symbol *),
1522 /* Allocate and partially fill a partial symtab. It will be
1523 completely filled at the end of the symbol list.
1525 FILENAME is the name of the symbol-file we are reading from. */
1527 struct partial_symtab *
1528 start_psymtab_common (struct objfile *objfile,
1529 struct section_offsets *section_offsets,
1530 const char *filename,
1531 CORE_ADDR textlow, struct partial_symbol **global_syms,
1532 struct partial_symbol **static_syms)
1534 struct partial_symtab *psymtab;
1536 psymtab = allocate_psymtab (filename, objfile);
1537 psymtab->section_offsets = section_offsets;
1538 psymtab->textlow = textlow;
1539 psymtab->texthigh = psymtab->textlow; /* default */
1540 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1541 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1545 /* Calculate a hash code for the given partial symbol. The hash is
1546 calculated using the symbol's value, language, domain, class
1547 and name. These are the values which are set by
1548 add_psymbol_to_bcache. */
1550 static unsigned long
1551 psymbol_hash (const void *addr, int length)
1553 unsigned long h = 0;
1554 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1555 unsigned int lang = psymbol->ginfo.language;
1556 unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1557 unsigned int theclass = PSYMBOL_CLASS (psymbol);
1559 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1560 h = hash_continue (&lang, sizeof (unsigned int), h);
1561 h = hash_continue (&domain, sizeof (unsigned int), h);
1562 h = hash_continue (&theclass, sizeof (unsigned int), h);
1563 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1568 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1569 For the comparison this function uses a symbols value,
1570 language, domain, class and name. */
1573 psymbol_compare (const void *addr1, const void *addr2, int length)
1575 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1576 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1578 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1579 sizeof (sym1->ginfo.value)) == 0
1580 && sym1->ginfo.language == sym2->ginfo.language
1581 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1582 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1583 && sym1->ginfo.name == sym2->ginfo.name);
1586 /* Initialize a partial symbol bcache. */
1588 struct psymbol_bcache *
1589 psymbol_bcache_init (void)
1591 struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
1592 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1596 /* Free a partial symbol bcache. */
1598 psymbol_bcache_free (struct psymbol_bcache *bcache)
1603 bcache_xfree (bcache->bcache);
1607 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1610 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1612 return bcache->bcache;
1615 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1616 symbol before, add a copy to BCACHE. In either case, return a pointer
1617 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1618 1 in case of new entry or 0 if returning an old entry. */
1620 static const struct partial_symbol *
1621 psymbol_bcache_full (struct partial_symbol *sym,
1622 struct psymbol_bcache *bcache,
1625 return bcache_full (sym,
1626 sizeof (struct partial_symbol),
1631 /* Helper function, initialises partial symbol structure and stashes
1632 it into objfile's bcache. Note that our caching mechanism will
1633 use all fields of struct partial_symbol to determine hash value of the
1634 structure. In other words, having two symbols with the same name but
1635 different domain (or address) is possible and correct. */
1637 static const struct partial_symbol *
1638 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1640 enum address_class theclass,
1641 long val, /* Value as a long */
1642 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1643 enum language language, struct objfile *objfile,
1646 struct partial_symbol psymbol;
1648 /* We must ensure that the entire struct has been zeroed before
1649 assigning to it, because an assignment may not touch some of the
1651 memset (&psymbol, 0, sizeof (psymbol));
1653 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1656 SYMBOL_VALUE (&psymbol) = val;
1660 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1662 SYMBOL_SECTION (&psymbol) = -1;
1663 SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
1664 PSYMBOL_DOMAIN (&psymbol) = domain;
1665 PSYMBOL_CLASS (&psymbol) = theclass;
1667 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1669 /* Stash the partial symbol away in the cache. */
1670 return psymbol_bcache_full (&psymbol,
1671 objfile->psymbol_cache,
1675 /* Increase the space allocated for LISTP, which is probably
1676 global_psymbols or static_psymbols. This space will eventually
1677 be freed in free_objfile(). */
1680 extend_psymbol_list (struct psymbol_allocation_list *listp,
1681 struct objfile *objfile)
1685 if (listp->size == 0)
1688 listp->list = (struct partial_symbol **)
1689 xmalloc (new_size * sizeof (struct partial_symbol *));
1693 new_size = listp->size * 2;
1694 listp->list = (struct partial_symbol **)
1695 xrealloc ((char *) listp->list,
1696 new_size * sizeof (struct partial_symbol *));
1698 /* Next assumes we only went one over. Should be good if
1699 program works correctly. */
1700 listp->next = listp->list + listp->size;
1701 listp->size = new_size;
1704 /* Helper function, adds partial symbol to the given partial symbol
1708 append_psymbol_to_list (struct psymbol_allocation_list *list,
1709 const struct partial_symbol *psym,
1710 struct objfile *objfile)
1712 if (list->next >= list->list + list->size)
1713 extend_psymbol_list (list, objfile);
1714 *list->next++ = (struct partial_symbol *) psym;
1715 OBJSTAT (objfile, n_psyms++);
1718 /* Add a symbol with a long value to a psymtab.
1719 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1720 Return the partial symbol that has been added. */
1723 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1725 enum address_class theclass,
1726 struct psymbol_allocation_list *list,
1727 long val, /* Value as a long */
1728 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1729 enum language language, struct objfile *objfile)
1731 const struct partial_symbol *psym;
1735 /* Stash the partial symbol away in the cache. */
1736 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
1737 val, coreaddr, language, objfile, &added);
1739 /* Do not duplicate global partial symbols. */
1740 if (list == &objfile->global_psymbols
1744 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1745 append_psymbol_to_list (list, psym, objfile);
1748 /* Initialize storage for partial symbols. */
1751 init_psymbol_list (struct objfile *objfile, int total_symbols)
1753 /* Free any previously allocated psymbol lists. */
1755 if (objfile->global_psymbols.list)
1757 xfree (objfile->global_psymbols.list);
1759 if (objfile->static_psymbols.list)
1761 xfree (objfile->static_psymbols.list);
1764 /* Current best guess is that approximately a twentieth
1765 of the total symbols (in a debugging file) are global or static
1766 oriented symbols, then multiply that by slop factor of two. */
1768 objfile->global_psymbols.size = total_symbols / 10;
1769 objfile->static_psymbols.size = total_symbols / 10;
1771 if (objfile->global_psymbols.size > 0)
1773 objfile->global_psymbols.next =
1774 objfile->global_psymbols.list = (struct partial_symbol **)
1775 xmalloc ((objfile->global_psymbols.size
1776 * sizeof (struct partial_symbol *)));
1778 if (objfile->static_psymbols.size > 0)
1780 objfile->static_psymbols.next =
1781 objfile->static_psymbols.list = (struct partial_symbol **)
1782 xmalloc ((objfile->static_psymbols.size
1783 * sizeof (struct partial_symbol *)));
1787 struct partial_symtab *
1788 allocate_psymtab (const char *filename, struct objfile *objfile)
1790 struct partial_symtab *psymtab;
1792 if (objfile->free_psymtabs)
1794 psymtab = objfile->free_psymtabs;
1795 objfile->free_psymtabs = psymtab->next;
1798 psymtab = (struct partial_symtab *)
1799 obstack_alloc (&objfile->objfile_obstack,
1800 sizeof (struct partial_symtab));
1802 memset (psymtab, 0, sizeof (struct partial_symtab));
1803 psymtab->filename = bcache (filename, strlen (filename) + 1,
1804 objfile->per_bfd->filename_cache);
1805 psymtab->compunit_symtab = NULL;
1807 /* Prepend it to the psymtab list for the objfile it belongs to.
1808 Psymtabs are searched in most recent inserted -> least recent
1811 psymtab->next = objfile->psymtabs;
1812 objfile->psymtabs = psymtab;
1814 if (symtab_create_debug)
1816 /* Be a bit clever with debugging messages, and don't print objfile
1817 every time, only when it changes. */
1818 static char *last_objfile_name = NULL;
1820 if (last_objfile_name == NULL
1821 || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1823 xfree (last_objfile_name);
1824 last_objfile_name = xstrdup (objfile_name (objfile));
1825 fprintf_unfiltered (gdb_stdlog,
1826 "Creating one or more psymtabs for objfile %s ...\n",
1829 fprintf_unfiltered (gdb_stdlog,
1830 "Created psymtab %s for module %s.\n",
1831 host_address_to_string (psymtab), filename);
1838 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1840 struct partial_symtab **prev_pst;
1843 Empty psymtabs happen as a result of header files which don't
1844 have any symbols in them. There can be a lot of them. But this
1845 check is wrong, in that a psymtab with N_SLINE entries but
1846 nothing else is not empty, but we don't realize that. Fixing
1847 that without slowing things down might be tricky. */
1849 /* First, snip it out of the psymtab chain. */
1851 prev_pst = &(objfile->psymtabs);
1852 while ((*prev_pst) != pst)
1853 prev_pst = &((*prev_pst)->next);
1854 (*prev_pst) = pst->next;
1856 /* Next, put it on a free list for recycling. */
1858 pst->next = objfile->free_psymtabs;
1859 objfile->free_psymtabs = pst;
1862 /* An object of this type is passed to discard_psymtabs_upto. */
1864 struct psymtab_state
1866 /* The objfile where psymtabs are discarded. */
1868 struct objfile *objfile;
1870 /* The first psymtab to save. */
1872 struct partial_symtab *save;
1875 /* A cleanup function used by make_cleanup_discard_psymtabs. */
1878 discard_psymtabs_upto (void *arg)
1880 struct psymtab_state *state = arg;
1882 while (state->objfile->psymtabs != state->save)
1883 discard_psymtab (state->objfile, state->objfile->psymtabs);
1886 /* Return a new cleanup that discards all psymtabs created in OBJFILE
1887 after this function is called. */
1890 make_cleanup_discard_psymtabs (struct objfile *objfile)
1892 struct psymtab_state *state = XNEW (struct psymtab_state);
1894 state->objfile = objfile;
1895 state->save = objfile->psymtabs;
1897 return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
1903 maintenance_print_psymbols (char *args, int from_tty)
1906 struct ui_file *outfile;
1907 struct cleanup *cleanups;
1908 char *symname = NULL;
1909 char *filename = DEV_TTY;
1910 struct objfile *objfile;
1911 struct partial_symtab *ps;
1918 print-psymbols takes an output file name and optional symbol file name"));
1920 argv = gdb_buildargv (args);
1921 cleanups = make_cleanup_freeargv (argv);
1923 if (argv[0] != NULL)
1926 /* If a second arg is supplied, it is a source file name to match on. */
1927 if (argv[1] != NULL)
1933 filename = tilde_expand (filename);
1934 make_cleanup (xfree, filename);
1936 outfile = gdb_fopen (filename, FOPEN_WT);
1938 perror_with_name (filename);
1939 make_cleanup_ui_file_delete (outfile);
1941 ALL_PSYMTABS (objfile, ps)
1944 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1945 dump_psymtab (objfile, ps, outfile);
1947 do_cleanups (cleanups);
1950 /* List all the partial symbol tables whose names match REGEXP (optional). */
1952 maintenance_info_psymtabs (char *regexp, int from_tty)
1954 struct program_space *pspace;
1955 struct objfile *objfile;
1960 ALL_PSPACES (pspace)
1961 ALL_PSPACE_OBJFILES (pspace, objfile)
1963 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1964 struct partial_symtab *psymtab;
1966 /* We don't want to print anything for this objfile until we
1967 actually find a symtab whose name matches. */
1968 int printed_objfile_start = 0;
1970 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1975 || re_exec (psymtab->filename))
1977 if (! printed_objfile_start)
1979 printf_filtered ("{ objfile %s ", objfile_name (objfile));
1981 printf_filtered ("((struct objfile *) %s)\n",
1982 host_address_to_string (objfile));
1983 printed_objfile_start = 1;
1986 printf_filtered (" { psymtab %s ", psymtab->filename);
1988 printf_filtered ("((struct partial_symtab *) %s)\n",
1989 host_address_to_string (psymtab));
1991 printf_filtered (" readin %s\n",
1992 psymtab->readin ? "yes" : "no");
1993 printf_filtered (" fullname %s\n",
1995 ? psymtab->fullname : "(null)");
1996 printf_filtered (" text addresses ");
1997 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1999 printf_filtered (" -- ");
2000 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
2002 printf_filtered ("\n");
2003 printf_filtered (" psymtabs_addrmap_supported %s\n",
2004 (psymtab->psymtabs_addrmap_supported
2006 printf_filtered (" globals ");
2007 if (psymtab->n_global_syms)
2009 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2010 host_address_to_string (objfile->global_psymbols.list
2011 + psymtab->globals_offset),
2012 psymtab->n_global_syms);
2015 printf_filtered ("(none)\n");
2016 printf_filtered (" statics ");
2017 if (psymtab->n_static_syms)
2019 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2020 host_address_to_string (objfile->static_psymbols.list
2021 + psymtab->statics_offset),
2022 psymtab->n_static_syms);
2025 printf_filtered ("(none)\n");
2026 printf_filtered (" dependencies ");
2027 if (psymtab->number_of_dependencies)
2031 printf_filtered ("{\n");
2032 for (i = 0; i < psymtab->number_of_dependencies; i++)
2034 struct partial_symtab *dep = psymtab->dependencies[i];
2036 /* Note the string concatenation there --- no comma. */
2037 printf_filtered (" psymtab %s "
2038 "((struct partial_symtab *) %s)\n",
2040 host_address_to_string (dep));
2042 printf_filtered (" }\n");
2045 printf_filtered ("(none)\n");
2046 printf_filtered (" }\n");
2050 if (printed_objfile_start)
2051 printf_filtered ("}\n");
2055 /* Check consistency of currently expanded psymtabs vs symtabs. */
2058 maintenance_check_psymtabs (char *ignore, int from_tty)
2061 struct partial_symbol **psym;
2062 struct compunit_symtab *cust = NULL;
2063 struct partial_symtab *ps;
2064 const struct blockvector *bv;
2065 struct objfile *objfile;
2069 ALL_PSYMTABS (objfile, ps)
2071 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2073 /* We don't call psymtab_to_symtab here because that may cause symtab
2074 expansion. When debugging a problem it helps if checkers leave
2075 things unchanged. */
2076 cust = ps->compunit_symtab;
2078 /* First do some checks that don't require the associated symtab. */
2079 if (ps->texthigh < ps->textlow)
2081 printf_filtered ("Psymtab ");
2082 puts_filtered (ps->filename);
2083 printf_filtered (" covers bad range ");
2084 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2085 printf_filtered (" - ");
2086 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2087 printf_filtered ("\n");
2091 /* Now do checks requiring the associated symtab. */
2094 bv = COMPUNIT_BLOCKVECTOR (cust);
2095 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2096 psym = objfile->static_psymbols.list + ps->statics_offset;
2097 length = ps->n_static_syms;
2100 sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2101 SYMBOL_DOMAIN (*psym));
2104 printf_filtered ("Static symbol `");
2105 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2106 printf_filtered ("' only found in ");
2107 puts_filtered (ps->filename);
2108 printf_filtered (" psymtab\n");
2112 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2113 psym = objfile->global_psymbols.list + ps->globals_offset;
2114 length = ps->n_global_syms;
2117 sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2118 SYMBOL_DOMAIN (*psym));
2121 printf_filtered ("Global symbol `");
2122 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2123 printf_filtered ("' only found in ");
2124 puts_filtered (ps->filename);
2125 printf_filtered (" psymtab\n");
2129 if (ps->texthigh != 0
2130 && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
2132 printf_filtered ("Psymtab ");
2133 puts_filtered (ps->filename);
2134 printf_filtered (" covers ");
2135 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2136 printf_filtered (" - ");
2137 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2138 printf_filtered (" but symtab covers only ");
2139 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2140 printf_filtered (" - ");
2141 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2142 printf_filtered ("\n");
2149 extern initialize_file_ftype _initialize_psymtab;
2152 _initialize_psymtab (void)
2154 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2155 Print dump of current partial symbol definitions.\n\
2156 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2157 If a SOURCE file is specified, dump only that file's partial symbols."),
2158 &maintenanceprintlist);
2160 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2161 List the partial symbol tables for all object files.\n\
2162 This does not include information about individual partial symbols,\n\
2163 just the symbol table structures themselves."),
2164 &maintenanceinfolist);
2166 add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2168 Check consistency of currently expanded psymtabs versus symtabs."),