1 /* Partial symbol tables.
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_assert.h"
26 #include "filenames.h"
33 #include "readline/readline.h"
34 #include "gdb_regex.h"
35 #include "dictionary.h"
37 #include "cp-support.h"
41 #define DEV_TTY "/dev/tty"
46 struct bcache *bcache;
49 static struct partial_symbol *match_partial_symbol (struct objfile *,
50 struct partial_symtab *,
52 const char *, domain_enum,
53 symbol_compare_ftype *,
54 symbol_compare_ftype *);
56 static struct partial_symbol *lookup_partial_symbol (struct objfile *,
57 struct partial_symtab *,
61 static const char *psymtab_to_fullname (struct partial_symtab *ps);
63 static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
64 struct partial_symtab *,
66 struct obj_section *);
68 static void fixup_psymbol_section (struct partial_symbol *psym,
69 struct objfile *objfile);
71 static struct symtab *psymtab_to_symtab (struct objfile *objfile,
72 struct partial_symtab *pst);
74 /* Ensure that the partial symbols for OBJFILE have been loaded. This
75 function always returns its argument, as a convenience. */
78 require_partial_symbols (struct objfile *objfile, int verbose)
80 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
82 objfile->flags |= OBJF_PSYMTABS_READ;
84 if (objfile->sf->sym_read_psymbols)
88 printf_unfiltered (_("Reading symbols from %s..."),
90 gdb_flush (gdb_stdout);
92 (*objfile->sf->sym_read_psymbols) (objfile);
95 if (!objfile_has_symbols (objfile))
98 printf_unfiltered (_("(no debugging symbols found)..."));
102 printf_unfiltered (_("done.\n"));
110 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
113 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
114 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
118 /* We want to make sure this file always requires psymtabs. */
120 #undef ALL_OBJFILE_PSYMTABS
122 /* Traverse all psymtabs in all objfiles. */
124 #define ALL_PSYMTABS(objfile, p) \
125 ALL_OBJFILES (objfile) \
126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
128 /* Helper function for partial_map_symtabs_matching_filename that
129 expands the symtabs and calls the iterator. */
132 partial_map_expand_apply (struct objfile *objfile,
134 const char *full_path,
135 const char *real_path,
136 struct partial_symtab *pst,
137 int (*callback) (struct symtab *, void *),
140 struct symtab *last_made = objfile->symtabs;
142 /* Shared psymtabs should never be seen here. Instead they should
143 be handled properly by the caller. */
144 gdb_assert (pst->user == NULL);
146 /* Don't visit already-expanded psymtabs. */
150 /* This may expand more than one symtab, and we want to iterate over
152 psymtab_to_symtab (objfile, pst);
154 return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
155 objfile->symtabs, last_made);
158 /* Implementation of the map_symtabs_matching_filename method. */
161 partial_map_symtabs_matching_filename (struct objfile *objfile,
163 const char *full_path,
164 const char *real_path,
165 int (*callback) (struct symtab *,
169 struct partial_symtab *pst;
170 const char *name_basename = lbasename (name);
171 int is_abs = IS_ABSOLUTE_PATH (name);
173 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
175 /* We can skip shared psymtabs here, because any file name will be
176 attached to the unshared psymtab. */
177 if (pst->user != NULL)
180 /* Anonymous psymtabs don't have a file name. */
184 if (FILENAME_CMP (name, pst->filename) == 0
185 || (!is_abs && compare_filenames_for_search (pst->filename, name)))
187 if (partial_map_expand_apply (objfile, name, full_path, real_path,
188 pst, callback, data))
192 /* Before we invoke realpath, which can get expensive when many
193 files are involved, do a quick comparison of the basenames. */
194 if (! basenames_may_differ
195 && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
198 /* If the user gave us an absolute path, try to find the file in
199 this symtab and use its absolute path. */
200 if (full_path != NULL)
202 psymtab_to_fullname (pst);
203 if (pst->fullname != NULL
204 && (FILENAME_CMP (full_path, pst->fullname) == 0
205 || (!is_abs && compare_filenames_for_search (pst->fullname,
208 if (partial_map_expand_apply (objfile, name, full_path, real_path,
209 pst, callback, data))
214 if (real_path != NULL)
217 psymtab_to_fullname (pst);
218 if (pst->fullname != NULL)
220 rp = gdb_realpath (pst->fullname);
221 make_cleanup (xfree, rp);
224 && (FILENAME_CMP (real_path, rp) == 0
225 || (!is_abs && compare_filenames_for_search (real_path, name))))
227 if (partial_map_expand_apply (objfile, name, full_path, real_path,
228 pst, callback, data))
237 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
238 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
240 static struct partial_symtab *
241 find_pc_sect_psymtab_closer (struct objfile *objfile,
242 CORE_ADDR pc, struct obj_section *section,
243 struct partial_symtab *pst,
244 struct minimal_symbol *msymbol)
246 struct partial_symtab *tpst;
247 struct partial_symtab *best_pst = pst;
248 CORE_ADDR best_addr = pst->textlow;
250 gdb_assert (!pst->psymtabs_addrmap_supported);
252 /* An objfile that has its functions reordered might have
253 many partial symbol tables containing the PC, but
254 we want the partial symbol table that contains the
255 function containing the PC. */
256 if (!(objfile->flags & OBJF_REORDERED) &&
257 section == 0) /* Can't validate section this way. */
263 /* The code range of partial symtabs sometimes overlap, so, in
264 the loop below, we need to check all partial symtabs and
265 find the one that fits better for the given PC address. We
266 select the partial symtab that contains a symbol whose
267 address is closest to the PC address. By closest we mean
268 that find_pc_sect_symbol returns the symbol with address
269 that is closest and still less than the given PC. */
270 for (tpst = pst; tpst != NULL; tpst = tpst->next)
272 if (pc >= tpst->textlow && pc < tpst->texthigh)
274 struct partial_symbol *p;
277 /* NOTE: This assumes that every psymbol has a
278 corresponding msymbol, which is not necessarily
279 true; the debug info might be much richer than the
280 object's symbol table. */
281 p = find_pc_sect_psymbol (objfile, tpst, pc, section);
283 && SYMBOL_VALUE_ADDRESS (p)
284 == SYMBOL_VALUE_ADDRESS (msymbol))
287 /* Also accept the textlow value of a psymtab as a
288 "symbol", to provide some support for partial
289 symbol tables with line information but no debug
290 symbols (e.g. those produced by an assembler). */
292 this_addr = SYMBOL_VALUE_ADDRESS (p);
294 this_addr = tpst->textlow;
296 /* Check whether it is closer than our current
297 BEST_ADDR. Since this symbol address is
298 necessarily lower or equal to PC, the symbol closer
299 to PC is the symbol which address is the highest.
300 This way we return the psymtab which contains such
301 best match symbol. This can help in cases where the
302 symbol information/debuginfo is not complete, like
303 for instance on IRIX6 with gcc, where no debug info
304 is emitted for statics. (See also the nodebug.exp
306 if (this_addr > best_addr)
308 best_addr = this_addr;
316 /* Find which partial symtab contains PC and SECTION. Return 0 if
317 none. We return the psymtab that contains a symbol whose address
318 exactly matches PC, or, if we cannot find an exact match, the
319 psymtab that contains a symbol whose address is closest to PC. */
320 static struct partial_symtab *
321 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
322 struct obj_section *section,
323 struct minimal_symbol *msymbol)
325 struct partial_symtab *pst;
327 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
328 than the later used TEXTLOW/TEXTHIGH one. */
330 if (objfile->psymtabs_addrmap != NULL)
332 pst = addrmap_find (objfile->psymtabs_addrmap, pc);
335 /* FIXME: addrmaps currently do not handle overlayed sections,
336 so fall back to the non-addrmap case if we're debugging
337 overlays and the addrmap returned the wrong section. */
338 if (overlay_debugging && msymbol && section)
340 struct partial_symbol *p;
342 /* NOTE: This assumes that every psymbol has a
343 corresponding msymbol, which is not necessarily
344 true; the debug info might be much richer than the
345 object's symbol table. */
346 p = find_pc_sect_psymbol (objfile, pst, pc, section);
348 || SYMBOL_VALUE_ADDRESS (p)
349 != SYMBOL_VALUE_ADDRESS (msymbol))
353 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
354 PSYMTABS_ADDRMAP we used has already the best 1-byte
355 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
356 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
365 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
366 which still have no corresponding full SYMTABs read. But it is not
367 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
370 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
371 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
372 debug info type in single OBJFILE. */
374 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
375 if (!pst->psymtabs_addrmap_supported
376 && pc >= pst->textlow && pc < pst->texthigh)
378 struct partial_symtab *best_pst;
380 best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
382 if (best_pst != NULL)
389 static struct symtab *
390 find_pc_sect_symtab_from_partial (struct objfile *objfile,
391 struct minimal_symbol *msymbol,
392 CORE_ADDR pc, struct obj_section *section,
395 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
399 if (warn_if_readin && ps->readin)
400 /* Might want to error() here (in case symtab is corrupt and
401 will cause a core dump), but maybe we can successfully
402 continue, so let's not. */
404 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
405 paddress (get_objfile_arch (objfile), pc));
406 psymtab_to_symtab (objfile, ps);
412 /* Find which partial symbol within a psymtab matches PC and SECTION.
415 static struct partial_symbol *
416 find_pc_sect_psymbol (struct objfile *objfile,
417 struct partial_symtab *psymtab, CORE_ADDR pc,
418 struct obj_section *section)
420 struct partial_symbol *best = NULL, *p, **pp;
423 gdb_assert (psymtab != NULL);
425 /* Cope with programs that start at address 0. */
426 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
428 /* Search the global symbols as well as the static symbols, so that
429 find_pc_partial_function doesn't use a minimal symbol and thus
430 cache a bad endaddr. */
431 for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
432 (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
433 < psymtab->n_global_syms);
437 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
438 && SYMBOL_CLASS (p) == LOC_BLOCK
439 && pc >= SYMBOL_VALUE_ADDRESS (p)
440 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
441 || (psymtab->textlow == 0
442 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
444 if (section) /* Match on a specific section. */
446 fixup_psymbol_section (p, objfile);
447 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
450 best_pc = SYMBOL_VALUE_ADDRESS (p);
455 for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
456 (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
457 < psymtab->n_static_syms);
461 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
462 && SYMBOL_CLASS (p) == LOC_BLOCK
463 && pc >= SYMBOL_VALUE_ADDRESS (p)
464 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
465 || (psymtab->textlow == 0
466 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
468 if (section) /* Match on a specific section. */
470 fixup_psymbol_section (p, objfile);
471 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
474 best_pc = SYMBOL_VALUE_ADDRESS (p);
483 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
487 if (psym == NULL || SYMBOL_OBJ_SECTION (psym) != NULL)
490 gdb_assert (objfile);
492 switch (SYMBOL_CLASS (psym))
497 addr = SYMBOL_VALUE_ADDRESS (psym);
500 /* Nothing else will be listed in the minsyms -- no use looking
505 fixup_section (&psym->ginfo, addr, objfile);
508 static struct symtab *
509 lookup_symbol_aux_psymtabs (struct objfile *objfile,
510 int block_index, const char *name,
511 const domain_enum domain)
513 struct partial_symtab *ps;
514 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
515 struct symtab *stab_best = NULL;
517 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
519 if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
520 psymtab_index, domain))
522 struct symbol *sym = NULL;
523 struct symtab *stab = psymtab_to_symtab (objfile, ps);
525 /* Some caution must be observed with overloaded functions
526 and methods, since the psymtab will not contain any overload
527 information (but NAME might contain it). */
530 struct blockvector *bv = BLOCKVECTOR (stab);
531 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
533 sym = lookup_block_symbol (block, name, domain);
536 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
538 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
544 /* Keep looking through other psymtabs. */
551 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
552 the global block of PST if GLOBAL, and otherwise the static block.
553 MATCH is the comparison operation that returns true iff MATCH (s,
554 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
555 non-null, the symbols in the block are assumed to be ordered
556 according to it (allowing binary search). It must be compatible
557 with MATCH. Returns the symbol, if found, and otherwise NULL. */
559 static struct partial_symbol *
560 match_partial_symbol (struct objfile *objfile,
561 struct partial_symtab *pst, int global,
562 const char *name, domain_enum domain,
563 symbol_compare_ftype *match,
564 symbol_compare_ftype *ordered_compare)
566 struct partial_symbol **start, **psym;
567 struct partial_symbol **top, **real_top, **bottom, **center;
568 int length = (global ? pst->n_global_syms : pst->n_static_syms);
569 int do_linear_search = 1;
574 objfile->global_psymbols.list + pst->globals_offset :
575 objfile->static_psymbols.list + pst->statics_offset);
577 if (global && ordered_compare) /* Can use a binary search. */
579 do_linear_search = 0;
581 /* Binary search. This search is guaranteed to end with center
582 pointing at the earliest partial symbol whose name might be
583 correct. At that point *all* partial symbols with an
584 appropriate name will be checked against the correct
588 top = start + length - 1;
592 center = bottom + (top - bottom) / 2;
593 gdb_assert (center < top);
594 if (!do_linear_search
595 && (SYMBOL_LANGUAGE (*center) == language_java))
596 do_linear_search = 1;
597 if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
602 gdb_assert (top == bottom);
604 while (top <= real_top
605 && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
607 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
608 SYMBOL_DOMAIN (*top), domain))
614 /* Can't use a binary search or else we found during the binary search that
615 we should also do a linear search. */
617 if (do_linear_search)
619 for (psym = start; psym < start + length; psym++)
621 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
622 SYMBOL_DOMAIN (*psym), domain)
623 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
631 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
632 not contain any method/function instance information (since this would
633 force reading type information while reading psymtabs). Therefore,
634 if NAME contains overload information, it must be stripped before searching
637 The caller is responsible for freeing the return result. */
640 psymtab_search_name (const char *name)
642 switch (current_language->la_language)
647 if (strchr (name, '('))
649 char *ret = cp_remove_params (name);
661 return xstrdup (name);
664 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
665 Check the global symbols if GLOBAL, the static symbols if not. */
667 static struct partial_symbol *
668 lookup_partial_symbol (struct objfile *objfile,
669 struct partial_symtab *pst, const char *name,
670 int global, domain_enum domain)
672 struct partial_symbol **start, **psym;
673 struct partial_symbol **top, **real_top, **bottom, **center;
674 int length = (global ? pst->n_global_syms : pst->n_static_syms);
675 int do_linear_search = 1;
677 struct cleanup *cleanup;
684 search_name = psymtab_search_name (name);
685 cleanup = make_cleanup (xfree, search_name);
687 objfile->global_psymbols.list + pst->globals_offset :
688 objfile->static_psymbols.list + pst->statics_offset);
690 if (global) /* This means we can use a binary search. */
692 do_linear_search = 0;
694 /* Binary search. This search is guaranteed to end with center
695 pointing at the earliest partial symbol whose name might be
696 correct. At that point *all* partial symbols with an
697 appropriate name will be checked against the correct
701 top = start + length - 1;
705 center = bottom + (top - bottom) / 2;
707 internal_error (__FILE__, __LINE__,
708 _("failed internal consistency check"));
709 if (!do_linear_search
710 && SYMBOL_LANGUAGE (*center) == language_java)
712 do_linear_search = 1;
714 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
724 if (!(top == bottom))
725 internal_error (__FILE__, __LINE__,
726 _("failed internal consistency check"));
728 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
729 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
730 while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
733 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
736 while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
738 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
739 SYMBOL_DOMAIN (*top), domain))
741 do_cleanups (cleanup);
748 /* Can't use a binary search or else we found during the binary search that
749 we should also do a linear search. */
751 if (do_linear_search)
753 for (psym = start; psym < start + length; psym++)
755 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
756 SYMBOL_DOMAIN (*psym), domain)
757 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
759 do_cleanups (cleanup);
765 do_cleanups (cleanup);
769 /* Get the symbol table that corresponds to a partial_symtab.
770 This is fast after the first time you do it. */
772 static struct symtab *
773 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
775 /* If it is a shared psymtab, find an unshared psymtab that includes
776 it. Any such psymtab will do. */
777 while (pst->user != NULL)
780 /* If it's been looked up before, return it. */
784 /* If it has not yet been read in, read it. */
787 struct cleanup *back_to = increment_reading_symtab ();
789 (*pst->read_symtab) (objfile, pst);
790 do_cleanups (back_to);
797 relocate_psymtabs (struct objfile *objfile,
798 struct section_offsets *new_offsets,
799 struct section_offsets *delta)
801 struct partial_symbol **psym;
802 struct partial_symtab *p;
804 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
806 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
807 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
810 for (psym = objfile->global_psymbols.list;
811 psym < objfile->global_psymbols.next;
814 fixup_psymbol_section (*psym, objfile);
815 if (SYMBOL_SECTION (*psym) >= 0)
816 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
817 SYMBOL_SECTION (*psym));
819 for (psym = objfile->static_psymbols.list;
820 psym < objfile->static_psymbols.next;
823 fixup_psymbol_section (*psym, objfile);
824 if (SYMBOL_SECTION (*psym) >= 0)
825 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
826 SYMBOL_SECTION (*psym));
830 static struct symtab *
831 find_last_source_symtab_from_partial (struct objfile *ofp)
833 struct partial_symtab *ps;
834 struct partial_symtab *cs_pst = 0;
836 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
838 const char *name = ps->filename;
839 int len = strlen (name);
841 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
842 || strcmp (name, "<<C++-namespaces>>") == 0)))
850 internal_error (__FILE__, __LINE__,
851 _("select_source_symtab: "
852 "readin pst found and no symtabs."));
855 return psymtab_to_symtab (ofp, cs_pst);
861 forget_cached_source_info_partial (struct objfile *objfile)
863 struct partial_symtab *pst;
865 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
867 if (pst->fullname != NULL)
869 xfree (pst->fullname);
870 pst->fullname = NULL;
876 print_partial_symbols (struct gdbarch *gdbarch,
877 struct partial_symbol **p, int count, char *what,
878 struct ui_file *outfile)
880 fprintf_filtered (outfile, " %s partial symbols:\n", what);
884 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
885 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
887 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
889 fputs_filtered (", ", outfile);
890 switch (SYMBOL_DOMAIN (*p))
893 fputs_filtered ("undefined domain, ", outfile);
896 /* This is the usual thing -- don't print it. */
899 fputs_filtered ("struct domain, ", outfile);
902 fputs_filtered ("label domain, ", outfile);
905 fputs_filtered ("<invalid domain>, ", outfile);
908 switch (SYMBOL_CLASS (*p))
911 fputs_filtered ("undefined", outfile);
914 fputs_filtered ("constant int", outfile);
917 fputs_filtered ("static", outfile);
920 fputs_filtered ("register", outfile);
923 fputs_filtered ("pass by value", outfile);
926 fputs_filtered ("pass by reference", outfile);
928 case LOC_REGPARM_ADDR:
929 fputs_filtered ("register address parameter", outfile);
932 fputs_filtered ("stack parameter", outfile);
935 fputs_filtered ("type", outfile);
938 fputs_filtered ("label", outfile);
941 fputs_filtered ("function", outfile);
943 case LOC_CONST_BYTES:
944 fputs_filtered ("constant bytes", outfile);
947 fputs_filtered ("unresolved", outfile);
949 case LOC_OPTIMIZED_OUT:
950 fputs_filtered ("optimized out", outfile);
953 fputs_filtered ("computed at runtime", outfile);
956 fputs_filtered ("<invalid location>", outfile);
959 fputs_filtered (", ", outfile);
960 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
961 fprintf_filtered (outfile, "\n");
967 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
968 struct ui_file *outfile)
970 struct gdbarch *gdbarch = get_objfile_arch (objfile);
973 if (psymtab->anonymous)
975 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
980 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
983 fprintf_filtered (outfile, "(object ");
984 gdb_print_host_address (psymtab, outfile);
985 fprintf_filtered (outfile, ")\n\n");
986 fprintf_unfiltered (outfile, " Read from object file %s (",
988 gdb_print_host_address (objfile, outfile);
989 fprintf_unfiltered (outfile, ")\n");
993 fprintf_filtered (outfile,
994 " Full symtab was read (at ");
995 gdb_print_host_address (psymtab->symtab, outfile);
996 fprintf_filtered (outfile, " by function at ");
997 gdb_print_host_address (psymtab->read_symtab, outfile);
998 fprintf_filtered (outfile, ")\n");
1001 fprintf_filtered (outfile, " Relocate symbols by ");
1002 for (i = 0; i < objfile->num_sections; ++i)
1005 fprintf_filtered (outfile, ", ");
1007 fputs_filtered (paddress (gdbarch,
1008 ANOFFSET (psymtab->section_offsets, i)),
1011 fprintf_filtered (outfile, "\n");
1013 fprintf_filtered (outfile, " Symbols cover text addresses ");
1014 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
1015 fprintf_filtered (outfile, "-");
1016 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
1017 fprintf_filtered (outfile, "\n");
1018 fprintf_filtered (outfile, " Address map supported - %s.\n",
1019 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1020 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
1021 psymtab->number_of_dependencies);
1022 for (i = 0; i < psymtab->number_of_dependencies; i++)
1024 fprintf_filtered (outfile, " %d ", i);
1025 gdb_print_host_address (psymtab->dependencies[i], outfile);
1026 fprintf_filtered (outfile, " %s\n",
1027 psymtab->dependencies[i]->filename);
1029 if (psymtab->user != NULL)
1031 fprintf_filtered (outfile, " Shared partial symtab with user ");
1032 gdb_print_host_address (psymtab->user, outfile);
1033 fprintf_filtered (outfile, "\n");
1035 if (psymtab->n_global_syms > 0)
1037 print_partial_symbols (gdbarch,
1038 objfile->global_psymbols.list
1039 + psymtab->globals_offset,
1040 psymtab->n_global_syms, "Global", outfile);
1042 if (psymtab->n_static_syms > 0)
1044 print_partial_symbols (gdbarch,
1045 objfile->static_psymbols.list
1046 + psymtab->statics_offset,
1047 psymtab->n_static_syms, "Static", outfile);
1049 fprintf_filtered (outfile, "\n");
1053 print_psymtab_stats_for_objfile (struct objfile *objfile)
1056 struct partial_symtab *ps;
1059 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1061 if (ps->readin == 0)
1064 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1068 dump_psymtabs_for_objfile (struct objfile *objfile)
1070 struct partial_symtab *psymtab;
1072 if (objfile->psymtabs)
1074 printf_filtered ("Psymtabs:\n");
1075 for (psymtab = objfile->psymtabs;
1077 psymtab = psymtab->next)
1079 printf_filtered ("%s at ",
1081 gdb_print_host_address (psymtab, gdb_stdout);
1082 printf_filtered (", ");
1085 printf_filtered ("\n\n");
1089 /* Look through the partial symtabs for all symbols which begin
1090 by matching FUNC_NAME. Make sure we read that symbol table in. */
1093 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1095 struct partial_symtab *ps;
1097 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1102 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1104 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1106 psymtab_to_symtab (objfile, ps);
1111 expand_partial_symbol_tables (struct objfile *objfile)
1113 struct partial_symtab *psymtab;
1115 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1117 psymtab_to_symtab (objfile, psymtab);
1122 read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
1124 struct partial_symtab *p;
1126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1128 /* Anonymous psymtabs don't have a name of a source file. */
1132 if (filename_cmp (filename, p->filename) == 0)
1133 psymtab_to_symtab (objfile, p);
1138 map_symbol_filenames_psymtab (struct objfile *objfile,
1139 symbol_filename_ftype *fun, void *data,
1142 struct partial_symtab *ps;
1144 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1146 const char *fullname;
1151 /* We can skip shared psymtabs here, because any file name will be
1152 attached to the unshared psymtab. */
1153 if (ps->user != NULL)
1156 /* Anonymous psymtabs don't have a file name. */
1162 fullname = psymtab_to_fullname (ps);
1165 (*fun) (ps->filename, fullname, data);
1169 /* Finds the fullname that a partial_symtab represents.
1171 If this functions finds the fullname, it will save it in ps->fullname
1172 and it will also return the value.
1174 If this function fails to find the file that this partial_symtab represents,
1175 NULL will be returned and ps->fullname will be set to NULL. */
1178 psymtab_to_fullname (struct partial_symtab *ps)
1187 /* Use cached copy if we have it.
1188 We rely on forget_cached_source_info being called appropriately
1189 to handle cases like the file being moved. */
1191 return ps->fullname;
1193 r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1198 return ps->fullname;
1205 find_symbol_file_from_partial (struct objfile *objfile, const char *name)
1207 struct partial_symtab *pst;
1209 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1211 if (lookup_partial_symbol (objfile, pst, name, 1, VAR_DOMAIN))
1212 return pst->filename;
1217 /* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1218 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1219 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1220 ever returns non-zero, and otherwise returns 0. */
1223 map_block (const char *name, domain_enum namespace, struct objfile *objfile,
1224 struct block *block,
1225 int (*callback) (struct block *, struct symbol *, void *),
1226 void *data, symbol_compare_ftype *match)
1228 struct block_iterator iter;
1231 for (sym = block_iter_match_first (block, name, match, &iter);
1232 sym != NULL; sym = block_iter_match_next (name, match, &iter))
1234 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1235 SYMBOL_DOMAIN (sym), namespace))
1237 if (callback (block, sym, data))
1245 /* Psymtab version of map_matching_symbols. See its definition in
1246 the definition of quick_symbol_functions in symfile.h. */
1249 map_matching_symbols_psymtab (const char *name, domain_enum namespace,
1250 struct objfile *objfile, int global,
1251 int (*callback) (struct block *,
1252 struct symbol *, void *),
1254 symbol_compare_ftype *match,
1255 symbol_compare_ftype *ordered_compare)
1257 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1258 struct partial_symtab *ps;
1260 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1264 || match_partial_symbol (objfile, ps, global, name, namespace, match,
1267 struct symtab *s = psymtab_to_symtab (objfile, ps);
1268 struct block *block;
1270 if (s == NULL || !s->primary)
1272 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1273 if (map_block (name, namespace, objfile, block,
1274 callback, data, match))
1276 if (callback (block, NULL, data))
1282 /* A helper for expand_symtabs_matching_via_partial that handles
1283 searching included psymtabs. This returns 1 if a symbol is found,
1284 and zero otherwise. It also updates the 'searched_flag' on the
1285 various psymtabs that it searches. */
1288 recursively_search_psymtabs (struct partial_symtab *ps,
1289 struct objfile *objfile,
1290 enum search_domain kind,
1291 int (*name_matcher) (const char *, void *),
1294 struct partial_symbol **psym;
1295 struct partial_symbol **bound, **gbound, **sbound;
1297 int result = PST_SEARCHED_AND_NOT_FOUND;
1300 if (ps->searched_flag != PST_NOT_SEARCHED)
1301 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1303 /* Recurse into shared psymtabs first, because they may have already
1304 been searched, and this could save some time. */
1305 for (i = 0; i < ps->number_of_dependencies; ++i)
1309 /* Skip non-shared dependencies, these are handled elsewhere. */
1310 if (ps->dependencies[i]->user == NULL)
1313 r = recursively_search_psymtabs (ps->dependencies[i],
1314 objfile, kind, name_matcher, data);
1317 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1322 gbound = (objfile->global_psymbols.list
1323 + ps->globals_offset + ps->n_global_syms);
1324 sbound = (objfile->static_psymbols.list
1325 + ps->statics_offset + ps->n_static_syms);
1328 /* Go through all of the symbols stored in a partial
1329 symtab in one loop. */
1330 psym = objfile->global_psymbols.list + ps->globals_offset;
1335 if (bound == gbound && ps->n_static_syms != 0)
1337 psym = objfile->static_psymbols.list + ps->statics_offset;
1348 if ((kind == ALL_DOMAIN
1349 || (kind == VARIABLES_DOMAIN
1350 && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
1351 && SYMBOL_CLASS (*psym) != LOC_BLOCK)
1352 || (kind == FUNCTIONS_DOMAIN
1353 && SYMBOL_CLASS (*psym) == LOC_BLOCK)
1354 || (kind == TYPES_DOMAIN
1355 && SYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1356 && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1358 /* Found a match, so notify our caller. */
1359 result = PST_SEARCHED_AND_FOUND;
1366 ps->searched_flag = result;
1367 return result == PST_SEARCHED_AND_FOUND;
1371 expand_symtabs_matching_via_partial
1372 (struct objfile *objfile,
1373 int (*file_matcher) (const char *, void *),
1374 int (*name_matcher) (const char *, void *),
1375 enum search_domain kind,
1378 struct partial_symtab *ps;
1380 /* Clear the search flags. */
1381 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1383 ps->searched_flag = PST_NOT_SEARCHED;
1386 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1391 /* We skip shared psymtabs because file-matching doesn't apply
1392 to them; but we search them later in the loop. */
1393 if (ps->user != NULL)
1400 if (! (*file_matcher) (ps->filename, data))
1404 if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
1405 psymtab_to_symtab (objfile, ps);
1410 objfile_has_psyms (struct objfile *objfile)
1412 return objfile->psymtabs != NULL;
1415 const struct quick_symbol_functions psym_functions =
1418 find_last_source_symtab_from_partial,
1419 forget_cached_source_info_partial,
1420 partial_map_symtabs_matching_filename,
1421 lookup_symbol_aux_psymtabs,
1422 print_psymtab_stats_for_objfile,
1423 dump_psymtabs_for_objfile,
1425 read_symtabs_for_function,
1426 expand_partial_symbol_tables,
1427 read_psymtabs_with_filename,
1428 find_symbol_file_from_partial,
1429 map_matching_symbols_psymtab,
1430 expand_symtabs_matching_via_partial,
1431 find_pc_sect_symtab_from_partial,
1432 map_symbol_filenames_psymtab
1437 /* This compares two partial symbols by names, using strcmp_iw_ordered
1438 for the comparison. */
1441 compare_psymbols (const void *s1p, const void *s2p)
1443 struct partial_symbol *const *s1 = s1p;
1444 struct partial_symbol *const *s2 = s2p;
1446 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1447 SYMBOL_SEARCH_NAME (*s2));
1451 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1453 /* Sort the global list; don't sort the static list. */
1455 qsort (objfile->global_psymbols.list + pst->globals_offset,
1456 pst->n_global_syms, sizeof (struct partial_symbol *),
1460 /* Allocate and partially fill a partial symtab. It will be
1461 completely filled at the end of the symbol list.
1463 FILENAME is the name of the symbol-file we are reading from. */
1465 struct partial_symtab *
1466 start_psymtab_common (struct objfile *objfile,
1467 struct section_offsets *section_offsets,
1468 const char *filename,
1469 CORE_ADDR textlow, struct partial_symbol **global_syms,
1470 struct partial_symbol **static_syms)
1472 struct partial_symtab *psymtab;
1474 psymtab = allocate_psymtab (filename, objfile);
1475 psymtab->section_offsets = section_offsets;
1476 psymtab->textlow = textlow;
1477 psymtab->texthigh = psymtab->textlow; /* default */
1478 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1479 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1483 /* Calculate a hash code for the given partial symbol. The hash is
1484 calculated using the symbol's value, language, domain, class
1485 and name. These are the values which are set by
1486 add_psymbol_to_bcache. */
1488 static unsigned long
1489 psymbol_hash (const void *addr, int length)
1491 unsigned long h = 0;
1492 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1493 unsigned int lang = psymbol->ginfo.language;
1494 unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1495 unsigned int class = PSYMBOL_CLASS (psymbol);
1497 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1498 h = hash_continue (&lang, sizeof (unsigned int), h);
1499 h = hash_continue (&domain, sizeof (unsigned int), h);
1500 h = hash_continue (&class, sizeof (unsigned int), h);
1501 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1506 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1507 For the comparison this function uses a symbols value,
1508 language, domain, class and name. */
1511 psymbol_compare (const void *addr1, const void *addr2, int length)
1513 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1514 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1516 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1517 sizeof (sym1->ginfo.value)) == 0
1518 && sym1->ginfo.language == sym2->ginfo.language
1519 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1520 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1521 && sym1->ginfo.name == sym2->ginfo.name);
1524 /* Initialize a partial symbol bcache. */
1526 struct psymbol_bcache *
1527 psymbol_bcache_init (void)
1529 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1530 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1534 /* Free a partial symbol bcache. */
1536 psymbol_bcache_free (struct psymbol_bcache *bcache)
1541 bcache_xfree (bcache->bcache);
1545 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1548 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1550 return bcache->bcache;
1553 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1554 symbol before, add a copy to BCACHE. In either case, return a pointer
1555 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1556 1 in case of new entry or 0 if returning an old entry. */
1558 static const struct partial_symbol *
1559 psymbol_bcache_full (struct partial_symbol *sym,
1560 struct psymbol_bcache *bcache,
1563 return bcache_full (sym,
1564 sizeof (struct partial_symbol),
1569 /* Helper function, initialises partial symbol structure and stashes
1570 it into objfile's bcache. Note that our caching mechanism will
1571 use all fields of struct partial_symbol to determine hash value of the
1572 structure. In other words, having two symbols with the same name but
1573 different domain (or address) is possible and correct. */
1575 static const struct partial_symbol *
1576 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1578 enum address_class class,
1579 long val, /* Value as a long */
1580 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1581 enum language language, struct objfile *objfile,
1584 struct partial_symbol psymbol;
1586 /* We must ensure that the entire 'value' field has been zeroed
1587 before assigning to it, because an assignment may not write the
1589 memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
1591 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1594 SYMBOL_VALUE (&psymbol) = val;
1598 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1600 SYMBOL_SECTION (&psymbol) = 0;
1601 SYMBOL_OBJ_SECTION (&psymbol) = NULL;
1602 SYMBOL_SET_LANGUAGE (&psymbol, language);
1603 PSYMBOL_DOMAIN (&psymbol) = domain;
1604 PSYMBOL_CLASS (&psymbol) = class;
1606 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1608 /* Stash the partial symbol away in the cache. */
1609 return psymbol_bcache_full (&psymbol,
1610 objfile->psymbol_cache,
1614 /* Increase the space allocated for LISTP, which is probably
1615 global_psymbols or static_psymbols. This space will eventually
1616 be freed in free_objfile(). */
1619 extend_psymbol_list (struct psymbol_allocation_list *listp,
1620 struct objfile *objfile)
1624 if (listp->size == 0)
1627 listp->list = (struct partial_symbol **)
1628 xmalloc (new_size * sizeof (struct partial_symbol *));
1632 new_size = listp->size * 2;
1633 listp->list = (struct partial_symbol **)
1634 xrealloc ((char *) listp->list,
1635 new_size * sizeof (struct partial_symbol *));
1637 /* Next assumes we only went one over. Should be good if
1638 program works correctly. */
1639 listp->next = listp->list + listp->size;
1640 listp->size = new_size;
1643 /* Helper function, adds partial symbol to the given partial symbol
1647 append_psymbol_to_list (struct psymbol_allocation_list *list,
1648 const struct partial_symbol *psym,
1649 struct objfile *objfile)
1651 if (list->next >= list->list + list->size)
1652 extend_psymbol_list (list, objfile);
1653 *list->next++ = (struct partial_symbol *) psym;
1654 OBJSTAT (objfile, n_psyms++);
1657 /* Add a symbol with a long value to a psymtab.
1658 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1659 Return the partial symbol that has been added. */
1662 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1664 enum address_class class,
1665 struct psymbol_allocation_list *list,
1666 long val, /* Value as a long */
1667 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1668 enum language language, struct objfile *objfile)
1670 const struct partial_symbol *psym;
1674 /* Stash the partial symbol away in the cache. */
1675 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
1676 val, coreaddr, language, objfile, &added);
1678 /* Do not duplicate global partial symbols. */
1679 if (list == &objfile->global_psymbols
1683 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1684 append_psymbol_to_list (list, psym, objfile);
1687 /* Initialize storage for partial symbols. */
1690 init_psymbol_list (struct objfile *objfile, int total_symbols)
1692 /* Free any previously allocated psymbol lists. */
1694 if (objfile->global_psymbols.list)
1696 xfree (objfile->global_psymbols.list);
1698 if (objfile->static_psymbols.list)
1700 xfree (objfile->static_psymbols.list);
1703 /* Current best guess is that approximately a twentieth
1704 of the total symbols (in a debugging file) are global or static
1705 oriented symbols. */
1707 objfile->global_psymbols.size = total_symbols / 10;
1708 objfile->static_psymbols.size = total_symbols / 10;
1710 if (objfile->global_psymbols.size > 0)
1712 objfile->global_psymbols.next =
1713 objfile->global_psymbols.list = (struct partial_symbol **)
1714 xmalloc ((objfile->global_psymbols.size
1715 * sizeof (struct partial_symbol *)));
1717 if (objfile->static_psymbols.size > 0)
1719 objfile->static_psymbols.next =
1720 objfile->static_psymbols.list = (struct partial_symbol **)
1721 xmalloc ((objfile->static_psymbols.size
1722 * sizeof (struct partial_symbol *)));
1726 struct partial_symtab *
1727 allocate_psymtab (const char *filename, struct objfile *objfile)
1729 struct partial_symtab *psymtab;
1731 if (objfile->free_psymtabs)
1733 psymtab = objfile->free_psymtabs;
1734 objfile->free_psymtabs = psymtab->next;
1737 psymtab = (struct partial_symtab *)
1738 obstack_alloc (&objfile->objfile_obstack,
1739 sizeof (struct partial_symtab));
1741 memset (psymtab, 0, sizeof (struct partial_symtab));
1742 psymtab->filename = obsavestring (filename, strlen (filename),
1743 &objfile->objfile_obstack);
1744 psymtab->symtab = NULL;
1746 /* Prepend it to the psymtab list for the objfile it belongs to.
1747 Psymtabs are searched in most recent inserted -> least recent
1750 psymtab->next = objfile->psymtabs;
1751 objfile->psymtabs = psymtab;
1753 if (symtab_create_debug)
1755 /* Be a bit clever with debugging messages, and don't print objfile
1756 every time, only when it changes. */
1757 static char *last_objfile_name = NULL;
1759 if (last_objfile_name == NULL
1760 || strcmp (last_objfile_name, objfile->name) != 0)
1762 xfree (last_objfile_name);
1763 last_objfile_name = xstrdup (objfile->name);
1764 fprintf_unfiltered (gdb_stdlog,
1765 "Creating one or more psymtabs for objfile %s ...\n",
1768 fprintf_unfiltered (gdb_stdlog,
1769 "Created psymtab %s for module %s.\n",
1770 host_address_to_string (psymtab), filename);
1777 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1779 struct partial_symtab **prev_pst;
1782 Empty psymtabs happen as a result of header files which don't
1783 have any symbols in them. There can be a lot of them. But this
1784 check is wrong, in that a psymtab with N_SLINE entries but
1785 nothing else is not empty, but we don't realize that. Fixing
1786 that without slowing things down might be tricky. */
1788 /* First, snip it out of the psymtab chain. */
1790 prev_pst = &(objfile->psymtabs);
1791 while ((*prev_pst) != pst)
1792 prev_pst = &((*prev_pst)->next);
1793 (*prev_pst) = pst->next;
1795 /* Next, put it on a free list for recycling. */
1797 pst->next = objfile->free_psymtabs;
1798 objfile->free_psymtabs = pst;
1804 maintenance_print_psymbols (char *args, int from_tty)
1807 struct ui_file *outfile;
1808 struct cleanup *cleanups;
1809 char *symname = NULL;
1810 char *filename = DEV_TTY;
1811 struct objfile *objfile;
1812 struct partial_symtab *ps;
1819 print-psymbols takes an output file name and optional symbol file name"));
1821 argv = gdb_buildargv (args);
1822 cleanups = make_cleanup_freeargv (argv);
1824 if (argv[0] != NULL)
1827 /* If a second arg is supplied, it is a source file name to match on. */
1828 if (argv[1] != NULL)
1834 filename = tilde_expand (filename);
1835 make_cleanup (xfree, filename);
1837 outfile = gdb_fopen (filename, FOPEN_WT);
1839 perror_with_name (filename);
1840 make_cleanup_ui_file_delete (outfile);
1842 ALL_PSYMTABS (objfile, ps)
1845 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1846 dump_psymtab (objfile, ps, outfile);
1848 do_cleanups (cleanups);
1851 /* List all the partial symbol tables whose names match REGEXP (optional). */
1853 maintenance_info_psymtabs (char *regexp, int from_tty)
1855 struct program_space *pspace;
1856 struct objfile *objfile;
1861 ALL_PSPACES (pspace)
1862 ALL_PSPACE_OBJFILES (pspace, objfile)
1864 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1865 struct partial_symtab *psymtab;
1867 /* We don't want to print anything for this objfile until we
1868 actually find a symtab whose name matches. */
1869 int printed_objfile_start = 0;
1871 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1876 || re_exec (psymtab->filename))
1878 if (! printed_objfile_start)
1880 printf_filtered ("{ objfile %s ", objfile->name);
1882 printf_filtered ("((struct objfile *) %s)\n",
1883 host_address_to_string (objfile));
1884 printed_objfile_start = 1;
1887 printf_filtered (" { psymtab %s ", psymtab->filename);
1889 printf_filtered ("((struct partial_symtab *) %s)\n",
1890 host_address_to_string (psymtab));
1892 printf_filtered (" readin %s\n",
1893 psymtab->readin ? "yes" : "no");
1894 printf_filtered (" fullname %s\n",
1896 ? psymtab->fullname : "(null)");
1897 printf_filtered (" text addresses ");
1898 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1900 printf_filtered (" -- ");
1901 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1903 printf_filtered ("\n");
1904 printf_filtered (" psymtabs_addrmap_supported %s\n",
1905 (psymtab->psymtabs_addrmap_supported
1907 printf_filtered (" globals ");
1908 if (psymtab->n_global_syms)
1910 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1911 host_address_to_string (objfile->global_psymbols.list
1912 + psymtab->globals_offset),
1913 psymtab->n_global_syms);
1916 printf_filtered ("(none)\n");
1917 printf_filtered (" statics ");
1918 if (psymtab->n_static_syms)
1920 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1921 host_address_to_string (objfile->static_psymbols.list
1922 + psymtab->statics_offset),
1923 psymtab->n_static_syms);
1926 printf_filtered ("(none)\n");
1927 printf_filtered (" dependencies ");
1928 if (psymtab->number_of_dependencies)
1932 printf_filtered ("{\n");
1933 for (i = 0; i < psymtab->number_of_dependencies; i++)
1935 struct partial_symtab *dep = psymtab->dependencies[i];
1937 /* Note the string concatenation there --- no comma. */
1938 printf_filtered (" psymtab %s "
1939 "((struct partial_symtab *) %s)\n",
1941 host_address_to_string (dep));
1943 printf_filtered (" }\n");
1946 printf_filtered ("(none)\n");
1947 printf_filtered (" }\n");
1951 if (printed_objfile_start)
1952 printf_filtered ("}\n");
1956 /* Check consistency of psymtabs and symtabs. */
1959 maintenance_check_symtabs (char *ignore, int from_tty)
1962 struct partial_symbol **psym;
1963 struct symtab *s = NULL;
1964 struct partial_symtab *ps;
1965 struct blockvector *bv;
1966 struct objfile *objfile;
1970 ALL_PSYMTABS (objfile, ps)
1972 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1974 s = psymtab_to_symtab (objfile, ps);
1977 bv = BLOCKVECTOR (s);
1978 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1979 psym = objfile->static_psymbols.list + ps->statics_offset;
1980 length = ps->n_static_syms;
1983 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1984 SYMBOL_DOMAIN (*psym));
1987 printf_filtered ("Static symbol `");
1988 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
1989 printf_filtered ("' only found in ");
1990 puts_filtered (ps->filename);
1991 printf_filtered (" psymtab\n");
1995 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1996 psym = objfile->global_psymbols.list + ps->globals_offset;
1997 length = ps->n_global_syms;
2000 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2001 SYMBOL_DOMAIN (*psym));
2004 printf_filtered ("Global symbol `");
2005 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2006 printf_filtered ("' only found in ");
2007 puts_filtered (ps->filename);
2008 printf_filtered (" psymtab\n");
2012 if (ps->texthigh < ps->textlow)
2014 printf_filtered ("Psymtab ");
2015 puts_filtered (ps->filename);
2016 printf_filtered (" covers bad range ");
2017 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2018 printf_filtered (" - ");
2019 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2020 printf_filtered ("\n");
2023 if (ps->texthigh == 0)
2025 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
2027 printf_filtered ("Psymtab ");
2028 puts_filtered (ps->filename);
2029 printf_filtered (" covers ");
2030 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2031 printf_filtered (" - ");
2032 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2033 printf_filtered (" but symtab covers only ");
2034 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2035 printf_filtered (" - ");
2036 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2037 printf_filtered ("\n");
2045 expand_partial_symbol_names (int (*fun) (const char *, void *),
2048 struct objfile *objfile;
2050 ALL_OBJFILES (objfile)
2053 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
2059 map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
2062 struct objfile *objfile;
2064 ALL_OBJFILES (objfile)
2067 objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
2072 extern initialize_file_ftype _initialize_psymtab;
2075 _initialize_psymtab (void)
2077 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2078 Print dump of current partial symbol definitions.\n\
2079 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2080 If a SOURCE file is specified, dump only that file's partial symbols."),
2081 &maintenanceprintlist);
2083 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2084 List the partial symbol tables for all object files.\n\
2085 This does not include information about individual partial symbols,\n\
2086 just the symbol table structures themselves."),
2087 &maintenanceinfolist);
2089 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
2090 _("Check consistency of psymtabs and symtabs."),