1 /* Partial symbol tables.
3 Copyright (C) 2009-2022 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 scoped_fd fd
= find_and_open_source (ps
->filename
, ps
->dirname
,
959 ps
->fullname
= fullname
.release ();
963 /* rewrite_source_path would be applied by find_and_open_source, we
964 should report the pathname where GDB tried to find the file. */
966 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
967 fullname
.reset (xstrdup (ps
->filename
));
969 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
970 ps
->filename
, (char *) NULL
));
972 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
973 if (ps
->fullname
== NULL
)
974 ps
->fullname
= fullname
.release ();
981 /* Psymtab version of expand_matching_symbols. See its definition in
982 the definition of quick_symbol_functions in symfile.h. */
985 psymbol_functions::expand_matching_symbols
986 (struct objfile
*objfile
,
987 const lookup_name_info
&name
, domain_enum domain
,
989 symbol_compare_ftype
*ordered_compare
)
991 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
994 if (!ps
->readin_p (objfile
)
995 && match_partial_symbol (objfile
, ps
, global
, name
, domain
,
997 psymtab_to_symtab (objfile
, ps
);
1001 /* A helper for psym_expand_symtabs_matching that handles searching
1002 included psymtabs. This returns true if a symbol is found, and
1003 false otherwise. It also updates the 'searched_flag' on the
1004 various psymtabs that it searches. */
1007 recursively_search_psymtabs
1008 (struct partial_symtab
*ps
,
1009 struct objfile
*objfile
,
1010 block_search_flags search_flags
,
1012 enum search_domain search
,
1013 const lookup_name_info
&lookup_name
,
1014 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1017 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1020 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1021 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1023 /* Recurse into shared psymtabs first, because they may have already
1024 been searched, and this could save some time. */
1025 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1029 /* Skip non-shared dependencies, these are handled elsewhere. */
1030 if (ps
->dependencies
[i
]->user
== NULL
)
1033 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1034 objfile
, search_flags
, domain
, search
,
1035 lookup_name
, sym_matcher
);
1038 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1043 partial_symbol
**gbound
= (ps
->global_psymbols
.data ()
1044 + ps
->global_psymbols
.size ());
1045 partial_symbol
**sbound
= (ps
->static_psymbols
.data ()
1046 + ps
->static_psymbols
.size ());
1047 partial_symbol
**bound
= gbound
;
1049 /* Go through all of the symbols stored in a partial
1050 symtab in one loop. */
1051 partial_symbol
**psym
= ps
->global_psymbols
.data ();
1053 if ((search_flags
& SEARCH_GLOBAL_BLOCK
) == 0)
1055 if (ps
->static_psymbols
.empty ())
1059 psym
= ps
->static_psymbols
.data ();
1068 if (bound
== gbound
&& !ps
->static_psymbols
.empty ()
1069 && (search_flags
& SEARCH_STATIC_BLOCK
) != 0)
1071 psym
= ps
->static_psymbols
.data ();
1082 if ((domain
== UNDEF_DOMAIN
1083 || symbol_matches_domain ((*psym
)->ginfo
.language (),
1084 (*psym
)->domain
, domain
))
1085 && (search
== ALL_DOMAIN
1086 || (search
== MODULES_DOMAIN
1087 && (*psym
)->domain
== MODULE_DOMAIN
)
1088 || (search
== VARIABLES_DOMAIN
1089 && (*psym
)->aclass
!= LOC_TYPEDEF
1090 && (*psym
)->aclass
!= LOC_BLOCK
)
1091 || (search
== FUNCTIONS_DOMAIN
1092 && (*psym
)->aclass
== LOC_BLOCK
)
1093 || (search
== TYPES_DOMAIN
1094 && (*psym
)->aclass
== LOC_TYPEDEF
))
1095 && psymbol_name_matches (*psym
, lookup_name
)
1096 && (sym_matcher
== NULL
1097 || sym_matcher ((*psym
)->ginfo
.search_name ())))
1099 /* Found a match, so notify our caller. */
1100 result
= PST_SEARCHED_AND_FOUND
;
1107 ps
->searched_flag
= result
;
1108 return result
== PST_SEARCHED_AND_FOUND
;
1111 /* Psymtab version of expand_symtabs_matching. See its definition in
1112 the definition of quick_symbol_functions in symfile.h. */
1115 psymbol_functions::expand_symtabs_matching
1116 (struct objfile
*objfile
,
1117 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1118 const lookup_name_info
*lookup_name
,
1119 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1120 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1121 block_search_flags search_flags
,
1123 enum search_domain search
)
1125 /* Clear the search flags. */
1126 for (partial_symtab
*ps
: require_partial_symbols (objfile
))
1127 ps
->searched_flag
= PST_NOT_SEARCHED
;
1129 gdb::optional
<lookup_name_info
> psym_lookup_name
;
1130 if (lookup_name
!= nullptr)
1131 psym_lookup_name
= lookup_name
->make_ignore_params ();
1133 for (partial_symtab
*ps
: m_partial_symtabs
->range ())
1137 if (ps
->readin_p (objfile
))
1147 match
= file_matcher (ps
->filename
, false);
1150 /* Before we invoke realpath, which can get expensive when many
1151 files are involved, do a quick comparison of the basenames. */
1152 if (basenames_may_differ
1153 || file_matcher (lbasename (ps
->filename
), true))
1154 match
= file_matcher (psymtab_to_fullname (ps
), false);
1160 if ((symbol_matcher
== NULL
&& lookup_name
== NULL
)
1161 || recursively_search_psymtabs (ps
, objfile
, search_flags
,
1166 struct compunit_symtab
*symtab
=
1167 psymtab_to_symtab (objfile
, ps
);
1169 if (expansion_notify
!= NULL
)
1170 if (!expansion_notify (symtab
))
1178 /* Psymtab version of has_symbols. See its definition in
1179 the definition of quick_symbol_functions in symfile.h. */
1182 psymbol_functions::has_symbols (struct objfile
*objfile
)
1184 return m_partial_symtabs
->psymtabs
!= NULL
;
1187 /* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
1190 psymbol_functions::has_unexpanded_symtabs (struct objfile
*objfile
)
1192 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
))
1194 /* Is this already expanded? */
1195 if (psymtab
->readin_p (objfile
))
1198 /* It has not yet been expanded. */
1205 /* Helper function for psym_find_compunit_symtab_by_address that fills
1206 in m_psymbol_map for a given range of psymbols. */
1209 psymbol_functions::fill_psymbol_map
1210 (struct objfile
*objfile
,
1211 struct partial_symtab
*psymtab
,
1212 std::set
<CORE_ADDR
> *seen_addrs
,
1213 const std::vector
<partial_symbol
*> &symbols
)
1215 for (partial_symbol
*psym
: symbols
)
1217 if (psym
->aclass
== LOC_STATIC
)
1219 CORE_ADDR addr
= psym
->address (objfile
);
1220 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1222 seen_addrs
->insert (addr
);
1223 m_psymbol_map
.emplace_back (addr
, psymtab
);
1229 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1233 psymbol_functions::find_compunit_symtab_by_address (struct objfile
*objfile
,
1236 if (m_psymbol_map
.empty ())
1238 std::set
<CORE_ADDR
> seen_addrs
;
1240 for (partial_symtab
*pst
: require_partial_symbols (objfile
))
1242 fill_psymbol_map (objfile
, pst
,
1244 pst
->global_psymbols
);
1245 fill_psymbol_map (objfile
, pst
,
1247 pst
->static_psymbols
);
1250 m_psymbol_map
.shrink_to_fit ();
1252 std::sort (m_psymbol_map
.begin (), m_psymbol_map
.end (),
1253 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1254 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1256 return a
.first
< b
.first
;
1260 auto iter
= std::lower_bound
1261 (m_psymbol_map
.begin (), m_psymbol_map
.end (), address
,
1262 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1268 if (iter
== m_psymbol_map
.end () || iter
->first
!= address
)
1271 return psymtab_to_symtab (objfile
, iter
->second
);
1276 /* Partially fill a partial symtab. It will be completely filled at
1277 the end of the symbol list. */
1279 partial_symtab::partial_symtab (const char *filename
,
1280 psymtab_storage
*partial_symtabs
,
1281 objfile_per_bfd_storage
*objfile_per_bfd
,
1283 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
1285 set_text_low (textlow
);
1286 set_text_high (raw_text_low ()); /* default */
1289 /* Perform "finishing up" operations of a partial symtab. */
1292 partial_symtab::end ()
1294 global_psymbols
.shrink_to_fit ();
1295 static_psymbols
.shrink_to_fit ();
1297 /* Sort the global list; don't sort the static list. */
1298 std::sort (global_psymbols
.begin (),
1299 global_psymbols
.end (),
1300 [] (partial_symbol
*s1
, partial_symbol
*s2
)
1302 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1303 s2
->ginfo
.search_name ()) < 0;
1307 /* See psymtab.h. */
1310 psymbol_bcache::hash (const void *addr
, int length
)
1312 unsigned long h
= 0;
1313 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1314 unsigned int lang
= psymbol
->ginfo
.language ();
1315 unsigned int domain
= psymbol
->domain
;
1316 unsigned int theclass
= psymbol
->aclass
;
1318 h
= fast_hash (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1319 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1320 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1321 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1322 /* Note that psymbol names are interned via compute_and_set_names, so
1323 there's no need to hash the contents of the name here. */
1324 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1329 /* See psymtab.h. */
1332 psymbol_bcache::compare (const void *addr1
, const void *addr2
, int length
)
1334 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1335 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1337 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1338 sizeof (sym1
->ginfo
.value
)) == 0
1339 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1340 && sym1
->domain
== sym2
->domain
1341 && sym1
->aclass
== sym2
->aclass
1342 /* Note that psymbol names are interned via
1343 compute_and_set_names, so there's no need to compare the
1344 contents of the name here. */
1345 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1348 /* See psympriv.h. */
1351 partial_symtab::add_psymbol (const partial_symbol
&psymbol
,
1352 psymbol_placement where
,
1353 psymtab_storage
*partial_symtabs
,
1354 struct objfile
*objfile
)
1358 /* Stash the partial symbol away in the cache. */
1359 partial_symbol
*psym
1360 = ((struct partial_symbol
*)
1361 partial_symtabs
->psymbol_cache
.insert
1362 (&psymbol
, sizeof (struct partial_symbol
), &added
));
1364 /* Do not duplicate global partial symbols. */
1365 if (where
== psymbol_placement::GLOBAL
&& !added
)
1368 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1369 std::vector
<partial_symbol
*> &list
1370 = (where
== psymbol_placement::STATIC
1373 list
.push_back (psym
);
1376 /* See psympriv.h. */
1379 partial_symtab::add_psymbol (gdb::string_view name
, bool copy_name
,
1381 enum address_class theclass
,
1383 psymbol_placement where
,
1385 enum language language
,
1386 psymtab_storage
*partial_symtabs
,
1387 struct objfile
*objfile
)
1389 struct partial_symbol psymbol
;
1390 memset (&psymbol
, 0, sizeof (psymbol
));
1392 psymbol
.set_unrelocated_address (coreaddr
);
1393 psymbol
.ginfo
.set_section_index (section
);
1394 psymbol
.domain
= domain
;
1395 psymbol
.aclass
= theclass
;
1396 psymbol
.ginfo
.set_language (language
, partial_symtabs
->obstack ());
1397 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1399 add_psymbol (psymbol
, where
, partial_symtabs
, objfile
);
1402 /* See psympriv.h. */
1404 partial_symtab::partial_symtab (const char *filename_
,
1405 psymtab_storage
*partial_symtabs
,
1406 objfile_per_bfd_storage
*objfile_per_bfd
)
1407 : searched_flag (PST_NOT_SEARCHED
),
1411 partial_symtabs
->install_psymtab (this);
1413 filename
= objfile_per_bfd
->intern (filename_
);
1415 if (symtab_create_debug
)
1417 /* Be a bit clever with debugging messages, and don't print objfile
1418 every time, only when it changes. */
1419 static std::string last_bfd_name
;
1420 const char *this_bfd_name
1421 = bfd_get_filename (objfile_per_bfd
->get_bfd ());
1423 if (last_bfd_name
.empty () || last_bfd_name
!= this_bfd_name
)
1425 last_bfd_name
= this_bfd_name
;
1426 fprintf_filtered (gdb_stdlog
,
1427 "Creating one or more psymtabs for %s ...\n",
1430 fprintf_filtered (gdb_stdlog
,
1431 "Created psymtab %s for module %s.\n",
1432 host_address_to_string (this), filename
);
1436 /* See psympriv.h. */
1439 partial_symtab::expand_dependencies (struct objfile
*objfile
)
1441 for (int i
= 0; i
< number_of_dependencies
; ++i
)
1443 if (!dependencies
[i
]->readin_p (objfile
)
1444 && dependencies
[i
]->user
== NULL
)
1446 /* Inform about additional files to be read in. */
1449 fputs_filtered (" ", gdb_stdout
);
1451 fputs_filtered ("and ", gdb_stdout
);
1453 printf_filtered ("%s...", dependencies
[i
]->filename
);
1454 wrap_here (""); /* Flush output */
1455 gdb_flush (gdb_stdout
);
1457 dependencies
[i
]->expand_psymtab (objfile
);
1464 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1466 struct partial_symtab
**prev_pst
;
1469 Empty psymtabs happen as a result of header files which don't
1470 have any symbols in them. There can be a lot of them. But this
1471 check is wrong, in that a psymtab with N_SLINE entries but
1472 nothing else is not empty, but we don't realize that. Fixing
1473 that without slowing things down might be tricky. */
1475 /* First, snip it out of the psymtab chain. */
1477 prev_pst
= &psymtabs
;
1478 while ((*prev_pst
) != pst
)
1479 prev_pst
= &((*prev_pst
)->next
);
1480 (*prev_pst
) = pst
->next
;
1486 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1489 dump_psymtab_addrmap_1 (struct objfile
*objfile
,
1490 struct partial_symtab
*psymtab
,
1491 struct ui_file
*outfile
,
1492 int *previous_matched
,
1493 CORE_ADDR start_addr
,
1496 struct gdbarch
*gdbarch
= objfile
->arch ();
1497 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1498 const char *psymtab_address_or_end
= NULL
;
1503 || psymtab
== addrmap_psymtab
)
1504 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1505 else if (*previous_matched
)
1506 psymtab_address_or_end
= "<ends here>";
1509 || psymtab
== addrmap_psymtab
1510 || *previous_matched
)
1512 fprintf_filtered (outfile
, " %s%s %s\n",
1513 psymtab
!= NULL
? " " : "",
1514 paddress (gdbarch
, start_addr
),
1515 psymtab_address_or_end
);
1518 *previous_matched
= psymtab
== NULL
|| psymtab
== addrmap_psymtab
;
1523 /* Helper function for maintenance_print_psymbols to print the addrmap
1524 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1527 dump_psymtab_addrmap (struct objfile
*objfile
,
1528 psymtab_storage
*partial_symtabs
,
1529 struct partial_symtab
*psymtab
,
1530 struct ui_file
*outfile
)
1532 if ((psymtab
== NULL
1533 || psymtab
->psymtabs_addrmap_supported
)
1534 && partial_symtabs
->psymtabs_addrmap
!= NULL
)
1536 /* Non-zero if the previously printed addrmap entry was for
1537 PSYMTAB. If so, we want to print the next one as well (since
1538 the next addrmap entry defines the end of the range). */
1539 int previous_matched
= 0;
1541 auto callback
= [&] (CORE_ADDR start_addr
, void *obj
)
1543 return dump_psymtab_addrmap_1 (objfile
, psymtab
, outfile
,
1544 &previous_matched
, start_addr
, obj
);
1547 fprintf_filtered (outfile
, "%sddress map:\n",
1548 psymtab
== NULL
? "Entire a" : " A");
1549 addrmap_foreach (partial_symtabs
->psymtabs_addrmap
, callback
);
1554 maintenance_print_psymbols (const char *args
, int from_tty
)
1556 struct ui_file
*outfile
= gdb_stdout
;
1557 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1558 int i
, outfile_idx
, found
;
1560 struct obj_section
*section
= NULL
;
1564 gdb_argv
argv (args
);
1566 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1568 if (strcmp (argv
[i
], "-pc") == 0)
1570 if (argv
[i
+ 1] == NULL
)
1571 error (_("Missing pc value"));
1572 address_arg
= argv
[++i
];
1574 else if (strcmp (argv
[i
], "-source") == 0)
1576 if (argv
[i
+ 1] == NULL
)
1577 error (_("Missing source file"));
1578 source_arg
= argv
[++i
];
1580 else if (strcmp (argv
[i
], "-objfile") == 0)
1582 if (argv
[i
+ 1] == NULL
)
1583 error (_("Missing objfile name"));
1584 objfile_arg
= argv
[++i
];
1586 else if (strcmp (argv
[i
], "--") == 0)
1588 /* End of options. */
1592 else if (argv
[i
][0] == '-')
1594 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1595 error (_("Unknown option: %s"), argv
[i
]);
1602 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1603 error (_("Must specify at most one of -pc and -source"));
1605 stdio_file arg_outfile
;
1607 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1609 if (argv
[outfile_idx
+ 1] != NULL
)
1610 error (_("Junk at end of command"));
1611 gdb::unique_xmalloc_ptr
<char> outfile_name
1612 (tilde_expand (argv
[outfile_idx
]));
1613 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1614 perror_with_name (outfile_name
.get ());
1615 outfile
= &arg_outfile
;
1618 if (address_arg
!= NULL
)
1620 pc
= parse_and_eval_address (address_arg
);
1621 /* If we fail to find a section, that's ok, try the lookup anyway. */
1622 section
= find_pc_section (pc
);
1626 for (objfile
*objfile
: current_program_space
->objfiles ())
1628 int printed_objfile_header
= 0;
1629 int print_for_objfile
= 1;
1632 if (objfile_arg
!= NULL
)
1634 = compare_filenames_for_search (objfile_name (objfile
),
1636 if (!print_for_objfile
)
1639 for (const auto &iter
: objfile
->qf
)
1641 psymbol_functions
*psf
1642 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1646 psymtab_storage
*partial_symtabs
1647 = psf
->get_partial_symtabs ().get ();
1649 if (address_arg
!= NULL
)
1651 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1653 /* We don't assume each pc has a unique objfile (this is for
1655 struct partial_symtab
*ps
1656 = psf
->find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1659 if (!printed_objfile_header
)
1661 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1662 objfile_name (objfile
));
1663 printed_objfile_header
= 1;
1665 dump_psymtab (objfile
, ps
, outfile
);
1666 dump_psymtab_addrmap (objfile
, partial_symtabs
, ps
, outfile
);
1672 for (partial_symtab
*ps
: psf
->require_partial_symbols (objfile
))
1674 int print_for_source
= 0;
1677 if (source_arg
!= NULL
)
1680 = compare_filenames_for_search (ps
->filename
, source_arg
);
1683 if (source_arg
== NULL
1684 || print_for_source
)
1686 if (!printed_objfile_header
)
1688 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1689 objfile_name (objfile
));
1690 printed_objfile_header
= 1;
1692 dump_psymtab (objfile
, ps
, outfile
);
1693 dump_psymtab_addrmap (objfile
, partial_symtabs
, ps
,
1699 /* If we're printing all the objfile's symbols dump the full addrmap. */
1701 if (address_arg
== NULL
1702 && source_arg
== NULL
1703 && partial_symtabs
->psymtabs_addrmap
!= NULL
)
1705 outfile
->puts ("\n");
1706 dump_psymtab_addrmap (objfile
, partial_symtabs
, NULL
, outfile
);
1713 if (address_arg
!= NULL
)
1714 error (_("No partial symtab for address: %s"), address_arg
);
1715 if (source_arg
!= NULL
)
1716 error (_("No partial symtab for source file: %s"), source_arg
);
1720 /* List all the partial symbol tables whose names match REGEXP (optional). */
1723 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1728 for (struct program_space
*pspace
: program_spaces
)
1729 for (objfile
*objfile
: pspace
->objfiles ())
1731 struct gdbarch
*gdbarch
= objfile
->arch ();
1733 /* We don't want to print anything for this objfile until we
1734 actually find a symtab whose name matches. */
1735 int printed_objfile_start
= 0;
1737 for (const auto &iter
: objfile
->qf
)
1739 psymbol_functions
*psf
1740 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1743 for (partial_symtab
*psymtab
: psf
->require_partial_symbols (objfile
))
1748 || re_exec (psymtab
->filename
))
1750 if (! printed_objfile_start
)
1752 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
1754 printf_filtered ("((struct objfile *) %s)\n",
1755 host_address_to_string (objfile
));
1756 printed_objfile_start
= 1;
1759 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1761 printf_filtered ("((struct partial_symtab *) %s)\n",
1762 host_address_to_string (psymtab
));
1764 printf_filtered (" readin %s\n",
1765 psymtab
->readin_p (objfile
) ? "yes" : "no");
1766 printf_filtered (" fullname %s\n",
1768 ? psymtab
->fullname
: "(null)");
1769 printf_filtered (" text addresses ");
1770 fputs_filtered (paddress (gdbarch
,
1771 psymtab
->text_low (objfile
)),
1773 printf_filtered (" -- ");
1774 fputs_filtered (paddress (gdbarch
,
1775 psymtab
->text_high (objfile
)),
1777 printf_filtered ("\n");
1778 printf_filtered (" psymtabs_addrmap_supported %s\n",
1779 (psymtab
->psymtabs_addrmap_supported
1781 printf_filtered (" globals ");
1782 if (!psymtab
->global_psymbols
.empty ())
1784 ("(* (struct partial_symbol **) %s @ %d)\n",
1785 host_address_to_string (psymtab
->global_psymbols
.data ()),
1786 (int) psymtab
->global_psymbols
.size ());
1788 printf_filtered ("(none)\n");
1789 printf_filtered (" statics ");
1790 if (!psymtab
->static_psymbols
.empty ())
1792 ("(* (struct partial_symbol **) %s @ %d)\n",
1793 host_address_to_string (psymtab
->static_psymbols
.data ()),
1794 (int) psymtab
->static_psymbols
.size ());
1796 printf_filtered ("(none)\n");
1798 printf_filtered (" user %s "
1799 "((struct partial_symtab *) %s)\n",
1800 psymtab
->user
->filename
,
1801 host_address_to_string (psymtab
->user
));
1802 printf_filtered (" dependencies ");
1803 if (psymtab
->number_of_dependencies
)
1807 printf_filtered ("{\n");
1808 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1810 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
1812 /* Note the string concatenation there --- no
1814 printf_filtered (" psymtab %s "
1815 "((struct partial_symtab *) %s)\n",
1817 host_address_to_string (dep
));
1819 printf_filtered (" }\n");
1822 printf_filtered ("(none)\n");
1823 printf_filtered (" }\n");
1828 if (printed_objfile_start
)
1829 printf_filtered ("}\n");
1833 /* Check consistency of currently expanded psymtabs vs symtabs. */
1836 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
1839 struct compunit_symtab
*cust
= NULL
;
1840 const struct blockvector
*bv
;
1841 const struct block
*b
;
1843 for (objfile
*objfile
: current_program_space
->objfiles ())
1845 for (const auto &iter
: objfile
->qf
)
1847 psymbol_functions
*psf
1848 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1852 for (partial_symtab
*ps
: psf
->require_partial_symbols (objfile
))
1854 struct gdbarch
*gdbarch
= objfile
->arch ();
1856 /* We don't call psymtab_to_symtab here because that may cause symtab
1857 expansion. When debugging a problem it helps if checkers leave
1858 things unchanged. */
1859 cust
= ps
->get_compunit_symtab (objfile
);
1861 /* First do some checks that don't require the associated symtab. */
1862 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
1864 printf_filtered ("Psymtab ");
1865 puts_filtered (ps
->filename
);
1866 printf_filtered (" covers bad range ");
1867 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
1869 printf_filtered (" - ");
1870 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
1872 printf_filtered ("\n");
1876 /* Now do checks requiring the associated symtab. */
1879 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1880 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1881 for (partial_symbol
*psym
: ps
->static_psymbols
)
1883 /* Skip symbols for inlined functions without address. These may
1884 or may not have a match in the full symtab. */
1885 if (psym
->aclass
== LOC_BLOCK
1886 && psym
->ginfo
.value
.address
== 0)
1889 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1890 symbol_name_match_type::SEARCH_NAME
,
1894 printf_filtered ("Static symbol `");
1895 puts_filtered (psym
->ginfo
.linkage_name ());
1896 printf_filtered ("' only found in ");
1897 puts_filtered (ps
->filename
);
1898 printf_filtered (" psymtab\n");
1901 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1902 for (partial_symbol
*psym
: ps
->global_psymbols
)
1904 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1905 symbol_name_match_type::SEARCH_NAME
,
1909 printf_filtered ("Global symbol `");
1910 puts_filtered (psym
->ginfo
.linkage_name ());
1911 printf_filtered ("' only found in ");
1912 puts_filtered (ps
->filename
);
1913 printf_filtered (" psymtab\n");
1916 if (ps
->raw_text_high () != 0
1917 && (ps
->text_low (objfile
) < BLOCK_START (b
)
1918 || ps
->text_high (objfile
) > BLOCK_END (b
)))
1920 printf_filtered ("Psymtab ");
1921 puts_filtered (ps
->filename
);
1922 printf_filtered (" covers ");
1923 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
1925 printf_filtered (" - ");
1926 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
1928 printf_filtered (" but symtab covers only ");
1929 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
1930 printf_filtered (" - ");
1931 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
1932 printf_filtered ("\n");
1939 void _initialize_psymtab ();
1941 _initialize_psymtab ()
1943 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
1944 Print dump of current partial symbol definitions.\n\
1945 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
1946 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1947 Entries in the partial symbol table are dumped to file OUTFILE,\n\
1948 or the terminal if OUTFILE is unspecified.\n\
1949 If ADDRESS is provided, dump only the file for that address.\n\
1950 If SOURCE is provided, dump only that file's symbols.\n\
1951 If OBJFILE is provided, dump only that file's minimal symbols."),
1952 &maintenanceprintlist
);
1954 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
1955 List the partial symbol tables for all object files.\n\
1956 This does not include information about individual partial symbols,\n\
1957 just the symbol table structures themselves."),
1958 &maintenanceinfolist
);
1960 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
1962 Check consistency of currently expanded psymtabs versus symtabs."),