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..."),
89 objfile_name (objfile));
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 *real_path,
135 struct partial_symtab *pst,
136 int (*callback) (struct symtab *, void *),
139 struct symtab *last_made = objfile->symtabs;
141 /* Shared psymtabs should never be seen here. Instead they should
142 be handled properly by the caller. */
143 gdb_assert (pst->user == NULL);
145 /* Don't visit already-expanded psymtabs. */
149 /* This may expand more than one symtab, and we want to iterate over
151 psymtab_to_symtab (objfile, pst);
153 return iterate_over_some_symtabs (name, real_path, callback, data,
154 objfile->symtabs, last_made);
157 /* Implementation of the map_symtabs_matching_filename method. */
160 partial_map_symtabs_matching_filename (struct objfile *objfile,
162 const char *real_path,
163 int (*callback) (struct symtab *,
167 struct partial_symtab *pst;
168 const char *name_basename = lbasename (name);
170 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
172 /* We can skip shared psymtabs here, because any file name will be
173 attached to the unshared psymtab. */
174 if (pst->user != NULL)
177 /* Anonymous psymtabs don't have a file name. */
181 if (compare_filenames_for_search (pst->filename, name))
183 if (partial_map_expand_apply (objfile, name, real_path,
184 pst, callback, data))
189 /* Before we invoke realpath, which can get expensive when many
190 files are involved, do a quick comparison of the basenames. */
191 if (! basenames_may_differ
192 && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
195 if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
197 if (partial_map_expand_apply (objfile, name, real_path,
198 pst, callback, data))
203 /* If the user gave us an absolute path, try to find the file in
204 this symtab and use its absolute path. */
205 if (real_path != NULL)
207 gdb_assert (IS_ABSOLUTE_PATH (real_path));
208 gdb_assert (IS_ABSOLUTE_PATH (name));
209 if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
211 if (partial_map_expand_apply (objfile, name, real_path,
212 pst, callback, data))
222 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
223 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
225 static struct partial_symtab *
226 find_pc_sect_psymtab_closer (struct objfile *objfile,
227 CORE_ADDR pc, struct obj_section *section,
228 struct partial_symtab *pst,
229 struct minimal_symbol *msymbol)
231 struct partial_symtab *tpst;
232 struct partial_symtab *best_pst = pst;
233 CORE_ADDR best_addr = pst->textlow;
235 gdb_assert (!pst->psymtabs_addrmap_supported);
237 /* An objfile that has its functions reordered might have
238 many partial symbol tables containing the PC, but
239 we want the partial symbol table that contains the
240 function containing the PC. */
241 if (!(objfile->flags & OBJF_REORDERED) &&
242 section == 0) /* Can't validate section this way. */
248 /* The code range of partial symtabs sometimes overlap, so, in
249 the loop below, we need to check all partial symtabs and
250 find the one that fits better for the given PC address. We
251 select the partial symtab that contains a symbol whose
252 address is closest to the PC address. By closest we mean
253 that find_pc_sect_symbol returns the symbol with address
254 that is closest and still less than the given PC. */
255 for (tpst = pst; tpst != NULL; tpst = tpst->next)
257 if (pc >= tpst->textlow && pc < tpst->texthigh)
259 struct partial_symbol *p;
262 /* NOTE: This assumes that every psymbol has a
263 corresponding msymbol, which is not necessarily
264 true; the debug info might be much richer than the
265 object's symbol table. */
266 p = find_pc_sect_psymbol (objfile, tpst, pc, section);
268 && SYMBOL_VALUE_ADDRESS (p)
269 == SYMBOL_VALUE_ADDRESS (msymbol))
272 /* Also accept the textlow value of a psymtab as a
273 "symbol", to provide some support for partial
274 symbol tables with line information but no debug
275 symbols (e.g. those produced by an assembler). */
277 this_addr = SYMBOL_VALUE_ADDRESS (p);
279 this_addr = tpst->textlow;
281 /* Check whether it is closer than our current
282 BEST_ADDR. Since this symbol address is
283 necessarily lower or equal to PC, the symbol closer
284 to PC is the symbol which address is the highest.
285 This way we return the psymtab which contains such
286 best match symbol. This can help in cases where the
287 symbol information/debuginfo is not complete, like
288 for instance on IRIX6 with gcc, where no debug info
289 is emitted for statics. (See also the nodebug.exp
291 if (this_addr > best_addr)
293 best_addr = this_addr;
301 /* Find which partial symtab contains PC and SECTION. Return 0 if
302 none. We return the psymtab that contains a symbol whose address
303 exactly matches PC, or, if we cannot find an exact match, the
304 psymtab that contains a symbol whose address is closest to PC. */
305 static struct partial_symtab *
306 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
307 struct obj_section *section,
308 struct minimal_symbol *msymbol)
310 struct partial_symtab *pst;
312 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
313 than the later used TEXTLOW/TEXTHIGH one. */
315 if (objfile->psymtabs_addrmap != NULL)
317 pst = addrmap_find (objfile->psymtabs_addrmap, pc);
320 /* FIXME: addrmaps currently do not handle overlayed sections,
321 so fall back to the non-addrmap case if we're debugging
322 overlays and the addrmap returned the wrong section. */
323 if (overlay_debugging && msymbol && section)
325 struct partial_symbol *p;
327 /* NOTE: This assumes that every psymbol has a
328 corresponding msymbol, which is not necessarily
329 true; the debug info might be much richer than the
330 object's symbol table. */
331 p = find_pc_sect_psymbol (objfile, pst, pc, section);
333 || SYMBOL_VALUE_ADDRESS (p)
334 != SYMBOL_VALUE_ADDRESS (msymbol))
338 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
339 PSYMTABS_ADDRMAP we used has already the best 1-byte
340 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
341 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
350 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
351 which still have no corresponding full SYMTABs read. But it is not
352 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
355 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
356 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
357 debug info type in single OBJFILE. */
359 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
360 if (!pst->psymtabs_addrmap_supported
361 && pc >= pst->textlow && pc < pst->texthigh)
363 struct partial_symtab *best_pst;
365 best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
367 if (best_pst != NULL)
374 static struct symtab *
375 find_pc_sect_symtab_from_partial (struct objfile *objfile,
376 struct minimal_symbol *msymbol,
377 CORE_ADDR pc, struct obj_section *section,
380 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
384 if (warn_if_readin && ps->readin)
385 /* Might want to error() here (in case symtab is corrupt and
386 will cause a core dump), but maybe we can successfully
387 continue, so let's not. */
389 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
390 paddress (get_objfile_arch (objfile), pc));
391 psymtab_to_symtab (objfile, ps);
397 /* Find which partial symbol within a psymtab matches PC and SECTION.
400 static struct partial_symbol *
401 find_pc_sect_psymbol (struct objfile *objfile,
402 struct partial_symtab *psymtab, CORE_ADDR pc,
403 struct obj_section *section)
405 struct partial_symbol *best = NULL, *p, **pp;
408 gdb_assert (psymtab != NULL);
410 /* Cope with programs that start at address 0. */
411 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
413 /* Search the global symbols as well as the static symbols, so that
414 find_pc_partial_function doesn't use a minimal symbol and thus
415 cache a bad endaddr. */
416 for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
417 (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
418 < psymtab->n_global_syms);
422 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
423 && PSYMBOL_CLASS (p) == LOC_BLOCK
424 && pc >= SYMBOL_VALUE_ADDRESS (p)
425 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
426 || (psymtab->textlow == 0
427 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
429 if (section) /* Match on a specific section. */
431 fixup_psymbol_section (p, objfile);
432 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
436 best_pc = SYMBOL_VALUE_ADDRESS (p);
441 for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
442 (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
443 < psymtab->n_static_syms);
447 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
448 && PSYMBOL_CLASS (p) == LOC_BLOCK
449 && pc >= SYMBOL_VALUE_ADDRESS (p)
450 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
451 || (psymtab->textlow == 0
452 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
454 if (section) /* Match on a specific section. */
456 fixup_psymbol_section (p, objfile);
457 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p),
461 best_pc = SYMBOL_VALUE_ADDRESS (p);
470 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
477 if (SYMBOL_SECTION (psym) >= 0)
480 gdb_assert (objfile);
482 switch (PSYMBOL_CLASS (psym))
487 addr = SYMBOL_VALUE_ADDRESS (psym);
490 /* Nothing else will be listed in the minsyms -- no use looking
495 fixup_section (&psym->ginfo, addr, objfile);
498 static struct symtab *
499 lookup_symbol_aux_psymtabs (struct objfile *objfile,
500 int block_index, const char *name,
501 const domain_enum domain)
503 struct partial_symtab *ps;
504 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
505 struct symtab *stab_best = NULL;
507 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
509 if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
510 psymtab_index, domain))
512 struct symbol *sym = NULL;
513 struct symtab *stab = psymtab_to_symtab (objfile, ps);
515 /* Some caution must be observed with overloaded functions
516 and methods, since the psymtab will not contain any overload
517 information (but NAME might contain it). */
520 struct blockvector *bv = BLOCKVECTOR (stab);
521 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
523 sym = lookup_block_symbol (block, name, domain);
526 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
528 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
534 /* Keep looking through other psymtabs. */
541 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
542 the global block of PST if GLOBAL, and otherwise the static block.
543 MATCH is the comparison operation that returns true iff MATCH (s,
544 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
545 non-null, the symbols in the block are assumed to be ordered
546 according to it (allowing binary search). It must be compatible
547 with MATCH. Returns the symbol, if found, and otherwise NULL. */
549 static struct partial_symbol *
550 match_partial_symbol (struct objfile *objfile,
551 struct partial_symtab *pst, int global,
552 const char *name, domain_enum domain,
553 symbol_compare_ftype *match,
554 symbol_compare_ftype *ordered_compare)
556 struct partial_symbol **start, **psym;
557 struct partial_symbol **top, **real_top, **bottom, **center;
558 int length = (global ? pst->n_global_syms : pst->n_static_syms);
559 int do_linear_search = 1;
564 objfile->global_psymbols.list + pst->globals_offset :
565 objfile->static_psymbols.list + pst->statics_offset);
567 if (global && ordered_compare) /* Can use a binary search. */
569 do_linear_search = 0;
571 /* Binary search. This search is guaranteed to end with center
572 pointing at the earliest partial symbol whose name might be
573 correct. At that point *all* partial symbols with an
574 appropriate name will be checked against the correct
578 top = start + length - 1;
582 center = bottom + (top - bottom) / 2;
583 gdb_assert (center < top);
584 if (!do_linear_search
585 && (SYMBOL_LANGUAGE (*center) == language_java))
586 do_linear_search = 1;
587 if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
592 gdb_assert (top == bottom);
594 while (top <= real_top
595 && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
597 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
598 SYMBOL_DOMAIN (*top), domain))
604 /* Can't use a binary search or else we found during the binary search that
605 we should also do a linear search. */
607 if (do_linear_search)
609 for (psym = start; psym < start + length; psym++)
611 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
612 SYMBOL_DOMAIN (*psym), domain)
613 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
621 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
622 not contain any method/function instance information (since this would
623 force reading type information while reading psymtabs). Therefore,
624 if NAME contains overload information, it must be stripped before searching
627 The caller is responsible for freeing the return result. */
630 psymtab_search_name (const char *name)
632 switch (current_language->la_language)
637 if (strchr (name, '('))
639 char *ret = cp_remove_params (name);
651 return xstrdup (name);
654 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
655 Check the global symbols if GLOBAL, the static symbols if not. */
657 static struct partial_symbol *
658 lookup_partial_symbol (struct objfile *objfile,
659 struct partial_symtab *pst, const char *name,
660 int global, domain_enum domain)
662 struct partial_symbol **start, **psym;
663 struct partial_symbol **top, **real_top, **bottom, **center;
664 int length = (global ? pst->n_global_syms : pst->n_static_syms);
665 int do_linear_search = 1;
667 struct cleanup *cleanup;
674 search_name = psymtab_search_name (name);
675 cleanup = make_cleanup (xfree, search_name);
677 objfile->global_psymbols.list + pst->globals_offset :
678 objfile->static_psymbols.list + pst->statics_offset);
680 if (global) /* This means we can use a binary search. */
682 do_linear_search = 0;
684 /* Binary search. This search is guaranteed to end with center
685 pointing at the earliest partial symbol whose name might be
686 correct. At that point *all* partial symbols with an
687 appropriate name will be checked against the correct
691 top = start + length - 1;
695 center = bottom + (top - bottom) / 2;
697 internal_error (__FILE__, __LINE__,
698 _("failed internal consistency check"));
699 if (!do_linear_search
700 && SYMBOL_LANGUAGE (*center) == language_java)
702 do_linear_search = 1;
704 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
714 if (!(top == bottom))
715 internal_error (__FILE__, __LINE__,
716 _("failed internal consistency check"));
718 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
719 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
720 while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
723 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
726 while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
728 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
729 SYMBOL_DOMAIN (*top), domain))
731 do_cleanups (cleanup);
738 /* Can't use a binary search or else we found during the binary search that
739 we should also do a linear search. */
741 if (do_linear_search)
743 for (psym = start; psym < start + length; psym++)
745 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
746 SYMBOL_DOMAIN (*psym), domain)
747 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
749 do_cleanups (cleanup);
755 do_cleanups (cleanup);
759 /* Get the symbol table that corresponds to a partial_symtab.
760 This is fast after the first time you do it. */
762 static struct symtab *
763 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
765 /* If it is a shared psymtab, find an unshared psymtab that includes
766 it. Any such psymtab will do. */
767 while (pst->user != NULL)
770 /* If it's been looked up before, return it. */
774 /* If it has not yet been read in, read it. */
777 struct cleanup *back_to = increment_reading_symtab ();
779 (*pst->read_symtab) (pst, objfile);
780 do_cleanups (back_to);
787 relocate_psymtabs (struct objfile *objfile,
788 const struct section_offsets *new_offsets,
789 const struct section_offsets *delta)
791 struct partial_symbol **psym;
792 struct partial_symtab *p;
794 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
796 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
797 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
800 for (psym = objfile->global_psymbols.list;
801 psym < objfile->global_psymbols.next;
804 fixup_psymbol_section (*psym, objfile);
805 if (SYMBOL_SECTION (*psym) >= 0)
806 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
807 SYMBOL_SECTION (*psym));
809 for (psym = objfile->static_psymbols.list;
810 psym < objfile->static_psymbols.next;
813 fixup_psymbol_section (*psym, objfile);
814 if (SYMBOL_SECTION (*psym) >= 0)
815 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
816 SYMBOL_SECTION (*psym));
820 static struct symtab *
821 find_last_source_symtab_from_partial (struct objfile *ofp)
823 struct partial_symtab *ps;
824 struct partial_symtab *cs_pst = 0;
826 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
828 const char *name = ps->filename;
829 int len = strlen (name);
831 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
832 || strcmp (name, "<<C++-namespaces>>") == 0)))
840 internal_error (__FILE__, __LINE__,
841 _("select_source_symtab: "
842 "readin pst found and no symtabs."));
845 return psymtab_to_symtab (ofp, cs_pst);
851 forget_cached_source_info_partial (struct objfile *objfile)
853 struct partial_symtab *pst;
855 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
857 if (pst->fullname != NULL)
859 xfree (pst->fullname);
860 pst->fullname = NULL;
866 print_partial_symbols (struct gdbarch *gdbarch,
867 struct partial_symbol **p, int count, char *what,
868 struct ui_file *outfile)
870 fprintf_filtered (outfile, " %s partial symbols:\n", what);
874 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
875 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
877 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
879 fputs_filtered (", ", outfile);
880 switch (SYMBOL_DOMAIN (*p))
883 fputs_filtered ("undefined domain, ", outfile);
886 /* This is the usual thing -- don't print it. */
889 fputs_filtered ("struct domain, ", outfile);
892 fputs_filtered ("label domain, ", outfile);
895 fputs_filtered ("<invalid domain>, ", outfile);
898 switch (PSYMBOL_CLASS (*p))
901 fputs_filtered ("undefined", outfile);
904 fputs_filtered ("constant int", outfile);
907 fputs_filtered ("static", outfile);
910 fputs_filtered ("register", outfile);
913 fputs_filtered ("pass by value", outfile);
916 fputs_filtered ("pass by reference", outfile);
918 case LOC_REGPARM_ADDR:
919 fputs_filtered ("register address parameter", outfile);
922 fputs_filtered ("stack parameter", outfile);
925 fputs_filtered ("type", outfile);
928 fputs_filtered ("label", outfile);
931 fputs_filtered ("function", outfile);
933 case LOC_CONST_BYTES:
934 fputs_filtered ("constant bytes", outfile);
937 fputs_filtered ("unresolved", outfile);
939 case LOC_OPTIMIZED_OUT:
940 fputs_filtered ("optimized out", outfile);
943 fputs_filtered ("computed at runtime", outfile);
946 fputs_filtered ("<invalid location>", outfile);
949 fputs_filtered (", ", outfile);
950 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
951 fprintf_filtered (outfile, "\n");
957 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
958 struct ui_file *outfile)
960 struct gdbarch *gdbarch = get_objfile_arch (objfile);
963 if (psymtab->anonymous)
965 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
970 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
973 fprintf_filtered (outfile, "(object ");
974 gdb_print_host_address (psymtab, outfile);
975 fprintf_filtered (outfile, ")\n\n");
976 fprintf_unfiltered (outfile, " Read from object file %s (",
977 objfile_name (objfile));
978 gdb_print_host_address (objfile, outfile);
979 fprintf_unfiltered (outfile, ")\n");
983 fprintf_filtered (outfile,
984 " Full symtab was read (at ");
985 gdb_print_host_address (psymtab->symtab, outfile);
986 fprintf_filtered (outfile, " by function at ");
987 gdb_print_host_address (psymtab->read_symtab, outfile);
988 fprintf_filtered (outfile, ")\n");
991 fprintf_filtered (outfile, " Relocate symbols by ");
992 for (i = 0; i < objfile->num_sections; ++i)
995 fprintf_filtered (outfile, ", ");
997 fputs_filtered (paddress (gdbarch,
998 ANOFFSET (psymtab->section_offsets, i)),
1001 fprintf_filtered (outfile, "\n");
1003 fprintf_filtered (outfile, " Symbols cover text addresses ");
1004 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
1005 fprintf_filtered (outfile, "-");
1006 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
1007 fprintf_filtered (outfile, "\n");
1008 fprintf_filtered (outfile, " Address map supported - %s.\n",
1009 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1010 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
1011 psymtab->number_of_dependencies);
1012 for (i = 0; i < psymtab->number_of_dependencies; i++)
1014 fprintf_filtered (outfile, " %d ", i);
1015 gdb_print_host_address (psymtab->dependencies[i], outfile);
1016 fprintf_filtered (outfile, " %s\n",
1017 psymtab->dependencies[i]->filename);
1019 if (psymtab->user != NULL)
1021 fprintf_filtered (outfile, " Shared partial symtab with user ");
1022 gdb_print_host_address (psymtab->user, outfile);
1023 fprintf_filtered (outfile, "\n");
1025 if (psymtab->n_global_syms > 0)
1027 print_partial_symbols (gdbarch,
1028 objfile->global_psymbols.list
1029 + psymtab->globals_offset,
1030 psymtab->n_global_syms, "Global", outfile);
1032 if (psymtab->n_static_syms > 0)
1034 print_partial_symbols (gdbarch,
1035 objfile->static_psymbols.list
1036 + psymtab->statics_offset,
1037 psymtab->n_static_syms, "Static", outfile);
1039 fprintf_filtered (outfile, "\n");
1043 print_psymtab_stats_for_objfile (struct objfile *objfile)
1046 struct partial_symtab *ps;
1049 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1051 if (ps->readin == 0)
1054 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1058 dump_psymtabs_for_objfile (struct objfile *objfile)
1060 struct partial_symtab *psymtab;
1062 if (objfile->psymtabs)
1064 printf_filtered ("Psymtabs:\n");
1065 for (psymtab = objfile->psymtabs;
1067 psymtab = psymtab->next)
1069 printf_filtered ("%s at ",
1071 gdb_print_host_address (psymtab, gdb_stdout);
1072 printf_filtered (", ");
1075 printf_filtered ("\n\n");
1079 /* Look through the partial symtabs for all symbols which begin
1080 by matching FUNC_NAME. Make sure we read that symbol table in. */
1083 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1085 struct partial_symtab *ps;
1087 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1092 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1094 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1096 psymtab_to_symtab (objfile, ps);
1101 expand_partial_symbol_tables (struct objfile *objfile)
1103 struct partial_symtab *psymtab;
1105 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1107 psymtab_to_symtab (objfile, psymtab);
1112 read_psymtabs_with_fullname (struct objfile *objfile, const char *fullname)
1114 struct partial_symtab *p;
1116 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1118 /* Anonymous psymtabs don't have a name of a source file. */
1122 /* psymtab_to_fullname tries to open the file which is slow.
1123 Don't call it if we know the basenames don't match. */
1124 if ((basenames_may_differ
1125 || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
1126 && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
1127 psymtab_to_symtab (objfile, p);
1132 map_symbol_filenames_psymtab (struct objfile *objfile,
1133 symbol_filename_ftype *fun, void *data,
1136 struct partial_symtab *ps;
1138 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1140 const char *fullname;
1145 /* We can skip shared psymtabs here, because any file name will be
1146 attached to the unshared psymtab. */
1147 if (ps->user != NULL)
1150 /* Anonymous psymtabs don't have a file name. */
1156 fullname = psymtab_to_fullname (ps);
1159 (*fun) (ps->filename, fullname, data);
1163 /* Finds the fullname that a partial_symtab represents.
1165 If this functions finds the fullname, it will save it in ps->fullname
1166 and it will also return the value.
1168 If this function fails to find the file that this partial_symtab represents,
1169 NULL will be returned and ps->fullname will be set to NULL. */
1172 psymtab_to_fullname (struct partial_symtab *ps)
1174 gdb_assert (!ps->anonymous);
1176 /* Use cached copy if we have it.
1177 We rely on forget_cached_source_info being called appropriately
1178 to handle cases like the file being moved. */
1179 if (ps->fullname == NULL)
1181 int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1188 struct cleanup *back_to;
1190 /* rewrite_source_path would be applied by find_and_open_source, we
1191 should report the pathname where GDB tried to find the file. */
1193 if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1194 fullname = xstrdup (ps->filename);
1196 fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);
1198 back_to = make_cleanup (xfree, fullname);
1199 ps->fullname = rewrite_source_path (fullname);
1200 if (ps->fullname == NULL)
1201 ps->fullname = xstrdup (fullname);
1202 do_cleanups (back_to);
1206 return ps->fullname;
1209 /* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1210 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1211 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1212 ever returns non-zero, and otherwise returns 0. */
1215 map_block (const char *name, domain_enum namespace, struct objfile *objfile,
1216 struct block *block,
1217 int (*callback) (struct block *, struct symbol *, void *),
1218 void *data, symbol_compare_ftype *match)
1220 struct block_iterator iter;
1223 for (sym = block_iter_match_first (block, name, match, &iter);
1224 sym != NULL; sym = block_iter_match_next (name, match, &iter))
1226 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1227 SYMBOL_DOMAIN (sym), namespace))
1229 if (callback (block, sym, data))
1237 /* Psymtab version of map_matching_symbols. See its definition in
1238 the definition of quick_symbol_functions in symfile.h. */
1241 map_matching_symbols_psymtab (struct objfile *objfile,
1242 const char *name, domain_enum namespace,
1244 int (*callback) (struct block *,
1245 struct symbol *, void *),
1247 symbol_compare_ftype *match,
1248 symbol_compare_ftype *ordered_compare)
1250 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1251 struct partial_symtab *ps;
1253 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1257 || match_partial_symbol (objfile, ps, global, name, namespace, match,
1260 struct symtab *s = psymtab_to_symtab (objfile, ps);
1261 struct block *block;
1263 if (s == NULL || !s->primary)
1265 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1266 if (map_block (name, namespace, objfile, block,
1267 callback, data, match))
1269 if (callback (block, NULL, data))
1275 /* A helper for expand_symtabs_matching_via_partial that handles
1276 searching included psymtabs. This returns 1 if a symbol is found,
1277 and zero otherwise. It also updates the 'searched_flag' on the
1278 various psymtabs that it searches. */
1281 recursively_search_psymtabs (struct partial_symtab *ps,
1282 struct objfile *objfile,
1283 enum search_domain kind,
1284 int (*name_matcher) (const char *, void *),
1287 struct partial_symbol **psym;
1288 struct partial_symbol **bound, **gbound, **sbound;
1290 int result = PST_SEARCHED_AND_NOT_FOUND;
1293 if (ps->searched_flag != PST_NOT_SEARCHED)
1294 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1296 /* Recurse into shared psymtabs first, because they may have already
1297 been searched, and this could save some time. */
1298 for (i = 0; i < ps->number_of_dependencies; ++i)
1302 /* Skip non-shared dependencies, these are handled elsewhere. */
1303 if (ps->dependencies[i]->user == NULL)
1306 r = recursively_search_psymtabs (ps->dependencies[i],
1307 objfile, kind, name_matcher, data);
1310 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1315 gbound = (objfile->global_psymbols.list
1316 + ps->globals_offset + ps->n_global_syms);
1317 sbound = (objfile->static_psymbols.list
1318 + ps->statics_offset + ps->n_static_syms);
1321 /* Go through all of the symbols stored in a partial
1322 symtab in one loop. */
1323 psym = objfile->global_psymbols.list + ps->globals_offset;
1328 if (bound == gbound && ps->n_static_syms != 0)
1330 psym = objfile->static_psymbols.list + ps->statics_offset;
1341 if ((kind == ALL_DOMAIN
1342 || (kind == VARIABLES_DOMAIN
1343 && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF
1344 && PSYMBOL_CLASS (*psym) != LOC_BLOCK)
1345 || (kind == FUNCTIONS_DOMAIN
1346 && PSYMBOL_CLASS (*psym) == LOC_BLOCK)
1347 || (kind == TYPES_DOMAIN
1348 && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1349 && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1351 /* Found a match, so notify our caller. */
1352 result = PST_SEARCHED_AND_FOUND;
1359 ps->searched_flag = result;
1360 return result == PST_SEARCHED_AND_FOUND;
1364 expand_symtabs_matching_via_partial
1365 (struct objfile *objfile,
1366 int (*file_matcher) (const char *, void *, int basenames),
1367 int (*name_matcher) (const char *, void *),
1368 enum search_domain kind,
1371 struct partial_symtab *ps;
1373 /* Clear the search flags. */
1374 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1376 ps->searched_flag = PST_NOT_SEARCHED;
1379 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1384 /* We skip shared psymtabs because file-matching doesn't apply
1385 to them; but we search them later in the loop. */
1386 if (ps->user != NULL)
1396 match = (*file_matcher) (ps->filename, data, 0);
1399 /* Before we invoke realpath, which can get expensive when many
1400 files are involved, do a quick comparison of the basenames. */
1401 if (basenames_may_differ
1402 || (*file_matcher) (lbasename (ps->filename), data, 1))
1403 match = (*file_matcher) (psymtab_to_fullname (ps), data, 0);
1409 if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
1410 psymtab_to_symtab (objfile, ps);
1415 objfile_has_psyms (struct objfile *objfile)
1417 return objfile->psymtabs != NULL;
1420 const struct quick_symbol_functions psym_functions =
1423 find_last_source_symtab_from_partial,
1424 forget_cached_source_info_partial,
1425 partial_map_symtabs_matching_filename,
1426 lookup_symbol_aux_psymtabs,
1427 print_psymtab_stats_for_objfile,
1428 dump_psymtabs_for_objfile,
1430 read_symtabs_for_function,
1431 expand_partial_symbol_tables,
1432 read_psymtabs_with_fullname,
1433 map_matching_symbols_psymtab,
1434 expand_symtabs_matching_via_partial,
1435 find_pc_sect_symtab_from_partial,
1436 map_symbol_filenames_psymtab
1441 /* This compares two partial symbols by names, using strcmp_iw_ordered
1442 for the comparison. */
1445 compare_psymbols (const void *s1p, const void *s2p)
1447 struct partial_symbol *const *s1 = s1p;
1448 struct partial_symbol *const *s2 = s2p;
1450 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1451 SYMBOL_SEARCH_NAME (*s2));
1455 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1457 /* Sort the global list; don't sort the static list. */
1459 qsort (objfile->global_psymbols.list + pst->globals_offset,
1460 pst->n_global_syms, sizeof (struct partial_symbol *),
1464 /* Allocate and partially fill a partial symtab. It will be
1465 completely filled at the end of the symbol list.
1467 FILENAME is the name of the symbol-file we are reading from. */
1469 struct partial_symtab *
1470 start_psymtab_common (struct objfile *objfile,
1471 struct section_offsets *section_offsets,
1472 const char *filename,
1473 CORE_ADDR textlow, struct partial_symbol **global_syms,
1474 struct partial_symbol **static_syms)
1476 struct partial_symtab *psymtab;
1478 psymtab = allocate_psymtab (filename, objfile);
1479 psymtab->section_offsets = section_offsets;
1480 psymtab->textlow = textlow;
1481 psymtab->texthigh = psymtab->textlow; /* default */
1482 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1483 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1487 /* Calculate a hash code for the given partial symbol. The hash is
1488 calculated using the symbol's value, language, domain, class
1489 and name. These are the values which are set by
1490 add_psymbol_to_bcache. */
1492 static unsigned long
1493 psymbol_hash (const void *addr, int length)
1495 unsigned long h = 0;
1496 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1497 unsigned int lang = psymbol->ginfo.language;
1498 unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1499 unsigned int class = PSYMBOL_CLASS (psymbol);
1501 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1502 h = hash_continue (&lang, sizeof (unsigned int), h);
1503 h = hash_continue (&domain, sizeof (unsigned int), h);
1504 h = hash_continue (&class, sizeof (unsigned int), h);
1505 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1510 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1511 For the comparison this function uses a symbols value,
1512 language, domain, class and name. */
1515 psymbol_compare (const void *addr1, const void *addr2, int length)
1517 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1518 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1520 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1521 sizeof (sym1->ginfo.value)) == 0
1522 && sym1->ginfo.language == sym2->ginfo.language
1523 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1524 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1525 && sym1->ginfo.name == sym2->ginfo.name);
1528 /* Initialize a partial symbol bcache. */
1530 struct psymbol_bcache *
1531 psymbol_bcache_init (void)
1533 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1534 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1538 /* Free a partial symbol bcache. */
1540 psymbol_bcache_free (struct psymbol_bcache *bcache)
1545 bcache_xfree (bcache->bcache);
1549 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1552 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1554 return bcache->bcache;
1557 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1558 symbol before, add a copy to BCACHE. In either case, return a pointer
1559 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1560 1 in case of new entry or 0 if returning an old entry. */
1562 static const struct partial_symbol *
1563 psymbol_bcache_full (struct partial_symbol *sym,
1564 struct psymbol_bcache *bcache,
1567 return bcache_full (sym,
1568 sizeof (struct partial_symbol),
1573 /* Helper function, initialises partial symbol structure and stashes
1574 it into objfile's bcache. Note that our caching mechanism will
1575 use all fields of struct partial_symbol to determine hash value of the
1576 structure. In other words, having two symbols with the same name but
1577 different domain (or address) is possible and correct. */
1579 static const struct partial_symbol *
1580 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1582 enum address_class class,
1583 long val, /* Value as a long */
1584 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1585 enum language language, struct objfile *objfile,
1588 struct partial_symbol psymbol;
1590 /* We must ensure that the entire struct has been zeroed before
1591 assigning to it, because an assignment may not touch some of the
1593 memset (&psymbol, 0, sizeof (psymbol));
1595 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1598 SYMBOL_VALUE (&psymbol) = val;
1602 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1604 SYMBOL_SECTION (&psymbol) = -1;
1605 SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack);
1606 PSYMBOL_DOMAIN (&psymbol) = domain;
1607 PSYMBOL_CLASS (&psymbol) = class;
1609 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1611 /* Stash the partial symbol away in the cache. */
1612 return psymbol_bcache_full (&psymbol,
1613 objfile->psymbol_cache,
1617 /* Increase the space allocated for LISTP, which is probably
1618 global_psymbols or static_psymbols. This space will eventually
1619 be freed in free_objfile(). */
1622 extend_psymbol_list (struct psymbol_allocation_list *listp,
1623 struct objfile *objfile)
1627 if (listp->size == 0)
1630 listp->list = (struct partial_symbol **)
1631 xmalloc (new_size * sizeof (struct partial_symbol *));
1635 new_size = listp->size * 2;
1636 listp->list = (struct partial_symbol **)
1637 xrealloc ((char *) listp->list,
1638 new_size * sizeof (struct partial_symbol *));
1640 /* Next assumes we only went one over. Should be good if
1641 program works correctly. */
1642 listp->next = listp->list + listp->size;
1643 listp->size = new_size;
1646 /* Helper function, adds partial symbol to the given partial symbol
1650 append_psymbol_to_list (struct psymbol_allocation_list *list,
1651 const struct partial_symbol *psym,
1652 struct objfile *objfile)
1654 if (list->next >= list->list + list->size)
1655 extend_psymbol_list (list, objfile);
1656 *list->next++ = (struct partial_symbol *) psym;
1657 OBJSTAT (objfile, n_psyms++);
1660 /* Add a symbol with a long value to a psymtab.
1661 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1662 Return the partial symbol that has been added. */
1665 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1667 enum address_class class,
1668 struct psymbol_allocation_list *list,
1669 long val, /* Value as a long */
1670 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1671 enum language language, struct objfile *objfile)
1673 const struct partial_symbol *psym;
1677 /* Stash the partial symbol away in the cache. */
1678 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
1679 val, coreaddr, language, objfile, &added);
1681 /* Do not duplicate global partial symbols. */
1682 if (list == &objfile->global_psymbols
1686 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1687 append_psymbol_to_list (list, psym, objfile);
1690 /* Initialize storage for partial symbols. */
1693 init_psymbol_list (struct objfile *objfile, int total_symbols)
1695 /* Free any previously allocated psymbol lists. */
1697 if (objfile->global_psymbols.list)
1699 xfree (objfile->global_psymbols.list);
1701 if (objfile->static_psymbols.list)
1703 xfree (objfile->static_psymbols.list);
1706 /* Current best guess is that approximately a twentieth
1707 of the total symbols (in a debugging file) are global or static
1708 oriented symbols, then multiply that by slop factor of two. */
1710 objfile->global_psymbols.size = total_symbols / 10;
1711 objfile->static_psymbols.size = total_symbols / 10;
1713 if (objfile->global_psymbols.size > 0)
1715 objfile->global_psymbols.next =
1716 objfile->global_psymbols.list = (struct partial_symbol **)
1717 xmalloc ((objfile->global_psymbols.size
1718 * sizeof (struct partial_symbol *)));
1720 if (objfile->static_psymbols.size > 0)
1722 objfile->static_psymbols.next =
1723 objfile->static_psymbols.list = (struct partial_symbol **)
1724 xmalloc ((objfile->static_psymbols.size
1725 * sizeof (struct partial_symbol *)));
1729 struct partial_symtab *
1730 allocate_psymtab (const char *filename, struct objfile *objfile)
1732 struct partial_symtab *psymtab;
1734 if (objfile->free_psymtabs)
1736 psymtab = objfile->free_psymtabs;
1737 objfile->free_psymtabs = psymtab->next;
1740 psymtab = (struct partial_symtab *)
1741 obstack_alloc (&objfile->objfile_obstack,
1742 sizeof (struct partial_symtab));
1744 memset (psymtab, 0, sizeof (struct partial_symtab));
1745 psymtab->filename = bcache (filename, strlen (filename) + 1,
1746 objfile->per_bfd->filename_cache);
1747 psymtab->symtab = NULL;
1749 /* Prepend it to the psymtab list for the objfile it belongs to.
1750 Psymtabs are searched in most recent inserted -> least recent
1753 psymtab->next = objfile->psymtabs;
1754 objfile->psymtabs = psymtab;
1756 if (symtab_create_debug)
1758 /* Be a bit clever with debugging messages, and don't print objfile
1759 every time, only when it changes. */
1760 static char *last_objfile_name = NULL;
1762 if (last_objfile_name == NULL
1763 || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
1765 xfree (last_objfile_name);
1766 last_objfile_name = xstrdup (objfile_name (objfile));
1767 fprintf_unfiltered (gdb_stdlog,
1768 "Creating one or more psymtabs for objfile %s ...\n",
1771 fprintf_unfiltered (gdb_stdlog,
1772 "Created psymtab %s for module %s.\n",
1773 host_address_to_string (psymtab), filename);
1780 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1782 struct partial_symtab **prev_pst;
1785 Empty psymtabs happen as a result of header files which don't
1786 have any symbols in them. There can be a lot of them. But this
1787 check is wrong, in that a psymtab with N_SLINE entries but
1788 nothing else is not empty, but we don't realize that. Fixing
1789 that without slowing things down might be tricky. */
1791 /* First, snip it out of the psymtab chain. */
1793 prev_pst = &(objfile->psymtabs);
1794 while ((*prev_pst) != pst)
1795 prev_pst = &((*prev_pst)->next);
1796 (*prev_pst) = pst->next;
1798 /* Next, put it on a free list for recycling. */
1800 pst->next = objfile->free_psymtabs;
1801 objfile->free_psymtabs = pst;
1804 /* An object of this type is passed to discard_psymtabs_upto. */
1806 struct psymtab_state
1808 /* The objfile where psymtabs are discarded. */
1810 struct objfile *objfile;
1812 /* The first psymtab to save. */
1814 struct partial_symtab *save;
1817 /* A cleanup function used by make_cleanup_discard_psymtabs. */
1820 discard_psymtabs_upto (void *arg)
1822 struct psymtab_state *state = arg;
1824 while (state->objfile->psymtabs != state->save)
1825 discard_psymtab (state->objfile, state->objfile->psymtabs);
1828 /* Return a new cleanup that discards all psymtabs created in OBJFILE
1829 after this function is called. */
1832 make_cleanup_discard_psymtabs (struct objfile *objfile)
1834 struct psymtab_state *state = XNEW (struct psymtab_state);
1836 state->objfile = objfile;
1837 state->save = objfile->psymtabs;
1839 return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
1845 maintenance_print_psymbols (char *args, int from_tty)
1848 struct ui_file *outfile;
1849 struct cleanup *cleanups;
1850 char *symname = NULL;
1851 char *filename = DEV_TTY;
1852 struct objfile *objfile;
1853 struct partial_symtab *ps;
1860 print-psymbols takes an output file name and optional symbol file name"));
1862 argv = gdb_buildargv (args);
1863 cleanups = make_cleanup_freeargv (argv);
1865 if (argv[0] != NULL)
1868 /* If a second arg is supplied, it is a source file name to match on. */
1869 if (argv[1] != NULL)
1875 filename = tilde_expand (filename);
1876 make_cleanup (xfree, filename);
1878 outfile = gdb_fopen (filename, FOPEN_WT);
1880 perror_with_name (filename);
1881 make_cleanup_ui_file_delete (outfile);
1883 ALL_PSYMTABS (objfile, ps)
1886 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1887 dump_psymtab (objfile, ps, outfile);
1889 do_cleanups (cleanups);
1892 /* List all the partial symbol tables whose names match REGEXP (optional). */
1894 maintenance_info_psymtabs (char *regexp, int from_tty)
1896 struct program_space *pspace;
1897 struct objfile *objfile;
1902 ALL_PSPACES (pspace)
1903 ALL_PSPACE_OBJFILES (pspace, objfile)
1905 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1906 struct partial_symtab *psymtab;
1908 /* We don't want to print anything for this objfile until we
1909 actually find a symtab whose name matches. */
1910 int printed_objfile_start = 0;
1912 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1917 || re_exec (psymtab->filename))
1919 if (! printed_objfile_start)
1921 printf_filtered ("{ objfile %s ", objfile_name (objfile));
1923 printf_filtered ("((struct objfile *) %s)\n",
1924 host_address_to_string (objfile));
1925 printed_objfile_start = 1;
1928 printf_filtered (" { psymtab %s ", psymtab->filename);
1930 printf_filtered ("((struct partial_symtab *) %s)\n",
1931 host_address_to_string (psymtab));
1933 printf_filtered (" readin %s\n",
1934 psymtab->readin ? "yes" : "no");
1935 printf_filtered (" fullname %s\n",
1937 ? psymtab->fullname : "(null)");
1938 printf_filtered (" text addresses ");
1939 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1941 printf_filtered (" -- ");
1942 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1944 printf_filtered ("\n");
1945 printf_filtered (" psymtabs_addrmap_supported %s\n",
1946 (psymtab->psymtabs_addrmap_supported
1948 printf_filtered (" globals ");
1949 if (psymtab->n_global_syms)
1951 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1952 host_address_to_string (objfile->global_psymbols.list
1953 + psymtab->globals_offset),
1954 psymtab->n_global_syms);
1957 printf_filtered ("(none)\n");
1958 printf_filtered (" statics ");
1959 if (psymtab->n_static_syms)
1961 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1962 host_address_to_string (objfile->static_psymbols.list
1963 + psymtab->statics_offset),
1964 psymtab->n_static_syms);
1967 printf_filtered ("(none)\n");
1968 printf_filtered (" dependencies ");
1969 if (psymtab->number_of_dependencies)
1973 printf_filtered ("{\n");
1974 for (i = 0; i < psymtab->number_of_dependencies; i++)
1976 struct partial_symtab *dep = psymtab->dependencies[i];
1978 /* Note the string concatenation there --- no comma. */
1979 printf_filtered (" psymtab %s "
1980 "((struct partial_symtab *) %s)\n",
1982 host_address_to_string (dep));
1984 printf_filtered (" }\n");
1987 printf_filtered ("(none)\n");
1988 printf_filtered (" }\n");
1992 if (printed_objfile_start)
1993 printf_filtered ("}\n");
1997 /* Check consistency of currently expanded psymtabs vs symtabs. */
2000 maintenance_check_psymtabs (char *ignore, int from_tty)
2003 struct partial_symbol **psym;
2004 struct symtab *s = NULL;
2005 struct partial_symtab *ps;
2006 struct blockvector *bv;
2007 struct objfile *objfile;
2011 ALL_PSYMTABS (objfile, ps)
2013 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2015 /* We don't call psymtab_to_symtab here because that may cause symtab
2016 expansion. When debugging a problem it helps if checkers leave
2017 things unchanged. */
2020 /* First do some checks that don't require the associated symtab. */
2021 if (ps->texthigh < ps->textlow)
2023 printf_filtered ("Psymtab ");
2024 puts_filtered (ps->filename);
2025 printf_filtered (" covers bad range ");
2026 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2027 printf_filtered (" - ");
2028 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2029 printf_filtered ("\n");
2033 /* Now do checks requiring the associated symtab. */
2036 bv = BLOCKVECTOR (s);
2037 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2038 psym = objfile->static_psymbols.list + ps->statics_offset;
2039 length = ps->n_static_syms;
2042 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2043 SYMBOL_DOMAIN (*psym));
2046 printf_filtered ("Static symbol `");
2047 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2048 printf_filtered ("' only found in ");
2049 puts_filtered (ps->filename);
2050 printf_filtered (" psymtab\n");
2054 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2055 psym = objfile->global_psymbols.list + ps->globals_offset;
2056 length = ps->n_global_syms;
2059 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2060 SYMBOL_DOMAIN (*psym));
2063 printf_filtered ("Global symbol `");
2064 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2065 printf_filtered ("' only found in ");
2066 puts_filtered (ps->filename);
2067 printf_filtered (" psymtab\n");
2071 if (ps->texthigh != 0
2072 && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b)))
2074 printf_filtered ("Psymtab ");
2075 puts_filtered (ps->filename);
2076 printf_filtered (" covers ");
2077 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2078 printf_filtered (" - ");
2079 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2080 printf_filtered (" but symtab covers only ");
2081 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2082 printf_filtered (" - ");
2083 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2084 printf_filtered ("\n");
2092 expand_partial_symbol_names (int (*fun) (const char *, void *),
2095 struct objfile *objfile;
2097 ALL_OBJFILES (objfile)
2100 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
2106 map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
2109 struct objfile *objfile;
2111 ALL_OBJFILES (objfile)
2114 objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
2119 extern initialize_file_ftype _initialize_psymtab;
2122 _initialize_psymtab (void)
2124 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2125 Print dump of current partial symbol definitions.\n\
2126 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2127 If a SOURCE file is specified, dump only that file's partial symbols."),
2128 &maintenanceprintlist);
2130 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2131 List the partial symbol tables for all object files.\n\
2132 This does not include information about individual partial symbols,\n\
2133 just the symbol table structures themselves."),
2134 &maintenanceinfolist);
2136 add_cmd ("check-psymtabs", class_maintenance, maintenance_check_psymtabs,
2138 Check consistency of currently expanded psymtabs versus symtabs."),