1 /* Partial symbol tables.
3 Copyright (C) 2009-2023 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 "gdbsupport/gdb_regex.h"
33 #include "dictionary.h"
35 #include "cp-support.h"
39 #include "gdbsupport/buildargv.h"
41 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
42 struct partial_symtab
*,
43 const lookup_name_info
&,
47 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
49 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
50 struct partial_symtab
*,
52 struct obj_section
*);
54 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
55 struct partial_symtab
*pst
);
57 psymtab_storage::~psymtab_storage ()
59 partial_symtab
*iter
= psymtabs
;
60 while (iter
!= nullptr)
62 partial_symtab
*next
= iter
->next
;
71 psymtab_storage::install_psymtab (partial_symtab
*pst
)
81 psymtab_storage::partial_symtab_range
82 psymbol_functions::partial_symbols (struct objfile
*objfile
)
84 gdb_assert ((objfile
->flags
& OBJF_PSYMTABS_READ
) != 0);
85 return m_partial_symtabs
->range ();
88 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
89 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
91 static struct partial_symtab
*
92 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
93 CORE_ADDR pc
, struct obj_section
*section
,
94 struct partial_symtab
*pst
,
95 struct bound_minimal_symbol msymbol
)
97 struct partial_symtab
*tpst
;
98 struct partial_symtab
*best_pst
= pst
;
99 CORE_ADDR best_addr
= pst
->text_low (objfile
);
101 /* An objfile that has its functions reordered might have
102 many partial symbol tables containing the PC, but
103 we want the partial symbol table that contains the
104 function containing the PC. */
105 if (section
== nullptr)
108 if (msymbol
.minsym
== NULL
)
111 /* The code range of partial symtabs sometimes overlap, so, in
112 the loop below, we need to check all partial symtabs and
113 find the one that fits better for the given PC address. We
114 select the partial symtab that contains a symbol whose
115 address is closest to the PC address. By closest we mean
116 that find_pc_sect_symbol returns the symbol with address
117 that is closest and still less than the given PC. */
118 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
120 if (pc
>= tpst
->text_low (objfile
) && pc
< tpst
->text_high (objfile
))
122 struct partial_symbol
*p
;
125 /* NOTE: This assumes that every psymbol has a
126 corresponding msymbol, which is not necessarily
127 true; the debug info might be much richer than the
128 object's symbol table. */
129 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
131 && (p
->address (objfile
) == msymbol
.value_address ()))
134 /* Also accept the textlow value of a psymtab as a
135 "symbol", to provide some support for partial
136 symbol tables with line information but no debug
137 symbols (e.g. those produced by an assembler). */
139 this_addr
= p
->address (objfile
);
141 this_addr
= tpst
->text_low (objfile
);
143 /* Check whether it is closer than our current
144 BEST_ADDR. Since this symbol address is
145 necessarily lower or equal to PC, the symbol closer
146 to PC is the symbol which address is the highest.
147 This way we return the psymtab which contains such
148 best match symbol. This can help in cases where the
149 symbol information/debuginfo is not complete, like
150 for instance on IRIX6 with gcc, where no debug info
151 is emitted for statics. (See also the nodebug.exp
153 if (this_addr
> best_addr
)
155 best_addr
= this_addr
;
163 /* See psympriv.h. */
165 struct partial_symtab
*
166 psymbol_functions::find_pc_sect_psymtab (struct objfile
*objfile
,
168 struct obj_section
*section
,
169 struct bound_minimal_symbol msymbol
)
171 for (partial_symtab
*pst
: partial_symbols (objfile
))
172 if (pc
>= pst
->text_low (objfile
) && pc
< pst
->text_high (objfile
))
174 struct partial_symtab
*best_pst
;
176 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
178 if (best_pst
!= NULL
)
185 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
186 the definition of quick_symbol_functions in symfile.h. */
188 struct compunit_symtab
*
189 psymbol_functions::find_pc_sect_compunit_symtab
190 (struct objfile
*objfile
,
191 struct bound_minimal_symbol msymbol
,
193 struct obj_section
*section
,
196 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
,
201 if (warn_if_readin
&& ps
->readin_p (objfile
))
202 /* Might want to error() here (in case symtab is corrupt and
203 will cause a core dump), but maybe we can successfully
204 continue, so let's not. */
206 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
207 paddress (objfile
->arch (), pc
));
208 psymtab_to_symtab (objfile
, ps
);
209 return ps
->get_compunit_symtab (objfile
);
214 /* Find which partial symbol within a psymtab matches PC and SECTION.
215 Return NULL if none. */
217 static struct partial_symbol
*
218 find_pc_sect_psymbol (struct objfile
*objfile
,
219 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
220 struct obj_section
*section
)
222 struct partial_symbol
*best
= NULL
;
224 const CORE_ADDR textlow
= psymtab
->text_low (objfile
);
226 gdb_assert (psymtab
!= NULL
);
228 /* Cope with programs that start at address 0. */
229 best_pc
= (textlow
!= 0) ? textlow
- 1 : 0;
231 /* Search the global symbols as well as the static symbols, so that
232 find_pc_partial_function doesn't use a minimal symbol and thus
233 cache a bad endaddr. */
234 for (partial_symbol
*p
: psymtab
->global_psymbols
)
236 if (p
->domain
== VAR_DOMAIN
237 && p
->aclass
== LOC_BLOCK
238 && pc
>= p
->address (objfile
)
239 && (p
->address (objfile
) > best_pc
240 || (psymtab
->text_low (objfile
) == 0
241 && best_pc
== 0 && p
->address (objfile
) == 0)))
243 if (section
!= NULL
) /* Match on a specific section. */
245 if (!matching_obj_sections (p
->obj_section (objfile
),
249 best_pc
= p
->address (objfile
);
254 for (partial_symbol
*p
: psymtab
->static_psymbols
)
256 if (p
->domain
== VAR_DOMAIN
257 && p
->aclass
== LOC_BLOCK
258 && pc
>= p
->address (objfile
)
259 && (p
->address (objfile
) > best_pc
260 || (psymtab
->text_low (objfile
) == 0
261 && best_pc
== 0 && p
->address (objfile
) == 0)))
263 if (section
!= NULL
) /* Match on a specific section. */
265 if (!matching_obj_sections (p
->obj_section (objfile
),
269 best_pc
= p
->address (objfile
);
277 /* Psymtab version of lookup_global_symbol_language. See its definition in
278 the definition of quick_symbol_functions in symfile.h. */
281 psymbol_functions::lookup_global_symbol_language (struct objfile
*objfile
,
284 bool *symbol_found_p
)
286 *symbol_found_p
= false;
287 if (objfile
->sf
== NULL
)
288 return language_unknown
;
290 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
292 for (partial_symtab
*ps
: partial_symbols (objfile
))
294 struct partial_symbol
*psym
;
295 if (ps
->readin_p (objfile
))
298 psym
= lookup_partial_symbol (objfile
, ps
, lookup_name
, 1, domain
);
301 *symbol_found_p
= true;
302 return psym
->ginfo
.language ();
306 return language_unknown
;
309 /* Returns true if PSYM matches LOOKUP_NAME. */
312 psymbol_name_matches (partial_symbol
*psym
,
313 const lookup_name_info
&lookup_name
)
315 const language_defn
*lang
= language_def (psym
->ginfo
.language ());
316 symbol_name_matcher_ftype
*name_match
317 = lang
->get_symbol_name_matcher (lookup_name
);
318 return name_match (psym
->ginfo
.search_name (), lookup_name
, NULL
);
321 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
322 the global block of PST if GLOBAL, and otherwise the static block.
323 MATCH is the comparison operation that returns true iff MATCH (s,
324 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
325 non-null, the symbols in the block are assumed to be ordered
326 according to it (allowing binary search). It must be compatible
327 with MATCH. Returns the symbol, if found, and otherwise NULL. */
329 static struct partial_symbol
*
330 match_partial_symbol (struct objfile
*objfile
,
331 struct partial_symtab
*pst
, int global
,
332 const lookup_name_info
&name
, domain_enum domain
,
333 symbol_compare_ftype
*ordered_compare
)
335 struct partial_symbol
**start
, **psym
;
336 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
338 ? pst
->global_psymbols
.size ()
339 : pst
->static_psymbols
.size ());
340 int do_linear_search
= 1;
346 &pst
->global_psymbols
[0] :
347 &pst
->static_psymbols
[0]);
349 if (global
&& ordered_compare
) /* Can use a binary search. */
351 do_linear_search
= 0;
353 /* Binary search. This search is guaranteed to end with center
354 pointing at the earliest partial symbol whose name might be
355 correct. At that point *all* partial symbols with an
356 appropriate name will be checked against the correct
360 top
= start
+ length
- 1;
364 center
= bottom
+ (top
- bottom
) / 2;
365 gdb_assert (center
< top
);
367 enum language lang
= (*center
)->ginfo
.language ();
368 const char *lang_ln
= name
.language_lookup_name (lang
);
370 if (ordered_compare ((*center
)->ginfo
.search_name (),
376 gdb_assert (top
== bottom
);
378 while (top
<= real_top
379 && psymbol_name_matches (*top
, name
))
381 if (symbol_matches_domain ((*top
)->ginfo
.language (),
382 (*top
)->domain
, domain
))
388 /* Can't use a binary search or else we found during the binary search that
389 we should also do a linear search. */
391 if (do_linear_search
)
393 for (psym
= start
; psym
< start
+ length
; psym
++)
395 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
396 (*psym
)->domain
, domain
)
397 && psymbol_name_matches (*psym
, name
))
405 /* Look, in partial_symtab PST, for symbol whose natural name is
406 LOOKUP_NAME. Check the global symbols if GLOBAL, the static
409 static struct partial_symbol
*
410 lookup_partial_symbol (struct objfile
*objfile
,
411 struct partial_symtab
*pst
,
412 const lookup_name_info
&lookup_name
,
413 int global
, domain_enum domain
)
415 struct partial_symbol
**start
, **psym
;
416 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
418 ? pst
->global_psymbols
.size ()
419 : pst
->static_psymbols
.size ());
420 int do_linear_search
= 1;
426 &pst
->global_psymbols
[0] :
427 &pst
->static_psymbols
[0]);
429 if (global
) /* This means we can use a binary search. */
431 do_linear_search
= 0;
433 /* Binary search. This search is guaranteed to end with center
434 pointing at the earliest partial symbol whose name might be
435 correct. At that point *all* partial symbols with an
436 appropriate name will be checked against the correct
440 top
= start
+ length
- 1;
444 center
= bottom
+ (top
- bottom
) / 2;
446 gdb_assert (center
< top
);
448 if (strcmp_iw_ordered ((*center
)->ginfo
.search_name (),
449 lookup_name
.c_str ()) >= 0)
459 gdb_assert (top
== bottom
);
461 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
462 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
463 while (top
>= start
&& symbol_matches_search_name (&(*top
)->ginfo
,
467 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
470 while (top
<= real_top
&& symbol_matches_search_name (&(*top
)->ginfo
,
473 if (symbol_matches_domain ((*top
)->ginfo
.language (),
474 (*top
)->domain
, domain
))
480 /* Can't use a binary search or else we found during the binary search that
481 we should also do a linear search. */
483 if (do_linear_search
)
485 for (psym
= start
; psym
< start
+ length
; psym
++)
487 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
488 (*psym
)->domain
, domain
)
489 && symbol_matches_search_name (&(*psym
)->ginfo
, lookup_name
))
497 /* Get the symbol table that corresponds to a partial_symtab.
498 This is fast after the first time you do it.
499 The result will be NULL if the primary symtab has no symbols,
500 which can happen. Otherwise the result is the primary symtab
501 that contains PST. */
503 static struct compunit_symtab
*
504 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
506 /* If it is a shared psymtab, find an unshared psymtab that includes
507 it. Any such psymtab will do. */
508 while (pst
->user
!= NULL
)
511 /* If it's been looked up before, return it. */
512 if (pst
->get_compunit_symtab (objfile
))
513 return pst
->get_compunit_symtab (objfile
);
515 /* If it has not yet been read in, read it. */
516 if (!pst
->readin_p (objfile
))
518 scoped_restore decrementer
= increment_reading_symtab ();
522 gdb_printf (_("Reading in symbols for %s...\n"),
524 gdb_flush (gdb_stdout
);
527 pst
->read_symtab (objfile
);
530 return pst
->get_compunit_symtab (objfile
);
533 /* Psymtab version of find_last_source_symtab. See its definition in
534 the definition of quick_symbol_functions in symfile.h. */
537 psymbol_functions::find_last_source_symtab (struct objfile
*ofp
)
539 struct partial_symtab
*cs_pst
= NULL
;
541 for (partial_symtab
*ps
: partial_symbols (ofp
))
543 const char *name
= ps
->filename
;
544 int len
= strlen (name
);
546 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
547 || strcmp (name
, "<<C++-namespaces>>") == 0)))
553 if (cs_pst
->readin_p (ofp
))
555 internal_error (_("select_source_symtab: "
556 "readin pst found and no symtabs."));
560 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
564 return cust
->primary_filetab ();
570 /* Psymtab version of forget_cached_source_info. See its definition in
571 the definition of quick_symbol_functions in symfile.h. */
574 psymbol_functions::forget_cached_source_info (struct objfile
*objfile
)
576 for (partial_symtab
*pst
: partial_symbols (objfile
))
578 if (pst
->fullname
!= NULL
)
580 xfree (pst
->fullname
);
581 pst
->fullname
= NULL
;
587 print_partial_symbols (struct gdbarch
*gdbarch
, struct objfile
*objfile
,
588 const std::vector
<partial_symbol
*> &symbols
,
589 const char *what
, struct ui_file
*outfile
)
591 gdb_printf (outfile
, " %s partial symbols:\n", what
);
592 for (partial_symbol
*p
: symbols
)
595 gdb_printf (outfile
, " `%s'", p
->ginfo
.linkage_name ());
596 if (p
->ginfo
.demangled_name () != NULL
)
598 gdb_printf (outfile
, " `%s'",
599 p
->ginfo
.demangled_name ());
601 gdb_puts (", ", outfile
);
605 gdb_puts ("undefined domain, ", outfile
);
608 /* This is the usual thing -- don't print it. */
611 gdb_puts ("struct domain, ", outfile
);
614 gdb_puts ("module domain, ", outfile
);
617 gdb_puts ("label domain, ", outfile
);
619 case COMMON_BLOCK_DOMAIN
:
620 gdb_puts ("common block domain, ", outfile
);
623 gdb_puts ("<invalid domain>, ", outfile
);
629 gdb_puts ("undefined", outfile
);
632 gdb_puts ("constant int", outfile
);
635 gdb_puts ("static", outfile
);
638 gdb_puts ("register", outfile
);
641 gdb_puts ("pass by value", outfile
);
644 gdb_puts ("pass by reference", outfile
);
646 case LOC_REGPARM_ADDR
:
647 gdb_puts ("register address parameter", outfile
);
650 gdb_puts ("stack parameter", outfile
);
653 gdb_puts ("type", outfile
);
656 gdb_puts ("label", outfile
);
659 gdb_puts ("function", outfile
);
661 case LOC_CONST_BYTES
:
662 gdb_puts ("constant bytes", outfile
);
665 gdb_puts ("unresolved", outfile
);
667 case LOC_OPTIMIZED_OUT
:
668 gdb_puts ("optimized out", outfile
);
671 gdb_puts ("computed at runtime", outfile
);
674 gdb_puts ("<invalid location>", outfile
);
677 gdb_puts (", ", outfile
);
678 gdb_puts (paddress (gdbarch
, CORE_ADDR (p
->unrelocated_address ())),
680 gdb_printf (outfile
, "\n");
685 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
686 struct ui_file
*outfile
)
688 struct gdbarch
*gdbarch
= objfile
->arch ();
691 if (psymtab
->anonymous
)
693 gdb_printf (outfile
, "\nAnonymous partial symtab (%s) ",
698 gdb_printf (outfile
, "\nPartial symtab for source file %s ",
701 gdb_printf (outfile
, "(object %s)\n\n",
702 host_address_to_string (psymtab
));
703 gdb_printf (outfile
, " Read from object file %s (%s)\n",
704 objfile_name (objfile
),
705 host_address_to_string (objfile
));
707 if (psymtab
->readin_p (objfile
))
710 " Full symtab was read (at %s)\n",
711 host_address_to_string (psymtab
->get_compunit_symtab (objfile
)));
713 gdb_printf (outfile
, " Symbols cover text addresses ");
714 gdb_puts (paddress (gdbarch
, psymtab
->text_low (objfile
)), outfile
);
715 gdb_printf (outfile
, "-");
716 gdb_puts (paddress (gdbarch
, psymtab
->text_high (objfile
)), outfile
);
717 gdb_printf (outfile
, "\n");
718 gdb_printf (outfile
, " Depends on %d other partial symtabs.\n",
719 psymtab
->number_of_dependencies
);
720 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
721 gdb_printf (outfile
, " %d %s\n", i
,
722 host_address_to_string (psymtab
->dependencies
[i
]));
723 if (psymtab
->user
!= NULL
)
724 gdb_printf (outfile
, " Shared partial symtab with user %s\n",
725 host_address_to_string (psymtab
->user
));
726 if (!psymtab
->global_psymbols
.empty ())
728 print_partial_symbols
729 (gdbarch
, objfile
, psymtab
->global_psymbols
,
732 if (!psymtab
->static_psymbols
.empty ())
734 print_partial_symbols
735 (gdbarch
, objfile
, psymtab
->static_psymbols
,
738 gdb_printf (outfile
, "\n");
741 /* Count the number of partial symbols in OBJFILE. */
744 psymbol_functions::count_psyms ()
747 for (partial_symtab
*pst
: m_partial_symtabs
->range ())
749 count
+= pst
->global_psymbols
.size ();
750 count
+= pst
->static_psymbols
.size ();
755 /* Psymtab version of print_stats. See its definition in
756 the definition of quick_symbol_functions in symfile.h. */
759 psymbol_functions::print_stats (struct objfile
*objfile
, bool print_bcache
)
765 int n_psyms
= count_psyms ();
767 gdb_printf (_(" Number of \"partial\" symbols read: %d\n"),
771 for (partial_symtab
*ps
: partial_symbols (objfile
))
773 if (!ps
->readin_p (objfile
))
776 gdb_printf (_(" Number of psym tables (not yet expanded): %d\n"),
778 gdb_printf (_(" Total memory used for psymbol cache: %d\n"),
779 m_partial_symtabs
->psymbol_cache
.memory_used ());
783 gdb_printf (_("Psymbol byte cache statistics:\n"));
784 m_partial_symtabs
->psymbol_cache
.print_statistics
785 ("partial symbol cache");
789 /* Psymtab version of dump. See its definition in
790 the definition of quick_symbol_functions in symfile.h. */
793 psymbol_functions::dump (struct objfile
*objfile
)
795 struct partial_symtab
*psymtab
;
797 if (m_partial_symtabs
->psymtabs
)
799 gdb_printf ("Psymtabs:\n");
800 for (psymtab
= m_partial_symtabs
->psymtabs
;
802 psymtab
= psymtab
->next
)
803 gdb_printf ("%s at %s\n",
805 host_address_to_string (psymtab
));
810 /* Psymtab version of expand_all_symtabs. See its definition in
811 the definition of quick_symbol_functions in symfile.h. */
814 psymbol_functions::expand_all_symtabs (struct objfile
*objfile
)
816 for (partial_symtab
*psymtab
: partial_symbols (objfile
))
817 psymtab_to_symtab (objfile
, psymtab
);
820 /* Psymtab version of map_symbol_filenames. See its definition in
821 the definition of quick_symbol_functions in symfile.h. */
824 psymbol_functions::map_symbol_filenames
825 (struct objfile
*objfile
,
826 gdb::function_view
<symbol_filename_ftype
> fun
,
829 for (partial_symtab
*ps
: partial_symbols (objfile
))
831 const char *fullname
;
833 if (ps
->readin_p (objfile
))
836 /* We can skip shared psymtabs here, because any file name will be
837 attached to the unshared psymtab. */
838 if (ps
->user
!= NULL
)
841 /* Anonymous psymtabs don't have a file name. */
847 fullname
= psymtab_to_fullname (ps
);
850 fun (ps
->filename
, fullname
);
854 /* Finds the fullname that a partial_symtab represents.
856 If this functions finds the fullname, it will save it in ps->fullname
857 and it will also return the value.
859 If this function fails to find the file that this partial_symtab represents,
860 NULL will be returned and ps->fullname will be set to NULL. */
863 psymtab_to_fullname (struct partial_symtab
*ps
)
865 gdb_assert (!ps
->anonymous
);
867 /* Use cached copy if we have it.
868 We rely on forget_cached_source_info being called appropriately
869 to handle cases like the file being moved. */
870 if (ps
->fullname
== NULL
)
872 gdb::unique_xmalloc_ptr
<char> fullname
873 = find_source_or_rewrite (ps
->filename
, ps
->dirname
);
874 ps
->fullname
= fullname
.release ();
880 /* Psymtab version of expand_matching_symbols. See its definition in
881 the definition of quick_symbol_functions in symfile.h. */
884 psymbol_functions::expand_matching_symbols
885 (struct objfile
*objfile
,
886 const lookup_name_info
&name
, domain_enum domain
,
888 symbol_compare_ftype
*ordered_compare
)
890 for (partial_symtab
*ps
: partial_symbols (objfile
))
893 if (!ps
->readin_p (objfile
)
894 && match_partial_symbol (objfile
, ps
, global
, name
, domain
,
896 psymtab_to_symtab (objfile
, ps
);
900 /* A helper for psym_expand_symtabs_matching that handles searching
901 included psymtabs. This returns true if a symbol is found, and
902 false otherwise. It also updates the 'searched_flag' on the
903 various psymtabs that it searches. */
906 recursively_search_psymtabs
907 (struct partial_symtab
*ps
,
908 struct objfile
*objfile
,
909 block_search_flags search_flags
,
911 enum search_domain search
,
912 const lookup_name_info
&lookup_name
,
913 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
916 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
919 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
920 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
922 /* Recurse into shared psymtabs first, because they may have already
923 been searched, and this could save some time. */
924 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
928 /* Skip non-shared dependencies, these are handled elsewhere. */
929 if (ps
->dependencies
[i
]->user
== NULL
)
932 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
933 objfile
, search_flags
, domain
, search
,
934 lookup_name
, sym_matcher
);
937 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
942 partial_symbol
**gbound
= (ps
->global_psymbols
.data ()
943 + ps
->global_psymbols
.size ());
944 partial_symbol
**sbound
= (ps
->static_psymbols
.data ()
945 + ps
->static_psymbols
.size ());
946 partial_symbol
**bound
= gbound
;
948 /* Go through all of the symbols stored in a partial
949 symtab in one loop. */
950 partial_symbol
**psym
= ps
->global_psymbols
.data ();
952 if ((search_flags
& SEARCH_GLOBAL_BLOCK
) == 0)
954 if (ps
->static_psymbols
.empty ())
958 psym
= ps
->static_psymbols
.data ();
967 if (bound
== gbound
&& !ps
->static_psymbols
.empty ()
968 && (search_flags
& SEARCH_STATIC_BLOCK
) != 0)
970 psym
= ps
->static_psymbols
.data ();
981 if ((domain
== UNDEF_DOMAIN
982 || symbol_matches_domain ((*psym
)->ginfo
.language (),
983 (*psym
)->domain
, domain
))
984 && (search
== ALL_DOMAIN
985 || (search
== MODULES_DOMAIN
986 && (*psym
)->domain
== MODULE_DOMAIN
)
987 || (search
== VARIABLES_DOMAIN
988 && (*psym
)->aclass
!= LOC_TYPEDEF
989 && (*psym
)->aclass
!= LOC_BLOCK
)
990 || (search
== FUNCTIONS_DOMAIN
991 && (*psym
)->aclass
== LOC_BLOCK
)
992 || (search
== TYPES_DOMAIN
993 && (*psym
)->aclass
== LOC_TYPEDEF
))
994 && psymbol_name_matches (*psym
, lookup_name
)
995 && (sym_matcher
== NULL
996 || sym_matcher ((*psym
)->ginfo
.search_name ())))
998 /* Found a match, so notify our caller. */
999 result
= PST_SEARCHED_AND_FOUND
;
1006 ps
->searched_flag
= result
;
1007 return result
== PST_SEARCHED_AND_FOUND
;
1010 /* Psymtab version of expand_symtabs_matching. See its definition in
1011 the definition of quick_symbol_functions in symfile.h. */
1014 psymbol_functions::expand_symtabs_matching
1015 (struct objfile
*objfile
,
1016 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1017 const lookup_name_info
*lookup_name
,
1018 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1019 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1020 block_search_flags search_flags
,
1022 enum search_domain search
)
1024 /* Clear the search flags. */
1025 for (partial_symtab
*ps
: partial_symbols (objfile
))
1026 ps
->searched_flag
= PST_NOT_SEARCHED
;
1028 gdb::optional
<lookup_name_info
> psym_lookup_name
;
1029 if (lookup_name
!= nullptr)
1030 psym_lookup_name
= lookup_name
->make_ignore_params ();
1032 /* This invariant is documented in quick-functions.h. */
1033 gdb_assert (lookup_name
!= nullptr || symbol_matcher
== nullptr);
1035 for (partial_symtab
*ps
: m_partial_symtabs
->range ())
1039 if (ps
->readin_p (objfile
))
1049 match
= file_matcher (ps
->filename
, false);
1052 /* Before we invoke realpath, which can get expensive when many
1053 files are involved, do a quick comparison of the basenames. */
1054 if (basenames_may_differ
1055 || file_matcher (lbasename (ps
->filename
), true))
1056 match
= file_matcher (psymtab_to_fullname (ps
), false);
1062 if (lookup_name
== nullptr
1063 || recursively_search_psymtabs (ps
, objfile
, search_flags
,
1068 compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1070 if (cust
!= nullptr && expansion_notify
!= nullptr)
1071 if (!expansion_notify (cust
))
1079 /* Psymtab version of has_symbols. See its definition in
1080 the definition of quick_symbol_functions in symfile.h. */
1083 psymbol_functions::has_symbols (struct objfile
*objfile
)
1085 return m_partial_symtabs
->psymtabs
!= NULL
;
1088 /* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
1091 psymbol_functions::has_unexpanded_symtabs (struct objfile
*objfile
)
1093 for (partial_symtab
*psymtab
: partial_symbols (objfile
))
1095 /* Is this already expanded? */
1096 if (psymtab
->readin_p (objfile
))
1099 /* It has not yet been expanded. */
1108 /* Partially fill a partial symtab. It will be completely filled at
1109 the end of the symbol list. */
1111 partial_symtab::partial_symtab (const char *filename
,
1112 psymtab_storage
*partial_symtabs
,
1113 objfile_per_bfd_storage
*objfile_per_bfd
,
1114 unrelocated_addr textlow
)
1115 : partial_symtab (filename
, partial_symtabs
, objfile_per_bfd
)
1117 set_text_low (textlow
);
1118 set_text_high (unrelocated_text_low ()); /* default */
1121 /* Perform "finishing up" operations of a partial symtab. */
1124 partial_symtab::end ()
1126 global_psymbols
.shrink_to_fit ();
1127 static_psymbols
.shrink_to_fit ();
1129 /* Sort the global list; don't sort the static list. */
1130 std::sort (global_psymbols
.begin (),
1131 global_psymbols
.end (),
1132 [] (partial_symbol
*s1
, partial_symbol
*s2
)
1134 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1135 s2
->ginfo
.search_name ()) < 0;
1139 /* See psymtab.h. */
1142 psymbol_bcache::hash (const void *addr
, int length
)
1144 unsigned long h
= 0;
1145 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1146 unsigned int lang
= psymbol
->ginfo
.language ();
1147 unsigned int domain
= psymbol
->domain
;
1148 unsigned int theclass
= psymbol
->aclass
;
1150 h
= fast_hash (&psymbol
->ginfo
.m_value
, sizeof (psymbol
->ginfo
.m_value
), h
);
1151 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1152 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1153 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1154 /* Note that psymbol names are interned via compute_and_set_names, so
1155 there's no need to hash the contents of the name here. */
1156 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1161 /* See psymtab.h. */
1164 psymbol_bcache::compare (const void *addr1
, const void *addr2
, int length
)
1166 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1167 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1169 return (memcmp (&sym1
->ginfo
.m_value
, &sym2
->ginfo
.m_value
,
1170 sizeof (sym1
->ginfo
.m_value
)) == 0
1171 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1172 && sym1
->domain
== sym2
->domain
1173 && sym1
->aclass
== sym2
->aclass
1174 /* Note that psymbol names are interned via
1175 compute_and_set_names, so there's no need to compare the
1176 contents of the name here. */
1177 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1180 /* See psympriv.h. */
1183 partial_symtab::add_psymbol (const partial_symbol
&psymbol
,
1184 psymbol_placement where
,
1185 psymtab_storage
*partial_symtabs
,
1186 struct objfile
*objfile
)
1190 /* Stash the partial symbol away in the cache. */
1191 partial_symbol
*psym
1192 = ((struct partial_symbol
*)
1193 partial_symtabs
->psymbol_cache
.insert
1194 (&psymbol
, sizeof (struct partial_symbol
), &added
));
1196 /* Do not duplicate global partial symbols. */
1197 if (where
== psymbol_placement::GLOBAL
&& !added
)
1200 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1201 std::vector
<partial_symbol
*> &list
1202 = (where
== psymbol_placement::STATIC
1205 list
.push_back (psym
);
1208 /* See psympriv.h. */
1211 partial_symtab::add_psymbol (gdb::string_view name
, bool copy_name
,
1213 enum address_class theclass
,
1215 psymbol_placement where
,
1216 unrelocated_addr coreaddr
,
1217 enum language language
,
1218 psymtab_storage
*partial_symtabs
,
1219 struct objfile
*objfile
)
1221 struct partial_symbol psymbol
;
1222 memset (&psymbol
, 0, sizeof (psymbol
));
1224 psymbol
.set_unrelocated_address (coreaddr
);
1225 psymbol
.ginfo
.set_section_index (section
);
1226 psymbol
.domain
= domain
;
1227 psymbol
.aclass
= theclass
;
1228 psymbol
.ginfo
.set_language (language
, partial_symtabs
->obstack ());
1229 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1231 add_psymbol (psymbol
, where
, partial_symtabs
, objfile
);
1234 /* See psympriv.h. */
1236 partial_symtab::partial_symtab (const char *filename_
,
1237 psymtab_storage
*partial_symtabs
,
1238 objfile_per_bfd_storage
*objfile_per_bfd
)
1239 : searched_flag (PST_NOT_SEARCHED
),
1243 partial_symtabs
->install_psymtab (this);
1245 filename
= objfile_per_bfd
->intern (filename_
);
1247 if (symtab_create_debug
>= 1)
1249 /* Be a bit clever with debugging messages, and don't print objfile
1250 every time, only when it changes. */
1251 static std::string last_bfd_name
;
1252 const char *this_bfd_name
1253 = bfd_get_filename (objfile_per_bfd
->get_bfd ());
1255 if (last_bfd_name
.empty () || last_bfd_name
!= this_bfd_name
)
1257 last_bfd_name
= this_bfd_name
;
1259 symtab_create_debug_printf ("creating one or more psymtabs for %s",
1263 symtab_create_debug_printf ("created psymtab %s for module %s",
1264 host_address_to_string (this), filename
);
1268 /* See psympriv.h. */
1271 partial_symtab::expand_dependencies (struct objfile
*objfile
)
1273 for (int i
= 0; i
< number_of_dependencies
; ++i
)
1275 if (!dependencies
[i
]->readin_p (objfile
)
1276 && dependencies
[i
]->user
== NULL
)
1278 /* Inform about additional files to be read in. */
1282 gdb_stdout
->wrap_here (0);
1284 gdb_stdout
->wrap_here (0);
1285 gdb_printf ("%s...", dependencies
[i
]->filename
);
1286 gdb_flush (gdb_stdout
);
1288 dependencies
[i
]->expand_psymtab (objfile
);
1295 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1297 struct partial_symtab
**prev_pst
;
1300 Empty psymtabs happen as a result of header files which don't
1301 have any symbols in them. There can be a lot of them. But this
1302 check is wrong, in that a psymtab with N_SLINE entries but
1303 nothing else is not empty, but we don't realize that. Fixing
1304 that without slowing things down might be tricky. */
1306 /* First, snip it out of the psymtab chain. */
1308 prev_pst
= &psymtabs
;
1309 while ((*prev_pst
) != pst
)
1310 prev_pst
= &((*prev_pst
)->next
);
1311 (*prev_pst
) = pst
->next
;
1318 maintenance_print_psymbols (const char *args
, int from_tty
)
1320 struct ui_file
*outfile
= gdb_stdout
;
1321 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1322 int i
, outfile_idx
, found
;
1324 struct obj_section
*section
= NULL
;
1328 gdb_argv
argv (args
);
1330 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1332 if (strcmp (argv
[i
], "-pc") == 0)
1334 if (argv
[i
+ 1] == NULL
)
1335 error (_("Missing pc value"));
1336 address_arg
= argv
[++i
];
1338 else if (strcmp (argv
[i
], "-source") == 0)
1340 if (argv
[i
+ 1] == NULL
)
1341 error (_("Missing source file"));
1342 source_arg
= argv
[++i
];
1344 else if (strcmp (argv
[i
], "-objfile") == 0)
1346 if (argv
[i
+ 1] == NULL
)
1347 error (_("Missing objfile name"));
1348 objfile_arg
= argv
[++i
];
1350 else if (strcmp (argv
[i
], "--") == 0)
1352 /* End of options. */
1356 else if (argv
[i
][0] == '-')
1358 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1359 error (_("Unknown option: %s"), argv
[i
]);
1366 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1367 error (_("Must specify at most one of -pc and -source"));
1369 stdio_file arg_outfile
;
1371 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1373 if (argv
[outfile_idx
+ 1] != NULL
)
1374 error (_("Junk at end of command"));
1375 gdb::unique_xmalloc_ptr
<char> outfile_name
1376 (tilde_expand (argv
[outfile_idx
]));
1377 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1378 perror_with_name (outfile_name
.get ());
1379 outfile
= &arg_outfile
;
1382 if (address_arg
!= NULL
)
1384 pc
= parse_and_eval_address (address_arg
);
1385 /* If we fail to find a section, that's ok, try the lookup anyway. */
1386 section
= find_pc_section (pc
);
1390 for (objfile
*objfile
: current_program_space
->objfiles ())
1392 int printed_objfile_header
= 0;
1393 int print_for_objfile
= 1;
1396 if (objfile_arg
!= NULL
)
1398 = compare_filenames_for_search (objfile_name (objfile
),
1400 if (!print_for_objfile
)
1403 for (const auto &iter
: objfile
->qf
)
1405 psymbol_functions
*psf
1406 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1410 if (address_arg
!= NULL
)
1412 struct bound_minimal_symbol msymbol
;
1414 /* We don't assume each pc has a unique objfile (this is for
1416 struct partial_symtab
*ps
1417 = psf
->find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1420 if (!printed_objfile_header
)
1422 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1423 objfile_name (objfile
));
1424 printed_objfile_header
= 1;
1426 dump_psymtab (objfile
, ps
, outfile
);
1432 for (partial_symtab
*ps
: psf
->partial_symbols (objfile
))
1434 int print_for_source
= 0;
1437 if (source_arg
!= NULL
)
1440 = compare_filenames_for_search (ps
->filename
, source_arg
);
1443 if (source_arg
== NULL
1444 || print_for_source
)
1446 if (!printed_objfile_header
)
1448 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1449 objfile_name (objfile
));
1450 printed_objfile_header
= 1;
1452 dump_psymtab (objfile
, ps
, outfile
);
1461 if (address_arg
!= NULL
)
1462 error (_("No partial symtab for address: %s"), address_arg
);
1463 if (source_arg
!= NULL
)
1464 error (_("No partial symtab for source file: %s"), source_arg
);
1468 /* List all the partial symbol tables whose names match REGEXP (optional). */
1471 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1476 for (struct program_space
*pspace
: program_spaces
)
1477 for (objfile
*objfile
: pspace
->objfiles ())
1479 struct gdbarch
*gdbarch
= objfile
->arch ();
1481 /* We don't want to print anything for this objfile until we
1482 actually find a symtab whose name matches. */
1483 int printed_objfile_start
= 0;
1485 for (const auto &iter
: objfile
->qf
)
1487 psymbol_functions
*psf
1488 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1491 for (partial_symtab
*psymtab
: psf
->partial_symbols (objfile
))
1496 || re_exec (psymtab
->filename
))
1498 if (! printed_objfile_start
)
1500 gdb_printf ("{ objfile %s ", objfile_name (objfile
));
1501 gdb_stdout
->wrap_here (2);
1502 gdb_printf ("((struct objfile *) %s)\n",
1503 host_address_to_string (objfile
));
1504 printed_objfile_start
= 1;
1507 gdb_printf (" { psymtab %s ", psymtab
->filename
);
1508 gdb_stdout
->wrap_here (4);
1509 gdb_printf ("((struct partial_symtab *) %s)\n",
1510 host_address_to_string (psymtab
));
1512 gdb_printf (" readin %s\n",
1513 psymtab
->readin_p (objfile
) ? "yes" : "no");
1514 gdb_printf (" fullname %s\n",
1516 ? psymtab
->fullname
: "(null)");
1517 gdb_printf (" text addresses ");
1518 gdb_puts (paddress (gdbarch
,
1519 psymtab
->text_low (objfile
)));
1520 gdb_printf (" -- ");
1521 gdb_puts (paddress (gdbarch
,
1522 psymtab
->text_high (objfile
)));
1524 gdb_printf (" globals ");
1525 if (!psymtab
->global_psymbols
.empty ())
1527 ("(* (struct partial_symbol **) %s @ %d)\n",
1528 host_address_to_string (psymtab
->global_psymbols
.data ()),
1529 (int) psymtab
->global_psymbols
.size ());
1531 gdb_printf ("(none)\n");
1532 gdb_printf (" statics ");
1533 if (!psymtab
->static_psymbols
.empty ())
1535 ("(* (struct partial_symbol **) %s @ %d)\n",
1536 host_address_to_string (psymtab
->static_psymbols
.data ()),
1537 (int) psymtab
->static_psymbols
.size ());
1539 gdb_printf ("(none)\n");
1541 gdb_printf (" user %s "
1542 "((struct partial_symtab *) %s)\n",
1543 psymtab
->user
->filename
,
1544 host_address_to_string (psymtab
->user
));
1545 gdb_printf (" dependencies ");
1546 if (psymtab
->number_of_dependencies
)
1551 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1553 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
1555 /* Note the string concatenation there --- no
1557 gdb_printf (" psymtab %s "
1558 "((struct partial_symtab *) %s)\n",
1560 host_address_to_string (dep
));
1562 gdb_printf (" }\n");
1565 gdb_printf ("(none)\n");
1566 gdb_printf (" }\n");
1571 if (printed_objfile_start
)
1576 /* Check consistency of currently expanded psymtabs vs symtabs. */
1579 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
1582 struct compunit_symtab
*cust
= NULL
;
1583 const struct blockvector
*bv
;
1584 const struct block
*b
;
1586 for (objfile
*objfile
: current_program_space
->objfiles ())
1588 for (const auto &iter
: objfile
->qf
)
1590 psymbol_functions
*psf
1591 = dynamic_cast<psymbol_functions
*> (iter
.get ());
1595 for (partial_symtab
*ps
: psf
->partial_symbols (objfile
))
1597 struct gdbarch
*gdbarch
= objfile
->arch ();
1599 /* We don't call psymtab_to_symtab here because that may cause symtab
1600 expansion. When debugging a problem it helps if checkers leave
1601 things unchanged. */
1602 cust
= ps
->get_compunit_symtab (objfile
);
1604 /* First do some checks that don't require the associated symtab. */
1605 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
1607 gdb_printf ("Psymtab ");
1608 gdb_puts (ps
->filename
);
1609 gdb_printf (" covers bad range ");
1610 gdb_puts (paddress (gdbarch
, ps
->text_low (objfile
)));
1612 gdb_puts (paddress (gdbarch
, ps
->text_high (objfile
)));
1617 /* Now do checks requiring the associated symtab. */
1620 bv
= cust
->blockvector ();
1621 b
= bv
->static_block ();
1622 for (partial_symbol
*psym
: ps
->static_psymbols
)
1624 /* Skip symbols for inlined functions without address. These may
1625 or may not have a match in the full symtab. */
1626 if (psym
->aclass
== LOC_BLOCK
1627 && psym
->ginfo
.value_address () == 0)
1630 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1631 symbol_name_match_type::SEARCH_NAME
,
1635 gdb_printf ("Static symbol `");
1636 gdb_puts (psym
->ginfo
.linkage_name ());
1637 gdb_printf ("' only found in ");
1638 gdb_puts (ps
->filename
);
1639 gdb_printf (" psymtab\n");
1642 b
= bv
->global_block ();
1643 for (partial_symbol
*psym
: ps
->global_psymbols
)
1645 sym
= block_lookup_symbol (b
, psym
->ginfo
.search_name (),
1646 symbol_name_match_type::SEARCH_NAME
,
1650 gdb_printf ("Global symbol `");
1651 gdb_puts (psym
->ginfo
.linkage_name ());
1652 gdb_printf ("' only found in ");
1653 gdb_puts (ps
->filename
);
1654 gdb_printf (" psymtab\n");
1657 if (ps
->unrelocated_text_high () != unrelocated_addr (0)
1658 && (ps
->text_low (objfile
) < b
->start ()
1659 || ps
->text_high (objfile
) > b
->end ()))
1661 gdb_printf ("Psymtab ");
1662 gdb_puts (ps
->filename
);
1663 gdb_printf (" covers ");
1664 gdb_puts (paddress (gdbarch
, ps
->text_low (objfile
)));
1666 gdb_puts (paddress (gdbarch
, ps
->text_high (objfile
)));
1667 gdb_printf (" but symtab covers only ");
1668 gdb_puts (paddress (gdbarch
, b
->start ()));
1670 gdb_puts (paddress (gdbarch
, b
->end ()));
1678 void _initialize_psymtab ();
1680 _initialize_psymtab ()
1682 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
1683 Print dump of current partial symbol definitions.\n\
1684 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
1685 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1686 Entries in the partial symbol table are dumped to file OUTFILE,\n\
1687 or the terminal if OUTFILE is unspecified.\n\
1688 If ADDRESS is provided, dump only the file for that address.\n\
1689 If SOURCE is provided, dump only that file's symbols.\n\
1690 If OBJFILE is provided, dump only that file's minimal symbols."),
1691 &maintenanceprintlist
);
1693 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
1694 List the partial symbol tables for all object files.\n\
1695 This does not include information about individual partial symbols,\n\
1696 just the symbol table structures themselves."),
1697 &maintenanceinfolist
);
1699 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
1701 Check consistency of currently expanded psymtabs versus symtabs."),