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 /* Note that psymbol names are interned via symbol_set_names, so
1552 there's no need to hash the contents of the name here. */
1553 h
= hash_continue (&psymbol
->ginfo
.name
, sizeof (psymbol
->ginfo
.name
), h
);
1558 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1559 For the comparison this function uses a symbols value,
1560 language, domain, class and name. */
1563 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1565 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1566 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1568 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1569 sizeof (sym1
->ginfo
.value
)) == 0
1570 && sym1
->ginfo
.language
== sym2
->ginfo
.language
1571 && PSYMBOL_DOMAIN (sym1
) == PSYMBOL_DOMAIN (sym2
)
1572 && PSYMBOL_CLASS (sym1
) == PSYMBOL_CLASS (sym2
)
1573 /* Note that psymbol names are interned via
1574 symbol_set_names, so there's no need to compare the
1575 contents of the name here. */
1576 && sym1
->ginfo
.name
== sym2
->ginfo
.name
);
1579 /* Initialize a partial symbol bcache. */
1581 struct psymbol_bcache
*
1582 psymbol_bcache_init (void)
1584 struct psymbol_bcache
*bcache
= XCNEW (struct psymbol_bcache
);
1586 bcache
->bcache
= bcache_xmalloc (psymbol_hash
, psymbol_compare
);
1590 /* Free a partial symbol bcache. */
1593 psymbol_bcache_free (struct psymbol_bcache
*bcache
)
1598 bcache_xfree (bcache
->bcache
);
1602 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1605 psymbol_bcache_get_bcache (struct psymbol_bcache
*bcache
)
1607 return bcache
->bcache
;
1610 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1611 symbol before, add a copy to BCACHE. In either case, return a pointer
1612 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1613 1 in case of new entry or 0 if returning an old entry. */
1615 static struct partial_symbol
*
1616 psymbol_bcache_full (struct partial_symbol
*sym
,
1617 struct psymbol_bcache
*bcache
,
1620 return ((struct partial_symbol
*)
1621 bcache_full (sym
, sizeof (struct partial_symbol
), bcache
->bcache
,
1625 /* Helper function, initialises partial symbol structure and stashes
1626 it into objfile's bcache. Note that our caching mechanism will
1627 use all fields of struct partial_symbol to determine hash value of the
1628 structure. In other words, having two symbols with the same name but
1629 different domain (or address) is possible and correct. */
1631 static struct partial_symbol
*
1632 add_psymbol_to_bcache (const char *name
, int namelength
, int copy_name
,
1634 enum address_class theclass
,
1636 enum language language
, struct objfile
*objfile
,
1639 struct partial_symbol psymbol
;
1641 /* We must ensure that the entire struct has been zeroed before
1642 assigning to it, because an assignment may not touch some of the
1644 memset (&psymbol
, 0, sizeof (psymbol
));
1646 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
1647 SYMBOL_SECTION (&psymbol
) = -1;
1648 SYMBOL_SET_LANGUAGE (&psymbol
, language
, &objfile
->objfile_obstack
);
1649 PSYMBOL_DOMAIN (&psymbol
) = domain
;
1650 PSYMBOL_CLASS (&psymbol
) = theclass
;
1652 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
1654 /* Stash the partial symbol away in the cache. */
1655 return psymbol_bcache_full (&psymbol
, objfile
->psymbol_cache
, added
);
1658 /* Helper function, adds partial symbol to the given partial symbol list. */
1661 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1662 struct partial_symbol
*psym
,
1663 struct objfile
*objfile
)
1665 list
->push_back (psym
);
1666 OBJSTAT (objfile
, n_psyms
++);
1669 /* Add a symbol with a long value to a psymtab.
1670 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1671 The only value we need to store for psyms is an address.
1672 For all other psyms pass zero for COREADDR.
1673 Return the partial symbol that has been added. */
1676 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1678 enum address_class theclass
,
1679 std::vector
<partial_symbol
*> *list
,
1681 enum language language
, struct objfile
*objfile
)
1683 struct partial_symbol
*psym
;
1687 /* Stash the partial symbol away in the cache. */
1688 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, theclass
,
1689 coreaddr
, language
, objfile
, &added
);
1691 /* Do not duplicate global partial symbols. */
1692 if (list
== &objfile
->global_psymbols
1696 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1697 append_psymbol_to_list (list
, psym
, objfile
);
1700 /* Initialize storage for partial symbols. */
1703 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1705 /* Free any previously allocated psymbol lists. */
1706 objfile
->global_psymbols
.clear ();
1707 objfile
->static_psymbols
.clear ();
1709 /* Current best guess is that approximately a twentieth
1710 of the total symbols (in a debugging file) are global or static
1711 oriented symbols, then multiply that by slop factor of two. */
1712 objfile
->global_psymbols
.reserve (total_symbols
/ 10);
1713 objfile
->static_psymbols
.reserve (total_symbols
/ 10);
1716 struct partial_symtab
*
1717 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1719 struct partial_symtab
*psymtab
;
1721 if (objfile
->free_psymtabs
)
1723 psymtab
= objfile
->free_psymtabs
;
1724 objfile
->free_psymtabs
= psymtab
->next
;
1727 psymtab
= (struct partial_symtab
*)
1728 obstack_alloc (&objfile
->objfile_obstack
,
1729 sizeof (struct partial_symtab
));
1731 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1733 = (const char *) bcache (filename
, strlen (filename
) + 1,
1734 objfile
->per_bfd
->filename_cache
);
1735 psymtab
->compunit_symtab
= NULL
;
1737 /* Prepend it to the psymtab list for the objfile it belongs to.
1738 Psymtabs are searched in most recent inserted -> least recent
1741 psymtab
->next
= objfile
->psymtabs
;
1742 objfile
->psymtabs
= psymtab
;
1744 if (symtab_create_debug
)
1746 /* Be a bit clever with debugging messages, and don't print objfile
1747 every time, only when it changes. */
1748 static char *last_objfile_name
= NULL
;
1750 if (last_objfile_name
== NULL
1751 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1753 xfree (last_objfile_name
);
1754 last_objfile_name
= xstrdup (objfile_name (objfile
));
1755 fprintf_unfiltered (gdb_stdlog
,
1756 "Creating one or more psymtabs for objfile %s ...\n",
1759 fprintf_unfiltered (gdb_stdlog
,
1760 "Created psymtab %s for module %s.\n",
1761 host_address_to_string (psymtab
), filename
);
1768 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1770 struct partial_symtab
**prev_pst
;
1773 Empty psymtabs happen as a result of header files which don't
1774 have any symbols in them. There can be a lot of them. But this
1775 check is wrong, in that a psymtab with N_SLINE entries but
1776 nothing else is not empty, but we don't realize that. Fixing
1777 that without slowing things down might be tricky. */
1779 /* First, snip it out of the psymtab chain. */
1781 prev_pst
= &(objfile
->psymtabs
);
1782 while ((*prev_pst
) != pst
)
1783 prev_pst
= &((*prev_pst
)->next
);
1784 (*prev_pst
) = pst
->next
;
1786 /* Next, put it on a free list for recycling. */
1788 pst
->next
= objfile
->free_psymtabs
;
1789 objfile
->free_psymtabs
= pst
;
1794 /* We need to pass a couple of items to the addrmap_foreach function,
1797 struct dump_psymtab_addrmap_data
1799 struct objfile
*objfile
;
1800 struct partial_symtab
*psymtab
;
1801 struct ui_file
*outfile
;
1803 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1804 If so, we want to print the next one as well (since the next addrmap
1805 entry defines the end of the range). */
1806 int previous_matched
;
1809 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1812 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1814 struct dump_psymtab_addrmap_data
*data
1815 = (struct dump_psymtab_addrmap_data
*) datap
;
1816 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1817 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1818 const char *psymtab_address_or_end
= NULL
;
1822 if (data
->psymtab
== NULL
1823 || data
->psymtab
== addrmap_psymtab
)
1824 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1825 else if (data
->previous_matched
)
1826 psymtab_address_or_end
= "<ends here>";
1828 if (data
->psymtab
== NULL
1829 || data
->psymtab
== addrmap_psymtab
1830 || data
->previous_matched
)
1832 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1833 data
->psymtab
!= NULL
? " " : "",
1834 paddress (gdbarch
, start_addr
),
1835 psymtab_address_or_end
);
1838 data
->previous_matched
= (data
->psymtab
== NULL
1839 || data
->psymtab
== addrmap_psymtab
);
1844 /* Helper function for maintenance_print_psymbols to print the addrmap
1845 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1848 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1849 struct ui_file
*outfile
)
1851 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1853 if ((psymtab
== NULL
1854 || psymtab
->psymtabs_addrmap_supported
)
1855 && objfile
->psymtabs_addrmap
!= NULL
)
1857 addrmap_dump_data
.objfile
= objfile
;
1858 addrmap_dump_data
.psymtab
= psymtab
;
1859 addrmap_dump_data
.outfile
= outfile
;
1860 addrmap_dump_data
.previous_matched
= 0;
1861 fprintf_filtered (outfile
, "%sddress map:\n",
1862 psymtab
== NULL
? "Entire a" : " A");
1863 addrmap_foreach (objfile
->psymtabs_addrmap
, dump_psymtab_addrmap_1
,
1864 &addrmap_dump_data
);
1869 maintenance_print_psymbols (const char *args
, int from_tty
)
1871 struct ui_file
*outfile
= gdb_stdout
;
1872 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1873 struct objfile
*objfile
;
1874 struct partial_symtab
*ps
;
1875 int i
, outfile_idx
, found
;
1877 struct obj_section
*section
= NULL
;
1881 gdb_argv
argv (args
);
1883 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1885 if (strcmp (argv
[i
], "-pc") == 0)
1887 if (argv
[i
+ 1] == NULL
)
1888 error (_("Missing pc value"));
1889 address_arg
= argv
[++i
];
1891 else if (strcmp (argv
[i
], "-source") == 0)
1893 if (argv
[i
+ 1] == NULL
)
1894 error (_("Missing source file"));
1895 source_arg
= argv
[++i
];
1897 else if (strcmp (argv
[i
], "-objfile") == 0)
1899 if (argv
[i
+ 1] == NULL
)
1900 error (_("Missing objfile name"));
1901 objfile_arg
= argv
[++i
];
1903 else if (strcmp (argv
[i
], "--") == 0)
1905 /* End of options. */
1909 else if (argv
[i
][0] == '-')
1911 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1912 error (_("Unknown option: %s"), argv
[i
]);
1919 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1920 error (_("Must specify at most one of -pc and -source"));
1922 stdio_file arg_outfile
;
1924 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1926 if (argv
[outfile_idx
+ 1] != NULL
)
1927 error (_("Junk at end of command"));
1928 gdb::unique_xmalloc_ptr
<char> outfile_name
1929 (tilde_expand (argv
[outfile_idx
]));
1930 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1931 perror_with_name (outfile_name
.get ());
1932 outfile
= &arg_outfile
;
1935 if (address_arg
!= NULL
)
1937 pc
= parse_and_eval_address (address_arg
);
1938 /* If we fail to find a section, that's ok, try the lookup anyway. */
1939 section
= find_pc_section (pc
);
1943 ALL_OBJFILES (objfile
)
1945 int printed_objfile_header
= 0;
1946 int print_for_objfile
= 1;
1949 if (objfile_arg
!= NULL
)
1951 = compare_filenames_for_search (objfile_name (objfile
),
1953 if (!print_for_objfile
)
1956 if (address_arg
!= NULL
)
1958 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1960 /* We don't assume each pc has a unique objfile (this is for
1962 ps
= find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1965 if (!printed_objfile_header
)
1967 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1968 objfile_name (objfile
));
1969 printed_objfile_header
= 1;
1971 dump_psymtab (objfile
, ps
, outfile
);
1972 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1978 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1980 int print_for_source
= 0;
1983 if (source_arg
!= NULL
)
1986 = compare_filenames_for_search (ps
->filename
, source_arg
);
1989 if (source_arg
== NULL
1990 || print_for_source
)
1992 if (!printed_objfile_header
)
1994 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1995 objfile_name (objfile
));
1996 printed_objfile_header
= 1;
1998 dump_psymtab (objfile
, ps
, outfile
);
1999 dump_psymtab_addrmap (objfile
, ps
, outfile
);
2004 /* If we're printing all the objfile's symbols dump the full addrmap. */
2006 if (address_arg
== NULL
2007 && source_arg
== NULL
2008 && objfile
->psymtabs_addrmap
!= NULL
)
2010 outfile
->puts ("\n");
2011 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
2017 if (address_arg
!= NULL
)
2018 error (_("No partial symtab for address: %s"), address_arg
);
2019 if (source_arg
!= NULL
)
2020 error (_("No partial symtab for source file: %s"), source_arg
);
2024 /* List all the partial symbol tables whose names match REGEXP (optional). */
2027 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
2029 struct program_space
*pspace
;
2030 struct objfile
*objfile
;
2035 ALL_PSPACES (pspace
)
2036 ALL_PSPACE_OBJFILES (pspace
, objfile
)
2038 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2039 struct partial_symtab
*psymtab
;
2041 /* We don't want to print anything for this objfile until we
2042 actually find a symtab whose name matches. */
2043 int printed_objfile_start
= 0;
2045 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
2050 || re_exec (psymtab
->filename
))
2052 if (! printed_objfile_start
)
2054 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2056 printf_filtered ("((struct objfile *) %s)\n",
2057 host_address_to_string (objfile
));
2058 printed_objfile_start
= 1;
2061 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2063 printf_filtered ("((struct partial_symtab *) %s)\n",
2064 host_address_to_string (psymtab
));
2066 printf_filtered (" readin %s\n",
2067 psymtab
->readin
? "yes" : "no");
2068 printf_filtered (" fullname %s\n",
2070 ? psymtab
->fullname
: "(null)");
2071 printf_filtered (" text addresses ");
2072 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
),
2074 printf_filtered (" -- ");
2075 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
),
2077 printf_filtered ("\n");
2078 printf_filtered (" psymtabs_addrmap_supported %s\n",
2079 (psymtab
->psymtabs_addrmap_supported
2081 printf_filtered (" globals ");
2082 if (psymtab
->n_global_syms
)
2084 auto p
= &objfile
->global_psymbols
[psymtab
->globals_offset
];
2086 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2087 host_address_to_string (p
),
2088 psymtab
->n_global_syms
);
2091 printf_filtered ("(none)\n");
2092 printf_filtered (" statics ");
2093 if (psymtab
->n_static_syms
)
2095 auto p
= &objfile
->static_psymbols
[psymtab
->statics_offset
];
2097 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2098 host_address_to_string (p
),
2099 psymtab
->n_static_syms
);
2102 printf_filtered ("(none)\n");
2103 printf_filtered (" dependencies ");
2104 if (psymtab
->number_of_dependencies
)
2108 printf_filtered ("{\n");
2109 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2111 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2113 /* Note the string concatenation there --- no comma. */
2114 printf_filtered (" psymtab %s "
2115 "((struct partial_symtab *) %s)\n",
2117 host_address_to_string (dep
));
2119 printf_filtered (" }\n");
2122 printf_filtered ("(none)\n");
2123 printf_filtered (" }\n");
2127 if (printed_objfile_start
)
2128 printf_filtered ("}\n");
2132 /* Check consistency of currently expanded psymtabs vs symtabs. */
2135 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2138 struct compunit_symtab
*cust
= NULL
;
2139 struct partial_symtab
*ps
;
2140 const struct blockvector
*bv
;
2141 struct objfile
*objfile
;
2145 ALL_PSYMTABS (objfile
, ps
)
2147 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2149 /* We don't call psymtab_to_symtab here because that may cause symtab
2150 expansion. When debugging a problem it helps if checkers leave
2151 things unchanged. */
2152 cust
= ps
->compunit_symtab
;
2154 /* First do some checks that don't require the associated symtab. */
2155 if (ps
->texthigh
< ps
->textlow
)
2157 printf_filtered ("Psymtab ");
2158 puts_filtered (ps
->filename
);
2159 printf_filtered (" covers bad range ");
2160 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2161 printf_filtered (" - ");
2162 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2163 printf_filtered ("\n");
2167 /* Now do checks requiring the associated symtab. */
2170 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2171 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2172 partial_symbol
**psym
= &objfile
->static_psymbols
[ps
->statics_offset
];
2173 length
= ps
->n_static_syms
;
2176 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2177 SYMBOL_DOMAIN (*psym
));
2180 printf_filtered ("Static symbol `");
2181 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2182 printf_filtered ("' only found in ");
2183 puts_filtered (ps
->filename
);
2184 printf_filtered (" psymtab\n");
2188 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2189 psym
= &objfile
->global_psymbols
[ps
->globals_offset
];
2190 length
= ps
->n_global_syms
;
2193 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2194 SYMBOL_DOMAIN (*psym
));
2197 printf_filtered ("Global symbol `");
2198 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2199 printf_filtered ("' only found in ");
2200 puts_filtered (ps
->filename
);
2201 printf_filtered (" psymtab\n");
2205 if (ps
->texthigh
!= 0
2206 && (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
)))
2208 printf_filtered ("Psymtab ");
2209 puts_filtered (ps
->filename
);
2210 printf_filtered (" covers ");
2211 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2212 printf_filtered (" - ");
2213 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2214 printf_filtered (" but symtab covers only ");
2215 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2216 printf_filtered (" - ");
2217 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2218 printf_filtered ("\n");
2224 _initialize_psymtab (void)
2226 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2227 Print dump of current partial symbol definitions.\n\
2228 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2229 mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2230 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2231 or the terminal if OUTFILE is unspecified.\n\
2232 If ADDRESS is provided, dump only the file for that address.\n\
2233 If SOURCE is provided, dump only that file's symbols.\n\
2234 If OBJFILE is provided, dump only that file's minimal symbols."),
2235 &maintenanceprintlist
);
2237 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2238 List the partial symbol tables for all object files.\n\
2239 This does not include information about individual partial symbols,\n\
2240 just the symbol table structures themselves."),
2241 &maintenanceinfolist
);
2243 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2245 Check consistency of currently expanded psymtabs versus symtabs."),