GDB (xrefs)
Loading...
Searching...
No Matches
psymtab.c
Go to the documentation of this file.
1/* Partial symbol tables.
2
3 Copyright (C) 2009-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "symtab.h"
22#include "objfiles.h"
23#include "psympriv.h"
24#include "block.h"
25#include "filenames.h"
26#include "source.h"
27#include "addrmap.h"
28#include "gdbtypes.h"
29#include "ui-out.h"
30#include "command.h"
31#include "readline/tilde.h"
32#include "gdbsupport/gdb_regex.h"
33#include "dictionary.h"
34#include "language.h"
35#include "cp-support.h"
36#include "gdbcmd.h"
37#include <algorithm>
38#include <set>
39#include "gdbsupport/buildargv.h"
40
41static struct partial_symbol *lookup_partial_symbol (struct objfile *,
42 struct partial_symtab *,
43 const lookup_name_info &,
44 int,
46
47static const char *psymtab_to_fullname (struct partial_symtab *ps);
48
49static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
50 struct partial_symtab *,
51 CORE_ADDR,
52 struct obj_section *);
53
54static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
55 struct partial_symtab *pst);
56
58{
60 while (iter != nullptr)
61 {
62 partial_symtab *next = iter->next;
63 delete iter;
64 iter = next;
65 }
66}
67
68/* See psymtab.h. */
69
70void
72{
73 pst->next = psymtabs;
74 psymtabs = pst;
75}
76
77
78
79/* See psympriv.h. */
80
83{
84 gdb_assert ((objfile->flags & OBJF_PSYMTABS_READ) != 0);
85 return m_partial_symtabs->range ();
86}
87
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. */
90
91static struct partial_symtab *
93 CORE_ADDR pc, struct obj_section *section,
94 struct partial_symtab *pst,
95 struct bound_minimal_symbol msymbol)
96{
97 struct partial_symtab *tpst;
98 struct partial_symtab *best_pst = pst;
99 CORE_ADDR best_addr = pst->text_low (objfile);
100
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. */
106 && section == NULL) /* Can't validate section this way. */
107 return pst;
108
109 if (msymbol.minsym == NULL)
110 return pst;
111
112 /* The code range of partial symtabs sometimes overlap, so, in
113 the loop below, we need to check all partial symtabs and
114 find the one that fits better for the given PC address. We
115 select the partial symtab that contains a symbol whose
116 address is closest to the PC address. By closest we mean
117 that find_pc_sect_symbol returns the symbol with address
118 that is closest and still less than the given PC. */
119 for (tpst = pst; tpst != NULL; tpst = tpst->next)
120 {
121 if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile))
122 {
123 struct partial_symbol *p;
124 CORE_ADDR this_addr;
125
126 /* NOTE: This assumes that every psymbol has a
127 corresponding msymbol, which is not necessarily
128 true; the debug info might be much richer than the
129 object's symbol table. */
130 p = find_pc_sect_psymbol (objfile, tpst, pc, section);
131 if (p != NULL
132 && (p->address (objfile) == msymbol.value_address ()))
133 return tpst;
134
135 /* Also accept the textlow value of a psymtab as a
136 "symbol", to provide some support for partial
137 symbol tables with line information but no debug
138 symbols (e.g. those produced by an assembler). */
139 if (p != NULL)
140 this_addr = p->address (objfile);
141 else
142 this_addr = tpst->text_low (objfile);
143
144 /* Check whether it is closer than our current
145 BEST_ADDR. Since this symbol address is
146 necessarily lower or equal to PC, the symbol closer
147 to PC is the symbol which address is the highest.
148 This way we return the psymtab which contains such
149 best match symbol. This can help in cases where the
150 symbol information/debuginfo is not complete, like
151 for instance on IRIX6 with gcc, where no debug info
152 is emitted for statics. (See also the nodebug.exp
153 testcase.) */
154 if (this_addr > best_addr)
155 {
156 best_addr = this_addr;
157 best_pst = tpst;
158 }
159 }
160 }
161 return best_pst;
162}
163
164/* See psympriv.h. */
165
166struct partial_symtab *
168 CORE_ADDR pc,
169 struct obj_section *section,
170 struct bound_minimal_symbol msymbol)
171{
173 if (pc >= pst->text_low (objfile) && pc < pst->text_high (objfile))
174 {
175 struct partial_symtab *best_pst;
176
177 best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
178 msymbol);
179 if (best_pst != NULL)
180 return best_pst;
181 }
182
183 return NULL;
184}
185
186/* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
187 the definition of quick_symbol_functions in symfile.h. */
188
189struct compunit_symtab *
191 (struct objfile *objfile,
192 struct bound_minimal_symbol msymbol,
193 CORE_ADDR pc,
194 struct obj_section *section,
195 int warn_if_readin)
196{
198 pc, section,
199 msymbol);
200 if (ps != NULL)
201 {
202 if (warn_if_readin && ps->readin_p (objfile))
203 /* Might want to error() here (in case symtab is corrupt and
204 will cause a core dump), but maybe we can successfully
205 continue, so let's not. */
206 warning (_("\
207(Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
208 paddress (objfile->arch (), pc));
210 return ps->get_compunit_symtab (objfile);
211 }
212 return NULL;
213}
214
215/* Find which partial symbol within a psymtab matches PC and SECTION.
216 Return NULL if none. */
217
218static struct partial_symbol *
220 struct partial_symtab *psymtab, CORE_ADDR pc,
221 struct obj_section *section)
222{
223 struct partial_symbol *best = NULL;
224 CORE_ADDR best_pc;
225 const CORE_ADDR textlow = psymtab->text_low (objfile);
226
227 gdb_assert (psymtab != NULL);
228
229 /* Cope with programs that start at address 0. */
230 best_pc = (textlow != 0) ? textlow - 1 : 0;
231
232 /* Search the global symbols as well as the static symbols, so that
233 find_pc_partial_function doesn't use a minimal symbol and thus
234 cache a bad endaddr. */
235 for (partial_symbol *p : psymtab->global_psymbols)
236 {
237 if (p->domain == VAR_DOMAIN
238 && p->aclass == LOC_BLOCK
239 && pc >= p->address (objfile)
240 && (p->address (objfile) > best_pc
241 || (psymtab->text_low (objfile) == 0
242 && best_pc == 0 && p->address (objfile) == 0)))
243 {
244 if (section != NULL) /* Match on a specific section. */
245 {
246 if (!matching_obj_sections (p->obj_section (objfile),
247 section))
248 continue;
249 }
250 best_pc = p->address (objfile);
251 best = p;
252 }
253 }
254
255 for (partial_symbol *p : psymtab->static_psymbols)
256 {
257 if (p->domain == VAR_DOMAIN
258 && p->aclass == LOC_BLOCK
259 && pc >= p->address (objfile)
260 && (p->address (objfile) > best_pc
261 || (psymtab->text_low (objfile) == 0
262 && best_pc == 0 && p->address (objfile) == 0)))
263 {
264 if (section != NULL) /* Match on a specific section. */
265 {
266 if (!matching_obj_sections (p->obj_section (objfile),
267 section))
268 continue;
269 }
270 best_pc = p->address (objfile);
271 best = p;
272 }
273 }
274
275 return best;
276}
277
278/* Psymtab version of lookup_global_symbol_language. See its definition in
279 the definition of quick_symbol_functions in symfile.h. */
280
281enum language
283 const char *name,
285 bool *symbol_found_p)
286{
287 *symbol_found_p = false;
288 if (objfile->sf == NULL)
289 return language_unknown;
290
292
294 {
295 struct partial_symbol *psym;
296 if (ps->readin_p (objfile))
297 continue;
298
299 psym = lookup_partial_symbol (objfile, ps, lookup_name, 1, domain);
300 if (psym)
301 {
302 *symbol_found_p = true;
303 return psym->ginfo.language ();
304 }
305 }
306
307 return language_unknown;
308}
309
310/* Returns true if PSYM matches LOOKUP_NAME. */
311
312static bool
314 const lookup_name_info &lookup_name)
315{
316 const language_defn *lang = language_def (psym->ginfo.language ());
317 symbol_name_matcher_ftype *name_match
318 = lang->get_symbol_name_matcher (lookup_name);
319 return name_match (psym->ginfo.search_name (), lookup_name, NULL);
320}
321
322/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
323 the global block of PST if GLOBAL, and otherwise the static block.
324 MATCH is the comparison operation that returns true iff MATCH (s,
325 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
326 non-null, the symbols in the block are assumed to be ordered
327 according to it (allowing binary search). It must be compatible
328 with MATCH. Returns the symbol, if found, and otherwise NULL. */
329
330static struct partial_symbol *
332 struct partial_symtab *pst, int global,
334 symbol_compare_ftype *ordered_compare)
335{
336 struct partial_symbol **start, **psym;
337 struct partial_symbol **top, **real_top, **bottom, **center;
338 int length = (global
339 ? pst->global_psymbols.size ()
340 : pst->static_psymbols.size ());
341 int do_linear_search = 1;
342
343 if (length == 0)
344 return NULL;
345
346 start = (global ?
347 &pst->global_psymbols[0] :
348 &pst->static_psymbols[0]);
349
350 if (global && ordered_compare) /* Can use a binary search. */
351 {
352 do_linear_search = 0;
353
354 /* Binary search. This search is guaranteed to end with center
355 pointing at the earliest partial symbol whose name might be
356 correct. At that point *all* partial symbols with an
357 appropriate name will be checked against the correct
358 domain. */
359
360 bottom = start;
361 top = start + length - 1;
362 real_top = top;
363 while (top > bottom)
364 {
365 center = bottom + (top - bottom) / 2;
366 gdb_assert (center < top);
367
368 enum language lang = (*center)->ginfo.language ();
369 const char *lang_ln = name.language_lookup_name (lang);
370
371 if (ordered_compare ((*center)->ginfo.search_name (),
372 lang_ln) >= 0)
373 top = center;
374 else
375 bottom = center + 1;
376 }
377 gdb_assert (top == bottom);
378
379 while (top <= real_top
380 && psymbol_name_matches (*top, name))
381 {
382 if (symbol_matches_domain ((*top)->ginfo.language (),
383 (*top)->domain, domain))
384 return *top;
385 top++;
386 }
387 }
388
389 /* Can't use a binary search or else we found during the binary search that
390 we should also do a linear search. */
391
392 if (do_linear_search)
393 {
394 for (psym = start; psym < start + length; psym++)
395 {
396 if (symbol_matches_domain ((*psym)->ginfo.language (),
397 (*psym)->domain, domain)
398 && psymbol_name_matches (*psym, name))
399 return *psym;
400 }
401 }
402
403 return NULL;
404}
405
406/* Look, in partial_symtab PST, for symbol whose natural name is
407 LOOKUP_NAME. Check the global symbols if GLOBAL, the static
408 symbols if not. */
409
410static struct partial_symbol *
412 struct partial_symtab *pst,
413 const lookup_name_info &lookup_name,
414 int global, domain_enum domain)
415{
416 struct partial_symbol **start, **psym;
417 struct partial_symbol **top, **real_top, **bottom, **center;
418 int length = (global
419 ? pst->global_psymbols.size ()
420 : pst->static_psymbols.size ());
421 int do_linear_search = 1;
422
423 if (length == 0)
424 return NULL;
425
426 start = (global ?
427 &pst->global_psymbols[0] :
428 &pst->static_psymbols[0]);
429
430 if (global) /* This means we can use a binary search. */
431 {
432 do_linear_search = 0;
433
434 /* Binary search. This search is guaranteed to end with center
435 pointing at the earliest partial symbol whose name might be
436 correct. At that point *all* partial symbols with an
437 appropriate name will be checked against the correct
438 domain. */
439
440 bottom = start;
441 top = start + length - 1;
442 real_top = top;
443 while (top > bottom)
444 {
445 center = bottom + (top - bottom) / 2;
446
447 gdb_assert (center < top);
448
449 if (strcmp_iw_ordered ((*center)->ginfo.search_name (),
450 lookup_name.c_str ()) >= 0)
451 {
452 top = center;
453 }
454 else
455 {
456 bottom = center + 1;
457 }
458 }
459
460 gdb_assert (top == bottom);
461
462 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
463 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
464 while (top >= start && symbol_matches_search_name (&(*top)->ginfo,
465 lookup_name))
466 top--;
467
468 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
469 top++;
470
471 while (top <= real_top && symbol_matches_search_name (&(*top)->ginfo,
472 lookup_name))
473 {
474 if (symbol_matches_domain ((*top)->ginfo.language (),
475 (*top)->domain, domain))
476 return *top;
477 top++;
478 }
479 }
480
481 /* Can't use a binary search or else we found during the binary search that
482 we should also do a linear search. */
483
484 if (do_linear_search)
485 {
486 for (psym = start; psym < start + length; psym++)
487 {
488 if (symbol_matches_domain ((*psym)->ginfo.language (),
489 (*psym)->domain, domain)
490 && symbol_matches_search_name (&(*psym)->ginfo, lookup_name))
491 return *psym;
492 }
493 }
494
495 return NULL;
496}
497
498/* Get the symbol table that corresponds to a partial_symtab.
499 This is fast after the first time you do it.
500 The result will be NULL if the primary symtab has no symbols,
501 which can happen. Otherwise the result is the primary symtab
502 that contains PST. */
503
504static struct compunit_symtab *
506{
507 /* If it is a shared psymtab, find an unshared psymtab that includes
508 it. Any such psymtab will do. */
509 while (pst->user != NULL)
510 pst = pst->user;
511
512 /* If it's been looked up before, return it. */
513 if (pst->get_compunit_symtab (objfile))
514 return pst->get_compunit_symtab (objfile);
515
516 /* If it has not yet been read in, read it. */
517 if (!pst->readin_p (objfile))
518 {
519 scoped_restore decrementer = increment_reading_symtab ();
520
521 if (info_verbose)
522 {
523 gdb_printf (_("Reading in symbols for %s...\n"),
524 pst->filename);
526 }
527
528 pst->read_symtab (objfile);
529 }
530
531 return pst->get_compunit_symtab (objfile);
532}
533
534/* Psymtab version of find_last_source_symtab. See its definition in
535 the definition of quick_symbol_functions in symfile.h. */
536
537struct symtab *
539{
540 struct partial_symtab *cs_pst = NULL;
541
542 for (partial_symtab *ps : partial_symbols (ofp))
543 {
544 const char *name = ps->filename;
545 int len = strlen (name);
546
547 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
548 || strcmp (name, "<<C++-namespaces>>") == 0)))
549 cs_pst = ps;
550 }
551
552 if (cs_pst)
553 {
554 if (cs_pst->readin_p (ofp))
555 {
556 internal_error (_("select_source_symtab: "
557 "readin pst found and no symtabs."));
558 }
559 else
560 {
561 struct compunit_symtab *cust = psymtab_to_symtab (ofp, cs_pst);
562
563 if (cust == NULL)
564 return NULL;
565 return cust->primary_filetab ();
566 }
567 }
568 return NULL;
569}
570
571/* Psymtab version of forget_cached_source_info. See its definition in
572 the definition of quick_symbol_functions in symfile.h. */
573
574void
576{
578 {
579 if (pst->fullname != NULL)
580 {
581 xfree (pst->fullname);
582 pst->fullname = NULL;
583 }
584 }
585}
586
587static void
589 const std::vector<partial_symbol *> &symbols,
590 const char *what, struct ui_file *outfile)
591{
592 gdb_printf (outfile, " %s partial symbols:\n", what);
593 for (partial_symbol *p : symbols)
594 {
595 QUIT;
596 gdb_printf (outfile, " `%s'", p->ginfo.linkage_name ());
597 if (p->ginfo.demangled_name () != NULL)
598 {
599 gdb_printf (outfile, " `%s'",
600 p->ginfo.demangled_name ());
601 }
602 gdb_puts (", ", outfile);
603 switch (p->domain)
604 {
605 case UNDEF_DOMAIN:
606 gdb_puts ("undefined domain, ", outfile);
607 break;
608 case VAR_DOMAIN:
609 /* This is the usual thing -- don't print it. */
610 break;
611 case STRUCT_DOMAIN:
612 gdb_puts ("struct domain, ", outfile);
613 break;
614 case MODULE_DOMAIN:
615 gdb_puts ("module domain, ", outfile);
616 break;
617 case LABEL_DOMAIN:
618 gdb_puts ("label domain, ", outfile);
619 break;
621 gdb_puts ("common block domain, ", outfile);
622 break;
623 default:
624 gdb_puts ("<invalid domain>, ", outfile);
625 break;
626 }
627 switch (p->aclass)
628 {
629 case LOC_UNDEF:
630 gdb_puts ("undefined", outfile);
631 break;
632 case LOC_CONST:
633 gdb_puts ("constant int", outfile);
634 break;
635 case LOC_STATIC:
636 gdb_puts ("static", outfile);
637 break;
638 case LOC_REGISTER:
639 gdb_puts ("register", outfile);
640 break;
641 case LOC_ARG:
642 gdb_puts ("pass by value", outfile);
643 break;
644 case LOC_REF_ARG:
645 gdb_puts ("pass by reference", outfile);
646 break;
647 case LOC_REGPARM_ADDR:
648 gdb_puts ("register address parameter", outfile);
649 break;
650 case LOC_LOCAL:
651 gdb_puts ("stack parameter", outfile);
652 break;
653 case LOC_TYPEDEF:
654 gdb_puts ("type", outfile);
655 break;
656 case LOC_LABEL:
657 gdb_puts ("label", outfile);
658 break;
659 case LOC_BLOCK:
660 gdb_puts ("function", outfile);
661 break;
662 case LOC_CONST_BYTES:
663 gdb_puts ("constant bytes", outfile);
664 break;
665 case LOC_UNRESOLVED:
666 gdb_puts ("unresolved", outfile);
667 break;
669 gdb_puts ("optimized out", outfile);
670 break;
671 case LOC_COMPUTED:
672 gdb_puts ("computed at runtime", outfile);
673 break;
674 default:
675 gdb_puts ("<invalid location>", outfile);
676 break;
677 }
678 gdb_puts (", ", outfile);
679 gdb_puts (paddress (gdbarch, p->unrelocated_address ()), outfile);
680 gdb_printf (outfile, "\n");
681 }
682}
683
684static void
685dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
686 struct ui_file *outfile)
687{
688 struct gdbarch *gdbarch = objfile->arch ();
689 int i;
690
691 if (psymtab->anonymous)
692 {
693 gdb_printf (outfile, "\nAnonymous partial symtab (%s) ",
694 psymtab->filename);
695 }
696 else
697 {
698 gdb_printf (outfile, "\nPartial symtab for source file %s ",
699 psymtab->filename);
700 }
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",
705 host_address_to_string (objfile));
706
707 if (psymtab->readin_p (objfile))
709 (outfile,
710 " Full symtab was read (at %s)\n",
711 host_address_to_string (psymtab->get_compunit_symtab (objfile)));
712
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 ())
727 {
729 (gdbarch, objfile, psymtab->global_psymbols,
730 "Global", outfile);
731 }
732 if (!psymtab->static_psymbols.empty ())
733 {
735 (gdbarch, objfile, psymtab->static_psymbols,
736 "Static", outfile);
737 }
738 gdb_printf (outfile, "\n");
739}
740
741/* Count the number of partial symbols in OBJFILE. */
742
743int
745{
746 int count = 0;
747 for (partial_symtab *pst : m_partial_symtabs->range ())
748 {
749 count += pst->global_psymbols.size ();
750 count += pst->static_psymbols.size ();
751 }
752 return count;
753}
754
755/* Psymtab version of print_stats. See its definition in
756 the definition of quick_symbol_functions in symfile.h. */
757
758void
760{
761 int i;
762
763 if (!print_bcache)
764 {
765 int n_psyms = count_psyms ();
766 if (n_psyms > 0)
767 gdb_printf (_(" Number of \"partial\" symbols read: %d\n"),
768 n_psyms);
769
770 i = 0;
772 {
773 if (!ps->readin_p (objfile))
774 i++;
775 }
776 gdb_printf (_(" Number of psym tables (not yet expanded): %d\n"),
777 i);
778 gdb_printf (_(" Total memory used for psymbol cache: %d\n"),
779 m_partial_symtabs->psymbol_cache.memory_used ());
780 }
781 else
782 {
783 gdb_printf (_("Psymbol byte cache statistics:\n"));
784 m_partial_symtabs->psymbol_cache.print_statistics
785 ("partial symbol cache");
786 }
787}
788
789/* Psymtab version of dump. See its definition in
790 the definition of quick_symbol_functions in symfile.h. */
791
792void
794{
795 struct partial_symtab *psymtab;
796
797 if (m_partial_symtabs->psymtabs)
798 {
799 gdb_printf ("Psymtabs:\n");
800 for (psymtab = m_partial_symtabs->psymtabs;
801 psymtab != NULL;
802 psymtab = psymtab->next)
803 gdb_printf ("%s at %s\n",
804 psymtab->filename,
805 host_address_to_string (psymtab));
806 gdb_printf ("\n\n");
807 }
808}
809
810/* Psymtab version of expand_all_symtabs. See its definition in
811 the definition of quick_symbol_functions in symfile.h. */
812
813void
815{
816 for (partial_symtab *psymtab : partial_symbols (objfile))
817 psymtab_to_symtab (objfile, psymtab);
818}
819
820/* Psymtab version of map_symbol_filenames. See its definition in
821 the definition of quick_symbol_functions in symfile.h. */
822
823void
825 (struct objfile *objfile,
826 gdb::function_view<symbol_filename_ftype> fun,
827 bool need_fullname)
828{
830 {
831 const char *fullname;
832
833 if (ps->readin_p (objfile))
834 continue;
835
836 /* We can skip shared psymtabs here, because any file name will be
837 attached to the unshared psymtab. */
838 if (ps->user != NULL)
839 continue;
840
841 /* Anonymous psymtabs don't have a file name. */
842 if (ps->anonymous)
843 continue;
844
845 QUIT;
846 if (need_fullname)
847 fullname = psymtab_to_fullname (ps);
848 else
849 fullname = NULL;
850 fun (ps->filename, fullname);
851 }
852}
853
854/* Finds the fullname that a partial_symtab represents.
855
856 If this functions finds the fullname, it will save it in ps->fullname
857 and it will also return the value.
858
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. */
861
862static const char *
864{
865 gdb_assert (!ps->anonymous);
866
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)
871 {
872 gdb::unique_xmalloc_ptr<char> fullname
874 ps->fullname = fullname.release ();
875 }
876
877 return ps->fullname;
878}
879
880/* Psymtab version of expand_matching_symbols. See its definition in
881 the definition of quick_symbol_functions in symfile.h. */
882
883void
885 (struct objfile *objfile,
886 const lookup_name_info &name, domain_enum domain,
887 int global,
888 symbol_compare_ftype *ordered_compare)
889{
891 {
892 QUIT;
893 if (!ps->readin_p (objfile)
894 && match_partial_symbol (objfile, ps, global, name, domain,
895 ordered_compare))
897 }
898}
899
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. */
904
905static bool
907 (struct partial_symtab *ps,
908 struct objfile *objfile,
909 block_search_flags search_flags,
910 domain_enum domain,
911 enum search_domain search,
912 const lookup_name_info &lookup_name,
913 gdb::function_view<expand_symtabs_symbol_matcher_ftype> sym_matcher)
914{
915 int keep_going = 1;
917 int i;
918
921
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)
925 {
926 int r;
927
928 /* Skip non-shared dependencies, these are handled elsewhere. */
929 if (ps->dependencies[i]->user == NULL)
930 continue;
931
933 objfile, search_flags, domain, search,
934 lookup_name, sym_matcher);
935 if (r != 0)
936 {
938 return true;
939 }
940 }
941
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;
947
948 /* Go through all of the symbols stored in a partial
949 symtab in one loop. */
950 partial_symbol **psym = ps->global_psymbols.data ();
951
952 if ((search_flags & SEARCH_GLOBAL_BLOCK) == 0)
953 {
954 if (ps->static_psymbols.empty ())
955 keep_going = 0;
956 else
957 {
958 psym = ps->static_psymbols.data ();
959 bound = sbound;
960 }
961 }
962
963 while (keep_going)
964 {
965 if (psym >= bound)
966 {
967 if (bound == gbound && !ps->static_psymbols.empty ()
968 && (search_flags & SEARCH_STATIC_BLOCK) != 0)
969 {
970 psym = ps->static_psymbols.data ();
971 bound = sbound;
972 }
973 else
974 keep_going = 0;
975 continue;
976 }
977 else
978 {
979 QUIT;
980
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 ())))
997 {
998 /* Found a match, so notify our caller. */
999 result = PST_SEARCHED_AND_FOUND;
1000 keep_going = 0;
1001 }
1002 }
1003 psym++;
1004 }
1005
1006 ps->searched_flag = result;
1007 return result == PST_SEARCHED_AND_FOUND;
1008}
1009
1010/* Psymtab version of expand_symtabs_matching. See its definition in
1011 the definition of quick_symbol_functions in symfile.h. */
1012
1013bool
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,
1021 domain_enum domain,
1022 enum search_domain search)
1023{
1024 /* Clear the search flags. */
1026 ps->searched_flag = PST_NOT_SEARCHED;
1027
1028 gdb::optional<lookup_name_info> psym_lookup_name;
1029 if (lookup_name != nullptr)
1030 psym_lookup_name = lookup_name->make_ignore_params ();
1031
1032 /* This invariant is documented in quick-functions.h. */
1033 gdb_assert (lookup_name != nullptr || symbol_matcher == nullptr);
1034
1035 for (partial_symtab *ps : m_partial_symtabs->range ())
1036 {
1037 QUIT;
1038
1039 if (ps->readin_p (objfile))
1040 continue;
1041
1042 if (file_matcher)
1043 {
1044 bool match;
1045
1046 if (ps->anonymous)
1047 continue;
1048
1049 match = file_matcher (ps->filename, false);
1050 if (!match)
1051 {
1052 /* Before we invoke realpath, which can get expensive when many
1053 files are involved, do a quick comparison of the basenames. */
1055 || file_matcher (lbasename (ps->filename), true))
1056 match = file_matcher (psymtab_to_fullname (ps), false);
1057 }
1058 if (!match)
1059 continue;
1060 }
1061
1062 if (lookup_name == nullptr
1063 || recursively_search_psymtabs (ps, objfile, search_flags,
1064 domain, search,
1065 *psym_lookup_name,
1066 symbol_matcher))
1067 {
1069
1070 if (cust != nullptr && expansion_notify != nullptr)
1071 if (!expansion_notify (cust))
1072 return false;
1073 }
1074 }
1075
1076 return true;
1077}
1078
1079/* Psymtab version of has_symbols. See its definition in
1080 the definition of quick_symbol_functions in symfile.h. */
1081
1082bool
1084{
1085 return m_partial_symtabs->psymtabs != NULL;
1086}
1087
1088/* See quick_symbol_functions::has_unexpanded_symtabs in quick-symbol.h. */
1089
1090bool
1092{
1093 for (partial_symtab *psymtab : partial_symbols (objfile))
1094 {
1095 /* Is this already expanded? */
1096 if (psymtab->readin_p (objfile))
1097 continue;
1098
1099 /* It has not yet been expanded. */
1100 return true;
1101 }
1102
1103 return false;
1104}
1105
1106/* Helper function for psym_find_compunit_symtab_by_address that fills
1107 in m_psymbol_map for a given range of psymbols. */
1108
1109void
1111 (struct objfile *objfile,
1112 struct partial_symtab *psymtab,
1113 std::set<CORE_ADDR> *seen_addrs,
1114 const std::vector<partial_symbol *> &symbols)
1115{
1116 for (partial_symbol *psym : symbols)
1117 {
1118 if (psym->aclass == LOC_STATIC)
1119 {
1120 CORE_ADDR addr = psym->address (objfile);
1121 if (seen_addrs->find (addr) == seen_addrs->end ())
1122 {
1123 seen_addrs->insert (addr);
1124 m_psymbol_map.emplace_back (addr, psymtab);
1125 }
1126 }
1127 }
1128}
1129
1130/* See find_compunit_symtab_by_address in quick_symbol_functions, in
1131 symfile.h. */
1132
1135 CORE_ADDR address)
1136{
1137 if (m_psymbol_map.empty ())
1138 {
1139 std::set<CORE_ADDR> seen_addrs;
1140
1142 {
1144 &seen_addrs,
1145 pst->global_psymbols);
1147 &seen_addrs,
1148 pst->static_psymbols);
1149 }
1150
1151 m_psymbol_map.shrink_to_fit ();
1152
1153 std::sort (m_psymbol_map.begin (), m_psymbol_map.end (),
1154 [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1155 const std::pair<CORE_ADDR, partial_symtab *> &b)
1156 {
1157 return a.first < b.first;
1158 });
1159 }
1160
1161 auto iter = std::lower_bound
1162 (m_psymbol_map.begin (), m_psymbol_map.end (), address,
1163 [] (const std::pair<CORE_ADDR, partial_symtab *> &a,
1164 CORE_ADDR b)
1165 {
1166 return a.first < b;
1167 });
1168
1169 if (iter == m_psymbol_map.end () || iter->first != address)
1170 return NULL;
1171
1172 return psymtab_to_symtab (objfile, iter->second);
1173}
1174
1175
1176
1177/* Partially fill a partial symtab. It will be completely filled at
1178 the end of the symbol list. */
1179
1181 psymtab_storage *partial_symtabs,
1182 objfile_per_bfd_storage *objfile_per_bfd,
1183 CORE_ADDR textlow)
1184 : partial_symtab (filename, partial_symtabs, objfile_per_bfd)
1185{
1186 set_text_low (textlow);
1187 set_text_high (raw_text_low ()); /* default */
1188}
1189
1190/* Perform "finishing up" operations of a partial symtab. */
1191
1192void
1194{
1195 global_psymbols.shrink_to_fit ();
1196 static_psymbols.shrink_to_fit ();
1197
1198 /* Sort the global list; don't sort the static list. */
1199 std::sort (global_psymbols.begin (),
1200 global_psymbols.end (),
1202 {
1203 return strcmp_iw_ordered (s1->ginfo.search_name (),
1204 s2->ginfo.search_name ()) < 0;
1205 });
1206}
1207
1208/* See psymtab.h. */
1209
1210unsigned long
1211psymbol_bcache::hash (const void *addr, int length)
1212{
1213 unsigned long h = 0;
1214 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1215 unsigned int lang = psymbol->ginfo.language ();
1216 unsigned int domain = psymbol->domain;
1217 unsigned int theclass = psymbol->aclass;
1218
1219 h = fast_hash (&psymbol->ginfo.m_value, sizeof (psymbol->ginfo.m_value), h);
1220 h = fast_hash (&lang, sizeof (unsigned int), h);
1221 h = fast_hash (&domain, sizeof (unsigned int), h);
1222 h = fast_hash (&theclass, sizeof (unsigned int), h);
1223 /* Note that psymbol names are interned via compute_and_set_names, so
1224 there's no need to hash the contents of the name here. */
1225 h = fast_hash (&psymbol->ginfo.m_name, sizeof (psymbol->ginfo.m_name), h);
1226
1227 return h;
1228}
1229
1230/* See psymtab.h. */
1231
1232int
1233psymbol_bcache::compare (const void *addr1, const void *addr2, int length)
1234{
1235 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1236 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1237
1238 return (memcmp (&sym1->ginfo.m_value, &sym2->ginfo.m_value,
1239 sizeof (sym1->ginfo.m_value)) == 0
1240 && sym1->ginfo.language () == sym2->ginfo.language ()
1241 && sym1->domain == sym2->domain
1242 && sym1->aclass == sym2->aclass
1243 /* Note that psymbol names are interned via
1244 compute_and_set_names, so there's no need to compare the
1245 contents of the name here. */
1246 && sym1->ginfo.linkage_name () == sym2->ginfo.linkage_name ());
1247}
1248
1249/* See psympriv.h. */
1250
1251void
1253 psymbol_placement where,
1254 psymtab_storage *partial_symtabs,
1255 struct objfile *objfile)
1256{
1257 bool added;
1258
1259 /* Stash the partial symbol away in the cache. */
1260 partial_symbol *psym
1261 = ((struct partial_symbol *)
1262 partial_symtabs->psymbol_cache.insert
1263 (&psymbol, sizeof (struct partial_symbol), &added));
1264
1265 /* Do not duplicate global partial symbols. */
1266 if (where == psymbol_placement::GLOBAL && !added)
1267 return;
1268
1269 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1270 std::vector<partial_symbol *> &list
1271 = (where == psymbol_placement::STATIC
1273 : global_psymbols);
1274 list.push_back (psym);
1275}
1276
1277/* See psympriv.h. */
1278
1279void
1282 enum address_class theclass,
1283 short section,
1284 psymbol_placement where,
1285 CORE_ADDR coreaddr,
1286 enum language language,
1287 psymtab_storage *partial_symtabs,
1288 struct objfile *objfile)
1289{
1290 struct partial_symbol psymbol;
1291 memset (&psymbol, 0, sizeof (psymbol));
1292
1293 psymbol.set_unrelocated_address (coreaddr);
1294 psymbol.ginfo.set_section_index (section);
1295 psymbol.domain = domain;
1296 psymbol.aclass = theclass;
1297 psymbol.ginfo.set_language (language, partial_symtabs->obstack ());
1299
1300 add_psymbol (psymbol, where, partial_symtabs, objfile);
1301}
1302
1303/* See psympriv.h. */
1304
1305partial_symtab::partial_symtab (const char *filename_,
1306 psymtab_storage *partial_symtabs,
1307 objfile_per_bfd_storage *objfile_per_bfd)
1308 : searched_flag (PST_NOT_SEARCHED),
1309 text_low_valid (0),
1310 text_high_valid (0)
1311{
1312 partial_symtabs->install_psymtab (this);
1313
1314 filename = objfile_per_bfd->intern (filename_);
1315
1316 if (symtab_create_debug >= 1)
1317 {
1318 /* Be a bit clever with debugging messages, and don't print objfile
1319 every time, only when it changes. */
1320 static std::string last_bfd_name;
1321 const char *this_bfd_name
1322 = bfd_get_filename (objfile_per_bfd->get_bfd ());
1323
1324 if (last_bfd_name.empty () || last_bfd_name != this_bfd_name)
1325 {
1326 last_bfd_name = this_bfd_name;
1327
1328 symtab_create_debug_printf ("creating one or more psymtabs for %s",
1329 this_bfd_name);
1330 }
1331
1332 symtab_create_debug_printf ("created psymtab %s for module %s",
1333 host_address_to_string (this), filename);
1334 }
1335}
1336
1337/* See psympriv.h. */
1338
1339void
1341{
1342 for (int i = 0; i < number_of_dependencies; ++i)
1343 {
1344 if (!dependencies[i]->readin_p (objfile)
1345 && dependencies[i]->user == NULL)
1346 {
1347 /* Inform about additional files to be read in. */
1348 if (info_verbose)
1349 {
1350 gdb_puts (" ");
1351 gdb_stdout->wrap_here (0);
1352 gdb_puts ("and ");
1353 gdb_stdout->wrap_here (0);
1354 gdb_printf ("%s...", dependencies[i]->filename);
1356 }
1358 }
1359 }
1360}
1361
1362
1363void
1365{
1366 struct partial_symtab **prev_pst;
1367
1368 /* From dbxread.c:
1369 Empty psymtabs happen as a result of header files which don't
1370 have any symbols in them. There can be a lot of them. But this
1371 check is wrong, in that a psymtab with N_SLINE entries but
1372 nothing else is not empty, but we don't realize that. Fixing
1373 that without slowing things down might be tricky. */
1374
1375 /* First, snip it out of the psymtab chain. */
1376
1377 prev_pst = &psymtabs;
1378 while ((*prev_pst) != pst)
1379 prev_pst = &((*prev_pst)->next);
1380 (*prev_pst) = pst->next;
1381 delete pst;
1382}
1383
1384
1385
1386static void
1387maintenance_print_psymbols (const char *args, int from_tty)
1388{
1389 struct ui_file *outfile = gdb_stdout;
1390 char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
1391 int i, outfile_idx, found;
1392 CORE_ADDR pc = 0;
1393 struct obj_section *section = NULL;
1394
1395 dont_repeat ();
1396
1397 gdb_argv argv (args);
1398
1399 for (i = 0; argv != NULL && argv[i] != NULL; ++i)
1400 {
1401 if (strcmp (argv[i], "-pc") == 0)
1402 {
1403 if (argv[i + 1] == NULL)
1404 error (_("Missing pc value"));
1405 address_arg = argv[++i];
1406 }
1407 else if (strcmp (argv[i], "-source") == 0)
1408 {
1409 if (argv[i + 1] == NULL)
1410 error (_("Missing source file"));
1411 source_arg = argv[++i];
1412 }
1413 else if (strcmp (argv[i], "-objfile") == 0)
1414 {
1415 if (argv[i + 1] == NULL)
1416 error (_("Missing objfile name"));
1417 objfile_arg = argv[++i];
1418 }
1419 else if (strcmp (argv[i], "--") == 0)
1420 {
1421 /* End of options. */
1422 ++i;
1423 break;
1424 }
1425 else if (argv[i][0] == '-')
1426 {
1427 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1428 error (_("Unknown option: %s"), argv[i]);
1429 }
1430 else
1431 break;
1432 }
1433 outfile_idx = i;
1434
1435 if (address_arg != NULL && source_arg != NULL)
1436 error (_("Must specify at most one of -pc and -source"));
1437
1438 stdio_file arg_outfile;
1439
1440 if (argv != NULL && argv[outfile_idx] != NULL)
1441 {
1442 if (argv[outfile_idx + 1] != NULL)
1443 error (_("Junk at end of command"));
1444 gdb::unique_xmalloc_ptr<char> outfile_name
1445 (tilde_expand (argv[outfile_idx]));
1446 if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
1447 perror_with_name (outfile_name.get ());
1448 outfile = &arg_outfile;
1449 }
1450
1451 if (address_arg != NULL)
1452 {
1453 pc = parse_and_eval_address (address_arg);
1454 /* If we fail to find a section, that's ok, try the lookup anyway. */
1455 section = find_pc_section (pc);
1456 }
1457
1458 found = 0;
1460 {
1461 int printed_objfile_header = 0;
1462 int print_for_objfile = 1;
1463
1464 QUIT;
1465 if (objfile_arg != NULL)
1466 print_for_objfile
1468 objfile_arg);
1469 if (!print_for_objfile)
1470 continue;
1471
1472 for (const auto &iter : objfile->qf)
1473 {
1475 = dynamic_cast<psymbol_functions *> (iter.get ());
1476 if (psf == nullptr)
1477 continue;
1478
1479 if (address_arg != NULL)
1480 {
1481 struct bound_minimal_symbol msymbol;
1482
1483 /* We don't assume each pc has a unique objfile (this is for
1484 debugging). */
1485 struct partial_symtab *ps
1486 = psf->find_pc_sect_psymtab (objfile, pc, section, msymbol);
1487 if (ps != NULL)
1488 {
1489 if (!printed_objfile_header)
1490 {
1491 outfile->printf ("\nPartial symtabs for objfile %s\n",
1493 printed_objfile_header = 1;
1494 }
1495 dump_psymtab (objfile, ps, outfile);
1496 found = 1;
1497 }
1498 }
1499 else
1500 {
1501 for (partial_symtab *ps : psf->partial_symbols (objfile))
1502 {
1503 int print_for_source = 0;
1504
1505 QUIT;
1506 if (source_arg != NULL)
1507 {
1508 print_for_source
1509 = compare_filenames_for_search (ps->filename, source_arg);
1510 found = 1;
1511 }
1512 if (source_arg == NULL
1513 || print_for_source)
1514 {
1515 if (!printed_objfile_header)
1516 {
1517 outfile->printf ("\nPartial symtabs for objfile %s\n",
1519 printed_objfile_header = 1;
1520 }
1521 dump_psymtab (objfile, ps, outfile);
1522 }
1523 }
1524 }
1525 }
1526 }
1527
1528 if (!found)
1529 {
1530 if (address_arg != NULL)
1531 error (_("No partial symtab for address: %s"), address_arg);
1532 if (source_arg != NULL)
1533 error (_("No partial symtab for source file: %s"), source_arg);
1534 }
1535}
1536
1537/* List all the partial symbol tables whose names match REGEXP (optional). */
1538
1539static void
1540maintenance_info_psymtabs (const char *regexp, int from_tty)
1541{
1542 if (regexp)
1543 re_comp (regexp);
1544
1545 for (struct program_space *pspace : program_spaces)
1546 for (objfile *objfile : pspace->objfiles ())
1547 {
1548 struct gdbarch *gdbarch = objfile->arch ();
1549
1550 /* We don't want to print anything for this objfile until we
1551 actually find a symtab whose name matches. */
1552 int printed_objfile_start = 0;
1553
1554 for (const auto &iter : objfile->qf)
1555 {
1557 = dynamic_cast<psymbol_functions *> (iter.get ());
1558 if (psf == nullptr)
1559 continue;
1560 for (partial_symtab *psymtab : psf->partial_symbols (objfile))
1561 {
1562 QUIT;
1563
1564 if (! regexp
1565 || re_exec (psymtab->filename))
1566 {
1567 if (! printed_objfile_start)
1568 {
1569 gdb_printf ("{ objfile %s ", objfile_name (objfile));
1570 gdb_stdout->wrap_here (2);
1571 gdb_printf ("((struct objfile *) %s)\n",
1572 host_address_to_string (objfile));
1573 printed_objfile_start = 1;
1574 }
1575
1576 gdb_printf (" { psymtab %s ", psymtab->filename);
1577 gdb_stdout->wrap_here (4);
1578 gdb_printf ("((struct partial_symtab *) %s)\n",
1579 host_address_to_string (psymtab));
1580
1581 gdb_printf (" readin %s\n",
1582 psymtab->readin_p (objfile) ? "yes" : "no");
1583 gdb_printf (" fullname %s\n",
1584 psymtab->fullname
1585 ? psymtab->fullname : "(null)");
1586 gdb_printf (" text addresses ");
1588 psymtab->text_low (objfile)));
1589 gdb_printf (" -- ");
1591 psymtab->text_high (objfile)));
1592 gdb_printf ("\n");
1593 gdb_printf (" globals ");
1594 if (!psymtab->global_psymbols.empty ())
1596 ("(* (struct partial_symbol **) %s @ %d)\n",
1597 host_address_to_string (psymtab->global_psymbols.data ()),
1598 (int) psymtab->global_psymbols.size ());
1599 else
1600 gdb_printf ("(none)\n");
1601 gdb_printf (" statics ");
1602 if (!psymtab->static_psymbols.empty ())
1604 ("(* (struct partial_symbol **) %s @ %d)\n",
1605 host_address_to_string (psymtab->static_psymbols.data ()),
1606 (int) psymtab->static_psymbols.size ());
1607 else
1608 gdb_printf ("(none)\n");
1609 if (psymtab->user)
1610 gdb_printf (" user %s "
1611 "((struct partial_symtab *) %s)\n",
1612 psymtab->user->filename,
1613 host_address_to_string (psymtab->user));
1614 gdb_printf (" dependencies ");
1615 if (psymtab->number_of_dependencies)
1616 {
1617 int i;
1618
1619 gdb_printf ("{\n");
1620 for (i = 0; i < psymtab->number_of_dependencies; i++)
1621 {
1622 struct partial_symtab *dep = psymtab->dependencies[i];
1623
1624 /* Note the string concatenation there --- no
1625 comma. */
1626 gdb_printf (" psymtab %s "
1627 "((struct partial_symtab *) %s)\n",
1628 dep->filename,
1629 host_address_to_string (dep));
1630 }
1631 gdb_printf (" }\n");
1632 }
1633 else
1634 gdb_printf ("(none)\n");
1635 gdb_printf (" }\n");
1636 }
1637 }
1638 }
1639
1640 if (printed_objfile_start)
1641 gdb_printf ("}\n");
1642 }
1643}
1644
1645/* Check consistency of currently expanded psymtabs vs symtabs. */
1646
1647static void
1648maintenance_check_psymtabs (const char *ignore, int from_tty)
1649{
1650 struct symbol *sym;
1651 struct compunit_symtab *cust = NULL;
1652 const struct blockvector *bv;
1653 const struct block *b;
1654
1656 {
1657 for (const auto &iter : objfile->qf)
1658 {
1660 = dynamic_cast<psymbol_functions *> (iter.get ());
1661 if (psf == nullptr)
1662 continue;
1663
1664 for (partial_symtab *ps : psf->partial_symbols (objfile))
1665 {
1666 struct gdbarch *gdbarch = objfile->arch ();
1667
1668 /* We don't call psymtab_to_symtab here because that may cause symtab
1669 expansion. When debugging a problem it helps if checkers leave
1670 things unchanged. */
1671 cust = ps->get_compunit_symtab (objfile);
1672
1673 /* First do some checks that don't require the associated symtab. */
1674 if (ps->text_high (objfile) < ps->text_low (objfile))
1675 {
1676 gdb_printf ("Psymtab ");
1677 gdb_puts (ps->filename);
1678 gdb_printf (" covers bad range ");
1679 gdb_puts (paddress (gdbarch, ps->text_low (objfile)));
1680 gdb_printf (" - ");
1681 gdb_puts (paddress (gdbarch, ps->text_high (objfile)));
1682 gdb_printf ("\n");
1683 continue;
1684 }
1685
1686 /* Now do checks requiring the associated symtab. */
1687 if (cust == NULL)
1688 continue;
1689 bv = cust->blockvector ();
1690 b = bv->static_block ();
1691 for (partial_symbol *psym : ps->static_psymbols)
1692 {
1693 /* Skip symbols for inlined functions without address. These may
1694 or may not have a match in the full symtab. */
1695 if (psym->aclass == LOC_BLOCK
1696 && psym->ginfo.value_address () == 0)
1697 continue;
1698
1699 sym = block_lookup_symbol (b, psym->ginfo.search_name (),
1701 psym->domain);
1702 if (!sym)
1703 {
1704 gdb_printf ("Static symbol `");
1705 gdb_puts (psym->ginfo.linkage_name ());
1706 gdb_printf ("' only found in ");
1707 gdb_puts (ps->filename);
1708 gdb_printf (" psymtab\n");
1709 }
1710 }
1711 b = bv->global_block ();
1712 for (partial_symbol *psym : ps->global_psymbols)
1713 {
1714 sym = block_lookup_symbol (b, psym->ginfo.search_name (),
1716 psym->domain);
1717 if (!sym)
1718 {
1719 gdb_printf ("Global symbol `");
1720 gdb_puts (psym->ginfo.linkage_name ());
1721 gdb_printf ("' only found in ");
1722 gdb_puts (ps->filename);
1723 gdb_printf (" psymtab\n");
1724 }
1725 }
1726 if (ps->raw_text_high () != 0
1727 && (ps->text_low (objfile) < b->start ()
1728 || ps->text_high (objfile) > b->end ()))
1729 {
1730 gdb_printf ("Psymtab ");
1731 gdb_puts (ps->filename);
1732 gdb_printf (" covers ");
1733 gdb_puts (paddress (gdbarch, ps->text_low (objfile)));
1734 gdb_printf (" - ");
1735 gdb_puts (paddress (gdbarch, ps->text_high (objfile)));
1736 gdb_printf (" but symtab covers only ");
1737 gdb_puts (paddress (gdbarch, b->start ()));
1738 gdb_printf (" - ");
1739 gdb_puts (paddress (gdbarch, b->end ()));
1740 gdb_printf ("\n");
1741 }
1742 }
1743 }
1744 }
1745}
1746
1747void _initialize_psymtab ();
1748void
1750{
1752Print dump of current partial symbol definitions.\n\
1753Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
1754 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1755Entries in the partial symbol table are dumped to file OUTFILE,\n\
1756or the terminal if OUTFILE is unspecified.\n\
1757If ADDRESS is provided, dump only the file for that address.\n\
1758If SOURCE is provided, dump only that file's symbols.\n\
1759If OBJFILE is provided, dump only that file's minimal symbols."),
1761
1763List the partial symbol tables for all object files.\n\
1764This does not include information about individual partial symbols,\n\
1765just the symbol table structures themselves."),
1767
1769 _("\
1770Check consistency of currently expanded psymtabs versus symtabs."),
1772}
const char *const name
void xfree(void *)
constexpr std::string_view s1
Definition 2.cc:26
constexpr std::string_view s2
Definition 2.cc:27
struct symbol * block_lookup_symbol(const struct block *block, const char *name, symbol_name_match_type match_type, const domain_enum domain)
Definition block.c:706
const char * c_str() const
Definition symtab.h:245
lookup_name_info make_ignore_params() const
Definition symtab.h:255
struct partial_symtab * psymtabs
Definition psymtab.h:122
void discard_psymtab(struct partial_symtab *pst)
Definition psymtab.c:1364
void install_psymtab(partial_symtab *pst)
Definition psymtab.c:71
next_range< partial_symtab > partial_symtab_range
Definition psymtab.h:107
struct obstack * obstack()
Definition psymtab.h:87
psymbol_bcache psymbol_cache
Definition psymtab.h:127
bool open(const char *name, const char *mode)
Definition ui-file.c:263
void printf(const char *,...) ATTRIBUTE_PRINTF(2
Definition ui-file.c:40
struct cmd_list_element * maintenanceprintlist
Definition cli-cmds.c:149
struct cmd_list_element * maintenancelist
Definition cli-cmds.c:141
struct cmd_list_element * maintenanceinfolist
Definition cli-cmds.c:145
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void dont_repeat()
Definition top.c:809
@ class_maintenance
Definition command.h:65
EXTERN_C char * re_comp(const char *)
bool info_verbose
Definition top.c:2022
language
Definition defs.h:211
@ language_unknown
Definition defs.h:212
#define QUIT
Definition defs.h:186
CORE_ADDR parse_and_eval_address(const char *exp)
Definition eval.c:52
static void keep_going(struct execution_control_state *ecs)
Definition infrun.c:8245
const struct language_defn * language_def(enum language lang)
Definition language.c:442
@ OBJF_PSYMTABS_READ
@ OBJF_REORDERED
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1170
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1308
std::string copy_name(struct stoken token)
Definition parse.c:407
struct program_space * current_program_space
Definition progspace.c:39
std::vector< struct program_space * > program_spaces
Definition progspace.c:36
psymtab_search_status
Definition psympriv.h:88
@ PST_NOT_SEARCHED
Definition psympriv.h:89
@ PST_SEARCHED_AND_NOT_FOUND
Definition psympriv.h:91
@ PST_SEARCHED_AND_FOUND
Definition psympriv.h:90
psymbol_placement
Definition psympriv.h:98
static struct compunit_symtab * psymtab_to_symtab(struct objfile *objfile, struct partial_symtab *pst)
Definition psymtab.c:505
static struct partial_symbol * match_partial_symbol(struct objfile *objfile, struct partial_symtab *pst, int global, const lookup_name_info &name, domain_enum domain, symbol_compare_ftype *ordered_compare)
Definition psymtab.c:331
static void print_partial_symbols(struct gdbarch *gdbarch, struct objfile *objfile, const std::vector< partial_symbol * > &symbols, const char *what, struct ui_file *outfile)
Definition psymtab.c:588
void _initialize_psymtab()
Definition psymtab.c:1749
static bool recursively_search_psymtabs(struct partial_symtab *ps, struct objfile *objfile, block_search_flags search_flags, domain_enum domain, enum search_domain search, const lookup_name_info &lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > sym_matcher)
Definition psymtab.c:907
static void dump_psymtab(struct objfile *objfile, struct partial_symtab *psymtab, struct ui_file *outfile)
Definition psymtab.c:685
static bool psymbol_name_matches(partial_symbol *psym, const lookup_name_info &lookup_name)
Definition psymtab.c:313
static void maintenance_check_psymtabs(const char *ignore, int from_tty)
Definition psymtab.c:1648
static struct partial_symbol * find_pc_sect_psymbol(struct objfile *, struct partial_symtab *, CORE_ADDR, struct obj_section *)
Definition psymtab.c:219
static void maintenance_info_psymtabs(const char *regexp, int from_tty)
Definition psymtab.c:1540
static struct partial_symtab * find_pc_sect_psymtab_closer(struct objfile *objfile, CORE_ADDR pc, struct obj_section *section, struct partial_symtab *pst, struct bound_minimal_symbol msymbol)
Definition psymtab.c:92
static struct partial_symbol * lookup_partial_symbol(struct objfile *, struct partial_symtab *, const lookup_name_info &, int, domain_enum)
Definition psymtab.c:411
static void maintenance_print_psymbols(const char *args, int from_tty)
Definition psymtab.c:1387
static const char * psymtab_to_fullname(struct partial_symtab *ps)
Definition psymtab.c:863
int() symbol_compare_ftype(const char *string1, const char *string2)
@ SEARCH_GLOBAL_BLOCK
@ SEARCH_STATIC_BLOCK
gdb::unique_xmalloc_ptr< char > find_source_or_rewrite(const char *filename, const char *dirname)
Definition source.c:1217
Definition block.h:109
CORE_ADDR start() const
Definition block.h:111
CORE_ADDR end() const
Definition block.h:119
struct block * static_block()
Definition block.h:302
struct block * global_block()
Definition block.h:294
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
symtab * primary_filetab() const
Definition symtab.c:397
struct blockvector * blockvector()
Definition symtab.h:1773
const void * insert(const void *addr, int length, bool *added=nullptr)
Definition bcache.c:143
union general_symbol_info::@177 m_value
void set_section_index(short idx)
Definition symtab.h:597
void compute_and_set_names(gdb::string_view linkage_name, bool copy_name, struct objfile_per_bfd_storage *per_bfd, gdb::optional< hashval_t > hash=gdb::optional< hashval_t >())
Definition symtab.c:914
const char * search_name() const
Definition symtab.c:1077
enum language language() const
Definition symtab.h:501
void set_language(enum language language, struct obstack *obstack)
Definition symtab.c:771
const char * m_name
Definition symtab.h:532
const char * linkage_name() const
Definition symtab.h:459
symbol_name_matcher_ftype * get_symbol_name_matcher(const lookup_name_info &lookup_name) const
Definition language.c:686
const char * intern(const char *str)
Definition objfiles.h:244
bfd * get_bfd() const
Definition objfiles.h:258
const struct sym_fns * sf
Definition objfiles.h:681
struct gdbarch * arch() const
Definition objfiles.h:482
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:657
objfile_flags flags
Definition objfiles.h:637
std::forward_list< quick_symbol_functions_up > qf
Definition objfiles.h:685
__extension__ enum domain_enum domain
Definition psympriv.h:74
CORE_ADDR address(const struct objfile *objfile) const
Definition psympriv.h:54
struct general_symbol_info ginfo
Definition psympriv.h:70
__extension__ enum address_class aclass
Definition psympriv.h:80
void set_unrelocated_address(CORE_ADDR addr)
Definition psympriv.h:62
struct partial_symtab * user
Definition psympriv.h:316
virtual struct compunit_symtab * get_compunit_symtab(struct objfile *) const =0
struct partial_symtab ** dependencies
Definition psympriv.h:327
std::vector< partial_symbol * > static_psymbols
Definition psympriv.h:344
CORE_ADDR raw_text_low() const
Definition psympriv.h:175
partial_symtab(const char *filename, psymtab_storage *partial_symtabs, objfile_per_bfd_storage *objfile_per_bfd) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
Definition psymtab.c:1305
const char * dirname
Definition psympriv.h:277
__extension__ enum psymtab_search_status searched_flag
Definition psympriv.h:352
const char * filename
Definition psympriv.h:269
virtual bool readin_p(struct objfile *) const =0
void set_text_low(CORE_ADDR addr)
Definition psympriv.h:199
virtual void expand_psymtab(struct objfile *)=0
std::vector< partial_symbol * > global_psymbols
Definition psympriv.h:335
int number_of_dependencies
Definition psympriv.h:329
virtual void read_symtab(struct objfile *)=0
struct partial_symtab * next
Definition psympriv.h:263
CORE_ADDR text_high(struct objfile *objfile) const
Definition psympriv.h:193
void expand_dependencies(struct objfile *)
Definition psymtab.c:1340
void add_psymbol(gdb::string_view name, bool copy_name, domain_enum domain, enum address_class theclass, short section, psymbol_placement where, CORE_ADDR coreaddr, enum language language, psymtab_storage *partial_symtabs, struct objfile *objfile)
Definition psymtab.c:1280
void set_text_high(CORE_ADDR addr)
Definition psympriv.h:206
CORE_ADDR text_low(struct objfile *objfile) const
Definition psympriv.h:187
char * fullname
Definition psympriv.h:273
objfiles_range objfiles()
Definition progspace.h:209
unsigned long hash(const void *addr, int length) override
Definition psymtab.c:1211
int compare(const void *left, const void *right, int length) override
Definition psymtab.c:1233
enum language lookup_global_symbol_language(struct objfile *objfile, const char *name, domain_enum domain, bool *symbol_found_p) override
Definition psymtab.c:282
struct compunit_symtab * find_pc_sect_compunit_symtab(struct objfile *objfile, struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin) override
Definition psymtab.c:191
void dump(struct objfile *objfile) override
Definition psymtab.c:793
void print_stats(struct objfile *objfile, bool print_bcache) override
Definition psymtab.c:759
void expand_matching_symbols(struct objfile *, const lookup_name_info &lookup_name, domain_enum domain, int global, symbol_compare_ftype *ordered_compare) override
Definition psymtab.c:885
struct compunit_symtab * find_compunit_symtab_by_address(struct objfile *objfile, CORE_ADDR address) override
Definition psymtab.c:1134
void fill_psymbol_map(struct objfile *objfile, struct partial_symtab *psymtab, std::set< CORE_ADDR > *seen_addrs, const std::vector< partial_symbol * > &symbols)
Definition psymtab.c:1111
void expand_all_symtabs(struct objfile *objfile) override
Definition psymtab.c:814
psymtab_storage::partial_symtab_range partial_symbols(struct objfile *objfile)
Definition psymtab.c:82
void forget_cached_source_info(struct objfile *objfile) override
Definition psymtab.c:575
void map_symbol_filenames(struct objfile *objfile, gdb::function_view< symbol_filename_ftype > fun, bool need_fullname) override
Definition psymtab.c:825
struct symtab * find_last_source_symtab(struct objfile *objfile) override
Definition psymtab.c:538
std::shared_ptr< psymtab_storage > m_partial_symtabs
Definition psympriv.h:590
bool has_unexpanded_symtabs(struct objfile *objfile) override
Definition psymtab.c:1091
struct partial_symtab * find_pc_sect_psymtab(struct objfile *objfile, CORE_ADDR pc, struct obj_section *section, struct bound_minimal_symbol msymbol)
Definition psymtab.c:167
std::vector< std::pair< CORE_ADDR, partial_symtab * > > m_psymbol_map
Definition psympriv.h:595
bool expand_symtabs_matching(struct objfile *objfile, gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info *lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, domain_enum domain, enum search_domain kind) override
Definition psymtab.c:1015
bool has_symbols(struct objfile *objfile) override
Definition psymtab.c:1083
scoped_restore_tmpl< int > increment_reading_symtab(void)
Definition symfile.c:187
bool symbol_matches_search_name(const struct general_symbol_info *gsymbol, const lookup_name_info &name)
Definition symtab.c:1098
bool compare_filenames_for_search(const char *filename, const char *search_name)
Definition symtab.c:461
bool basenames_may_differ
Definition symtab.c:273
bool matching_obj_sections(struct obj_section *obj_first, struct obj_section *obj_second)
Definition symtab.c:1113
bool symbol_matches_domain(enum language symbol_language, domain_enum symbol_domain, domain_enum domain)
Definition symtab.c:2649
unsigned int symtab_create_debug
Definition symtab.c:257
search_domain
Definition symtab.h:916
@ VARIABLES_DOMAIN
Definition symtab.h:919
@ FUNCTIONS_DOMAIN
Definition symtab.h:922
@ TYPES_DOMAIN
Definition symtab.h:925
@ MODULES_DOMAIN
Definition symtab.h:928
@ ALL_DOMAIN
Definition symtab.h:931
bool() symbol_name_matcher_ftype(const char *symbol_search_name, const lookup_name_info &lookup_name, completion_match_result *comp_match_res)
Definition symtab.h:398
address_class
Definition symtab.h:939
@ LOC_STATIC
Definition symtab.h:950
@ LOC_BLOCK
Definition symtab.h:999
@ LOC_LABEL
Definition symtab.h:993
@ LOC_REGISTER
Definition symtab.h:964
@ LOC_REF_ARG
Definition symtab.h:972
@ LOC_UNRESOLVED
Definition symtab.h:1028
@ LOC_LOCAL
Definition symtab.h:984
@ LOC_CONST
Definition symtab.h:946
@ LOC_CONST_BYTES
Definition symtab.h:1004
@ LOC_UNDEF
Definition symtab.h:942
@ LOC_OPTIMIZED_OUT
Definition symtab.h:1033
@ LOC_TYPEDEF
Definition symtab.h:989
@ LOC_REGPARM_ADDR
Definition symtab.h:980
@ LOC_COMPUTED
Definition symtab.h:1037
@ LOC_ARG
Definition symtab.h:968
domain_enum
Definition symtab.h:871
@ VAR_DOMAIN
Definition symtab.h:881
@ STRUCT_DOMAIN
Definition symtab.h:887
@ LABEL_DOMAIN
Definition symtab.h:895
@ COMMON_BLOCK_DOMAIN
Definition symtab.h:899
@ UNDEF_DOMAIN
Definition symtab.h:876
@ MODULE_DOMAIN
Definition symtab.h:891
#define symtab_create_debug_printf(fmt,...)
Definition symtab.h:2617
void perror_with_name(const char *string)
Definition utils.c:643
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
int strcmp_iw_ordered(const char *string1, const char *string2)
Definition utils.c:3025
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
void gdb_flush(struct ui_file *stream)
Definition utils.c:1477
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1788
static unsigned int fast_hash(const void *ptr, size_t len, unsigned int start_value=0)
Definition utils.h:357
#define gdb_stdout
Definition utils.h:188