1 /* Partial symbol tables.
3 Copyright (C) 2009-2018 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"
43 struct bcache *bcache;
46 static struct partial_symbol *match_partial_symbol (struct objfile *,
47 struct partial_symtab *,
49 const char *, domain_enum,
50 symbol_name_match_type,
51 symbol_compare_ftype *);
53 static struct partial_symbol *lookup_partial_symbol (struct objfile *,
54 struct partial_symtab *,
58 static const char *psymtab_to_fullname (struct partial_symtab *ps);
60 static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
61 struct partial_symtab *,
63 struct obj_section *);
65 static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
66 struct partial_symtab *pst);
68 /* Ensure that the partial symbols for OBJFILE have been loaded. This
69 function always returns its argument, as a convenience. */
72 require_partial_symbols (struct objfile *objfile, int verbose)
74 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
76 objfile->flags |= OBJF_PSYMTABS_READ;
78 if (objfile->sf->sym_read_psymbols)
81 printf_filtered (_("Reading symbols from %s...\n"),
82 objfile_name (objfile));
83 (*objfile->sf->sym_read_psymbols) (objfile);
85 /* Partial symbols list are not expected to changed after this
87 objfile->global_psymbols.shrink_to_fit ();
88 objfile->static_psymbols.shrink_to_fit ();
90 if (verbose && !objfile_has_symbols (objfile))
91 printf_filtered (_("(No debugging symbols found in %s)\n"),
92 objfile_name (objfile));
99 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
102 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
103 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
107 /* We want to make sure this file always requires psymtabs. */
109 #undef ALL_OBJFILE_PSYMTABS
111 /* Traverse all psymtabs in all objfiles. */
113 #define ALL_PSYMTABS(objfile, p) \
114 ALL_OBJFILES (objfile) \
115 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
117 /* Helper function for psym_map_symtabs_matching_filename that
118 expands the symtabs and calls the iterator. */
121 partial_map_expand_apply (struct objfile *objfile,
123 const char *real_path,
124 struct partial_symtab *pst,
125 gdb::function_view<bool (symtab *)> callback)
127 struct compunit_symtab *last_made = objfile->compunit_symtabs;
129 /* Shared psymtabs should never be seen here. Instead they should
130 be handled properly by the caller. */
131 gdb_assert (pst->user == NULL);
133 /* Don't visit already-expanded psymtabs. */
137 /* This may expand more than one symtab, and we want to iterate over
139 psymtab_to_symtab (objfile, pst);
141 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
142 last_made, callback);
145 /* Psymtab version of map_symtabs_matching_filename. See its definition in
146 the definition of quick_symbol_functions in symfile.h. */
149 psym_map_symtabs_matching_filename
150 (struct objfile *objfile,
152 const char *real_path,
153 gdb::function_view<bool (symtab *)> callback)
155 struct partial_symtab *pst;
156 const char *name_basename = lbasename (name);
158 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
160 /* We can skip shared psymtabs here, because any file name will be
161 attached to the unshared psymtab. */
162 if (pst->user != NULL)
165 /* Anonymous psymtabs don't have a file name. */
169 if (compare_filenames_for_search (pst->filename, name))
171 if (partial_map_expand_apply (objfile, name, real_path,
177 /* Before we invoke realpath, which can get expensive when many
178 files are involved, do a quick comparison of the basenames. */
179 if (! basenames_may_differ
180 && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
183 if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
185 if (partial_map_expand_apply (objfile, name, real_path,
191 /* If the user gave us an absolute path, try to find the file in
192 this symtab and use its absolute path. */
193 if (real_path != NULL)
195 gdb_assert (IS_ABSOLUTE_PATH (real_path));
196 gdb_assert (IS_ABSOLUTE_PATH (name));
197 if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
199 if (partial_map_expand_apply (objfile, name, real_path,
210 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
211 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
213 static struct partial_symtab *
214 find_pc_sect_psymtab_closer (struct objfile *objfile,
215 CORE_ADDR pc, struct obj_section *section,
216 struct partial_symtab *pst,
217 struct bound_minimal_symbol msymbol)
219 struct partial_symtab *tpst;
220 struct partial_symtab *best_pst = pst;
221 CORE_ADDR best_addr = pst->text_low (objfile);
223 gdb_assert (!pst->psymtabs_addrmap_supported);
225 /* An objfile that has its functions reordered might have
226 many partial symbol tables containing the PC, but
227 we want the partial symbol table that contains the
228 function containing the PC. */
229 if (!(objfile->flags & OBJF_REORDERED)
230 && section == NULL) /* Can't validate section this way. */
233 if (msymbol.minsym == NULL)
236 /* The code range of partial symtabs sometimes overlap, so, in
237 the loop below, we need to check all partial symtabs and
238 find the one that fits better for the given PC address. We
239 select the partial symtab that contains a symbol whose
240 address is closest to the PC address. By closest we mean
241 that find_pc_sect_symbol returns the symbol with address
242 that is closest and still less than the given PC. */
243 for (tpst = pst; tpst != NULL; tpst = tpst->next)
245 if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile))
247 struct partial_symbol *p;
250 /* NOTE: This assumes that every psymbol has a
251 corresponding msymbol, which is not necessarily
252 true; the debug info might be much richer than the
253 object's symbol table. */
254 p = find_pc_sect_psymbol (objfile, tpst, pc, section);
256 && (p->address (objfile) == BMSYMBOL_VALUE_ADDRESS (msymbol)))
259 /* Also accept the textlow value of a psymtab as a
260 "symbol", to provide some support for partial
261 symbol tables with line information but no debug
262 symbols (e.g. those produced by an assembler). */
264 this_addr = p->address (objfile);
266 this_addr = tpst->text_low (objfile);
268 /* Check whether it is closer than our current
269 BEST_ADDR. Since this symbol address is
270 necessarily lower or equal to PC, the symbol closer
271 to PC is the symbol which address is the highest.
272 This way we return the psymtab which contains such
273 best match symbol. This can help in cases where the
274 symbol information/debuginfo is not complete, like
275 for instance on IRIX6 with gcc, where no debug info
276 is emitted for statics. (See also the nodebug.exp
278 if (this_addr > best_addr)
280 best_addr = this_addr;
288 /* Find which partial symtab contains PC and SECTION. Return NULL if
289 none. We return the psymtab that contains a symbol whose address
290 exactly matches PC, or, if we cannot find an exact match, the
291 psymtab that contains a symbol whose address is closest to PC. */
293 static struct partial_symtab *
294 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
295 struct obj_section *section,
296 struct bound_minimal_symbol msymbol)
298 struct partial_symtab *pst;
299 CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
300 SECT_OFF_TEXT (objfile));
302 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
303 than the later used TEXTLOW/TEXTHIGH one. */
305 if (objfile->psymtabs_addrmap != NULL)
307 pst = ((struct partial_symtab *)
308 addrmap_find (objfile->psymtabs_addrmap, pc - baseaddr));
311 /* FIXME: addrmaps currently do not handle overlayed sections,
312 so fall back to the non-addrmap case if we're debugging
313 overlays and the addrmap returned the wrong section. */
314 if (overlay_debugging && msymbol.minsym != NULL && section != NULL)
316 struct partial_symbol *p;
318 /* NOTE: This assumes that every psymbol has a
319 corresponding msymbol, which is not necessarily
320 true; the debug info might be much richer than the
321 object's symbol table. */
322 p = find_pc_sect_psymbol (objfile, pst, pc, section);
324 || (p->address (objfile)
325 != BMSYMBOL_VALUE_ADDRESS (msymbol)))
329 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
330 PSYMTABS_ADDRMAP we used has already the best 1-byte
331 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
332 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
341 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
342 which still have no corresponding full SYMTABs read. But it is not
343 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
346 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
347 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
348 debug info type in single OBJFILE. */
350 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
351 if (!pst->psymtabs_addrmap_supported
352 && pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
354 struct partial_symtab *best_pst;
356 best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
358 if (best_pst != NULL)
365 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
366 the definition of quick_symbol_functions in symfile.h. */
368 static struct compunit_symtab *
369 psym_find_pc_sect_compunit_symtab (struct objfile *objfile,
370 struct bound_minimal_symbol msymbol,
372 struct obj_section *section,
375 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
379 if (warn_if_readin && ps->readin)
380 /* Might want to error() here (in case symtab is corrupt and
381 will cause a core dump), but maybe we can successfully
382 continue, so let's not. */
384 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
385 paddress (get_objfile_arch (objfile), pc));
386 psymtab_to_symtab (objfile, ps);
387 return ps->compunit_symtab;
392 /* Find which partial symbol within a psymtab matches PC and SECTION.
393 Return NULL if none. */
395 static struct partial_symbol *
396 find_pc_sect_psymbol (struct objfile *objfile,
397 struct partial_symtab *psymtab, CORE_ADDR pc,
398 struct obj_section *section)
400 struct partial_symbol *best = NULL;
402 const CORE_ADDR textlow = psymtab->text_low (objfile);
404 gdb_assert (psymtab != NULL);
406 /* Cope with programs that start at address 0. */
407 best_pc = (textlow != 0) ? textlow - 1 : 0;
409 /* Search the global symbols as well as the static symbols, so that
410 find_pc_partial_function doesn't use a minimal symbol and thus
411 cache a bad endaddr. */
412 for (int i = 0; i < psymtab->n_global_syms; i++)
414 partial_symbol *p = objfile->global_psymbols[psymtab->globals_offset + i];
416 if (p->domain == VAR_DOMAIN
417 && p->aclass == LOC_BLOCK
418 && pc >= p->address (objfile)
419 && (p->address (objfile) > best_pc
420 || (psymtab->text_low (objfile) == 0
421 && best_pc == 0 && p->address (objfile) == 0)))
423 if (section != NULL) /* Match on a specific section. */
425 if (!matching_obj_sections (p->obj_section (objfile),
429 best_pc = p->address (objfile);
434 for (int i = 0; i < psymtab->n_static_syms; i++)
436 partial_symbol *p = objfile->static_psymbols[psymtab->statics_offset + i];
438 if (p->domain == VAR_DOMAIN
439 && p->aclass == LOC_BLOCK
440 && pc >= p->address (objfile)
441 && (p->address (objfile) > best_pc
442 || (psymtab->text_low (objfile) == 0
443 && best_pc == 0 && p->address (objfile) == 0)))
445 if (section != NULL) /* Match on a specific section. */
447 if (!matching_obj_sections (p->obj_section (objfile),
451 best_pc = p->address (objfile);
459 /* Psymtab version of lookup_symbol. See its definition in
460 the definition of quick_symbol_functions in symfile.h. */
462 static struct compunit_symtab *
463 psym_lookup_symbol (struct objfile *objfile,
464 int block_index, const char *name,
465 const domain_enum domain)
467 struct partial_symtab *ps;
468 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
469 struct compunit_symtab *stab_best = NULL;
471 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
473 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
475 if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
476 psymtab_index, domain))
478 struct symbol *sym, *with_opaque = NULL;
479 struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps);
480 /* Note: While psymtab_to_symtab can return NULL if the partial symtab
481 is empty, we can assume it won't here because lookup_partial_symbol
483 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
484 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
486 sym = block_find_symbol (block, name, domain,
487 block_find_non_opaque_type_preferred,
490 /* Some caution must be observed with overloaded functions
491 and methods, since the index will not contain any overload
492 information (but NAME might contain it). */
495 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
497 if (with_opaque != NULL
498 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
501 /* Keep looking through other psymtabs. */
508 /* Returns true if PSYM matches LOOKUP_NAME. */
511 psymbol_name_matches (partial_symbol *psym,
512 const lookup_name_info &lookup_name)
514 const language_defn *lang = language_def (psym->language);
515 symbol_name_matcher_ftype *name_match
516 = get_symbol_name_matcher (lang, lookup_name);
517 return name_match (symbol_search_name (psym), lookup_name, NULL);
520 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
521 the global block of PST if GLOBAL, and otherwise the static block.
522 MATCH is the comparison operation that returns true iff MATCH (s,
523 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
524 non-null, the symbols in the block are assumed to be ordered
525 according to it (allowing binary search). It must be compatible
526 with MATCH. Returns the symbol, if found, and otherwise NULL. */
528 static struct partial_symbol *
529 match_partial_symbol (struct objfile *objfile,
530 struct partial_symtab *pst, int global,
531 const char *name, domain_enum domain,
532 symbol_name_match_type match_type,
533 symbol_compare_ftype *ordered_compare)
535 struct partial_symbol **start, **psym;
536 struct partial_symbol **top, **real_top, **bottom, **center;
537 int length = (global ? pst->n_global_syms : pst->n_static_syms);
538 int do_linear_search = 1;
543 lookup_name_info lookup_name (name, match_type);
546 &objfile->global_psymbols[pst->globals_offset] :
547 &objfile->static_psymbols[pst->statics_offset]);
549 if (global && ordered_compare) /* Can use a binary search. */
551 do_linear_search = 0;
553 /* Binary search. This search is guaranteed to end with center
554 pointing at the earliest partial symbol whose name might be
555 correct. At that point *all* partial symbols with an
556 appropriate name will be checked against the correct
560 top = start + length - 1;
564 center = bottom + (top - bottom) / 2;
565 gdb_assert (center < top);
567 enum language lang = (*center)->language;
569 = lookup_name.language_lookup_name (lang).c_str ();
571 if (ordered_compare (symbol_search_name (*center), lang_ln) >= 0)
576 gdb_assert (top == bottom);
578 while (top <= real_top
579 && psymbol_name_matches (*top, lookup_name))
581 if (symbol_matches_domain ((*top)->language,
582 (*top)->domain, domain))
588 /* Can't use a binary search or else we found during the binary search that
589 we should also do a linear search. */
591 if (do_linear_search)
593 for (psym = start; psym < start + length; psym++)
595 if (symbol_matches_domain ((*psym)->language,
596 (*psym)->domain, domain)
597 && psymbol_name_matches (*psym, lookup_name))
605 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
606 not contain any method/function instance information (since this would
607 force reading type information while reading psymtabs). Therefore,
608 if NAME contains overload information, it must be stripped before searching
611 static gdb::unique_xmalloc_ptr<char>
612 psymtab_search_name (const char *name)
614 switch (current_language->la_language)
618 if (strchr (name, '('))
620 gdb::unique_xmalloc_ptr<char> ret = cp_remove_params (name);
632 return gdb::unique_xmalloc_ptr<char> (xstrdup (name));
635 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
636 Check the global symbols if GLOBAL, the static symbols if not. */
638 static struct partial_symbol *
639 lookup_partial_symbol (struct objfile *objfile,
640 struct partial_symtab *pst, const char *name,
641 int global, domain_enum domain)
643 struct partial_symbol **start, **psym;
644 struct partial_symbol **top, **real_top, **bottom, **center;
645 int length = (global ? pst->n_global_syms : pst->n_static_syms);
646 int do_linear_search = 1;
651 gdb::unique_xmalloc_ptr<char> search_name = psymtab_search_name (name);
653 lookup_name_info lookup_name (search_name.get (), symbol_name_match_type::FULL);
656 &objfile->global_psymbols[pst->globals_offset] :
657 &objfile->static_psymbols[pst->statics_offset]);
659 if (global) /* This means we can use a binary search. */
661 do_linear_search = 0;
663 /* Binary search. This search is guaranteed to end with center
664 pointing at the earliest partial symbol whose name might be
665 correct. At that point *all* partial symbols with an
666 appropriate name will be checked against the correct
670 top = start + length - 1;
674 center = bottom + (top - bottom) / 2;
676 internal_error (__FILE__, __LINE__,
677 _("failed internal consistency check"));
678 if (strcmp_iw_ordered (symbol_search_name (*center),
679 search_name.get ()) >= 0)
688 if (!(top == bottom))
689 internal_error (__FILE__, __LINE__,
690 _("failed internal consistency check"));
692 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
693 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
694 while (top >= start && symbol_matches_search_name (*top, lookup_name))
697 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
700 while (top <= real_top && symbol_matches_search_name (*top, lookup_name))
702 if (symbol_matches_domain ((*top)->language,
703 (*top)->domain, domain))
709 /* Can't use a binary search or else we found during the binary search that
710 we should also do a linear search. */
712 if (do_linear_search)
714 for (psym = start; psym < start + length; psym++)
716 if (symbol_matches_domain ((*psym)->language,
717 (*psym)->domain, domain)
718 && symbol_matches_search_name (*psym, lookup_name))
726 /* Get the symbol table that corresponds to a partial_symtab.
727 This is fast after the first time you do it.
728 The result will be NULL if the primary symtab has no symbols,
729 which can happen. Otherwise the result is the primary symtab
730 that contains PST. */
732 static struct compunit_symtab *
733 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
735 /* If it is a shared psymtab, find an unshared psymtab that includes
736 it. Any such psymtab will do. */
737 while (pst->user != NULL)
740 /* If it's been looked up before, return it. */
741 if (pst->compunit_symtab)
742 return pst->compunit_symtab;
744 /* If it has not yet been read in, read it. */
747 scoped_restore decrementer = increment_reading_symtab ();
749 (*pst->read_symtab) (pst, objfile);
752 return pst->compunit_symtab;
755 /* Psymtab version of find_last_source_symtab. See its definition in
756 the definition of quick_symbol_functions in symfile.h. */
758 static struct symtab *
759 psym_find_last_source_symtab (struct objfile *ofp)
761 struct partial_symtab *ps;
762 struct partial_symtab *cs_pst = NULL;
764 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
766 const char *name = ps->filename;
767 int len = strlen (name);
769 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
770 || strcmp (name, "<<C++-namespaces>>") == 0)))
778 internal_error (__FILE__, __LINE__,
779 _("select_source_symtab: "
780 "readin pst found and no symtabs."));
784 struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
788 return compunit_primary_filetab (cust);
794 /* Psymtab version of forget_cached_source_info. See its definition in
795 the definition of quick_symbol_functions in symfile.h. */
798 psym_forget_cached_source_info (struct objfile *objfile)
800 struct partial_symtab *pst;
802 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
804 if (pst->fullname != NULL)
806 xfree (pst->fullname);
807 pst->fullname = NULL;
813 print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
814 struct partial_symbol **p, int count, const char *what,
815 struct ui_file *outfile)
817 fprintf_filtered (outfile, " %s partial symbols:\n", what);
821 fprintf_filtered (outfile, " `%s'", (*p)->name);
822 if (symbol_demangled_name (*p) != NULL)
824 fprintf_filtered (outfile, " `%s'", symbol_demangled_name (*p));
826 fputs_filtered (", ", outfile);
827 switch ((*p)->domain)
830 fputs_filtered ("undefined domain, ", outfile);
833 /* This is the usual thing -- don't print it. */
836 fputs_filtered ("struct domain, ", outfile);
839 fputs_filtered ("label domain, ", outfile);
842 fputs_filtered ("<invalid domain>, ", outfile);
845 switch ((*p)->aclass)
848 fputs_filtered ("undefined", outfile);
851 fputs_filtered ("constant int", outfile);
854 fputs_filtered ("static", outfile);
857 fputs_filtered ("register", outfile);
860 fputs_filtered ("pass by value", outfile);
863 fputs_filtered ("pass by reference", outfile);
865 case LOC_REGPARM_ADDR:
866 fputs_filtered ("register address parameter", outfile);
869 fputs_filtered ("stack parameter", outfile);
872 fputs_filtered ("type", outfile);
875 fputs_filtered ("label", outfile);
878 fputs_filtered ("function", outfile);
880 case LOC_CONST_BYTES:
881 fputs_filtered ("constant bytes", outfile);
884 fputs_filtered ("unresolved", outfile);
886 case LOC_OPTIMIZED_OUT:
887 fputs_filtered ("optimized out", outfile);
890 fputs_filtered ("computed at runtime", outfile);
893 fputs_filtered ("<invalid location>", outfile);
896 fputs_filtered (", ", outfile);
897 fputs_filtered (paddress (gdbarch, (*p)->unrelocated_address ()), outfile);
898 fprintf_filtered (outfile, "\n");
904 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
905 struct ui_file *outfile)
907 struct gdbarch *gdbarch = get_objfile_arch (objfile);
910 if (psymtab->anonymous)
912 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
917 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
920 fprintf_filtered (outfile, "(object ");
921 gdb_print_host_address (psymtab, outfile);
922 fprintf_filtered (outfile, ")\n\n");
923 fprintf_filtered (outfile, " Read from object file %s (",
924 objfile_name (objfile));
925 gdb_print_host_address (objfile, outfile);
926 fprintf_filtered (outfile, ")\n");
930 fprintf_filtered (outfile,
931 " Full symtab was read (at ");
932 gdb_print_host_address (psymtab->compunit_symtab, outfile);
933 fprintf_filtered (outfile, " by function at ");
934 gdb_print_host_address (psymtab->read_symtab, outfile);
935 fprintf_filtered (outfile, ")\n");
938 fprintf_filtered (outfile, " Symbols cover text addresses ");
939 fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
940 fprintf_filtered (outfile, "-");
941 fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
942 fprintf_filtered (outfile, "\n");
943 fprintf_filtered (outfile, " Address map supported - %s.\n",
944 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
945 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
946 psymtab->number_of_dependencies);
947 for (i = 0; i < psymtab->number_of_dependencies; i++)
949 fprintf_filtered (outfile, " %d ", i);
950 gdb_print_host_address (psymtab->dependencies[i], outfile);
951 fprintf_filtered (outfile, " %s\n",
952 psymtab->dependencies[i]->filename);
954 if (psymtab->user != NULL)
956 fprintf_filtered (outfile, " Shared partial symtab with user ");
957 gdb_print_host_address (psymtab->user, outfile);
958 fprintf_filtered (outfile, "\n");
960 if (psymtab->n_global_syms > 0)
962 print_partial_symbols (gdbarch, objfile,
963 &objfile->global_psymbols[psymtab->globals_offset],
964 psymtab->n_global_syms, "Global", outfile);
966 if (psymtab->n_static_syms > 0)
968 print_partial_symbols (gdbarch, objfile,
969 &objfile->static_psymbols[psymtab->statics_offset],
970 psymtab->n_static_syms, "Static", outfile);
972 fprintf_filtered (outfile, "\n");
975 /* Psymtab version of print_stats. See its definition in
976 the definition of quick_symbol_functions in symfile.h. */
979 psym_print_stats (struct objfile *objfile)
982 struct partial_symtab *ps;
985 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
990 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
993 /* Psymtab version of dump. See its definition in
994 the definition of quick_symbol_functions in symfile.h. */
997 psym_dump (struct objfile *objfile)
999 struct partial_symtab *psymtab;
1001 if (objfile->psymtabs)
1003 printf_filtered ("Psymtabs:\n");
1004 for (psymtab = objfile->psymtabs;
1006 psymtab = psymtab->next)
1008 printf_filtered ("%s at ",
1010 gdb_print_host_address (psymtab, gdb_stdout);
1011 printf_filtered (", ");
1014 printf_filtered ("\n\n");
1018 /* Psymtab version of expand_symtabs_for_function. See its definition in
1019 the definition of quick_symbol_functions in symfile.h. */
1022 psym_expand_symtabs_for_function (struct objfile *objfile,
1023 const char *func_name)
1025 struct partial_symtab *ps;
1027 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1032 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1034 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1036 psymtab_to_symtab (objfile, ps);
1040 /* Psymtab version of expand_all_symtabs. See its definition in
1041 the definition of quick_symbol_functions in symfile.h. */
1044 psym_expand_all_symtabs (struct objfile *objfile)
1046 struct partial_symtab *psymtab;
1048 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1050 psymtab_to_symtab (objfile, psymtab);
1054 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1055 the definition of quick_symbol_functions in symfile.h. */
1058 psym_expand_symtabs_with_fullname (struct objfile *objfile,
1059 const char *fullname)
1061 struct partial_symtab *p;
1063 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1065 /* Anonymous psymtabs don't have a name of a source file. */
1069 /* psymtab_to_fullname tries to open the file which is slow.
1070 Don't call it if we know the basenames don't match. */
1071 if ((basenames_may_differ
1072 || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
1073 && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
1074 psymtab_to_symtab (objfile, p);
1078 /* Psymtab version of map_symbol_filenames. See its definition in
1079 the definition of quick_symbol_functions in symfile.h. */
1082 psym_map_symbol_filenames (struct objfile *objfile,
1083 symbol_filename_ftype *fun, void *data,
1086 struct partial_symtab *ps;
1088 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1090 const char *fullname;
1095 /* We can skip shared psymtabs here, because any file name will be
1096 attached to the unshared psymtab. */
1097 if (ps->user != NULL)
1100 /* Anonymous psymtabs don't have a file name. */
1106 fullname = psymtab_to_fullname (ps);
1109 (*fun) (ps->filename, fullname, data);
1113 /* Finds the fullname that a partial_symtab represents.
1115 If this functions finds the fullname, it will save it in ps->fullname
1116 and it will also return the value.
1118 If this function fails to find the file that this partial_symtab represents,
1119 NULL will be returned and ps->fullname will be set to NULL. */
1122 psymtab_to_fullname (struct partial_symtab *ps)
1124 gdb_assert (!ps->anonymous);
1126 /* Use cached copy if we have it.
1127 We rely on forget_cached_source_info being called appropriately
1128 to handle cases like the file being moved. */
1129 if (ps->fullname == NULL)
1131 gdb::unique_xmalloc_ptr<char> fullname;
1132 int fd = find_and_open_source (ps->filename, ps->dirname, &fullname);
1133 ps->fullname = fullname.release ();
1139 /* rewrite_source_path would be applied by find_and_open_source, we
1140 should report the pathname where GDB tried to find the file. */
1142 if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1143 fullname.reset (xstrdup (ps->filename));
1145 fullname.reset (concat (ps->dirname, SLASH_STRING,
1146 ps->filename, (char *) NULL));
1148 ps->fullname = rewrite_source_path (fullname.get ()).release ();
1149 if (ps->fullname == NULL)
1150 ps->fullname = fullname.release ();
1154 return ps->fullname;
1157 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1158 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1159 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1160 ever returns non-zero, and otherwise returns 0. */
1163 map_block (const char *name, domain_enum domain, struct objfile *objfile,
1164 struct block *block,
1165 int (*callback) (struct block *, struct symbol *, void *),
1166 void *data, symbol_name_match_type match)
1168 struct block_iterator iter;
1171 lookup_name_info lookup_name (name, match);
1173 for (sym = block_iter_match_first (block, lookup_name, &iter);
1175 sym = block_iter_match_next (lookup_name, &iter))
1177 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1178 SYMBOL_DOMAIN (sym), domain))
1180 if (callback (block, sym, data))
1188 /* Psymtab version of map_matching_symbols. See its definition in
1189 the definition of quick_symbol_functions in symfile.h. */
1192 psym_map_matching_symbols (struct objfile *objfile,
1193 const char *name, domain_enum domain,
1195 int (*callback) (struct block *,
1196 struct symbol *, void *),
1198 symbol_name_match_type match,
1199 symbol_compare_ftype *ordered_compare)
1201 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1202 struct partial_symtab *ps;
1204 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1208 || match_partial_symbol (objfile, ps, global, name, domain, match,
1211 struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps);
1212 struct block *block;
1216 block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind);
1217 if (map_block (name, domain, objfile, block,
1218 callback, data, match))
1220 if (callback (block, NULL, data))
1226 /* A helper for psym_expand_symtabs_matching that handles searching
1227 included psymtabs. This returns true if a symbol is found, and
1228 false otherwise. It also updates the 'searched_flag' on the
1229 various psymtabs that it searches. */
1232 recursively_search_psymtabs
1233 (struct partial_symtab *ps, struct objfile *objfile, enum search_domain domain,
1234 const lookup_name_info &lookup_name,
1235 gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
1238 enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND;
1241 if (ps->searched_flag != PST_NOT_SEARCHED)
1242 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1244 /* Recurse into shared psymtabs first, because they may have already
1245 been searched, and this could save some time. */
1246 for (i = 0; i < ps->number_of_dependencies; ++i)
1250 /* Skip non-shared dependencies, these are handled elsewhere. */
1251 if (ps->dependencies[i]->user == NULL)
1254 r = recursively_search_psymtabs (ps->dependencies[i],
1255 objfile, domain, lookup_name,
1259 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1264 partial_symbol **gbound
1265 = objfile->global_psymbols.data () + ps->globals_offset + ps->n_global_syms;
1266 partial_symbol **sbound
1267 = objfile->static_psymbols.data () + ps->statics_offset + ps->n_static_syms;
1268 partial_symbol **bound = gbound;
1270 /* Go through all of the symbols stored in a partial
1271 symtab in one loop. */
1272 partial_symbol **psym = objfile->global_psymbols.data () + ps->globals_offset;
1277 if (bound == gbound && ps->n_static_syms != 0)
1279 psym = objfile->static_psymbols.data () + ps->statics_offset;
1290 if ((domain == ALL_DOMAIN
1291 || (domain == VARIABLES_DOMAIN
1292 && (*psym)->aclass != LOC_TYPEDEF
1293 && (*psym)->aclass != LOC_BLOCK)
1294 || (domain == FUNCTIONS_DOMAIN
1295 && (*psym)->aclass == LOC_BLOCK)
1296 || (domain == TYPES_DOMAIN
1297 && (*psym)->aclass == LOC_TYPEDEF))
1298 && psymbol_name_matches (*psym, lookup_name)
1299 && (sym_matcher == NULL || sym_matcher (symbol_search_name (*psym))))
1301 /* Found a match, so notify our caller. */
1302 result = PST_SEARCHED_AND_FOUND;
1309 ps->searched_flag = result;
1310 return result == PST_SEARCHED_AND_FOUND;
1313 /* Psymtab version of expand_symtabs_matching. See its definition in
1314 the definition of quick_symbol_functions in symfile.h. */
1317 psym_expand_symtabs_matching
1318 (struct objfile *objfile,
1319 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
1320 const lookup_name_info &lookup_name_in,
1321 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
1322 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
1323 enum search_domain domain)
1325 struct partial_symtab *ps;
1327 lookup_name_info lookup_name = lookup_name_in.make_ignore_params ();
1329 /* Clear the search flags. */
1330 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1332 ps->searched_flag = PST_NOT_SEARCHED;
1335 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1342 /* We skip shared psymtabs because file-matching doesn't apply
1343 to them; but we search them later in the loop. */
1344 if (ps->user != NULL)
1354 match = file_matcher (ps->filename, false);
1357 /* Before we invoke realpath, which can get expensive when many
1358 files are involved, do a quick comparison of the basenames. */
1359 if (basenames_may_differ
1360 || file_matcher (lbasename (ps->filename), true))
1361 match = file_matcher (psymtab_to_fullname (ps), false);
1367 if (recursively_search_psymtabs (ps, objfile, domain,
1368 lookup_name, symbol_matcher))
1370 struct compunit_symtab *symtab =
1371 psymtab_to_symtab (objfile, ps);
1373 if (expansion_notify != NULL)
1374 expansion_notify (symtab);
1379 /* Psymtab version of has_symbols. See its definition in
1380 the definition of quick_symbol_functions in symfile.h. */
1383 psym_has_symbols (struct objfile *objfile)
1385 return objfile->psymtabs != NULL;
1388 /* Helper function for psym_find_compunit_symtab_by_address that fills
1389 in psymbol_map for a given range of psymbols. */
1392 psym_fill_psymbol_map (struct objfile *objfile,
1393 struct partial_symtab *psymtab,
1394 std::set<CORE_ADDR> *seen_addrs,
1395 const std::vector<partial_symbol *> &symbols,
1399 for (int i = 0; i < length; ++i)
1401 struct partial_symbol *psym = symbols[start + i];
1403 if (psym->aclass == LOC_STATIC)
1405 CORE_ADDR addr = psym->address (objfile);
1406 if (seen_addrs->find (addr) == seen_addrs->end ())
1408 seen_addrs->insert (addr);
1409 objfile->psymbol_map.emplace_back (addr, psymtab);
1415 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1418 static compunit_symtab *
1419 psym_find_compunit_symtab_by_address (struct objfile *objfile,
1422 if (objfile->psymbol_map.empty ())
1424 struct partial_symtab *pst;
1426 std::set<CORE_ADDR> seen_addrs;
1428 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1430 psym_fill_psymbol_map (objfile, pst,
1432 objfile->global_psymbols,
1433 pst->globals_offset,
1434 pst->n_global_syms);
1435 psym_fill_psymbol_map (objfile, pst,
1437 objfile->static_psymbols,
1438 pst->statics_offset,
1439 pst->n_static_syms);
1442 objfile->psymbol_map.shrink_to_fit ();
1444 std::sort (objfile->psymbol_map.begin (), objfile->psymbol_map.end (),
1445 [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1446 const std::pair<CORE_ADDR, partial_symtab *> &b)
1448 return a.first < b.first;
1452 auto iter = std::lower_bound
1453 (objfile->psymbol_map.begin (), objfile->psymbol_map.end (), address,
1454 [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1460 if (iter == objfile->psymbol_map.end () || iter->first != address)
1463 return psymtab_to_symtab (objfile, iter->second);
1466 const struct quick_symbol_functions psym_functions =
1469 psym_find_last_source_symtab,
1470 psym_forget_cached_source_info,
1471 psym_map_symtabs_matching_filename,
1475 psym_expand_symtabs_for_function,
1476 psym_expand_all_symtabs,
1477 psym_expand_symtabs_with_fullname,
1478 psym_map_matching_symbols,
1479 psym_expand_symtabs_matching,
1480 psym_find_pc_sect_compunit_symtab,
1481 psym_find_compunit_symtab_by_address,
1482 psym_map_symbol_filenames
1488 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1490 /* Sort the global list; don't sort the static list. */
1491 auto begin = objfile->global_psymbols.begin ();
1492 std::advance (begin, pst->globals_offset);
1494 /* The psymbols for this partial_symtab are currently at the end of the
1496 auto end = objfile->global_psymbols.end ();
1498 std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
1500 return strcmp_iw_ordered (symbol_search_name (s1),
1501 symbol_search_name (s2)) < 0;
1505 /* Allocate and partially fill a partial symtab. It will be
1506 completely filled at the end of the symbol list.
1508 FILENAME is the name of the symbol-file we are reading from. */
1510 struct partial_symtab *
1511 start_psymtab_common (struct objfile *objfile,
1512 const char *filename,
1514 std::vector<partial_symbol *> &global_psymbols,
1515 std::vector<partial_symbol *> &static_psymbols)
1517 struct partial_symtab *psymtab;
1519 psymtab = allocate_psymtab (filename, objfile);
1520 psymtab->set_text_low (textlow);
1521 psymtab->set_text_high (psymtab->raw_text_low ()); /* default */
1522 psymtab->globals_offset = global_psymbols.size ();
1523 psymtab->statics_offset = static_psymbols.size ();
1527 /* Perform "finishing up" operations of a partial symtab. */
1530 end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
1532 pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
1533 pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
1535 sort_pst_symbols (objfile, pst);
1538 /* Calculate a hash code for the given partial symbol. The hash is
1539 calculated using the symbol's value, language, domain, class
1540 and name. These are the values which are set by
1541 add_psymbol_to_bcache. */
1543 static unsigned long
1544 psymbol_hash (const void *addr, int length)
1546 unsigned long h = 0;
1547 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1548 unsigned int lang = psymbol->language;
1549 unsigned int domain = psymbol->domain;
1550 unsigned int theclass = psymbol->aclass;
1552 h = hash_continue (&psymbol->value, sizeof (psymbol->value), h);
1553 h = hash_continue (&lang, sizeof (unsigned int), h);
1554 h = hash_continue (&domain, sizeof (unsigned int), h);
1555 h = hash_continue (&theclass, sizeof (unsigned int), h);
1556 /* Note that psymbol names are interned via symbol_set_names, so
1557 there's no need to hash the contents of the name here. */
1558 h = hash_continue (&psymbol->name,
1559 sizeof (psymbol->name), h);
1564 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1565 For the comparison this function uses a symbols value,
1566 language, domain, class and name. */
1569 psymbol_compare (const void *addr1, const void *addr2, int length)
1571 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1572 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1574 return (memcmp (&sym1->value, &sym2->value,
1575 sizeof (sym1->value)) == 0
1576 && sym1->language == sym2->language
1577 && sym1->domain == sym2->domain
1578 && sym1->aclass == sym2->aclass
1579 /* Note that psymbol names are interned via
1580 symbol_set_names, so there's no need to compare the
1581 contents of the name here. */
1582 && sym1->name == sym2->name);
1585 /* Initialize a partial symbol bcache. */
1587 struct psymbol_bcache *
1588 psymbol_bcache_init (void)
1590 struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
1592 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1596 /* Free a partial symbol bcache. */
1599 psymbol_bcache_free (struct psymbol_bcache *bcache)
1604 bcache_xfree (bcache->bcache);
1608 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1611 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1613 return bcache->bcache;
1616 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1617 symbol before, add a copy to BCACHE. In either case, return a pointer
1618 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1619 1 in case of new entry or 0 if returning an old entry. */
1621 static struct partial_symbol *
1622 psymbol_bcache_full (struct partial_symbol *sym,
1623 struct psymbol_bcache *bcache,
1626 return ((struct partial_symbol *)
1627 bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache,
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 struct partial_symbol *
1638 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1640 enum address_class theclass,
1643 enum language language, struct objfile *objfile,
1646 struct partial_symbol psymbol;
1648 psymbol.set_unrelocated_address (coreaddr);
1649 psymbol.section = section;
1650 psymbol.domain = domain;
1651 psymbol.aclass = theclass;
1653 memset (&psymbol.language_specific, 0, sizeof (psymbol.language_specific));
1654 psymbol.ada_mangled = 0;
1655 symbol_set_language (&psymbol, language, &objfile->objfile_obstack);
1656 symbol_set_names (&psymbol, name, namelength, copy_name, objfile);
1658 /* Stash the partial symbol away in the cache. */
1659 return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
1662 /* Helper function, adds partial symbol to the given partial symbol list. */
1665 append_psymbol_to_list (std::vector<partial_symbol *> *list,
1666 struct partial_symbol *psym,
1667 struct objfile *objfile)
1669 list->push_back (psym);
1670 OBJSTAT (objfile, n_psyms++);
1673 /* Add a symbol with a long value to a psymtab.
1674 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1675 The only value we need to store for psyms is an address.
1676 For all other psyms pass zero for COREADDR.
1677 Return the partial symbol that has been added. */
1680 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1682 enum address_class theclass,
1684 std::vector<partial_symbol *> *list,
1686 enum language language, struct objfile *objfile)
1688 struct partial_symbol *psym;
1692 /* Stash the partial symbol away in the cache. */
1693 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass,
1694 section, coreaddr, language, objfile, &added);
1696 /* Do not duplicate global partial symbols. */
1697 if (list == &objfile->global_psymbols
1701 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1702 append_psymbol_to_list (list, psym, objfile);
1705 /* Initialize storage for partial symbols. */
1708 init_psymbol_list (struct objfile *objfile, int total_symbols)
1710 /* Free any previously allocated psymbol lists. */
1711 objfile->global_psymbols.clear ();
1712 objfile->static_psymbols.clear ();
1714 /* Current best guess is that approximately a twentieth
1715 of the total symbols (in a debugging file) are global or static
1716 oriented symbols, then multiply that by slop factor of two. */
1717 objfile->global_psymbols.reserve (total_symbols / 10);
1718 objfile->static_psymbols.reserve (total_symbols / 10);
1721 struct partial_symtab *
1722 allocate_psymtab (const char *filename, struct objfile *objfile)
1724 struct partial_symtab *psymtab;
1726 if (objfile->free_psymtabs)
1728 psymtab = objfile->free_psymtabs;
1729 objfile->free_psymtabs = psymtab->next;
1732 psymtab = XOBNEW (&objfile->objfile_obstack, partial_symtab);
1734 memset (psymtab, 0, sizeof (struct partial_symtab));
1736 = (const char *) bcache (filename, strlen (filename) + 1,
1737 objfile->per_bfd->filename_cache);
1738 psymtab->compunit_symtab = NULL;
1740 /* Prepend it to the psymtab list for the objfile it belongs to.
1741 Psymtabs are searched in most recent inserted -> least recent
1744 psymtab->next = objfile->psymtabs;
1745 objfile->psymtabs = psymtab;
1747 if (symtab_create_debug)
1749 /* Be a bit clever with debugging messages, and don't print objfile
1750 every time, only when it changes. */
1751 static char *last_objfile_name = NULL;
1753 if (last_objfile_name == NULL
1754 || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1756 xfree (last_objfile_name);
1757 last_objfile_name = xstrdup (objfile_name (objfile));
1758 fprintf_filtered (gdb_stdlog,
1759 "Creating one or more psymtabs for objfile %s ...\n",
1762 fprintf_filtered (gdb_stdlog,
1763 "Created psymtab %s for module %s.\n",
1764 host_address_to_string (psymtab), filename);
1771 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1773 struct partial_symtab **prev_pst;
1776 Empty psymtabs happen as a result of header files which don't
1777 have any symbols in them. There can be a lot of them. But this
1778 check is wrong, in that a psymtab with N_SLINE entries but
1779 nothing else is not empty, but we don't realize that. Fixing
1780 that without slowing things down might be tricky. */
1782 /* First, snip it out of the psymtab chain. */
1784 prev_pst = &(objfile->psymtabs);
1785 while ((*prev_pst) != pst)
1786 prev_pst = &((*prev_pst)->next);
1787 (*prev_pst) = pst->next;
1789 /* Next, put it on a free list for recycling. */
1791 pst->next = objfile->free_psymtabs;
1792 objfile->free_psymtabs = pst;
1797 /* We need to pass a couple of items to the addrmap_foreach function,
1800 struct dump_psymtab_addrmap_data
1802 struct objfile *objfile;
1803 struct partial_symtab *psymtab;
1804 struct ui_file *outfile;
1806 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1807 If so, we want to print the next one as well (since the next addrmap
1808 entry defines the end of the range). */
1809 int previous_matched;
1812 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1815 dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj)
1817 struct dump_psymtab_addrmap_data *data
1818 = (struct dump_psymtab_addrmap_data *) datap;
1819 struct gdbarch *gdbarch = get_objfile_arch (data->objfile);
1820 struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj;
1821 const char *psymtab_address_or_end = NULL;
1825 if (data->psymtab == NULL
1826 || data->psymtab == addrmap_psymtab)
1827 psymtab_address_or_end = host_address_to_string (addrmap_psymtab);
1828 else if (data->previous_matched)
1829 psymtab_address_or_end = "<ends here>";
1831 if (data->psymtab == NULL
1832 || data->psymtab == addrmap_psymtab
1833 || data->previous_matched)
1835 fprintf_filtered (data->outfile, " %s%s %s\n",
1836 data->psymtab != NULL ? " " : "",
1837 paddress (gdbarch, start_addr),
1838 psymtab_address_or_end);
1841 data->previous_matched = (data->psymtab == NULL
1842 || data->psymtab == addrmap_psymtab);
1847 /* Helper function for maintenance_print_psymbols to print the addrmap
1848 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1851 dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab,
1852 struct ui_file *outfile)
1854 struct dump_psymtab_addrmap_data addrmap_dump_data;
1856 if ((psymtab == NULL
1857 || psymtab->psymtabs_addrmap_supported)
1858 && objfile->psymtabs_addrmap != NULL)
1860 addrmap_dump_data.objfile = objfile;
1861 addrmap_dump_data.psymtab = psymtab;
1862 addrmap_dump_data.outfile = outfile;
1863 addrmap_dump_data.previous_matched = 0;
1864 fprintf_filtered (outfile, "%sddress map:\n",
1865 psymtab == NULL ? "Entire a" : " A");
1866 addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1,
1867 &addrmap_dump_data);
1872 maintenance_print_psymbols (const char *args, int from_tty)
1874 struct ui_file *outfile = gdb_stdout;
1875 char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
1876 struct objfile *objfile;
1877 struct partial_symtab *ps;
1878 int i, outfile_idx, found;
1880 struct obj_section *section = NULL;
1884 gdb_argv argv (args);
1886 for (i = 0; argv != NULL && argv[i] != NULL; ++i)
1888 if (strcmp (argv[i], "-pc") == 0)
1890 if (argv[i + 1] == NULL)
1891 error (_("Missing pc value"));
1892 address_arg = argv[++i];
1894 else if (strcmp (argv[i], "-source") == 0)
1896 if (argv[i + 1] == NULL)
1897 error (_("Missing source file"));
1898 source_arg = argv[++i];
1900 else if (strcmp (argv[i], "-objfile") == 0)
1902 if (argv[i + 1] == NULL)
1903 error (_("Missing objfile name"));
1904 objfile_arg = argv[++i];
1906 else if (strcmp (argv[i], "--") == 0)
1908 /* End of options. */
1912 else if (argv[i][0] == '-')
1914 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1915 error (_("Unknown option: %s"), argv[i]);
1922 if (address_arg != NULL && source_arg != NULL)
1923 error (_("Must specify at most one of -pc and -source"));
1925 stdio_file arg_outfile;
1927 if (argv != NULL && argv[outfile_idx] != NULL)
1929 if (argv[outfile_idx + 1] != NULL)
1930 error (_("Junk at end of command"));
1931 gdb::unique_xmalloc_ptr<char> outfile_name
1932 (tilde_expand (argv[outfile_idx]));
1933 if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
1934 perror_with_name (outfile_name.get ());
1935 outfile = &arg_outfile;
1938 if (address_arg != NULL)
1940 pc = parse_and_eval_address (address_arg);
1941 /* If we fail to find a section, that's ok, try the lookup anyway. */
1942 section = find_pc_section (pc);
1946 ALL_OBJFILES (objfile)
1948 int printed_objfile_header = 0;
1949 int print_for_objfile = 1;
1952 if (objfile_arg != NULL)
1954 = compare_filenames_for_search (objfile_name (objfile),
1956 if (!print_for_objfile)
1959 if (address_arg != NULL)
1961 struct bound_minimal_symbol msymbol = { NULL, NULL };
1963 /* We don't assume each pc has a unique objfile (this is for
1965 ps = find_pc_sect_psymtab (objfile, pc, section, msymbol);
1968 if (!printed_objfile_header)
1970 outfile->printf ("\nPartial symtabs for objfile %s\n",
1971 objfile_name (objfile));
1972 printed_objfile_header = 1;
1974 dump_psymtab (objfile, ps, outfile);
1975 dump_psymtab_addrmap (objfile, ps, outfile);
1981 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1983 int print_for_source = 0;
1986 if (source_arg != NULL)
1989 = compare_filenames_for_search (ps->filename, source_arg);
1992 if (source_arg == NULL
1993 || print_for_source)
1995 if (!printed_objfile_header)
1997 outfile->printf ("\nPartial symtabs for objfile %s\n",
1998 objfile_name (objfile));
1999 printed_objfile_header = 1;
2001 dump_psymtab (objfile, ps, outfile);
2002 dump_psymtab_addrmap (objfile, ps, outfile);
2007 /* If we're printing all the objfile's symbols dump the full addrmap. */
2009 if (address_arg == NULL
2010 && source_arg == NULL
2011 && objfile->psymtabs_addrmap != NULL)
2013 outfile->puts ("\n");
2014 dump_psymtab_addrmap (objfile, NULL, outfile);
2020 if (address_arg != NULL)
2021 error (_("No partial symtab for address: %s"), address_arg);
2022 if (source_arg != NULL)
2023 error (_("No partial symtab for source file: %s"), source_arg);
2027 /* List all the partial symbol tables whose names match REGEXP (optional). */
2030 maintenance_info_psymtabs (const char *regexp, int from_tty)
2032 struct program_space *pspace;
2033 struct objfile *objfile;
2038 ALL_PSPACES (pspace)
2039 ALL_PSPACE_OBJFILES (pspace, objfile)
2041 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2042 struct partial_symtab *psymtab;
2044 /* We don't want to print anything for this objfile until we
2045 actually find a symtab whose name matches. */
2046 int printed_objfile_start = 0;
2048 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
2053 || re_exec (psymtab->filename))
2055 if (! printed_objfile_start)
2057 printf_filtered ("{ objfile %s ", objfile_name (objfile));
2059 printf_filtered ("((struct objfile *) %s)\n",
2060 host_address_to_string (objfile));
2061 printed_objfile_start = 1;
2064 printf_filtered (" { psymtab %s ", psymtab->filename);
2066 printf_filtered ("((struct partial_symtab *) %s)\n",
2067 host_address_to_string (psymtab));
2069 printf_filtered (" readin %s\n",
2070 psymtab->readin ? "yes" : "no");
2071 printf_filtered (" fullname %s\n",
2073 ? psymtab->fullname : "(null)");
2074 printf_filtered (" text addresses ");
2075 fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)),
2077 printf_filtered (" -- ");
2078 fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)),
2080 printf_filtered ("\n");
2081 printf_filtered (" psymtabs_addrmap_supported %s\n",
2082 (psymtab->psymtabs_addrmap_supported
2084 printf_filtered (" globals ");
2085 if (psymtab->n_global_syms)
2087 auto p = &objfile->global_psymbols[psymtab->globals_offset];
2089 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2090 host_address_to_string (p),
2091 psymtab->n_global_syms);
2094 printf_filtered ("(none)\n");
2095 printf_filtered (" statics ");
2096 if (psymtab->n_static_syms)
2098 auto p = &objfile->static_psymbols[psymtab->statics_offset];
2100 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2101 host_address_to_string (p),
2102 psymtab->n_static_syms);
2105 printf_filtered ("(none)\n");
2106 printf_filtered (" dependencies ");
2107 if (psymtab->number_of_dependencies)
2111 printf_filtered ("{\n");
2112 for (i = 0; i < psymtab->number_of_dependencies; i++)
2114 struct partial_symtab *dep = psymtab->dependencies[i];
2116 /* Note the string concatenation there --- no comma. */
2117 printf_filtered (" psymtab %s "
2118 "((struct partial_symtab *) %s)\n",
2120 host_address_to_string (dep));
2122 printf_filtered (" }\n");
2125 printf_filtered ("(none)\n");
2126 printf_filtered (" }\n");
2130 if (printed_objfile_start)
2131 printf_filtered ("}\n");
2135 /* Check consistency of currently expanded psymtabs vs symtabs. */
2138 maintenance_check_psymtabs (const char *ignore, int from_tty)
2141 struct compunit_symtab *cust = NULL;
2142 struct partial_symtab *ps;
2143 const struct blockvector *bv;
2144 struct objfile *objfile;
2148 ALL_PSYMTABS (objfile, ps)
2150 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2152 /* We don't call psymtab_to_symtab here because that may cause symtab
2153 expansion. When debugging a problem it helps if checkers leave
2154 things unchanged. */
2155 cust = ps->compunit_symtab;
2157 /* First do some checks that don't require the associated symtab. */
2158 if (ps->text_high (objfile) < ps->text_low (objfile))
2160 printf_filtered ("Psymtab ");
2161 puts_filtered (ps->filename);
2162 printf_filtered (" covers bad range ");
2163 fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2165 printf_filtered (" - ");
2166 fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2168 printf_filtered ("\n");
2172 /* Now do checks requiring the associated symtab. */
2175 bv = COMPUNIT_BLOCKVECTOR (cust);
2176 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2177 partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
2178 length = ps->n_static_syms;
2181 sym = block_lookup_symbol (b, symbol_search_name (*psym),
2182 symbol_name_match_type::SEARCH_NAME,
2186 printf_filtered ("Static symbol `");
2187 puts_filtered ((*psym)->name);
2188 printf_filtered ("' only found in ");
2189 puts_filtered (ps->filename);
2190 printf_filtered (" psymtab\n");
2194 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2195 psym = &objfile->global_psymbols[ps->globals_offset];
2196 length = ps->n_global_syms;
2199 sym = block_lookup_symbol (b, symbol_search_name (*psym),
2200 symbol_name_match_type::SEARCH_NAME,
2204 printf_filtered ("Global symbol `");
2205 puts_filtered ((*psym)->name);
2206 printf_filtered ("' only found in ");
2207 puts_filtered (ps->filename);
2208 printf_filtered (" psymtab\n");
2212 if (ps->raw_text_high () != 0
2213 && (ps->text_low (objfile) < BLOCK_START (b)
2214 || ps->text_high (objfile) > BLOCK_END (b)))
2216 printf_filtered ("Psymtab ");
2217 puts_filtered (ps->filename);
2218 printf_filtered (" covers ");
2219 fputs_filtered (paddress (gdbarch, ps->text_low (objfile)),
2221 printf_filtered (" - ");
2222 fputs_filtered (paddress (gdbarch, ps->text_high (objfile)),
2224 printf_filtered (" but symtab covers only ");
2225 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2226 printf_filtered (" - ");
2227 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2228 printf_filtered ("\n");
2234 _initialize_psymtab (void)
2236 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2237 Print dump of current partial symbol definitions.\n\
2238 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2239 mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2240 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2241 or the terminal if OUTFILE is unspecified.\n\
2242 If ADDRESS is provided, dump only the file for that address.\n\
2243 If SOURCE is provided, dump only that file's symbols.\n\
2244 If OBJFILE is provided, dump only that file's minimal symbols."),
2245 &maintenanceprintlist);
2247 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2248 List the partial symbol tables for all object files.\n\
2249 This does not include information about individual partial symbols,\n\
2250 just the symbol table structures themselves."),
2251 &maintenanceinfolist);
2253 add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2255 Check consistency of currently expanded psymtabs versus symtabs."),