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 gdb_assert (symtab
!= nullptr);
1157 if (expansion_notify
!= NULL
)
1158 if (!expansion_notify (symtab
))
1166 /* Psymtab version of has_symbols. See its definition in
1167 the definition of quick_symbol_functions in symfile.h. */
1170 psymbol_functions::has_symbols (struct objfile
*objfile
)
1172 return m_partial_symtabs
->psymtabs
!= NULL
;
1175 /* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
1178 psymbol_functions::has_unexpanded_symtabs (struct objfile
*objfile
)
1180 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
))
1182 /* Is this already expanded? */
1183 if (psymtab
->readin_p (objfile
))
1186 /* It has not yet been expanded. */
1193 /* Helper function for psym_find_compunit_symtab_by_address that fills
1194 in m_psymbol_map for a given range of psymbols. */
1197 psymbol_functions::fill_psymbol_map
1198 (struct objfile
*objfile
,
1199 struct partial_symtab
*psymtab
,
1200 std::set
<CORE_ADDR
> *seen_addrs
,
1201 const std::vector
<partial_symbol
*> &symbols
)
1203 for (partial_symbol
*psym
: symbols
)
1205 if (psym
->aclass
== LOC_STATIC
)
1207 CORE_ADDR addr
= psym
->address (objfile
);
1208 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1210 seen_addrs
->insert (addr
);
1211 m_psymbol_map
.emplace_back (addr
, psymtab
);
1217 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1221 psymbol_functions::find_compunit_symtab_by_address (struct objfile
*objfile
,
1224 if (m_psymbol_map
.empty ())
1226 std::set
<CORE_ADDR
> seen_addrs
;
1228 for (partial_symtab
*pst
: require_partial_symbols (objfile
))
1230 fill_psymbol_map (objfile
, pst
,
1232 pst
->global_psymbols
);
1233 fill_psymbol_map (objfile
, pst
,
1235 pst
->static_psymbols
);
1238 m_psymbol_map
.shrink_to_fit ();
1240 std::sort (m_psymbol_map
.begin (), m_psymbol_map
.end (),
1241 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1242 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1244 return a
.first
< b
.first
;
1248 auto iter
= std::lower_bound
1249 (m_psymbol_map
.begin (), m_psymbol_map
.end (), address
,
1250 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1256 if (iter
== m_psymbol_map
.end () || iter
->first
!= address
)
1259 return psymtab_to_symtab (objfile
, iter
->second
);
1264 /* Partially fill a partial symtab. It will be completely filled at
1265 the end of the symbol list. */
1267 partial_symtab::partial_symtab (const char *filename
,
1268 psymtab_storage
*partial_symtabs
,
1269 objfile_per_bfd_storage
*objfile_per_bfd
,
1271 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
1273 set_text_low (textlow
);
1274 set_text_high (raw_text_low ()); /* default */
1277 /* Perform "finishing up" operations of a partial symtab. */
1280 partial_symtab::end ()
1282 global_psymbols
.shrink_to_fit ();
1283 static_psymbols
.shrink_to_fit ();
1285 /* Sort the global list; don't sort the static list. */
1286 std::sort (global_psymbols
.begin (),
1287 global_psymbols
.end (),
1288 [] (partial_symbol
*s1
, partial_symbol
*s2
)
1290 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1291 s2
->ginfo
.search_name ()) < 0;
1295 /* See psymtab.h. */
1298 psymbol_bcache::hash (const void *addr
, int length
)
1300 unsigned long h
= 0;
1301 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1302 unsigned int lang
= psymbol
->ginfo
.language ();
1303 unsigned int domain
= psymbol
->domain
;
1304 unsigned int theclass
= psymbol
->aclass
;
1306 h
= fast_hash (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1307 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1308 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1309 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1310 /* Note that psymbol names are interned via compute_and_set_names, so
1311 there's no need to hash the contents of the name here. */
1312 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1317 /* See psymtab.h. */
1320 psymbol_bcache::compare (const void *addr1
, const void *addr2
, int length
)
1322 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1323 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1325 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1326 sizeof (sym1
->ginfo
.value
)) == 0
1327 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1328 && sym1
->domain
== sym2
->domain
1329 && sym1
->aclass
== sym2
->aclass
1330 /* Note that psymbol names are interned via
1331 compute_and_set_names, so there's no need to compare the
1332 contents of the name here. */
1333 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1336 /* See psympriv.h. */
1339 partial_symtab::add_psymbol (const partial_symbol
&psymbol
,
1340 psymbol_placement where
,
1341 psymtab_storage
*partial_symtabs
,
1342 struct objfile
*objfile
)
1346 /* Stash the partial symbol away in the cache. */
1347 partial_symbol
*psym
1348 = ((struct partial_symbol
*)
1349 partial_symtabs
->psymbol_cache
.insert
1350 (&psymbol
, sizeof (struct partial_symbol
), &added
));
1352 /* Do not duplicate global partial symbols. */
1353 if (where
== psymbol_placement::GLOBAL
&& !added
)
1356 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1357 std::vector
<partial_symbol
*> &list
1358 = (where
== psymbol_placement::STATIC
1361 list
.push_back (psym
);
1364 /* See psympriv.h. */
1367 partial_symtab::add_psymbol (gdb::string_view name
, bool copy_name
,
1369 enum address_class theclass
,
1371 psymbol_placement where
,
1373 enum language language
,
1374 psymtab_storage
*partial_symtabs
,
1375 struct objfile
*objfile
)
1377 struct partial_symbol psymbol
;
1378 memset (&psymbol
, 0, sizeof (psymbol
));
1380 psymbol
.set_unrelocated_address (coreaddr
);
1381 psymbol
.ginfo
.set_section_index (section
);
1382 psymbol
.domain
= domain
;
1383 psymbol
.aclass
= theclass
;
1384 psymbol
.ginfo
.set_language (language
, partial_symtabs
->obstack ());
1385 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1387 add_psymbol (psymbol
, where
, partial_symtabs
, objfile
);
1390 /* See psympriv.h. */
1392 partial_symtab::partial_symtab (const char *filename_
,
1393 psymtab_storage
*partial_symtabs
,
1394 objfile_per_bfd_storage
*objfile_per_bfd
)
1395 : searched_flag (PST_NOT_SEARCHED
),
1399 partial_symtabs
->install_psymtab (this);
1401 filename
= objfile_per_bfd
->intern (filename_
);
1403 if (symtab_create_debug
)
1405 /* Be a bit clever with debugging messages, and don't print objfile
1406 every time, only when it changes. */
1407 static std::string last_bfd_name
;
1408 const char *this_bfd_name
1409 = bfd_get_filename (objfile_per_bfd
->get_bfd ());
1411 if (last_bfd_name
.empty () || last_bfd_name
!= this_bfd_name
)
1413 last_bfd_name
= this_bfd_name
;
1414 fprintf_filtered (gdb_stdlog
,
1415 "Creating one or more psymtabs for %s ...\n",
1418 fprintf_filtered (gdb_stdlog
,
1419 "Created psymtab %s for module %s.\n",
1420 host_address_to_string (this), filename
);
1424 /* See psympriv.h. */
1427 partial_symtab::expand_dependencies (struct objfile
*objfile
)
1429 for (int i
= 0; i
< number_of_dependencies
; ++i
)
1431 if (!dependencies
[i
]->readin_p (objfile
)
1432 && dependencies
[i
]->user
== NULL
)
1434 /* Inform about additional files to be read in. */
1437 fputs_filtered (" ", gdb_stdout
);
1439 fputs_filtered ("and ", gdb_stdout
);
1441 printf_filtered ("%s...", dependencies
[i
]->filename
);
1442 wrap_here (""); /* Flush output */
1443 gdb_flush (gdb_stdout
);
1445 dependencies
[i
]->expand_psymtab (objfile
);
1452 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1454 struct partial_symtab
**prev_pst
;
1457 Empty psymtabs happen as a result of header files which don't
1458 have any symbols in them. There can be a lot of them. But this
1459 check is wrong, in that a psymtab with N_SLINE entries but
1460 nothing else is not empty, but we don't realize that. Fixing
1461 that without slowing things down might be tricky. */
1463 /* First, snip it out of the psymtab chain. */
1465 prev_pst
= &psymtabs
;
1466 while ((*prev_pst
) != pst
)
1467 prev_pst
= &((*prev_pst
)->next
);
1468 (*prev_pst
) = pst
->next
;
1474 /* Helper function for maintenance_print_psymbols to print the addrmap
1475 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1478 dump_psymtab_addrmap (struct objfile
*objfile
,
1479 psymtab_storage
*partial_symtabs
,
1480 struct partial_symtab
*psymtab
,
1481 struct ui_file
*outfile
)
1483 if ((psymtab
== NULL
1484 || psymtab
->psymtabs_addrmap_supported
)
1485 && partial_symtabs
->psymtabs_addrmap
!= NULL
)
1487 if (psymtab
== nullptr)
1488 fprintf_filtered (outfile
, _("Entire address map:\n"));
1490 fprintf_filtered (outfile
, _("Address map:\n"));
1491 addrmap_dump (partial_symtabs
->psymtabs_addrmap
, outfile
, psymtab
);
1496 maintenance_print_psymbols (const char *args
, int from_tty
)
1498 struct ui_file
*outfile
= gdb_stdout
;
1499 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1500 int i
, outfile_idx
, found
;
1502 struct obj_section
*section
= NULL
;
1506 gdb_argv
argv (args
);
1508 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1510 if (strcmp (argv
[i
], "-pc") == 0)
1512 if (argv
[i
+ 1] == NULL
)
1513 error (_("Missing pc value"));
1514 address_arg
= argv
[++i
];
1516 else if (strcmp (argv
[i
], "-source") == 0)
1518 if (argv
[i
+ 1] == NULL
)
1519 error (_("Missing source file"));
1520 source_arg
= argv
[++i
];
1522 else if (strcmp (argv
[i
], "-objfile") == 0)
1524 if (argv
[i
+ 1] == NULL
)
1525 error (_("Missing objfile name"));
1526 objfile_arg
= argv
[++i
];
1528 else if (strcmp (argv
[i
], "--") == 0)
1530 /* End of options. */
1534 else if (argv
[i
][0] == '-')
1536 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1537 error (_("Unknown option: %s"), argv
[i
]);
1544 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1545 error (_("Must specify at most one of -pc and -source"));
1547 stdio_file arg_outfile
;
1549 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1551 if (argv
[outfile_idx
+ 1] != NULL
)
1552 error (_("Junk at end of command"));
1553 gdb::unique_xmalloc_ptr
<char> outfile_name
1554 (tilde_expand (argv
[outfile_idx
]));
1555 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1556 perror_with_name (outfile_name
.get ());
1557 outfile
= &arg_outfile
;
1560 if (address_arg
!= NULL
)
1562 pc
= parse_and_eval_address (address_arg
);
1563 /* If we fail to find a section, that's ok, try the lookup anyway. */
1564 section
= find_pc_section (pc
);
1568 for (objfile
*objfile
: current_program_space
->objfiles ())
1570 int printed_objfile_header
= 0;
1571 int print_for_objfile
= 1;
1574 if (objfile_arg
!= NULL
)
1576 = compare_filenames_for_search (objfile_name (objfile
),
1578 if (!print_for_objfile
)
1581 for (const auto &iter
: objfile
->qf
)
1583 psymbol_functions
*psf
1584 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1588 psymtab_storage
*partial_symtabs
1589 = psf
->get_partial_symtabs ().get ();
1591 if (address_arg
!= NULL
)
1593 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1595 /* We don't assume each pc has a unique objfile (this is for
1597 struct partial_symtab
*ps
1598 = psf
->find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1601 if (!printed_objfile_header
)
1603 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1604 objfile_name (objfile
));
1605 printed_objfile_header
= 1;
1607 dump_psymtab (objfile
, ps
, outfile
);
1608 dump_psymtab_addrmap (objfile
, partial_symtabs
, ps
, outfile
);
1614 for (partial_symtab
*ps
: psf
->require_partial_symbols (objfile
))
1616 int print_for_source
= 0;
1619 if (source_arg
!= NULL
)
1622 = compare_filenames_for_search (ps
->filename
, source_arg
);
1625 if (source_arg
== NULL
1626 || print_for_source
)
1628 if (!printed_objfile_header
)
1630 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1631 objfile_name (objfile
));
1632 printed_objfile_header
= 1;
1634 dump_psymtab (objfile
, ps
, outfile
);
1635 dump_psymtab_addrmap (objfile
, partial_symtabs
, ps
,
1641 /* If we're printing all the objfile's symbols dump the full addrmap. */
1643 if (address_arg
== NULL
1644 && source_arg
== NULL
1645 && partial_symtabs
->psymtabs_addrmap
!= NULL
)
1647 outfile
->puts ("\n");
1648 dump_psymtab_addrmap (objfile
, partial_symtabs
, NULL
, outfile
);
1655 if (address_arg
!= NULL
)
1656 error (_("No partial symtab for address: %s"), address_arg
);
1657 if (source_arg
!= NULL
)
1658 error (_("No partial symtab for source file: %s"), source_arg
);
1662 /* List all the partial symbol tables whose names match REGEXP (optional). */
1665 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1670 for (struct program_space
*pspace
: program_spaces
)
1671 for (objfile
*objfile
: pspace
->objfiles ())
1673 struct gdbarch
*gdbarch
= objfile
->arch ();
1675 /* We don't want to print anything for this objfile until we
1676 actually find a symtab whose name matches. */
1677 int printed_objfile_start
= 0;
1679 for (const auto &iter
: objfile
->qf
)
1681 psymbol_functions
*psf
1682 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1685 for (partial_symtab
*psymtab
: psf
->require_partial_symbols (objfile
))
1690 || re_exec (psymtab
->filename
))
1692 if (! printed_objfile_start
)
1694 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
1696 printf_filtered ("((struct objfile *) %s)\n",
1697 host_address_to_string (objfile
));
1698 printed_objfile_start
= 1;
1701 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1703 printf_filtered ("((struct partial_symtab *) %s)\n",
1704 host_address_to_string (psymtab
));
1706 printf_filtered (" readin %s\n",
1707 psymtab
->readin_p (objfile
) ? "yes" : "no");
1708 printf_filtered (" fullname %s\n",
1710 ? psymtab
->fullname
: "(null)");
1711 printf_filtered (" text addresses ");
1712 fputs_filtered (paddress (gdbarch
,
1713 psymtab
->text_low (objfile
)),
1715 printf_filtered (" -- ");
1716 fputs_filtered (paddress (gdbarch
,
1717 psymtab
->text_high (objfile
)),
1719 printf_filtered ("\n");
1720 printf_filtered (" psymtabs_addrmap_supported %s\n",
1721 (psymtab
->psymtabs_addrmap_supported
1723 printf_filtered (" globals ");
1724 if (!psymtab
->global_psymbols
.empty ())
1726 ("(* (struct partial_symbol **) %s @ %d)\n",
1727 host_address_to_string (psymtab
->global_psymbols
.data ()),
1728 (int) psymtab
->global_psymbols
.size ());
1730 printf_filtered ("(none)\n");
1731 printf_filtered (" statics ");
1732 if (!psymtab
->static_psymbols
.empty ())
1734 ("(* (struct partial_symbol **) %s @ %d)\n",
1735 host_address_to_string (psymtab
->static_psymbols
.data ()),
1736 (int) psymtab
->static_psymbols
.size ());
1738 printf_filtered ("(none)\n");
1740 printf_filtered (" user %s "
1741 "((struct partial_symtab *) %s)\n",
1742 psymtab
->user
->filename
,
1743 host_address_to_string (psymtab
->user
));
1744 printf_filtered (" dependencies ");
1745 if (psymtab
->number_of_dependencies
)
1749 printf_filtered ("{\n");
1750 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1752 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
1754 /* Note the string concatenation there --- no
1756 printf_filtered (" psymtab %s "
1757 "((struct partial_symtab *) %s)\n",
1759 host_address_to_string (dep
));
1761 printf_filtered (" }\n");
1764 printf_filtered ("(none)\n");
1765 printf_filtered (" }\n");
1770 if (printed_objfile_start
)
1771 printf_filtered ("}\n");
1775 /* Check consistency of currently expanded psymtabs vs symtabs. */
1778 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
1781 struct compunit_symtab
*cust
= NULL
;
1782 const struct blockvector
*bv
;
1783 const struct block
*b
;
1785 for (objfile
*objfile
: current_program_space
->objfiles ())
1787 for (const auto &iter
: objfile
->qf
)
1789 psymbol_functions
*psf
1790 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1794 for (partial_symtab
*ps
: psf
->require_partial_symbols (objfile
))
1796 struct gdbarch
*gdbarch
= objfile
->arch ();
1798 /* We don't call psymtab_to_symtab here because that may cause symtab
1799 expansion. When debugging a problem it helps if checkers leave
1800 things unchanged. */
1801 cust
= ps
->get_compunit_symtab (objfile
);
1803 /* First do some checks that don't require the associated symtab. */
1804 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
1806 printf_filtered ("Psymtab ");
1807 puts_filtered (ps
->filename
);
1808 printf_filtered (" covers bad range ");
1809 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
1811 printf_filtered (" - ");
1812 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
1814 printf_filtered ("\n");
1818 /* Now do checks requiring the associated symtab. */
1821 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1822 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1823 for (partial_symbol
*psym
: ps
->static_psymbols
)
1825 /* Skip symbols for inlined functions without address. These may
1826 or may not have a match in the full symtab. */
1827 if (psym
->aclass
== LOC_BLOCK
1828 && psym
->ginfo
.value
.address
== 0)
1831 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1832 symbol_name_match_type::SEARCH_NAME
,
1836 printf_filtered ("Static symbol `");
1837 puts_filtered (psym
->ginfo
.linkage_name ());
1838 printf_filtered ("' only found in ");
1839 puts_filtered (ps
->filename
);
1840 printf_filtered (" psymtab\n");
1843 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1844 for (partial_symbol
*psym
: ps
->global_psymbols
)
1846 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1847 symbol_name_match_type::SEARCH_NAME
,
1851 printf_filtered ("Global symbol `");
1852 puts_filtered (psym
->ginfo
.linkage_name ());
1853 printf_filtered ("' only found in ");
1854 puts_filtered (ps
->filename
);
1855 printf_filtered (" psymtab\n");
1858 if (ps
->raw_text_high () != 0
1859 && (ps
->text_low (objfile
) < BLOCK_START (b
)
1860 || ps
->text_high (objfile
) > BLOCK_END (b
)))
1862 printf_filtered ("Psymtab ");
1863 puts_filtered (ps
->filename
);
1864 printf_filtered (" covers ");
1865 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
1867 printf_filtered (" - ");
1868 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
1870 printf_filtered (" but symtab covers only ");
1871 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
1872 printf_filtered (" - ");
1873 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
1874 printf_filtered ("\n");
1881 void _initialize_psymtab ();
1883 _initialize_psymtab ()
1885 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
1886 Print dump of current partial symbol definitions.\n\
1887 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
1888 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1889 Entries in the partial symbol table are dumped to file OUTFILE,\n\
1890 or the terminal if OUTFILE is unspecified.\n\
1891 If ADDRESS is provided, dump only the file for that address.\n\
1892 If SOURCE is provided, dump only that file's symbols.\n\
1893 If OBJFILE is provided, dump only that file's minimal symbols."),
1894 &maintenanceprintlist
);
1896 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
1897 List the partial symbol tables for all object files.\n\
1898 This does not include information about individual partial symbols,\n\
1899 just the symbol table structures themselves."),
1900 &maintenanceinfolist
);
1902 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
1904 Check consistency of currently expanded psymtabs versus symtabs."),