1 /* Partial symbol tables.
3 Copyright (C) 2009-2017 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"
32 #include "readline/readline.h"
33 #include "gdb_regex.h"
34 #include "dictionary.h"
36 #include "cp-support.h"
42 struct bcache
*bcache
;
45 static struct partial_symbol
*match_partial_symbol (struct objfile
*,
46 struct partial_symtab
*,
48 const char *, domain_enum
,
49 symbol_name_match_type
,
50 symbol_compare_ftype
*);
52 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
53 struct partial_symtab
*,
57 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
59 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
60 struct partial_symtab
*,
62 struct obj_section
*);
64 static void fixup_psymbol_section (struct partial_symbol
*psym
,
65 struct objfile
*objfile
);
67 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
68 struct partial_symtab
*pst
);
70 /* Ensure that the partial symbols for OBJFILE have been loaded. This
71 function always returns its argument, as a convenience. */
74 require_partial_symbols (struct objfile
*objfile
, int verbose
)
76 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
78 objfile
->flags
|= OBJF_PSYMTABS_READ
;
80 if (objfile
->sf
->sym_read_psymbols
)
84 printf_unfiltered (_("Reading symbols from %s..."),
85 objfile_name (objfile
));
86 gdb_flush (gdb_stdout
);
88 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
90 /* Partial symbols list are not expected to changed after this
92 objfile
->global_psymbols
.shrink_to_fit ();
93 objfile
->static_psymbols
.shrink_to_fit ();
97 if (!objfile_has_symbols (objfile
))
100 printf_unfiltered (_("(no debugging symbols found)..."));
104 printf_unfiltered (_("done.\n"));
112 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
115 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
116 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
120 /* We want to make sure this file always requires psymtabs. */
122 #undef ALL_OBJFILE_PSYMTABS
124 /* Traverse all psymtabs in all objfiles. */
126 #define ALL_PSYMTABS(objfile, p) \
127 ALL_OBJFILES (objfile) \
128 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
130 /* Helper function for psym_map_symtabs_matching_filename that
131 expands the symtabs and calls the iterator. */
134 partial_map_expand_apply (struct objfile
*objfile
,
136 const char *real_path
,
137 struct partial_symtab
*pst
,
138 gdb::function_view
<bool (symtab
*)> callback
)
140 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
142 /* Shared psymtabs should never be seen here. Instead they should
143 be handled properly by the caller. */
144 gdb_assert (pst
->user
== NULL
);
146 /* Don't visit already-expanded psymtabs. */
150 /* This may expand more than one symtab, and we want to iterate over
152 psymtab_to_symtab (objfile
, pst
);
154 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
155 last_made
, callback
);
158 /* Psymtab version of map_symtabs_matching_filename. See its definition in
159 the definition of quick_symbol_functions in symfile.h. */
162 psym_map_symtabs_matching_filename
163 (struct objfile
*objfile
,
165 const char *real_path
,
166 gdb::function_view
<bool (symtab
*)> callback
)
168 struct partial_symtab
*pst
;
169 const char *name_basename
= lbasename (name
);
171 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
173 /* We can skip shared psymtabs here, because any file name will be
174 attached to the unshared psymtab. */
175 if (pst
->user
!= NULL
)
178 /* Anonymous psymtabs don't have a file name. */
182 if (compare_filenames_for_search (pst
->filename
, name
))
184 if (partial_map_expand_apply (objfile
, name
, real_path
,
190 /* Before we invoke realpath, which can get expensive when many
191 files are involved, do a quick comparison of the basenames. */
192 if (! basenames_may_differ
193 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
196 if (compare_filenames_for_search (psymtab_to_fullname (pst
), name
))
198 if (partial_map_expand_apply (objfile
, name
, real_path
,
204 /* If the user gave us an absolute path, try to find the file in
205 this symtab and use its absolute path. */
206 if (real_path
!= NULL
)
208 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
209 gdb_assert (IS_ABSOLUTE_PATH (name
));
210 if (filename_cmp (psymtab_to_fullname (pst
), real_path
) == 0)
212 if (partial_map_expand_apply (objfile
, name
, real_path
,
223 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
224 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
226 static struct partial_symtab
*
227 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
228 CORE_ADDR pc
, struct obj_section
*section
,
229 struct partial_symtab
*pst
,
230 struct bound_minimal_symbol msymbol
)
232 struct partial_symtab
*tpst
;
233 struct partial_symtab
*best_pst
= pst
;
234 CORE_ADDR best_addr
= pst
->textlow
;
236 gdb_assert (!pst
->psymtabs_addrmap_supported
);
238 /* An objfile that has its functions reordered might have
239 many partial symbol tables containing the PC, but
240 we want the partial symbol table that contains the
241 function containing the PC. */
242 if (!(objfile
->flags
& OBJF_REORDERED
)
243 && section
== NULL
) /* Can't validate section this way. */
246 if (msymbol
.minsym
== NULL
)
249 /* The code range of partial symtabs sometimes overlap, so, in
250 the loop below, we need to check all partial symtabs and
251 find the one that fits better for the given PC address. We
252 select the partial symtab that contains a symbol whose
253 address is closest to the PC address. By closest we mean
254 that find_pc_sect_symbol returns the symbol with address
255 that is closest and still less than the given PC. */
256 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
258 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
260 struct partial_symbol
*p
;
263 /* NOTE: This assumes that every psymbol has a
264 corresponding msymbol, which is not necessarily
265 true; the debug info might be much richer than the
266 object's symbol table. */
267 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
269 && (SYMBOL_VALUE_ADDRESS (p
)
270 == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
273 /* Also accept the textlow value of a psymtab as a
274 "symbol", to provide some support for partial
275 symbol tables with line information but no debug
276 symbols (e.g. those produced by an assembler). */
278 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
280 this_addr
= tpst
->textlow
;
282 /* Check whether it is closer than our current
283 BEST_ADDR. Since this symbol address is
284 necessarily lower or equal to PC, the symbol closer
285 to PC is the symbol which address is the highest.
286 This way we return the psymtab which contains such
287 best match symbol. This can help in cases where the
288 symbol information/debuginfo is not complete, like
289 for instance on IRIX6 with gcc, where no debug info
290 is emitted for statics. (See also the nodebug.exp
292 if (this_addr
> best_addr
)
294 best_addr
= this_addr
;
302 /* Find which partial symtab contains PC and SECTION. Return NULL if
303 none. We return the psymtab that contains a symbol whose address
304 exactly matches PC, or, if we cannot find an exact match, the
305 psymtab that contains a symbol whose address is closest to PC. */
307 static struct partial_symtab
*
308 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
309 struct obj_section
*section
,
310 struct bound_minimal_symbol msymbol
)
312 struct partial_symtab
*pst
;
314 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
315 than the later used TEXTLOW/TEXTHIGH one. */
317 if (objfile
->psymtabs_addrmap
!= NULL
)
319 pst
= ((struct partial_symtab
*)
320 addrmap_find (objfile
->psymtabs_addrmap
, pc
));
323 /* FIXME: addrmaps currently do not handle overlayed sections,
324 so fall back to the non-addrmap case if we're debugging
325 overlays and the addrmap returned the wrong section. */
326 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
328 struct partial_symbol
*p
;
330 /* NOTE: This assumes that every psymbol has a
331 corresponding msymbol, which is not necessarily
332 true; the debug info might be much richer than the
333 object's symbol table. */
334 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
336 || (SYMBOL_VALUE_ADDRESS (p
)
337 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
341 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
342 PSYMTABS_ADDRMAP we used has already the best 1-byte
343 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
344 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
353 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
354 which still have no corresponding full SYMTABs read. But it is not
355 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
358 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
359 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
360 debug info type in single OBJFILE. */
362 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
363 if (!pst
->psymtabs_addrmap_supported
364 && pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
366 struct partial_symtab
*best_pst
;
368 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
370 if (best_pst
!= NULL
)
377 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
378 the definition of quick_symbol_functions in symfile.h. */
380 static struct compunit_symtab
*
381 psym_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
382 struct bound_minimal_symbol msymbol
,
384 struct obj_section
*section
,
387 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
391 if (warn_if_readin
&& ps
->readin
)
392 /* Might want to error() here (in case symtab is corrupt and
393 will cause a core dump), but maybe we can successfully
394 continue, so let's not. */
396 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
397 paddress (get_objfile_arch (objfile
), pc
));
398 psymtab_to_symtab (objfile
, ps
);
399 return ps
->compunit_symtab
;
404 /* Find which partial symbol within a psymtab matches PC and SECTION.
405 Return NULL if none. */
407 static struct partial_symbol
*
408 find_pc_sect_psymbol (struct objfile
*objfile
,
409 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
410 struct obj_section
*section
)
412 struct partial_symbol
*best
= NULL
;
415 gdb_assert (psymtab
!= NULL
);
417 /* Cope with programs that start at address 0. */
418 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
420 /* Search the global symbols as well as the static symbols, so that
421 find_pc_partial_function doesn't use a minimal symbol and thus
422 cache a bad endaddr. */
423 for (int i
= 0; i
< psymtab
->n_global_syms
; i
++)
425 partial_symbol
*p
= objfile
->global_psymbols
[psymtab
->globals_offset
+ i
];
427 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
428 && PSYMBOL_CLASS (p
) == LOC_BLOCK
429 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
430 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
431 || (psymtab
->textlow
== 0
432 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
434 if (section
!= NULL
) /* Match on a specific section. */
436 fixup_psymbol_section (p
, objfile
);
437 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, p
),
441 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
446 for (int i
= 0; i
< psymtab
->n_static_syms
; i
++)
448 partial_symbol
*p
= objfile
->static_psymbols
[psymtab
->statics_offset
+ i
];
450 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
451 && PSYMBOL_CLASS (p
) == LOC_BLOCK
452 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
453 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
454 || (psymtab
->textlow
== 0
455 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
457 if (section
!= NULL
) /* Match on a specific section. */
459 fixup_psymbol_section (p
, objfile
);
460 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, p
),
464 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
473 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
480 if (SYMBOL_SECTION (psym
) >= 0)
483 gdb_assert (objfile
);
485 switch (PSYMBOL_CLASS (psym
))
490 addr
= SYMBOL_VALUE_ADDRESS (psym
);
493 /* Nothing else will be listed in the minsyms -- no use looking
498 fixup_section (&psym
->ginfo
, addr
, objfile
);
501 /* Psymtab version of lookup_symbol. See its definition in
502 the definition of quick_symbol_functions in symfile.h. */
504 static struct compunit_symtab
*
505 psym_lookup_symbol (struct objfile
*objfile
,
506 int block_index
, const char *name
,
507 const domain_enum domain
)
509 struct partial_symtab
*ps
;
510 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
511 struct compunit_symtab
*stab_best
= NULL
;
513 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
515 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
517 if (!ps
->readin
&& lookup_partial_symbol (objfile
, ps
, name
,
518 psymtab_index
, domain
))
520 struct symbol
*sym
, *with_opaque
= NULL
;
521 struct compunit_symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
522 /* Note: While psymtab_to_symtab can return NULL if the partial symtab
523 is empty, we can assume it won't here because lookup_partial_symbol
525 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
526 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
528 sym
= block_find_symbol (block
, name
, domain
,
529 block_find_non_opaque_type_preferred
,
532 /* Some caution must be observed with overloaded functions
533 and methods, since the index will not contain any overload
534 information (but NAME might contain it). */
537 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
539 if (with_opaque
!= NULL
540 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
543 /* Keep looking through other psymtabs. */
550 /* Returns true if PSYM matches LOOKUP_NAME. */
553 psymbol_name_matches (partial_symbol
*psym
,
554 const lookup_name_info
&lookup_name
)
556 const language_defn
*lang
= language_def (SYMBOL_LANGUAGE (psym
));
557 symbol_name_matcher_ftype
*name_match
558 = language_get_symbol_name_matcher (lang
, lookup_name
);
559 return name_match (SYMBOL_SEARCH_NAME (psym
), lookup_name
, NULL
);
562 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
563 the global block of PST if GLOBAL, and otherwise the static block.
564 MATCH is the comparison operation that returns true iff MATCH (s,
565 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
566 non-null, the symbols in the block are assumed to be ordered
567 according to it (allowing binary search). It must be compatible
568 with MATCH. Returns the symbol, if found, and otherwise NULL. */
570 static struct partial_symbol
*
571 match_partial_symbol (struct objfile
*objfile
,
572 struct partial_symtab
*pst
, int global
,
573 const char *name
, domain_enum domain
,
574 symbol_name_match_type match_type
,
575 symbol_compare_ftype
*ordered_compare
)
577 struct partial_symbol
**start
, **psym
;
578 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
579 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
580 int do_linear_search
= 1;
585 lookup_name_info
lookup_name (name
, match_type
);
588 &objfile
->global_psymbols
[pst
->globals_offset
] :
589 &objfile
->static_psymbols
[pst
->statics_offset
]);
591 if (global
&& ordered_compare
) /* Can use a binary search. */
593 do_linear_search
= 0;
595 /* Binary search. This search is guaranteed to end with center
596 pointing at the earliest partial symbol whose name might be
597 correct. At that point *all* partial symbols with an
598 appropriate name will be checked against the correct
602 top
= start
+ length
- 1;
606 center
= bottom
+ (top
- bottom
) / 2;
607 gdb_assert (center
< top
);
609 enum language lang
= SYMBOL_LANGUAGE (*center
);
611 = lookup_name
.language_lookup_name (lang
).c_str ();
613 if (ordered_compare (SYMBOL_SEARCH_NAME (*center
), lang_ln
) >= 0)
618 gdb_assert (top
== bottom
);
620 while (top
<= real_top
621 && psymbol_name_matches (*top
, lookup_name
))
623 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
624 SYMBOL_DOMAIN (*top
), domain
))
630 /* Can't use a binary search or else we found during the binary search that
631 we should also do a linear search. */
633 if (do_linear_search
)
635 for (psym
= start
; psym
< start
+ length
; psym
++)
637 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
638 SYMBOL_DOMAIN (*psym
), domain
)
639 && psymbol_name_matches (*psym
, lookup_name
))
647 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
648 not contain any method/function instance information (since this would
649 force reading type information while reading psymtabs). Therefore,
650 if NAME contains overload information, it must be stripped before searching
653 static gdb::unique_xmalloc_ptr
<char>
654 psymtab_search_name (const char *name
)
656 switch (current_language
->la_language
)
660 if (strchr (name
, '('))
662 gdb::unique_xmalloc_ptr
<char> ret
= cp_remove_params (name
);
674 return gdb::unique_xmalloc_ptr
<char> (xstrdup (name
));
677 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
678 Check the global symbols if GLOBAL, the static symbols if not. */
680 static struct partial_symbol
*
681 lookup_partial_symbol (struct objfile
*objfile
,
682 struct partial_symtab
*pst
, const char *name
,
683 int global
, domain_enum domain
)
685 struct partial_symbol
**start
, **psym
;
686 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
687 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
688 int do_linear_search
= 1;
693 gdb::unique_xmalloc_ptr
<char> search_name
= psymtab_search_name (name
);
695 lookup_name_info
lookup_name (search_name
.get (), symbol_name_match_type::FULL
);
698 &objfile
->global_psymbols
[pst
->globals_offset
] :
699 &objfile
->static_psymbols
[pst
->statics_offset
]);
701 if (global
) /* This means we can use a binary search. */
703 do_linear_search
= 0;
705 /* Binary search. This search is guaranteed to end with center
706 pointing at the earliest partial symbol whose name might be
707 correct. At that point *all* partial symbols with an
708 appropriate name will be checked against the correct
712 top
= start
+ length
- 1;
716 center
= bottom
+ (top
- bottom
) / 2;
718 internal_error (__FILE__
, __LINE__
,
719 _("failed internal consistency check"));
720 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
),
721 search_name
.get ()) >= 0)
730 if (!(top
== bottom
))
731 internal_error (__FILE__
, __LINE__
,
732 _("failed internal consistency check"));
734 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
735 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
736 while (top
>= start
&& SYMBOL_MATCHES_SEARCH_NAME (*top
, lookup_name
))
739 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
742 while (top
<= real_top
&& SYMBOL_MATCHES_SEARCH_NAME (*top
, lookup_name
))
744 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
745 SYMBOL_DOMAIN (*top
), domain
))
751 /* Can't use a binary search or else we found during the binary search that
752 we should also do a linear search. */
754 if (do_linear_search
)
756 for (psym
= start
; psym
< start
+ length
; psym
++)
758 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
759 SYMBOL_DOMAIN (*psym
), domain
)
760 && SYMBOL_MATCHES_SEARCH_NAME (*psym
, lookup_name
))
768 /* Get the symbol table that corresponds to a partial_symtab.
769 This is fast after the first time you do it.
770 The result will be NULL if the primary symtab has no symbols,
771 which can happen. Otherwise the result is the primary symtab
772 that contains PST. */
774 static struct compunit_symtab
*
775 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
777 /* If it is a shared psymtab, find an unshared psymtab that includes
778 it. Any such psymtab will do. */
779 while (pst
->user
!= NULL
)
782 /* If it's been looked up before, return it. */
783 if (pst
->compunit_symtab
)
784 return pst
->compunit_symtab
;
786 /* If it has not yet been read in, read it. */
789 scoped_restore decrementer
= increment_reading_symtab ();
791 (*pst
->read_symtab
) (pst
, objfile
);
794 return pst
->compunit_symtab
;
797 /* Psymtab version of relocate. See its definition in
798 the definition of quick_symbol_functions in symfile.h. */
801 psym_relocate (struct objfile
*objfile
,
802 const struct section_offsets
*new_offsets
,
803 const struct section_offsets
*delta
)
805 struct partial_symbol
**psym
;
806 struct partial_symtab
*p
;
808 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
810 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
811 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
814 for (partial_symbol
*psym
: objfile
->global_psymbols
)
816 fixup_psymbol_section (psym
, objfile
);
817 if (SYMBOL_SECTION (psym
) >= 0)
818 SYMBOL_VALUE_ADDRESS (psym
) += ANOFFSET (delta
, SYMBOL_SECTION (psym
));
820 for (partial_symbol
*psym
: objfile
->static_psymbols
)
822 fixup_psymbol_section (psym
, objfile
);
823 if (SYMBOL_SECTION (psym
) >= 0)
824 SYMBOL_VALUE_ADDRESS (psym
) += ANOFFSET (delta
, SYMBOL_SECTION (psym
));
828 /* Psymtab version of find_last_source_symtab. See its definition in
829 the definition of quick_symbol_functions in symfile.h. */
831 static struct symtab
*
832 psym_find_last_source_symtab (struct objfile
*ofp
)
834 struct partial_symtab
*ps
;
835 struct partial_symtab
*cs_pst
= NULL
;
837 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp
, ps
)
839 const char *name
= ps
->filename
;
840 int len
= strlen (name
);
842 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
843 || strcmp (name
, "<<C++-namespaces>>") == 0)))
851 internal_error (__FILE__
, __LINE__
,
852 _("select_source_symtab: "
853 "readin pst found and no symtabs."));
857 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
861 return compunit_primary_filetab (cust
);
867 /* Psymtab version of forget_cached_source_info. See its definition in
868 the definition of quick_symbol_functions in symfile.h. */
871 psym_forget_cached_source_info (struct objfile
*objfile
)
873 struct partial_symtab
*pst
;
875 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
877 if (pst
->fullname
!= NULL
)
879 xfree (pst
->fullname
);
880 pst
->fullname
= NULL
;
886 print_partial_symbols (struct gdbarch
*gdbarch
,
887 struct partial_symbol
**p
, int count
, const char *what
,
888 struct ui_file
*outfile
)
890 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
894 fprintf_filtered (outfile
, " `%s'", SYMBOL_LINKAGE_NAME (*p
));
895 if (SYMBOL_DEMANGLED_NAME (*p
) != NULL
)
897 fprintf_filtered (outfile
, " `%s'", SYMBOL_DEMANGLED_NAME (*p
));
899 fputs_filtered (", ", outfile
);
900 switch (SYMBOL_DOMAIN (*p
))
903 fputs_filtered ("undefined domain, ", outfile
);
906 /* This is the usual thing -- don't print it. */
909 fputs_filtered ("struct domain, ", outfile
);
912 fputs_filtered ("label domain, ", outfile
);
915 fputs_filtered ("<invalid domain>, ", outfile
);
918 switch (PSYMBOL_CLASS (*p
))
921 fputs_filtered ("undefined", outfile
);
924 fputs_filtered ("constant int", outfile
);
927 fputs_filtered ("static", outfile
);
930 fputs_filtered ("register", outfile
);
933 fputs_filtered ("pass by value", outfile
);
936 fputs_filtered ("pass by reference", outfile
);
938 case LOC_REGPARM_ADDR
:
939 fputs_filtered ("register address parameter", outfile
);
942 fputs_filtered ("stack parameter", outfile
);
945 fputs_filtered ("type", outfile
);
948 fputs_filtered ("label", outfile
);
951 fputs_filtered ("function", outfile
);
953 case LOC_CONST_BYTES
:
954 fputs_filtered ("constant bytes", outfile
);
957 fputs_filtered ("unresolved", outfile
);
959 case LOC_OPTIMIZED_OUT
:
960 fputs_filtered ("optimized out", outfile
);
963 fputs_filtered ("computed at runtime", outfile
);
966 fputs_filtered ("<invalid location>", outfile
);
969 fputs_filtered (", ", outfile
);
970 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (*p
)), outfile
);
971 fprintf_filtered (outfile
, "\n");
977 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
978 struct ui_file
*outfile
)
980 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
983 if (psymtab
->anonymous
)
985 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
990 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
993 fprintf_filtered (outfile
, "(object ");
994 gdb_print_host_address (psymtab
, outfile
);
995 fprintf_filtered (outfile
, ")\n\n");
996 fprintf_unfiltered (outfile
, " Read from object file %s (",
997 objfile_name (objfile
));
998 gdb_print_host_address (objfile
, outfile
);
999 fprintf_unfiltered (outfile
, ")\n");
1001 if (psymtab
->readin
)
1003 fprintf_filtered (outfile
,
1004 " Full symtab was read (at ");
1005 gdb_print_host_address (psymtab
->compunit_symtab
, outfile
);
1006 fprintf_filtered (outfile
, " by function at ");
1007 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
1008 fprintf_filtered (outfile
, ")\n");
1011 fprintf_filtered (outfile
, " Symbols cover text addresses ");
1012 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
), outfile
);
1013 fprintf_filtered (outfile
, "-");
1014 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
), outfile
);
1015 fprintf_filtered (outfile
, "\n");
1016 fprintf_filtered (outfile
, " Address map supported - %s.\n",
1017 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
1018 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
1019 psymtab
->number_of_dependencies
);
1020 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1022 fprintf_filtered (outfile
, " %d ", i
);
1023 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
1024 fprintf_filtered (outfile
, " %s\n",
1025 psymtab
->dependencies
[i
]->filename
);
1027 if (psymtab
->user
!= NULL
)
1029 fprintf_filtered (outfile
, " Shared partial symtab with user ");
1030 gdb_print_host_address (psymtab
->user
, outfile
);
1031 fprintf_filtered (outfile
, "\n");
1033 if (psymtab
->n_global_syms
> 0)
1035 print_partial_symbols (gdbarch
,
1036 &objfile
->global_psymbols
[psymtab
->globals_offset
],
1037 psymtab
->n_global_syms
, "Global", outfile
);
1039 if (psymtab
->n_static_syms
> 0)
1041 print_partial_symbols (gdbarch
,
1042 &objfile
->static_psymbols
[psymtab
->statics_offset
],
1043 psymtab
->n_static_syms
, "Static", outfile
);
1045 fprintf_filtered (outfile
, "\n");
1048 /* Psymtab version of print_stats. See its definition in
1049 the definition of quick_symbol_functions in symfile.h. */
1052 psym_print_stats (struct objfile
*objfile
)
1055 struct partial_symtab
*ps
;
1058 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1060 if (ps
->readin
== 0)
1063 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1066 /* Psymtab version of dump. See its definition in
1067 the definition of quick_symbol_functions in symfile.h. */
1070 psym_dump (struct objfile
*objfile
)
1072 struct partial_symtab
*psymtab
;
1074 if (objfile
->psymtabs
)
1076 printf_filtered ("Psymtabs:\n");
1077 for (psymtab
= objfile
->psymtabs
;
1079 psymtab
= psymtab
->next
)
1081 printf_filtered ("%s at ",
1083 gdb_print_host_address (psymtab
, gdb_stdout
);
1084 printf_filtered (", ");
1087 printf_filtered ("\n\n");
1091 /* Psymtab version of expand_symtabs_for_function. See its definition in
1092 the definition of quick_symbol_functions in symfile.h. */
1095 psym_expand_symtabs_for_function (struct objfile
*objfile
,
1096 const char *func_name
)
1098 struct partial_symtab
*ps
;
1100 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1105 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1107 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1109 psymtab_to_symtab (objfile
, ps
);
1113 /* Psymtab version of expand_all_symtabs. See its definition in
1114 the definition of quick_symbol_functions in symfile.h. */
1117 psym_expand_all_symtabs (struct objfile
*objfile
)
1119 struct partial_symtab
*psymtab
;
1121 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
1123 psymtab_to_symtab (objfile
, psymtab
);
1127 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1128 the definition of quick_symbol_functions in symfile.h. */
1131 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1132 const char *fullname
)
1134 struct partial_symtab
*p
;
1136 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
1138 /* Anonymous psymtabs don't have a name of a source file. */
1142 /* psymtab_to_fullname tries to open the file which is slow.
1143 Don't call it if we know the basenames don't match. */
1144 if ((basenames_may_differ
1145 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1146 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1147 psymtab_to_symtab (objfile
, p
);
1151 /* Psymtab version of map_symbol_filenames. See its definition in
1152 the definition of quick_symbol_functions in symfile.h. */
1155 psym_map_symbol_filenames (struct objfile
*objfile
,
1156 symbol_filename_ftype
*fun
, void *data
,
1159 struct partial_symtab
*ps
;
1161 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1163 const char *fullname
;
1168 /* We can skip shared psymtabs here, because any file name will be
1169 attached to the unshared psymtab. */
1170 if (ps
->user
!= NULL
)
1173 /* Anonymous psymtabs don't have a file name. */
1179 fullname
= psymtab_to_fullname (ps
);
1182 (*fun
) (ps
->filename
, fullname
, data
);
1186 /* Finds the fullname that a partial_symtab represents.
1188 If this functions finds the fullname, it will save it in ps->fullname
1189 and it will also return the value.
1191 If this function fails to find the file that this partial_symtab represents,
1192 NULL will be returned and ps->fullname will be set to NULL. */
1195 psymtab_to_fullname (struct partial_symtab
*ps
)
1197 gdb_assert (!ps
->anonymous
);
1199 /* Use cached copy if we have it.
1200 We rely on forget_cached_source_info being called appropriately
1201 to handle cases like the file being moved. */
1202 if (ps
->fullname
== NULL
)
1204 int fd
= find_and_open_source (ps
->filename
, ps
->dirname
, &ps
->fullname
);
1210 gdb::unique_xmalloc_ptr
<char> fullname
;
1212 /* rewrite_source_path would be applied by find_and_open_source, we
1213 should report the pathname where GDB tried to find the file. */
1215 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
1216 fullname
.reset (xstrdup (ps
->filename
));
1218 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
1219 ps
->filename
, (char *) NULL
));
1221 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1222 if (ps
->fullname
== NULL
)
1223 ps
->fullname
= fullname
.release ();
1227 return ps
->fullname
;
1230 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1231 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1232 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1233 ever returns non-zero, and otherwise returns 0. */
1236 map_block (const char *name
, domain_enum domain
, struct objfile
*objfile
,
1237 struct block
*block
,
1238 int (*callback
) (struct block
*, struct symbol
*, void *),
1239 void *data
, symbol_name_match_type match
)
1241 struct block_iterator iter
;
1244 lookup_name_info
lookup_name (name
, match
);
1246 for (sym
= block_iter_match_first (block
, lookup_name
, &iter
);
1248 sym
= block_iter_match_next (lookup_name
, &iter
))
1250 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1251 SYMBOL_DOMAIN (sym
), domain
))
1253 if (callback (block
, sym
, data
))
1261 /* Psymtab version of map_matching_symbols. See its definition in
1262 the definition of quick_symbol_functions in symfile.h. */
1265 psym_map_matching_symbols (struct objfile
*objfile
,
1266 const char *name
, domain_enum domain
,
1268 int (*callback
) (struct block
*,
1269 struct symbol
*, void *),
1271 symbol_name_match_type match
,
1272 symbol_compare_ftype
*ordered_compare
)
1274 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1275 struct partial_symtab
*ps
;
1277 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1281 || match_partial_symbol (objfile
, ps
, global
, name
, domain
, match
,
1284 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1285 struct block
*block
;
1289 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1290 if (map_block (name
, domain
, objfile
, block
,
1291 callback
, data
, match
))
1293 if (callback (block
, NULL
, data
))
1299 /* A helper for psym_expand_symtabs_matching that handles searching
1300 included psymtabs. This returns true if a symbol is found, and
1301 false otherwise. It also updates the 'searched_flag' on the
1302 various psymtabs that it searches. */
1305 recursively_search_psymtabs
1306 (struct partial_symtab
*ps
, struct objfile
*objfile
, enum search_domain domain
,
1307 const lookup_name_info
&lookup_name
,
1308 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1311 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1314 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1315 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1317 /* Recurse into shared psymtabs first, because they may have already
1318 been searched, and this could save some time. */
1319 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1323 /* Skip non-shared dependencies, these are handled elsewhere. */
1324 if (ps
->dependencies
[i
]->user
== NULL
)
1327 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1328 objfile
, domain
, lookup_name
,
1332 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1337 partial_symbol
**gbound
1338 = &objfile
->global_psymbols
[ps
->globals_offset
+ ps
->n_global_syms
];
1339 partial_symbol
**sbound
1340 = &objfile
->static_psymbols
[ps
->statics_offset
+ ps
->n_static_syms
];
1341 partial_symbol
**bound
= gbound
;
1343 /* Go through all of the symbols stored in a partial
1344 symtab in one loop. */
1345 partial_symbol
**psym
= &objfile
->global_psymbols
[ps
->globals_offset
];
1350 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1352 psym
= &objfile
->static_psymbols
[ps
->statics_offset
];
1363 if ((domain
== ALL_DOMAIN
1364 || (domain
== VARIABLES_DOMAIN
1365 && PSYMBOL_CLASS (*psym
) != LOC_TYPEDEF
1366 && PSYMBOL_CLASS (*psym
) != LOC_BLOCK
)
1367 || (domain
== FUNCTIONS_DOMAIN
1368 && PSYMBOL_CLASS (*psym
) == LOC_BLOCK
)
1369 || (domain
== TYPES_DOMAIN
1370 && PSYMBOL_CLASS (*psym
) == LOC_TYPEDEF
))
1371 && psymbol_name_matches (*psym
, lookup_name
)
1372 && (sym_matcher
== NULL
|| sym_matcher (SYMBOL_SEARCH_NAME (*psym
))))
1374 /* Found a match, so notify our caller. */
1375 result
= PST_SEARCHED_AND_FOUND
;
1382 ps
->searched_flag
= result
;
1383 return result
== PST_SEARCHED_AND_FOUND
;
1386 /* Psymtab version of expand_symtabs_matching. See its definition in
1387 the definition of quick_symbol_functions in symfile.h. */
1390 psym_expand_symtabs_matching
1391 (struct objfile
*objfile
,
1392 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1393 const lookup_name_info
&lookup_name_in
,
1394 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1395 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1396 enum search_domain domain
)
1398 struct partial_symtab
*ps
;
1400 lookup_name_info lookup_name
= lookup_name_in
.make_ignore_params ();
1402 /* Clear the search flags. */
1403 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1405 ps
->searched_flag
= PST_NOT_SEARCHED
;
1408 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1415 /* We skip shared psymtabs because file-matching doesn't apply
1416 to them; but we search them later in the loop. */
1417 if (ps
->user
!= NULL
)
1427 match
= file_matcher (ps
->filename
, false);
1430 /* Before we invoke realpath, which can get expensive when many
1431 files are involved, do a quick comparison of the basenames. */
1432 if (basenames_may_differ
1433 || file_matcher (lbasename (ps
->filename
), true))
1434 match
= file_matcher (psymtab_to_fullname (ps
), false);
1440 if (recursively_search_psymtabs (ps
, objfile
, domain
,
1441 lookup_name
, symbol_matcher
))
1443 struct compunit_symtab
*symtab
=
1444 psymtab_to_symtab (objfile
, ps
);
1446 if (expansion_notify
!= NULL
)
1447 expansion_notify (symtab
);
1452 /* Psymtab version of has_symbols. See its definition in
1453 the definition of quick_symbol_functions in symfile.h. */
1456 psym_has_symbols (struct objfile
*objfile
)
1458 return objfile
->psymtabs
!= NULL
;
1461 const struct quick_symbol_functions psym_functions
=
1464 psym_find_last_source_symtab
,
1465 psym_forget_cached_source_info
,
1466 psym_map_symtabs_matching_filename
,
1471 psym_expand_symtabs_for_function
,
1472 psym_expand_all_symtabs
,
1473 psym_expand_symtabs_with_fullname
,
1474 psym_map_matching_symbols
,
1475 psym_expand_symtabs_matching
,
1476 psym_find_pc_sect_compunit_symtab
,
1477 psym_map_symbol_filenames
1483 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1485 /* Sort the global list; don't sort the static list. */
1486 auto begin
= objfile
->global_psymbols
.begin ();
1487 std::advance (begin
, pst
->globals_offset
);
1489 /* The psymbols for this partial_symtab are currently at the end of the
1491 auto end
= objfile
->global_psymbols
.end ();
1493 std::sort (begin
, end
, [] (partial_symbol
*s1
, partial_symbol
*s2
)
1495 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (s1
),
1496 SYMBOL_SEARCH_NAME (s2
)) < 0;
1500 /* Allocate and partially fill a partial symtab. It will be
1501 completely filled at the end of the symbol list.
1503 FILENAME is the name of the symbol-file we are reading from. */
1505 struct partial_symtab
*
1506 start_psymtab_common (struct objfile
*objfile
,
1507 const char *filename
,
1509 std::vector
<partial_symbol
*> &global_psymbols
,
1510 std::vector
<partial_symbol
*> &static_psymbols
)
1512 struct partial_symtab
*psymtab
;
1514 psymtab
= allocate_psymtab (filename
, objfile
);
1515 psymtab
->textlow
= textlow
;
1516 psymtab
->texthigh
= psymtab
->textlow
; /* default */
1517 psymtab
->globals_offset
= global_psymbols
.size ();
1518 psymtab
->statics_offset
= static_psymbols
.size ();
1522 /* Perform "finishing up" operations of a partial symtab. */
1525 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1527 pst
->n_global_syms
= objfile
->global_psymbols
.size () - pst
->globals_offset
;
1528 pst
->n_static_syms
= objfile
->static_psymbols
.size () - pst
->statics_offset
;
1530 sort_pst_symbols (objfile
, pst
);
1533 /* Calculate a hash code for the given partial symbol. The hash is
1534 calculated using the symbol's value, language, domain, class
1535 and name. These are the values which are set by
1536 add_psymbol_to_bcache. */
1538 static unsigned long
1539 psymbol_hash (const void *addr
, int length
)
1541 unsigned long h
= 0;
1542 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1543 unsigned int lang
= psymbol
->ginfo
.language
;
1544 unsigned int domain
= PSYMBOL_DOMAIN (psymbol
);
1545 unsigned int theclass
= PSYMBOL_CLASS (psymbol
);
1547 h
= hash_continue (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1548 h
= hash_continue (&lang
, sizeof (unsigned int), h
);
1549 h
= hash_continue (&domain
, sizeof (unsigned int), h
);
1550 h
= hash_continue (&theclass
, sizeof (unsigned int), h
);
1551 h
= hash_continue (psymbol
->ginfo
.name
, strlen (psymbol
->ginfo
.name
), h
);
1556 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1557 For the comparison this function uses a symbols value,
1558 language, domain, class and name. */
1561 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1563 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1564 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1566 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1567 sizeof (sym1
->ginfo
.value
)) == 0
1568 && sym1
->ginfo
.language
== sym2
->ginfo
.language
1569 && PSYMBOL_DOMAIN (sym1
) == PSYMBOL_DOMAIN (sym2
)
1570 && PSYMBOL_CLASS (sym1
) == PSYMBOL_CLASS (sym2
)
1571 && sym1
->ginfo
.name
== sym2
->ginfo
.name
);
1574 /* Initialize a partial symbol bcache. */
1576 struct psymbol_bcache
*
1577 psymbol_bcache_init (void)
1579 struct psymbol_bcache
*bcache
= XCNEW (struct psymbol_bcache
);
1581 bcache
->bcache
= bcache_xmalloc (psymbol_hash
, psymbol_compare
);
1585 /* Free a partial symbol bcache. */
1588 psymbol_bcache_free (struct psymbol_bcache
*bcache
)
1593 bcache_xfree (bcache
->bcache
);
1597 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1600 psymbol_bcache_get_bcache (struct psymbol_bcache
*bcache
)
1602 return bcache
->bcache
;
1605 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1606 symbol before, add a copy to BCACHE. In either case, return a pointer
1607 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1608 1 in case of new entry or 0 if returning an old entry. */
1610 static struct partial_symbol
*
1611 psymbol_bcache_full (struct partial_symbol
*sym
,
1612 struct psymbol_bcache
*bcache
,
1615 return ((struct partial_symbol
*)
1616 bcache_full (sym
, sizeof (struct partial_symbol
), bcache
->bcache
,
1620 /* Helper function, initialises partial symbol structure and stashes
1621 it into objfile's bcache. Note that our caching mechanism will
1622 use all fields of struct partial_symbol to determine hash value of the
1623 structure. In other words, having two symbols with the same name but
1624 different domain (or address) is possible and correct. */
1626 static struct partial_symbol
*
1627 add_psymbol_to_bcache (const char *name
, int namelength
, int copy_name
,
1629 enum address_class theclass
,
1631 enum language language
, struct objfile
*objfile
,
1634 struct partial_symbol psymbol
;
1636 /* We must ensure that the entire struct has been zeroed before
1637 assigning to it, because an assignment may not touch some of the
1639 memset (&psymbol
, 0, sizeof (psymbol
));
1641 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
1642 SYMBOL_SECTION (&psymbol
) = -1;
1643 SYMBOL_SET_LANGUAGE (&psymbol
, language
, &objfile
->objfile_obstack
);
1644 PSYMBOL_DOMAIN (&psymbol
) = domain
;
1645 PSYMBOL_CLASS (&psymbol
) = theclass
;
1647 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
1649 /* Stash the partial symbol away in the cache. */
1650 return psymbol_bcache_full (&psymbol
, objfile
->psymbol_cache
, added
);
1653 /* Helper function, adds partial symbol to the given partial symbol list. */
1656 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1657 struct partial_symbol
*psym
,
1658 struct objfile
*objfile
)
1660 list
->push_back (psym
);
1661 OBJSTAT (objfile
, n_psyms
++);
1664 /* Add a symbol with a long value to a psymtab.
1665 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1666 The only value we need to store for psyms is an address.
1667 For all other psyms pass zero for COREADDR.
1668 Return the partial symbol that has been added. */
1671 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1673 enum address_class theclass
,
1674 std::vector
<partial_symbol
*> *list
,
1676 enum language language
, struct objfile
*objfile
)
1678 struct partial_symbol
*psym
;
1682 /* Stash the partial symbol away in the cache. */
1683 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, theclass
,
1684 coreaddr
, language
, objfile
, &added
);
1686 /* Do not duplicate global partial symbols. */
1687 if (list
== &objfile
->global_psymbols
1691 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1692 append_psymbol_to_list (list
, psym
, objfile
);
1695 /* Initialize storage for partial symbols. */
1698 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1700 /* Free any previously allocated psymbol lists. */
1701 objfile
->global_psymbols
.clear ();
1702 objfile
->static_psymbols
.clear ();
1704 /* Current best guess is that approximately a twentieth
1705 of the total symbols (in a debugging file) are global or static
1706 oriented symbols, then multiply that by slop factor of two. */
1707 objfile
->global_psymbols
.reserve (total_symbols
/ 10);
1708 objfile
->static_psymbols
.reserve (total_symbols
/ 10);
1711 struct partial_symtab
*
1712 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1714 struct partial_symtab
*psymtab
;
1716 if (objfile
->free_psymtabs
)
1718 psymtab
= objfile
->free_psymtabs
;
1719 objfile
->free_psymtabs
= psymtab
->next
;
1722 psymtab
= (struct partial_symtab
*)
1723 obstack_alloc (&objfile
->objfile_obstack
,
1724 sizeof (struct partial_symtab
));
1726 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1728 = (const char *) bcache (filename
, strlen (filename
) + 1,
1729 objfile
->per_bfd
->filename_cache
);
1730 psymtab
->compunit_symtab
= NULL
;
1732 /* Prepend it to the psymtab list for the objfile it belongs to.
1733 Psymtabs are searched in most recent inserted -> least recent
1736 psymtab
->next
= objfile
->psymtabs
;
1737 objfile
->psymtabs
= psymtab
;
1739 if (symtab_create_debug
)
1741 /* Be a bit clever with debugging messages, and don't print objfile
1742 every time, only when it changes. */
1743 static char *last_objfile_name
= NULL
;
1745 if (last_objfile_name
== NULL
1746 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1748 xfree (last_objfile_name
);
1749 last_objfile_name
= xstrdup (objfile_name (objfile
));
1750 fprintf_unfiltered (gdb_stdlog
,
1751 "Creating one or more psymtabs for objfile %s ...\n",
1754 fprintf_unfiltered (gdb_stdlog
,
1755 "Created psymtab %s for module %s.\n",
1756 host_address_to_string (psymtab
), filename
);
1763 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1765 struct partial_symtab
**prev_pst
;
1768 Empty psymtabs happen as a result of header files which don't
1769 have any symbols in them. There can be a lot of them. But this
1770 check is wrong, in that a psymtab with N_SLINE entries but
1771 nothing else is not empty, but we don't realize that. Fixing
1772 that without slowing things down might be tricky. */
1774 /* First, snip it out of the psymtab chain. */
1776 prev_pst
= &(objfile
->psymtabs
);
1777 while ((*prev_pst
) != pst
)
1778 prev_pst
= &((*prev_pst
)->next
);
1779 (*prev_pst
) = pst
->next
;
1781 /* Next, put it on a free list for recycling. */
1783 pst
->next
= objfile
->free_psymtabs
;
1784 objfile
->free_psymtabs
= pst
;
1789 /* We need to pass a couple of items to the addrmap_foreach function,
1792 struct dump_psymtab_addrmap_data
1794 struct objfile
*objfile
;
1795 struct partial_symtab
*psymtab
;
1796 struct ui_file
*outfile
;
1798 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1799 If so, we want to print the next one as well (since the next addrmap
1800 entry defines the end of the range). */
1801 int previous_matched
;
1804 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1807 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1809 struct dump_psymtab_addrmap_data
*data
1810 = (struct dump_psymtab_addrmap_data
*) datap
;
1811 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1812 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1813 const char *psymtab_address_or_end
= NULL
;
1817 if (data
->psymtab
== NULL
1818 || data
->psymtab
== addrmap_psymtab
)
1819 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1820 else if (data
->previous_matched
)
1821 psymtab_address_or_end
= "<ends here>";
1823 if (data
->psymtab
== NULL
1824 || data
->psymtab
== addrmap_psymtab
1825 || data
->previous_matched
)
1827 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1828 data
->psymtab
!= NULL
? " " : "",
1829 paddress (gdbarch
, start_addr
),
1830 psymtab_address_or_end
);
1833 data
->previous_matched
= (data
->psymtab
== NULL
1834 || data
->psymtab
== addrmap_psymtab
);
1839 /* Helper function for maintenance_print_psymbols to print the addrmap
1840 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1843 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1844 struct ui_file
*outfile
)
1846 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1848 if ((psymtab
== NULL
1849 || psymtab
->psymtabs_addrmap_supported
)
1850 && objfile
->psymtabs_addrmap
!= NULL
)
1852 addrmap_dump_data
.objfile
= objfile
;
1853 addrmap_dump_data
.psymtab
= psymtab
;
1854 addrmap_dump_data
.outfile
= outfile
;
1855 addrmap_dump_data
.previous_matched
= 0;
1856 fprintf_filtered (outfile
, "%sddress map:\n",
1857 psymtab
== NULL
? "Entire a" : " A");
1858 addrmap_foreach (objfile
->psymtabs_addrmap
, dump_psymtab_addrmap_1
,
1859 &addrmap_dump_data
);
1864 maintenance_print_psymbols (const char *args
, int from_tty
)
1866 struct ui_file
*outfile
= gdb_stdout
;
1867 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1868 struct objfile
*objfile
;
1869 struct partial_symtab
*ps
;
1870 int i
, outfile_idx
, found
;
1872 struct obj_section
*section
= NULL
;
1876 gdb_argv
argv (args
);
1878 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1880 if (strcmp (argv
[i
], "-pc") == 0)
1882 if (argv
[i
+ 1] == NULL
)
1883 error (_("Missing pc value"));
1884 address_arg
= argv
[++i
];
1886 else if (strcmp (argv
[i
], "-source") == 0)
1888 if (argv
[i
+ 1] == NULL
)
1889 error (_("Missing source file"));
1890 source_arg
= argv
[++i
];
1892 else if (strcmp (argv
[i
], "-objfile") == 0)
1894 if (argv
[i
+ 1] == NULL
)
1895 error (_("Missing objfile name"));
1896 objfile_arg
= argv
[++i
];
1898 else if (strcmp (argv
[i
], "--") == 0)
1900 /* End of options. */
1904 else if (argv
[i
][0] == '-')
1906 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1907 error (_("Unknown option: %s"), argv
[i
]);
1914 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1915 error (_("Must specify at most one of -pc and -source"));
1917 stdio_file arg_outfile
;
1919 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1921 if (argv
[outfile_idx
+ 1] != NULL
)
1922 error (_("Junk at end of command"));
1923 gdb::unique_xmalloc_ptr
<char> outfile_name
1924 (tilde_expand (argv
[outfile_idx
]));
1925 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1926 perror_with_name (outfile_name
.get ());
1927 outfile
= &arg_outfile
;
1930 if (address_arg
!= NULL
)
1932 pc
= parse_and_eval_address (address_arg
);
1933 /* If we fail to find a section, that's ok, try the lookup anyway. */
1934 section
= find_pc_section (pc
);
1938 ALL_OBJFILES (objfile
)
1940 int printed_objfile_header
= 0;
1941 int print_for_objfile
= 1;
1944 if (objfile_arg
!= NULL
)
1946 = compare_filenames_for_search (objfile_name (objfile
),
1948 if (!print_for_objfile
)
1951 if (address_arg
!= NULL
)
1953 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1955 /* We don't assume each pc has a unique objfile (this is for
1957 ps
= find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1960 if (!printed_objfile_header
)
1962 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1963 objfile_name (objfile
));
1964 printed_objfile_header
= 1;
1966 dump_psymtab (objfile
, ps
, outfile
);
1967 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1973 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1975 int print_for_source
= 0;
1978 if (source_arg
!= NULL
)
1981 = compare_filenames_for_search (ps
->filename
, source_arg
);
1984 if (source_arg
== NULL
1985 || print_for_source
)
1987 if (!printed_objfile_header
)
1989 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1990 objfile_name (objfile
));
1991 printed_objfile_header
= 1;
1993 dump_psymtab (objfile
, ps
, outfile
);
1994 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1999 /* If we're printing all the objfile's symbols dump the full addrmap. */
2001 if (address_arg
== NULL
2002 && source_arg
== NULL
2003 && objfile
->psymtabs_addrmap
!= NULL
)
2005 outfile
->puts ("\n");
2006 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
2012 if (address_arg
!= NULL
)
2013 error (_("No partial symtab for address: %s"), address_arg
);
2014 if (source_arg
!= NULL
)
2015 error (_("No partial symtab for source file: %s"), source_arg
);
2019 /* List all the partial symbol tables whose names match REGEXP (optional). */
2022 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
2024 struct program_space
*pspace
;
2025 struct objfile
*objfile
;
2030 ALL_PSPACES (pspace
)
2031 ALL_PSPACE_OBJFILES (pspace
, objfile
)
2033 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2034 struct partial_symtab
*psymtab
;
2036 /* We don't want to print anything for this objfile until we
2037 actually find a symtab whose name matches. */
2038 int printed_objfile_start
= 0;
2040 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
2045 || re_exec (psymtab
->filename
))
2047 if (! printed_objfile_start
)
2049 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2051 printf_filtered ("((struct objfile *) %s)\n",
2052 host_address_to_string (objfile
));
2053 printed_objfile_start
= 1;
2056 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2058 printf_filtered ("((struct partial_symtab *) %s)\n",
2059 host_address_to_string (psymtab
));
2061 printf_filtered (" readin %s\n",
2062 psymtab
->readin
? "yes" : "no");
2063 printf_filtered (" fullname %s\n",
2065 ? psymtab
->fullname
: "(null)");
2066 printf_filtered (" text addresses ");
2067 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
),
2069 printf_filtered (" -- ");
2070 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
),
2072 printf_filtered ("\n");
2073 printf_filtered (" psymtabs_addrmap_supported %s\n",
2074 (psymtab
->psymtabs_addrmap_supported
2076 printf_filtered (" globals ");
2077 if (psymtab
->n_global_syms
)
2079 auto p
= &objfile
->global_psymbols
[psymtab
->globals_offset
];
2081 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2082 host_address_to_string (p
),
2083 psymtab
->n_global_syms
);
2086 printf_filtered ("(none)\n");
2087 printf_filtered (" statics ");
2088 if (psymtab
->n_static_syms
)
2090 auto p
= &objfile
->static_psymbols
[psymtab
->statics_offset
];
2092 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2093 host_address_to_string (p
),
2094 psymtab
->n_static_syms
);
2097 printf_filtered ("(none)\n");
2098 printf_filtered (" dependencies ");
2099 if (psymtab
->number_of_dependencies
)
2103 printf_filtered ("{\n");
2104 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2106 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2108 /* Note the string concatenation there --- no comma. */
2109 printf_filtered (" psymtab %s "
2110 "((struct partial_symtab *) %s)\n",
2112 host_address_to_string (dep
));
2114 printf_filtered (" }\n");
2117 printf_filtered ("(none)\n");
2118 printf_filtered (" }\n");
2122 if (printed_objfile_start
)
2123 printf_filtered ("}\n");
2127 /* Check consistency of currently expanded psymtabs vs symtabs. */
2130 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2133 struct compunit_symtab
*cust
= NULL
;
2134 struct partial_symtab
*ps
;
2135 const struct blockvector
*bv
;
2136 struct objfile
*objfile
;
2140 ALL_PSYMTABS (objfile
, ps
)
2142 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2144 /* We don't call psymtab_to_symtab here because that may cause symtab
2145 expansion. When debugging a problem it helps if checkers leave
2146 things unchanged. */
2147 cust
= ps
->compunit_symtab
;
2149 /* First do some checks that don't require the associated symtab. */
2150 if (ps
->texthigh
< ps
->textlow
)
2152 printf_filtered ("Psymtab ");
2153 puts_filtered (ps
->filename
);
2154 printf_filtered (" covers bad range ");
2155 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2156 printf_filtered (" - ");
2157 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2158 printf_filtered ("\n");
2162 /* Now do checks requiring the associated symtab. */
2165 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2166 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2167 partial_symbol
**psym
= &objfile
->static_psymbols
[ps
->statics_offset
];
2168 length
= ps
->n_static_syms
;
2171 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2172 SYMBOL_DOMAIN (*psym
));
2175 printf_filtered ("Static symbol `");
2176 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2177 printf_filtered ("' only found in ");
2178 puts_filtered (ps
->filename
);
2179 printf_filtered (" psymtab\n");
2183 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2184 psym
= &objfile
->global_psymbols
[ps
->globals_offset
];
2185 length
= ps
->n_global_syms
;
2188 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2189 SYMBOL_DOMAIN (*psym
));
2192 printf_filtered ("Global symbol `");
2193 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2194 printf_filtered ("' only found in ");
2195 puts_filtered (ps
->filename
);
2196 printf_filtered (" psymtab\n");
2200 if (ps
->texthigh
!= 0
2201 && (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
)))
2203 printf_filtered ("Psymtab ");
2204 puts_filtered (ps
->filename
);
2205 printf_filtered (" covers ");
2206 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2207 printf_filtered (" - ");
2208 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2209 printf_filtered (" but symtab covers only ");
2210 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2211 printf_filtered (" - ");
2212 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2213 printf_filtered ("\n");
2219 _initialize_psymtab (void)
2221 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2222 Print dump of current partial symbol definitions.\n\
2223 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2224 mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2225 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2226 or the terminal if OUTFILE is unspecified.\n\
2227 If ADDRESS is provided, dump only the file for that address.\n\
2228 If SOURCE is provided, dump only that file's symbols.\n\
2229 If OBJFILE is provided, dump only that file's minimal symbols."),
2230 &maintenanceprintlist
);
2232 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2233 List the partial symbol tables for all object files.\n\
2234 This does not include information about individual partial symbols,\n\
2235 just the symbol table structures themselves."),
2236 &maintenanceinfolist
);
2238 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2240 Check consistency of currently expanded psymtabs versus symtabs."),