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"
41 struct bcache
*bcache
;
44 static struct partial_symbol
*match_partial_symbol (struct objfile
*,
45 struct partial_symtab
*,
47 const char *, domain_enum
,
48 symbol_compare_ftype
*,
49 symbol_compare_ftype
*);
51 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
52 struct partial_symtab
*,
56 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
58 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
59 struct partial_symtab
*,
61 struct obj_section
*);
63 static void fixup_psymbol_section (struct partial_symbol
*psym
,
64 struct objfile
*objfile
);
66 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
67 struct partial_symtab
*pst
);
69 /* Ensure that the partial symbols for OBJFILE have been loaded. This
70 function always returns its argument, as a convenience. */
73 require_partial_symbols (struct objfile
*objfile
, int verbose
)
75 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
77 objfile
->flags
|= OBJF_PSYMTABS_READ
;
79 if (objfile
->sf
->sym_read_psymbols
)
83 printf_unfiltered (_("Reading symbols from %s..."),
84 objfile_name (objfile
));
85 gdb_flush (gdb_stdout
);
87 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
90 if (!objfile_has_symbols (objfile
))
93 printf_unfiltered (_("(no debugging symbols found)..."));
97 printf_unfiltered (_("done.\n"));
105 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
108 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
109 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
113 /* We want to make sure this file always requires psymtabs. */
115 #undef ALL_OBJFILE_PSYMTABS
117 /* Traverse all psymtabs in all objfiles. */
119 #define ALL_PSYMTABS(objfile, p) \
120 ALL_OBJFILES (objfile) \
121 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
123 /* Helper function for psym_map_symtabs_matching_filename that
124 expands the symtabs and calls the iterator. */
127 partial_map_expand_apply (struct objfile
*objfile
,
129 const char *real_path
,
130 struct partial_symtab
*pst
,
131 gdb::function_view
<bool (symtab
*)> callback
)
133 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
135 /* Shared psymtabs should never be seen here. Instead they should
136 be handled properly by the caller. */
137 gdb_assert (pst
->user
== NULL
);
139 /* Don't visit already-expanded psymtabs. */
143 /* This may expand more than one symtab, and we want to iterate over
145 psymtab_to_symtab (objfile
, pst
);
147 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
148 last_made
, callback
);
151 /* Psymtab version of map_symtabs_matching_filename. See its definition in
152 the definition of quick_symbol_functions in symfile.h. */
155 psym_map_symtabs_matching_filename
156 (struct objfile
*objfile
,
158 const char *real_path
,
159 gdb::function_view
<bool (symtab
*)> callback
)
161 struct partial_symtab
*pst
;
162 const char *name_basename
= lbasename (name
);
164 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
166 /* We can skip shared psymtabs here, because any file name will be
167 attached to the unshared psymtab. */
168 if (pst
->user
!= NULL
)
171 /* Anonymous psymtabs don't have a file name. */
175 if (compare_filenames_for_search (pst
->filename
, name
))
177 if (partial_map_expand_apply (objfile
, name
, real_path
,
183 /* Before we invoke realpath, which can get expensive when many
184 files are involved, do a quick comparison of the basenames. */
185 if (! basenames_may_differ
186 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
189 if (compare_filenames_for_search (psymtab_to_fullname (pst
), name
))
191 if (partial_map_expand_apply (objfile
, name
, real_path
,
197 /* If the user gave us an absolute path, try to find the file in
198 this symtab and use its absolute path. */
199 if (real_path
!= NULL
)
201 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
202 gdb_assert (IS_ABSOLUTE_PATH (name
));
203 if (filename_cmp (psymtab_to_fullname (pst
), real_path
) == 0)
205 if (partial_map_expand_apply (objfile
, name
, real_path
,
216 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
217 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
219 static struct partial_symtab
*
220 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
221 CORE_ADDR pc
, struct obj_section
*section
,
222 struct partial_symtab
*pst
,
223 struct bound_minimal_symbol msymbol
)
225 struct partial_symtab
*tpst
;
226 struct partial_symtab
*best_pst
= pst
;
227 CORE_ADDR best_addr
= pst
->textlow
;
229 gdb_assert (!pst
->psymtabs_addrmap_supported
);
231 /* An objfile that has its functions reordered might have
232 many partial symbol tables containing the PC, but
233 we want the partial symbol table that contains the
234 function containing the PC. */
235 if (!(objfile
->flags
& OBJF_REORDERED
)
236 && section
== NULL
) /* Can't validate section this way. */
239 if (msymbol
.minsym
== NULL
)
242 /* The code range of partial symtabs sometimes overlap, so, in
243 the loop below, we need to check all partial symtabs and
244 find the one that fits better for the given PC address. We
245 select the partial symtab that contains a symbol whose
246 address is closest to the PC address. By closest we mean
247 that find_pc_sect_symbol returns the symbol with address
248 that is closest and still less than the given PC. */
249 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
251 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
253 struct partial_symbol
*p
;
256 /* NOTE: This assumes that every psymbol has a
257 corresponding msymbol, which is not necessarily
258 true; the debug info might be much richer than the
259 object's symbol table. */
260 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
262 && (SYMBOL_VALUE_ADDRESS (p
)
263 == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
266 /* Also accept the textlow value of a psymtab as a
267 "symbol", to provide some support for partial
268 symbol tables with line information but no debug
269 symbols (e.g. those produced by an assembler). */
271 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
273 this_addr
= tpst
->textlow
;
275 /* Check whether it is closer than our current
276 BEST_ADDR. Since this symbol address is
277 necessarily lower or equal to PC, the symbol closer
278 to PC is the symbol which address is the highest.
279 This way we return the psymtab which contains such
280 best match symbol. This can help in cases where the
281 symbol information/debuginfo is not complete, like
282 for instance on IRIX6 with gcc, where no debug info
283 is emitted for statics. (See also the nodebug.exp
285 if (this_addr
> best_addr
)
287 best_addr
= this_addr
;
295 /* Find which partial symtab contains PC and SECTION. Return NULL if
296 none. We return the psymtab that contains a symbol whose address
297 exactly matches PC, or, if we cannot find an exact match, the
298 psymtab that contains a symbol whose address is closest to PC. */
300 static struct partial_symtab
*
301 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
302 struct obj_section
*section
,
303 struct bound_minimal_symbol msymbol
)
305 struct partial_symtab
*pst
;
307 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
308 than the later used TEXTLOW/TEXTHIGH one. */
310 if (objfile
->psymtabs_addrmap
!= NULL
)
312 pst
= ((struct partial_symtab
*)
313 addrmap_find (objfile
->psymtabs_addrmap
, pc
));
316 /* FIXME: addrmaps currently do not handle overlayed sections,
317 so fall back to the non-addrmap case if we're debugging
318 overlays and the addrmap returned the wrong section. */
319 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
321 struct partial_symbol
*p
;
323 /* NOTE: This assumes that every psymbol has a
324 corresponding msymbol, which is not necessarily
325 true; the debug info might be much richer than the
326 object's symbol table. */
327 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
329 || (SYMBOL_VALUE_ADDRESS (p
)
330 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
334 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
335 PSYMTABS_ADDRMAP we used has already the best 1-byte
336 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
337 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
346 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
347 which still have no corresponding full SYMTABs read. But it is not
348 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
351 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
352 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
353 debug info type in single OBJFILE. */
355 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
356 if (!pst
->psymtabs_addrmap_supported
357 && pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
359 struct partial_symtab
*best_pst
;
361 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
363 if (best_pst
!= NULL
)
370 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
371 the definition of quick_symbol_functions in symfile.h. */
373 static struct compunit_symtab
*
374 psym_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
375 struct bound_minimal_symbol msymbol
,
377 struct obj_section
*section
,
380 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
384 if (warn_if_readin
&& ps
->readin
)
385 /* Might want to error() here (in case symtab is corrupt and
386 will cause a core dump), but maybe we can successfully
387 continue, so let's not. */
389 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
390 paddress (get_objfile_arch (objfile
), pc
));
391 psymtab_to_symtab (objfile
, ps
);
392 return ps
->compunit_symtab
;
397 /* Find which partial symbol within a psymtab matches PC and SECTION.
398 Return NULL if none. */
400 static struct partial_symbol
*
401 find_pc_sect_psymbol (struct objfile
*objfile
,
402 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
403 struct obj_section
*section
)
405 struct partial_symbol
*best
= NULL
, *p
, **pp
;
408 gdb_assert (psymtab
!= NULL
);
410 /* Cope with programs that start at address 0. */
411 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
413 /* Search the global symbols as well as the static symbols, so that
414 find_pc_partial_function doesn't use a minimal symbol and thus
415 cache a bad endaddr. */
416 for (pp
= objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
417 (pp
- (objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
418 < psymtab
->n_global_syms
);
422 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
423 && PSYMBOL_CLASS (p
) == LOC_BLOCK
424 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
425 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
426 || (psymtab
->textlow
== 0
427 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
429 if (section
!= NULL
) /* Match on a specific section. */
431 fixup_psymbol_section (p
, objfile
);
432 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, p
),
436 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
441 for (pp
= objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
442 (pp
- (objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
443 < psymtab
->n_static_syms
);
447 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
448 && PSYMBOL_CLASS (p
) == LOC_BLOCK
449 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
450 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
451 || (psymtab
->textlow
== 0
452 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
454 if (section
!= NULL
) /* Match on a specific section. */
456 fixup_psymbol_section (p
, objfile
);
457 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, p
),
461 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
470 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
477 if (SYMBOL_SECTION (psym
) >= 0)
480 gdb_assert (objfile
);
482 switch (PSYMBOL_CLASS (psym
))
487 addr
= SYMBOL_VALUE_ADDRESS (psym
);
490 /* Nothing else will be listed in the minsyms -- no use looking
495 fixup_section (&psym
->ginfo
, addr
, objfile
);
498 /* Psymtab version of lookup_symbol. See its definition in
499 the definition of quick_symbol_functions in symfile.h. */
501 static struct compunit_symtab
*
502 psym_lookup_symbol (struct objfile
*objfile
,
503 int block_index
, const char *name
,
504 const domain_enum domain
)
506 struct partial_symtab
*ps
;
507 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
508 struct compunit_symtab
*stab_best
= NULL
;
510 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
512 if (!ps
->readin
&& lookup_partial_symbol (objfile
, ps
, name
,
513 psymtab_index
, domain
))
515 struct symbol
*sym
, *with_opaque
= NULL
;
516 struct compunit_symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
517 /* Note: While psymtab_to_symtab can return NULL if the partial symtab
518 is empty, we can assume it won't here because lookup_partial_symbol
520 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
521 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
523 sym
= block_find_symbol (block
, name
, domain
,
524 block_find_non_opaque_type_preferred
,
527 /* Some caution must be observed with overloaded functions
528 and methods, since the index will not contain any overload
529 information (but NAME might contain it). */
532 && SYMBOL_MATCHES_SEARCH_NAME (sym
, name
))
534 if (with_opaque
!= NULL
535 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, name
))
538 /* Keep looking through other psymtabs. */
545 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
546 the global block of PST if GLOBAL, and otherwise the static block.
547 MATCH is the comparison operation that returns true iff MATCH (s,
548 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
549 non-null, the symbols in the block are assumed to be ordered
550 according to it (allowing binary search). It must be compatible
551 with MATCH. Returns the symbol, if found, and otherwise NULL. */
553 static struct partial_symbol
*
554 match_partial_symbol (struct objfile
*objfile
,
555 struct partial_symtab
*pst
, int global
,
556 const char *name
, domain_enum domain
,
557 symbol_compare_ftype
*match
,
558 symbol_compare_ftype
*ordered_compare
)
560 struct partial_symbol
**start
, **psym
;
561 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
562 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
563 int do_linear_search
= 1;
568 objfile
->global_psymbols
.list
+ pst
->globals_offset
:
569 objfile
->static_psymbols
.list
+ pst
->statics_offset
);
571 if (global
&& ordered_compare
) /* Can use a binary search. */
573 do_linear_search
= 0;
575 /* Binary search. This search is guaranteed to end with center
576 pointing at the earliest partial symbol whose name might be
577 correct. At that point *all* partial symbols with an
578 appropriate name will be checked against the correct
582 top
= start
+ length
- 1;
586 center
= bottom
+ (top
- bottom
) / 2;
587 gdb_assert (center
< top
);
588 if (ordered_compare (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
593 gdb_assert (top
== bottom
);
595 while (top
<= real_top
596 && match (SYMBOL_SEARCH_NAME (*top
), name
) == 0)
598 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
599 SYMBOL_DOMAIN (*top
), domain
))
605 /* Can't use a binary search or else we found during the binary search that
606 we should also do a linear search. */
608 if (do_linear_search
)
610 for (psym
= start
; psym
< start
+ length
; psym
++)
612 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
613 SYMBOL_DOMAIN (*psym
), domain
)
614 && match (SYMBOL_SEARCH_NAME (*psym
), name
) == 0)
622 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
623 not contain any method/function instance information (since this would
624 force reading type information while reading psymtabs). Therefore,
625 if NAME contains overload information, it must be stripped before searching
628 static gdb::unique_xmalloc_ptr
<char>
629 psymtab_search_name (const char *name
)
631 switch (current_language
->la_language
)
635 if (strchr (name
, '('))
637 gdb::unique_xmalloc_ptr
<char> ret
= cp_remove_params (name
);
649 return gdb::unique_xmalloc_ptr
<char> (xstrdup (name
));
652 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
653 Check the global symbols if GLOBAL, the static symbols if not. */
655 static struct partial_symbol
*
656 lookup_partial_symbol (struct objfile
*objfile
,
657 struct partial_symtab
*pst
, const char *name
,
658 int global
, domain_enum domain
)
660 struct partial_symbol
**start
, **psym
;
661 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
662 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
663 int do_linear_search
= 1;
668 gdb::unique_xmalloc_ptr
<char> search_name
= psymtab_search_name (name
);
670 objfile
->global_psymbols
.list
+ pst
->globals_offset
:
671 objfile
->static_psymbols
.list
+ pst
->statics_offset
);
673 if (global
) /* This means we can use a binary search. */
675 do_linear_search
= 0;
677 /* Binary search. This search is guaranteed to end with center
678 pointing at the earliest partial symbol whose name might be
679 correct. At that point *all* partial symbols with an
680 appropriate name will be checked against the correct
684 top
= start
+ length
- 1;
688 center
= bottom
+ (top
- bottom
) / 2;
690 internal_error (__FILE__
, __LINE__
,
691 _("failed internal consistency check"));
692 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
),
693 search_name
.get ()) >= 0)
702 if (!(top
== bottom
))
703 internal_error (__FILE__
, __LINE__
,
704 _("failed internal consistency check"));
706 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
707 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
708 while (top
>= start
&& SYMBOL_MATCHES_SEARCH_NAME (*top
,
712 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
715 while (top
<= real_top
716 && SYMBOL_MATCHES_SEARCH_NAME (*top
, search_name
.get ()))
718 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
719 SYMBOL_DOMAIN (*top
), domain
))
725 /* Can't use a binary search or else we found during the binary search that
726 we should also do a linear search. */
728 if (do_linear_search
)
730 for (psym
= start
; psym
< start
+ length
; psym
++)
732 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
733 SYMBOL_DOMAIN (*psym
), domain
)
734 && SYMBOL_MATCHES_SEARCH_NAME (*psym
, search_name
.get ()))
742 /* Get the symbol table that corresponds to a partial_symtab.
743 This is fast after the first time you do it.
744 The result will be NULL if the primary symtab has no symbols,
745 which can happen. Otherwise the result is the primary symtab
746 that contains PST. */
748 static struct compunit_symtab
*
749 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
751 /* If it is a shared psymtab, find an unshared psymtab that includes
752 it. Any such psymtab will do. */
753 while (pst
->user
!= NULL
)
756 /* If it's been looked up before, return it. */
757 if (pst
->compunit_symtab
)
758 return pst
->compunit_symtab
;
760 /* If it has not yet been read in, read it. */
763 scoped_restore decrementer
= increment_reading_symtab ();
765 (*pst
->read_symtab
) (pst
, objfile
);
768 return pst
->compunit_symtab
;
771 /* Psymtab version of relocate. See its definition in
772 the definition of quick_symbol_functions in symfile.h. */
775 psym_relocate (struct objfile
*objfile
,
776 const struct section_offsets
*new_offsets
,
777 const struct section_offsets
*delta
)
779 struct partial_symbol
**psym
;
780 struct partial_symtab
*p
;
782 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
784 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
785 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
788 for (psym
= objfile
->global_psymbols
.list
;
789 psym
< objfile
->global_psymbols
.next
;
792 fixup_psymbol_section (*psym
, objfile
);
793 if (SYMBOL_SECTION (*psym
) >= 0)
794 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
795 SYMBOL_SECTION (*psym
));
797 for (psym
= objfile
->static_psymbols
.list
;
798 psym
< objfile
->static_psymbols
.next
;
801 fixup_psymbol_section (*psym
, objfile
);
802 if (SYMBOL_SECTION (*psym
) >= 0)
803 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
804 SYMBOL_SECTION (*psym
));
808 /* Psymtab version of find_last_source_symtab. See its definition in
809 the definition of quick_symbol_functions in symfile.h. */
811 static struct symtab
*
812 psym_find_last_source_symtab (struct objfile
*ofp
)
814 struct partial_symtab
*ps
;
815 struct partial_symtab
*cs_pst
= NULL
;
817 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp
, ps
)
819 const char *name
= ps
->filename
;
820 int len
= strlen (name
);
822 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
823 || strcmp (name
, "<<C++-namespaces>>") == 0)))
831 internal_error (__FILE__
, __LINE__
,
832 _("select_source_symtab: "
833 "readin pst found and no symtabs."));
837 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
841 return compunit_primary_filetab (cust
);
847 /* Psymtab version of forget_cached_source_info. See its definition in
848 the definition of quick_symbol_functions in symfile.h. */
851 psym_forget_cached_source_info (struct objfile
*objfile
)
853 struct partial_symtab
*pst
;
855 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
857 if (pst
->fullname
!= NULL
)
859 xfree (pst
->fullname
);
860 pst
->fullname
= NULL
;
866 print_partial_symbols (struct gdbarch
*gdbarch
,
867 struct partial_symbol
**p
, int count
, const char *what
,
868 struct ui_file
*outfile
)
870 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
874 fprintf_filtered (outfile
, " `%s'", SYMBOL_LINKAGE_NAME (*p
));
875 if (SYMBOL_DEMANGLED_NAME (*p
) != NULL
)
877 fprintf_filtered (outfile
, " `%s'", SYMBOL_DEMANGLED_NAME (*p
));
879 fputs_filtered (", ", outfile
);
880 switch (SYMBOL_DOMAIN (*p
))
883 fputs_filtered ("undefined domain, ", outfile
);
886 /* This is the usual thing -- don't print it. */
889 fputs_filtered ("struct domain, ", outfile
);
892 fputs_filtered ("label domain, ", outfile
);
895 fputs_filtered ("<invalid domain>, ", outfile
);
898 switch (PSYMBOL_CLASS (*p
))
901 fputs_filtered ("undefined", outfile
);
904 fputs_filtered ("constant int", outfile
);
907 fputs_filtered ("static", outfile
);
910 fputs_filtered ("register", outfile
);
913 fputs_filtered ("pass by value", outfile
);
916 fputs_filtered ("pass by reference", outfile
);
918 case LOC_REGPARM_ADDR
:
919 fputs_filtered ("register address parameter", outfile
);
922 fputs_filtered ("stack parameter", outfile
);
925 fputs_filtered ("type", outfile
);
928 fputs_filtered ("label", outfile
);
931 fputs_filtered ("function", outfile
);
933 case LOC_CONST_BYTES
:
934 fputs_filtered ("constant bytes", outfile
);
937 fputs_filtered ("unresolved", outfile
);
939 case LOC_OPTIMIZED_OUT
:
940 fputs_filtered ("optimized out", outfile
);
943 fputs_filtered ("computed at runtime", outfile
);
946 fputs_filtered ("<invalid location>", outfile
);
949 fputs_filtered (", ", outfile
);
950 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (*p
)), outfile
);
951 fprintf_filtered (outfile
, "\n");
957 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
958 struct ui_file
*outfile
)
960 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
963 if (psymtab
->anonymous
)
965 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
970 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
973 fprintf_filtered (outfile
, "(object ");
974 gdb_print_host_address (psymtab
, outfile
);
975 fprintf_filtered (outfile
, ")\n\n");
976 fprintf_unfiltered (outfile
, " Read from object file %s (",
977 objfile_name (objfile
));
978 gdb_print_host_address (objfile
, outfile
);
979 fprintf_unfiltered (outfile
, ")\n");
983 fprintf_filtered (outfile
,
984 " Full symtab was read (at ");
985 gdb_print_host_address (psymtab
->compunit_symtab
, outfile
);
986 fprintf_filtered (outfile
, " by function at ");
987 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
988 fprintf_filtered (outfile
, ")\n");
991 fprintf_filtered (outfile
, " Symbols cover text addresses ");
992 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
), outfile
);
993 fprintf_filtered (outfile
, "-");
994 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
), outfile
);
995 fprintf_filtered (outfile
, "\n");
996 fprintf_filtered (outfile
, " Address map supported - %s.\n",
997 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
998 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
999 psymtab
->number_of_dependencies
);
1000 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1002 fprintf_filtered (outfile
, " %d ", i
);
1003 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
1004 fprintf_filtered (outfile
, " %s\n",
1005 psymtab
->dependencies
[i
]->filename
);
1007 if (psymtab
->user
!= NULL
)
1009 fprintf_filtered (outfile
, " Shared partial symtab with user ");
1010 gdb_print_host_address (psymtab
->user
, outfile
);
1011 fprintf_filtered (outfile
, "\n");
1013 if (psymtab
->n_global_syms
> 0)
1015 print_partial_symbols (gdbarch
,
1016 objfile
->global_psymbols
.list
1017 + psymtab
->globals_offset
,
1018 psymtab
->n_global_syms
, "Global", outfile
);
1020 if (psymtab
->n_static_syms
> 0)
1022 print_partial_symbols (gdbarch
,
1023 objfile
->static_psymbols
.list
1024 + psymtab
->statics_offset
,
1025 psymtab
->n_static_syms
, "Static", outfile
);
1027 fprintf_filtered (outfile
, "\n");
1030 /* Psymtab version of print_stats. See its definition in
1031 the definition of quick_symbol_functions in symfile.h. */
1034 psym_print_stats (struct objfile
*objfile
)
1037 struct partial_symtab
*ps
;
1040 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1042 if (ps
->readin
== 0)
1045 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1048 /* Psymtab version of dump. See its definition in
1049 the definition of quick_symbol_functions in symfile.h. */
1052 psym_dump (struct objfile
*objfile
)
1054 struct partial_symtab
*psymtab
;
1056 if (objfile
->psymtabs
)
1058 printf_filtered ("Psymtabs:\n");
1059 for (psymtab
= objfile
->psymtabs
;
1061 psymtab
= psymtab
->next
)
1063 printf_filtered ("%s at ",
1065 gdb_print_host_address (psymtab
, gdb_stdout
);
1066 printf_filtered (", ");
1069 printf_filtered ("\n\n");
1073 /* Psymtab version of expand_symtabs_for_function. See its definition in
1074 the definition of quick_symbol_functions in symfile.h. */
1077 psym_expand_symtabs_for_function (struct objfile
*objfile
,
1078 const char *func_name
)
1080 struct partial_symtab
*ps
;
1082 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1087 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1089 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1091 psymtab_to_symtab (objfile
, ps
);
1095 /* Psymtab version of expand_all_symtabs. See its definition in
1096 the definition of quick_symbol_functions in symfile.h. */
1099 psym_expand_all_symtabs (struct objfile
*objfile
)
1101 struct partial_symtab
*psymtab
;
1103 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
1105 psymtab_to_symtab (objfile
, psymtab
);
1109 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1110 the definition of quick_symbol_functions in symfile.h. */
1113 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1114 const char *fullname
)
1116 struct partial_symtab
*p
;
1118 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
1120 /* Anonymous psymtabs don't have a name of a source file. */
1124 /* psymtab_to_fullname tries to open the file which is slow.
1125 Don't call it if we know the basenames don't match. */
1126 if ((basenames_may_differ
1127 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1128 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1129 psymtab_to_symtab (objfile
, p
);
1133 /* Psymtab version of map_symbol_filenames. See its definition in
1134 the definition of quick_symbol_functions in symfile.h. */
1137 psym_map_symbol_filenames (struct objfile
*objfile
,
1138 symbol_filename_ftype
*fun
, void *data
,
1141 struct partial_symtab
*ps
;
1143 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1145 const char *fullname
;
1150 /* We can skip shared psymtabs here, because any file name will be
1151 attached to the unshared psymtab. */
1152 if (ps
->user
!= NULL
)
1155 /* Anonymous psymtabs don't have a file name. */
1161 fullname
= psymtab_to_fullname (ps
);
1164 (*fun
) (ps
->filename
, fullname
, data
);
1168 /* Finds the fullname that a partial_symtab represents.
1170 If this functions finds the fullname, it will save it in ps->fullname
1171 and it will also return the value.
1173 If this function fails to find the file that this partial_symtab represents,
1174 NULL will be returned and ps->fullname will be set to NULL. */
1177 psymtab_to_fullname (struct partial_symtab
*ps
)
1179 gdb_assert (!ps
->anonymous
);
1181 /* Use cached copy if we have it.
1182 We rely on forget_cached_source_info being called appropriately
1183 to handle cases like the file being moved. */
1184 if (ps
->fullname
== NULL
)
1186 int fd
= find_and_open_source (ps
->filename
, ps
->dirname
, &ps
->fullname
);
1192 gdb::unique_xmalloc_ptr
<char> fullname
;
1194 /* rewrite_source_path would be applied by find_and_open_source, we
1195 should report the pathname where GDB tried to find the file. */
1197 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
1198 fullname
.reset (xstrdup (ps
->filename
));
1200 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
1201 ps
->filename
, (char *) NULL
));
1203 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1204 if (ps
->fullname
== NULL
)
1205 ps
->fullname
= fullname
.release ();
1209 return ps
->fullname
;
1212 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1213 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1214 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1215 ever returns non-zero, and otherwise returns 0. */
1218 map_block (const char *name
, domain_enum domain
, struct objfile
*objfile
,
1219 struct block
*block
,
1220 int (*callback
) (struct block
*, struct symbol
*, void *),
1221 void *data
, symbol_compare_ftype
*match
)
1223 struct block_iterator iter
;
1226 for (sym
= block_iter_match_first (block
, name
, match
, &iter
);
1227 sym
!= NULL
; sym
= block_iter_match_next (name
, match
, &iter
))
1229 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1230 SYMBOL_DOMAIN (sym
), domain
))
1232 if (callback (block
, sym
, data
))
1240 /* Psymtab version of map_matching_symbols. See its definition in
1241 the definition of quick_symbol_functions in symfile.h. */
1244 psym_map_matching_symbols (struct objfile
*objfile
,
1245 const char *name
, domain_enum domain
,
1247 int (*callback
) (struct block
*,
1248 struct symbol
*, void *),
1250 symbol_compare_ftype
*match
,
1251 symbol_compare_ftype
*ordered_compare
)
1253 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1254 struct partial_symtab
*ps
;
1256 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1260 || match_partial_symbol (objfile
, ps
, global
, name
, domain
, match
,
1263 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1264 struct block
*block
;
1268 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1269 if (map_block (name
, domain
, objfile
, block
,
1270 callback
, data
, match
))
1272 if (callback (block
, NULL
, data
))
1278 /* A helper for psym_expand_symtabs_matching that handles searching
1279 included psymtabs. This returns true if a symbol is found, and
1280 false otherwise. It also updates the 'searched_flag' on the
1281 various psymtabs that it searches. */
1284 recursively_search_psymtabs
1285 (struct partial_symtab
*ps
, struct objfile
*objfile
, enum search_domain kind
,
1286 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1288 struct partial_symbol
**psym
;
1289 struct partial_symbol
**bound
, **gbound
, **sbound
;
1291 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1294 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1295 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1297 /* Recurse into shared psymtabs first, because they may have already
1298 been searched, and this could save some time. */
1299 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1303 /* Skip non-shared dependencies, these are handled elsewhere. */
1304 if (ps
->dependencies
[i
]->user
== NULL
)
1307 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1308 objfile
, kind
, sym_matcher
);
1311 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1316 gbound
= (objfile
->global_psymbols
.list
1317 + ps
->globals_offset
+ ps
->n_global_syms
);
1318 sbound
= (objfile
->static_psymbols
.list
1319 + ps
->statics_offset
+ ps
->n_static_syms
);
1322 /* Go through all of the symbols stored in a partial
1323 symtab in one loop. */
1324 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
1329 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1331 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
1342 if ((kind
== ALL_DOMAIN
1343 || (kind
== VARIABLES_DOMAIN
1344 && PSYMBOL_CLASS (*psym
) != LOC_TYPEDEF
1345 && PSYMBOL_CLASS (*psym
) != LOC_BLOCK
)
1346 || (kind
== FUNCTIONS_DOMAIN
1347 && PSYMBOL_CLASS (*psym
) == LOC_BLOCK
)
1348 || (kind
== TYPES_DOMAIN
1349 && PSYMBOL_CLASS (*psym
) == LOC_TYPEDEF
))
1350 && sym_matcher (SYMBOL_SEARCH_NAME (*psym
)))
1352 /* Found a match, so notify our caller. */
1353 result
= PST_SEARCHED_AND_FOUND
;
1360 ps
->searched_flag
= result
;
1361 return result
== PST_SEARCHED_AND_FOUND
;
1364 /* Psymtab version of expand_symtabs_matching. See its definition in
1365 the definition of quick_symbol_functions in symfile.h. */
1368 psym_expand_symtabs_matching
1369 (struct objfile
*objfile
,
1370 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1371 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1372 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1373 enum search_domain kind
)
1375 struct partial_symtab
*ps
;
1377 /* Clear the search flags. */
1378 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1380 ps
->searched_flag
= PST_NOT_SEARCHED
;
1383 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1390 /* We skip shared psymtabs because file-matching doesn't apply
1391 to them; but we search them later in the loop. */
1392 if (ps
->user
!= NULL
)
1402 match
= file_matcher (ps
->filename
, false);
1405 /* Before we invoke realpath, which can get expensive when many
1406 files are involved, do a quick comparison of the basenames. */
1407 if (basenames_may_differ
1408 || file_matcher (lbasename (ps
->filename
), true))
1409 match
= file_matcher (psymtab_to_fullname (ps
), false);
1415 if (recursively_search_psymtabs (ps
, objfile
, kind
, symbol_matcher
))
1417 struct compunit_symtab
*symtab
=
1418 psymtab_to_symtab (objfile
, ps
);
1420 if (expansion_notify
!= NULL
)
1421 expansion_notify (symtab
);
1426 /* Psymtab version of has_symbols. See its definition in
1427 the definition of quick_symbol_functions in symfile.h. */
1430 psym_has_symbols (struct objfile
*objfile
)
1432 return objfile
->psymtabs
!= NULL
;
1435 const struct quick_symbol_functions psym_functions
=
1438 psym_find_last_source_symtab
,
1439 psym_forget_cached_source_info
,
1440 psym_map_symtabs_matching_filename
,
1445 psym_expand_symtabs_for_function
,
1446 psym_expand_all_symtabs
,
1447 psym_expand_symtabs_with_fullname
,
1448 psym_map_matching_symbols
,
1449 psym_expand_symtabs_matching
,
1450 psym_find_pc_sect_compunit_symtab
,
1451 psym_map_symbol_filenames
1456 /* This compares two partial symbols by names, using strcmp_iw_ordered
1457 for the comparison. */
1460 compare_psymbols (const void *s1p
, const void *s2p
)
1462 struct partial_symbol
*const *s1
= (struct partial_symbol
* const*) s1p
;
1463 struct partial_symbol
*const *s2
= (struct partial_symbol
* const*) s2p
;
1465 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
1466 SYMBOL_SEARCH_NAME (*s2
));
1470 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1472 /* Sort the global list; don't sort the static list. */
1474 qsort (objfile
->global_psymbols
.list
+ pst
->globals_offset
,
1475 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
1479 /* Allocate and partially fill a partial symtab. It will be
1480 completely filled at the end of the symbol list.
1482 FILENAME is the name of the symbol-file we are reading from. */
1484 struct partial_symtab
*
1485 start_psymtab_common (struct objfile
*objfile
,
1486 const char *filename
,
1487 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
1488 struct partial_symbol
**static_syms
)
1490 struct partial_symtab
*psymtab
;
1492 psymtab
= allocate_psymtab (filename
, objfile
);
1493 psymtab
->textlow
= textlow
;
1494 psymtab
->texthigh
= psymtab
->textlow
; /* default */
1495 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
1496 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
1500 /* Perform "finishing up" operations of a partial symtab. */
1503 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1506 = objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
1507 + pst
->globals_offset
);
1509 = objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
1510 + pst
->statics_offset
);
1512 sort_pst_symbols (objfile
, pst
);
1515 /* Calculate a hash code for the given partial symbol. The hash is
1516 calculated using the symbol's value, language, domain, class
1517 and name. These are the values which are set by
1518 add_psymbol_to_bcache. */
1520 static unsigned long
1521 psymbol_hash (const void *addr
, int length
)
1523 unsigned long h
= 0;
1524 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1525 unsigned int lang
= psymbol
->ginfo
.language
;
1526 unsigned int domain
= PSYMBOL_DOMAIN (psymbol
);
1527 unsigned int theclass
= PSYMBOL_CLASS (psymbol
);
1529 h
= hash_continue (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1530 h
= hash_continue (&lang
, sizeof (unsigned int), h
);
1531 h
= hash_continue (&domain
, sizeof (unsigned int), h
);
1532 h
= hash_continue (&theclass
, sizeof (unsigned int), h
);
1533 h
= hash_continue (psymbol
->ginfo
.name
, strlen (psymbol
->ginfo
.name
), h
);
1538 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1539 For the comparison this function uses a symbols value,
1540 language, domain, class and name. */
1543 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1545 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1546 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1548 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1549 sizeof (sym1
->ginfo
.value
)) == 0
1550 && sym1
->ginfo
.language
== sym2
->ginfo
.language
1551 && PSYMBOL_DOMAIN (sym1
) == PSYMBOL_DOMAIN (sym2
)
1552 && PSYMBOL_CLASS (sym1
) == PSYMBOL_CLASS (sym2
)
1553 && sym1
->ginfo
.name
== sym2
->ginfo
.name
);
1556 /* Initialize a partial symbol bcache. */
1558 struct psymbol_bcache
*
1559 psymbol_bcache_init (void)
1561 struct psymbol_bcache
*bcache
= XCNEW (struct psymbol_bcache
);
1563 bcache
->bcache
= bcache_xmalloc (psymbol_hash
, psymbol_compare
);
1567 /* Free a partial symbol bcache. */
1570 psymbol_bcache_free (struct psymbol_bcache
*bcache
)
1575 bcache_xfree (bcache
->bcache
);
1579 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1582 psymbol_bcache_get_bcache (struct psymbol_bcache
*bcache
)
1584 return bcache
->bcache
;
1587 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1588 symbol before, add a copy to BCACHE. In either case, return a pointer
1589 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1590 1 in case of new entry or 0 if returning an old entry. */
1592 static const struct partial_symbol
*
1593 psymbol_bcache_full (struct partial_symbol
*sym
,
1594 struct psymbol_bcache
*bcache
,
1597 return ((const struct partial_symbol
*)
1598 bcache_full (sym
, sizeof (struct partial_symbol
), bcache
->bcache
,
1602 /* Helper function, initialises partial symbol structure and stashes
1603 it into objfile's bcache. Note that our caching mechanism will
1604 use all fields of struct partial_symbol to determine hash value of the
1605 structure. In other words, having two symbols with the same name but
1606 different domain (or address) is possible and correct. */
1608 static const struct partial_symbol
*
1609 add_psymbol_to_bcache (const char *name
, int namelength
, int copy_name
,
1611 enum address_class theclass
,
1613 enum language language
, struct objfile
*objfile
,
1616 struct partial_symbol psymbol
;
1618 /* We must ensure that the entire struct has been zeroed before
1619 assigning to it, because an assignment may not touch some of the
1621 memset (&psymbol
, 0, sizeof (psymbol
));
1623 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
1624 SYMBOL_SECTION (&psymbol
) = -1;
1625 SYMBOL_SET_LANGUAGE (&psymbol
, language
, &objfile
->objfile_obstack
);
1626 PSYMBOL_DOMAIN (&psymbol
) = domain
;
1627 PSYMBOL_CLASS (&psymbol
) = theclass
;
1629 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
1631 /* Stash the partial symbol away in the cache. */
1632 return psymbol_bcache_full (&psymbol
, objfile
->psymbol_cache
, added
);
1635 /* Increase the space allocated for LISTP, which is probably
1636 global_psymbols or static_psymbols. This space will eventually
1637 be freed in free_objfile(). */
1640 extend_psymbol_list (struct psymbol_allocation_list
*listp
,
1641 struct objfile
*objfile
)
1645 if (listp
->size
== 0)
1648 listp
->list
= XNEWVEC (struct partial_symbol
*, new_size
);
1652 new_size
= listp
->size
* 2;
1653 listp
->list
= (struct partial_symbol
**)
1654 xrealloc ((char *) listp
->list
,
1655 new_size
* sizeof (struct partial_symbol
*));
1657 /* Next assumes we only went one over. Should be good if
1658 program works correctly. */
1659 listp
->next
= listp
->list
+ listp
->size
;
1660 listp
->size
= new_size
;
1663 /* Helper function, adds partial symbol to the given partial symbol list. */
1666 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
1667 const struct partial_symbol
*psym
,
1668 struct objfile
*objfile
)
1670 if (list
->next
>= list
->list
+ list
->size
)
1671 extend_psymbol_list (list
, objfile
);
1672 *list
->next
++ = (struct partial_symbol
*) psym
;
1673 OBJSTAT (objfile
, n_psyms
++);
1676 /* Add a symbol with a long value to a psymtab.
1677 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1678 The only value we need to store for psyms is an address.
1679 For all other psyms pass zero for COREADDR.
1680 Return the partial symbol that has been added. */
1683 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1685 enum address_class theclass
,
1686 struct psymbol_allocation_list
*list
,
1688 enum language language
, struct objfile
*objfile
)
1690 const struct partial_symbol
*psym
;
1694 /* Stash the partial symbol away in the cache. */
1695 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, theclass
,
1696 coreaddr
, language
, objfile
, &added
);
1698 /* Do not duplicate global partial symbols. */
1699 if (list
== &objfile
->global_psymbols
1703 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1704 append_psymbol_to_list (list
, psym
, objfile
);
1707 /* Initialize storage for partial symbols. */
1710 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1712 /* Free any previously allocated psymbol lists. */
1714 if (objfile
->global_psymbols
.list
)
1715 xfree (objfile
->global_psymbols
.list
);
1716 if (objfile
->static_psymbols
.list
)
1717 xfree (objfile
->static_psymbols
.list
);
1719 /* Current best guess is that approximately a twentieth
1720 of the total symbols (in a debugging file) are global or static
1721 oriented symbols, then multiply that by slop factor of two. */
1723 objfile
->global_psymbols
.size
= total_symbols
/ 10;
1724 objfile
->static_psymbols
.size
= total_symbols
/ 10;
1726 if (objfile
->global_psymbols
.size
> 0)
1728 objfile
->global_psymbols
.next
=
1729 objfile
->global_psymbols
.list
=
1730 XNEWVEC (struct partial_symbol
*, objfile
->global_psymbols
.size
);
1732 if (objfile
->static_psymbols
.size
> 0)
1734 objfile
->static_psymbols
.next
=
1735 objfile
->static_psymbols
.list
=
1736 XNEWVEC (struct partial_symbol
*, objfile
->static_psymbols
.size
);
1740 struct partial_symtab
*
1741 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1743 struct partial_symtab
*psymtab
;
1745 if (objfile
->free_psymtabs
)
1747 psymtab
= objfile
->free_psymtabs
;
1748 objfile
->free_psymtabs
= psymtab
->next
;
1751 psymtab
= (struct partial_symtab
*)
1752 obstack_alloc (&objfile
->objfile_obstack
,
1753 sizeof (struct partial_symtab
));
1755 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1757 = (const char *) bcache (filename
, strlen (filename
) + 1,
1758 objfile
->per_bfd
->filename_cache
);
1759 psymtab
->compunit_symtab
= NULL
;
1761 /* Prepend it to the psymtab list for the objfile it belongs to.
1762 Psymtabs are searched in most recent inserted -> least recent
1765 psymtab
->next
= objfile
->psymtabs
;
1766 objfile
->psymtabs
= psymtab
;
1768 if (symtab_create_debug
)
1770 /* Be a bit clever with debugging messages, and don't print objfile
1771 every time, only when it changes. */
1772 static char *last_objfile_name
= NULL
;
1774 if (last_objfile_name
== NULL
1775 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1777 xfree (last_objfile_name
);
1778 last_objfile_name
= xstrdup (objfile_name (objfile
));
1779 fprintf_unfiltered (gdb_stdlog
,
1780 "Creating one or more psymtabs for objfile %s ...\n",
1783 fprintf_unfiltered (gdb_stdlog
,
1784 "Created psymtab %s for module %s.\n",
1785 host_address_to_string (psymtab
), filename
);
1792 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1794 struct partial_symtab
**prev_pst
;
1797 Empty psymtabs happen as a result of header files which don't
1798 have any symbols in them. There can be a lot of them. But this
1799 check is wrong, in that a psymtab with N_SLINE entries but
1800 nothing else is not empty, but we don't realize that. Fixing
1801 that without slowing things down might be tricky. */
1803 /* First, snip it out of the psymtab chain. */
1805 prev_pst
= &(objfile
->psymtabs
);
1806 while ((*prev_pst
) != pst
)
1807 prev_pst
= &((*prev_pst
)->next
);
1808 (*prev_pst
) = pst
->next
;
1810 /* Next, put it on a free list for recycling. */
1812 pst
->next
= objfile
->free_psymtabs
;
1813 objfile
->free_psymtabs
= pst
;
1818 /* We need to pass a couple of items to the addrmap_foreach function,
1821 struct dump_psymtab_addrmap_data
1823 struct objfile
*objfile
;
1824 struct partial_symtab
*psymtab
;
1825 struct ui_file
*outfile
;
1827 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1828 If so, we want to print the next one as well (since the next addrmap
1829 entry defines the end of the range). */
1830 int previous_matched
;
1833 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1836 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1838 struct dump_psymtab_addrmap_data
*data
1839 = (struct dump_psymtab_addrmap_data
*) datap
;
1840 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1841 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1842 const char *psymtab_address_or_end
= NULL
;
1846 if (data
->psymtab
== NULL
1847 || data
->psymtab
== addrmap_psymtab
)
1848 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1849 else if (data
->previous_matched
)
1850 psymtab_address_or_end
= "<ends here>";
1852 if (data
->psymtab
== NULL
1853 || data
->psymtab
== addrmap_psymtab
1854 || data
->previous_matched
)
1856 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1857 data
->psymtab
!= NULL
? " " : "",
1858 paddress (gdbarch
, start_addr
),
1859 psymtab_address_or_end
);
1862 data
->previous_matched
= (data
->psymtab
== NULL
1863 || data
->psymtab
== addrmap_psymtab
);
1868 /* Helper function for maintenance_print_psymbols to print the addrmap
1869 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1872 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1873 struct ui_file
*outfile
)
1875 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1877 if ((psymtab
== NULL
1878 || psymtab
->psymtabs_addrmap_supported
)
1879 && objfile
->psymtabs_addrmap
!= NULL
)
1881 addrmap_dump_data
.objfile
= objfile
;
1882 addrmap_dump_data
.psymtab
= psymtab
;
1883 addrmap_dump_data
.outfile
= outfile
;
1884 addrmap_dump_data
.previous_matched
= 0;
1885 fprintf_filtered (outfile
, "%sddress map:\n",
1886 psymtab
== NULL
? "Entire a" : " A");
1887 addrmap_foreach (objfile
->psymtabs_addrmap
, dump_psymtab_addrmap_1
,
1888 &addrmap_dump_data
);
1893 maintenance_print_psymbols (const char *args
, int from_tty
)
1895 struct ui_file
*outfile
= gdb_stdout
;
1896 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1897 struct objfile
*objfile
;
1898 struct partial_symtab
*ps
;
1899 int i
, outfile_idx
, found
;
1901 struct obj_section
*section
= NULL
;
1905 gdb_argv
argv (args
);
1907 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1909 if (strcmp (argv
[i
], "-pc") == 0)
1911 if (argv
[i
+ 1] == NULL
)
1912 error (_("Missing pc value"));
1913 address_arg
= argv
[++i
];
1915 else if (strcmp (argv
[i
], "-source") == 0)
1917 if (argv
[i
+ 1] == NULL
)
1918 error (_("Missing source file"));
1919 source_arg
= argv
[++i
];
1921 else if (strcmp (argv
[i
], "-objfile") == 0)
1923 if (argv
[i
+ 1] == NULL
)
1924 error (_("Missing objfile name"));
1925 objfile_arg
= argv
[++i
];
1927 else if (strcmp (argv
[i
], "--") == 0)
1929 /* End of options. */
1933 else if (argv
[i
][0] == '-')
1935 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1936 error (_("Unknown option: %s"), argv
[i
]);
1943 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1944 error (_("Must specify at most one of -pc and -source"));
1946 stdio_file arg_outfile
;
1948 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1950 if (argv
[outfile_idx
+ 1] != NULL
)
1951 error (_("Junk at end of command"));
1952 gdb::unique_xmalloc_ptr
<char> outfile_name
1953 (tilde_expand (argv
[outfile_idx
]));
1954 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1955 perror_with_name (outfile_name
.get ());
1956 outfile
= &arg_outfile
;
1959 if (address_arg
!= NULL
)
1961 pc
= parse_and_eval_address (address_arg
);
1962 /* If we fail to find a section, that's ok, try the lookup anyway. */
1963 section
= find_pc_section (pc
);
1967 ALL_OBJFILES (objfile
)
1969 int printed_objfile_header
= 0;
1970 int print_for_objfile
= 1;
1973 if (objfile_arg
!= NULL
)
1975 = compare_filenames_for_search (objfile_name (objfile
),
1977 if (!print_for_objfile
)
1980 if (address_arg
!= NULL
)
1982 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1984 /* We don't assume each pc has a unique objfile (this is for
1986 ps
= find_pc_sect_psymtab (objfile
, pc
, section
, msymbol
);
1989 if (!printed_objfile_header
)
1991 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1992 objfile_name (objfile
));
1993 printed_objfile_header
= 1;
1995 dump_psymtab (objfile
, ps
, outfile
);
1996 dump_psymtab_addrmap (objfile
, ps
, outfile
);
2002 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
2004 int print_for_source
= 0;
2007 if (source_arg
!= NULL
)
2010 = compare_filenames_for_search (ps
->filename
, source_arg
);
2013 if (source_arg
== NULL
2014 || print_for_source
)
2016 if (!printed_objfile_header
)
2018 outfile
->printf ("\nPartial symtabs for objfile %s\n",
2019 objfile_name (objfile
));
2020 printed_objfile_header
= 1;
2022 dump_psymtab (objfile
, ps
, outfile
);
2023 dump_psymtab_addrmap (objfile
, ps
, outfile
);
2028 /* If we're printing all the objfile's symbols dump the full addrmap. */
2030 if (address_arg
== NULL
2031 && source_arg
== NULL
2032 && objfile
->psymtabs_addrmap
!= NULL
)
2034 outfile
->puts ("\n");
2035 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
2041 if (address_arg
!= NULL
)
2042 error (_("No partial symtab for address: %s"), address_arg
);
2043 if (source_arg
!= NULL
)
2044 error (_("No partial symtab for source file: %s"), source_arg
);
2048 /* List all the partial symbol tables whose names match REGEXP (optional). */
2051 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
2053 struct program_space
*pspace
;
2054 struct objfile
*objfile
;
2059 ALL_PSPACES (pspace
)
2060 ALL_PSPACE_OBJFILES (pspace
, objfile
)
2062 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2063 struct partial_symtab
*psymtab
;
2065 /* We don't want to print anything for this objfile until we
2066 actually find a symtab whose name matches. */
2067 int printed_objfile_start
= 0;
2069 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
2074 || re_exec (psymtab
->filename
))
2076 if (! printed_objfile_start
)
2078 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2080 printf_filtered ("((struct objfile *) %s)\n",
2081 host_address_to_string (objfile
));
2082 printed_objfile_start
= 1;
2085 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2087 printf_filtered ("((struct partial_symtab *) %s)\n",
2088 host_address_to_string (psymtab
));
2090 printf_filtered (" readin %s\n",
2091 psymtab
->readin
? "yes" : "no");
2092 printf_filtered (" fullname %s\n",
2094 ? psymtab
->fullname
: "(null)");
2095 printf_filtered (" text addresses ");
2096 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
),
2098 printf_filtered (" -- ");
2099 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
),
2101 printf_filtered ("\n");
2102 printf_filtered (" psymtabs_addrmap_supported %s\n",
2103 (psymtab
->psymtabs_addrmap_supported
2105 printf_filtered (" globals ");
2106 if (psymtab
->n_global_syms
)
2108 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2109 host_address_to_string (objfile
->global_psymbols
.list
2110 + psymtab
->globals_offset
),
2111 psymtab
->n_global_syms
);
2114 printf_filtered ("(none)\n");
2115 printf_filtered (" statics ");
2116 if (psymtab
->n_static_syms
)
2118 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2119 host_address_to_string (objfile
->static_psymbols
.list
2120 + psymtab
->statics_offset
),
2121 psymtab
->n_static_syms
);
2124 printf_filtered ("(none)\n");
2125 printf_filtered (" dependencies ");
2126 if (psymtab
->number_of_dependencies
)
2130 printf_filtered ("{\n");
2131 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2133 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2135 /* Note the string concatenation there --- no comma. */
2136 printf_filtered (" psymtab %s "
2137 "((struct partial_symtab *) %s)\n",
2139 host_address_to_string (dep
));
2141 printf_filtered (" }\n");
2144 printf_filtered ("(none)\n");
2145 printf_filtered (" }\n");
2149 if (printed_objfile_start
)
2150 printf_filtered ("}\n");
2154 /* Check consistency of currently expanded psymtabs vs symtabs. */
2157 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2160 struct partial_symbol
**psym
;
2161 struct compunit_symtab
*cust
= NULL
;
2162 struct partial_symtab
*ps
;
2163 const struct blockvector
*bv
;
2164 struct objfile
*objfile
;
2168 ALL_PSYMTABS (objfile
, ps
)
2170 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2172 /* We don't call psymtab_to_symtab here because that may cause symtab
2173 expansion. When debugging a problem it helps if checkers leave
2174 things unchanged. */
2175 cust
= ps
->compunit_symtab
;
2177 /* First do some checks that don't require the associated symtab. */
2178 if (ps
->texthigh
< ps
->textlow
)
2180 printf_filtered ("Psymtab ");
2181 puts_filtered (ps
->filename
);
2182 printf_filtered (" covers bad range ");
2183 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2184 printf_filtered (" - ");
2185 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2186 printf_filtered ("\n");
2190 /* Now do checks requiring the associated symtab. */
2193 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2194 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2195 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2196 length
= ps
->n_static_syms
;
2199 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2200 SYMBOL_DOMAIN (*psym
));
2203 printf_filtered ("Static symbol `");
2204 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2205 printf_filtered ("' only found in ");
2206 puts_filtered (ps
->filename
);
2207 printf_filtered (" psymtab\n");
2211 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2212 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2213 length
= ps
->n_global_syms
;
2216 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2217 SYMBOL_DOMAIN (*psym
));
2220 printf_filtered ("Global symbol `");
2221 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2222 printf_filtered ("' only found in ");
2223 puts_filtered (ps
->filename
);
2224 printf_filtered (" psymtab\n");
2228 if (ps
->texthigh
!= 0
2229 && (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
)))
2231 printf_filtered ("Psymtab ");
2232 puts_filtered (ps
->filename
);
2233 printf_filtered (" covers ");
2234 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2235 printf_filtered (" - ");
2236 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2237 printf_filtered (" but symtab covers only ");
2238 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2239 printf_filtered (" - ");
2240 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2241 printf_filtered ("\n");
2247 _initialize_psymtab (void)
2249 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2250 Print dump of current partial symbol definitions.\n\
2251 Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\
2252 mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\
2253 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2254 or the terminal if OUTFILE is unspecified.\n\
2255 If ADDRESS is provided, dump only the file for that address.\n\
2256 If SOURCE is provided, dump only that file's symbols.\n\
2257 If OBJFILE is provided, dump only that file's minimal symbols."),
2258 &maintenanceprintlist
);
2260 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2261 List the partial symbol tables for all object files.\n\
2262 This does not include information about individual partial symbols,\n\
2263 just the symbol table structures themselves."),
2264 &maintenanceinfolist
);
2266 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2268 Check consistency of currently expanded psymtabs versus symtabs."),