1 /* Partial symbol tables.
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_assert.h"
26 #include "filenames.h"
33 #include "readline/readline.h"
34 #include "gdb_regex.h"
35 #include "dictionary.h"
37 #include "cp-support.h"
41 #define DEV_TTY "/dev/tty"
46 struct bcache *bcache;
49 static struct partial_symbol *match_partial_symbol (struct objfile *,
50 struct partial_symtab *,
52 const char *, domain_enum,
53 symbol_compare_ftype *,
54 symbol_compare_ftype *);
56 static struct partial_symbol *lookup_partial_symbol (struct objfile *,
57 struct partial_symtab *,
61 static const char *psymtab_to_fullname (struct partial_symtab *ps);
63 static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
64 struct partial_symtab *,
66 struct obj_section *);
68 static void fixup_psymbol_section (struct partial_symbol *psym,
69 struct objfile *objfile);
71 static struct symtab *psymtab_to_symtab (struct objfile *objfile,
72 struct partial_symtab *pst);
74 /* Ensure that the partial symbols for OBJFILE have been loaded. This
75 function always returns its argument, as a convenience. */
78 require_partial_symbols (struct objfile *objfile, int verbose)
80 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
82 objfile->flags |= OBJF_PSYMTABS_READ;
84 if (objfile->sf->sym_read_psymbols)
88 printf_unfiltered (_("Reading symbols from %s..."),
90 gdb_flush (gdb_stdout);
92 (*objfile->sf->sym_read_psymbols) (objfile);
95 if (!objfile_has_symbols (objfile))
98 printf_unfiltered (_("(no debugging symbols found)..."));
102 printf_unfiltered (_("done.\n"));
110 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
113 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
114 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
118 /* We want to make sure this file always requires psymtabs. */
120 #undef ALL_OBJFILE_PSYMTABS
122 /* Traverse all psymtabs in all objfiles. */
124 #define ALL_PSYMTABS(objfile, p) \
125 ALL_OBJFILES (objfile) \
126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
128 /* Helper function for partial_map_symtabs_matching_filename that
129 expands the symtabs and calls the iterator. */
132 partial_map_expand_apply (struct objfile *objfile,
134 const char *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 && SYMBOL_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 (p), section))
435 best_pc = SYMBOL_VALUE_ADDRESS (p);
440 for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
441 (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
442 < psymtab->n_static_syms);
446 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
447 && SYMBOL_CLASS (p) == LOC_BLOCK
448 && pc >= SYMBOL_VALUE_ADDRESS (p)
449 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
450 || (psymtab->textlow == 0
451 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
453 if (section) /* Match on a specific section. */
455 fixup_psymbol_section (p, objfile);
456 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
459 best_pc = SYMBOL_VALUE_ADDRESS (p);
468 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
472 if (psym == NULL || SYMBOL_OBJ_SECTION (psym) != NULL)
475 gdb_assert (objfile);
477 switch (SYMBOL_CLASS (psym))
482 addr = SYMBOL_VALUE_ADDRESS (psym);
485 /* Nothing else will be listed in the minsyms -- no use looking
490 fixup_section (&psym->ginfo, addr, objfile);
493 static struct symtab *
494 lookup_symbol_aux_psymtabs (struct objfile *objfile,
495 int block_index, const char *name,
496 const domain_enum domain)
498 struct partial_symtab *ps;
499 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
500 struct symtab *stab_best = NULL;
502 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
504 if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
505 psymtab_index, domain))
507 struct symbol *sym = NULL;
508 struct symtab *stab = psymtab_to_symtab (objfile, ps);
510 /* Some caution must be observed with overloaded functions
511 and methods, since the psymtab will not contain any overload
512 information (but NAME might contain it). */
515 struct blockvector *bv = BLOCKVECTOR (stab);
516 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
518 sym = lookup_block_symbol (block, name, domain);
521 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
523 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
529 /* Keep looking through other psymtabs. */
536 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
537 the global block of PST if GLOBAL, and otherwise the static block.
538 MATCH is the comparison operation that returns true iff MATCH (s,
539 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
540 non-null, the symbols in the block are assumed to be ordered
541 according to it (allowing binary search). It must be compatible
542 with MATCH. Returns the symbol, if found, and otherwise NULL. */
544 static struct partial_symbol *
545 match_partial_symbol (struct objfile *objfile,
546 struct partial_symtab *pst, int global,
547 const char *name, domain_enum domain,
548 symbol_compare_ftype *match,
549 symbol_compare_ftype *ordered_compare)
551 struct partial_symbol **start, **psym;
552 struct partial_symbol **top, **real_top, **bottom, **center;
553 int length = (global ? pst->n_global_syms : pst->n_static_syms);
554 int do_linear_search = 1;
559 objfile->global_psymbols.list + pst->globals_offset :
560 objfile->static_psymbols.list + pst->statics_offset);
562 if (global && ordered_compare) /* Can use a binary search. */
564 do_linear_search = 0;
566 /* Binary search. This search is guaranteed to end with center
567 pointing at the earliest partial symbol whose name might be
568 correct. At that point *all* partial symbols with an
569 appropriate name will be checked against the correct
573 top = start + length - 1;
577 center = bottom + (top - bottom) / 2;
578 gdb_assert (center < top);
579 if (!do_linear_search
580 && (SYMBOL_LANGUAGE (*center) == language_java))
581 do_linear_search = 1;
582 if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
587 gdb_assert (top == bottom);
589 while (top <= real_top
590 && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
592 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
593 SYMBOL_DOMAIN (*top), domain))
599 /* Can't use a binary search or else we found during the binary search that
600 we should also do a linear search. */
602 if (do_linear_search)
604 for (psym = start; psym < start + length; psym++)
606 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
607 SYMBOL_DOMAIN (*psym), domain)
608 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
616 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
617 not contain any method/function instance information (since this would
618 force reading type information while reading psymtabs). Therefore,
619 if NAME contains overload information, it must be stripped before searching
622 The caller is responsible for freeing the return result. */
625 psymtab_search_name (const char *name)
627 switch (current_language->la_language)
632 if (strchr (name, '('))
634 char *ret = cp_remove_params (name);
646 return xstrdup (name);
649 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
650 Check the global symbols if GLOBAL, the static symbols if not. */
652 static struct partial_symbol *
653 lookup_partial_symbol (struct objfile *objfile,
654 struct partial_symtab *pst, const char *name,
655 int global, domain_enum domain)
657 struct partial_symbol **start, **psym;
658 struct partial_symbol **top, **real_top, **bottom, **center;
659 int length = (global ? pst->n_global_syms : pst->n_static_syms);
660 int do_linear_search = 1;
662 struct cleanup *cleanup;
669 search_name = psymtab_search_name (name);
670 cleanup = make_cleanup (xfree, search_name);
672 objfile->global_psymbols.list + pst->globals_offset :
673 objfile->static_psymbols.list + pst->statics_offset);
675 if (global) /* This means we can use a binary search. */
677 do_linear_search = 0;
679 /* Binary search. This search is guaranteed to end with center
680 pointing at the earliest partial symbol whose name might be
681 correct. At that point *all* partial symbols with an
682 appropriate name will be checked against the correct
686 top = start + length - 1;
690 center = bottom + (top - bottom) / 2;
692 internal_error (__FILE__, __LINE__,
693 _("failed internal consistency check"));
694 if (!do_linear_search
695 && SYMBOL_LANGUAGE (*center) == language_java)
697 do_linear_search = 1;
699 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
709 if (!(top == bottom))
710 internal_error (__FILE__, __LINE__,
711 _("failed internal consistency check"));
713 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
714 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
715 while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
718 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
721 while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
723 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
724 SYMBOL_DOMAIN (*top), domain))
726 do_cleanups (cleanup);
733 /* Can't use a binary search or else we found during the binary search that
734 we should also do a linear search. */
736 if (do_linear_search)
738 for (psym = start; psym < start + length; psym++)
740 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
741 SYMBOL_DOMAIN (*psym), domain)
742 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
744 do_cleanups (cleanup);
750 do_cleanups (cleanup);
754 /* Get the symbol table that corresponds to a partial_symtab.
755 This is fast after the first time you do it. */
757 static struct symtab *
758 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
760 /* If it is a shared psymtab, find an unshared psymtab that includes
761 it. Any such psymtab will do. */
762 while (pst->user != NULL)
765 /* If it's been looked up before, return it. */
769 /* If it has not yet been read in, read it. */
772 struct cleanup *back_to = increment_reading_symtab ();
774 (*pst->read_symtab) (pst, objfile);
775 do_cleanups (back_to);
782 relocate_psymtabs (struct objfile *objfile,
783 struct section_offsets *new_offsets,
784 struct section_offsets *delta)
786 struct partial_symbol **psym;
787 struct partial_symtab *p;
789 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
791 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
792 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
795 for (psym = objfile->global_psymbols.list;
796 psym < objfile->global_psymbols.next;
799 fixup_psymbol_section (*psym, objfile);
800 if (SYMBOL_SECTION (*psym) >= 0)
801 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
802 SYMBOL_SECTION (*psym));
804 for (psym = objfile->static_psymbols.list;
805 psym < objfile->static_psymbols.next;
808 fixup_psymbol_section (*psym, objfile);
809 if (SYMBOL_SECTION (*psym) >= 0)
810 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
811 SYMBOL_SECTION (*psym));
815 static struct symtab *
816 find_last_source_symtab_from_partial (struct objfile *ofp)
818 struct partial_symtab *ps;
819 struct partial_symtab *cs_pst = 0;
821 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
823 const char *name = ps->filename;
824 int len = strlen (name);
826 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
827 || strcmp (name, "<<C++-namespaces>>") == 0)))
835 internal_error (__FILE__, __LINE__,
836 _("select_source_symtab: "
837 "readin pst found and no symtabs."));
840 return psymtab_to_symtab (ofp, cs_pst);
846 forget_cached_source_info_partial (struct objfile *objfile)
848 struct partial_symtab *pst;
850 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
852 if (pst->fullname != NULL)
854 xfree (pst->fullname);
855 pst->fullname = NULL;
861 print_partial_symbols (struct gdbarch *gdbarch,
862 struct partial_symbol **p, int count, char *what,
863 struct ui_file *outfile)
865 fprintf_filtered (outfile, " %s partial symbols:\n", what);
869 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
870 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
872 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
874 fputs_filtered (", ", outfile);
875 switch (SYMBOL_DOMAIN (*p))
878 fputs_filtered ("undefined domain, ", outfile);
881 /* This is the usual thing -- don't print it. */
884 fputs_filtered ("struct domain, ", outfile);
887 fputs_filtered ("label domain, ", outfile);
890 fputs_filtered ("<invalid domain>, ", outfile);
893 switch (SYMBOL_CLASS (*p))
896 fputs_filtered ("undefined", outfile);
899 fputs_filtered ("constant int", outfile);
902 fputs_filtered ("static", outfile);
905 fputs_filtered ("register", outfile);
908 fputs_filtered ("pass by value", outfile);
911 fputs_filtered ("pass by reference", outfile);
913 case LOC_REGPARM_ADDR:
914 fputs_filtered ("register address parameter", outfile);
917 fputs_filtered ("stack parameter", outfile);
920 fputs_filtered ("type", outfile);
923 fputs_filtered ("label", outfile);
926 fputs_filtered ("function", outfile);
928 case LOC_CONST_BYTES:
929 fputs_filtered ("constant bytes", outfile);
932 fputs_filtered ("unresolved", outfile);
934 case LOC_OPTIMIZED_OUT:
935 fputs_filtered ("optimized out", outfile);
938 fputs_filtered ("computed at runtime", outfile);
941 fputs_filtered ("<invalid location>", outfile);
944 fputs_filtered (", ", outfile);
945 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
946 fprintf_filtered (outfile, "\n");
952 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
953 struct ui_file *outfile)
955 struct gdbarch *gdbarch = get_objfile_arch (objfile);
958 if (psymtab->anonymous)
960 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
965 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
968 fprintf_filtered (outfile, "(object ");
969 gdb_print_host_address (psymtab, outfile);
970 fprintf_filtered (outfile, ")\n\n");
971 fprintf_unfiltered (outfile, " Read from object file %s (",
973 gdb_print_host_address (objfile, outfile);
974 fprintf_unfiltered (outfile, ")\n");
978 fprintf_filtered (outfile,
979 " Full symtab was read (at ");
980 gdb_print_host_address (psymtab->symtab, outfile);
981 fprintf_filtered (outfile, " by function at ");
982 gdb_print_host_address (psymtab->read_symtab, outfile);
983 fprintf_filtered (outfile, ")\n");
986 fprintf_filtered (outfile, " Relocate symbols by ");
987 for (i = 0; i < objfile->num_sections; ++i)
990 fprintf_filtered (outfile, ", ");
992 fputs_filtered (paddress (gdbarch,
993 ANOFFSET (psymtab->section_offsets, i)),
996 fprintf_filtered (outfile, "\n");
998 fprintf_filtered (outfile, " Symbols cover text addresses ");
999 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
1000 fprintf_filtered (outfile, "-");
1001 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
1002 fprintf_filtered (outfile, "\n");
1003 fprintf_filtered (outfile, " Address map supported - %s.\n",
1004 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1005 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
1006 psymtab->number_of_dependencies);
1007 for (i = 0; i < psymtab->number_of_dependencies; i++)
1009 fprintf_filtered (outfile, " %d ", i);
1010 gdb_print_host_address (psymtab->dependencies[i], outfile);
1011 fprintf_filtered (outfile, " %s\n",
1012 psymtab->dependencies[i]->filename);
1014 if (psymtab->user != NULL)
1016 fprintf_filtered (outfile, " Shared partial symtab with user ");
1017 gdb_print_host_address (psymtab->user, outfile);
1018 fprintf_filtered (outfile, "\n");
1020 if (psymtab->n_global_syms > 0)
1022 print_partial_symbols (gdbarch,
1023 objfile->global_psymbols.list
1024 + psymtab->globals_offset,
1025 psymtab->n_global_syms, "Global", outfile);
1027 if (psymtab->n_static_syms > 0)
1029 print_partial_symbols (gdbarch,
1030 objfile->static_psymbols.list
1031 + psymtab->statics_offset,
1032 psymtab->n_static_syms, "Static", outfile);
1034 fprintf_filtered (outfile, "\n");
1038 print_psymtab_stats_for_objfile (struct objfile *objfile)
1041 struct partial_symtab *ps;
1044 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1046 if (ps->readin == 0)
1049 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1053 dump_psymtabs_for_objfile (struct objfile *objfile)
1055 struct partial_symtab *psymtab;
1057 if (objfile->psymtabs)
1059 printf_filtered ("Psymtabs:\n");
1060 for (psymtab = objfile->psymtabs;
1062 psymtab = psymtab->next)
1064 printf_filtered ("%s at ",
1066 gdb_print_host_address (psymtab, gdb_stdout);
1067 printf_filtered (", ");
1070 printf_filtered ("\n\n");
1074 /* Look through the partial symtabs for all symbols which begin
1075 by matching FUNC_NAME. Make sure we read that symbol table in. */
1078 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1080 struct partial_symtab *ps;
1082 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1087 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1089 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1091 psymtab_to_symtab (objfile, ps);
1096 expand_partial_symbol_tables (struct objfile *objfile)
1098 struct partial_symtab *psymtab;
1100 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1102 psymtab_to_symtab (objfile, psymtab);
1107 read_psymtabs_with_fullname (struct objfile *objfile, const char *fullname)
1109 struct partial_symtab *p;
1111 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1113 /* Anonymous psymtabs don't have a name of a source file. */
1117 if (filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
1118 psymtab_to_symtab (objfile, p);
1123 map_symbol_filenames_psymtab (struct objfile *objfile,
1124 symbol_filename_ftype *fun, void *data,
1127 struct partial_symtab *ps;
1129 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1131 const char *fullname;
1136 /* We can skip shared psymtabs here, because any file name will be
1137 attached to the unshared psymtab. */
1138 if (ps->user != NULL)
1141 /* Anonymous psymtabs don't have a file name. */
1147 fullname = psymtab_to_fullname (ps);
1150 (*fun) (ps->filename, fullname, data);
1154 /* Finds the fullname that a partial_symtab represents.
1156 If this functions finds the fullname, it will save it in ps->fullname
1157 and it will also return the value.
1159 If this function fails to find the file that this partial_symtab represents,
1160 NULL will be returned and ps->fullname will be set to NULL. */
1163 psymtab_to_fullname (struct partial_symtab *ps)
1165 gdb_assert (!ps->anonymous);
1167 /* Use cached copy if we have it.
1168 We rely on forget_cached_source_info being called appropriately
1169 to handle cases like the file being moved. */
1170 if (ps->fullname == NULL)
1172 int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1179 struct cleanup *back_to;
1181 /* rewrite_source_path would be applied by find_and_open_source, we
1182 should report the pathname where GDB tried to find the file. */
1184 if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1185 fullname = xstrdup (ps->filename);
1187 fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);
1189 back_to = make_cleanup (xfree, fullname);
1190 ps->fullname = rewrite_source_path (fullname);
1191 if (ps->fullname == NULL)
1192 ps->fullname = xstrdup (fullname);
1193 do_cleanups (back_to);
1197 return ps->fullname;
1201 find_symbol_file_from_partial (struct objfile *objfile, const char *name)
1203 struct partial_symtab *pst;
1205 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1207 if (lookup_partial_symbol (objfile, pst, name, 1, VAR_DOMAIN))
1208 return pst->filename;
1213 /* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1214 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1215 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1216 ever returns non-zero, and otherwise returns 0. */
1219 map_block (const char *name, domain_enum namespace, struct objfile *objfile,
1220 struct block *block,
1221 int (*callback) (struct block *, struct symbol *, void *),
1222 void *data, symbol_compare_ftype *match)
1224 struct block_iterator iter;
1227 for (sym = block_iter_match_first (block, name, match, &iter);
1228 sym != NULL; sym = block_iter_match_next (name, match, &iter))
1230 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1231 SYMBOL_DOMAIN (sym), namespace))
1233 if (callback (block, sym, data))
1241 /* Psymtab version of map_matching_symbols. See its definition in
1242 the definition of quick_symbol_functions in symfile.h. */
1245 map_matching_symbols_psymtab (const char *name, domain_enum namespace,
1246 struct objfile *objfile, int global,
1247 int (*callback) (struct block *,
1248 struct symbol *, void *),
1250 symbol_compare_ftype *match,
1251 symbol_compare_ftype *ordered_compare)
1253 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1254 struct partial_symtab *ps;
1256 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1260 || match_partial_symbol (objfile, ps, global, name, namespace, match,
1263 struct symtab *s = psymtab_to_symtab (objfile, ps);
1264 struct block *block;
1266 if (s == NULL || !s->primary)
1268 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1269 if (map_block (name, namespace, objfile, block,
1270 callback, data, match))
1272 if (callback (block, NULL, data))
1278 /* A helper for expand_symtabs_matching_via_partial that handles
1279 searching included psymtabs. This returns 1 if a symbol is found,
1280 and zero otherwise. It also updates the 'searched_flag' on the
1281 various psymtabs that it searches. */
1284 recursively_search_psymtabs (struct partial_symtab *ps,
1285 struct objfile *objfile,
1286 enum search_domain kind,
1287 int (*name_matcher) (const char *, void *),
1290 struct partial_symbol **psym;
1291 struct partial_symbol **bound, **gbound, **sbound;
1293 int result = PST_SEARCHED_AND_NOT_FOUND;
1296 if (ps->searched_flag != PST_NOT_SEARCHED)
1297 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1299 /* Recurse into shared psymtabs first, because they may have already
1300 been searched, and this could save some time. */
1301 for (i = 0; i < ps->number_of_dependencies; ++i)
1305 /* Skip non-shared dependencies, these are handled elsewhere. */
1306 if (ps->dependencies[i]->user == NULL)
1309 r = recursively_search_psymtabs (ps->dependencies[i],
1310 objfile, kind, name_matcher, data);
1313 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1318 gbound = (objfile->global_psymbols.list
1319 + ps->globals_offset + ps->n_global_syms);
1320 sbound = (objfile->static_psymbols.list
1321 + ps->statics_offset + ps->n_static_syms);
1324 /* Go through all of the symbols stored in a partial
1325 symtab in one loop. */
1326 psym = objfile->global_psymbols.list + ps->globals_offset;
1331 if (bound == gbound && ps->n_static_syms != 0)
1333 psym = objfile->static_psymbols.list + ps->statics_offset;
1344 if ((kind == ALL_DOMAIN
1345 || (kind == VARIABLES_DOMAIN
1346 && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
1347 && SYMBOL_CLASS (*psym) != LOC_BLOCK)
1348 || (kind == FUNCTIONS_DOMAIN
1349 && SYMBOL_CLASS (*psym) == LOC_BLOCK)
1350 || (kind == TYPES_DOMAIN
1351 && SYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1352 && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1354 /* Found a match, so notify our caller. */
1355 result = PST_SEARCHED_AND_FOUND;
1362 ps->searched_flag = result;
1363 return result == PST_SEARCHED_AND_FOUND;
1367 expand_symtabs_matching_via_partial
1368 (struct objfile *objfile,
1369 int (*file_matcher) (const char *, void *, int basenames),
1370 int (*name_matcher) (const char *, void *),
1371 enum search_domain kind,
1374 struct partial_symtab *ps;
1376 /* Clear the search flags. */
1377 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1379 ps->searched_flag = PST_NOT_SEARCHED;
1382 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1387 /* We skip shared psymtabs because file-matching doesn't apply
1388 to them; but we search them later in the loop. */
1389 if (ps->user != NULL)
1397 /* Before we invoke realpath, which can get expensive when many
1398 files are involved, do a quick comparison of the basenames. */
1399 if (!(*file_matcher) (ps->filename, data, 0)
1400 && (basenames_may_differ
1401 || (*file_matcher) (lbasename (ps->filename), data, 1))
1402 && !(*file_matcher) (psymtab_to_fullname (ps), data, 0))
1406 if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
1407 psymtab_to_symtab (objfile, ps);
1412 objfile_has_psyms (struct objfile *objfile)
1414 return objfile->psymtabs != NULL;
1417 const struct quick_symbol_functions psym_functions =
1420 find_last_source_symtab_from_partial,
1421 forget_cached_source_info_partial,
1422 partial_map_symtabs_matching_filename,
1423 lookup_symbol_aux_psymtabs,
1424 print_psymtab_stats_for_objfile,
1425 dump_psymtabs_for_objfile,
1427 read_symtabs_for_function,
1428 expand_partial_symbol_tables,
1429 read_psymtabs_with_fullname,
1430 find_symbol_file_from_partial,
1431 map_matching_symbols_psymtab,
1432 expand_symtabs_matching_via_partial,
1433 find_pc_sect_symtab_from_partial,
1434 map_symbol_filenames_psymtab
1439 /* This compares two partial symbols by names, using strcmp_iw_ordered
1440 for the comparison. */
1443 compare_psymbols (const void *s1p, const void *s2p)
1445 struct partial_symbol *const *s1 = s1p;
1446 struct partial_symbol *const *s2 = s2p;
1448 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1449 SYMBOL_SEARCH_NAME (*s2));
1453 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1455 /* Sort the global list; don't sort the static list. */
1457 qsort (objfile->global_psymbols.list + pst->globals_offset,
1458 pst->n_global_syms, sizeof (struct partial_symbol *),
1462 /* Allocate and partially fill a partial symtab. It will be
1463 completely filled at the end of the symbol list.
1465 FILENAME is the name of the symbol-file we are reading from. */
1467 struct partial_symtab *
1468 start_psymtab_common (struct objfile *objfile,
1469 struct section_offsets *section_offsets,
1470 const char *filename,
1471 CORE_ADDR textlow, struct partial_symbol **global_syms,
1472 struct partial_symbol **static_syms)
1474 struct partial_symtab *psymtab;
1476 psymtab = allocate_psymtab (filename, objfile);
1477 psymtab->section_offsets = section_offsets;
1478 psymtab->textlow = textlow;
1479 psymtab->texthigh = psymtab->textlow; /* default */
1480 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1481 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1485 /* Calculate a hash code for the given partial symbol. The hash is
1486 calculated using the symbol's value, language, domain, class
1487 and name. These are the values which are set by
1488 add_psymbol_to_bcache. */
1490 static unsigned long
1491 psymbol_hash (const void *addr, int length)
1493 unsigned long h = 0;
1494 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1495 unsigned int lang = psymbol->ginfo.language;
1496 unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1497 unsigned int class = PSYMBOL_CLASS (psymbol);
1499 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1500 h = hash_continue (&lang, sizeof (unsigned int), h);
1501 h = hash_continue (&domain, sizeof (unsigned int), h);
1502 h = hash_continue (&class, sizeof (unsigned int), h);
1503 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1508 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1509 For the comparison this function uses a symbols value,
1510 language, domain, class and name. */
1513 psymbol_compare (const void *addr1, const void *addr2, int length)
1515 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1516 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1518 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1519 sizeof (sym1->ginfo.value)) == 0
1520 && sym1->ginfo.language == sym2->ginfo.language
1521 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1522 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1523 && sym1->ginfo.name == sym2->ginfo.name);
1526 /* Initialize a partial symbol bcache. */
1528 struct psymbol_bcache *
1529 psymbol_bcache_init (void)
1531 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1532 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1536 /* Free a partial symbol bcache. */
1538 psymbol_bcache_free (struct psymbol_bcache *bcache)
1543 bcache_xfree (bcache->bcache);
1547 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1550 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1552 return bcache->bcache;
1555 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1556 symbol before, add a copy to BCACHE. In either case, return a pointer
1557 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1558 1 in case of new entry or 0 if returning an old entry. */
1560 static const struct partial_symbol *
1561 psymbol_bcache_full (struct partial_symbol *sym,
1562 struct psymbol_bcache *bcache,
1565 return bcache_full (sym,
1566 sizeof (struct partial_symbol),
1571 /* Helper function, initialises partial symbol structure and stashes
1572 it into objfile's bcache. Note that our caching mechanism will
1573 use all fields of struct partial_symbol to determine hash value of the
1574 structure. In other words, having two symbols with the same name but
1575 different domain (or address) is possible and correct. */
1577 static const struct partial_symbol *
1578 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1580 enum address_class class,
1581 long val, /* Value as a long */
1582 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1583 enum language language, struct objfile *objfile,
1586 struct partial_symbol psymbol;
1588 /* We must ensure that the entire 'value' field has been zeroed
1589 before assigning to it, because an assignment may not write the
1591 memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
1593 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1596 SYMBOL_VALUE (&psymbol) = val;
1600 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1602 SYMBOL_SECTION (&psymbol) = 0;
1603 SYMBOL_OBJ_SECTION (&psymbol) = NULL;
1604 SYMBOL_SET_LANGUAGE (&psymbol, language);
1605 PSYMBOL_DOMAIN (&psymbol) = domain;
1606 PSYMBOL_CLASS (&psymbol) = class;
1608 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1610 /* Stash the partial symbol away in the cache. */
1611 return psymbol_bcache_full (&psymbol,
1612 objfile->psymbol_cache,
1616 /* Increase the space allocated for LISTP, which is probably
1617 global_psymbols or static_psymbols. This space will eventually
1618 be freed in free_objfile(). */
1621 extend_psymbol_list (struct psymbol_allocation_list *listp,
1622 struct objfile *objfile)
1626 if (listp->size == 0)
1629 listp->list = (struct partial_symbol **)
1630 xmalloc (new_size * sizeof (struct partial_symbol *));
1634 new_size = listp->size * 2;
1635 listp->list = (struct partial_symbol **)
1636 xrealloc ((char *) listp->list,
1637 new_size * sizeof (struct partial_symbol *));
1639 /* Next assumes we only went one over. Should be good if
1640 program works correctly. */
1641 listp->next = listp->list + listp->size;
1642 listp->size = new_size;
1645 /* Helper function, adds partial symbol to the given partial symbol
1649 append_psymbol_to_list (struct psymbol_allocation_list *list,
1650 const struct partial_symbol *psym,
1651 struct objfile *objfile)
1653 if (list->next >= list->list + list->size)
1654 extend_psymbol_list (list, objfile);
1655 *list->next++ = (struct partial_symbol *) psym;
1656 OBJSTAT (objfile, n_psyms++);
1659 /* Add a symbol with a long value to a psymtab.
1660 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1661 Return the partial symbol that has been added. */
1664 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1666 enum address_class class,
1667 struct psymbol_allocation_list *list,
1668 long val, /* Value as a long */
1669 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1670 enum language language, struct objfile *objfile)
1672 const struct partial_symbol *psym;
1676 /* Stash the partial symbol away in the cache. */
1677 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
1678 val, coreaddr, language, objfile, &added);
1680 /* Do not duplicate global partial symbols. */
1681 if (list == &objfile->global_psymbols
1685 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1686 append_psymbol_to_list (list, psym, objfile);
1689 /* Initialize storage for partial symbols. */
1692 init_psymbol_list (struct objfile *objfile, int total_symbols)
1694 /* Free any previously allocated psymbol lists. */
1696 if (objfile->global_psymbols.list)
1698 xfree (objfile->global_psymbols.list);
1700 if (objfile->static_psymbols.list)
1702 xfree (objfile->static_psymbols.list);
1705 /* Current best guess is that approximately a twentieth
1706 of the total symbols (in a debugging file) are global or static
1707 oriented symbols, then multiply that by slop factor of two. */
1709 objfile->global_psymbols.size = total_symbols / 10;
1710 objfile->static_psymbols.size = total_symbols / 10;
1712 if (objfile->global_psymbols.size > 0)
1714 objfile->global_psymbols.next =
1715 objfile->global_psymbols.list = (struct partial_symbol **)
1716 xmalloc ((objfile->global_psymbols.size
1717 * sizeof (struct partial_symbol *)));
1719 if (objfile->static_psymbols.size > 0)
1721 objfile->static_psymbols.next =
1722 objfile->static_psymbols.list = (struct partial_symbol **)
1723 xmalloc ((objfile->static_psymbols.size
1724 * sizeof (struct partial_symbol *)));
1728 struct partial_symtab *
1729 allocate_psymtab (const char *filename, struct objfile *objfile)
1731 struct partial_symtab *psymtab;
1733 if (objfile->free_psymtabs)
1735 psymtab = objfile->free_psymtabs;
1736 objfile->free_psymtabs = psymtab->next;
1739 psymtab = (struct partial_symtab *)
1740 obstack_alloc (&objfile->objfile_obstack,
1741 sizeof (struct partial_symtab));
1743 memset (psymtab, 0, sizeof (struct partial_symtab));
1744 psymtab->filename = obstack_copy0 (&objfile->objfile_obstack,
1745 filename, strlen (filename));
1746 psymtab->symtab = NULL;
1748 /* Prepend it to the psymtab list for the objfile it belongs to.
1749 Psymtabs are searched in most recent inserted -> least recent
1752 psymtab->next = objfile->psymtabs;
1753 objfile->psymtabs = psymtab;
1755 if (symtab_create_debug)
1757 /* Be a bit clever with debugging messages, and don't print objfile
1758 every time, only when it changes. */
1759 static char *last_objfile_name = NULL;
1761 if (last_objfile_name == NULL
1762 || strcmp (last_objfile_name, objfile->name) != 0)
1764 xfree (last_objfile_name);
1765 last_objfile_name = xstrdup (objfile->name);
1766 fprintf_unfiltered (gdb_stdlog,
1767 "Creating one or more psymtabs for objfile %s ...\n",
1770 fprintf_unfiltered (gdb_stdlog,
1771 "Created psymtab %s for module %s.\n",
1772 host_address_to_string (psymtab), filename);
1779 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1781 struct partial_symtab **prev_pst;
1784 Empty psymtabs happen as a result of header files which don't
1785 have any symbols in them. There can be a lot of them. But this
1786 check is wrong, in that a psymtab with N_SLINE entries but
1787 nothing else is not empty, but we don't realize that. Fixing
1788 that without slowing things down might be tricky. */
1790 /* First, snip it out of the psymtab chain. */
1792 prev_pst = &(objfile->psymtabs);
1793 while ((*prev_pst) != pst)
1794 prev_pst = &((*prev_pst)->next);
1795 (*prev_pst) = pst->next;
1797 /* Next, put it on a free list for recycling. */
1799 pst->next = objfile->free_psymtabs;
1800 objfile->free_psymtabs = pst;
1803 /* An object of this type is passed to discard_psymtabs_upto. */
1805 struct psymtab_state
1807 /* The objfile where psymtabs are discarded. */
1809 struct objfile *objfile;
1811 /* The first psymtab to save. */
1813 struct partial_symtab *save;
1816 /* A cleanup function used by make_cleanup_discard_psymtabs. */
1819 discard_psymtabs_upto (void *arg)
1821 struct psymtab_state *state = arg;
1823 while (state->objfile->psymtabs != state->save)
1824 discard_psymtab (state->objfile, state->objfile->psymtabs);
1827 /* Return a new cleanup that discards all psymtabs created in OBJFILE
1828 after this function is called. */
1831 make_cleanup_discard_psymtabs (struct objfile *objfile)
1833 struct psymtab_state *state = XNEW (struct psymtab_state);
1835 state->objfile = objfile;
1836 state->save = objfile->psymtabs;
1838 return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
1844 maintenance_print_psymbols (char *args, int from_tty)
1847 struct ui_file *outfile;
1848 struct cleanup *cleanups;
1849 char *symname = NULL;
1850 char *filename = DEV_TTY;
1851 struct objfile *objfile;
1852 struct partial_symtab *ps;
1859 print-psymbols takes an output file name and optional symbol file name"));
1861 argv = gdb_buildargv (args);
1862 cleanups = make_cleanup_freeargv (argv);
1864 if (argv[0] != NULL)
1867 /* If a second arg is supplied, it is a source file name to match on. */
1868 if (argv[1] != NULL)
1874 filename = tilde_expand (filename);
1875 make_cleanup (xfree, filename);
1877 outfile = gdb_fopen (filename, FOPEN_WT);
1879 perror_with_name (filename);
1880 make_cleanup_ui_file_delete (outfile);
1882 ALL_PSYMTABS (objfile, ps)
1885 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1886 dump_psymtab (objfile, ps, outfile);
1888 do_cleanups (cleanups);
1891 /* List all the partial symbol tables whose names match REGEXP (optional). */
1893 maintenance_info_psymtabs (char *regexp, int from_tty)
1895 struct program_space *pspace;
1896 struct objfile *objfile;
1901 ALL_PSPACES (pspace)
1902 ALL_PSPACE_OBJFILES (pspace, objfile)
1904 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1905 struct partial_symtab *psymtab;
1907 /* We don't want to print anything for this objfile until we
1908 actually find a symtab whose name matches. */
1909 int printed_objfile_start = 0;
1911 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1916 || re_exec (psymtab->filename))
1918 if (! printed_objfile_start)
1920 printf_filtered ("{ objfile %s ", objfile->name);
1922 printf_filtered ("((struct objfile *) %s)\n",
1923 host_address_to_string (objfile));
1924 printed_objfile_start = 1;
1927 printf_filtered (" { psymtab %s ", psymtab->filename);
1929 printf_filtered ("((struct partial_symtab *) %s)\n",
1930 host_address_to_string (psymtab));
1932 printf_filtered (" readin %s\n",
1933 psymtab->readin ? "yes" : "no");
1934 printf_filtered (" fullname %s\n",
1936 ? psymtab->fullname : "(null)");
1937 printf_filtered (" text addresses ");
1938 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1940 printf_filtered (" -- ");
1941 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1943 printf_filtered ("\n");
1944 printf_filtered (" psymtabs_addrmap_supported %s\n",
1945 (psymtab->psymtabs_addrmap_supported
1947 printf_filtered (" globals ");
1948 if (psymtab->n_global_syms)
1950 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1951 host_address_to_string (objfile->global_psymbols.list
1952 + psymtab->globals_offset),
1953 psymtab->n_global_syms);
1956 printf_filtered ("(none)\n");
1957 printf_filtered (" statics ");
1958 if (psymtab->n_static_syms)
1960 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1961 host_address_to_string (objfile->static_psymbols.list
1962 + psymtab->statics_offset),
1963 psymtab->n_static_syms);
1966 printf_filtered ("(none)\n");
1967 printf_filtered (" dependencies ");
1968 if (psymtab->number_of_dependencies)
1972 printf_filtered ("{\n");
1973 for (i = 0; i < psymtab->number_of_dependencies; i++)
1975 struct partial_symtab *dep = psymtab->dependencies[i];
1977 /* Note the string concatenation there --- no comma. */
1978 printf_filtered (" psymtab %s "
1979 "((struct partial_symtab *) %s)\n",
1981 host_address_to_string (dep));
1983 printf_filtered (" }\n");
1986 printf_filtered ("(none)\n");
1987 printf_filtered (" }\n");
1991 if (printed_objfile_start)
1992 printf_filtered ("}\n");
1996 /* Check consistency of psymtabs and symtabs. */
1999 maintenance_check_symtabs (char *ignore, int from_tty)
2002 struct partial_symbol **psym;
2003 struct symtab *s = NULL;
2004 struct partial_symtab *ps;
2005 struct blockvector *bv;
2006 struct objfile *objfile;
2010 ALL_PSYMTABS (objfile, ps)
2012 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2014 s = psymtab_to_symtab (objfile, ps);
2017 bv = BLOCKVECTOR (s);
2018 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2019 psym = objfile->static_psymbols.list + ps->statics_offset;
2020 length = ps->n_static_syms;
2023 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2024 SYMBOL_DOMAIN (*psym));
2027 printf_filtered ("Static symbol `");
2028 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2029 printf_filtered ("' only found in ");
2030 puts_filtered (ps->filename);
2031 printf_filtered (" psymtab\n");
2035 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2036 psym = objfile->global_psymbols.list + ps->globals_offset;
2037 length = ps->n_global_syms;
2040 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2041 SYMBOL_DOMAIN (*psym));
2044 printf_filtered ("Global symbol `");
2045 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2046 printf_filtered ("' only found in ");
2047 puts_filtered (ps->filename);
2048 printf_filtered (" psymtab\n");
2052 if (ps->texthigh < ps->textlow)
2054 printf_filtered ("Psymtab ");
2055 puts_filtered (ps->filename);
2056 printf_filtered (" covers bad range ");
2057 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2058 printf_filtered (" - ");
2059 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2060 printf_filtered ("\n");
2063 if (ps->texthigh == 0)
2065 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
2067 printf_filtered ("Psymtab ");
2068 puts_filtered (ps->filename);
2069 printf_filtered (" covers ");
2070 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2071 printf_filtered (" - ");
2072 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2073 printf_filtered (" but symtab covers only ");
2074 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2075 printf_filtered (" - ");
2076 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2077 printf_filtered ("\n");
2085 expand_partial_symbol_names (int (*fun) (const char *, void *),
2088 struct objfile *objfile;
2090 ALL_OBJFILES (objfile)
2093 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
2099 map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
2102 struct objfile *objfile;
2104 ALL_OBJFILES (objfile)
2107 objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
2112 extern initialize_file_ftype _initialize_psymtab;
2115 _initialize_psymtab (void)
2117 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2118 Print dump of current partial symbol definitions.\n\
2119 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2120 If a SOURCE file is specified, dump only that file's partial symbols."),
2121 &maintenanceprintlist);
2123 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2124 List the partial symbol tables for all object files.\n\
2125 This does not include information about individual partial symbols,\n\
2126 just the symbol table structures themselves."),
2127 &maintenanceinfolist);
2129 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
2130 _("Check consistency of psymtabs and symtabs."),