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