1 /* Partial symbol tables.
3 Copyright (C) 2009-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "filenames.h"
31 #include "readline/tilde.h"
32 #include "gdb_regex.h"
33 #include "dictionary.h"
35 #include "cp-support.h"
40 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
41 struct partial_symtab
*,
42 const lookup_name_info
&,
46 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
48 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
49 struct partial_symtab
*,
51 struct obj_section
*);
53 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
54 struct partial_symtab
*pst
);
56 psymtab_storage::~psymtab_storage ()
58 partial_symtab
*iter
= psymtabs
;
59 while (iter
!= nullptr)
61 partial_symtab
*next
= iter
->next
;
70 psymtab_storage::install_psymtab (partial_symtab
*pst
)
78 /* Ensure that the partial symbols for OBJFILE have been loaded. This
79 will print a message when symbols are loaded. This function
80 returns a range adapter suitable for iterating over the psymtabs of
83 psymtab_storage::partial_symtab_range
84 psymbol_functions::require_partial_symbols (struct objfile
*objfile
)
86 objfile
->require_partial_symbols (true);
87 return m_partial_symtabs
->range ();
90 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
91 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
93 static struct partial_symtab
*
94 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
95 CORE_ADDR pc
, struct obj_section
*section
,
96 struct partial_symtab
*pst
,
97 struct bound_minimal_symbol msymbol
)
99 struct partial_symtab
*tpst
;
100 struct partial_symtab
*best_pst
= pst
;
101 CORE_ADDR best_addr
= pst
->text_low (objfile
);
103 gdb_assert (!pst
->psymtabs_addrmap_supported
);
105 /* An objfile that has its functions reordered might have
106 many partial symbol tables containing the PC, but
107 we want the partial symbol table that contains the
108 function containing the PC. */
109 if (!(objfile
->flags
& OBJF_REORDERED
)
110 && section
== NULL
) /* Can't validate section this way. */
113 if (msymbol
.minsym
== NULL
)
116 /* The code range of partial symtabs sometimes overlap, so, in
117 the loop below, we need to check all partial symtabs and
118 find the one that fits better for the given PC address. We
119 select the partial symtab that contains a symbol whose
120 address is closest to the PC address. By closest we mean
121 that find_pc_sect_symbol returns the symbol with address
122 that is closest and still less than the given PC. */
123 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
125 if (pc
>= tpst
->text_low (objfile
) && pc
< tpst
->text_high (objfile
))
127 struct partial_symbol
*p
;
130 /* NOTE: This assumes that every psymbol has a
131 corresponding msymbol, which is not necessarily
132 true; the debug info might be much richer than the
133 object's symbol table. */
134 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
136 && (p
->address (objfile
) == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
139 /* Also accept the textlow value of a psymtab as a
140 "symbol", to provide some support for partial
141 symbol tables with line information but no debug
142 symbols (e.g. those produced by an assembler). */
144 this_addr
= p
->address (objfile
);
146 this_addr
= tpst
->text_low (objfile
);
148 /* Check whether it is closer than our current
149 BEST_ADDR. Since this symbol address is
150 necessarily lower or equal to PC, the symbol closer
151 to PC is the symbol which address is the highest.
152 This way we return the psymtab which contains such
153 best match symbol. This can help in cases where the
154 symbol information/debuginfo is not complete, like
155 for instance on IRIX6 with gcc, where no debug info
156 is emitted for statics. (See also the nodebug.exp
158 if (this_addr
> best_addr
)
160 best_addr
= this_addr
;
168 /* See psympriv.h. */
170 struct partial_symtab
*
171 psymbol_functions::find_pc_sect_psymtab (struct objfile
*objfile
,
173 struct obj_section
*section
,
174 struct bound_minimal_symbol msymbol
)
176 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better
177 granularity than the later used TEXTLOW/TEXTHIGH one. However, we need
178 to take care as the PSYMTABS_ADDRMAP can hold things other than partial
179 symtabs in some cases.
181 This function should only be called for objfiles that are using partial
182 symtabs, not for objfiles that are using indexes (.gdb_index or
183 .debug_names), however 'maintenance print psymbols' calls this function
184 directly for all objfiles. If we assume that PSYMTABS_ADDRMAP contains
185 partial symtabs then we will end up returning a pointer to an object
186 that is not a partial_symtab, which doesn't end well. */
188 if (m_partial_symtabs
->psymtabs
!= NULL
189 && m_partial_symtabs
->psymtabs_addrmap
!= NULL
)
191 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
193 struct partial_symtab
*pst
194 = ((struct partial_symtab
*)
195 addrmap_find (m_partial_symtabs
->psymtabs_addrmap
,
199 /* FIXME: addrmaps currently do not handle overlayed sections,
200 so fall back to the non-addrmap case if we're debugging
201 overlays and the addrmap returned the wrong section. */
202 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
204 struct partial_symbol
*p
;
206 /* NOTE: This assumes that every psymbol has a
207 corresponding msymbol, which is not necessarily
208 true; the debug info might be much richer than the
209 object's symbol table. */
210 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
212 || (p
->address (objfile
)
213 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
217 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
218 PSYMTABS_ADDRMAP we used has already the best 1-byte
219 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
220 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
229 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
230 which still have no corresponding full SYMTABs read. But it is not
231 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
234 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
235 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
236 debug info type in single OBJFILE. */
238 for (partial_symtab
*pst
: require_partial_symbols (objfile
))
239 if (!pst
->psymtabs_addrmap_supported
240 && pc
>= pst
->text_low (objfile
) && pc
< pst
->text_high (objfile
))
242 struct partial_symtab
*best_pst
;
244 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
246 if (best_pst
!= NULL
)
253 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
254 the definition of quick_symbol_functions in symfile.h. */
256 struct compunit_symtab
*
257 psymbol_functions::find_pc_sect_compunit_symtab
258 (struct objfile
*objfile
,
259 struct bound_minimal_symbol msymbol
,
261 struct obj_section
*section
,
264 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
,
269 if (warn_if_readin
&& ps
->readin_p (objfile
))
270 /* Might want to error() here (in case symtab is corrupt and
271 will cause a core dump), but maybe we can successfully
272 continue, so let's not. */
274 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
275 paddress (objfile
->arch (), pc
));
276 psymtab_to_symtab (objfile
, ps
);
277 return ps
->get_compunit_symtab (objfile
);
282 /* Find which partial symbol within a psymtab matches PC and SECTION.
283 Return NULL if none. */
285 static struct partial_symbol
*
286 find_pc_sect_psymbol (struct objfile
*objfile
,
287 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
288 struct obj_section
*section
)
290 struct partial_symbol
*best
= NULL
;
292 const CORE_ADDR textlow
= psymtab
->text_low (objfile
);
294 gdb_assert (psymtab
!= NULL
);
296 /* Cope with programs that start at address 0. */
297 best_pc
= (textlow
!= 0) ? textlow
- 1 : 0;
299 /* Search the global symbols as well as the static symbols, so that
300 find_pc_partial_function doesn't use a minimal symbol and thus
301 cache a bad endaddr. */
302 for (partial_symbol
*p
: psymtab
->global_psymbols
)
304 if (p
->domain
== VAR_DOMAIN
305 && p
->aclass
== LOC_BLOCK
306 && pc
>= p
->address (objfile
)
307 && (p
->address (objfile
) > best_pc
308 || (psymtab
->text_low (objfile
) == 0
309 && best_pc
== 0 && p
->address (objfile
) == 0)))
311 if (section
!= NULL
) /* Match on a specific section. */
313 if (!matching_obj_sections (p
->obj_section (objfile
),
317 best_pc
= p
->address (objfile
);
322 for (partial_symbol
*p
: psymtab
->static_psymbols
)
324 if (p
->domain
== VAR_DOMAIN
325 && p
->aclass
== LOC_BLOCK
326 && pc
>= p
->address (objfile
)
327 && (p
->address (objfile
) > best_pc
328 || (psymtab
->text_low (objfile
) == 0
329 && best_pc
== 0 && p
->address (objfile
) == 0)))
331 if (section
!= NULL
) /* Match on a specific section. */
333 if (!matching_obj_sections (p
->obj_section (objfile
),
337 best_pc
= p
->address (objfile
);
345 /* Psymtab version of lookup_global_symbol_language. See its definition in
346 the definition of quick_symbol_functions in symfile.h. */
349 psymbol_functions::lookup_global_symbol_language (struct objfile
*objfile
,
352 bool *symbol_found_p
)
354 *symbol_found_p
= false;
355 if (objfile
->sf
== NULL
)
356 return language_unknown
;
358 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
360 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
362 struct partial_symbol
*psym
;
363 if (ps
->readin_p (objfile
))
366 psym
= lookup_partial_symbol (objfile
, ps
, lookup_name
, 1, domain
);
369 *symbol_found_p
= true;
370 return psym
->ginfo
.language ();
374 return language_unknown
;
377 /* Returns true if PSYM matches LOOKUP_NAME. */
380 psymbol_name_matches (partial_symbol
*psym
,
381 const lookup_name_info
&lookup_name
)
383 const language_defn
*lang
= language_def (psym
->ginfo
.language ());
384 symbol_name_matcher_ftype
*name_match
385 = lang
->get_symbol_name_matcher (lookup_name
);
386 return name_match (psym
->ginfo
.search_name (), lookup_name
, NULL
);
389 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
390 the global block of PST if GLOBAL, and otherwise the static block.
391 MATCH is the comparison operation that returns true iff MATCH (s,
392 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
393 non-null, the symbols in the block are assumed to be ordered
394 according to it (allowing binary search). It must be compatible
395 with MATCH. Returns the symbol, if found, and otherwise NULL. */
397 static struct partial_symbol
*
398 match_partial_symbol (struct objfile
*objfile
,
399 struct partial_symtab
*pst
, int global
,
400 const lookup_name_info
&name
, domain_enum domain
,
401 symbol_compare_ftype
*ordered_compare
)
403 struct partial_symbol
**start
, **psym
;
404 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
406 ? pst
->global_psymbols
.size ()
407 : pst
->static_psymbols
.size ());
408 int do_linear_search
= 1;
414 &pst
->global_psymbols
[0] :
415 &pst
->static_psymbols
[0]);
417 if (global
&& ordered_compare
) /* Can use a binary search. */
419 do_linear_search
= 0;
421 /* Binary search. This search is guaranteed to end with center
422 pointing at the earliest partial symbol whose name might be
423 correct. At that point *all* partial symbols with an
424 appropriate name will be checked against the correct
428 top
= start
+ length
- 1;
432 center
= bottom
+ (top
- bottom
) / 2;
433 gdb_assert (center
< top
);
435 enum language lang
= (*center
)->ginfo
.language ();
436 const char *lang_ln
= name
.language_lookup_name (lang
);
438 if (ordered_compare ((*center
)->ginfo
.search_name (),
444 gdb_assert (top
== bottom
);
446 while (top
<= real_top
447 && psymbol_name_matches (*top
, name
))
449 if (symbol_matches_domain ((*top
)->ginfo
.language (),
450 (*top
)->domain
, domain
))
456 /* Can't use a binary search or else we found during the binary search that
457 we should also do a linear search. */
459 if (do_linear_search
)
461 for (psym
= start
; psym
< start
+ length
; psym
++)
463 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
464 (*psym
)->domain
, domain
)
465 && psymbol_name_matches (*psym
, name
))
473 /* Look, in partial_symtab PST, for symbol whose natural name is
474 LOOKUP_NAME. Check the global symbols if GLOBAL, the static
477 static struct partial_symbol
*
478 lookup_partial_symbol (struct objfile
*objfile
,
479 struct partial_symtab
*pst
,
480 const lookup_name_info
&lookup_name
,
481 int global
, domain_enum domain
)
483 struct partial_symbol
**start
, **psym
;
484 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
486 ? pst
->global_psymbols
.size ()
487 : pst
->static_psymbols
.size ());
488 int do_linear_search
= 1;
494 &pst
->global_psymbols
[0] :
495 &pst
->static_psymbols
[0]);
497 if (global
) /* This means we can use a binary search. */
499 do_linear_search
= 0;
501 /* Binary search. This search is guaranteed to end with center
502 pointing at the earliest partial symbol whose name might be
503 correct. At that point *all* partial symbols with an
504 appropriate name will be checked against the correct
508 top
= start
+ length
- 1;
512 center
= bottom
+ (top
- bottom
) / 2;
514 gdb_assert (center
< top
);
516 if (strcmp_iw_ordered ((*center
)->ginfo
.search_name (),
517 lookup_name
.c_str ()) >= 0)
527 gdb_assert (top
== bottom
);
529 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
530 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
531 while (top
>= start
&& symbol_matches_search_name (&(*top
)->ginfo
,
535 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
538 while (top
<= real_top
&& symbol_matches_search_name (&(*top
)->ginfo
,
541 if (symbol_matches_domain ((*top
)->ginfo
.language (),
542 (*top
)->domain
, domain
))
548 /* Can't use a binary search or else we found during the binary search that
549 we should also do a linear search. */
551 if (do_linear_search
)
553 for (psym
= start
; psym
< start
+ length
; psym
++)
555 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
556 (*psym
)->domain
, domain
)
557 && symbol_matches_search_name (&(*psym
)->ginfo
, lookup_name
))
565 /* Get the symbol table that corresponds to a partial_symtab.
566 This is fast after the first time you do it.
567 The result will be NULL if the primary symtab has no symbols,
568 which can happen. Otherwise the result is the primary symtab
569 that contains PST. */
571 static struct compunit_symtab
*
572 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
574 /* If it is a shared psymtab, find an unshared psymtab that includes
575 it. Any such psymtab will do. */
576 while (pst
->user
!= NULL
)
579 /* If it's been looked up before, return it. */
580 if (pst
->get_compunit_symtab (objfile
))
581 return pst
->get_compunit_symtab (objfile
);
583 /* If it has not yet been read in, read it. */
584 if (!pst
->readin_p (objfile
))
586 scoped_restore decrementer
= increment_reading_symtab ();
590 printf_filtered (_("Reading in symbols for %s...\n"),
592 gdb_flush (gdb_stdout
);
595 pst
->read_symtab (objfile
);
598 return pst
->get_compunit_symtab (objfile
);
601 /* Psymtab version of find_last_source_symtab. See its definition in
602 the definition of quick_symbol_functions in symfile.h. */
605 psymbol_functions::find_last_source_symtab (struct objfile
*ofp
)
607 struct partial_symtab
*cs_pst
= NULL
;
609 for (partial_symtab
*ps
: require_partial_symbols (ofp
))
611 const char *name
= ps
->filename
;
612 int len
= strlen (name
);
614 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
615 || strcmp (name
, "<<C++-namespaces>>") == 0)))
621 if (cs_pst
->readin_p (ofp
))
623 internal_error (__FILE__
, __LINE__
,
624 _("select_source_symtab: "
625 "readin pst found and no symtabs."));
629 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
633 return compunit_primary_filetab (cust
);
639 /* Psymtab version of forget_cached_source_info. See its definition in
640 the definition of quick_symbol_functions in symfile.h. */
643 psymbol_functions::forget_cached_source_info (struct objfile
*objfile
)
645 for (partial_symtab
*pst
: require_partial_symbols (objfile
))
647 if (pst
->fullname
!= NULL
)
649 xfree (pst
->fullname
);
650 pst
->fullname
= NULL
;
656 print_partial_symbols (struct gdbarch
*gdbarch
, struct objfile
*objfile
,
657 const std::vector
<partial_symbol
*> &symbols
,
658 const char *what
, struct ui_file
*outfile
)
660 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
661 for (partial_symbol
*p
: symbols
)
664 fprintf_filtered (outfile
, " `%s'", p
->ginfo
.linkage_name ());
665 if (p
->ginfo
.demangled_name () != NULL
)
667 fprintf_filtered (outfile
, " `%s'",
668 p
->ginfo
.demangled_name ());
670 fputs_filtered (", ", outfile
);
674 fputs_filtered ("undefined domain, ", outfile
);
677 /* This is the usual thing -- don't print it. */
680 fputs_filtered ("struct domain, ", outfile
);
683 fputs_filtered ("module domain, ", outfile
);
686 fputs_filtered ("label domain, ", outfile
);
688 case COMMON_BLOCK_DOMAIN
:
689 fputs_filtered ("common block domain, ", outfile
);
692 fputs_filtered ("<invalid domain>, ", outfile
);
698 fputs_filtered ("undefined", outfile
);
701 fputs_filtered ("constant int", outfile
);
704 fputs_filtered ("static", outfile
);
707 fputs_filtered ("register", outfile
);
710 fputs_filtered ("pass by value", outfile
);
713 fputs_filtered ("pass by reference", outfile
);
715 case LOC_REGPARM_ADDR
:
716 fputs_filtered ("register address parameter", outfile
);
719 fputs_filtered ("stack parameter", outfile
);
722 fputs_filtered ("type", outfile
);
725 fputs_filtered ("label", outfile
);
728 fputs_filtered ("function", outfile
);
730 case LOC_CONST_BYTES
:
731 fputs_filtered ("constant bytes", outfile
);
734 fputs_filtered ("unresolved", outfile
);
736 case LOC_OPTIMIZED_OUT
:
737 fputs_filtered ("optimized out", outfile
);
740 fputs_filtered ("computed at runtime", outfile
);
743 fputs_filtered ("<invalid location>", outfile
);
746 fputs_filtered (", ", outfile
);
747 fputs_filtered (paddress (gdbarch
, p
->unrelocated_address ()), outfile
);
748 fprintf_filtered (outfile
, "\n");
753 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
754 struct ui_file
*outfile
)
756 struct gdbarch
*gdbarch
= objfile
->arch ();
759 if (psymtab
->anonymous
)
761 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
766 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
769 fprintf_filtered (outfile
, "(object ");
770 gdb_print_host_address (psymtab
, outfile
);
771 fprintf_filtered (outfile
, ")\n\n");
772 fprintf_filtered (outfile
, " Read from object file %s (",
773 objfile_name (objfile
));
774 gdb_print_host_address (objfile
, outfile
);
775 fprintf_filtered (outfile
, ")\n");
777 if (psymtab
->readin_p (objfile
))
779 fprintf_filtered (outfile
,
780 " Full symtab was read (at ");
781 gdb_print_host_address (psymtab
->get_compunit_symtab (objfile
), outfile
);
782 fprintf_filtered (outfile
, ")\n");
785 fprintf_filtered (outfile
, " Symbols cover text addresses ");
786 fputs_filtered (paddress (gdbarch
, psymtab
->text_low (objfile
)), outfile
);
787 fprintf_filtered (outfile
, "-");
788 fputs_filtered (paddress (gdbarch
, psymtab
->text_high (objfile
)), outfile
);
789 fprintf_filtered (outfile
, "\n");
790 fprintf_filtered (outfile
, " Address map supported - %s.\n",
791 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
792 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
793 psymtab
->number_of_dependencies
);
794 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
796 fprintf_filtered (outfile
, " %d ", i
);
797 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
798 fprintf_filtered (outfile
, " %s\n",
799 psymtab
->dependencies
[i
]->filename
);
801 if (psymtab
->user
!= NULL
)
803 fprintf_filtered (outfile
, " Shared partial symtab with user ");
804 gdb_print_host_address (psymtab
->user
, outfile
);
805 fprintf_filtered (outfile
, "\n");
807 if (!psymtab
->global_psymbols
.empty ())
809 print_partial_symbols
810 (gdbarch
, objfile
, psymtab
->global_psymbols
,
813 if (!psymtab
->static_psymbols
.empty ())
815 print_partial_symbols
816 (gdbarch
, objfile
, psymtab
->static_psymbols
,
819 fprintf_filtered (outfile
, "\n");
822 /* Count the number of partial symbols in OBJFILE. */
825 psymbol_functions::count_psyms ()
828 for (partial_symtab
*pst
: m_partial_symtabs
->range ())
830 count
+= pst
->global_psymbols
.size ();
831 count
+= pst
->static_psymbols
.size ();
836 /* Psymtab version of print_stats. See its definition in
837 the definition of quick_symbol_functions in symfile.h. */
840 psymbol_functions::print_stats (struct objfile
*objfile
, bool print_bcache
)
846 int n_psyms
= count_psyms ();
848 printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
852 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
854 if (!ps
->readin_p (objfile
))
857 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"),
859 printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
860 m_partial_symtabs
->psymbol_cache
.memory_used ());
864 printf_filtered (_("Psymbol byte cache statistics:\n"));
865 m_partial_symtabs
->psymbol_cache
.print_statistics
866 ("partial symbol cache");
870 /* Psymtab version of dump. See its definition in
871 the definition of quick_symbol_functions in symfile.h. */
874 psymbol_functions::dump (struct objfile
*objfile
)
876 struct partial_symtab
*psymtab
;
878 if (m_partial_symtabs
->psymtabs
)
880 printf_filtered ("Psymtabs:\n");
881 for (psymtab
= m_partial_symtabs
->psymtabs
;
883 psymtab
= psymtab
->next
)
885 printf_filtered ("%s at ",
887 gdb_print_host_address (psymtab
, gdb_stdout
);
888 printf_filtered ("\n");
890 printf_filtered ("\n\n");
894 /* Psymtab version of expand_all_symtabs. See its definition in
895 the definition of quick_symbol_functions in symfile.h. */
898 psymbol_functions::expand_all_symtabs (struct objfile
*objfile
)
900 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
))
901 psymtab_to_symtab (objfile
, psymtab
);
904 /* Psymtab version of map_symbol_filenames. See its definition in
905 the definition of quick_symbol_functions in symfile.h. */
908 psymbol_functions::map_symbol_filenames
909 (struct objfile
*objfile
,
910 gdb::function_view
<symbol_filename_ftype
> fun
,
913 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
915 const char *fullname
;
917 if (ps
->readin_p (objfile
))
920 /* We can skip shared psymtabs here, because any file name will be
921 attached to the unshared psymtab. */
922 if (ps
->user
!= NULL
)
925 /* Anonymous psymtabs don't have a file name. */
931 fullname
= psymtab_to_fullname (ps
);
934 fun (ps
->filename
, fullname
);
938 /* Finds the fullname that a partial_symtab represents.
940 If this functions finds the fullname, it will save it in ps->fullname
941 and it will also return the value.
943 If this function fails to find the file that this partial_symtab represents,
944 NULL will be returned and ps->fullname will be set to NULL. */
947 psymtab_to_fullname (struct partial_symtab
*ps
)
949 gdb_assert (!ps
->anonymous
);
951 /* Use cached copy if we have it.
952 We rely on forget_cached_source_info being called appropriately
953 to handle cases like the file being moved. */
954 if (ps
->fullname
== NULL
)
956 gdb::unique_xmalloc_ptr
<char> fullname
957 = find_source_or_rewrite (ps
->filename
, ps
->dirname
);
958 ps
->fullname
= fullname
.release ();
964 /* Psymtab version of expand_matching_symbols. See its definition in
965 the definition of quick_symbol_functions in symfile.h. */
968 psymbol_functions::expand_matching_symbols
969 (struct objfile
*objfile
,
970 const lookup_name_info
&name
, domain_enum domain
,
972 symbol_compare_ftype
*ordered_compare
)
974 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
977 if (!ps
->readin_p (objfile
)
978 && match_partial_symbol (objfile
, ps
, global
, name
, domain
,
980 psymtab_to_symtab (objfile
, ps
);
984 /* A helper for psym_expand_symtabs_matching that handles searching
985 included psymtabs. This returns true if a symbol is found, and
986 false otherwise. It also updates the 'searched_flag' on the
987 various psymtabs that it searches. */
990 recursively_search_psymtabs
991 (struct partial_symtab
*ps
,
992 struct objfile
*objfile
,
993 block_search_flags search_flags
,
995 enum search_domain search
,
996 const lookup_name_info
&lookup_name
,
997 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1000 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1003 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1004 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1006 /* Recurse into shared psymtabs first, because they may have already
1007 been searched, and this could save some time. */
1008 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1012 /* Skip non-shared dependencies, these are handled elsewhere. */
1013 if (ps
->dependencies
[i
]->user
== NULL
)
1016 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1017 objfile
, search_flags
, domain
, search
,
1018 lookup_name
, sym_matcher
);
1021 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1026 partial_symbol
**gbound
= (ps
->global_psymbols
.data ()
1027 + ps
->global_psymbols
.size ());
1028 partial_symbol
**sbound
= (ps
->static_psymbols
.data ()
1029 + ps
->static_psymbols
.size ());
1030 partial_symbol
**bound
= gbound
;
1032 /* Go through all of the symbols stored in a partial
1033 symtab in one loop. */
1034 partial_symbol
**psym
= ps
->global_psymbols
.data ();
1036 if ((search_flags
& SEARCH_GLOBAL_BLOCK
) == 0)
1038 if (ps
->static_psymbols
.empty ())
1042 psym
= ps
->static_psymbols
.data ();
1051 if (bound
== gbound
&& !ps
->static_psymbols
.empty ()
1052 && (search_flags
& SEARCH_STATIC_BLOCK
) != 0)
1054 psym
= ps
->static_psymbols
.data ();
1065 if ((domain
== UNDEF_DOMAIN
1066 || symbol_matches_domain ((*psym
)->ginfo
.language (),
1067 (*psym
)->domain
, domain
))
1068 && (search
== ALL_DOMAIN
1069 || (search
== MODULES_DOMAIN
1070 && (*psym
)->domain
== MODULE_DOMAIN
)
1071 || (search
== VARIABLES_DOMAIN
1072 && (*psym
)->aclass
!= LOC_TYPEDEF
1073 && (*psym
)->aclass
!= LOC_BLOCK
)
1074 || (search
== FUNCTIONS_DOMAIN
1075 && (*psym
)->aclass
== LOC_BLOCK
)
1076 || (search
== TYPES_DOMAIN
1077 && (*psym
)->aclass
== LOC_TYPEDEF
))
1078 && psymbol_name_matches (*psym
, lookup_name
)
1079 && (sym_matcher
== NULL
1080 || sym_matcher ((*psym
)->ginfo
.search_name ())))
1082 /* Found a match, so notify our caller. */
1083 result
= PST_SEARCHED_AND_FOUND
;
1090 ps
->searched_flag
= result
;
1091 return result
== PST_SEARCHED_AND_FOUND
;
1094 /* Psymtab version of expand_symtabs_matching. See its definition in
1095 the definition of quick_symbol_functions in symfile.h. */
1098 psymbol_functions::expand_symtabs_matching
1099 (struct objfile
*objfile
,
1100 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1101 const lookup_name_info
*lookup_name
,
1102 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1103 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1104 block_search_flags search_flags
,
1106 enum search_domain search
)
1108 /* Clear the search flags. */
1109 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
1110 ps
->searched_flag
= PST_NOT_SEARCHED
;
1112 gdb::optional
<lookup_name_info
> psym_lookup_name
;
1113 if (lookup_name
!= nullptr)
1114 psym_lookup_name
= lookup_name
->make_ignore_params ();
1116 /* This invariant is documented in quick-functions.h. */
1117 gdb_assert (lookup_name
!= nullptr || symbol_matcher
== nullptr);
1119 for (partial_symtab
*ps
: m_partial_symtabs
->range ())
1123 if (ps
->readin_p (objfile
))
1133 match
= file_matcher (ps
->filename
, false);
1136 /* Before we invoke realpath, which can get expensive when many
1137 files are involved, do a quick comparison of the basenames. */
1138 if (basenames_may_differ
1139 || file_matcher (lbasename (ps
->filename
), true))
1140 match
= file_matcher (psymtab_to_fullname (ps
), false);
1146 if (lookup_name
== nullptr
1147 || recursively_search_psymtabs (ps
, objfile
, search_flags
,
1152 struct compunit_symtab
*symtab
=
1153 psymtab_to_symtab (objfile
, ps
);
1155 if (expansion_notify
!= NULL
)
1156 if (!expansion_notify (symtab
))
1164 /* Psymtab version of has_symbols. See its definition in
1165 the definition of quick_symbol_functions in symfile.h. */
1168 psymbol_functions::has_symbols (struct objfile
*objfile
)
1170 return m_partial_symtabs
->psymtabs
!= NULL
;
1173 /* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
1176 psymbol_functions::has_unexpanded_symtabs (struct objfile
*objfile
)
1178 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
))
1180 /* Is this already expanded? */
1181 if (psymtab
->readin_p (objfile
))
1184 /* It has not yet been expanded. */
1191 /* Helper function for psym_find_compunit_symtab_by_address that fills
1192 in m_psymbol_map for a given range of psymbols. */
1195 psymbol_functions::fill_psymbol_map
1196 (struct objfile
*objfile
,
1197 struct partial_symtab
*psymtab
,
1198 std::set
<CORE_ADDR
> *seen_addrs
,
1199 const std::vector
<partial_symbol
*> &symbols
)
1201 for (partial_symbol
*psym
: symbols
)
1203 if (psym
->aclass
== LOC_STATIC
)
1205 CORE_ADDR addr
= psym
->address (objfile
);
1206 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1208 seen_addrs
->insert (addr
);
1209 m_psymbol_map
.emplace_back (addr
, psymtab
);
1215 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1219 psymbol_functions::find_compunit_symtab_by_address (struct objfile
*objfile
,
1222 if (m_psymbol_map
.empty ())
1224 std::set
<CORE_ADDR
> seen_addrs
;
1226 for (partial_symtab
*pst
: require_partial_symbols (objfile
))
1228 fill_psymbol_map (objfile
, pst
,
1230 pst
->global_psymbols
);
1231 fill_psymbol_map (objfile
, pst
,
1233 pst
->static_psymbols
);
1236 m_psymbol_map
.shrink_to_fit ();
1238 std::sort (m_psymbol_map
.begin (), m_psymbol_map
.end (),
1239 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1240 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1242 return a
.first
< b
.first
;
1246 auto iter
= std::lower_bound
1247 (m_psymbol_map
.begin (), m_psymbol_map
.end (), address
,
1248 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1254 if (iter
== m_psymbol_map
.end () || iter
->first
!= address
)
1257 return psymtab_to_symtab (objfile
, iter
->second
);
1262 /* Partially fill a partial symtab. It will be completely filled at
1263 the end of the symbol list. */
1265 partial_symtab::partial_symtab (const char *filename
,
1266 psymtab_storage
*partial_symtabs
,
1267 objfile_per_bfd_storage
*objfile_per_bfd
,
1269 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
1271 set_text_low (textlow
);
1272 set_text_high (raw_text_low ()); /* default */
1275 /* Perform "finishing up" operations of a partial symtab. */
1278 partial_symtab::end ()
1280 global_psymbols
.shrink_to_fit ();
1281 static_psymbols
.shrink_to_fit ();
1283 /* Sort the global list; don't sort the static list. */
1284 std::sort (global_psymbols
.begin (),
1285 global_psymbols
.end (),
1286 [] (partial_symbol
*s1
, partial_symbol
*s2
)
1288 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1289 s2
->ginfo
.search_name ()) < 0;
1293 /* See psymtab.h. */
1296 psymbol_bcache::hash (const void *addr
, int length
)
1298 unsigned long h
= 0;
1299 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1300 unsigned int lang
= psymbol
->ginfo
.language ();
1301 unsigned int domain
= psymbol
->domain
;
1302 unsigned int theclass
= psymbol
->aclass
;
1304 h
= fast_hash (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1305 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1306 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1307 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1308 /* Note that psymbol names are interned via compute_and_set_names, so
1309 there's no need to hash the contents of the name here. */
1310 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1315 /* See psymtab.h. */
1318 psymbol_bcache::compare (const void *addr1
, const void *addr2
, int length
)
1320 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1321 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1323 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1324 sizeof (sym1
->ginfo
.value
)) == 0
1325 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1326 && sym1
->domain
== sym2
->domain
1327 && sym1
->aclass
== sym2
->aclass
1328 /* Note that psymbol names are interned via
1329 compute_and_set_names, so there's no need to compare the
1330 contents of the name here. */
1331 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1334 /* See psympriv.h. */
1337 partial_symtab::add_psymbol (const partial_symbol
&psymbol
,
1338 psymbol_placement where
,
1339 psymtab_storage
*partial_symtabs
,
1340 struct objfile
*objfile
)
1344 /* Stash the partial symbol away in the cache. */
1345 partial_symbol
*psym
1346 = ((struct partial_symbol
*)
1347 partial_symtabs
->psymbol_cache
.insert
1348 (&psymbol
, sizeof (struct partial_symbol
), &added
));
1350 /* Do not duplicate global partial symbols. */
1351 if (where
== psymbol_placement::GLOBAL
&& !added
)
1354 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1355 std::vector
<partial_symbol
*> &list
1356 = (where
== psymbol_placement::STATIC
1359 list
.push_back (psym
);
1362 /* See psympriv.h. */
1365 partial_symtab::add_psymbol (gdb::string_view name
, bool copy_name
,
1367 enum address_class theclass
,
1369 psymbol_placement where
,
1371 enum language language
,
1372 psymtab_storage
*partial_symtabs
,
1373 struct objfile
*objfile
)
1375 struct partial_symbol psymbol
;
1376 memset (&psymbol
, 0, sizeof (psymbol
));
1378 psymbol
.set_unrelocated_address (coreaddr
);
1379 psymbol
.ginfo
.set_section_index (section
);
1380 psymbol
.domain
= domain
;
1381 psymbol
.aclass
= theclass
;
1382 psymbol
.ginfo
.set_language (language
, partial_symtabs
->obstack ());
1383 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1385 add_psymbol (psymbol
, where
, partial_symtabs
, objfile
);
1388 /* See psympriv.h. */
1390 partial_symtab::partial_symtab (const char *filename_
,
1391 psymtab_storage
*partial_symtabs
,
1392 objfile_per_bfd_storage
*objfile_per_bfd
)
1393 : searched_flag (PST_NOT_SEARCHED
),
1397 partial_symtabs
->install_psymtab (this);
1399 filename
= objfile_per_bfd
->intern (filename_
);
1401 if (symtab_create_debug
)
1403 /* Be a bit clever with debugging messages, and don't print objfile
1404 every time, only when it changes. */
1405 static std::string last_bfd_name
;
1406 const char *this_bfd_name
1407 = bfd_get_filename (objfile_per_bfd
->get_bfd ());
1409 if (last_bfd_name
.empty () || last_bfd_name
!= this_bfd_name
)
1411 last_bfd_name
= this_bfd_name
;
1412 fprintf_filtered (gdb_stdlog
,
1413 "Creating one or more psymtabs for %s ...\n",
1416 fprintf_filtered (gdb_stdlog
,
1417 "Created psymtab %s for module %s.\n",
1418 host_address_to_string (this), filename
);
1422 /* See psympriv.h. */
1425 partial_symtab::expand_dependencies (struct objfile
*objfile
)
1427 for (int i
= 0; i
< number_of_dependencies
; ++i
)
1429 if (!dependencies
[i
]->readin_p (objfile
)
1430 && dependencies
[i
]->user
== NULL
)
1432 /* Inform about additional files to be read in. */
1435 fputs_filtered (" ", gdb_stdout
);
1437 fputs_filtered ("and ", gdb_stdout
);
1439 printf_filtered ("%s...", dependencies
[i
]->filename
);
1440 wrap_here (""); /* Flush output */
1441 gdb_flush (gdb_stdout
);
1443 dependencies
[i
]->expand_psymtab (objfile
);
1450 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1452 struct partial_symtab
**prev_pst
;
1455 Empty psymtabs happen as a result of header files which don't
1456 have any symbols in them. There can be a lot of them. But this
1457 check is wrong, in that a psymtab with N_SLINE entries but
1458 nothing else is not empty, but we don't realize that. Fixing
1459 that without slowing things down might be tricky. */
1461 /* First, snip it out of the psymtab chain. */
1463 prev_pst
= &psymtabs
;
1464 while ((*prev_pst
) != pst
)
1465 prev_pst
= &((*prev_pst
)->next
);
1466 (*prev_pst
) = pst
->next
;
1472 /* Helper function for maintenance_print_psymbols to print the addrmap
1473 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1476 dump_psymtab_addrmap (struct objfile
*objfile
,
1477 psymtab_storage
*partial_symtabs
,
1478 struct partial_symtab
*psymtab
,
1479 struct ui_file
*outfile
)
1481 if ((psymtab
== NULL
1482 || psymtab
->psymtabs_addrmap_supported
)
1483 && partial_symtabs
->psymtabs_addrmap
!= NULL
)
1485 if (psymtab
== nullptr)
1486 fprintf_filtered (outfile
, _("Entire address map:\n"));
1488 fprintf_filtered (outfile
, _("Address map:\n"));
1489 addrmap_dump (partial_symtabs
->psymtabs_addrmap
, outfile
, psymtab
);
1494 maintenance_print_psymbols (const char *args
, int from_tty
)
1496 struct ui_file
*outfile
= gdb_stdout
;
1497 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1498 int i
, outfile_idx
, found
;
1500 struct obj_section
*section
= NULL
;
1504 gdb_argv
argv (args
);
1506 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1508 if (strcmp (argv
[i
], "-pc") == 0)
1510 if (argv
[i
+ 1] == NULL
)
1511 error (_("Missing pc value"));
1512 address_arg
= argv
[++i
];
1514 else if (strcmp (argv
[i
], "-source") == 0)
1516 if (argv
[i
+ 1] == NULL
)
1517 error (_("Missing source file"));
1518 source_arg
= argv
[++i
];
1520 else if (strcmp (argv
[i
], "-objfile") == 0)
1522 if (argv
[i
+ 1] == NULL
)
1523 error (_("Missing objfile name"));
1524 objfile_arg
= argv
[++i
];
1526 else if (strcmp (argv
[i
], "--") == 0)
1528 /* End of options. */
1532 else if (argv
[i
][0] == '-')
1534 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1535 error (_("Unknown option: %s"), argv
[i
]);
1542 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1543 error (_("Must specify at most one of -pc and -source"));
1545 stdio_file arg_outfile
;
1547 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1549 if (argv
[outfile_idx
+ 1] != NULL
)
1550 error (_("Junk at end of command"));
1551 gdb::unique_xmalloc_ptr
<char> outfile_name
1552 (tilde_expand (argv
[outfile_idx
]));
1553 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1554 perror_with_name (outfile_name
.get ());
1555 outfile
= &arg_outfile
;
1558 if (address_arg
!= NULL
)
1560 pc
= parse_and_eval_address (address_arg
);
1561 /* If we fail to find a section, that's ok, try the lookup anyway. */
1562 section
= find_pc_section (pc
);
1566 for (objfile
*objfile
: current_program_space
->objfiles ())
1568 int printed_objfile_header
= 0;
1569 int print_for_objfile
= 1;
1572 if (objfile_arg
!= NULL
)
1574 = compare_filenames_for_search (objfile_name (objfile
),
1576 if (!print_for_objfile
)
1579 for (const auto &iter
: objfile
->qf
)
1581 psymbol_functions
*psf
1582 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1586 psymtab_storage
*partial_symtabs
1587 = psf
->get_partial_symtabs ().get ();
1589 if (address_arg
!= NULL
)
1591 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1593 /* We don't assume each pc has a unique objfile (this is for
1595 struct partial_symtab
*ps
1596 = psf
->find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1599 if (!printed_objfile_header
)
1601 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1602 objfile_name (objfile
));
1603 printed_objfile_header
= 1;
1605 dump_psymtab (objfile
, ps
, outfile
);
1606 dump_psymtab_addrmap (objfile
, partial_symtabs
, ps
, outfile
);
1612 for (partial_symtab
*ps
: psf
->require_partial_symbols (objfile
))
1614 int print_for_source
= 0;
1617 if (source_arg
!= NULL
)
1620 = compare_filenames_for_search (ps
->filename
, source_arg
);
1623 if (source_arg
== NULL
1624 || print_for_source
)
1626 if (!printed_objfile_header
)
1628 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1629 objfile_name (objfile
));
1630 printed_objfile_header
= 1;
1632 dump_psymtab (objfile
, ps
, outfile
);
1633 dump_psymtab_addrmap (objfile
, partial_symtabs
, ps
,
1639 /* If we're printing all the objfile's symbols dump the full addrmap. */
1641 if (address_arg
== NULL
1642 && source_arg
== NULL
1643 && partial_symtabs
->psymtabs_addrmap
!= NULL
)
1645 outfile
->puts ("\n");
1646 dump_psymtab_addrmap (objfile
, partial_symtabs
, NULL
, outfile
);
1653 if (address_arg
!= NULL
)
1654 error (_("No partial symtab for address: %s"), address_arg
);
1655 if (source_arg
!= NULL
)
1656 error (_("No partial symtab for source file: %s"), source_arg
);
1660 /* List all the partial symbol tables whose names match REGEXP (optional). */
1663 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1668 for (struct program_space
*pspace
: program_spaces
)
1669 for (objfile
*objfile
: pspace
->objfiles ())
1671 struct gdbarch
*gdbarch
= objfile
->arch ();
1673 /* We don't want to print anything for this objfile until we
1674 actually find a symtab whose name matches. */
1675 int printed_objfile_start
= 0;
1677 for (const auto &iter
: objfile
->qf
)
1679 psymbol_functions
*psf
1680 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1683 for (partial_symtab
*psymtab
: psf
->require_partial_symbols (objfile
))
1688 || re_exec (psymtab
->filename
))
1690 if (! printed_objfile_start
)
1692 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
1694 printf_filtered ("((struct objfile *) %s)\n",
1695 host_address_to_string (objfile
));
1696 printed_objfile_start
= 1;
1699 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1701 printf_filtered ("((struct partial_symtab *) %s)\n",
1702 host_address_to_string (psymtab
));
1704 printf_filtered (" readin %s\n",
1705 psymtab
->readin_p (objfile
) ? "yes" : "no");
1706 printf_filtered (" fullname %s\n",
1708 ? psymtab
->fullname
: "(null)");
1709 printf_filtered (" text addresses ");
1710 fputs_filtered (paddress (gdbarch
,
1711 psymtab
->text_low (objfile
)),
1713 printf_filtered (" -- ");
1714 fputs_filtered (paddress (gdbarch
,
1715 psymtab
->text_high (objfile
)),
1717 printf_filtered ("\n");
1718 printf_filtered (" psymtabs_addrmap_supported %s\n",
1719 (psymtab
->psymtabs_addrmap_supported
1721 printf_filtered (" globals ");
1722 if (!psymtab
->global_psymbols
.empty ())
1724 ("(* (struct partial_symbol **) %s @ %d)\n",
1725 host_address_to_string (psymtab
->global_psymbols
.data ()),
1726 (int) psymtab
->global_psymbols
.size ());
1728 printf_filtered ("(none)\n");
1729 printf_filtered (" statics ");
1730 if (!psymtab
->static_psymbols
.empty ())
1732 ("(* (struct partial_symbol **) %s @ %d)\n",
1733 host_address_to_string (psymtab
->static_psymbols
.data ()),
1734 (int) psymtab
->static_psymbols
.size ());
1736 printf_filtered ("(none)\n");
1738 printf_filtered (" user %s "
1739 "((struct partial_symtab *) %s)\n",
1740 psymtab
->user
->filename
,
1741 host_address_to_string (psymtab
->user
));
1742 printf_filtered (" dependencies ");
1743 if (psymtab
->number_of_dependencies
)
1747 printf_filtered ("{\n");
1748 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1750 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
1752 /* Note the string concatenation there --- no
1754 printf_filtered (" psymtab %s "
1755 "((struct partial_symtab *) %s)\n",
1757 host_address_to_string (dep
));
1759 printf_filtered (" }\n");
1762 printf_filtered ("(none)\n");
1763 printf_filtered (" }\n");
1768 if (printed_objfile_start
)
1769 printf_filtered ("}\n");
1773 /* Check consistency of currently expanded psymtabs vs symtabs. */
1776 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
1779 struct compunit_symtab
*cust
= NULL
;
1780 const struct blockvector
*bv
;
1781 const struct block
*b
;
1783 for (objfile
*objfile
: current_program_space
->objfiles ())
1785 for (const auto &iter
: objfile
->qf
)
1787 psymbol_functions
*psf
1788 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1792 for (partial_symtab
*ps
: psf
->require_partial_symbols (objfile
))
1794 struct gdbarch
*gdbarch
= objfile
->arch ();
1796 /* We don't call psymtab_to_symtab here because that may cause symtab
1797 expansion. When debugging a problem it helps if checkers leave
1798 things unchanged. */
1799 cust
= ps
->get_compunit_symtab (objfile
);
1801 /* First do some checks that don't require the associated symtab. */
1802 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
1804 printf_filtered ("Psymtab ");
1805 puts_filtered (ps
->filename
);
1806 printf_filtered (" covers bad range ");
1807 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
1809 printf_filtered (" - ");
1810 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
1812 printf_filtered ("\n");
1816 /* Now do checks requiring the associated symtab. */
1819 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1820 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1821 for (partial_symbol
*psym
: ps
->static_psymbols
)
1823 /* Skip symbols for inlined functions without address. These may
1824 or may not have a match in the full symtab. */
1825 if (psym
->aclass
== LOC_BLOCK
1826 && psym
->ginfo
.value
.address
== 0)
1829 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1830 symbol_name_match_type::SEARCH_NAME
,
1834 printf_filtered ("Static symbol `");
1835 puts_filtered (psym
->ginfo
.linkage_name ());
1836 printf_filtered ("' only found in ");
1837 puts_filtered (ps
->filename
);
1838 printf_filtered (" psymtab\n");
1841 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1842 for (partial_symbol
*psym
: ps
->global_psymbols
)
1844 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1845 symbol_name_match_type::SEARCH_NAME
,
1849 printf_filtered ("Global symbol `");
1850 puts_filtered (psym
->ginfo
.linkage_name ());
1851 printf_filtered ("' only found in ");
1852 puts_filtered (ps
->filename
);
1853 printf_filtered (" psymtab\n");
1856 if (ps
->raw_text_high () != 0
1857 && (ps
->text_low (objfile
) < BLOCK_START (b
)
1858 || ps
->text_high (objfile
) > BLOCK_END (b
)))
1860 printf_filtered ("Psymtab ");
1861 puts_filtered (ps
->filename
);
1862 printf_filtered (" covers ");
1863 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
1865 printf_filtered (" - ");
1866 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
1868 printf_filtered (" but symtab covers only ");
1869 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
1870 printf_filtered (" - ");
1871 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
1872 printf_filtered ("\n");
1879 void _initialize_psymtab ();
1881 _initialize_psymtab ()
1883 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
1884 Print dump of current partial symbol definitions.\n\
1885 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
1886 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1887 Entries in the partial symbol table are dumped to file OUTFILE,\n\
1888 or the terminal if OUTFILE is unspecified.\n\
1889 If ADDRESS is provided, dump only the file for that address.\n\
1890 If SOURCE is provided, dump only that file's symbols.\n\
1891 If OBJFILE is provided, dump only that file's minimal symbols."),
1892 &maintenanceprintlist
);
1894 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
1895 List the partial symbol tables for all object files.\n\
1896 This does not include information about individual partial symbols,\n\
1897 just the symbol table structures themselves."),
1898 &maintenanceinfolist
);
1900 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
1902 Check consistency of currently expanded psymtabs versus symtabs."),