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
*,
45 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
47 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
48 struct partial_symtab
*,
50 struct obj_section
*);
52 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
53 struct partial_symtab
*pst
);
57 static unsigned long psymbol_hash (const void *addr
, int length
);
58 static int psymbol_compare (const void *addr1
, const void *addr2
, int length
);
60 psymtab_storage::psymtab_storage ()
61 : psymbol_cache (psymbol_hash
, psymbol_compare
)
65 psymtab_storage::~psymtab_storage ()
67 partial_symtab
*iter
= psymtabs
;
68 while (iter
!= nullptr)
70 partial_symtab
*next
= iter
->next
;
79 psymtab_storage::install_psymtab (partial_symtab
*pst
)
89 psymtab_storage::partial_symtab_range
90 require_partial_symbols (struct objfile
*objfile
, bool verbose
)
92 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
94 objfile
->flags
|= OBJF_PSYMTABS_READ
;
96 if (objfile
->sf
->sym_read_psymbols
)
99 printf_filtered (_("Reading symbols from %s...\n"),
100 objfile_name (objfile
));
101 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
103 /* Partial symbols list are not expected to changed after this
105 objfile
->partial_symtabs
->global_psymbols
.shrink_to_fit ();
106 objfile
->partial_symtabs
->static_psymbols
.shrink_to_fit ();
108 if (verbose
&& !objfile_has_symbols (objfile
))
109 printf_filtered (_("(No debugging symbols found in %s)\n"),
110 objfile_name (objfile
));
114 return objfile
->psymtabs ();
117 /* Helper function for psym_map_symtabs_matching_filename that
118 expands the symtabs and calls the iterator. */
121 partial_map_expand_apply (struct objfile
*objfile
,
123 const char *real_path
,
124 struct partial_symtab
*pst
,
125 gdb::function_view
<bool (symtab
*)> callback
)
127 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
129 /* Shared psymtabs should never be seen here. Instead they should
130 be handled properly by the caller. */
131 gdb_assert (pst
->user
== NULL
);
133 /* Don't visit already-expanded psymtabs. */
137 /* This may expand more than one symtab, and we want to iterate over
139 psymtab_to_symtab (objfile
, pst
);
141 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
142 last_made
, callback
);
145 /* Psymtab version of map_symtabs_matching_filename. See its definition in
146 the definition of quick_symbol_functions in symfile.h. */
149 psym_map_symtabs_matching_filename
150 (struct objfile
*objfile
,
152 const char *real_path
,
153 gdb::function_view
<bool (symtab
*)> callback
)
155 const char *name_basename
= lbasename (name
);
157 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
159 /* We can skip shared psymtabs here, because any file name will be
160 attached to the unshared psymtab. */
161 if (pst
->user
!= NULL
)
164 /* Anonymous psymtabs don't have a file name. */
168 if (compare_filenames_for_search (pst
->filename
, name
))
170 if (partial_map_expand_apply (objfile
, name
, real_path
,
176 /* Before we invoke realpath, which can get expensive when many
177 files are involved, do a quick comparison of the basenames. */
178 if (! basenames_may_differ
179 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
182 if (compare_filenames_for_search (psymtab_to_fullname (pst
), name
))
184 if (partial_map_expand_apply (objfile
, name
, real_path
,
190 /* If the user gave us an absolute path, try to find the file in
191 this symtab and use its absolute path. */
192 if (real_path
!= NULL
)
194 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
195 gdb_assert (IS_ABSOLUTE_PATH (name
));
196 if (filename_cmp (psymtab_to_fullname (pst
), real_path
) == 0)
198 if (partial_map_expand_apply (objfile
, name
, real_path
,
209 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
210 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
212 static struct partial_symtab
*
213 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
214 CORE_ADDR pc
, struct obj_section
*section
,
215 struct partial_symtab
*pst
,
216 struct bound_minimal_symbol msymbol
)
218 struct partial_symtab
*tpst
;
219 struct partial_symtab
*best_pst
= pst
;
220 CORE_ADDR best_addr
= pst
->text_low (objfile
);
222 gdb_assert (!pst
->psymtabs_addrmap_supported
);
224 /* An objfile that has its functions reordered might have
225 many partial symbol tables containing the PC, but
226 we want the partial symbol table that contains the
227 function containing the PC. */
228 if (!(objfile
->flags
& OBJF_REORDERED
)
229 && section
== NULL
) /* Can't validate section this way. */
232 if (msymbol
.minsym
== NULL
)
235 /* The code range of partial symtabs sometimes overlap, so, in
236 the loop below, we need to check all partial symtabs and
237 find the one that fits better for the given PC address. We
238 select the partial symtab that contains a symbol whose
239 address is closest to the PC address. By closest we mean
240 that find_pc_sect_symbol returns the symbol with address
241 that is closest and still less than the given PC. */
242 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
244 if (pc
>= tpst
->text_low (objfile
) && pc
< tpst
->text_high (objfile
))
246 struct partial_symbol
*p
;
249 /* NOTE: This assumes that every psymbol has a
250 corresponding msymbol, which is not necessarily
251 true; the debug info might be much richer than the
252 object's symbol table. */
253 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
255 && (p
->address (objfile
) == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
258 /* Also accept the textlow value of a psymtab as a
259 "symbol", to provide some support for partial
260 symbol tables with line information but no debug
261 symbols (e.g. those produced by an assembler). */
263 this_addr
= p
->address (objfile
);
265 this_addr
= tpst
->text_low (objfile
);
267 /* Check whether it is closer than our current
268 BEST_ADDR. Since this symbol address is
269 necessarily lower or equal to PC, the symbol closer
270 to PC is the symbol which address is the highest.
271 This way we return the psymtab which contains such
272 best match symbol. This can help in cases where the
273 symbol information/debuginfo is not complete, like
274 for instance on IRIX6 with gcc, where no debug info
275 is emitted for statics. (See also the nodebug.exp
277 if (this_addr
> best_addr
)
279 best_addr
= this_addr
;
287 /* Find which partial symtab contains PC and SECTION. Return NULL if
288 none. We return the psymtab that contains a symbol whose address
289 exactly matches PC, or, if we cannot find an exact match, the
290 psymtab that contains a symbol whose address is closest to PC. */
292 static struct partial_symtab
*
293 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
294 struct obj_section
*section
,
295 struct bound_minimal_symbol msymbol
)
297 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better
298 granularity than the later used TEXTLOW/TEXTHIGH one. However, we need
299 to take care as the PSYMTABS_ADDRMAP can hold things other than partial
300 symtabs in some cases.
302 This function should only be called for objfiles that are using partial
303 symtabs, not for objfiles that are using indexes (.gdb_index or
304 .debug_names), however 'maintenance print psymbols' calls this function
305 directly for all objfiles. If we assume that PSYMTABS_ADDRMAP contains
306 partial symtabs then we will end up returning a pointer to an object
307 that is not a partial_symtab, which doesn't end well. */
309 if (objfile
->partial_symtabs
->psymtabs
!= NULL
310 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
312 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
314 struct partial_symtab
*pst
315 = ((struct partial_symtab
*)
316 addrmap_find (objfile
->partial_symtabs
->psymtabs_addrmap
,
320 /* FIXME: addrmaps currently do not handle overlayed sections,
321 so fall back to the non-addrmap case if we're debugging
322 overlays and the addrmap returned the wrong section. */
323 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
325 struct partial_symbol
*p
;
327 /* NOTE: This assumes that every psymbol has a
328 corresponding msymbol, which is not necessarily
329 true; the debug info might be much richer than the
330 object's symbol table. */
331 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
333 || (p
->address (objfile
)
334 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
338 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
339 PSYMTABS_ADDRMAP we used has already the best 1-byte
340 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
341 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
350 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
351 which still have no corresponding full SYMTABs read. But it is not
352 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
355 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
356 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
357 debug info type in single OBJFILE. */
359 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
360 if (!pst
->psymtabs_addrmap_supported
361 && pc
>= pst
->text_low (objfile
) && pc
< pst
->text_high (objfile
))
363 struct partial_symtab
*best_pst
;
365 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
367 if (best_pst
!= NULL
)
374 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
375 the definition of quick_symbol_functions in symfile.h. */
377 static struct compunit_symtab
*
378 psym_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
379 struct bound_minimal_symbol msymbol
,
381 struct obj_section
*section
,
384 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
388 if (warn_if_readin
&& ps
->readin
)
389 /* Might want to error() here (in case symtab is corrupt and
390 will cause a core dump), but maybe we can successfully
391 continue, so let's not. */
393 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
394 paddress (get_objfile_arch (objfile
), pc
));
395 psymtab_to_symtab (objfile
, ps
);
396 return ps
->compunit_symtab
;
401 /* Find which partial symbol within a psymtab matches PC and SECTION.
402 Return NULL if none. */
404 static struct partial_symbol
*
405 find_pc_sect_psymbol (struct objfile
*objfile
,
406 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
407 struct obj_section
*section
)
409 struct partial_symbol
*best
= NULL
;
411 const CORE_ADDR textlow
= psymtab
->text_low (objfile
);
413 gdb_assert (psymtab
!= NULL
);
415 /* Cope with programs that start at address 0. */
416 best_pc
= (textlow
!= 0) ? textlow
- 1 : 0;
418 /* Search the global symbols as well as the static symbols, so that
419 find_pc_partial_function doesn't use a minimal symbol and thus
420 cache a bad endaddr. */
421 for (int i
= 0; i
< psymtab
->n_global_syms
; i
++)
424 = objfile
->partial_symtabs
->global_psymbols
[psymtab
->globals_offset
427 if (p
->domain
== VAR_DOMAIN
428 && p
->aclass
== LOC_BLOCK
429 && pc
>= p
->address (objfile
)
430 && (p
->address (objfile
) > best_pc
431 || (psymtab
->text_low (objfile
) == 0
432 && best_pc
== 0 && p
->address (objfile
) == 0)))
434 if (section
!= NULL
) /* Match on a specific section. */
436 if (!matching_obj_sections (p
->obj_section (objfile
),
440 best_pc
= p
->address (objfile
);
445 for (int i
= 0; i
< psymtab
->n_static_syms
; i
++)
448 = objfile
->partial_symtabs
->static_psymbols
[psymtab
->statics_offset
451 if (p
->domain
== VAR_DOMAIN
452 && p
->aclass
== LOC_BLOCK
453 && pc
>= p
->address (objfile
)
454 && (p
->address (objfile
) > best_pc
455 || (psymtab
->text_low (objfile
) == 0
456 && best_pc
== 0 && p
->address (objfile
) == 0)))
458 if (section
!= NULL
) /* Match on a specific section. */
460 if (!matching_obj_sections (p
->obj_section (objfile
),
464 best_pc
= p
->address (objfile
);
472 /* Psymtab version of lookup_symbol. See its definition in
473 the definition of quick_symbol_functions in symfile.h. */
475 static struct compunit_symtab
*
476 psym_lookup_symbol (struct objfile
*objfile
,
477 block_enum block_index
, const char *name
,
478 const domain_enum domain
)
480 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
481 struct compunit_symtab
*stab_best
= NULL
;
483 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
485 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
487 if (!ps
->readin
&& lookup_partial_symbol (objfile
, ps
, name
,
488 psymtab_index
, domain
))
490 struct symbol
*sym
, *with_opaque
= NULL
;
491 struct compunit_symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
492 /* Note: While psymtab_to_symtab can return NULL if the
493 partial symtab is empty, we can assume it won't here
494 because lookup_partial_symbol succeeded. */
495 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
496 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
498 sym
= block_find_symbol (block
, name
, domain
,
499 block_find_non_opaque_type_preferred
,
502 /* Some caution must be observed with overloaded functions
503 and methods, since the index will not contain any overload
504 information (but NAME might contain it). */
507 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
509 if (with_opaque
!= NULL
510 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
513 /* Keep looking through other psymtabs. */
520 /* Returns true if PSYM matches LOOKUP_NAME. */
523 psymbol_name_matches (partial_symbol
*psym
,
524 const lookup_name_info
&lookup_name
)
526 const language_defn
*lang
= language_def (psym
->ginfo
.language ());
527 symbol_name_matcher_ftype
*name_match
528 = get_symbol_name_matcher (lang
, lookup_name
);
529 return name_match (psym
->ginfo
.search_name (), lookup_name
, NULL
);
532 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
533 the global block of PST if GLOBAL, and otherwise the static block.
534 MATCH is the comparison operation that returns true iff MATCH (s,
535 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
536 non-null, the symbols in the block are assumed to be ordered
537 according to it (allowing binary search). It must be compatible
538 with MATCH. Returns the symbol, if found, and otherwise NULL. */
540 static struct partial_symbol
*
541 match_partial_symbol (struct objfile
*objfile
,
542 struct partial_symtab
*pst
, int global
,
543 const lookup_name_info
&name
, domain_enum domain
,
544 symbol_compare_ftype
*ordered_compare
)
546 struct partial_symbol
**start
, **psym
;
547 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
548 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
549 int do_linear_search
= 1;
555 &objfile
->partial_symtabs
->global_psymbols
[pst
->globals_offset
] :
556 &objfile
->partial_symtabs
->static_psymbols
[pst
->statics_offset
]);
558 if (global
&& ordered_compare
) /* Can use a binary search. */
560 do_linear_search
= 0;
562 /* Binary search. This search is guaranteed to end with center
563 pointing at the earliest partial symbol whose name might be
564 correct. At that point *all* partial symbols with an
565 appropriate name will be checked against the correct
569 top
= start
+ length
- 1;
573 center
= bottom
+ (top
- bottom
) / 2;
574 gdb_assert (center
< top
);
576 enum language lang
= (*center
)->ginfo
.language ();
578 = name
.language_lookup_name (lang
).c_str ();
580 if (ordered_compare ((*center
)->ginfo
.search_name (),
586 gdb_assert (top
== bottom
);
588 while (top
<= real_top
589 && psymbol_name_matches (*top
, name
))
591 if (symbol_matches_domain ((*top
)->ginfo
.language (),
592 (*top
)->domain
, domain
))
598 /* Can't use a binary search or else we found during the binary search that
599 we should also do a linear search. */
601 if (do_linear_search
)
603 for (psym
= start
; psym
< start
+ length
; psym
++)
605 if (symbol_matches_domain ((*psym
)->ginfo
.language (),
606 (*psym
)->domain
, domain
)
607 && psymbol_name_matches (*psym
, name
))
615 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
616 not contain any method/function instance information (since this would
617 force reading type information while reading psymtabs). Therefore,
618 if NAME contains overload information, it must be stripped before searching
621 static gdb::unique_xmalloc_ptr
<char>
622 psymtab_search_name (const char *name
)
624 switch (current_language
->la_language
)
628 if (strchr (name
, '('))
630 gdb::unique_xmalloc_ptr
<char> ret
= cp_remove_params (name
);
642 return make_unique_xstrdup (name
);
645 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
646 Check the global symbols if GLOBAL, the static symbols if not. */
648 static struct partial_symbol
*
649 lookup_partial_symbol (struct objfile
*objfile
,
650 struct partial_symtab
*pst
, const char *name
,
651 int global
, domain_enum domain
)
653 struct partial_symbol
**start
, **psym
;
654 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
655 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
656 int do_linear_search
= 1;
661 gdb::unique_xmalloc_ptr
<char> search_name
= psymtab_search_name (name
);
663 lookup_name_info
lookup_name (search_name
.get (), symbol_name_match_type::FULL
);
666 &objfile
->partial_symtabs
->global_psymbols
[pst
->globals_offset
] :
667 &objfile
->partial_symtabs
->static_psymbols
[pst
->statics_offset
]);
669 if (global
) /* This means we can use a binary search. */
671 do_linear_search
= 0;
673 /* Binary search. This search is guaranteed to end with center
674 pointing at the earliest partial symbol whose name might be
675 correct. At that point *all* partial symbols with an
676 appropriate name will be checked against the correct
680 top
= start
+ length
- 1;
684 center
= bottom
+ (top
- bottom
) / 2;
686 internal_error (__FILE__
, __LINE__
,
687 _("failed internal consistency check"));
688 if (strcmp_iw_ordered ((*center
)->ginfo
.search_name (),
689 search_name
.get ()) >= 0)
698 if (!(top
== bottom
))
699 internal_error (__FILE__
, __LINE__
,
700 _("failed internal consistency check"));
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
->compunit_symtab
)
754 return pst
->compunit_symtab
;
756 /* If it has not yet been read in, read it. */
759 scoped_restore decrementer
= increment_reading_symtab ();
761 pst
->read_symtab (objfile
);
764 return pst
->compunit_symtab
;
767 /* Psymtab version of find_last_source_symtab. See its definition in
768 the definition of quick_symbol_functions in symfile.h. */
770 static struct symtab
*
771 psym_find_last_source_symtab (struct objfile
*ofp
)
773 struct partial_symtab
*cs_pst
= NULL
;
775 for (partial_symtab
*ps
: require_partial_symbols (ofp
, true))
777 const char *name
= ps
->filename
;
778 int len
= strlen (name
);
780 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
781 || strcmp (name
, "<<C++-namespaces>>") == 0)))
789 internal_error (__FILE__
, __LINE__
,
790 _("select_source_symtab: "
791 "readin pst found and no symtabs."));
795 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
799 return compunit_primary_filetab (cust
);
805 /* Psymtab version of forget_cached_source_info. See its definition in
806 the definition of quick_symbol_functions in symfile.h. */
809 psym_forget_cached_source_info (struct objfile
*objfile
)
811 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
813 if (pst
->fullname
!= NULL
)
815 xfree (pst
->fullname
);
816 pst
->fullname
= NULL
;
822 print_partial_symbols (struct gdbarch
*gdbarch
, struct objfile
*objfile
,
823 struct partial_symbol
**p
, int count
, const char *what
,
824 struct ui_file
*outfile
)
826 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
830 fprintf_filtered (outfile
, " `%s'", (*p
)->ginfo
.linkage_name ());
831 if ((*p
)->ginfo
.demangled_name () != NULL
)
833 fprintf_filtered (outfile
, " `%s'",
834 (*p
)->ginfo
.demangled_name ());
836 fputs_filtered (", ", outfile
);
837 switch ((*p
)->domain
)
840 fputs_filtered ("undefined domain, ", outfile
);
843 /* This is the usual thing -- don't print it. */
846 fputs_filtered ("struct domain, ", outfile
);
849 fputs_filtered ("module domain, ", outfile
);
852 fputs_filtered ("label domain, ", outfile
);
854 case COMMON_BLOCK_DOMAIN
:
855 fputs_filtered ("common block domain, ", outfile
);
858 fputs_filtered ("<invalid domain>, ", outfile
);
861 switch ((*p
)->aclass
)
864 fputs_filtered ("undefined", outfile
);
867 fputs_filtered ("constant int", outfile
);
870 fputs_filtered ("static", outfile
);
873 fputs_filtered ("register", outfile
);
876 fputs_filtered ("pass by value", outfile
);
879 fputs_filtered ("pass by reference", outfile
);
881 case LOC_REGPARM_ADDR
:
882 fputs_filtered ("register address parameter", outfile
);
885 fputs_filtered ("stack parameter", outfile
);
888 fputs_filtered ("type", outfile
);
891 fputs_filtered ("label", outfile
);
894 fputs_filtered ("function", outfile
);
896 case LOC_CONST_BYTES
:
897 fputs_filtered ("constant bytes", outfile
);
900 fputs_filtered ("unresolved", outfile
);
902 case LOC_OPTIMIZED_OUT
:
903 fputs_filtered ("optimized out", outfile
);
906 fputs_filtered ("computed at runtime", outfile
);
909 fputs_filtered ("<invalid location>", outfile
);
912 fputs_filtered (", ", outfile
);
913 fputs_filtered (paddress (gdbarch
, (*p
)->unrelocated_address ()), outfile
);
914 fprintf_filtered (outfile
, "\n");
920 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
921 struct ui_file
*outfile
)
923 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
926 if (psymtab
->anonymous
)
928 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
933 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
936 fprintf_filtered (outfile
, "(object ");
937 gdb_print_host_address (psymtab
, outfile
);
938 fprintf_filtered (outfile
, ")\n\n");
939 fprintf_filtered (outfile
, " Read from object file %s (",
940 objfile_name (objfile
));
941 gdb_print_host_address (objfile
, outfile
);
942 fprintf_filtered (outfile
, ")\n");
946 fprintf_filtered (outfile
,
947 " Full symtab was read (at ");
948 gdb_print_host_address (psymtab
->compunit_symtab
, outfile
);
949 fprintf_filtered (outfile
, ")\n");
952 fprintf_filtered (outfile
, " Symbols cover text addresses ");
953 fputs_filtered (paddress (gdbarch
, psymtab
->text_low (objfile
)), outfile
);
954 fprintf_filtered (outfile
, "-");
955 fputs_filtered (paddress (gdbarch
, psymtab
->text_high (objfile
)), outfile
);
956 fprintf_filtered (outfile
, "\n");
957 fprintf_filtered (outfile
, " Address map supported - %s.\n",
958 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
959 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
960 psymtab
->number_of_dependencies
);
961 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
963 fprintf_filtered (outfile
, " %d ", i
);
964 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
965 fprintf_filtered (outfile
, " %s\n",
966 psymtab
->dependencies
[i
]->filename
);
968 if (psymtab
->user
!= NULL
)
970 fprintf_filtered (outfile
, " Shared partial symtab with user ");
971 gdb_print_host_address (psymtab
->user
, outfile
);
972 fprintf_filtered (outfile
, "\n");
974 if (psymtab
->n_global_syms
> 0)
976 print_partial_symbols
978 &objfile
->partial_symtabs
->global_psymbols
[psymtab
->globals_offset
],
979 psymtab
->n_global_syms
, "Global", outfile
);
981 if (psymtab
->n_static_syms
> 0)
983 print_partial_symbols
985 &objfile
->partial_symtabs
->static_psymbols
[psymtab
->statics_offset
],
986 psymtab
->n_static_syms
, "Static", outfile
);
988 fprintf_filtered (outfile
, "\n");
991 /* Psymtab version of print_stats. See its definition in
992 the definition of quick_symbol_functions in symfile.h. */
995 psym_print_stats (struct objfile
*objfile
)
1000 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1005 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1008 /* Psymtab version of dump. See its definition in
1009 the definition of quick_symbol_functions in symfile.h. */
1012 psym_dump (struct objfile
*objfile
)
1014 struct partial_symtab
*psymtab
;
1016 if (objfile
->partial_symtabs
->psymtabs
)
1018 printf_filtered ("Psymtabs:\n");
1019 for (psymtab
= objfile
->partial_symtabs
->psymtabs
;
1021 psymtab
= psymtab
->next
)
1023 printf_filtered ("%s at ",
1025 gdb_print_host_address (psymtab
, gdb_stdout
);
1026 printf_filtered (", ");
1029 printf_filtered ("\n\n");
1033 /* Psymtab version of expand_symtabs_for_function. See its definition in
1034 the definition of quick_symbol_functions in symfile.h. */
1037 psym_expand_symtabs_for_function (struct objfile
*objfile
,
1038 const char *func_name
)
1040 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1045 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1047 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1049 psymtab_to_symtab (objfile
, ps
);
1053 /* Psymtab version of expand_all_symtabs. See its definition in
1054 the definition of quick_symbol_functions in symfile.h. */
1057 psym_expand_all_symtabs (struct objfile
*objfile
)
1059 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, true))
1060 psymtab_to_symtab (objfile
, psymtab
);
1063 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1064 the definition of quick_symbol_functions in symfile.h. */
1067 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1068 const char *fullname
)
1070 for (partial_symtab
*p
: require_partial_symbols (objfile
, true))
1072 /* Anonymous psymtabs don't have a name of a source file. */
1076 /* psymtab_to_fullname tries to open the file which is slow.
1077 Don't call it if we know the basenames don't match. */
1078 if ((basenames_may_differ
1079 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1080 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1081 psymtab_to_symtab (objfile
, p
);
1085 /* Psymtab version of map_symbol_filenames. See its definition in
1086 the definition of quick_symbol_functions in symfile.h. */
1089 psym_map_symbol_filenames (struct objfile
*objfile
,
1090 symbol_filename_ftype
*fun
, void *data
,
1093 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1095 const char *fullname
;
1100 /* We can skip shared psymtabs here, because any file name will be
1101 attached to the unshared psymtab. */
1102 if (ps
->user
!= NULL
)
1105 /* Anonymous psymtabs don't have a file name. */
1111 fullname
= psymtab_to_fullname (ps
);
1114 (*fun
) (ps
->filename
, fullname
, data
);
1118 /* Finds the fullname that a partial_symtab represents.
1120 If this functions finds the fullname, it will save it in ps->fullname
1121 and it will also return the value.
1123 If this function fails to find the file that this partial_symtab represents,
1124 NULL will be returned and ps->fullname will be set to NULL. */
1127 psymtab_to_fullname (struct partial_symtab
*ps
)
1129 gdb_assert (!ps
->anonymous
);
1131 /* Use cached copy if we have it.
1132 We rely on forget_cached_source_info being called appropriately
1133 to handle cases like the file being moved. */
1134 if (ps
->fullname
== NULL
)
1136 gdb::unique_xmalloc_ptr
<char> fullname
;
1137 scoped_fd fd
= find_and_open_source (ps
->filename
, ps
->dirname
,
1139 ps
->fullname
= fullname
.release ();
1143 /* rewrite_source_path would be applied by find_and_open_source, we
1144 should report the pathname where GDB tried to find the file. */
1146 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
1147 fullname
.reset (xstrdup (ps
->filename
));
1149 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
1150 ps
->filename
, (char *) NULL
));
1152 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1153 if (ps
->fullname
== NULL
)
1154 ps
->fullname
= fullname
.release ();
1158 return ps
->fullname
;
1161 /* Psymtab version of map_matching_symbols. See its definition in
1162 the definition of quick_symbol_functions in symfile.h. */
1165 psym_map_matching_symbols
1166 (struct objfile
*objfile
,
1167 const lookup_name_info
&name
, domain_enum domain
,
1169 gdb::function_view
<symbol_found_callback_ftype
> callback
,
1170 symbol_compare_ftype
*ordered_compare
)
1172 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1174 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1178 || match_partial_symbol (objfile
, ps
, global
, name
, domain
,
1181 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1182 const struct block
*block
;
1186 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1187 if (!iterate_over_symbols_terminated (block
, name
,
1194 /* A helper for psym_expand_symtabs_matching that handles searching
1195 included psymtabs. This returns true if a symbol is found, and
1196 false otherwise. It also updates the 'searched_flag' on the
1197 various psymtabs that it searches. */
1200 recursively_search_psymtabs
1201 (struct partial_symtab
*ps
,
1202 struct objfile
*objfile
,
1203 enum search_domain domain
,
1204 const lookup_name_info
&lookup_name
,
1205 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1208 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1211 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1212 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1214 /* Recurse into shared psymtabs first, because they may have already
1215 been searched, and this could save some time. */
1216 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1220 /* Skip non-shared dependencies, these are handled elsewhere. */
1221 if (ps
->dependencies
[i
]->user
== NULL
)
1224 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1225 objfile
, domain
, lookup_name
,
1229 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1234 partial_symbol
**gbound
1235 = (objfile
->partial_symtabs
->global_psymbols
.data ()
1236 + ps
->globals_offset
+ ps
->n_global_syms
);
1237 partial_symbol
**sbound
1238 = (objfile
->partial_symtabs
->static_psymbols
.data ()
1239 + ps
->statics_offset
+ ps
->n_static_syms
);
1240 partial_symbol
**bound
= gbound
;
1242 /* Go through all of the symbols stored in a partial
1243 symtab in one loop. */
1244 partial_symbol
**psym
= (objfile
->partial_symtabs
->global_psymbols
.data ()
1245 + ps
->globals_offset
);
1250 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1252 psym
= (objfile
->partial_symtabs
->static_psymbols
.data ()
1253 + ps
->statics_offset
);
1264 if ((domain
== ALL_DOMAIN
1265 || (domain
== MODULES_DOMAIN
1266 && (*psym
)->domain
== MODULE_DOMAIN
)
1267 || (domain
== VARIABLES_DOMAIN
1268 && (*psym
)->aclass
!= LOC_TYPEDEF
1269 && (*psym
)->aclass
!= LOC_BLOCK
)
1270 || (domain
== FUNCTIONS_DOMAIN
1271 && (*psym
)->aclass
== LOC_BLOCK
)
1272 || (domain
== TYPES_DOMAIN
1273 && (*psym
)->aclass
== LOC_TYPEDEF
))
1274 && psymbol_name_matches (*psym
, lookup_name
)
1275 && (sym_matcher
== NULL
1276 || sym_matcher ((*psym
)->ginfo
.search_name ())))
1278 /* Found a match, so notify our caller. */
1279 result
= PST_SEARCHED_AND_FOUND
;
1286 ps
->searched_flag
= result
;
1287 return result
== PST_SEARCHED_AND_FOUND
;
1290 /* Psymtab version of expand_symtabs_matching. See its definition in
1291 the definition of quick_symbol_functions in symfile.h. */
1294 psym_expand_symtabs_matching
1295 (struct objfile
*objfile
,
1296 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1297 const lookup_name_info
&lookup_name_in
,
1298 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1299 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1300 enum search_domain domain
)
1302 lookup_name_info lookup_name
= lookup_name_in
.make_ignore_params ();
1304 /* Clear the search flags. */
1305 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1306 ps
->searched_flag
= PST_NOT_SEARCHED
;
1308 for (partial_symtab
*ps
: objfile
->psymtabs ())
1315 /* We skip shared psymtabs because file-matching doesn't apply
1316 to them; but we search them later in the loop. */
1317 if (ps
->user
!= NULL
)
1327 match
= file_matcher (ps
->filename
, false);
1330 /* Before we invoke realpath, which can get expensive when many
1331 files are involved, do a quick comparison of the basenames. */
1332 if (basenames_may_differ
1333 || file_matcher (lbasename (ps
->filename
), true))
1334 match
= file_matcher (psymtab_to_fullname (ps
), false);
1340 if (recursively_search_psymtabs (ps
, objfile
, domain
,
1341 lookup_name
, symbol_matcher
))
1343 struct compunit_symtab
*symtab
=
1344 psymtab_to_symtab (objfile
, ps
);
1346 if (expansion_notify
!= NULL
)
1347 expansion_notify (symtab
);
1352 /* Psymtab version of has_symbols. See its definition in
1353 the definition of quick_symbol_functions in symfile.h. */
1356 psym_has_symbols (struct objfile
*objfile
)
1358 return objfile
->partial_symtabs
->psymtabs
!= NULL
;
1361 /* Helper function for psym_find_compunit_symtab_by_address that fills
1362 in psymbol_map for a given range of psymbols. */
1365 psym_fill_psymbol_map (struct objfile
*objfile
,
1366 struct partial_symtab
*psymtab
,
1367 std::set
<CORE_ADDR
> *seen_addrs
,
1368 const std::vector
<partial_symbol
*> &symbols
,
1372 for (int i
= 0; i
< length
; ++i
)
1374 struct partial_symbol
*psym
= symbols
[start
+ i
];
1376 if (psym
->aclass
== LOC_STATIC
)
1378 CORE_ADDR addr
= psym
->address (objfile
);
1379 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1381 seen_addrs
->insert (addr
);
1382 objfile
->psymbol_map
.emplace_back (addr
, psymtab
);
1388 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1391 static compunit_symtab
*
1392 psym_find_compunit_symtab_by_address (struct objfile
*objfile
,
1395 if (objfile
->psymbol_map
.empty ())
1397 std::set
<CORE_ADDR
> seen_addrs
;
1399 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
1401 psym_fill_psymbol_map (objfile
, pst
,
1403 objfile
->partial_symtabs
->global_psymbols
,
1404 pst
->globals_offset
,
1405 pst
->n_global_syms
);
1406 psym_fill_psymbol_map (objfile
, pst
,
1408 objfile
->partial_symtabs
->static_psymbols
,
1409 pst
->statics_offset
,
1410 pst
->n_static_syms
);
1413 objfile
->psymbol_map
.shrink_to_fit ();
1415 std::sort (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (),
1416 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1417 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1419 return a
.first
< b
.first
;
1423 auto iter
= std::lower_bound
1424 (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (), address
,
1425 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1431 if (iter
== objfile
->psymbol_map
.end () || iter
->first
!= address
)
1434 return psymtab_to_symtab (objfile
, iter
->second
);
1437 const struct quick_symbol_functions psym_functions
=
1440 psym_find_last_source_symtab
,
1441 psym_forget_cached_source_info
,
1442 psym_map_symtabs_matching_filename
,
1446 psym_expand_symtabs_for_function
,
1447 psym_expand_all_symtabs
,
1448 psym_expand_symtabs_with_fullname
,
1449 psym_map_matching_symbols
,
1450 psym_expand_symtabs_matching
,
1451 psym_find_pc_sect_compunit_symtab
,
1452 psym_find_compunit_symtab_by_address
,
1453 psym_map_symbol_filenames
1459 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1461 /* Sort the global list; don't sort the static list. */
1462 auto begin
= objfile
->partial_symtabs
->global_psymbols
.begin ();
1463 std::advance (begin
, pst
->globals_offset
);
1465 /* The psymbols for this partial_symtab are currently at the end of the
1467 auto end
= objfile
->partial_symtabs
->global_psymbols
.end ();
1469 std::sort (begin
, end
, [] (partial_symbol
*s1
, partial_symbol
*s2
)
1471 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1472 s2
->ginfo
.search_name ()) < 0;
1476 /* Partially fill a partial symtab. It will be completely filled at
1477 the end of the symbol list. */
1479 partial_symtab::partial_symtab (const char *filename
,
1480 struct objfile
*objfile
,
1482 : partial_symtab (filename
, objfile
)
1484 set_text_low (textlow
);
1485 set_text_high (raw_text_low ()); /* default */
1486 globals_offset
= objfile
->partial_symtabs
->global_psymbols
.size ();
1487 statics_offset
= objfile
->partial_symtabs
->static_psymbols
.size ();
1490 /* Perform "finishing up" operations of a partial symtab. */
1493 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1495 pst
->n_global_syms
= (objfile
->partial_symtabs
->global_psymbols
.size ()
1496 - pst
->globals_offset
);
1497 pst
->n_static_syms
= (objfile
->partial_symtabs
->static_psymbols
.size ()
1498 - pst
->statics_offset
);
1500 sort_pst_symbols (objfile
, pst
);
1503 /* Calculate a hash code for the given partial symbol. The hash is
1504 calculated using the symbol's value, language, domain, class
1505 and name. These are the values which are set by
1506 add_psymbol_to_bcache. */
1508 static unsigned long
1509 psymbol_hash (const void *addr
, int length
)
1511 unsigned long h
= 0;
1512 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1513 unsigned int lang
= psymbol
->ginfo
.language ();
1514 unsigned int domain
= psymbol
->domain
;
1515 unsigned int theclass
= psymbol
->aclass
;
1517 h
= fast_hash (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1518 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1519 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1520 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1521 /* Note that psymbol names are interned via compute_and_set_names, so
1522 there's no need to hash the contents of the name here. */
1523 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1528 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1529 For the comparison this function uses a symbols value,
1530 language, domain, class and name. */
1533 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1535 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1536 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1538 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1539 sizeof (sym1
->ginfo
.value
)) == 0
1540 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1541 && sym1
->domain
== sym2
->domain
1542 && sym1
->aclass
== sym2
->aclass
1543 /* Note that psymbol names are interned via
1544 compute_and_set_names, so there's no need to compare the
1545 contents of the name here. */
1546 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1549 /* Helper function, initialises partial symbol structure and stashes
1550 it into objfile's bcache. Note that our caching mechanism will
1551 use all fields of struct partial_symbol to determine hash value of the
1552 structure. In other words, having two symbols with the same name but
1553 different domain (or address) is possible and correct. */
1555 static struct partial_symbol
*
1556 add_psymbol_to_bcache (gdb::string_view name
, bool copy_name
,
1558 enum address_class theclass
,
1561 enum language language
, struct objfile
*objfile
,
1564 struct partial_symbol psymbol
;
1565 memset (&psymbol
, 0, sizeof (psymbol
));
1567 psymbol
.set_unrelocated_address (coreaddr
);
1568 psymbol
.ginfo
.section
= section
;
1569 psymbol
.domain
= domain
;
1570 psymbol
.aclass
= theclass
;
1571 psymbol
.ginfo
.set_language (language
, objfile
->partial_symtabs
->obstack ());
1572 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1574 /* Stash the partial symbol away in the cache. */
1575 return ((struct partial_symbol
*)
1576 objfile
->partial_symtabs
->psymbol_cache
.insert
1577 (&psymbol
, sizeof (struct partial_symbol
), added
));
1580 /* Helper function, adds partial symbol to the given partial symbol list. */
1583 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1584 struct partial_symbol
*psym
,
1585 struct objfile
*objfile
)
1587 list
->push_back (psym
);
1588 OBJSTAT (objfile
, n_psyms
++);
1591 /* See psympriv.h. */
1594 add_psymbol_to_list (gdb::string_view name
, bool copy_name
,
1596 enum address_class theclass
,
1598 psymbol_placement where
,
1600 enum language language
, struct objfile
*objfile
)
1602 struct partial_symbol
*psym
;
1606 /* Stash the partial symbol away in the cache. */
1607 psym
= add_psymbol_to_bcache (name
, copy_name
, domain
, theclass
,
1608 section
, coreaddr
, language
, objfile
, &added
);
1610 /* Do not duplicate global partial symbols. */
1611 if (where
== psymbol_placement::GLOBAL
&& !added
)
1614 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1615 std::vector
<partial_symbol
*> *list
1616 = (where
== psymbol_placement::STATIC
1617 ? &objfile
->partial_symtabs
->static_psymbols
1618 : &objfile
->partial_symtabs
->global_psymbols
);
1619 append_psymbol_to_list (list
, psym
, objfile
);
1622 /* See psympriv.h. */
1625 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1627 if (objfile
->partial_symtabs
->global_psymbols
.capacity () == 0
1628 && objfile
->partial_symtabs
->static_psymbols
.capacity () == 0)
1630 /* Current best guess is that approximately a twentieth of the
1631 total symbols (in a debugging file) are global or static
1632 oriented symbols, then multiply that by slop factor of
1634 objfile
->partial_symtabs
->global_psymbols
.reserve (total_symbols
/ 10);
1635 objfile
->partial_symtabs
->static_psymbols
.reserve (total_symbols
/ 10);
1639 /* See psympriv.h. */
1641 partial_symtab::partial_symtab (const char *filename_
, struct objfile
*objfile
)
1642 : searched_flag (PST_NOT_SEARCHED
),
1646 objfile
->partial_symtabs
->install_psymtab (this);
1649 = ((const char *) objfile
->per_bfd
->filename_cache
.insert
1650 (filename_
, strlen (filename_
) + 1));
1651 compunit_symtab
= NULL
;
1653 if (symtab_create_debug
)
1655 /* Be a bit clever with debugging messages, and don't print objfile
1656 every time, only when it changes. */
1657 static char *last_objfile_name
= NULL
;
1659 if (last_objfile_name
== NULL
1660 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1662 xfree (last_objfile_name
);
1663 last_objfile_name
= xstrdup (objfile_name (objfile
));
1664 fprintf_filtered (gdb_stdlog
,
1665 "Creating one or more psymtabs for objfile %s ...\n",
1668 fprintf_filtered (gdb_stdlog
,
1669 "Created psymtab %s for module %s.\n",
1670 host_address_to_string (this), filename
);
1675 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1677 struct partial_symtab
**prev_pst
;
1680 Empty psymtabs happen as a result of header files which don't
1681 have any symbols in them. There can be a lot of them. But this
1682 check is wrong, in that a psymtab with N_SLINE entries but
1683 nothing else is not empty, but we don't realize that. Fixing
1684 that without slowing things down might be tricky. */
1686 /* First, snip it out of the psymtab chain. */
1688 prev_pst
= &psymtabs
;
1689 while ((*prev_pst
) != pst
)
1690 prev_pst
= &((*prev_pst
)->next
);
1691 (*prev_pst
) = pst
->next
;
1697 /* We need to pass a couple of items to the addrmap_foreach function,
1700 struct dump_psymtab_addrmap_data
1702 struct objfile
*objfile
;
1703 struct partial_symtab
*psymtab
;
1704 struct ui_file
*outfile
;
1706 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1707 If so, we want to print the next one as well (since the next addrmap
1708 entry defines the end of the range). */
1709 int previous_matched
;
1712 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1715 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1717 struct dump_psymtab_addrmap_data
*data
1718 = (struct dump_psymtab_addrmap_data
*) datap
;
1719 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1720 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1721 const char *psymtab_address_or_end
= NULL
;
1725 if (data
->psymtab
== NULL
1726 || data
->psymtab
== addrmap_psymtab
)
1727 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1728 else if (data
->previous_matched
)
1729 psymtab_address_or_end
= "<ends here>";
1731 if (data
->psymtab
== NULL
1732 || data
->psymtab
== addrmap_psymtab
1733 || data
->previous_matched
)
1735 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1736 data
->psymtab
!= NULL
? " " : "",
1737 paddress (gdbarch
, start_addr
),
1738 psymtab_address_or_end
);
1741 data
->previous_matched
= (data
->psymtab
== NULL
1742 || data
->psymtab
== addrmap_psymtab
);
1747 /* Helper function for maintenance_print_psymbols to print the addrmap
1748 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1751 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1752 struct ui_file
*outfile
)
1754 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1756 if ((psymtab
== NULL
1757 || psymtab
->psymtabs_addrmap_supported
)
1758 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
1760 addrmap_dump_data
.objfile
= objfile
;
1761 addrmap_dump_data
.psymtab
= psymtab
;
1762 addrmap_dump_data
.outfile
= outfile
;
1763 addrmap_dump_data
.previous_matched
= 0;
1764 fprintf_filtered (outfile
, "%sddress map:\n",
1765 psymtab
== NULL
? "Entire a" : " A");
1766 addrmap_foreach (objfile
->partial_symtabs
->psymtabs_addrmap
,
1767 dump_psymtab_addrmap_1
, &addrmap_dump_data
);
1772 maintenance_print_psymbols (const char *args
, int from_tty
)
1774 struct ui_file
*outfile
= gdb_stdout
;
1775 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1776 int i
, outfile_idx
, found
;
1778 struct obj_section
*section
= NULL
;
1782 gdb_argv
argv (args
);
1784 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1786 if (strcmp (argv
[i
], "-pc") == 0)
1788 if (argv
[i
+ 1] == NULL
)
1789 error (_("Missing pc value"));
1790 address_arg
= argv
[++i
];
1792 else if (strcmp (argv
[i
], "-source") == 0)
1794 if (argv
[i
+ 1] == NULL
)
1795 error (_("Missing source file"));
1796 source_arg
= argv
[++i
];
1798 else if (strcmp (argv
[i
], "-objfile") == 0)
1800 if (argv
[i
+ 1] == NULL
)
1801 error (_("Missing objfile name"));
1802 objfile_arg
= argv
[++i
];
1804 else if (strcmp (argv
[i
], "--") == 0)
1806 /* End of options. */
1810 else if (argv
[i
][0] == '-')
1812 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1813 error (_("Unknown option: %s"), argv
[i
]);
1820 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1821 error (_("Must specify at most one of -pc and -source"));
1823 stdio_file arg_outfile
;
1825 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1827 if (argv
[outfile_idx
+ 1] != NULL
)
1828 error (_("Junk at end of command"));
1829 gdb::unique_xmalloc_ptr
<char> outfile_name
1830 (tilde_expand (argv
[outfile_idx
]));
1831 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1832 perror_with_name (outfile_name
.get ());
1833 outfile
= &arg_outfile
;
1836 if (address_arg
!= NULL
)
1838 pc
= parse_and_eval_address (address_arg
);
1839 /* If we fail to find a section, that's ok, try the lookup anyway. */
1840 section
= find_pc_section (pc
);
1844 for (objfile
*objfile
: current_program_space
->objfiles ())
1846 int printed_objfile_header
= 0;
1847 int print_for_objfile
= 1;
1850 if (objfile_arg
!= NULL
)
1852 = compare_filenames_for_search (objfile_name (objfile
),
1854 if (!print_for_objfile
)
1857 if (address_arg
!= NULL
)
1859 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1861 /* We don't assume each pc has a unique objfile (this is for
1863 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
,
1867 if (!printed_objfile_header
)
1869 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1870 objfile_name (objfile
));
1871 printed_objfile_header
= 1;
1873 dump_psymtab (objfile
, ps
, outfile
);
1874 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1880 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1882 int print_for_source
= 0;
1885 if (source_arg
!= NULL
)
1888 = compare_filenames_for_search (ps
->filename
, source_arg
);
1891 if (source_arg
== NULL
1892 || print_for_source
)
1894 if (!printed_objfile_header
)
1896 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1897 objfile_name (objfile
));
1898 printed_objfile_header
= 1;
1900 dump_psymtab (objfile
, ps
, outfile
);
1901 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1906 /* If we're printing all the objfile's symbols dump the full addrmap. */
1908 if (address_arg
== NULL
1909 && source_arg
== NULL
1910 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
1912 outfile
->puts ("\n");
1913 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
1919 if (address_arg
!= NULL
)
1920 error (_("No partial symtab for address: %s"), address_arg
);
1921 if (source_arg
!= NULL
)
1922 error (_("No partial symtab for source file: %s"), source_arg
);
1926 /* List all the partial symbol tables whose names match REGEXP (optional). */
1929 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1931 struct program_space
*pspace
;
1936 ALL_PSPACES (pspace
)
1937 for (objfile
*objfile
: pspace
->objfiles ())
1939 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1941 /* We don't want to print anything for this objfile until we
1942 actually find a symtab whose name matches. */
1943 int printed_objfile_start
= 0;
1945 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, true))
1950 || re_exec (psymtab
->filename
))
1952 if (! printed_objfile_start
)
1954 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
1956 printf_filtered ("((struct objfile *) %s)\n",
1957 host_address_to_string (objfile
));
1958 printed_objfile_start
= 1;
1961 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1963 printf_filtered ("((struct partial_symtab *) %s)\n",
1964 host_address_to_string (psymtab
));
1966 printf_filtered (" readin %s\n",
1967 psymtab
->readin
? "yes" : "no");
1968 printf_filtered (" fullname %s\n",
1970 ? psymtab
->fullname
: "(null)");
1971 printf_filtered (" text addresses ");
1972 fputs_filtered (paddress (gdbarch
,
1973 psymtab
->text_low (objfile
)),
1975 printf_filtered (" -- ");
1976 fputs_filtered (paddress (gdbarch
,
1977 psymtab
->text_high (objfile
)),
1979 printf_filtered ("\n");
1980 printf_filtered (" psymtabs_addrmap_supported %s\n",
1981 (psymtab
->psymtabs_addrmap_supported
1983 printf_filtered (" globals ");
1984 if (psymtab
->n_global_syms
)
1986 auto p
= &(objfile
->partial_symtabs
1987 ->global_psymbols
[psymtab
->globals_offset
]);
1990 ("(* (struct partial_symbol **) %s @ %d)\n",
1991 host_address_to_string (p
),
1992 psymtab
->n_global_syms
);
1995 printf_filtered ("(none)\n");
1996 printf_filtered (" statics ");
1997 if (psymtab
->n_static_syms
)
1999 auto p
= &(objfile
->partial_symtabs
2000 ->static_psymbols
[psymtab
->statics_offset
]);
2003 ("(* (struct partial_symbol **) %s @ %d)\n",
2004 host_address_to_string (p
),
2005 psymtab
->n_static_syms
);
2008 printf_filtered ("(none)\n");
2009 printf_filtered (" dependencies ");
2010 if (psymtab
->number_of_dependencies
)
2014 printf_filtered ("{\n");
2015 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2017 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2019 /* Note the string concatenation there --- no
2021 printf_filtered (" psymtab %s "
2022 "((struct partial_symtab *) %s)\n",
2024 host_address_to_string (dep
));
2026 printf_filtered (" }\n");
2029 printf_filtered ("(none)\n");
2030 printf_filtered (" }\n");
2034 if (printed_objfile_start
)
2035 printf_filtered ("}\n");
2039 /* Check consistency of currently expanded psymtabs vs symtabs. */
2042 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2045 struct compunit_symtab
*cust
= NULL
;
2046 const struct blockvector
*bv
;
2047 const struct block
*b
;
2050 for (objfile
*objfile
: current_program_space
->objfiles ())
2051 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
2053 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2055 /* We don't call psymtab_to_symtab here because that may cause symtab
2056 expansion. When debugging a problem it helps if checkers leave
2057 things unchanged. */
2058 cust
= ps
->compunit_symtab
;
2060 /* First do some checks that don't require the associated symtab. */
2061 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
2063 printf_filtered ("Psymtab ");
2064 puts_filtered (ps
->filename
);
2065 printf_filtered (" covers bad range ");
2066 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2068 printf_filtered (" - ");
2069 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2071 printf_filtered ("\n");
2075 /* Now do checks requiring the associated symtab. */
2078 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2079 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2080 partial_symbol
**psym
2081 = &objfile
->partial_symtabs
->static_psymbols
[ps
->statics_offset
];
2082 length
= ps
->n_static_syms
;
2085 sym
= block_lookup_symbol (b
, (*psym
)->ginfo
.search_name (),
2086 symbol_name_match_type::SEARCH_NAME
,
2090 printf_filtered ("Static symbol `");
2091 puts_filtered ((*psym
)->ginfo
.linkage_name ());
2092 printf_filtered ("' only found in ");
2093 puts_filtered (ps
->filename
);
2094 printf_filtered (" psymtab\n");
2098 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2099 psym
= &objfile
->partial_symtabs
->global_psymbols
[ps
->globals_offset
];
2100 length
= ps
->n_global_syms
;
2103 sym
= block_lookup_symbol (b
, (*psym
)->ginfo
.search_name (),
2104 symbol_name_match_type::SEARCH_NAME
,
2108 printf_filtered ("Global symbol `");
2109 puts_filtered ((*psym
)->ginfo
.linkage_name ());
2110 printf_filtered ("' only found in ");
2111 puts_filtered (ps
->filename
);
2112 printf_filtered (" psymtab\n");
2116 if (ps
->raw_text_high () != 0
2117 && (ps
->text_low (objfile
) < BLOCK_START (b
)
2118 || ps
->text_high (objfile
) > BLOCK_END (b
)))
2120 printf_filtered ("Psymtab ");
2121 puts_filtered (ps
->filename
);
2122 printf_filtered (" covers ");
2123 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2125 printf_filtered (" - ");
2126 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2128 printf_filtered (" but symtab covers only ");
2129 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2130 printf_filtered (" - ");
2131 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2132 printf_filtered ("\n");
2137 void _initialize_psymtab ();
2139 _initialize_psymtab ()
2141 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2142 Print dump of current partial symbol definitions.\n\
2143 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
2144 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
2145 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2146 or the terminal if OUTFILE is unspecified.\n\
2147 If ADDRESS is provided, dump only the file for that address.\n\
2148 If SOURCE is provided, dump only that file's symbols.\n\
2149 If OBJFILE is provided, dump only that file's minimal symbols."),
2150 &maintenanceprintlist
);
2152 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2153 List the partial symbol tables for all object files.\n\
2154 This does not include information about individual partial symbols,\n\
2155 just the symbol table structures themselves."),
2156 &maintenanceinfolist
);
2158 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2160 Check consistency of currently expanded psymtabs versus symtabs."),