1 /* Partial symbol tables.
3 Copyright (C) 2009-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "filenames.h"
31 #include "readline/tilde.h"
32 #include "gdb_regex.h"
33 #include "dictionary.h"
35 #include "cp-support.h"
40 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
41 struct partial_symtab
*,
42 const lookup_name_info
&,
46 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
48 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
49 struct partial_symtab
*,
51 struct obj_section
*);
53 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
54 struct partial_symtab
*pst
);
58 static unsigned long psymbol_hash (const void *addr
, int length
);
59 static int psymbol_compare (const void *addr1
, const void *addr2
, int length
);
61 psymtab_storage::psymtab_storage ()
62 : psymbol_cache (psymbol_hash
, psymbol_compare
)
66 psymtab_storage::~psymtab_storage ()
68 partial_symtab
*iter
= psymtabs
;
69 while (iter
!= nullptr)
71 partial_symtab
*next
= iter
->next
;
80 psymtab_storage::install_psymtab (partial_symtab
*pst
)
90 psymtab_storage::partial_symtab_range
91 require_partial_symbols (struct objfile
*objfile
, bool verbose
)
93 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
95 objfile
->flags
|= OBJF_PSYMTABS_READ
;
97 if (objfile
->sf
->sym_read_psymbols
)
100 printf_filtered (_("Reading symbols from %s...\n"),
101 objfile_name (objfile
));
102 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
104 /* Partial symbols list are not expected to changed after this
106 objfile
->partial_symtabs
->global_psymbols
.shrink_to_fit ();
107 objfile
->partial_symtabs
->static_psymbols
.shrink_to_fit ();
109 if (verbose
&& !objfile_has_symbols (objfile
))
110 printf_filtered (_("(No debugging symbols found in %s)\n"),
111 objfile_name (objfile
));
115 return objfile
->psymtabs ();
118 /* Helper function for psym_map_symtabs_matching_filename that
119 expands the symtabs and calls the iterator. */
122 partial_map_expand_apply (struct objfile
*objfile
,
124 const char *real_path
,
125 struct partial_symtab
*pst
,
126 gdb::function_view
<bool (symtab
*)> callback
)
128 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
130 /* Shared psymtabs should never be seen here. Instead they should
131 be handled properly by the caller. */
132 gdb_assert (pst
->user
== NULL
);
134 /* Don't visit already-expanded psymtabs. */
135 if (pst
->readin_p ())
138 /* This may expand more than one symtab, and we want to iterate over
140 psymtab_to_symtab (objfile
, pst
);
142 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
143 last_made
, callback
);
146 /* Psymtab version of map_symtabs_matching_filename. See its definition in
147 the definition of quick_symbol_functions in symfile.h. */
150 psym_map_symtabs_matching_filename
151 (struct objfile
*objfile
,
153 const char *real_path
,
154 gdb::function_view
<bool (symtab
*)> callback
)
156 const char *name_basename
= lbasename (name
);
158 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
160 /* We can skip shared psymtabs here, because any file name will be
161 attached to the unshared psymtab. */
162 if (pst
->user
!= NULL
)
165 /* Anonymous psymtabs don't have a file name. */
169 if (compare_filenames_for_search (pst
->filename
, name
))
171 if (partial_map_expand_apply (objfile
, name
, real_path
,
177 /* Before we invoke realpath, which can get expensive when many
178 files are involved, do a quick comparison of the basenames. */
179 if (! basenames_may_differ
180 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
183 if (compare_filenames_for_search (psymtab_to_fullname (pst
), name
))
185 if (partial_map_expand_apply (objfile
, name
, real_path
,
191 /* If the user gave us an absolute path, try to find the file in
192 this symtab and use its absolute path. */
193 if (real_path
!= NULL
)
195 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
196 gdb_assert (IS_ABSOLUTE_PATH (name
));
197 if (filename_cmp (psymtab_to_fullname (pst
), real_path
) == 0)
199 if (partial_map_expand_apply (objfile
, name
, real_path
,
210 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
211 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
213 static struct partial_symtab
*
214 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
215 CORE_ADDR pc
, struct obj_section
*section
,
216 struct partial_symtab
*pst
,
217 struct bound_minimal_symbol msymbol
)
219 struct partial_symtab
*tpst
;
220 struct partial_symtab
*best_pst
= pst
;
221 CORE_ADDR best_addr
= pst
->text_low (objfile
);
223 gdb_assert (!pst
->psymtabs_addrmap_supported
);
225 /* An objfile that has its functions reordered might have
226 many partial symbol tables containing the PC, but
227 we want the partial symbol table that contains the
228 function containing the PC. */
229 if (!(objfile
->flags
& OBJF_REORDERED
)
230 && section
== NULL
) /* Can't validate section this way. */
233 if (msymbol
.minsym
== NULL
)
236 /* The code range of partial symtabs sometimes overlap, so, in
237 the loop below, we need to check all partial symtabs and
238 find the one that fits better for the given PC address. We
239 select the partial symtab that contains a symbol whose
240 address is closest to the PC address. By closest we mean
241 that find_pc_sect_symbol returns the symbol with address
242 that is closest and still less than the given PC. */
243 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
245 if (pc
>= tpst
->text_low (objfile
) && pc
< tpst
->text_high (objfile
))
247 struct partial_symbol
*p
;
250 /* NOTE: This assumes that every psymbol has a
251 corresponding msymbol, which is not necessarily
252 true; the debug info might be much richer than the
253 object's symbol table. */
254 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
256 && (p
->address (objfile
) == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
259 /* Also accept the textlow value of a psymtab as a
260 "symbol", to provide some support for partial
261 symbol tables with line information but no debug
262 symbols (e.g. those produced by an assembler). */
264 this_addr
= p
->address (objfile
);
266 this_addr
= tpst
->text_low (objfile
);
268 /* Check whether it is closer than our current
269 BEST_ADDR. Since this symbol address is
270 necessarily lower or equal to PC, the symbol closer
271 to PC is the symbol which address is the highest.
272 This way we return the psymtab which contains such
273 best match symbol. This can help in cases where the
274 symbol information/debuginfo is not complete, like
275 for instance on IRIX6 with gcc, where no debug info
276 is emitted for statics. (See also the nodebug.exp
278 if (this_addr
> best_addr
)
280 best_addr
= this_addr
;
288 /* Find which partial symtab contains PC and SECTION. Return NULL if
289 none. We return the psymtab that contains a symbol whose address
290 exactly matches PC, or, if we cannot find an exact match, the
291 psymtab that contains a symbol whose address is closest to PC. */
293 static struct partial_symtab
*
294 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
295 struct obj_section
*section
,
296 struct bound_minimal_symbol msymbol
)
298 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better
299 granularity than the later used TEXTLOW/TEXTHIGH one. However, we need
300 to take care as the PSYMTABS_ADDRMAP can hold things other than partial
301 symtabs in some cases.
303 This function should only be called for objfiles that are using partial
304 symtabs, not for objfiles that are using indexes (.gdb_index or
305 .debug_names), however 'maintenance print psymbols' calls this function
306 directly for all objfiles. If we assume that PSYMTABS_ADDRMAP contains
307 partial symtabs then we will end up returning a pointer to an object
308 that is not a partial_symtab, which doesn't end well. */
310 if (objfile
->partial_symtabs
->psymtabs
!= NULL
311 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
313 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
315 struct partial_symtab
*pst
316 = ((struct partial_symtab
*)
317 addrmap_find (objfile
->partial_symtabs
->psymtabs_addrmap
,
321 /* FIXME: addrmaps currently do not handle overlayed sections,
322 so fall back to the non-addrmap case if we're debugging
323 overlays and the addrmap returned the wrong section. */
324 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
326 struct partial_symbol
*p
;
328 /* NOTE: This assumes that every psymbol has a
329 corresponding msymbol, which is not necessarily
330 true; the debug info might be much richer than the
331 object's symbol table. */
332 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
334 || (p
->address (objfile
)
335 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
339 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
340 PSYMTABS_ADDRMAP we used has already the best 1-byte
341 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
342 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
351 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
352 which still have no corresponding full SYMTABs read. But it is not
353 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
356 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
357 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
358 debug info type in single OBJFILE. */
360 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
361 if (!pst
->psymtabs_addrmap_supported
362 && pc
>= pst
->text_low (objfile
) && pc
< pst
->text_high (objfile
))
364 struct partial_symtab
*best_pst
;
366 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
368 if (best_pst
!= NULL
)
375 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
376 the definition of quick_symbol_functions in symfile.h. */
378 static struct compunit_symtab
*
379 psym_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
380 struct bound_minimal_symbol msymbol
,
382 struct obj_section
*section
,
385 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
389 if (warn_if_readin
&& ps
->readin_p ())
390 /* Might want to error() here (in case symtab is corrupt and
391 will cause a core dump), but maybe we can successfully
392 continue, so let's not. */
394 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
395 paddress (objfile
->arch (), pc
));
396 psymtab_to_symtab (objfile
, ps
);
397 return ps
->get_compunit_symtab ();
402 /* Find which partial symbol within a psymtab matches PC and SECTION.
403 Return NULL if none. */
405 static struct partial_symbol
*
406 find_pc_sect_psymbol (struct objfile
*objfile
,
407 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
408 struct obj_section
*section
)
410 struct partial_symbol
*best
= NULL
;
412 const CORE_ADDR textlow
= psymtab
->text_low (objfile
);
414 gdb_assert (psymtab
!= NULL
);
416 /* Cope with programs that start at address 0. */
417 best_pc
= (textlow
!= 0) ? textlow
- 1 : 0;
419 /* Search the global symbols as well as the static symbols, so that
420 find_pc_partial_function doesn't use a minimal symbol and thus
421 cache a bad endaddr. */
422 for (int i
= 0; i
< psymtab
->n_global_syms
; i
++)
425 = objfile
->partial_symtabs
->global_psymbols
[psymtab
->globals_offset
428 if (p
->domain
== VAR_DOMAIN
429 && p
->aclass
== LOC_BLOCK
430 && pc
>= p
->address (objfile
)
431 && (p
->address (objfile
) > best_pc
432 || (psymtab
->text_low (objfile
) == 0
433 && best_pc
== 0 && p
->address (objfile
) == 0)))
435 if (section
!= NULL
) /* Match on a specific section. */
437 if (!matching_obj_sections (p
->obj_section (objfile
),
441 best_pc
= p
->address (objfile
);
446 for (int i
= 0; i
< psymtab
->n_static_syms
; i
++)
449 = objfile
->partial_symtabs
->static_psymbols
[psymtab
->statics_offset
452 if (p
->domain
== VAR_DOMAIN
453 && p
->aclass
== LOC_BLOCK
454 && pc
>= p
->address (objfile
)
455 && (p
->address (objfile
) > best_pc
456 || (psymtab
->text_low (objfile
) == 0
457 && best_pc
== 0 && p
->address (objfile
) == 0)))
459 if (section
!= NULL
) /* Match on a specific section. */
461 if (!matching_obj_sections (p
->obj_section (objfile
),
465 best_pc
= p
->address (objfile
);
473 /* Psymtab version of lookup_symbol. See its definition in
474 the definition of quick_symbol_functions in symfile.h. */
476 static struct compunit_symtab
*
477 psym_lookup_symbol (struct objfile
*objfile
,
478 block_enum block_index
, const char *name
,
479 const domain_enum domain
)
481 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
482 struct compunit_symtab
*stab_best
= NULL
;
484 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
486 lookup_name_info psym_lookup_name
= lookup_name
.make_ignore_params ();
488 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
490 if (!ps
->readin_p () && lookup_partial_symbol (objfile
, ps
,
492 psymtab_index
, domain
))
494 struct symbol
*sym
, *with_opaque
= NULL
;
495 struct compunit_symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
496 /* Note: While psymtab_to_symtab can return NULL if the
497 partial symtab is empty, we can assume it won't here
498 because lookup_partial_symbol succeeded. */
499 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
500 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
502 sym
= block_find_symbol (block
, name
, domain
,
503 block_find_non_opaque_type_preferred
,
506 /* Some caution must be observed with overloaded functions
507 and methods, since the index will not contain any overload
508 information (but NAME might contain it). */
511 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
513 if (with_opaque
!= NULL
514 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
517 /* Keep looking through other psymtabs. */
524 /* Psymtab version of lookup_global_symbol_language. See its definition in
525 the definition of quick_symbol_functions in symfile.h. */
528 psym_lookup_global_symbol_language (struct objfile
*objfile
, const char *name
,
529 domain_enum domain
, bool *symbol_found_p
)
531 *symbol_found_p
= false;
532 if (objfile
->sf
== NULL
)
533 return language_unknown
;
535 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
537 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
539 struct partial_symbol
*psym
;
543 psym
= lookup_partial_symbol (objfile
, ps
, lookup_name
, 1, domain
);
546 *symbol_found_p
= true;
547 return psym
->ginfo
.language ();
551 return language_unknown
;
554 /* Returns true if PSYM matches LOOKUP_NAME. */
557 psymbol_name_matches (partial_symbol
*psym
,
558 const lookup_name_info
&lookup_name
)
560 const language_defn
*lang
= language_def (psym
->ginfo
.language ());
561 symbol_name_matcher_ftype
*name_match
562 = get_symbol_name_matcher (lang
, lookup_name
);
563 return name_match (psym
->ginfo
.search_name (), lookup_name
, NULL
);
566 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
567 the global block of PST if GLOBAL, and otherwise the static block.
568 MATCH is the comparison operation that returns true iff MATCH (s,
569 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
570 non-null, the symbols in the block are assumed to be ordered
571 according to it (allowing binary search). It must be compatible
572 with MATCH. Returns the symbol, if found, and otherwise NULL. */
574 static struct partial_symbol
*
575 match_partial_symbol (struct objfile
*objfile
,
576 struct partial_symtab
*pst
, int global
,
577 const lookup_name_info
&name
, domain_enum domain
,
578 symbol_compare_ftype
*ordered_compare
)
580 struct partial_symbol
**start
, **psym
;
581 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
582 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
583 int do_linear_search
= 1;
589 &objfile
->partial_symtabs
->global_psymbols
[pst
->globals_offset
] :
590 &objfile
->partial_symtabs
->static_psymbols
[pst
->statics_offset
]);
592 if (global
&& ordered_compare
) /* Can use a binary search. */
594 do_linear_search
= 0;
596 /* Binary search. This search is guaranteed to end with center
597 pointing at the earliest partial symbol whose name might be
598 correct. At that point *all* partial symbols with an
599 appropriate name will be checked against the correct
603 top
= start
+ length
- 1;
607 center
= bottom
+ (top
- bottom
) / 2;
608 gdb_assert (center
< top
);
610 enum language lang
= (*center
)->ginfo
.language ();
611 const char *lang_ln
= name
.language_lookup_name (lang
);
613 if (ordered_compare ((*center
)->ginfo
.search_name (),
619 gdb_assert (top
== bottom
);
621 while (top
<= real_top
622 && psymbol_name_matches (*top
, name
))
624 if (symbol_matches_domain ((*top
)->ginfo
.language (),
625 (*top
)->domain
, domain
))
631 /* Can't use a binary search or else we found during the binary search that
632 we should also do a linear search. */
634 if (do_linear_search
)
636 for (psym
= start
; psym
< start
+ length
; psym
++)
638 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
639 (*psym
)->domain
, domain
)
640 && psymbol_name_matches (*psym
, name
))
648 /* Look, in partial_symtab PST, for symbol whose natural name is
649 LOOKUP_NAME. Check the global symbols if GLOBAL, the static
652 static struct partial_symbol
*
653 lookup_partial_symbol (struct objfile
*objfile
,
654 struct partial_symtab
*pst
,
655 const lookup_name_info
&lookup_name
,
656 int global
, domain_enum domain
)
658 struct partial_symbol
**start
, **psym
;
659 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
660 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
661 int do_linear_search
= 1;
667 &objfile
->partial_symtabs
->global_psymbols
[pst
->globals_offset
] :
668 &objfile
->partial_symtabs
->static_psymbols
[pst
->statics_offset
]);
670 if (global
) /* This means we can use a binary search. */
672 do_linear_search
= 0;
674 /* Binary search. This search is guaranteed to end with center
675 pointing at the earliest partial symbol whose name might be
676 correct. At that point *all* partial symbols with an
677 appropriate name will be checked against the correct
681 top
= start
+ length
- 1;
685 center
= bottom
+ (top
- bottom
) / 2;
687 gdb_assert (center
< top
);
689 if (strcmp_iw_ordered ((*center
)->ginfo
.search_name (),
690 lookup_name
.c_str ()) >= 0)
700 gdb_assert (top
== bottom
);
702 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
703 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
704 while (top
>= start
&& symbol_matches_search_name (&(*top
)->ginfo
,
708 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
711 while (top
<= real_top
&& symbol_matches_search_name (&(*top
)->ginfo
,
714 if (symbol_matches_domain ((*top
)->ginfo
.language (),
715 (*top
)->domain
, domain
))
721 /* Can't use a binary search or else we found during the binary search that
722 we should also do a linear search. */
724 if (do_linear_search
)
726 for (psym
= start
; psym
< start
+ length
; psym
++)
728 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
729 (*psym
)->domain
, domain
)
730 && symbol_matches_search_name (&(*psym
)->ginfo
, lookup_name
))
738 /* Get the symbol table that corresponds to a partial_symtab.
739 This is fast after the first time you do it.
740 The result will be NULL if the primary symtab has no symbols,
741 which can happen. Otherwise the result is the primary symtab
742 that contains PST. */
744 static struct compunit_symtab
*
745 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
747 /* If it is a shared psymtab, find an unshared psymtab that includes
748 it. Any such psymtab will do. */
749 while (pst
->user
!= NULL
)
752 /* If it's been looked up before, return it. */
753 if (pst
->get_compunit_symtab ())
754 return pst
->get_compunit_symtab ();
756 /* If it has not yet been read in, read it. */
757 if (!pst
->readin_p ())
759 scoped_restore decrementer
= increment_reading_symtab ();
763 printf_filtered (_("Reading in symbols for %s...\n"),
765 gdb_flush (gdb_stdout
);
768 pst
->read_symtab (objfile
);
771 return pst
->get_compunit_symtab ();
774 /* Psymtab version of find_last_source_symtab. See its definition in
775 the definition of quick_symbol_functions in symfile.h. */
777 static struct symtab
*
778 psym_find_last_source_symtab (struct objfile
*ofp
)
780 struct partial_symtab
*cs_pst
= NULL
;
782 for (partial_symtab
*ps
: require_partial_symbols (ofp
, true))
784 const char *name
= ps
->filename
;
785 int len
= strlen (name
);
787 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
788 || strcmp (name
, "<<C++-namespaces>>") == 0)))
794 if (cs_pst
->readin_p ())
796 internal_error (__FILE__
, __LINE__
,
797 _("select_source_symtab: "
798 "readin pst found and no symtabs."));
802 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
806 return compunit_primary_filetab (cust
);
812 /* Psymtab version of forget_cached_source_info. See its definition in
813 the definition of quick_symbol_functions in symfile.h. */
816 psym_forget_cached_source_info (struct objfile
*objfile
)
818 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
820 if (pst
->fullname
!= NULL
)
822 xfree (pst
->fullname
);
823 pst
->fullname
= NULL
;
829 print_partial_symbols (struct gdbarch
*gdbarch
, struct objfile
*objfile
,
830 struct partial_symbol
**p
, int count
, const char *what
,
831 struct ui_file
*outfile
)
833 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
837 fprintf_filtered (outfile
, " `%s'", (*p
)->ginfo
.linkage_name ());
838 if ((*p
)->ginfo
.demangled_name () != NULL
)
840 fprintf_filtered (outfile
, " `%s'",
841 (*p
)->ginfo
.demangled_name ());
843 fputs_filtered (", ", outfile
);
844 switch ((*p
)->domain
)
847 fputs_filtered ("undefined domain, ", outfile
);
850 /* This is the usual thing -- don't print it. */
853 fputs_filtered ("struct domain, ", outfile
);
856 fputs_filtered ("module domain, ", outfile
);
859 fputs_filtered ("label domain, ", outfile
);
861 case COMMON_BLOCK_DOMAIN
:
862 fputs_filtered ("common block domain, ", outfile
);
865 fputs_filtered ("<invalid domain>, ", outfile
);
868 switch ((*p
)->aclass
)
871 fputs_filtered ("undefined", outfile
);
874 fputs_filtered ("constant int", outfile
);
877 fputs_filtered ("static", outfile
);
880 fputs_filtered ("register", outfile
);
883 fputs_filtered ("pass by value", outfile
);
886 fputs_filtered ("pass by reference", outfile
);
888 case LOC_REGPARM_ADDR
:
889 fputs_filtered ("register address parameter", outfile
);
892 fputs_filtered ("stack parameter", outfile
);
895 fputs_filtered ("type", outfile
);
898 fputs_filtered ("label", outfile
);
901 fputs_filtered ("function", outfile
);
903 case LOC_CONST_BYTES
:
904 fputs_filtered ("constant bytes", outfile
);
907 fputs_filtered ("unresolved", outfile
);
909 case LOC_OPTIMIZED_OUT
:
910 fputs_filtered ("optimized out", outfile
);
913 fputs_filtered ("computed at runtime", outfile
);
916 fputs_filtered ("<invalid location>", outfile
);
919 fputs_filtered (", ", outfile
);
920 fputs_filtered (paddress (gdbarch
, (*p
)->unrelocated_address ()), outfile
);
921 fprintf_filtered (outfile
, "\n");
927 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
928 struct ui_file
*outfile
)
930 struct gdbarch
*gdbarch
= objfile
->arch ();
933 if (psymtab
->anonymous
)
935 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
940 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
943 fprintf_filtered (outfile
, "(object ");
944 gdb_print_host_address (psymtab
, outfile
);
945 fprintf_filtered (outfile
, ")\n\n");
946 fprintf_filtered (outfile
, " Read from object file %s (",
947 objfile_name (objfile
));
948 gdb_print_host_address (objfile
, outfile
);
949 fprintf_filtered (outfile
, ")\n");
951 if (psymtab
->readin_p ())
953 fprintf_filtered (outfile
,
954 " Full symtab was read (at ");
955 gdb_print_host_address (psymtab
->get_compunit_symtab (), outfile
);
956 fprintf_filtered (outfile
, ")\n");
959 fprintf_filtered (outfile
, " Symbols cover text addresses ");
960 fputs_filtered (paddress (gdbarch
, psymtab
->text_low (objfile
)), outfile
);
961 fprintf_filtered (outfile
, "-");
962 fputs_filtered (paddress (gdbarch
, psymtab
->text_high (objfile
)), outfile
);
963 fprintf_filtered (outfile
, "\n");
964 fprintf_filtered (outfile
, " Address map supported - %s.\n",
965 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
966 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
967 psymtab
->number_of_dependencies
);
968 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
970 fprintf_filtered (outfile
, " %d ", i
);
971 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
972 fprintf_filtered (outfile
, " %s\n",
973 psymtab
->dependencies
[i
]->filename
);
975 if (psymtab
->user
!= NULL
)
977 fprintf_filtered (outfile
, " Shared partial symtab with user ");
978 gdb_print_host_address (psymtab
->user
, outfile
);
979 fprintf_filtered (outfile
, "\n");
981 if (psymtab
->n_global_syms
> 0)
983 print_partial_symbols
985 &objfile
->partial_symtabs
->global_psymbols
[psymtab
->globals_offset
],
986 psymtab
->n_global_syms
, "Global", outfile
);
988 if (psymtab
->n_static_syms
> 0)
990 print_partial_symbols
992 &objfile
->partial_symtabs
->static_psymbols
[psymtab
->statics_offset
],
993 psymtab
->n_static_syms
, "Static", outfile
);
995 fprintf_filtered (outfile
, "\n");
998 /* Psymtab version of print_stats. See its definition in
999 the definition of quick_symbol_functions in symfile.h. */
1002 psym_print_stats (struct objfile
*objfile
)
1007 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1009 if (!ps
->readin_p ())
1012 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1015 /* Psymtab version of dump. See its definition in
1016 the definition of quick_symbol_functions in symfile.h. */
1019 psym_dump (struct objfile
*objfile
)
1021 struct partial_symtab
*psymtab
;
1023 if (objfile
->partial_symtabs
->psymtabs
)
1025 printf_filtered ("Psymtabs:\n");
1026 for (psymtab
= objfile
->partial_symtabs
->psymtabs
;
1028 psymtab
= psymtab
->next
)
1030 printf_filtered ("%s at ",
1032 gdb_print_host_address (psymtab
, gdb_stdout
);
1033 printf_filtered (", ");
1036 printf_filtered ("\n\n");
1040 /* Psymtab version of expand_symtabs_for_function. See its definition in
1041 the definition of quick_symbol_functions in symfile.h. */
1044 psym_expand_symtabs_for_function (struct objfile
*objfile
,
1045 const char *func_name
)
1047 lookup_name_info
base_lookup (func_name
, symbol_name_match_type::FULL
);
1048 lookup_name_info lookup_name
= base_lookup
.make_ignore_params ();
1050 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1052 if (ps
->readin_p ())
1055 if ((lookup_partial_symbol (objfile
, ps
, lookup_name
, 1, VAR_DOMAIN
)
1057 || (lookup_partial_symbol (objfile
, ps
, lookup_name
, 0, VAR_DOMAIN
)
1059 psymtab_to_symtab (objfile
, ps
);
1063 /* Psymtab version of expand_all_symtabs. See its definition in
1064 the definition of quick_symbol_functions in symfile.h. */
1067 psym_expand_all_symtabs (struct objfile
*objfile
)
1069 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, true))
1070 psymtab_to_symtab (objfile
, psymtab
);
1073 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1074 the definition of quick_symbol_functions in symfile.h. */
1077 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1078 const char *fullname
)
1080 for (partial_symtab
*p
: require_partial_symbols (objfile
, true))
1082 /* Anonymous psymtabs don't have a name of a source file. */
1086 /* psymtab_to_fullname tries to open the file which is slow.
1087 Don't call it if we know the basenames don't match. */
1088 if ((basenames_may_differ
1089 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1090 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1091 psymtab_to_symtab (objfile
, p
);
1095 /* Psymtab version of map_symbol_filenames. See its definition in
1096 the definition of quick_symbol_functions in symfile.h. */
1099 psym_map_symbol_filenames (struct objfile
*objfile
,
1100 symbol_filename_ftype
*fun
, void *data
,
1103 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1105 const char *fullname
;
1107 if (ps
->readin_p ())
1110 /* We can skip shared psymtabs here, because any file name will be
1111 attached to the unshared psymtab. */
1112 if (ps
->user
!= NULL
)
1115 /* Anonymous psymtabs don't have a file name. */
1121 fullname
= psymtab_to_fullname (ps
);
1124 (*fun
) (ps
->filename
, fullname
, data
);
1128 /* Finds the fullname that a partial_symtab represents.
1130 If this functions finds the fullname, it will save it in ps->fullname
1131 and it will also return the value.
1133 If this function fails to find the file that this partial_symtab represents,
1134 NULL will be returned and ps->fullname will be set to NULL. */
1137 psymtab_to_fullname (struct partial_symtab
*ps
)
1139 gdb_assert (!ps
->anonymous
);
1141 /* Use cached copy if we have it.
1142 We rely on forget_cached_source_info being called appropriately
1143 to handle cases like the file being moved. */
1144 if (ps
->fullname
== NULL
)
1146 gdb::unique_xmalloc_ptr
<char> fullname
;
1147 scoped_fd fd
= find_and_open_source (ps
->filename
, ps
->dirname
,
1149 ps
->fullname
= fullname
.release ();
1153 /* rewrite_source_path would be applied by find_and_open_source, we
1154 should report the pathname where GDB tried to find the file. */
1156 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
1157 fullname
.reset (xstrdup (ps
->filename
));
1159 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
1160 ps
->filename
, (char *) NULL
));
1162 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1163 if (ps
->fullname
== NULL
)
1164 ps
->fullname
= fullname
.release ();
1168 return ps
->fullname
;
1171 /* Psymtab version of map_matching_symbols. See its definition in
1172 the definition of quick_symbol_functions in symfile.h. */
1175 psym_map_matching_symbols
1176 (struct objfile
*objfile
,
1177 const lookup_name_info
&name
, domain_enum domain
,
1179 gdb::function_view
<symbol_found_callback_ftype
> callback
,
1180 symbol_compare_ftype
*ordered_compare
)
1182 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1184 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1188 || match_partial_symbol (objfile
, ps
, global
, name
, domain
,
1191 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1192 const struct block
*block
;
1196 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1197 if (!iterate_over_symbols_terminated (block
, name
,
1204 /* A helper for psym_expand_symtabs_matching that handles searching
1205 included psymtabs. This returns true if a symbol is found, and
1206 false otherwise. It also updates the 'searched_flag' on the
1207 various psymtabs that it searches. */
1210 recursively_search_psymtabs
1211 (struct partial_symtab
*ps
,
1212 struct objfile
*objfile
,
1213 enum search_domain domain
,
1214 const lookup_name_info
&lookup_name
,
1215 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1218 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1221 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1222 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1224 /* Recurse into shared psymtabs first, because they may have already
1225 been searched, and this could save some time. */
1226 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1230 /* Skip non-shared dependencies, these are handled elsewhere. */
1231 if (ps
->dependencies
[i
]->user
== NULL
)
1234 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1235 objfile
, domain
, lookup_name
,
1239 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1244 partial_symbol
**gbound
1245 = (objfile
->partial_symtabs
->global_psymbols
.data ()
1246 + ps
->globals_offset
+ ps
->n_global_syms
);
1247 partial_symbol
**sbound
1248 = (objfile
->partial_symtabs
->static_psymbols
.data ()
1249 + ps
->statics_offset
+ ps
->n_static_syms
);
1250 partial_symbol
**bound
= gbound
;
1252 /* Go through all of the symbols stored in a partial
1253 symtab in one loop. */
1254 partial_symbol
**psym
= (objfile
->partial_symtabs
->global_psymbols
.data ()
1255 + ps
->globals_offset
);
1260 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1262 psym
= (objfile
->partial_symtabs
->static_psymbols
.data ()
1263 + ps
->statics_offset
);
1274 if ((domain
== ALL_DOMAIN
1275 || (domain
== MODULES_DOMAIN
1276 && (*psym
)->domain
== MODULE_DOMAIN
)
1277 || (domain
== VARIABLES_DOMAIN
1278 && (*psym
)->aclass
!= LOC_TYPEDEF
1279 && (*psym
)->aclass
!= LOC_BLOCK
)
1280 || (domain
== FUNCTIONS_DOMAIN
1281 && (*psym
)->aclass
== LOC_BLOCK
)
1282 || (domain
== TYPES_DOMAIN
1283 && (*psym
)->aclass
== LOC_TYPEDEF
))
1284 && psymbol_name_matches (*psym
, lookup_name
)
1285 && (sym_matcher
== NULL
1286 || sym_matcher ((*psym
)->ginfo
.search_name ())))
1288 /* Found a match, so notify our caller. */
1289 result
= PST_SEARCHED_AND_FOUND
;
1296 ps
->searched_flag
= result
;
1297 return result
== PST_SEARCHED_AND_FOUND
;
1300 /* Psymtab version of expand_symtabs_matching. See its definition in
1301 the definition of quick_symbol_functions in symfile.h. */
1304 psym_expand_symtabs_matching
1305 (struct objfile
*objfile
,
1306 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1307 const lookup_name_info
*lookup_name
,
1308 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1309 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1310 enum search_domain domain
)
1312 /* Clear the search flags. */
1313 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1314 ps
->searched_flag
= PST_NOT_SEARCHED
;
1316 for (partial_symtab
*ps
: objfile
->psymtabs ())
1320 if (ps
->readin_p ())
1323 /* We skip shared psymtabs because file-matching doesn't apply
1324 to them; but we search them later in the loop. */
1325 if (ps
->user
!= NULL
)
1335 match
= file_matcher (ps
->filename
, false);
1338 /* Before we invoke realpath, which can get expensive when many
1339 files are involved, do a quick comparison of the basenames. */
1340 if (basenames_may_differ
1341 || file_matcher (lbasename (ps
->filename
), true))
1342 match
= file_matcher (psymtab_to_fullname (ps
), false);
1348 if ((symbol_matcher
== NULL
&& lookup_name
== NULL
)
1349 || recursively_search_psymtabs (ps
, objfile
, domain
,
1350 lookup_name
->make_ignore_params (),
1353 struct compunit_symtab
*symtab
=
1354 psymtab_to_symtab (objfile
, ps
);
1356 if (expansion_notify
!= NULL
)
1357 expansion_notify (symtab
);
1362 /* Psymtab version of has_symbols. See its definition in
1363 the definition of quick_symbol_functions in symfile.h. */
1366 psym_has_symbols (struct objfile
*objfile
)
1368 return objfile
->partial_symtabs
->psymtabs
!= NULL
;
1371 /* Helper function for psym_find_compunit_symtab_by_address that fills
1372 in psymbol_map for a given range of psymbols. */
1375 psym_fill_psymbol_map (struct objfile
*objfile
,
1376 struct partial_symtab
*psymtab
,
1377 std::set
<CORE_ADDR
> *seen_addrs
,
1378 const std::vector
<partial_symbol
*> &symbols
,
1382 for (int i
= 0; i
< length
; ++i
)
1384 struct partial_symbol
*psym
= symbols
[start
+ i
];
1386 if (psym
->aclass
== LOC_STATIC
)
1388 CORE_ADDR addr
= psym
->address (objfile
);
1389 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1391 seen_addrs
->insert (addr
);
1392 objfile
->psymbol_map
.emplace_back (addr
, psymtab
);
1398 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1401 static compunit_symtab
*
1402 psym_find_compunit_symtab_by_address (struct objfile
*objfile
,
1405 if (objfile
->psymbol_map
.empty ())
1407 std::set
<CORE_ADDR
> seen_addrs
;
1409 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
1411 psym_fill_psymbol_map (objfile
, pst
,
1413 objfile
->partial_symtabs
->global_psymbols
,
1414 pst
->globals_offset
,
1415 pst
->n_global_syms
);
1416 psym_fill_psymbol_map (objfile
, pst
,
1418 objfile
->partial_symtabs
->static_psymbols
,
1419 pst
->statics_offset
,
1420 pst
->n_static_syms
);
1423 objfile
->psymbol_map
.shrink_to_fit ();
1425 std::sort (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (),
1426 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1427 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1429 return a
.first
< b
.first
;
1433 auto iter
= std::lower_bound
1434 (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (), address
,
1435 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1441 if (iter
== objfile
->psymbol_map
.end () || iter
->first
!= address
)
1444 return psymtab_to_symtab (objfile
, iter
->second
);
1447 const struct quick_symbol_functions psym_functions
=
1450 psym_find_last_source_symtab
,
1451 psym_forget_cached_source_info
,
1452 psym_map_symtabs_matching_filename
,
1454 psym_lookup_global_symbol_language
,
1457 psym_expand_symtabs_for_function
,
1458 psym_expand_all_symtabs
,
1459 psym_expand_symtabs_with_fullname
,
1460 psym_map_matching_symbols
,
1461 psym_expand_symtabs_matching
,
1462 psym_find_pc_sect_compunit_symtab
,
1463 psym_find_compunit_symtab_by_address
,
1464 psym_map_symbol_filenames
1470 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1472 /* Sort the global list; don't sort the static list. */
1473 auto begin
= objfile
->partial_symtabs
->global_psymbols
.begin ();
1474 std::advance (begin
, pst
->globals_offset
);
1476 /* The psymbols for this partial_symtab are currently at the end of the
1478 auto end
= objfile
->partial_symtabs
->global_psymbols
.end ();
1480 std::sort (begin
, end
, [] (partial_symbol
*s1
, partial_symbol
*s2
)
1482 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1483 s2
->ginfo
.search_name ()) < 0;
1487 /* Partially fill a partial symtab. It will be completely filled at
1488 the end of the symbol list. */
1490 partial_symtab::partial_symtab (const char *filename
,
1491 struct objfile
*objfile
,
1493 : partial_symtab (filename
, objfile
)
1495 set_text_low (textlow
);
1496 set_text_high (raw_text_low ()); /* default */
1498 auto *v1
= new std::vector
<partial_symbol
*>;
1499 objfile
->partial_symtabs
->current_global_psymbols
.push_back (v1
);
1500 auto *v2
= new std::vector
<partial_symbol
*>;
1501 objfile
->partial_symtabs
->current_static_psymbols
.push_back (v2
);
1504 /* Concat vectors V1 and V2. */
1507 concat (std::vector
<partial_symbol
*> *v1
, std::vector
<partial_symbol
*> *v2
)
1509 v1
->insert (v1
->end (), v2
->begin (), v2
->end ());
1513 /* Perform "finishing up" operations of a partial symtab. */
1516 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1518 pst
->globals_offset
= objfile
->partial_symtabs
->global_psymbols
.size ();
1519 pst
->statics_offset
= objfile
->partial_symtabs
->static_psymbols
.size ();
1521 auto *current_global_psymbols
1522 = objfile
->partial_symtabs
->current_global_psymbols
.back ();
1523 auto *current_static_psymbols
1524 = objfile
->partial_symtabs
->current_static_psymbols
.back ();
1525 objfile
->partial_symtabs
->current_global_psymbols
.pop_back ();
1526 objfile
->partial_symtabs
->current_static_psymbols
.pop_back ();
1529 = current_global_psymbols
->size ();
1531 = current_static_psymbols
->size ();
1533 concat (&objfile
->partial_symtabs
->global_psymbols
, current_global_psymbols
);
1534 concat (&objfile
->partial_symtabs
->static_psymbols
, current_static_psymbols
);
1536 delete current_global_psymbols
;
1537 delete current_static_psymbols
;
1539 sort_pst_symbols (objfile
, pst
);
1542 /* Calculate a hash code for the given partial symbol. The hash is
1543 calculated using the symbol's value, language, domain, class
1544 and name. These are the values which are set by
1545 add_psymbol_to_bcache. */
1547 static unsigned long
1548 psymbol_hash (const void *addr
, int length
)
1550 unsigned long h
= 0;
1551 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1552 unsigned int lang
= psymbol
->ginfo
.language ();
1553 unsigned int domain
= psymbol
->domain
;
1554 unsigned int theclass
= psymbol
->aclass
;
1556 h
= fast_hash (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1557 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1558 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1559 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1560 /* Note that psymbol names are interned via compute_and_set_names, so
1561 there's no need to hash the contents of the name here. */
1562 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1567 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1568 For the comparison this function uses a symbols value,
1569 language, domain, class and name. */
1572 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1574 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1575 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1577 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1578 sizeof (sym1
->ginfo
.value
)) == 0
1579 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1580 && sym1
->domain
== sym2
->domain
1581 && sym1
->aclass
== sym2
->aclass
1582 /* Note that psymbol names are interned via
1583 compute_and_set_names, so there's no need to compare the
1584 contents of the name here. */
1585 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1588 /* Helper function, initialises partial symbol structure and stashes
1589 it into objfile's bcache. Note that our caching mechanism will
1590 use all fields of struct partial_symbol to determine hash value of the
1591 structure. In other words, having two symbols with the same name but
1592 different domain (or address) is possible and correct. */
1594 static struct partial_symbol
*
1595 add_psymbol_to_bcache (gdb::string_view name
, bool copy_name
,
1597 enum address_class theclass
,
1600 enum language language
, struct objfile
*objfile
,
1603 struct partial_symbol psymbol
;
1604 memset (&psymbol
, 0, sizeof (psymbol
));
1606 psymbol
.set_unrelocated_address (coreaddr
);
1607 psymbol
.ginfo
.section
= section
;
1608 psymbol
.domain
= domain
;
1609 psymbol
.aclass
= theclass
;
1610 psymbol
.ginfo
.set_language (language
, objfile
->partial_symtabs
->obstack ());
1611 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1613 /* Stash the partial symbol away in the cache. */
1614 return ((struct partial_symbol
*)
1615 objfile
->partial_symtabs
->psymbol_cache
.insert
1616 (&psymbol
, sizeof (struct partial_symbol
), added
));
1619 /* Helper function, adds partial symbol to the given partial symbol list. */
1622 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1623 struct partial_symbol
*psym
,
1624 struct objfile
*objfile
)
1626 list
->push_back (psym
);
1627 OBJSTAT (objfile
, n_psyms
++);
1630 /* See psympriv.h. */
1633 add_psymbol_to_list (gdb::string_view name
, bool copy_name
,
1635 enum address_class theclass
,
1637 psymbol_placement where
,
1639 enum language language
, struct objfile
*objfile
)
1641 struct partial_symbol
*psym
;
1645 /* Stash the partial symbol away in the cache. */
1646 psym
= add_psymbol_to_bcache (name
, copy_name
, domain
, theclass
,
1647 section
, coreaddr
, language
, objfile
, &added
);
1649 /* Do not duplicate global partial symbols. */
1650 if (where
== psymbol_placement::GLOBAL
&& !added
)
1653 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1654 std::vector
<partial_symbol
*> *list
1655 = (where
== psymbol_placement::STATIC
1656 ? objfile
->partial_symtabs
->current_static_psymbols
.back ()
1657 : objfile
->partial_symtabs
->current_global_psymbols
.back ());
1658 append_psymbol_to_list (list
, psym
, objfile
);
1661 /* See psympriv.h. */
1664 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1666 if (objfile
->partial_symtabs
->global_psymbols
.capacity () == 0
1667 && objfile
->partial_symtabs
->static_psymbols
.capacity () == 0)
1669 /* Current best guess is that approximately a twentieth of the
1670 total symbols (in a debugging file) are global or static
1671 oriented symbols, then multiply that by slop factor of
1673 objfile
->partial_symtabs
->global_psymbols
.reserve (total_symbols
/ 10);
1674 objfile
->partial_symtabs
->static_psymbols
.reserve (total_symbols
/ 10);
1678 /* See psympriv.h. */
1680 partial_symtab::partial_symtab (const char *filename_
, struct objfile
*objfile
)
1681 : searched_flag (PST_NOT_SEARCHED
),
1685 objfile
->partial_symtabs
->install_psymtab (this);
1687 filename
= objfile
->intern (filename_
);
1689 if (symtab_create_debug
)
1691 /* Be a bit clever with debugging messages, and don't print objfile
1692 every time, only when it changes. */
1693 static char *last_objfile_name
= NULL
;
1695 if (last_objfile_name
== NULL
1696 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1698 xfree (last_objfile_name
);
1699 last_objfile_name
= xstrdup (objfile_name (objfile
));
1700 fprintf_filtered (gdb_stdlog
,
1701 "Creating one or more psymtabs for objfile %s ...\n",
1704 fprintf_filtered (gdb_stdlog
,
1705 "Created psymtab %s for module %s.\n",
1706 host_address_to_string (this), filename
);
1710 /* See psympriv.h. */
1713 partial_symtab::expand_dependencies (struct objfile
*objfile
)
1715 for (int i
= 0; i
< number_of_dependencies
; ++i
)
1717 if (!dependencies
[i
]->readin_p ()
1718 && dependencies
[i
]->user
== NULL
)
1720 /* Inform about additional files to be read in. */
1723 fputs_filtered (" ", gdb_stdout
);
1725 fputs_filtered ("and ", gdb_stdout
);
1727 printf_filtered ("%s...", dependencies
[i
]->filename
);
1728 wrap_here (""); /* Flush output */
1729 gdb_flush (gdb_stdout
);
1731 dependencies
[i
]->expand_psymtab (objfile
);
1738 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1740 struct partial_symtab
**prev_pst
;
1743 Empty psymtabs happen as a result of header files which don't
1744 have any symbols in them. There can be a lot of them. But this
1745 check is wrong, in that a psymtab with N_SLINE entries but
1746 nothing else is not empty, but we don't realize that. Fixing
1747 that without slowing things down might be tricky. */
1749 /* First, snip it out of the psymtab chain. */
1751 prev_pst
= &psymtabs
;
1752 while ((*prev_pst
) != pst
)
1753 prev_pst
= &((*prev_pst
)->next
);
1754 (*prev_pst
) = pst
->next
;
1760 /* We need to pass a couple of items to the addrmap_foreach function,
1763 struct dump_psymtab_addrmap_data
1765 struct objfile
*objfile
;
1766 struct partial_symtab
*psymtab
;
1767 struct ui_file
*outfile
;
1769 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1770 If so, we want to print the next one as well (since the next addrmap
1771 entry defines the end of the range). */
1772 int previous_matched
;
1775 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1778 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1780 struct dump_psymtab_addrmap_data
*data
1781 = (struct dump_psymtab_addrmap_data
*) datap
;
1782 struct gdbarch
*gdbarch
= data
->objfile
->arch ();
1783 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1784 const char *psymtab_address_or_end
= NULL
;
1788 if (data
->psymtab
== NULL
1789 || data
->psymtab
== addrmap_psymtab
)
1790 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1791 else if (data
->previous_matched
)
1792 psymtab_address_or_end
= "<ends here>";
1794 if (data
->psymtab
== NULL
1795 || data
->psymtab
== addrmap_psymtab
1796 || data
->previous_matched
)
1798 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1799 data
->psymtab
!= NULL
? " " : "",
1800 paddress (gdbarch
, start_addr
),
1801 psymtab_address_or_end
);
1804 data
->previous_matched
= (data
->psymtab
== NULL
1805 || data
->psymtab
== addrmap_psymtab
);
1810 /* Helper function for maintenance_print_psymbols to print the addrmap
1811 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1814 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1815 struct ui_file
*outfile
)
1817 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1819 if ((psymtab
== NULL
1820 || psymtab
->psymtabs_addrmap_supported
)
1821 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
1823 addrmap_dump_data
.objfile
= objfile
;
1824 addrmap_dump_data
.psymtab
= psymtab
;
1825 addrmap_dump_data
.outfile
= outfile
;
1826 addrmap_dump_data
.previous_matched
= 0;
1827 fprintf_filtered (outfile
, "%sddress map:\n",
1828 psymtab
== NULL
? "Entire a" : " A");
1829 addrmap_foreach (objfile
->partial_symtabs
->psymtabs_addrmap
,
1830 dump_psymtab_addrmap_1
, &addrmap_dump_data
);
1835 maintenance_print_psymbols (const char *args
, int from_tty
)
1837 struct ui_file
*outfile
= gdb_stdout
;
1838 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1839 int i
, outfile_idx
, found
;
1841 struct obj_section
*section
= NULL
;
1845 gdb_argv
argv (args
);
1847 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1849 if (strcmp (argv
[i
], "-pc") == 0)
1851 if (argv
[i
+ 1] == NULL
)
1852 error (_("Missing pc value"));
1853 address_arg
= argv
[++i
];
1855 else if (strcmp (argv
[i
], "-source") == 0)
1857 if (argv
[i
+ 1] == NULL
)
1858 error (_("Missing source file"));
1859 source_arg
= argv
[++i
];
1861 else if (strcmp (argv
[i
], "-objfile") == 0)
1863 if (argv
[i
+ 1] == NULL
)
1864 error (_("Missing objfile name"));
1865 objfile_arg
= argv
[++i
];
1867 else if (strcmp (argv
[i
], "--") == 0)
1869 /* End of options. */
1873 else if (argv
[i
][0] == '-')
1875 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1876 error (_("Unknown option: %s"), argv
[i
]);
1883 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1884 error (_("Must specify at most one of -pc and -source"));
1886 stdio_file arg_outfile
;
1888 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1890 if (argv
[outfile_idx
+ 1] != NULL
)
1891 error (_("Junk at end of command"));
1892 gdb::unique_xmalloc_ptr
<char> outfile_name
1893 (tilde_expand (argv
[outfile_idx
]));
1894 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1895 perror_with_name (outfile_name
.get ());
1896 outfile
= &arg_outfile
;
1899 if (address_arg
!= NULL
)
1901 pc
= parse_and_eval_address (address_arg
);
1902 /* If we fail to find a section, that's ok, try the lookup anyway. */
1903 section
= find_pc_section (pc
);
1907 for (objfile
*objfile
: current_program_space
->objfiles ())
1909 int printed_objfile_header
= 0;
1910 int print_for_objfile
= 1;
1913 if (objfile_arg
!= NULL
)
1915 = compare_filenames_for_search (objfile_name (objfile
),
1917 if (!print_for_objfile
)
1920 if (address_arg
!= NULL
)
1922 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1924 /* We don't assume each pc has a unique objfile (this is for
1926 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
,
1930 if (!printed_objfile_header
)
1932 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1933 objfile_name (objfile
));
1934 printed_objfile_header
= 1;
1936 dump_psymtab (objfile
, ps
, outfile
);
1937 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1943 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1945 int print_for_source
= 0;
1948 if (source_arg
!= NULL
)
1951 = compare_filenames_for_search (ps
->filename
, source_arg
);
1954 if (source_arg
== NULL
1955 || print_for_source
)
1957 if (!printed_objfile_header
)
1959 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1960 objfile_name (objfile
));
1961 printed_objfile_header
= 1;
1963 dump_psymtab (objfile
, ps
, outfile
);
1964 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1969 /* If we're printing all the objfile's symbols dump the full addrmap. */
1971 if (address_arg
== NULL
1972 && source_arg
== NULL
1973 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
1975 outfile
->puts ("\n");
1976 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
1982 if (address_arg
!= NULL
)
1983 error (_("No partial symtab for address: %s"), address_arg
);
1984 if (source_arg
!= NULL
)
1985 error (_("No partial symtab for source file: %s"), source_arg
);
1989 /* List all the partial symbol tables whose names match REGEXP (optional). */
1992 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1994 struct program_space
*pspace
;
1999 ALL_PSPACES (pspace
)
2000 for (objfile
*objfile
: pspace
->objfiles ())
2002 struct gdbarch
*gdbarch
= objfile
->arch ();
2004 /* We don't want to print anything for this objfile until we
2005 actually find a symtab whose name matches. */
2006 int printed_objfile_start
= 0;
2008 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, true))
2013 || re_exec (psymtab
->filename
))
2015 if (! printed_objfile_start
)
2017 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2019 printf_filtered ("((struct objfile *) %s)\n",
2020 host_address_to_string (objfile
));
2021 printed_objfile_start
= 1;
2024 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2026 printf_filtered ("((struct partial_symtab *) %s)\n",
2027 host_address_to_string (psymtab
));
2029 printf_filtered (" readin %s\n",
2030 psymtab
->readin_p () ? "yes" : "no");
2031 printf_filtered (" fullname %s\n",
2033 ? psymtab
->fullname
: "(null)");
2034 printf_filtered (" text addresses ");
2035 fputs_filtered (paddress (gdbarch
,
2036 psymtab
->text_low (objfile
)),
2038 printf_filtered (" -- ");
2039 fputs_filtered (paddress (gdbarch
,
2040 psymtab
->text_high (objfile
)),
2042 printf_filtered ("\n");
2043 printf_filtered (" psymtabs_addrmap_supported %s\n",
2044 (psymtab
->psymtabs_addrmap_supported
2046 printf_filtered (" globals ");
2047 if (psymtab
->n_global_syms
)
2049 auto p
= &(objfile
->partial_symtabs
2050 ->global_psymbols
[psymtab
->globals_offset
]);
2053 ("(* (struct partial_symbol **) %s @ %d)\n",
2054 host_address_to_string (p
),
2055 psymtab
->n_global_syms
);
2058 printf_filtered ("(none)\n");
2059 printf_filtered (" statics ");
2060 if (psymtab
->n_static_syms
)
2062 auto p
= &(objfile
->partial_symtabs
2063 ->static_psymbols
[psymtab
->statics_offset
]);
2066 ("(* (struct partial_symbol **) %s @ %d)\n",
2067 host_address_to_string (p
),
2068 psymtab
->n_static_syms
);
2071 printf_filtered ("(none)\n");
2073 printf_filtered (" user %s "
2074 "((struct partial_symtab *) %s)\n",
2075 psymtab
->user
->filename
,
2076 host_address_to_string (psymtab
->user
));
2077 printf_filtered (" dependencies ");
2078 if (psymtab
->number_of_dependencies
)
2082 printf_filtered ("{\n");
2083 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2085 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2087 /* Note the string concatenation there --- no
2089 printf_filtered (" psymtab %s "
2090 "((struct partial_symtab *) %s)\n",
2092 host_address_to_string (dep
));
2094 printf_filtered (" }\n");
2097 printf_filtered ("(none)\n");
2098 printf_filtered (" }\n");
2102 if (printed_objfile_start
)
2103 printf_filtered ("}\n");
2107 /* Check consistency of currently expanded psymtabs vs symtabs. */
2110 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2113 struct compunit_symtab
*cust
= NULL
;
2114 const struct blockvector
*bv
;
2115 const struct block
*b
;
2118 for (objfile
*objfile
: current_program_space
->objfiles ())
2119 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
2121 struct gdbarch
*gdbarch
= objfile
->arch ();
2123 /* We don't call psymtab_to_symtab here because that may cause symtab
2124 expansion. When debugging a problem it helps if checkers leave
2125 things unchanged. */
2126 cust
= ps
->get_compunit_symtab ();
2128 /* First do some checks that don't require the associated symtab. */
2129 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
2131 printf_filtered ("Psymtab ");
2132 puts_filtered (ps
->filename
);
2133 printf_filtered (" covers bad range ");
2134 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2136 printf_filtered (" - ");
2137 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2139 printf_filtered ("\n");
2143 /* Now do checks requiring the associated symtab. */
2146 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2147 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2148 partial_symbol
**psym
2149 = &objfile
->partial_symtabs
->static_psymbols
[ps
->statics_offset
];
2150 for (i
= 0; i
< ps
->n_static_syms
; psym
++, i
++)
2152 /* Skip symbols for inlined functions without address. These may
2153 or may not have a match in the full symtab. */
2154 if ((*psym
)->aclass
== LOC_BLOCK
2155 && (*psym
)->ginfo
.value
.address
== 0)
2158 sym
= block_lookup_symbol (b
, (*psym
)->ginfo
.search_name (),
2159 symbol_name_match_type::SEARCH_NAME
,
2163 printf_filtered ("Static symbol `");
2164 puts_filtered ((*psym
)->ginfo
.linkage_name ());
2165 printf_filtered ("' only found in ");
2166 puts_filtered (ps
->filename
);
2167 printf_filtered (" psymtab\n");
2170 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2171 psym
= &objfile
->partial_symtabs
->global_psymbols
[ps
->globals_offset
];
2172 for (i
= 0; i
< ps
->n_global_syms
; psym
++, i
++)
2174 sym
= block_lookup_symbol (b
, (*psym
)->ginfo
.search_name (),
2175 symbol_name_match_type::SEARCH_NAME
,
2179 printf_filtered ("Global symbol `");
2180 puts_filtered ((*psym
)->ginfo
.linkage_name ());
2181 printf_filtered ("' only found in ");
2182 puts_filtered (ps
->filename
);
2183 printf_filtered (" psymtab\n");
2186 if (ps
->raw_text_high () != 0
2187 && (ps
->text_low (objfile
) < BLOCK_START (b
)
2188 || ps
->text_high (objfile
) > BLOCK_END (b
)))
2190 printf_filtered ("Psymtab ");
2191 puts_filtered (ps
->filename
);
2192 printf_filtered (" covers ");
2193 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2195 printf_filtered (" - ");
2196 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2198 printf_filtered (" but symtab covers only ");
2199 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2200 printf_filtered (" - ");
2201 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2202 printf_filtered ("\n");
2207 void _initialize_psymtab ();
2209 _initialize_psymtab ()
2211 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2212 Print dump of current partial symbol definitions.\n\
2213 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
2214 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
2215 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2216 or the terminal if OUTFILE is unspecified.\n\
2217 If ADDRESS is provided, dump only the file for that address.\n\
2218 If SOURCE is provided, dump only that file's symbols.\n\
2219 If OBJFILE is provided, dump only that file's minimal symbols."),
2220 &maintenanceprintlist
);
2222 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2223 List the partial symbol tables for all object files.\n\
2224 This does not include information about individual partial symbols,\n\
2225 just the symbol table structures themselves."),
2226 &maintenanceinfolist
);
2228 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2230 Check consistency of currently expanded psymtabs versus symtabs."),