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
,
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 /* Clear the search flags. */
1401 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1403 ps
->searched_flag
= PST_NOT_SEARCHED
;
1406 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1413 /* We skip shared psymtabs because file-matching doesn't apply
1414 to them; but we search them later in the loop. */
1415 if (ps
->user
!= NULL
)
1425 match
= file_matcher (ps
->filename
, false);
1428 /* Before we invoke realpath, which can get expensive when many
1429 files are involved, do a quick comparison of the basenames. */
1430 if (basenames_may_differ
1431 || file_matcher (lbasename (ps
->filename
), true))
1432 match
= file_matcher (psymtab_to_fullname (ps
), false);
1438 if (recursively_search_psymtabs (ps
, objfile
, domain
,
1439 lookup_name
, symbol_matcher
))
1441 struct compunit_symtab
*symtab
=
1442 psymtab_to_symtab (objfile
, ps
);
1444 if (expansion_notify
!= NULL
)
1445 expansion_notify (symtab
);
1450 /* Psymtab version of has_symbols. See its definition in
1451 the definition of quick_symbol_functions in symfile.h. */
1454 psym_has_symbols (struct objfile
*objfile
)
1456 return objfile
->psymtabs
!= NULL
;
1459 const struct quick_symbol_functions psym_functions
=
1462 psym_find_last_source_symtab
,
1463 psym_forget_cached_source_info
,
1464 psym_map_symtabs_matching_filename
,
1469 psym_expand_symtabs_for_function
,
1470 psym_expand_all_symtabs
,
1471 psym_expand_symtabs_with_fullname
,
1472 psym_map_matching_symbols
,
1473 psym_expand_symtabs_matching
,
1474 psym_find_pc_sect_compunit_symtab
,
1475 psym_map_symbol_filenames
1481 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1483 /* Sort the global list; don't sort the static list. */
1484 auto begin
= objfile
->global_psymbols
.begin ();
1485 std::advance (begin
, pst
->globals_offset
);
1487 /* The psymbols for this partial_symtab are currently at the end of the
1489 auto end
= objfile
->global_psymbols
.end ();
1491 std::sort (begin
, end
, [] (partial_symbol
*s1
, partial_symbol
*s2
)
1493 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (s1
),
1494 SYMBOL_SEARCH_NAME (s2
)) < 0;
1498 /* Allocate and partially fill a partial symtab. It will be
1499 completely filled at the end of the symbol list.
1501 FILENAME is the name of the symbol-file we are reading from. */
1503 struct partial_symtab
*
1504 start_psymtab_common (struct objfile
*objfile
,
1505 const char *filename
,
1507 std::vector
<partial_symbol
*> &global_psymbols
,
1508 std::vector
<partial_symbol
*> &static_psymbols
)
1510 struct partial_symtab
*psymtab
;
1512 psymtab
= allocate_psymtab (filename
, objfile
);
1513 psymtab
->textlow
= textlow
;
1514 psymtab
->texthigh
= psymtab
->textlow
; /* default */
1515 psymtab
->globals_offset
= global_psymbols
.size ();
1516 psymtab
->statics_offset
= static_psymbols
.size ();
1520 /* Perform "finishing up" operations of a partial symtab. */
1523 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1525 pst
->n_global_syms
= objfile
->global_psymbols
.size () - pst
->globals_offset
;
1526 pst
->n_static_syms
= objfile
->static_psymbols
.size () - pst
->statics_offset
;
1528 sort_pst_symbols (objfile
, pst
);
1531 /* Calculate a hash code for the given partial symbol. The hash is
1532 calculated using the symbol's value, language, domain, class
1533 and name. These are the values which are set by
1534 add_psymbol_to_bcache. */
1536 static unsigned long
1537 psymbol_hash (const void *addr
, int length
)
1539 unsigned long h
= 0;
1540 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1541 unsigned int lang
= psymbol
->ginfo
.language
;
1542 unsigned int domain
= PSYMBOL_DOMAIN (psymbol
);
1543 unsigned int theclass
= PSYMBOL_CLASS (psymbol
);
1545 h
= hash_continue (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1546 h
= hash_continue (&lang
, sizeof (unsigned int), h
);
1547 h
= hash_continue (&domain
, sizeof (unsigned int), h
);
1548 h
= hash_continue (&theclass
, sizeof (unsigned int), h
);
1549 h
= hash_continue (psymbol
->ginfo
.name
, strlen (psymbol
->ginfo
.name
), h
);
1554 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1555 For the comparison this function uses a symbols value,
1556 language, domain, class and name. */
1559 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1561 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1562 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1564 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1565 sizeof (sym1
->ginfo
.value
)) == 0
1566 && sym1
->ginfo
.language
== sym2
->ginfo
.language
1567 && PSYMBOL_DOMAIN (sym1
) == PSYMBOL_DOMAIN (sym2
)
1568 && PSYMBOL_CLASS (sym1
) == PSYMBOL_CLASS (sym2
)
1569 && sym1
->ginfo
.name
== sym2
->ginfo
.name
);
1572 /* Initialize a partial symbol bcache. */
1574 struct psymbol_bcache
*
1575 psymbol_bcache_init (void)
1577 struct psymbol_bcache
*bcache
= XCNEW (struct psymbol_bcache
);
1579 bcache
->bcache
= bcache_xmalloc (psymbol_hash
, psymbol_compare
);
1583 /* Free a partial symbol bcache. */
1586 psymbol_bcache_free (struct psymbol_bcache
*bcache
)
1591 bcache_xfree (bcache
->bcache
);
1595 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1598 psymbol_bcache_get_bcache (struct psymbol_bcache
*bcache
)
1600 return bcache
->bcache
;
1603 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1604 symbol before, add a copy to BCACHE. In either case, return a pointer
1605 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1606 1 in case of new entry or 0 if returning an old entry. */
1608 static struct partial_symbol
*
1609 psymbol_bcache_full (struct partial_symbol
*sym
,
1610 struct psymbol_bcache
*bcache
,
1613 return ((struct partial_symbol
*)
1614 bcache_full (sym
, sizeof (struct partial_symbol
), bcache
->bcache
,
1618 /* Helper function, initialises partial symbol structure and stashes
1619 it into objfile's bcache. Note that our caching mechanism will
1620 use all fields of struct partial_symbol to determine hash value of the
1621 structure. In other words, having two symbols with the same name but
1622 different domain (or address) is possible and correct. */
1624 static struct partial_symbol
*
1625 add_psymbol_to_bcache (const char *name
, int namelength
, int copy_name
,
1627 enum address_class theclass
,
1629 enum language language
, struct objfile
*objfile
,
1632 struct partial_symbol psymbol
;
1634 /* We must ensure that the entire struct has been zeroed before
1635 assigning to it, because an assignment may not touch some of the
1637 memset (&psymbol
, 0, sizeof (psymbol
));
1639 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
1640 SYMBOL_SECTION (&psymbol
) = -1;
1641 SYMBOL_SET_LANGUAGE (&psymbol
, language
, &objfile
->objfile_obstack
);
1642 PSYMBOL_DOMAIN (&psymbol
) = domain
;
1643 PSYMBOL_CLASS (&psymbol
) = theclass
;
1645 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
1647 /* Stash the partial symbol away in the cache. */
1648 return psymbol_bcache_full (&psymbol
, objfile
->psymbol_cache
, added
);
1651 /* Helper function, adds partial symbol to the given partial symbol list. */
1654 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1655 struct partial_symbol
*psym
,
1656 struct objfile
*objfile
)
1658 list
->push_back (psym
);
1659 OBJSTAT (objfile
, n_psyms
++);
1662 /* Add a symbol with a long value to a psymtab.
1663 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1664 The only value we need to store for psyms is an address.
1665 For all other psyms pass zero for COREADDR.
1666 Return the partial symbol that has been added. */
1669 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1671 enum address_class theclass
,
1672 std::vector
<partial_symbol
*> *list
,
1674 enum language language
, struct objfile
*objfile
)
1676 struct partial_symbol
*psym
;
1680 /* Stash the partial symbol away in the cache. */
1681 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, theclass
,
1682 coreaddr
, language
, objfile
, &added
);
1684 /* Do not duplicate global partial symbols. */
1685 if (list
== &objfile
->global_psymbols
1689 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1690 append_psymbol_to_list (list
, psym
, objfile
);
1693 /* Initialize storage for partial symbols. */
1696 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1698 /* Free any previously allocated psymbol lists. */
1699 objfile
->global_psymbols
.clear ();
1700 objfile
->static_psymbols
.clear ();
1702 /* Current best guess is that approximately a twentieth
1703 of the total symbols (in a debugging file) are global or static
1704 oriented symbols, then multiply that by slop factor of two. */
1705 objfile
->global_psymbols
.reserve (total_symbols
/ 10);
1706 objfile
->static_psymbols
.reserve (total_symbols
/ 10);
1709 struct partial_symtab
*
1710 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1712 struct partial_symtab
*psymtab
;
1714 if (objfile
->free_psymtabs
)
1716 psymtab
= objfile
->free_psymtabs
;
1717 objfile
->free_psymtabs
= psymtab
->next
;
1720 psymtab
= (struct partial_symtab
*)
1721 obstack_alloc (&objfile
->objfile_obstack
,
1722 sizeof (struct partial_symtab
));
1724 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1726 = (const char *) bcache (filename
, strlen (filename
) + 1,
1727 objfile
->per_bfd
->filename_cache
);
1728 psymtab
->compunit_symtab
= NULL
;
1730 /* Prepend it to the psymtab list for the objfile it belongs to.
1731 Psymtabs are searched in most recent inserted -> least recent
1734 psymtab
->next
= objfile
->psymtabs
;
1735 objfile
->psymtabs
= psymtab
;
1737 if (symtab_create_debug
)
1739 /* Be a bit clever with debugging messages, and don't print objfile
1740 every time, only when it changes. */
1741 static char *last_objfile_name
= NULL
;
1743 if (last_objfile_name
== NULL
1744 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1746 xfree (last_objfile_name
);
1747 last_objfile_name
= xstrdup (objfile_name (objfile
));
1748 fprintf_unfiltered (gdb_stdlog
,
1749 "Creating one or more psymtabs for objfile %s ...\n",
1752 fprintf_unfiltered (gdb_stdlog
,
1753 "Created psymtab %s for module %s.\n",
1754 host_address_to_string (psymtab
), filename
);
1761 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1763 struct partial_symtab
**prev_pst
;
1766 Empty psymtabs happen as a result of header files which don't
1767 have any symbols in them. There can be a lot of them. But this
1768 check is wrong, in that a psymtab with N_SLINE entries but
1769 nothing else is not empty, but we don't realize that. Fixing
1770 that without slowing things down might be tricky. */
1772 /* First, snip it out of the psymtab chain. */
1774 prev_pst
= &(objfile
->psymtabs
);
1775 while ((*prev_pst
) != pst
)
1776 prev_pst
= &((*prev_pst
)->next
);
1777 (*prev_pst
) = pst
->next
;
1779 /* Next, put it on a free list for recycling. */
1781 pst
->next
= objfile
->free_psymtabs
;
1782 objfile
->free_psymtabs
= pst
;
1787 /* We need to pass a couple of items to the addrmap_foreach function,
1790 struct dump_psymtab_addrmap_data
1792 struct objfile
*objfile
;
1793 struct partial_symtab
*psymtab
;
1794 struct ui_file
*outfile
;
1796 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1797 If so, we want to print the next one as well (since the next addrmap
1798 entry defines the end of the range). */
1799 int previous_matched
;
1802 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1805 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1807 struct dump_psymtab_addrmap_data
*data
1808 = (struct dump_psymtab_addrmap_data
*) datap
;
1809 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1810 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1811 const char *psymtab_address_or_end
= NULL
;
1815 if (data
->psymtab
== NULL
1816 || data
->psymtab
== addrmap_psymtab
)
1817 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1818 else if (data
->previous_matched
)
1819 psymtab_address_or_end
= "<ends here>";
1821 if (data
->psymtab
== NULL
1822 || data
->psymtab
== addrmap_psymtab
1823 || data
->previous_matched
)
1825 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1826 data
->psymtab
!= NULL
? " " : "",
1827 paddress (gdbarch
, start_addr
),
1828 psymtab_address_or_end
);
1831 data
->previous_matched
= (data
->psymtab
== NULL
1832 || data
->psymtab
== addrmap_psymtab
);
1837 /* Helper function for maintenance_print_psymbols to print the addrmap
1838 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1841 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1842 struct ui_file
*outfile
)
1844 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1846 if ((psymtab
== NULL
1847 || psymtab
->psymtabs_addrmap_supported
)
1848 && objfile
->psymtabs_addrmap
!= NULL
)
1850 addrmap_dump_data
.objfile
= objfile
;
1851 addrmap_dump_data
.psymtab
= psymtab
;
1852 addrmap_dump_data
.outfile
= outfile
;
1853 addrmap_dump_data
.previous_matched
= 0;
1854 fprintf_filtered (outfile
, "%sddress map:\n",
1855 psymtab
== NULL
? "Entire a" : " A");
1856 addrmap_foreach (objfile
->psymtabs_addrmap
, dump_psymtab_addrmap_1
,
1857 &addrmap_dump_data
);
1862 maintenance_print_psymbols (const char *args
, int from_tty
)
1864 struct ui_file
*outfile
= gdb_stdout
;
1865 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1866 struct objfile
*objfile
;
1867 struct partial_symtab
*ps
;
1868 int i
, outfile_idx
, found
;
1870 struct obj_section
*section
= NULL
;
1874 gdb_argv
argv (args
);
1876 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1878 if (strcmp (argv
[i
], "-pc") == 0)
1880 if (argv
[i
+ 1] == NULL
)
1881 error (_("Missing pc value"));
1882 address_arg
= argv
[++i
];
1884 else if (strcmp (argv
[i
], "-source") == 0)
1886 if (argv
[i
+ 1] == NULL
)
1887 error (_("Missing source file"));
1888 source_arg
= argv
[++i
];
1890 else if (strcmp (argv
[i
], "-objfile") == 0)
1892 if (argv
[i
+ 1] == NULL
)
1893 error (_("Missing objfile name"));
1894 objfile_arg
= argv
[++i
];
1896 else if (strcmp (argv
[i
], "--") == 0)
1898 /* End of options. */
1902 else if (argv
[i
][0] == '-')
1904 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1905 error (_("Unknown option: %s"), argv
[i
]);
1912 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1913 error (_("Must specify at most one of -pc and -source"));
1915 stdio_file arg_outfile
;
1917 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1919 if (argv
[outfile_idx
+ 1] != NULL
)
1920 error (_("Junk at end of command"));
1921 gdb::unique_xmalloc_ptr
<char> outfile_name
1922 (tilde_expand (argv
[outfile_idx
]));
1923 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1924 perror_with_name (outfile_name
.get ());
1925 outfile
= &arg_outfile
;
1928 if (address_arg
!= NULL
)
1930 pc
= parse_and_eval_address (address_arg
);
1931 /* If we fail to find a section, that's ok, try the lookup anyway. */
1932 section
= find_pc_section (pc
);
1936 ALL_OBJFILES (objfile
)
1938 int printed_objfile_header
= 0;
1939 int print_for_objfile
= 1;
1942 if (objfile_arg
!= NULL
)
1944 = compare_filenames_for_search (objfile_name (objfile
),
1946 if (!print_for_objfile
)
1949 if (address_arg
!= NULL
)
1951 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1953 /* We don't assume each pc has a unique objfile (this is for
1955 ps
= find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1958 if (!printed_objfile_header
)
1960 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1961 objfile_name (objfile
));
1962 printed_objfile_header
= 1;
1964 dump_psymtab (objfile
, ps
, outfile
);
1965 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1971 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1973 int print_for_source
= 0;
1976 if (source_arg
!= NULL
)
1979 = compare_filenames_for_search (ps
->filename
, source_arg
);
1982 if (source_arg
== NULL
1983 || print_for_source
)
1985 if (!printed_objfile_header
)
1987 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1988 objfile_name (objfile
));
1989 printed_objfile_header
= 1;
1991 dump_psymtab (objfile
, ps
, outfile
);
1992 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1997 /* If we're printing all the objfile's symbols dump the full addrmap. */
1999 if (address_arg
== NULL
2000 && source_arg
== NULL
2001 && objfile
->psymtabs_addrmap
!= NULL
)
2003 outfile
->puts ("\n");
2004 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
2010 if (address_arg
!= NULL
)
2011 error (_("No partial symtab for address: %s"), address_arg
);
2012 if (source_arg
!= NULL
)
2013 error (_("No partial symtab for source file: %s"), source_arg
);
2017 /* List all the partial symbol tables whose names match REGEXP (optional). */
2020 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
2022 struct program_space
*pspace
;
2023 struct objfile
*objfile
;
2028 ALL_PSPACES (pspace
)
2029 ALL_PSPACE_OBJFILES (pspace
, objfile
)
2031 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2032 struct partial_symtab
*psymtab
;
2034 /* We don't want to print anything for this objfile until we
2035 actually find a symtab whose name matches. */
2036 int printed_objfile_start
= 0;
2038 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
2043 || re_exec (psymtab
->filename
))
2045 if (! printed_objfile_start
)
2047 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2049 printf_filtered ("((struct objfile *) %s)\n",
2050 host_address_to_string (objfile
));
2051 printed_objfile_start
= 1;
2054 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2056 printf_filtered ("((struct partial_symtab *) %s)\n",
2057 host_address_to_string (psymtab
));
2059 printf_filtered (" readin %s\n",
2060 psymtab
->readin
? "yes" : "no");
2061 printf_filtered (" fullname %s\n",
2063 ? psymtab
->fullname
: "(null)");
2064 printf_filtered (" text addresses ");
2065 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
),
2067 printf_filtered (" -- ");
2068 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
),
2070 printf_filtered ("\n");
2071 printf_filtered (" psymtabs_addrmap_supported %s\n",
2072 (psymtab
->psymtabs_addrmap_supported
2074 printf_filtered (" globals ");
2075 if (psymtab
->n_global_syms
)
2077 auto p
= &objfile
->global_psymbols
[psymtab
->globals_offset
];
2079 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2080 host_address_to_string (p
),
2081 psymtab
->n_global_syms
);
2084 printf_filtered ("(none)\n");
2085 printf_filtered (" statics ");
2086 if (psymtab
->n_static_syms
)
2088 auto p
= &objfile
->static_psymbols
[psymtab
->statics_offset
];
2090 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2091 host_address_to_string (p
),
2092 psymtab
->n_static_syms
);
2095 printf_filtered ("(none)\n");
2096 printf_filtered (" dependencies ");
2097 if (psymtab
->number_of_dependencies
)
2101 printf_filtered ("{\n");
2102 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2104 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2106 /* Note the string concatenation there --- no comma. */
2107 printf_filtered (" psymtab %s "
2108 "((struct partial_symtab *) %s)\n",
2110 host_address_to_string (dep
));
2112 printf_filtered (" }\n");
2115 printf_filtered ("(none)\n");
2116 printf_filtered (" }\n");
2120 if (printed_objfile_start
)
2121 printf_filtered ("}\n");
2125 /* Check consistency of currently expanded psymtabs vs symtabs. */
2128 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2131 struct compunit_symtab
*cust
= NULL
;
2132 struct partial_symtab
*ps
;
2133 const struct blockvector
*bv
;
2134 struct objfile
*objfile
;
2138 ALL_PSYMTABS (objfile
, ps
)
2140 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2142 /* We don't call psymtab_to_symtab here because that may cause symtab
2143 expansion. When debugging a problem it helps if checkers leave
2144 things unchanged. */
2145 cust
= ps
->compunit_symtab
;
2147 /* First do some checks that don't require the associated symtab. */
2148 if (ps
->texthigh
< ps
->textlow
)
2150 printf_filtered ("Psymtab ");
2151 puts_filtered (ps
->filename
);
2152 printf_filtered (" covers bad range ");
2153 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2154 printf_filtered (" - ");
2155 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2156 printf_filtered ("\n");
2160 /* Now do checks requiring the associated symtab. */
2163 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2164 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2165 partial_symbol
**psym
= &objfile
->static_psymbols
[ps
->statics_offset
];
2166 length
= ps
->n_static_syms
;
2169 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2170 SYMBOL_DOMAIN (*psym
));
2173 printf_filtered ("Static symbol `");
2174 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2175 printf_filtered ("' only found in ");
2176 puts_filtered (ps
->filename
);
2177 printf_filtered (" psymtab\n");
2181 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2182 psym
= &objfile
->global_psymbols
[ps
->globals_offset
];
2183 length
= ps
->n_global_syms
;
2186 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2187 SYMBOL_DOMAIN (*psym
));
2190 printf_filtered ("Global symbol `");
2191 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2192 printf_filtered ("' only found in ");
2193 puts_filtered (ps
->filename
);
2194 printf_filtered (" psymtab\n");
2198 if (ps
->texthigh
!= 0
2199 && (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
)))
2201 printf_filtered ("Psymtab ");
2202 puts_filtered (ps
->filename
);
2203 printf_filtered (" covers ");
2204 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2205 printf_filtered (" - ");
2206 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2207 printf_filtered (" but symtab covers only ");
2208 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2209 printf_filtered (" - ");
2210 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2211 printf_filtered ("\n");
2217 _initialize_psymtab (void)
2219 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2220 Print dump of current partial symbol definitions.\n\
2221 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2222 mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2223 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2224 or the terminal if OUTFILE is unspecified.\n\
2225 If ADDRESS is provided, dump only the file for that address.\n\
2226 If SOURCE is provided, dump only that file's symbols.\n\
2227 If OBJFILE is provided, dump only that file's minimal symbols."),
2228 &maintenanceprintlist
);
2230 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2231 List the partial symbol tables for all object files.\n\
2232 This does not include information about individual partial symbols,\n\
2233 just the symbol table structures themselves."),
2234 &maintenanceinfolist
);
2236 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2238 Check consistency of currently expanded psymtabs versus symtabs."),