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
) (pst
, 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
, " by function at ");
950 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
951 fprintf_filtered (outfile
, ")\n");
954 fprintf_filtered (outfile
, " Symbols cover text addresses ");
955 fputs_filtered (paddress (gdbarch
, psymtab
->text_low (objfile
)), outfile
);
956 fprintf_filtered (outfile
, "-");
957 fputs_filtered (paddress (gdbarch
, psymtab
->text_high (objfile
)), outfile
);
958 fprintf_filtered (outfile
, "\n");
959 fprintf_filtered (outfile
, " Address map supported - %s.\n",
960 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
961 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
962 psymtab
->number_of_dependencies
);
963 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
965 fprintf_filtered (outfile
, " %d ", i
);
966 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
967 fprintf_filtered (outfile
, " %s\n",
968 psymtab
->dependencies
[i
]->filename
);
970 if (psymtab
->user
!= NULL
)
972 fprintf_filtered (outfile
, " Shared partial symtab with user ");
973 gdb_print_host_address (psymtab
->user
, outfile
);
974 fprintf_filtered (outfile
, "\n");
976 if (psymtab
->n_global_syms
> 0)
978 print_partial_symbols
980 &objfile
->partial_symtabs
->global_psymbols
[psymtab
->globals_offset
],
981 psymtab
->n_global_syms
, "Global", outfile
);
983 if (psymtab
->n_static_syms
> 0)
985 print_partial_symbols
987 &objfile
->partial_symtabs
->static_psymbols
[psymtab
->statics_offset
],
988 psymtab
->n_static_syms
, "Static", outfile
);
990 fprintf_filtered (outfile
, "\n");
993 /* Psymtab version of print_stats. See its definition in
994 the definition of quick_symbol_functions in symfile.h. */
997 psym_print_stats (struct objfile
*objfile
)
1002 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1007 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1010 /* Psymtab version of dump. See its definition in
1011 the definition of quick_symbol_functions in symfile.h. */
1014 psym_dump (struct objfile
*objfile
)
1016 struct partial_symtab
*psymtab
;
1018 if (objfile
->partial_symtabs
->psymtabs
)
1020 printf_filtered ("Psymtabs:\n");
1021 for (psymtab
= objfile
->partial_symtabs
->psymtabs
;
1023 psymtab
= psymtab
->next
)
1025 printf_filtered ("%s at ",
1027 gdb_print_host_address (psymtab
, gdb_stdout
);
1028 printf_filtered (", ");
1031 printf_filtered ("\n\n");
1035 /* Psymtab version of expand_symtabs_for_function. See its definition in
1036 the definition of quick_symbol_functions in symfile.h. */
1039 psym_expand_symtabs_for_function (struct objfile
*objfile
,
1040 const char *func_name
)
1042 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1047 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1049 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1051 psymtab_to_symtab (objfile
, ps
);
1055 /* Psymtab version of expand_all_symtabs. See its definition in
1056 the definition of quick_symbol_functions in symfile.h. */
1059 psym_expand_all_symtabs (struct objfile
*objfile
)
1061 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, true))
1062 psymtab_to_symtab (objfile
, psymtab
);
1065 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1066 the definition of quick_symbol_functions in symfile.h. */
1069 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1070 const char *fullname
)
1072 for (partial_symtab
*p
: require_partial_symbols (objfile
, true))
1074 /* Anonymous psymtabs don't have a name of a source file. */
1078 /* psymtab_to_fullname tries to open the file which is slow.
1079 Don't call it if we know the basenames don't match. */
1080 if ((basenames_may_differ
1081 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1082 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1083 psymtab_to_symtab (objfile
, p
);
1087 /* Psymtab version of map_symbol_filenames. See its definition in
1088 the definition of quick_symbol_functions in symfile.h. */
1091 psym_map_symbol_filenames (struct objfile
*objfile
,
1092 symbol_filename_ftype
*fun
, void *data
,
1095 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1097 const char *fullname
;
1102 /* We can skip shared psymtabs here, because any file name will be
1103 attached to the unshared psymtab. */
1104 if (ps
->user
!= NULL
)
1107 /* Anonymous psymtabs don't have a file name. */
1113 fullname
= psymtab_to_fullname (ps
);
1116 (*fun
) (ps
->filename
, fullname
, data
);
1120 /* Finds the fullname that a partial_symtab represents.
1122 If this functions finds the fullname, it will save it in ps->fullname
1123 and it will also return the value.
1125 If this function fails to find the file that this partial_symtab represents,
1126 NULL will be returned and ps->fullname will be set to NULL. */
1129 psymtab_to_fullname (struct partial_symtab
*ps
)
1131 gdb_assert (!ps
->anonymous
);
1133 /* Use cached copy if we have it.
1134 We rely on forget_cached_source_info being called appropriately
1135 to handle cases like the file being moved. */
1136 if (ps
->fullname
== NULL
)
1138 gdb::unique_xmalloc_ptr
<char> fullname
;
1139 scoped_fd fd
= find_and_open_source (ps
->filename
, ps
->dirname
,
1141 ps
->fullname
= fullname
.release ();
1145 /* rewrite_source_path would be applied by find_and_open_source, we
1146 should report the pathname where GDB tried to find the file. */
1148 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
1149 fullname
.reset (xstrdup (ps
->filename
));
1151 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
1152 ps
->filename
, (char *) NULL
));
1154 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1155 if (ps
->fullname
== NULL
)
1156 ps
->fullname
= fullname
.release ();
1160 return ps
->fullname
;
1163 /* Psymtab version of map_matching_symbols. See its definition in
1164 the definition of quick_symbol_functions in symfile.h. */
1167 psym_map_matching_symbols
1168 (struct objfile
*objfile
,
1169 const lookup_name_info
&name
, domain_enum domain
,
1171 gdb::function_view
<symbol_found_callback_ftype
> callback
,
1172 symbol_compare_ftype
*ordered_compare
)
1174 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1176 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1180 || match_partial_symbol (objfile
, ps
, global
, name
, domain
,
1183 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1184 const struct block
*block
;
1188 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1189 if (!iterate_over_symbols_terminated (block
, name
,
1196 /* A helper for psym_expand_symtabs_matching that handles searching
1197 included psymtabs. This returns true if a symbol is found, and
1198 false otherwise. It also updates the 'searched_flag' on the
1199 various psymtabs that it searches. */
1202 recursively_search_psymtabs
1203 (struct partial_symtab
*ps
,
1204 struct objfile
*objfile
,
1205 enum search_domain domain
,
1206 const lookup_name_info
&lookup_name
,
1207 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1210 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1213 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1214 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1216 /* Recurse into shared psymtabs first, because they may have already
1217 been searched, and this could save some time. */
1218 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1222 /* Skip non-shared dependencies, these are handled elsewhere. */
1223 if (ps
->dependencies
[i
]->user
== NULL
)
1226 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1227 objfile
, domain
, lookup_name
,
1231 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1236 partial_symbol
**gbound
1237 = (objfile
->partial_symtabs
->global_psymbols
.data ()
1238 + ps
->globals_offset
+ ps
->n_global_syms
);
1239 partial_symbol
**sbound
1240 = (objfile
->partial_symtabs
->static_psymbols
.data ()
1241 + ps
->statics_offset
+ ps
->n_static_syms
);
1242 partial_symbol
**bound
= gbound
;
1244 /* Go through all of the symbols stored in a partial
1245 symtab in one loop. */
1246 partial_symbol
**psym
= (objfile
->partial_symtabs
->global_psymbols
.data ()
1247 + ps
->globals_offset
);
1252 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1254 psym
= (objfile
->partial_symtabs
->static_psymbols
.data ()
1255 + ps
->statics_offset
);
1266 if ((domain
== ALL_DOMAIN
1267 || (domain
== MODULES_DOMAIN
1268 && (*psym
)->domain
== MODULE_DOMAIN
)
1269 || (domain
== VARIABLES_DOMAIN
1270 && (*psym
)->aclass
!= LOC_TYPEDEF
1271 && (*psym
)->aclass
!= LOC_BLOCK
)
1272 || (domain
== FUNCTIONS_DOMAIN
1273 && (*psym
)->aclass
== LOC_BLOCK
)
1274 || (domain
== TYPES_DOMAIN
1275 && (*psym
)->aclass
== LOC_TYPEDEF
))
1276 && psymbol_name_matches (*psym
, lookup_name
)
1277 && (sym_matcher
== NULL
1278 || sym_matcher ((*psym
)->ginfo
.search_name ())))
1280 /* Found a match, so notify our caller. */
1281 result
= PST_SEARCHED_AND_FOUND
;
1288 ps
->searched_flag
= result
;
1289 return result
== PST_SEARCHED_AND_FOUND
;
1292 /* Psymtab version of expand_symtabs_matching. See its definition in
1293 the definition of quick_symbol_functions in symfile.h. */
1296 psym_expand_symtabs_matching
1297 (struct objfile
*objfile
,
1298 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1299 const lookup_name_info
&lookup_name_in
,
1300 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1301 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1302 enum search_domain domain
)
1304 lookup_name_info lookup_name
= lookup_name_in
.make_ignore_params ();
1306 /* Clear the search flags. */
1307 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1308 ps
->searched_flag
= PST_NOT_SEARCHED
;
1310 for (partial_symtab
*ps
: objfile
->psymtabs ())
1317 /* We skip shared psymtabs because file-matching doesn't apply
1318 to them; but we search them later in the loop. */
1319 if (ps
->user
!= NULL
)
1329 match
= file_matcher (ps
->filename
, false);
1332 /* Before we invoke realpath, which can get expensive when many
1333 files are involved, do a quick comparison of the basenames. */
1334 if (basenames_may_differ
1335 || file_matcher (lbasename (ps
->filename
), true))
1336 match
= file_matcher (psymtab_to_fullname (ps
), false);
1342 if (recursively_search_psymtabs (ps
, objfile
, domain
,
1343 lookup_name
, symbol_matcher
))
1345 struct compunit_symtab
*symtab
=
1346 psymtab_to_symtab (objfile
, ps
);
1348 if (expansion_notify
!= NULL
)
1349 expansion_notify (symtab
);
1354 /* Psymtab version of has_symbols. See its definition in
1355 the definition of quick_symbol_functions in symfile.h. */
1358 psym_has_symbols (struct objfile
*objfile
)
1360 return objfile
->partial_symtabs
->psymtabs
!= NULL
;
1363 /* Helper function for psym_find_compunit_symtab_by_address that fills
1364 in psymbol_map for a given range of psymbols. */
1367 psym_fill_psymbol_map (struct objfile
*objfile
,
1368 struct partial_symtab
*psymtab
,
1369 std::set
<CORE_ADDR
> *seen_addrs
,
1370 const std::vector
<partial_symbol
*> &symbols
,
1374 for (int i
= 0; i
< length
; ++i
)
1376 struct partial_symbol
*psym
= symbols
[start
+ i
];
1378 if (psym
->aclass
== LOC_STATIC
)
1380 CORE_ADDR addr
= psym
->address (objfile
);
1381 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1383 seen_addrs
->insert (addr
);
1384 objfile
->psymbol_map
.emplace_back (addr
, psymtab
);
1390 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1393 static compunit_symtab
*
1394 psym_find_compunit_symtab_by_address (struct objfile
*objfile
,
1397 if (objfile
->psymbol_map
.empty ())
1399 std::set
<CORE_ADDR
> seen_addrs
;
1401 for (partial_symtab
*pst
: require_partial_symbols (objfile
, true))
1403 psym_fill_psymbol_map (objfile
, pst
,
1405 objfile
->partial_symtabs
->global_psymbols
,
1406 pst
->globals_offset
,
1407 pst
->n_global_syms
);
1408 psym_fill_psymbol_map (objfile
, pst
,
1410 objfile
->partial_symtabs
->static_psymbols
,
1411 pst
->statics_offset
,
1412 pst
->n_static_syms
);
1415 objfile
->psymbol_map
.shrink_to_fit ();
1417 std::sort (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (),
1418 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1419 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1421 return a
.first
< b
.first
;
1425 auto iter
= std::lower_bound
1426 (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (), address
,
1427 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1433 if (iter
== objfile
->psymbol_map
.end () || iter
->first
!= address
)
1436 return psymtab_to_symtab (objfile
, iter
->second
);
1439 const struct quick_symbol_functions psym_functions
=
1442 psym_find_last_source_symtab
,
1443 psym_forget_cached_source_info
,
1444 psym_map_symtabs_matching_filename
,
1448 psym_expand_symtabs_for_function
,
1449 psym_expand_all_symtabs
,
1450 psym_expand_symtabs_with_fullname
,
1451 psym_map_matching_symbols
,
1452 psym_expand_symtabs_matching
,
1453 psym_find_pc_sect_compunit_symtab
,
1454 psym_find_compunit_symtab_by_address
,
1455 psym_map_symbol_filenames
1461 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1463 /* Sort the global list; don't sort the static list. */
1464 auto begin
= objfile
->partial_symtabs
->global_psymbols
.begin ();
1465 std::advance (begin
, pst
->globals_offset
);
1467 /* The psymbols for this partial_symtab are currently at the end of the
1469 auto end
= objfile
->partial_symtabs
->global_psymbols
.end ();
1471 std::sort (begin
, end
, [] (partial_symbol
*s1
, partial_symbol
*s2
)
1473 return strcmp_iw_ordered (s1
->ginfo
.search_name (),
1474 s2
->ginfo
.search_name ()) < 0;
1478 /* Allocate and partially fill a partial symtab. It will be
1479 completely filled at the end of the symbol list.
1481 FILENAME is the name of the symbol-file we are reading from. */
1483 struct partial_symtab
*
1484 start_psymtab_common (struct objfile
*objfile
,
1485 const char *filename
,
1488 struct partial_symtab
*psymtab
;
1490 psymtab
= allocate_psymtab (filename
, objfile
);
1491 psymtab
->set_text_low (textlow
);
1492 psymtab
->set_text_high (psymtab
->raw_text_low ()); /* default */
1493 psymtab
->globals_offset
= objfile
->partial_symtabs
->global_psymbols
.size ();
1494 psymtab
->statics_offset
= objfile
->partial_symtabs
->static_psymbols
.size ();
1498 /* Perform "finishing up" operations of a partial symtab. */
1501 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1503 pst
->n_global_syms
= (objfile
->partial_symtabs
->global_psymbols
.size ()
1504 - pst
->globals_offset
);
1505 pst
->n_static_syms
= (objfile
->partial_symtabs
->static_psymbols
.size ()
1506 - pst
->statics_offset
);
1508 sort_pst_symbols (objfile
, pst
);
1511 /* Calculate a hash code for the given partial symbol. The hash is
1512 calculated using the symbol's value, language, domain, class
1513 and name. These are the values which are set by
1514 add_psymbol_to_bcache. */
1516 static unsigned long
1517 psymbol_hash (const void *addr
, int length
)
1519 unsigned long h
= 0;
1520 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1521 unsigned int lang
= psymbol
->ginfo
.language ();
1522 unsigned int domain
= psymbol
->domain
;
1523 unsigned int theclass
= psymbol
->aclass
;
1525 h
= fast_hash (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1526 h
= fast_hash (&lang
, sizeof (unsigned int), h
);
1527 h
= fast_hash (&domain
, sizeof (unsigned int), h
);
1528 h
= fast_hash (&theclass
, sizeof (unsigned int), h
);
1529 /* Note that psymbol names are interned via compute_and_set_names, so
1530 there's no need to hash the contents of the name here. */
1531 h
= fast_hash (&psymbol
->ginfo
.m_name
, sizeof (psymbol
->ginfo
.m_name
), h
);
1536 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1537 For the comparison this function uses a symbols value,
1538 language, domain, class and name. */
1541 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1543 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1544 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1546 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1547 sizeof (sym1
->ginfo
.value
)) == 0
1548 && sym1
->ginfo
.language () == sym2
->ginfo
.language ()
1549 && sym1
->domain
== sym2
->domain
1550 && sym1
->aclass
== sym2
->aclass
1551 /* Note that psymbol names are interned via
1552 compute_and_set_names, so there's no need to compare the
1553 contents of the name here. */
1554 && sym1
->ginfo
.linkage_name () == sym2
->ginfo
.linkage_name ());
1557 /* Helper function, initialises partial symbol structure and stashes
1558 it into objfile's bcache. Note that our caching mechanism will
1559 use all fields of struct partial_symbol to determine hash value of the
1560 structure. In other words, having two symbols with the same name but
1561 different domain (or address) is possible and correct. */
1563 static struct partial_symbol
*
1564 add_psymbol_to_bcache (gdb::string_view name
, bool copy_name
,
1566 enum address_class theclass
,
1569 enum language language
, struct objfile
*objfile
,
1572 struct partial_symbol psymbol
;
1573 memset (&psymbol
, 0, sizeof (psymbol
));
1575 psymbol
.set_unrelocated_address (coreaddr
);
1576 psymbol
.ginfo
.section
= section
;
1577 psymbol
.domain
= domain
;
1578 psymbol
.aclass
= theclass
;
1579 psymbol
.ginfo
.set_language (language
, objfile
->partial_symtabs
->obstack ());
1580 psymbol
.ginfo
.compute_and_set_names (name
, copy_name
, objfile
->per_bfd
);
1582 /* Stash the partial symbol away in the cache. */
1583 return ((struct partial_symbol
*)
1584 objfile
->partial_symtabs
->psymbol_cache
.insert
1585 (&psymbol
, sizeof (struct partial_symbol
), added
));
1588 /* Helper function, adds partial symbol to the given partial symbol list. */
1591 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1592 struct partial_symbol
*psym
,
1593 struct objfile
*objfile
)
1595 list
->push_back (psym
);
1596 OBJSTAT (objfile
, n_psyms
++);
1599 /* See psympriv.h. */
1602 add_psymbol_to_list (gdb::string_view name
, bool copy_name
,
1604 enum address_class theclass
,
1606 psymbol_placement where
,
1608 enum language language
, struct objfile
*objfile
)
1610 struct partial_symbol
*psym
;
1614 /* Stash the partial symbol away in the cache. */
1615 psym
= add_psymbol_to_bcache (name
, copy_name
, domain
, theclass
,
1616 section
, coreaddr
, language
, objfile
, &added
);
1618 /* Do not duplicate global partial symbols. */
1619 if (where
== psymbol_placement::GLOBAL
&& !added
)
1622 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1623 std::vector
<partial_symbol
*> *list
1624 = (where
== psymbol_placement::STATIC
1625 ? &objfile
->partial_symtabs
->static_psymbols
1626 : &objfile
->partial_symtabs
->global_psymbols
);
1627 append_psymbol_to_list (list
, psym
, objfile
);
1630 /* See psympriv.h. */
1633 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1635 if (objfile
->partial_symtabs
->global_psymbols
.capacity () == 0
1636 && objfile
->partial_symtabs
->static_psymbols
.capacity () == 0)
1638 /* Current best guess is that approximately a twentieth of the
1639 total symbols (in a debugging file) are global or static
1640 oriented symbols, then multiply that by slop factor of
1642 objfile
->partial_symtabs
->global_psymbols
.reserve (total_symbols
/ 10);
1643 objfile
->partial_symtabs
->static_psymbols
.reserve (total_symbols
/ 10);
1647 /* See psympriv.h. */
1649 struct partial_symtab
*
1650 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1652 struct partial_symtab
*psymtab
= new partial_symtab
;
1653 objfile
->partial_symtabs
->install_psymtab (psymtab
);
1656 = ((const char *) objfile
->per_bfd
->filename_cache
.insert
1657 (filename
, strlen (filename
) + 1));
1658 psymtab
->compunit_symtab
= NULL
;
1660 if (symtab_create_debug
)
1662 /* Be a bit clever with debugging messages, and don't print objfile
1663 every time, only when it changes. */
1664 static char *last_objfile_name
= NULL
;
1666 if (last_objfile_name
== NULL
1667 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1669 xfree (last_objfile_name
);
1670 last_objfile_name
= xstrdup (objfile_name (objfile
));
1671 fprintf_filtered (gdb_stdlog
,
1672 "Creating one or more psymtabs for objfile %s ...\n",
1675 fprintf_filtered (gdb_stdlog
,
1676 "Created psymtab %s for module %s.\n",
1677 host_address_to_string (psymtab
), filename
);
1684 psymtab_storage::discard_psymtab (struct partial_symtab
*pst
)
1686 struct partial_symtab
**prev_pst
;
1689 Empty psymtabs happen as a result of header files which don't
1690 have any symbols in them. There can be a lot of them. But this
1691 check is wrong, in that a psymtab with N_SLINE entries but
1692 nothing else is not empty, but we don't realize that. Fixing
1693 that without slowing things down might be tricky. */
1695 /* First, snip it out of the psymtab chain. */
1697 prev_pst
= &psymtabs
;
1698 while ((*prev_pst
) != pst
)
1699 prev_pst
= &((*prev_pst
)->next
);
1700 (*prev_pst
) = pst
->next
;
1706 /* We need to pass a couple of items to the addrmap_foreach function,
1709 struct dump_psymtab_addrmap_data
1711 struct objfile
*objfile
;
1712 struct partial_symtab
*psymtab
;
1713 struct ui_file
*outfile
;
1715 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1716 If so, we want to print the next one as well (since the next addrmap
1717 entry defines the end of the range). */
1718 int previous_matched
;
1721 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1724 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1726 struct dump_psymtab_addrmap_data
*data
1727 = (struct dump_psymtab_addrmap_data
*) datap
;
1728 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1729 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1730 const char *psymtab_address_or_end
= NULL
;
1734 if (data
->psymtab
== NULL
1735 || data
->psymtab
== addrmap_psymtab
)
1736 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1737 else if (data
->previous_matched
)
1738 psymtab_address_or_end
= "<ends here>";
1740 if (data
->psymtab
== NULL
1741 || data
->psymtab
== addrmap_psymtab
1742 || data
->previous_matched
)
1744 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1745 data
->psymtab
!= NULL
? " " : "",
1746 paddress (gdbarch
, start_addr
),
1747 psymtab_address_or_end
);
1750 data
->previous_matched
= (data
->psymtab
== NULL
1751 || data
->psymtab
== addrmap_psymtab
);
1756 /* Helper function for maintenance_print_psymbols to print the addrmap
1757 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1760 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1761 struct ui_file
*outfile
)
1763 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1765 if ((psymtab
== NULL
1766 || psymtab
->psymtabs_addrmap_supported
)
1767 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
1769 addrmap_dump_data
.objfile
= objfile
;
1770 addrmap_dump_data
.psymtab
= psymtab
;
1771 addrmap_dump_data
.outfile
= outfile
;
1772 addrmap_dump_data
.previous_matched
= 0;
1773 fprintf_filtered (outfile
, "%sddress map:\n",
1774 psymtab
== NULL
? "Entire a" : " A");
1775 addrmap_foreach (objfile
->partial_symtabs
->psymtabs_addrmap
,
1776 dump_psymtab_addrmap_1
, &addrmap_dump_data
);
1781 maintenance_print_psymbols (const char *args
, int from_tty
)
1783 struct ui_file
*outfile
= gdb_stdout
;
1784 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1785 int i
, outfile_idx
, found
;
1787 struct obj_section
*section
= NULL
;
1791 gdb_argv
argv (args
);
1793 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1795 if (strcmp (argv
[i
], "-pc") == 0)
1797 if (argv
[i
+ 1] == NULL
)
1798 error (_("Missing pc value"));
1799 address_arg
= argv
[++i
];
1801 else if (strcmp (argv
[i
], "-source") == 0)
1803 if (argv
[i
+ 1] == NULL
)
1804 error (_("Missing source file"));
1805 source_arg
= argv
[++i
];
1807 else if (strcmp (argv
[i
], "-objfile") == 0)
1809 if (argv
[i
+ 1] == NULL
)
1810 error (_("Missing objfile name"));
1811 objfile_arg
= argv
[++i
];
1813 else if (strcmp (argv
[i
], "--") == 0)
1815 /* End of options. */
1819 else if (argv
[i
][0] == '-')
1821 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1822 error (_("Unknown option: %s"), argv
[i
]);
1829 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1830 error (_("Must specify at most one of -pc and -source"));
1832 stdio_file arg_outfile
;
1834 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1836 if (argv
[outfile_idx
+ 1] != NULL
)
1837 error (_("Junk at end of command"));
1838 gdb::unique_xmalloc_ptr
<char> outfile_name
1839 (tilde_expand (argv
[outfile_idx
]));
1840 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1841 perror_with_name (outfile_name
.get ());
1842 outfile
= &arg_outfile
;
1845 if (address_arg
!= NULL
)
1847 pc
= parse_and_eval_address (address_arg
);
1848 /* If we fail to find a section, that's ok, try the lookup anyway. */
1849 section
= find_pc_section (pc
);
1853 for (objfile
*objfile
: current_program_space
->objfiles ())
1855 int printed_objfile_header
= 0;
1856 int print_for_objfile
= 1;
1859 if (objfile_arg
!= NULL
)
1861 = compare_filenames_for_search (objfile_name (objfile
),
1863 if (!print_for_objfile
)
1866 if (address_arg
!= NULL
)
1868 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1870 /* We don't assume each pc has a unique objfile (this is for
1872 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
,
1876 if (!printed_objfile_header
)
1878 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1879 objfile_name (objfile
));
1880 printed_objfile_header
= 1;
1882 dump_psymtab (objfile
, ps
, outfile
);
1883 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1889 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
1891 int print_for_source
= 0;
1894 if (source_arg
!= NULL
)
1897 = compare_filenames_for_search (ps
->filename
, source_arg
);
1900 if (source_arg
== NULL
1901 || print_for_source
)
1903 if (!printed_objfile_header
)
1905 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1906 objfile_name (objfile
));
1907 printed_objfile_header
= 1;
1909 dump_psymtab (objfile
, ps
, outfile
);
1910 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1915 /* If we're printing all the objfile's symbols dump the full addrmap. */
1917 if (address_arg
== NULL
1918 && source_arg
== NULL
1919 && objfile
->partial_symtabs
->psymtabs_addrmap
!= NULL
)
1921 outfile
->puts ("\n");
1922 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
1928 if (address_arg
!= NULL
)
1929 error (_("No partial symtab for address: %s"), address_arg
);
1930 if (source_arg
!= NULL
)
1931 error (_("No partial symtab for source file: %s"), source_arg
);
1935 /* List all the partial symbol tables whose names match REGEXP (optional). */
1938 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1940 struct program_space
*pspace
;
1945 ALL_PSPACES (pspace
)
1946 for (objfile
*objfile
: pspace
->objfiles ())
1948 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1950 /* We don't want to print anything for this objfile until we
1951 actually find a symtab whose name matches. */
1952 int printed_objfile_start
= 0;
1954 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, true))
1959 || re_exec (psymtab
->filename
))
1961 if (! printed_objfile_start
)
1963 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
1965 printf_filtered ("((struct objfile *) %s)\n",
1966 host_address_to_string (objfile
));
1967 printed_objfile_start
= 1;
1970 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1972 printf_filtered ("((struct partial_symtab *) %s)\n",
1973 host_address_to_string (psymtab
));
1975 printf_filtered (" readin %s\n",
1976 psymtab
->readin
? "yes" : "no");
1977 printf_filtered (" fullname %s\n",
1979 ? psymtab
->fullname
: "(null)");
1980 printf_filtered (" text addresses ");
1981 fputs_filtered (paddress (gdbarch
,
1982 psymtab
->text_low (objfile
)),
1984 printf_filtered (" -- ");
1985 fputs_filtered (paddress (gdbarch
,
1986 psymtab
->text_high (objfile
)),
1988 printf_filtered ("\n");
1989 printf_filtered (" psymtabs_addrmap_supported %s\n",
1990 (psymtab
->psymtabs_addrmap_supported
1992 printf_filtered (" globals ");
1993 if (psymtab
->n_global_syms
)
1995 auto p
= &(objfile
->partial_symtabs
1996 ->global_psymbols
[psymtab
->globals_offset
]);
1999 ("(* (struct partial_symbol **) %s @ %d)\n",
2000 host_address_to_string (p
),
2001 psymtab
->n_global_syms
);
2004 printf_filtered ("(none)\n");
2005 printf_filtered (" statics ");
2006 if (psymtab
->n_static_syms
)
2008 auto p
= &(objfile
->partial_symtabs
2009 ->static_psymbols
[psymtab
->statics_offset
]);
2012 ("(* (struct partial_symbol **) %s @ %d)\n",
2013 host_address_to_string (p
),
2014 psymtab
->n_static_syms
);
2017 printf_filtered ("(none)\n");
2018 printf_filtered (" dependencies ");
2019 if (psymtab
->number_of_dependencies
)
2023 printf_filtered ("{\n");
2024 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2026 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2028 /* Note the string concatenation there --- no
2030 printf_filtered (" psymtab %s "
2031 "((struct partial_symtab *) %s)\n",
2033 host_address_to_string (dep
));
2035 printf_filtered (" }\n");
2038 printf_filtered ("(none)\n");
2039 printf_filtered (" }\n");
2043 if (printed_objfile_start
)
2044 printf_filtered ("}\n");
2048 /* Check consistency of currently expanded psymtabs vs symtabs. */
2051 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2054 struct compunit_symtab
*cust
= NULL
;
2055 const struct blockvector
*bv
;
2056 const struct block
*b
;
2059 for (objfile
*objfile
: current_program_space
->objfiles ())
2060 for (partial_symtab
*ps
: require_partial_symbols (objfile
, true))
2062 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2064 /* We don't call psymtab_to_symtab here because that may cause symtab
2065 expansion. When debugging a problem it helps if checkers leave
2066 things unchanged. */
2067 cust
= ps
->compunit_symtab
;
2069 /* First do some checks that don't require the associated symtab. */
2070 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
2072 printf_filtered ("Psymtab ");
2073 puts_filtered (ps
->filename
);
2074 printf_filtered (" covers bad range ");
2075 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2077 printf_filtered (" - ");
2078 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2080 printf_filtered ("\n");
2084 /* Now do checks requiring the associated symtab. */
2087 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2088 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2089 partial_symbol
**psym
2090 = &objfile
->partial_symtabs
->static_psymbols
[ps
->statics_offset
];
2091 length
= ps
->n_static_syms
;
2094 sym
= block_lookup_symbol (b
, (*psym
)->ginfo
.search_name (),
2095 symbol_name_match_type::SEARCH_NAME
,
2099 printf_filtered ("Static symbol `");
2100 puts_filtered ((*psym
)->ginfo
.linkage_name ());
2101 printf_filtered ("' only found in ");
2102 puts_filtered (ps
->filename
);
2103 printf_filtered (" psymtab\n");
2107 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2108 psym
= &objfile
->partial_symtabs
->global_psymbols
[ps
->globals_offset
];
2109 length
= ps
->n_global_syms
;
2112 sym
= block_lookup_symbol (b
, (*psym
)->ginfo
.search_name (),
2113 symbol_name_match_type::SEARCH_NAME
,
2117 printf_filtered ("Global symbol `");
2118 puts_filtered ((*psym
)->ginfo
.linkage_name ());
2119 printf_filtered ("' only found in ");
2120 puts_filtered (ps
->filename
);
2121 printf_filtered (" psymtab\n");
2125 if (ps
->raw_text_high () != 0
2126 && (ps
->text_low (objfile
) < BLOCK_START (b
)
2127 || ps
->text_high (objfile
) > BLOCK_END (b
)))
2129 printf_filtered ("Psymtab ");
2130 puts_filtered (ps
->filename
);
2131 printf_filtered (" covers ");
2132 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2134 printf_filtered (" - ");
2135 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2137 printf_filtered (" but symtab covers only ");
2138 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2139 printf_filtered (" - ");
2140 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2141 printf_filtered ("\n");
2146 void _initialize_psymtab ();
2148 _initialize_psymtab ()
2150 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2151 Print dump of current partial symbol definitions.\n\
2152 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
2153 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
2154 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2155 or the terminal if OUTFILE is unspecified.\n\
2156 If ADDRESS is provided, dump only the file for that address.\n\
2157 If SOURCE is provided, dump only that file's symbols.\n\
2158 If OBJFILE is provided, dump only that file's minimal symbols."),
2159 &maintenanceprintlist
);
2161 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2162 List the partial symbol tables for all object files.\n\
2163 This does not include information about individual partial symbols,\n\
2164 just the symbol table structures themselves."),
2165 &maintenanceinfolist
);
2167 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2169 Check consistency of currently expanded psymtabs versus symtabs."),