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 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)
632 pre_expand_symtabs_matching_psymtabs (struct objfile *objfile,
633 enum block_enum block_kind,
640 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
641 not contain any method/function instance information (since this would
642 force reading type information while reading psymtabs). Therefore,
643 if NAME contains overload information, it must be stripped before searching
646 The caller is responsible for freeing the return result. */
649 psymtab_search_name (const char *name)
651 switch (current_language->la_language)
656 if (strchr (name, '('))
658 char *ret = cp_remove_params (name);
670 return xstrdup (name);
673 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
674 Check the global symbols if GLOBAL, the static symbols if not. */
676 static struct partial_symbol *
677 lookup_partial_symbol (struct objfile *objfile,
678 struct partial_symtab *pst, const char *name,
679 int global, domain_enum domain)
681 struct partial_symbol **start, **psym;
682 struct partial_symbol **top, **real_top, **bottom, **center;
683 int length = (global ? pst->n_global_syms : pst->n_static_syms);
684 int do_linear_search = 1;
686 struct cleanup *cleanup;
693 search_name = psymtab_search_name (name);
694 cleanup = make_cleanup (xfree, search_name);
696 objfile->global_psymbols.list + pst->globals_offset :
697 objfile->static_psymbols.list + pst->statics_offset);
699 if (global) /* This means we can use a binary search. */
701 do_linear_search = 0;
703 /* Binary search. This search is guaranteed to end with center
704 pointing at the earliest partial symbol whose name might be
705 correct. At that point *all* partial symbols with an
706 appropriate name will be checked against the correct
710 top = start + length - 1;
714 center = bottom + (top - bottom) / 2;
716 internal_error (__FILE__, __LINE__,
717 _("failed internal consistency check"));
718 if (!do_linear_search
719 && SYMBOL_LANGUAGE (*center) == language_java)
721 do_linear_search = 1;
723 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
733 if (!(top == bottom))
734 internal_error (__FILE__, __LINE__,
735 _("failed internal consistency check"));
737 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
738 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
739 while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
742 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
745 while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
747 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
748 SYMBOL_DOMAIN (*top), domain))
750 do_cleanups (cleanup);
757 /* Can't use a binary search or else we found during the binary search that
758 we should also do a linear search. */
760 if (do_linear_search)
762 for (psym = start; psym < start + length; psym++)
764 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
765 SYMBOL_DOMAIN (*psym), domain)
766 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
768 do_cleanups (cleanup);
774 do_cleanups (cleanup);
778 /* Get the symbol table that corresponds to a partial_symtab.
779 This is fast after the first time you do it. */
781 static struct symtab *
782 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
784 /* If it is a shared psymtab, find an unshared psymtab that includes
785 it. Any such psymtab will do. */
786 while (pst->user != NULL)
789 /* If it's been looked up before, return it. */
793 /* If it has not yet been read in, read it. */
796 struct cleanup *back_to = increment_reading_symtab ();
798 (*pst->read_symtab) (objfile, pst);
799 do_cleanups (back_to);
806 relocate_psymtabs (struct objfile *objfile,
807 struct section_offsets *new_offsets,
808 struct section_offsets *delta)
810 struct partial_symbol **psym;
811 struct partial_symtab *p;
813 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
815 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
816 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
819 for (psym = objfile->global_psymbols.list;
820 psym < objfile->global_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));
828 for (psym = objfile->static_psymbols.list;
829 psym < objfile->static_psymbols.next;
832 fixup_psymbol_section (*psym, objfile);
833 if (SYMBOL_SECTION (*psym) >= 0)
834 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
835 SYMBOL_SECTION (*psym));
839 static struct symtab *
840 find_last_source_symtab_from_partial (struct objfile *ofp)
842 struct partial_symtab *ps;
843 struct partial_symtab *cs_pst = 0;
845 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
847 const char *name = ps->filename;
848 int len = strlen (name);
850 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
851 || strcmp (name, "<<C++-namespaces>>") == 0)))
859 internal_error (__FILE__, __LINE__,
860 _("select_source_symtab: "
861 "readin pst found and no symtabs."));
864 return psymtab_to_symtab (ofp, cs_pst);
870 forget_cached_source_info_partial (struct objfile *objfile)
872 struct partial_symtab *pst;
874 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
876 if (pst->fullname != NULL)
878 xfree (pst->fullname);
879 pst->fullname = NULL;
885 print_partial_symbols (struct gdbarch *gdbarch,
886 struct partial_symbol **p, int count, char *what,
887 struct ui_file *outfile)
889 fprintf_filtered (outfile, " %s partial symbols:\n", what);
893 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
894 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
896 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
898 fputs_filtered (", ", outfile);
899 switch (SYMBOL_DOMAIN (*p))
902 fputs_filtered ("undefined domain, ", outfile);
905 /* This is the usual thing -- don't print it. */
908 fputs_filtered ("struct domain, ", outfile);
911 fputs_filtered ("label domain, ", outfile);
914 fputs_filtered ("<invalid domain>, ", outfile);
917 switch (SYMBOL_CLASS (*p))
920 fputs_filtered ("undefined", outfile);
923 fputs_filtered ("constant int", outfile);
926 fputs_filtered ("static", outfile);
929 fputs_filtered ("register", outfile);
932 fputs_filtered ("pass by value", outfile);
935 fputs_filtered ("pass by reference", outfile);
937 case LOC_REGPARM_ADDR:
938 fputs_filtered ("register address parameter", outfile);
941 fputs_filtered ("stack parameter", outfile);
944 fputs_filtered ("type", outfile);
947 fputs_filtered ("label", outfile);
950 fputs_filtered ("function", outfile);
952 case LOC_CONST_BYTES:
953 fputs_filtered ("constant bytes", outfile);
956 fputs_filtered ("unresolved", outfile);
958 case LOC_OPTIMIZED_OUT:
959 fputs_filtered ("optimized out", outfile);
962 fputs_filtered ("computed at runtime", outfile);
965 fputs_filtered ("<invalid location>", outfile);
968 fputs_filtered (", ", outfile);
969 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
970 fprintf_filtered (outfile, "\n");
976 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
977 struct ui_file *outfile)
979 struct gdbarch *gdbarch = get_objfile_arch (objfile);
982 if (psymtab->anonymous)
984 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
989 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
992 fprintf_filtered (outfile, "(object ");
993 gdb_print_host_address (psymtab, outfile);
994 fprintf_filtered (outfile, ")\n\n");
995 fprintf_unfiltered (outfile, " Read from object file %s (",
997 gdb_print_host_address (objfile, outfile);
998 fprintf_unfiltered (outfile, ")\n");
1000 if (psymtab->readin)
1002 fprintf_filtered (outfile,
1003 " Full symtab was read (at ");
1004 gdb_print_host_address (psymtab->symtab, outfile);
1005 fprintf_filtered (outfile, " by function at ");
1006 gdb_print_host_address (psymtab->read_symtab, outfile);
1007 fprintf_filtered (outfile, ")\n");
1010 fprintf_filtered (outfile, " Relocate symbols by ");
1011 for (i = 0; i < objfile->num_sections; ++i)
1014 fprintf_filtered (outfile, ", ");
1016 fputs_filtered (paddress (gdbarch,
1017 ANOFFSET (psymtab->section_offsets, i)),
1020 fprintf_filtered (outfile, "\n");
1022 fprintf_filtered (outfile, " Symbols cover text addresses ");
1023 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
1024 fprintf_filtered (outfile, "-");
1025 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
1026 fprintf_filtered (outfile, "\n");
1027 fprintf_filtered (outfile, " Address map supported - %s.\n",
1028 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1029 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
1030 psymtab->number_of_dependencies);
1031 for (i = 0; i < psymtab->number_of_dependencies; i++)
1033 fprintf_filtered (outfile, " %d ", i);
1034 gdb_print_host_address (psymtab->dependencies[i], outfile);
1035 fprintf_filtered (outfile, " %s\n",
1036 psymtab->dependencies[i]->filename);
1038 if (psymtab->user != NULL)
1040 fprintf_filtered (outfile, " Shared partial symtab with user ");
1041 gdb_print_host_address (psymtab->user, outfile);
1042 fprintf_filtered (outfile, "\n");
1044 if (psymtab->n_global_syms > 0)
1046 print_partial_symbols (gdbarch,
1047 objfile->global_psymbols.list
1048 + psymtab->globals_offset,
1049 psymtab->n_global_syms, "Global", outfile);
1051 if (psymtab->n_static_syms > 0)
1053 print_partial_symbols (gdbarch,
1054 objfile->static_psymbols.list
1055 + psymtab->statics_offset,
1056 psymtab->n_static_syms, "Static", outfile);
1058 fprintf_filtered (outfile, "\n");
1062 print_psymtab_stats_for_objfile (struct objfile *objfile)
1065 struct partial_symtab *ps;
1068 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1070 if (ps->readin == 0)
1073 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1077 dump_psymtabs_for_objfile (struct objfile *objfile)
1079 struct partial_symtab *psymtab;
1081 if (objfile->psymtabs)
1083 printf_filtered ("Psymtabs:\n");
1084 for (psymtab = objfile->psymtabs;
1086 psymtab = psymtab->next)
1088 printf_filtered ("%s at ",
1090 gdb_print_host_address (psymtab, gdb_stdout);
1091 printf_filtered (", ");
1094 printf_filtered ("\n\n");
1098 /* Look through the partial symtabs for all symbols which begin
1099 by matching FUNC_NAME. Make sure we read that symbol table in. */
1102 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1104 struct partial_symtab *ps;
1106 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1111 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1113 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1115 psymtab_to_symtab (objfile, ps);
1120 expand_partial_symbol_tables (struct objfile *objfile)
1122 struct partial_symtab *psymtab;
1124 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1126 psymtab_to_symtab (objfile, psymtab);
1131 read_psymtabs_with_filename (struct objfile *objfile, const char *filename)
1133 struct partial_symtab *p;
1135 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1137 /* Anonymous psymtabs don't have a name of a source file. */
1141 if (filename_cmp (filename, p->filename) == 0)
1142 psymtab_to_symtab (objfile, p);
1147 map_symbol_filenames_psymtab (struct objfile *objfile,
1148 symbol_filename_ftype *fun, void *data,
1151 struct partial_symtab *ps;
1153 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1155 const char *fullname;
1160 /* We can skip shared psymtabs here, because any file name will be
1161 attached to the unshared psymtab. */
1162 if (ps->user != NULL)
1165 /* Anonymous psymtabs don't have a file name. */
1171 fullname = psymtab_to_fullname (ps);
1174 (*fun) (ps->filename, fullname, data);
1178 /* Finds the fullname that a partial_symtab represents.
1180 If this functions finds the fullname, it will save it in ps->fullname
1181 and it will also return the value.
1183 If this function fails to find the file that this partial_symtab represents,
1184 NULL will be returned and ps->fullname will be set to NULL. */
1187 psymtab_to_fullname (struct partial_symtab *ps)
1196 /* Use cached copy if we have it.
1197 We rely on forget_cached_source_info being called appropriately
1198 to handle cases like the file being moved. */
1200 return ps->fullname;
1202 r = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1207 return ps->fullname;
1214 find_symbol_file_from_partial (struct objfile *objfile, const char *name)
1216 struct partial_symtab *pst;
1218 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1220 if (lookup_partial_symbol (objfile, pst, name, 1, VAR_DOMAIN))
1221 return pst->filename;
1226 /* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1227 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1228 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1229 ever returns non-zero, and otherwise returns 0. */
1232 map_block (const char *name, domain_enum namespace, struct objfile *objfile,
1233 struct block *block,
1234 int (*callback) (struct block *, struct symbol *, void *),
1235 void *data, symbol_compare_ftype *match)
1237 struct block_iterator iter;
1240 for (sym = block_iter_match_first (block, name, match, &iter);
1241 sym != NULL; sym = block_iter_match_next (name, match, &iter))
1243 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1244 SYMBOL_DOMAIN (sym), namespace))
1246 if (callback (block, sym, data))
1254 /* Psymtab version of map_matching_symbols. See its definition in
1255 the definition of quick_symbol_functions in symfile.h. */
1258 map_matching_symbols_psymtab (const char *name, domain_enum namespace,
1259 struct objfile *objfile, int global,
1260 int (*callback) (struct block *,
1261 struct symbol *, void *),
1263 symbol_compare_ftype *match,
1264 symbol_compare_ftype *ordered_compare)
1266 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1267 struct partial_symtab *ps;
1269 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1273 || match_partial_symbol (objfile, ps, global, name, namespace, match,
1276 struct symtab *s = psymtab_to_symtab (objfile, ps);
1277 struct block *block;
1279 if (s == NULL || !s->primary)
1281 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1282 if (map_block (name, namespace, objfile, block,
1283 callback, data, match))
1285 if (callback (block, NULL, data))
1291 /* A helper for expand_symtabs_matching_via_partial that handles
1292 searching included psymtabs. This returns 1 if a symbol is found,
1293 and zero otherwise. It also updates the 'searched_flag' on the
1294 various psymtabs that it searches. */
1297 recursively_search_psymtabs (struct partial_symtab *ps,
1298 struct objfile *objfile,
1299 enum search_domain kind,
1300 int (*name_matcher) (const char *, void *),
1303 struct partial_symbol **psym;
1304 struct partial_symbol **bound, **gbound, **sbound;
1306 int result = PST_SEARCHED_AND_NOT_FOUND;
1309 if (ps->searched_flag != PST_NOT_SEARCHED)
1310 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1312 /* Recurse into shared psymtabs first, because they may have already
1313 been searched, and this could save some time. */
1314 for (i = 0; i < ps->number_of_dependencies; ++i)
1318 /* Skip non-shared dependencies, these are handled elsewhere. */
1319 if (ps->dependencies[i]->user == NULL)
1322 r = recursively_search_psymtabs (ps->dependencies[i],
1323 objfile, kind, name_matcher, data);
1326 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1331 gbound = (objfile->global_psymbols.list
1332 + ps->globals_offset + ps->n_global_syms);
1333 sbound = (objfile->static_psymbols.list
1334 + ps->statics_offset + ps->n_static_syms);
1337 /* Go through all of the symbols stored in a partial
1338 symtab in one loop. */
1339 psym = objfile->global_psymbols.list + ps->globals_offset;
1344 if (bound == gbound && ps->n_static_syms != 0)
1346 psym = objfile->static_psymbols.list + ps->statics_offset;
1357 if ((kind == ALL_DOMAIN
1358 || (kind == VARIABLES_DOMAIN
1359 && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
1360 && SYMBOL_CLASS (*psym) != LOC_BLOCK)
1361 || (kind == FUNCTIONS_DOMAIN
1362 && SYMBOL_CLASS (*psym) == LOC_BLOCK)
1363 || (kind == TYPES_DOMAIN
1364 && SYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1365 && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1367 /* Found a match, so notify our caller. */
1368 result = PST_SEARCHED_AND_FOUND;
1375 ps->searched_flag = result;
1376 return result == PST_SEARCHED_AND_FOUND;
1380 expand_symtabs_matching_via_partial
1381 (struct objfile *objfile,
1382 int (*file_matcher) (const char *, void *),
1383 int (*name_matcher) (const char *, void *),
1384 enum search_domain kind,
1387 struct partial_symtab *ps;
1389 /* Clear the search flags. */
1390 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1392 ps->searched_flag = PST_NOT_SEARCHED;
1395 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1400 /* We skip shared psymtabs because file-matching doesn't apply
1401 to them; but we search them later in the loop. */
1402 if (ps->user != NULL)
1409 if (! (*file_matcher) (ps->filename, data))
1413 if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
1414 psymtab_to_symtab (objfile, ps);
1419 objfile_has_psyms (struct objfile *objfile)
1421 return objfile->psymtabs != NULL;
1424 const struct quick_symbol_functions psym_functions =
1427 find_last_source_symtab_from_partial,
1428 forget_cached_source_info_partial,
1429 partial_map_symtabs_matching_filename,
1430 lookup_symbol_aux_psymtabs,
1431 pre_expand_symtabs_matching_psymtabs,
1432 print_psymtab_stats_for_objfile,
1433 dump_psymtabs_for_objfile,
1435 read_symtabs_for_function,
1436 expand_partial_symbol_tables,
1437 read_psymtabs_with_filename,
1438 find_symbol_file_from_partial,
1439 map_matching_symbols_psymtab,
1440 expand_symtabs_matching_via_partial,
1441 find_pc_sect_symtab_from_partial,
1442 map_symbol_filenames_psymtab
1447 /* This compares two partial symbols by names, using strcmp_iw_ordered
1448 for the comparison. */
1451 compare_psymbols (const void *s1p, const void *s2p)
1453 struct partial_symbol *const *s1 = s1p;
1454 struct partial_symbol *const *s2 = s2p;
1456 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1457 SYMBOL_SEARCH_NAME (*s2));
1461 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1463 /* Sort the global list; don't sort the static list. */
1465 qsort (objfile->global_psymbols.list + pst->globals_offset,
1466 pst->n_global_syms, sizeof (struct partial_symbol *),
1470 /* Allocate and partially fill a partial symtab. It will be
1471 completely filled at the end of the symbol list.
1473 FILENAME is the name of the symbol-file we are reading from. */
1475 struct partial_symtab *
1476 start_psymtab_common (struct objfile *objfile,
1477 struct section_offsets *section_offsets,
1478 const char *filename,
1479 CORE_ADDR textlow, struct partial_symbol **global_syms,
1480 struct partial_symbol **static_syms)
1482 struct partial_symtab *psymtab;
1484 psymtab = allocate_psymtab (filename, objfile);
1485 psymtab->section_offsets = section_offsets;
1486 psymtab->textlow = textlow;
1487 psymtab->texthigh = psymtab->textlow; /* default */
1488 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1489 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1493 /* Calculate a hash code for the given partial symbol. The hash is
1494 calculated using the symbol's value, language, domain, class
1495 and name. These are the values which are set by
1496 add_psymbol_to_bcache. */
1498 static unsigned long
1499 psymbol_hash (const void *addr, int length)
1501 unsigned long h = 0;
1502 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1503 unsigned int lang = psymbol->ginfo.language;
1504 unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1505 unsigned int class = PSYMBOL_CLASS (psymbol);
1507 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1508 h = hash_continue (&lang, sizeof (unsigned int), h);
1509 h = hash_continue (&domain, sizeof (unsigned int), h);
1510 h = hash_continue (&class, sizeof (unsigned int), h);
1511 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1516 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1517 For the comparison this function uses a symbols value,
1518 language, domain, class and name. */
1521 psymbol_compare (const void *addr1, const void *addr2, int length)
1523 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1524 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1526 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1527 sizeof (sym1->ginfo.value)) == 0
1528 && sym1->ginfo.language == sym2->ginfo.language
1529 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1530 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1531 && sym1->ginfo.name == sym2->ginfo.name);
1534 /* Initialize a partial symbol bcache. */
1536 struct psymbol_bcache *
1537 psymbol_bcache_init (void)
1539 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1540 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1544 /* Free a partial symbol bcache. */
1546 psymbol_bcache_free (struct psymbol_bcache *bcache)
1551 bcache_xfree (bcache->bcache);
1555 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1558 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1560 return bcache->bcache;
1563 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1564 symbol before, add a copy to BCACHE. In either case, return a pointer
1565 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1566 1 in case of new entry or 0 if returning an old entry. */
1568 static const struct partial_symbol *
1569 psymbol_bcache_full (struct partial_symbol *sym,
1570 struct psymbol_bcache *bcache,
1573 return bcache_full (sym,
1574 sizeof (struct partial_symbol),
1579 /* Helper function, initialises partial symbol structure and stashes
1580 it into objfile's bcache. Note that our caching mechanism will
1581 use all fields of struct partial_symbol to determine hash value of the
1582 structure. In other words, having two symbols with the same name but
1583 different domain (or address) is possible and correct. */
1585 static const struct partial_symbol *
1586 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1588 enum address_class class,
1589 long val, /* Value as a long */
1590 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1591 enum language language, struct objfile *objfile,
1594 struct partial_symbol psymbol;
1596 /* We must ensure that the entire 'value' field has been zeroed
1597 before assigning to it, because an assignment may not write the
1599 memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
1601 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1604 SYMBOL_VALUE (&psymbol) = val;
1608 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1610 SYMBOL_SECTION (&psymbol) = 0;
1611 SYMBOL_OBJ_SECTION (&psymbol) = NULL;
1612 SYMBOL_SET_LANGUAGE (&psymbol, language);
1613 PSYMBOL_DOMAIN (&psymbol) = domain;
1614 PSYMBOL_CLASS (&psymbol) = class;
1616 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1618 /* Stash the partial symbol away in the cache. */
1619 return psymbol_bcache_full (&psymbol,
1620 objfile->psymbol_cache,
1624 /* Increase the space allocated for LISTP, which is probably
1625 global_psymbols or static_psymbols. This space will eventually
1626 be freed in free_objfile(). */
1629 extend_psymbol_list (struct psymbol_allocation_list *listp,
1630 struct objfile *objfile)
1634 if (listp->size == 0)
1637 listp->list = (struct partial_symbol **)
1638 xmalloc (new_size * sizeof (struct partial_symbol *));
1642 new_size = listp->size * 2;
1643 listp->list = (struct partial_symbol **)
1644 xrealloc ((char *) listp->list,
1645 new_size * sizeof (struct partial_symbol *));
1647 /* Next assumes we only went one over. Should be good if
1648 program works correctly. */
1649 listp->next = listp->list + listp->size;
1650 listp->size = new_size;
1653 /* Helper function, adds partial symbol to the given partial symbol
1657 append_psymbol_to_list (struct psymbol_allocation_list *list,
1658 const struct partial_symbol *psym,
1659 struct objfile *objfile)
1661 if (list->next >= list->list + list->size)
1662 extend_psymbol_list (list, objfile);
1663 *list->next++ = (struct partial_symbol *) psym;
1664 OBJSTAT (objfile, n_psyms++);
1667 /* Add a symbol with a long value to a psymtab.
1668 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1669 Return the partial symbol that has been added. */
1672 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1674 enum address_class class,
1675 struct psymbol_allocation_list *list,
1676 long val, /* Value as a long */
1677 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1678 enum language language, struct objfile *objfile)
1680 const struct partial_symbol *psym;
1684 /* Stash the partial symbol away in the cache. */
1685 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
1686 val, coreaddr, language, objfile, &added);
1688 /* Do not duplicate global partial symbols. */
1689 if (list == &objfile->global_psymbols
1693 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1694 append_psymbol_to_list (list, psym, objfile);
1697 /* Initialize storage for partial symbols. */
1700 init_psymbol_list (struct objfile *objfile, int total_symbols)
1702 /* Free any previously allocated psymbol lists. */
1704 if (objfile->global_psymbols.list)
1706 xfree (objfile->global_psymbols.list);
1708 if (objfile->static_psymbols.list)
1710 xfree (objfile->static_psymbols.list);
1713 /* Current best guess is that approximately a twentieth
1714 of the total symbols (in a debugging file) are global or static
1715 oriented symbols. */
1717 objfile->global_psymbols.size = total_symbols / 10;
1718 objfile->static_psymbols.size = total_symbols / 10;
1720 if (objfile->global_psymbols.size > 0)
1722 objfile->global_psymbols.next =
1723 objfile->global_psymbols.list = (struct partial_symbol **)
1724 xmalloc ((objfile->global_psymbols.size
1725 * sizeof (struct partial_symbol *)));
1727 if (objfile->static_psymbols.size > 0)
1729 objfile->static_psymbols.next =
1730 objfile->static_psymbols.list = (struct partial_symbol **)
1731 xmalloc ((objfile->static_psymbols.size
1732 * sizeof (struct partial_symbol *)));
1736 struct partial_symtab *
1737 allocate_psymtab (const char *filename, struct objfile *objfile)
1739 struct partial_symtab *psymtab;
1741 if (objfile->free_psymtabs)
1743 psymtab = objfile->free_psymtabs;
1744 objfile->free_psymtabs = psymtab->next;
1747 psymtab = (struct partial_symtab *)
1748 obstack_alloc (&objfile->objfile_obstack,
1749 sizeof (struct partial_symtab));
1751 memset (psymtab, 0, sizeof (struct partial_symtab));
1752 psymtab->filename = obsavestring (filename, strlen (filename),
1753 &objfile->objfile_obstack);
1754 psymtab->symtab = NULL;
1756 /* Prepend it to the psymtab list for the objfile it belongs to.
1757 Psymtabs are searched in most recent inserted -> least recent
1760 psymtab->next = objfile->psymtabs;
1761 objfile->psymtabs = psymtab;
1763 if (symtab_create_debug)
1765 /* Be a bit clever with debugging messages, and don't print objfile
1766 every time, only when it changes. */
1767 static char *last_objfile_name = NULL;
1769 if (last_objfile_name == NULL
1770 || strcmp (last_objfile_name, objfile->name) != 0)
1772 xfree (last_objfile_name);
1773 last_objfile_name = xstrdup (objfile->name);
1774 fprintf_unfiltered (gdb_stdlog,
1775 "Creating one or more psymtabs for objfile %s ...\n",
1778 fprintf_unfiltered (gdb_stdlog,
1779 "Created psymtab %s for module %s.\n",
1780 host_address_to_string (psymtab), filename);
1787 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1789 struct partial_symtab **prev_pst;
1792 Empty psymtabs happen as a result of header files which don't
1793 have any symbols in them. There can be a lot of them. But this
1794 check is wrong, in that a psymtab with N_SLINE entries but
1795 nothing else is not empty, but we don't realize that. Fixing
1796 that without slowing things down might be tricky. */
1798 /* First, snip it out of the psymtab chain. */
1800 prev_pst = &(objfile->psymtabs);
1801 while ((*prev_pst) != pst)
1802 prev_pst = &((*prev_pst)->next);
1803 (*prev_pst) = pst->next;
1805 /* Next, put it on a free list for recycling. */
1807 pst->next = objfile->free_psymtabs;
1808 objfile->free_psymtabs = pst;
1814 maintenance_print_psymbols (char *args, int from_tty)
1817 struct ui_file *outfile;
1818 struct cleanup *cleanups;
1819 char *symname = NULL;
1820 char *filename = DEV_TTY;
1821 struct objfile *objfile;
1822 struct partial_symtab *ps;
1829 print-psymbols takes an output file name and optional symbol file name"));
1831 argv = gdb_buildargv (args);
1832 cleanups = make_cleanup_freeargv (argv);
1834 if (argv[0] != NULL)
1837 /* If a second arg is supplied, it is a source file name to match on. */
1838 if (argv[1] != NULL)
1844 filename = tilde_expand (filename);
1845 make_cleanup (xfree, filename);
1847 outfile = gdb_fopen (filename, FOPEN_WT);
1849 perror_with_name (filename);
1850 make_cleanup_ui_file_delete (outfile);
1852 ALL_PSYMTABS (objfile, ps)
1855 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1856 dump_psymtab (objfile, ps, outfile);
1858 do_cleanups (cleanups);
1861 /* List all the partial symbol tables whose names match REGEXP (optional). */
1863 maintenance_info_psymtabs (char *regexp, int from_tty)
1865 struct program_space *pspace;
1866 struct objfile *objfile;
1871 ALL_PSPACES (pspace)
1872 ALL_PSPACE_OBJFILES (pspace, objfile)
1874 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1875 struct partial_symtab *psymtab;
1877 /* We don't want to print anything for this objfile until we
1878 actually find a symtab whose name matches. */
1879 int printed_objfile_start = 0;
1881 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1886 || re_exec (psymtab->filename))
1888 if (! printed_objfile_start)
1890 printf_filtered ("{ objfile %s ", objfile->name);
1892 printf_filtered ("((struct objfile *) %s)\n",
1893 host_address_to_string (objfile));
1894 printed_objfile_start = 1;
1897 printf_filtered (" { psymtab %s ", psymtab->filename);
1899 printf_filtered ("((struct partial_symtab *) %s)\n",
1900 host_address_to_string (psymtab));
1902 printf_filtered (" readin %s\n",
1903 psymtab->readin ? "yes" : "no");
1904 printf_filtered (" fullname %s\n",
1906 ? psymtab->fullname : "(null)");
1907 printf_filtered (" text addresses ");
1908 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1910 printf_filtered (" -- ");
1911 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1913 printf_filtered ("\n");
1914 printf_filtered (" psymtabs_addrmap_supported %s\n",
1915 (psymtab->psymtabs_addrmap_supported
1917 printf_filtered (" globals ");
1918 if (psymtab->n_global_syms)
1920 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1921 host_address_to_string (objfile->global_psymbols.list
1922 + psymtab->globals_offset),
1923 psymtab->n_global_syms);
1926 printf_filtered ("(none)\n");
1927 printf_filtered (" statics ");
1928 if (psymtab->n_static_syms)
1930 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1931 host_address_to_string (objfile->static_psymbols.list
1932 + psymtab->statics_offset),
1933 psymtab->n_static_syms);
1936 printf_filtered ("(none)\n");
1937 printf_filtered (" dependencies ");
1938 if (psymtab->number_of_dependencies)
1942 printf_filtered ("{\n");
1943 for (i = 0; i < psymtab->number_of_dependencies; i++)
1945 struct partial_symtab *dep = psymtab->dependencies[i];
1947 /* Note the string concatenation there --- no comma. */
1948 printf_filtered (" psymtab %s "
1949 "((struct partial_symtab *) %s)\n",
1951 host_address_to_string (dep));
1953 printf_filtered (" }\n");
1956 printf_filtered ("(none)\n");
1957 printf_filtered (" }\n");
1961 if (printed_objfile_start)
1962 printf_filtered ("}\n");
1966 /* Check consistency of psymtabs and symtabs. */
1969 maintenance_check_symtabs (char *ignore, int from_tty)
1972 struct partial_symbol **psym;
1973 struct symtab *s = NULL;
1974 struct partial_symtab *ps;
1975 struct blockvector *bv;
1976 struct objfile *objfile;
1980 ALL_PSYMTABS (objfile, ps)
1982 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1984 s = psymtab_to_symtab (objfile, ps);
1987 bv = BLOCKVECTOR (s);
1988 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1989 psym = objfile->static_psymbols.list + ps->statics_offset;
1990 length = ps->n_static_syms;
1993 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1994 SYMBOL_DOMAIN (*psym));
1997 printf_filtered ("Static symbol `");
1998 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
1999 printf_filtered ("' only found in ");
2000 puts_filtered (ps->filename);
2001 printf_filtered (" psymtab\n");
2005 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2006 psym = objfile->global_psymbols.list + ps->globals_offset;
2007 length = ps->n_global_syms;
2010 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2011 SYMBOL_DOMAIN (*psym));
2014 printf_filtered ("Global symbol `");
2015 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2016 printf_filtered ("' only found in ");
2017 puts_filtered (ps->filename);
2018 printf_filtered (" psymtab\n");
2022 if (ps->texthigh < ps->textlow)
2024 printf_filtered ("Psymtab ");
2025 puts_filtered (ps->filename);
2026 printf_filtered (" covers bad range ");
2027 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2028 printf_filtered (" - ");
2029 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2030 printf_filtered ("\n");
2033 if (ps->texthigh == 0)
2035 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
2037 printf_filtered ("Psymtab ");
2038 puts_filtered (ps->filename);
2039 printf_filtered (" covers ");
2040 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2041 printf_filtered (" - ");
2042 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2043 printf_filtered (" but symtab covers only ");
2044 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2045 printf_filtered (" - ");
2046 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2047 printf_filtered ("\n");
2055 expand_partial_symbol_names (int (*fun) (const char *, void *),
2058 struct objfile *objfile;
2060 ALL_OBJFILES (objfile)
2063 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
2069 map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
2072 struct objfile *objfile;
2074 ALL_OBJFILES (objfile)
2077 objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
2082 extern initialize_file_ftype _initialize_psymtab;
2085 _initialize_psymtab (void)
2087 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2088 Print dump of current partial symbol definitions.\n\
2089 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2090 If a SOURCE file is specified, dump only that file's partial symbols."),
2091 &maintenanceprintlist);
2093 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2094 List the partial symbol tables for all object files.\n\
2095 This does not include information about individual partial symbols,\n\
2096 just the symbol table structures themselves."),
2097 &maintenanceinfolist);
2099 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
2100 _("Check consistency of psymtabs and symtabs."),