1 /* Partial symbol tables.
3 Copyright (C) 2009-2016 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"
40 #define DEV_TTY "/dev/tty"
45 struct bcache
*bcache
;
48 static struct partial_symbol
*match_partial_symbol (struct objfile
*,
49 struct partial_symtab
*,
51 const char *, domain_enum
,
52 symbol_compare_ftype
*,
53 symbol_compare_ftype
*);
55 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
56 struct partial_symtab
*,
60 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
62 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
63 struct partial_symtab
*,
65 struct obj_section
*);
67 static void fixup_psymbol_section (struct partial_symbol
*psym
,
68 struct objfile
*objfile
);
70 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
71 struct partial_symtab
*pst
);
73 /* Ensure that the partial symbols for OBJFILE have been loaded. This
74 function always returns its argument, as a convenience. */
77 require_partial_symbols (struct objfile
*objfile
, int verbose
)
79 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
81 objfile
->flags
|= OBJF_PSYMTABS_READ
;
83 if (objfile
->sf
->sym_read_psymbols
)
87 printf_unfiltered (_("Reading symbols from %s..."),
88 objfile_name (objfile
));
89 gdb_flush (gdb_stdout
);
91 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
94 if (!objfile_has_symbols (objfile
))
97 printf_unfiltered (_("(no debugging symbols found)..."));
101 printf_unfiltered (_("done.\n"));
109 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
112 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
113 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
117 /* We want to make sure this file always requires psymtabs. */
119 #undef ALL_OBJFILE_PSYMTABS
121 /* Traverse all psymtabs in all objfiles. */
123 #define ALL_PSYMTABS(objfile, p) \
124 ALL_OBJFILES (objfile) \
125 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
127 /* Helper function for psym_map_symtabs_matching_filename that
128 expands the symtabs and calls the iterator. */
131 partial_map_expand_apply (struct objfile
*objfile
,
133 const char *real_path
,
134 struct partial_symtab
*pst
,
135 int (*callback
) (struct symtab
*, void *),
138 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
140 /* Shared psymtabs should never be seen here. Instead they should
141 be handled properly by the caller. */
142 gdb_assert (pst
->user
== NULL
);
144 /* Don't visit already-expanded psymtabs. */
148 /* This may expand more than one symtab, and we want to iterate over
150 psymtab_to_symtab (objfile
, pst
);
152 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
153 objfile
->compunit_symtabs
, last_made
);
156 /* Psymtab version of map_symtabs_matching_filename. See its definition in
157 the definition of quick_symbol_functions in symfile.h. */
160 psym_map_symtabs_matching_filename (struct objfile
*objfile
,
162 const char *real_path
,
163 int (*callback
) (struct symtab
*,
167 struct partial_symtab
*pst
;
168 const char *name_basename
= lbasename (name
);
170 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
172 /* We can skip shared psymtabs here, because any file name will be
173 attached to the unshared psymtab. */
174 if (pst
->user
!= NULL
)
177 /* Anonymous psymtabs don't have a file name. */
181 if (compare_filenames_for_search (pst
->filename
, name
))
183 if (partial_map_expand_apply (objfile
, name
, real_path
,
184 pst
, callback
, data
))
189 /* Before we invoke realpath, which can get expensive when many
190 files are involved, do a quick comparison of the basenames. */
191 if (! basenames_may_differ
192 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
195 if (compare_filenames_for_search (psymtab_to_fullname (pst
), name
))
197 if (partial_map_expand_apply (objfile
, name
, real_path
,
198 pst
, callback
, data
))
203 /* If the user gave us an absolute path, try to find the file in
204 this symtab and use its absolute path. */
205 if (real_path
!= NULL
)
207 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
208 gdb_assert (IS_ABSOLUTE_PATH (name
));
209 if (filename_cmp (psymtab_to_fullname (pst
), real_path
) == 0)
211 if (partial_map_expand_apply (objfile
, name
, real_path
,
212 pst
, callback
, data
))
222 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
223 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
225 static struct partial_symtab
*
226 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
227 CORE_ADDR pc
, struct obj_section
*section
,
228 struct partial_symtab
*pst
,
229 struct bound_minimal_symbol msymbol
)
231 struct partial_symtab
*tpst
;
232 struct partial_symtab
*best_pst
= pst
;
233 CORE_ADDR best_addr
= pst
->textlow
;
235 gdb_assert (!pst
->psymtabs_addrmap_supported
);
237 /* An objfile that has its functions reordered might have
238 many partial symbol tables containing the PC, but
239 we want the partial symbol table that contains the
240 function containing the PC. */
241 if (!(objfile
->flags
& OBJF_REORDERED
)
242 && section
== NULL
) /* Can't validate section this way. */
245 if (msymbol
.minsym
== NULL
)
248 /* The code range of partial symtabs sometimes overlap, so, in
249 the loop below, we need to check all partial symtabs and
250 find the one that fits better for the given PC address. We
251 select the partial symtab that contains a symbol whose
252 address is closest to the PC address. By closest we mean
253 that find_pc_sect_symbol returns the symbol with address
254 that is closest and still less than the given PC. */
255 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
257 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
259 struct partial_symbol
*p
;
262 /* NOTE: This assumes that every psymbol has a
263 corresponding msymbol, which is not necessarily
264 true; the debug info might be much richer than the
265 object's symbol table. */
266 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
268 && (SYMBOL_VALUE_ADDRESS (p
)
269 == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
272 /* Also accept the textlow value of a psymtab as a
273 "symbol", to provide some support for partial
274 symbol tables with line information but no debug
275 symbols (e.g. those produced by an assembler). */
277 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
279 this_addr
= tpst
->textlow
;
281 /* Check whether it is closer than our current
282 BEST_ADDR. Since this symbol address is
283 necessarily lower or equal to PC, the symbol closer
284 to PC is the symbol which address is the highest.
285 This way we return the psymtab which contains such
286 best match symbol. This can help in cases where the
287 symbol information/debuginfo is not complete, like
288 for instance on IRIX6 with gcc, where no debug info
289 is emitted for statics. (See also the nodebug.exp
291 if (this_addr
> best_addr
)
293 best_addr
= this_addr
;
301 /* Find which partial symtab contains PC and SECTION. Return NULL if
302 none. We return the psymtab that contains a symbol whose address
303 exactly matches PC, or, if we cannot find an exact match, the
304 psymtab that contains a symbol whose address is closest to PC. */
306 static struct partial_symtab
*
307 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
308 struct obj_section
*section
,
309 struct bound_minimal_symbol msymbol
)
311 struct partial_symtab
*pst
;
313 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
314 than the later used TEXTLOW/TEXTHIGH one. */
316 if (objfile
->psymtabs_addrmap
!= NULL
)
318 pst
= ((struct partial_symtab
*)
319 addrmap_find (objfile
->psymtabs_addrmap
, pc
));
322 /* FIXME: addrmaps currently do not handle overlayed sections,
323 so fall back to the non-addrmap case if we're debugging
324 overlays and the addrmap returned the wrong section. */
325 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
327 struct partial_symbol
*p
;
329 /* NOTE: This assumes that every psymbol has a
330 corresponding msymbol, which is not necessarily
331 true; the debug info might be much richer than the
332 object's symbol table. */
333 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
335 || (SYMBOL_VALUE_ADDRESS (p
)
336 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
340 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
341 PSYMTABS_ADDRMAP we used has already the best 1-byte
342 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
343 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
352 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
353 which still have no corresponding full SYMTABs read. But it is not
354 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
357 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
358 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
359 debug info type in single OBJFILE. */
361 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
362 if (!pst
->psymtabs_addrmap_supported
363 && pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
365 struct partial_symtab
*best_pst
;
367 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
369 if (best_pst
!= NULL
)
376 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
377 the definition of quick_symbol_functions in symfile.h. */
379 static struct compunit_symtab
*
380 psym_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
381 struct bound_minimal_symbol msymbol
,
383 struct obj_section
*section
,
386 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
390 if (warn_if_readin
&& ps
->readin
)
391 /* Might want to error() here (in case symtab is corrupt and
392 will cause a core dump), but maybe we can successfully
393 continue, so let's not. */
395 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
396 paddress (get_objfile_arch (objfile
), pc
));
397 psymtab_to_symtab (objfile
, ps
);
398 return ps
->compunit_symtab
;
403 /* Find which partial symbol within a psymtab matches PC and SECTION.
404 Return NULL if none. */
406 static struct partial_symbol
*
407 find_pc_sect_psymbol (struct objfile
*objfile
,
408 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
409 struct obj_section
*section
)
411 struct partial_symbol
*best
= NULL
, *p
, **pp
;
414 gdb_assert (psymtab
!= NULL
);
416 /* Cope with programs that start at address 0. */
417 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
419 /* Search the global symbols as well as the static symbols, so that
420 find_pc_partial_function doesn't use a minimal symbol and thus
421 cache a bad endaddr. */
422 for (pp
= objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
423 (pp
- (objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
424 < psymtab
->n_global_syms
);
428 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
429 && PSYMBOL_CLASS (p
) == LOC_BLOCK
430 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
431 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
432 || (psymtab
->textlow
== 0
433 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
435 if (section
!= NULL
) /* Match on a specific section. */
437 fixup_psymbol_section (p
, objfile
);
438 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, p
),
442 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
447 for (pp
= objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
448 (pp
- (objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
449 < psymtab
->n_static_syms
);
453 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
454 && PSYMBOL_CLASS (p
) == LOC_BLOCK
455 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
456 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
457 || (psymtab
->textlow
== 0
458 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
460 if (section
!= NULL
) /* Match on a specific section. */
462 fixup_psymbol_section (p
, objfile
);
463 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, p
),
467 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
476 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
483 if (SYMBOL_SECTION (psym
) >= 0)
486 gdb_assert (objfile
);
488 switch (PSYMBOL_CLASS (psym
))
493 addr
= SYMBOL_VALUE_ADDRESS (psym
);
496 /* Nothing else will be listed in the minsyms -- no use looking
501 fixup_section (&psym
->ginfo
, addr
, objfile
);
504 /* Psymtab version of lookup_symbol. See its definition in
505 the definition of quick_symbol_functions in symfile.h. */
507 static struct compunit_symtab
*
508 psym_lookup_symbol (struct objfile
*objfile
,
509 int block_index
, const char *name
,
510 const domain_enum domain
)
512 struct partial_symtab
*ps
;
513 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
514 struct compunit_symtab
*stab_best
= NULL
;
516 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
518 if (!ps
->readin
&& lookup_partial_symbol (objfile
, ps
, name
,
519 psymtab_index
, domain
))
521 struct symbol
*sym
, *with_opaque
= NULL
;
522 struct compunit_symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
523 /* Note: While psymtab_to_symtab can return NULL if the partial symtab
524 is empty, we can assume it won't here because lookup_partial_symbol
526 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
527 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
529 sym
= block_find_symbol (block
, name
, domain
,
530 block_find_non_opaque_type_preferred
,
533 /* Some caution must be observed with overloaded functions
534 and methods, since the index will not contain any overload
535 information (but NAME might contain it). */
538 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
540 if (with_opaque
!= NULL
541 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
544 /* Keep looking through other psymtabs. */
551 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
552 the global block of PST if GLOBAL, and otherwise the static block.
553 MATCH is the comparison operation that returns true iff MATCH (s,
554 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
555 non-null, the symbols in the block are assumed to be ordered
556 according to it (allowing binary search). It must be compatible
557 with MATCH. Returns the symbol, if found, and otherwise NULL. */
559 static struct partial_symbol
*
560 match_partial_symbol (struct objfile
*objfile
,
561 struct partial_symtab
*pst
, int global
,
562 const char *name
, domain_enum domain
,
563 symbol_compare_ftype
*match
,
564 symbol_compare_ftype
*ordered_compare
)
566 struct partial_symbol
**start
, **psym
;
567 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
568 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
569 int do_linear_search
= 1;
574 objfile
->global_psymbols
.list
+ pst
->globals_offset
:
575 objfile
->static_psymbols
.list
+ pst
->statics_offset
);
577 if (global
&& ordered_compare
) /* Can use a binary search. */
579 do_linear_search
= 0;
581 /* Binary search. This search is guaranteed to end with center
582 pointing at the earliest partial symbol whose name might be
583 correct. At that point *all* partial symbols with an
584 appropriate name will be checked against the correct
588 top
= start
+ length
- 1;
592 center
= bottom
+ (top
- bottom
) / 2;
593 gdb_assert (center
< top
);
594 if (ordered_compare (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
599 gdb_assert (top
== bottom
);
601 while (top
<= real_top
602 && match (SYMBOL_SEARCH_NAME (*top
), name
) == 0)
604 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
605 SYMBOL_DOMAIN (*top
), domain
))
611 /* Can't use a binary search or else we found during the binary search that
612 we should also do a linear search. */
614 if (do_linear_search
)
616 for (psym
= start
; psym
< start
+ length
; psym
++)
618 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
619 SYMBOL_DOMAIN (*psym
), domain
)
620 && match (SYMBOL_SEARCH_NAME (*psym
), name
) == 0)
628 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
629 not contain any method/function instance information (since this would
630 force reading type information while reading psymtabs). Therefore,
631 if NAME contains overload information, it must be stripped before searching
634 The caller is responsible for freeing the return result. */
637 psymtab_search_name (const char *name
)
639 switch (current_language
->la_language
)
643 if (strchr (name
, '('))
645 char *ret
= cp_remove_params (name
);
657 return xstrdup (name
);
660 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
661 Check the global symbols if GLOBAL, the static symbols if not. */
663 static struct partial_symbol
*
664 lookup_partial_symbol (struct objfile
*objfile
,
665 struct partial_symtab
*pst
, const char *name
,
666 int global
, domain_enum domain
)
668 struct partial_symbol
**start
, **psym
;
669 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
670 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
671 int do_linear_search
= 1;
673 struct cleanup
*cleanup
;
678 search_name
= psymtab_search_name (name
);
679 cleanup
= make_cleanup (xfree
, search_name
);
681 objfile
->global_psymbols
.list
+ pst
->globals_offset
:
682 objfile
->static_psymbols
.list
+ pst
->statics_offset
);
684 if (global
) /* This means we can use a binary search. */
686 do_linear_search
= 0;
688 /* Binary search. This search is guaranteed to end with center
689 pointing at the earliest partial symbol whose name might be
690 correct. At that point *all* partial symbols with an
691 appropriate name will be checked against the correct
695 top
= start
+ length
- 1;
699 center
= bottom
+ (top
- bottom
) / 2;
701 internal_error (__FILE__
, __LINE__
,
702 _("failed internal consistency check"));
703 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
),
713 if (!(top
== bottom
))
714 internal_error (__FILE__
, __LINE__
,
715 _("failed internal consistency check"));
717 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
718 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
719 while (top
>= start
&& SYMBOL_MATCHES_SEARCH_NAME (*top
, search_name
))
722 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
725 while (top
<= real_top
&& SYMBOL_MATCHES_SEARCH_NAME (*top
, search_name
))
727 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
728 SYMBOL_DOMAIN (*top
), domain
))
730 do_cleanups (cleanup
);
737 /* Can't use a binary search or else we found during the binary search that
738 we should also do a linear search. */
740 if (do_linear_search
)
742 for (psym
= start
; psym
< start
+ length
; psym
++)
744 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
745 SYMBOL_DOMAIN (*psym
), domain
)
746 && SYMBOL_MATCHES_SEARCH_NAME (*psym
, search_name
))
748 do_cleanups (cleanup
);
754 do_cleanups (cleanup
);
758 /* Get the symbol table that corresponds to a partial_symtab.
759 This is fast after the first time you do it.
760 The result will be NULL if the primary symtab has no symbols,
761 which can happen. Otherwise the result is the primary symtab
762 that contains PST. */
764 static struct compunit_symtab
*
765 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
767 /* If it is a shared psymtab, find an unshared psymtab that includes
768 it. Any such psymtab will do. */
769 while (pst
->user
!= NULL
)
772 /* If it's been looked up before, return it. */
773 if (pst
->compunit_symtab
)
774 return pst
->compunit_symtab
;
776 /* If it has not yet been read in, read it. */
779 struct cleanup
*back_to
= increment_reading_symtab ();
781 (*pst
->read_symtab
) (pst
, objfile
);
782 do_cleanups (back_to
);
785 return pst
->compunit_symtab
;
788 /* Psymtab version of relocate. See its definition in
789 the definition of quick_symbol_functions in symfile.h. */
792 psym_relocate (struct objfile
*objfile
,
793 const struct section_offsets
*new_offsets
,
794 const struct section_offsets
*delta
)
796 struct partial_symbol
**psym
;
797 struct partial_symtab
*p
;
799 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
801 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
802 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
805 for (psym
= objfile
->global_psymbols
.list
;
806 psym
< objfile
->global_psymbols
.next
;
809 fixup_psymbol_section (*psym
, objfile
);
810 if (SYMBOL_SECTION (*psym
) >= 0)
811 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
812 SYMBOL_SECTION (*psym
));
814 for (psym
= objfile
->static_psymbols
.list
;
815 psym
< objfile
->static_psymbols
.next
;
818 fixup_psymbol_section (*psym
, objfile
);
819 if (SYMBOL_SECTION (*psym
) >= 0)
820 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
821 SYMBOL_SECTION (*psym
));
825 /* Psymtab version of find_last_source_symtab. See its definition in
826 the definition of quick_symbol_functions in symfile.h. */
828 static struct symtab
*
829 psym_find_last_source_symtab (struct objfile
*ofp
)
831 struct partial_symtab
*ps
;
832 struct partial_symtab
*cs_pst
= NULL
;
834 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp
, ps
)
836 const char *name
= ps
->filename
;
837 int len
= strlen (name
);
839 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
840 || strcmp (name
, "<<C++-namespaces>>") == 0)))
848 internal_error (__FILE__
, __LINE__
,
849 _("select_source_symtab: "
850 "readin pst found and no symtabs."));
854 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
858 return compunit_primary_filetab (cust
);
864 /* Psymtab version of forget_cached_source_info. See its definition in
865 the definition of quick_symbol_functions in symfile.h. */
868 psym_forget_cached_source_info (struct objfile
*objfile
)
870 struct partial_symtab
*pst
;
872 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
874 if (pst
->fullname
!= NULL
)
876 xfree (pst
->fullname
);
877 pst
->fullname
= NULL
;
883 print_partial_symbols (struct gdbarch
*gdbarch
,
884 struct partial_symbol
**p
, int count
, char *what
,
885 struct ui_file
*outfile
)
887 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
891 fprintf_filtered (outfile
, " `%s'", SYMBOL_LINKAGE_NAME (*p
));
892 if (SYMBOL_DEMANGLED_NAME (*p
) != NULL
)
894 fprintf_filtered (outfile
, " `%s'", SYMBOL_DEMANGLED_NAME (*p
));
896 fputs_filtered (", ", outfile
);
897 switch (SYMBOL_DOMAIN (*p
))
900 fputs_filtered ("undefined domain, ", outfile
);
903 /* This is the usual thing -- don't print it. */
906 fputs_filtered ("struct domain, ", outfile
);
909 fputs_filtered ("label domain, ", outfile
);
912 fputs_filtered ("<invalid domain>, ", outfile
);
915 switch (PSYMBOL_CLASS (*p
))
918 fputs_filtered ("undefined", outfile
);
921 fputs_filtered ("constant int", outfile
);
924 fputs_filtered ("static", outfile
);
927 fputs_filtered ("register", outfile
);
930 fputs_filtered ("pass by value", outfile
);
933 fputs_filtered ("pass by reference", outfile
);
935 case LOC_REGPARM_ADDR
:
936 fputs_filtered ("register address parameter", outfile
);
939 fputs_filtered ("stack parameter", outfile
);
942 fputs_filtered ("type", outfile
);
945 fputs_filtered ("label", outfile
);
948 fputs_filtered ("function", outfile
);
950 case LOC_CONST_BYTES
:
951 fputs_filtered ("constant bytes", outfile
);
954 fputs_filtered ("unresolved", outfile
);
956 case LOC_OPTIMIZED_OUT
:
957 fputs_filtered ("optimized out", outfile
);
960 fputs_filtered ("computed at runtime", outfile
);
963 fputs_filtered ("<invalid location>", outfile
);
966 fputs_filtered (", ", outfile
);
967 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (*p
)), outfile
);
968 fprintf_filtered (outfile
, "\n");
974 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
975 struct ui_file
*outfile
)
977 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
980 if (psymtab
->anonymous
)
982 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
987 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
990 fprintf_filtered (outfile
, "(object ");
991 gdb_print_host_address (psymtab
, outfile
);
992 fprintf_filtered (outfile
, ")\n\n");
993 fprintf_unfiltered (outfile
, " Read from object file %s (",
994 objfile_name (objfile
));
995 gdb_print_host_address (objfile
, outfile
);
996 fprintf_unfiltered (outfile
, ")\n");
1000 fprintf_filtered (outfile
,
1001 " Full symtab was read (at ");
1002 gdb_print_host_address (psymtab
->compunit_symtab
, outfile
);
1003 fprintf_filtered (outfile
, " by function at ");
1004 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
1005 fprintf_filtered (outfile
, ")\n");
1008 fprintf_filtered (outfile
, " Symbols cover text addresses ");
1009 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
), outfile
);
1010 fprintf_filtered (outfile
, "-");
1011 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
), outfile
);
1012 fprintf_filtered (outfile
, "\n");
1013 fprintf_filtered (outfile
, " Address map supported - %s.\n",
1014 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
1015 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
1016 psymtab
->number_of_dependencies
);
1017 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1019 fprintf_filtered (outfile
, " %d ", i
);
1020 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
1021 fprintf_filtered (outfile
, " %s\n",
1022 psymtab
->dependencies
[i
]->filename
);
1024 if (psymtab
->user
!= NULL
)
1026 fprintf_filtered (outfile
, " Shared partial symtab with user ");
1027 gdb_print_host_address (psymtab
->user
, outfile
);
1028 fprintf_filtered (outfile
, "\n");
1030 if (psymtab
->n_global_syms
> 0)
1032 print_partial_symbols (gdbarch
,
1033 objfile
->global_psymbols
.list
1034 + psymtab
->globals_offset
,
1035 psymtab
->n_global_syms
, "Global", outfile
);
1037 if (psymtab
->n_static_syms
> 0)
1039 print_partial_symbols (gdbarch
,
1040 objfile
->static_psymbols
.list
1041 + psymtab
->statics_offset
,
1042 psymtab
->n_static_syms
, "Static", outfile
);
1044 fprintf_filtered (outfile
, "\n");
1047 /* Psymtab version of print_stats. See its definition in
1048 the definition of quick_symbol_functions in symfile.h. */
1051 psym_print_stats (struct objfile
*objfile
)
1054 struct partial_symtab
*ps
;
1057 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1059 if (ps
->readin
== 0)
1062 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1065 /* Psymtab version of dump. See its definition in
1066 the definition of quick_symbol_functions in symfile.h. */
1069 psym_dump (struct objfile
*objfile
)
1071 struct partial_symtab
*psymtab
;
1073 if (objfile
->psymtabs
)
1075 printf_filtered ("Psymtabs:\n");
1076 for (psymtab
= objfile
->psymtabs
;
1078 psymtab
= psymtab
->next
)
1080 printf_filtered ("%s at ",
1082 gdb_print_host_address (psymtab
, gdb_stdout
);
1083 printf_filtered (", ");
1086 printf_filtered ("\n\n");
1090 /* Psymtab version of expand_symtabs_for_function. See its definition in
1091 the definition of quick_symbol_functions in symfile.h. */
1094 psym_expand_symtabs_for_function (struct objfile
*objfile
,
1095 const char *func_name
)
1097 struct partial_symtab
*ps
;
1099 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1104 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1106 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1108 psymtab_to_symtab (objfile
, ps
);
1112 /* Psymtab version of expand_all_symtabs. See its definition in
1113 the definition of quick_symbol_functions in symfile.h. */
1116 psym_expand_all_symtabs (struct objfile
*objfile
)
1118 struct partial_symtab
*psymtab
;
1120 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
1122 psymtab_to_symtab (objfile
, psymtab
);
1126 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1127 the definition of quick_symbol_functions in symfile.h. */
1130 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1131 const char *fullname
)
1133 struct partial_symtab
*p
;
1135 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
1137 /* Anonymous psymtabs don't have a name of a source file. */
1141 /* psymtab_to_fullname tries to open the file which is slow.
1142 Don't call it if we know the basenames don't match. */
1143 if ((basenames_may_differ
1144 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1145 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1146 psymtab_to_symtab (objfile
, p
);
1150 /* Psymtab version of map_symbol_filenames. See its definition in
1151 the definition of quick_symbol_functions in symfile.h. */
1154 psym_map_symbol_filenames (struct objfile
*objfile
,
1155 symbol_filename_ftype
*fun
, void *data
,
1158 struct partial_symtab
*ps
;
1160 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1162 const char *fullname
;
1167 /* We can skip shared psymtabs here, because any file name will be
1168 attached to the unshared psymtab. */
1169 if (ps
->user
!= NULL
)
1172 /* Anonymous psymtabs don't have a file name. */
1178 fullname
= psymtab_to_fullname (ps
);
1181 (*fun
) (ps
->filename
, fullname
, data
);
1185 /* Finds the fullname that a partial_symtab represents.
1187 If this functions finds the fullname, it will save it in ps->fullname
1188 and it will also return the value.
1190 If this function fails to find the file that this partial_symtab represents,
1191 NULL will be returned and ps->fullname will be set to NULL. */
1194 psymtab_to_fullname (struct partial_symtab
*ps
)
1196 gdb_assert (!ps
->anonymous
);
1198 /* Use cached copy if we have it.
1199 We rely on forget_cached_source_info being called appropriately
1200 to handle cases like the file being moved. */
1201 if (ps
->fullname
== NULL
)
1203 int fd
= find_and_open_source (ps
->filename
, ps
->dirname
, &ps
->fullname
);
1210 struct cleanup
*back_to
;
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
= xstrdup (ps
->filename
);
1218 fullname
= concat (ps
->dirname
, SLASH_STRING
,
1219 ps
->filename
, (char *) NULL
);
1221 back_to
= make_cleanup (xfree
, fullname
);
1222 ps
->fullname
= rewrite_source_path (fullname
);
1223 if (ps
->fullname
== NULL
)
1224 ps
->fullname
= xstrdup (fullname
);
1225 do_cleanups (back_to
);
1229 return ps
->fullname
;
1232 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1233 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1234 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1235 ever returns non-zero, and otherwise returns 0. */
1238 map_block (const char *name
, domain_enum domain
, struct objfile
*objfile
,
1239 struct block
*block
,
1240 int (*callback
) (struct block
*, struct symbol
*, void *),
1241 void *data
, symbol_compare_ftype
*match
)
1243 struct block_iterator iter
;
1246 for (sym
= block_iter_match_first (block
, name
, match
, &iter
);
1247 sym
!= NULL
; sym
= block_iter_match_next (name
, match
, &iter
))
1249 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1250 SYMBOL_DOMAIN (sym
), domain
))
1252 if (callback (block
, sym
, data
))
1260 /* Psymtab version of map_matching_symbols. See its definition in
1261 the definition of quick_symbol_functions in symfile.h. */
1264 psym_map_matching_symbols (struct objfile
*objfile
,
1265 const char *name
, domain_enum domain
,
1267 int (*callback
) (struct block
*,
1268 struct symbol
*, void *),
1270 symbol_compare_ftype
*match
,
1271 symbol_compare_ftype
*ordered_compare
)
1273 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1274 struct partial_symtab
*ps
;
1276 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1280 || match_partial_symbol (objfile
, ps
, global
, name
, domain
, match
,
1283 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1284 struct block
*block
;
1288 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1289 if (map_block (name
, domain
, objfile
, block
,
1290 callback
, data
, match
))
1292 if (callback (block
, NULL
, data
))
1298 /* A helper for psym_expand_symtabs_matching that handles
1299 searching included psymtabs. This returns 1 if a symbol is found,
1300 and zero otherwise. It also updates the 'searched_flag' on the
1301 various psymtabs that it searches. */
1304 recursively_search_psymtabs (struct partial_symtab
*ps
,
1305 struct objfile
*objfile
,
1306 enum search_domain kind
,
1307 expand_symtabs_symbol_matcher_ftype
*sym_matcher
,
1310 struct partial_symbol
**psym
;
1311 struct partial_symbol
**bound
, **gbound
, **sbound
;
1313 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1316 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1317 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1319 /* Recurse into shared psymtabs first, because they may have already
1320 been searched, and this could save some time. */
1321 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1325 /* Skip non-shared dependencies, these are handled elsewhere. */
1326 if (ps
->dependencies
[i
]->user
== NULL
)
1329 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1330 objfile
, kind
, sym_matcher
, data
);
1333 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1338 gbound
= (objfile
->global_psymbols
.list
1339 + ps
->globals_offset
+ ps
->n_global_syms
);
1340 sbound
= (objfile
->static_psymbols
.list
1341 + ps
->statics_offset
+ ps
->n_static_syms
);
1344 /* Go through all of the symbols stored in a partial
1345 symtab in one loop. */
1346 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
1351 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1353 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
1364 if ((kind
== ALL_DOMAIN
1365 || (kind
== VARIABLES_DOMAIN
1366 && PSYMBOL_CLASS (*psym
) != LOC_TYPEDEF
1367 && PSYMBOL_CLASS (*psym
) != LOC_BLOCK
)
1368 || (kind
== FUNCTIONS_DOMAIN
1369 && PSYMBOL_CLASS (*psym
) == LOC_BLOCK
)
1370 || (kind
== TYPES_DOMAIN
1371 && PSYMBOL_CLASS (*psym
) == LOC_TYPEDEF
))
1372 && (*sym_matcher
) (SYMBOL_SEARCH_NAME (*psym
), data
))
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 expand_symtabs_file_matcher_ftype
*file_matcher
,
1393 expand_symtabs_symbol_matcher_ftype
*symbol_matcher
,
1394 expand_symtabs_exp_notify_ftype
*expansion_notify
,
1395 enum search_domain kind
,
1398 struct partial_symtab
*ps
;
1400 /* Clear the search flags. */
1401 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1403 ps
->searched_flag
= PST_NOT_SEARCHED
;
1406 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1413 /* We skip shared psymtabs because file-matching doesn't apply
1414 to them; but we search them later in the loop. */
1415 if (ps
->user
!= NULL
)
1425 match
= (*file_matcher
) (ps
->filename
, data
, 0);
1428 /* Before we invoke realpath, which can get expensive when many
1429 files are involved, do a quick comparison of the basenames. */
1430 if (basenames_may_differ
1431 || (*file_matcher
) (lbasename (ps
->filename
), data
, 1))
1432 match
= (*file_matcher
) (psymtab_to_fullname (ps
), data
, 0);
1438 if (recursively_search_psymtabs (ps
, objfile
, kind
, symbol_matcher
, data
))
1440 struct compunit_symtab
*symtab
=
1441 psymtab_to_symtab (objfile
, ps
);
1443 if (expansion_notify
!= NULL
)
1444 expansion_notify (symtab
, data
);
1449 /* Psymtab version of has_symbols. See its definition in
1450 the definition of quick_symbol_functions in symfile.h. */
1453 psym_has_symbols (struct objfile
*objfile
)
1455 return objfile
->psymtabs
!= NULL
;
1458 const struct quick_symbol_functions psym_functions
=
1461 psym_find_last_source_symtab
,
1462 psym_forget_cached_source_info
,
1463 psym_map_symtabs_matching_filename
,
1468 psym_expand_symtabs_for_function
,
1469 psym_expand_all_symtabs
,
1470 psym_expand_symtabs_with_fullname
,
1471 psym_map_matching_symbols
,
1472 psym_expand_symtabs_matching
,
1473 psym_find_pc_sect_compunit_symtab
,
1474 psym_map_symbol_filenames
1479 /* This compares two partial symbols by names, using strcmp_iw_ordered
1480 for the comparison. */
1483 compare_psymbols (const void *s1p
, const void *s2p
)
1485 struct partial_symbol
*const *s1
= (struct partial_symbol
* const*) s1p
;
1486 struct partial_symbol
*const *s2
= (struct partial_symbol
* const*) s2p
;
1488 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
1489 SYMBOL_SEARCH_NAME (*s2
));
1493 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1495 /* Sort the global list; don't sort the static list. */
1497 qsort (objfile
->global_psymbols
.list
+ pst
->globals_offset
,
1498 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
1502 /* Allocate and partially fill a partial symtab. It will be
1503 completely filled at the end of the symbol list.
1505 FILENAME is the name of the symbol-file we are reading from. */
1507 struct partial_symtab
*
1508 start_psymtab_common (struct objfile
*objfile
,
1509 const char *filename
,
1510 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
1511 struct partial_symbol
**static_syms
)
1513 struct partial_symtab
*psymtab
;
1515 psymtab
= allocate_psymtab (filename
, objfile
);
1516 psymtab
->textlow
= textlow
;
1517 psymtab
->texthigh
= psymtab
->textlow
; /* default */
1518 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
1519 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
1523 /* Perform "finishing up" operations of a partial symtab. */
1526 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1529 = objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
1530 + pst
->globals_offset
);
1532 = objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
1533 + pst
->statics_offset
);
1535 sort_pst_symbols (objfile
, pst
);
1538 /* Calculate a hash code for the given partial symbol. The hash is
1539 calculated using the symbol's value, language, domain, class
1540 and name. These are the values which are set by
1541 add_psymbol_to_bcache. */
1543 static unsigned long
1544 psymbol_hash (const void *addr
, int length
)
1546 unsigned long h
= 0;
1547 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1548 unsigned int lang
= psymbol
->ginfo
.language
;
1549 unsigned int domain
= PSYMBOL_DOMAIN (psymbol
);
1550 unsigned int theclass
= PSYMBOL_CLASS (psymbol
);
1552 h
= hash_continue (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1553 h
= hash_continue (&lang
, sizeof (unsigned int), h
);
1554 h
= hash_continue (&domain
, sizeof (unsigned int), h
);
1555 h
= hash_continue (&theclass
, sizeof (unsigned int), h
);
1556 h
= hash_continue (psymbol
->ginfo
.name
, strlen (psymbol
->ginfo
.name
), h
);
1561 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1562 For the comparison this function uses a symbols value,
1563 language, domain, class and name. */
1566 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1568 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1569 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1571 return (memcmp (&sym1
->ginfo
.value
, &sym2
->ginfo
.value
,
1572 sizeof (sym1
->ginfo
.value
)) == 0
1573 && sym1
->ginfo
.language
== sym2
->ginfo
.language
1574 && PSYMBOL_DOMAIN (sym1
) == PSYMBOL_DOMAIN (sym2
)
1575 && PSYMBOL_CLASS (sym1
) == PSYMBOL_CLASS (sym2
)
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 const struct partial_symbol
*
1616 psymbol_bcache_full (struct partial_symbol
*sym
,
1617 struct psymbol_bcache
*bcache
,
1620 return ((const 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 const 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 /* Increase the space allocated for LISTP, which is probably
1659 global_psymbols or static_psymbols. This space will eventually
1660 be freed in free_objfile(). */
1663 extend_psymbol_list (struct psymbol_allocation_list
*listp
,
1664 struct objfile
*objfile
)
1668 if (listp
->size
== 0)
1671 listp
->list
= XNEWVEC (struct partial_symbol
*, new_size
);
1675 new_size
= listp
->size
* 2;
1676 listp
->list
= (struct partial_symbol
**)
1677 xrealloc ((char *) listp
->list
,
1678 new_size
* sizeof (struct partial_symbol
*));
1680 /* Next assumes we only went one over. Should be good if
1681 program works correctly. */
1682 listp
->next
= listp
->list
+ listp
->size
;
1683 listp
->size
= new_size
;
1686 /* Helper function, adds partial symbol to the given partial symbol list. */
1689 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
1690 const struct partial_symbol
*psym
,
1691 struct objfile
*objfile
)
1693 if (list
->next
>= list
->list
+ list
->size
)
1694 extend_psymbol_list (list
, objfile
);
1695 *list
->next
++ = (struct partial_symbol
*) psym
;
1696 OBJSTAT (objfile
, n_psyms
++);
1699 /* Add a symbol with a long value to a psymtab.
1700 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1701 The only value we need to store for psyms is an address.
1702 For all other psyms pass zero for COREADDR.
1703 Return the partial symbol that has been added. */
1706 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1708 enum address_class theclass
,
1709 struct psymbol_allocation_list
*list
,
1711 enum language language
, struct objfile
*objfile
)
1713 const struct partial_symbol
*psym
;
1717 /* Stash the partial symbol away in the cache. */
1718 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, theclass
,
1719 coreaddr
, language
, objfile
, &added
);
1721 /* Do not duplicate global partial symbols. */
1722 if (list
== &objfile
->global_psymbols
1726 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1727 append_psymbol_to_list (list
, psym
, objfile
);
1730 /* Initialize storage for partial symbols. */
1733 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1735 /* Free any previously allocated psymbol lists. */
1737 if (objfile
->global_psymbols
.list
)
1738 xfree (objfile
->global_psymbols
.list
);
1739 if (objfile
->static_psymbols
.list
)
1740 xfree (objfile
->static_psymbols
.list
);
1742 /* Current best guess is that approximately a twentieth
1743 of the total symbols (in a debugging file) are global or static
1744 oriented symbols, then multiply that by slop factor of two. */
1746 objfile
->global_psymbols
.size
= total_symbols
/ 10;
1747 objfile
->static_psymbols
.size
= total_symbols
/ 10;
1749 if (objfile
->global_psymbols
.size
> 0)
1751 objfile
->global_psymbols
.next
=
1752 objfile
->global_psymbols
.list
=
1753 XNEWVEC (struct partial_symbol
*, objfile
->global_psymbols
.size
);
1755 if (objfile
->static_psymbols
.size
> 0)
1757 objfile
->static_psymbols
.next
=
1758 objfile
->static_psymbols
.list
=
1759 XNEWVEC (struct partial_symbol
*, objfile
->static_psymbols
.size
);
1763 struct partial_symtab
*
1764 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1766 struct partial_symtab
*psymtab
;
1768 if (objfile
->free_psymtabs
)
1770 psymtab
= objfile
->free_psymtabs
;
1771 objfile
->free_psymtabs
= psymtab
->next
;
1774 psymtab
= (struct partial_symtab
*)
1775 obstack_alloc (&objfile
->objfile_obstack
,
1776 sizeof (struct partial_symtab
));
1778 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1780 = (const char *) bcache (filename
, strlen (filename
) + 1,
1781 objfile
->per_bfd
->filename_cache
);
1782 psymtab
->compunit_symtab
= NULL
;
1784 /* Prepend it to the psymtab list for the objfile it belongs to.
1785 Psymtabs are searched in most recent inserted -> least recent
1788 psymtab
->next
= objfile
->psymtabs
;
1789 objfile
->psymtabs
= psymtab
;
1791 if (symtab_create_debug
)
1793 /* Be a bit clever with debugging messages, and don't print objfile
1794 every time, only when it changes. */
1795 static char *last_objfile_name
= NULL
;
1797 if (last_objfile_name
== NULL
1798 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1800 xfree (last_objfile_name
);
1801 last_objfile_name
= xstrdup (objfile_name (objfile
));
1802 fprintf_unfiltered (gdb_stdlog
,
1803 "Creating one or more psymtabs for objfile %s ...\n",
1806 fprintf_unfiltered (gdb_stdlog
,
1807 "Created psymtab %s for module %s.\n",
1808 host_address_to_string (psymtab
), filename
);
1815 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1817 struct partial_symtab
**prev_pst
;
1820 Empty psymtabs happen as a result of header files which don't
1821 have any symbols in them. There can be a lot of them. But this
1822 check is wrong, in that a psymtab with N_SLINE entries but
1823 nothing else is not empty, but we don't realize that. Fixing
1824 that without slowing things down might be tricky. */
1826 /* First, snip it out of the psymtab chain. */
1828 prev_pst
= &(objfile
->psymtabs
);
1829 while ((*prev_pst
) != pst
)
1830 prev_pst
= &((*prev_pst
)->next
);
1831 (*prev_pst
) = pst
->next
;
1833 /* Next, put it on a free list for recycling. */
1835 pst
->next
= objfile
->free_psymtabs
;
1836 objfile
->free_psymtabs
= pst
;
1839 /* An object of this type is passed to discard_psymtabs_upto. */
1841 struct psymtab_state
1843 /* The objfile where psymtabs are discarded. */
1845 struct objfile
*objfile
;
1847 /* The first psymtab to save. */
1849 struct partial_symtab
*save
;
1852 /* A cleanup function used by make_cleanup_discard_psymtabs. */
1855 discard_psymtabs_upto (void *arg
)
1857 struct psymtab_state
*state
= (struct psymtab_state
*) arg
;
1859 while (state
->objfile
->psymtabs
!= state
->save
)
1860 discard_psymtab (state
->objfile
, state
->objfile
->psymtabs
);
1863 /* Return a new cleanup that discards all psymtabs created in OBJFILE
1864 after this function is called. */
1867 make_cleanup_discard_psymtabs (struct objfile
*objfile
)
1869 struct psymtab_state
*state
= XNEW (struct psymtab_state
);
1871 state
->objfile
= objfile
;
1872 state
->save
= objfile
->psymtabs
;
1874 return make_cleanup_dtor (discard_psymtabs_upto
, state
, xfree
);
1879 /* We need to pass a couple of items to the addrmap_foreach function,
1882 struct dump_psymtab_addrmap_data
1884 struct objfile
*objfile
;
1885 struct partial_symtab
*psymtab
;
1886 struct ui_file
*outfile
;
1888 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1889 If so, we want to print the next one as well (since the next addrmap
1890 entry defines the end of the range). */
1891 int previous_matched
;
1894 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1897 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1899 struct dump_psymtab_addrmap_data
*data
1900 = (struct dump_psymtab_addrmap_data
*) datap
;
1901 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1902 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1903 const char *psymtab_address_or_end
= NULL
;
1907 if (data
->psymtab
== NULL
1908 || data
->psymtab
== addrmap_psymtab
)
1909 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1910 else if (data
->previous_matched
)
1911 psymtab_address_or_end
= "<ends here>";
1913 if (data
->psymtab
== NULL
1914 || data
->psymtab
== addrmap_psymtab
1915 || data
->previous_matched
)
1917 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1918 data
->psymtab
!= NULL
? " " : "",
1919 paddress (gdbarch
, start_addr
),
1920 psymtab_address_or_end
);
1923 data
->previous_matched
= (data
->psymtab
== NULL
1924 || data
->psymtab
== addrmap_psymtab
);
1929 /* Helper function for maintenance_print_psymbols to print the addrmap
1930 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1933 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1934 struct ui_file
*outfile
)
1936 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1939 || psymtab
->psymtabs_addrmap_supported
)
1941 addrmap_dump_data
.objfile
= objfile
;
1942 addrmap_dump_data
.psymtab
= psymtab
;
1943 addrmap_dump_data
.outfile
= outfile
;
1944 addrmap_dump_data
.previous_matched
= 0;
1945 fprintf_filtered (outfile
, "%sddress map:\n",
1946 psymtab
== NULL
? "Entire a" : " A");
1947 addrmap_foreach (objfile
->psymtabs_addrmap
, dump_psymtab_addrmap_1
,
1948 &addrmap_dump_data
);
1953 maintenance_print_psymbols (char *args
, int from_tty
)
1956 struct ui_file
*outfile
;
1957 struct cleanup
*cleanups
;
1958 char *symname
= NULL
;
1959 char *filename
= DEV_TTY
;
1960 struct objfile
*objfile
;
1961 struct partial_symtab
*ps
;
1968 print-psymbols takes an output file name and optional symbol file name"));
1970 argv
= gdb_buildargv (args
);
1971 cleanups
= make_cleanup_freeargv (argv
);
1973 if (argv
[0] != NULL
)
1976 /* If a second arg is supplied, it is a source file name to match on. */
1977 if (argv
[1] != NULL
)
1983 filename
= tilde_expand (filename
);
1984 make_cleanup (xfree
, filename
);
1986 outfile
= gdb_fopen (filename
, FOPEN_WT
);
1987 if (outfile
== NULL
)
1988 perror_with_name (filename
);
1989 make_cleanup_ui_file_delete (outfile
);
1991 ALL_OBJFILES (objfile
)
1993 fprintf_filtered (outfile
, "\nPartial symtabs for objfile %s\n",
1994 objfile_name (objfile
));
1996 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1999 if (symname
== NULL
|| filename_cmp (symname
, ps
->filename
) == 0)
2001 dump_psymtab (objfile
, ps
, outfile
);
2002 dump_psymtab_addrmap (objfile
, ps
, outfile
);
2006 /* If we're printing all symbols dump the full addrmap. */
2008 if (symname
== NULL
)
2010 fprintf_filtered (outfile
, "\n");
2011 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
2015 do_cleanups (cleanups
);
2018 /* List all the partial symbol tables whose names match REGEXP (optional). */
2021 maintenance_info_psymtabs (char *regexp
, int from_tty
)
2023 struct program_space
*pspace
;
2024 struct objfile
*objfile
;
2029 ALL_PSPACES (pspace
)
2030 ALL_PSPACE_OBJFILES (pspace
, objfile
)
2032 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2033 struct partial_symtab
*psymtab
;
2035 /* We don't want to print anything for this objfile until we
2036 actually find a symtab whose name matches. */
2037 int printed_objfile_start
= 0;
2039 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
2044 || re_exec (psymtab
->filename
))
2046 if (! printed_objfile_start
)
2048 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2050 printf_filtered ("((struct objfile *) %s)\n",
2051 host_address_to_string (objfile
));
2052 printed_objfile_start
= 1;
2055 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2057 printf_filtered ("((struct partial_symtab *) %s)\n",
2058 host_address_to_string (psymtab
));
2060 printf_filtered (" readin %s\n",
2061 psymtab
->readin
? "yes" : "no");
2062 printf_filtered (" fullname %s\n",
2064 ? psymtab
->fullname
: "(null)");
2065 printf_filtered (" text addresses ");
2066 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
),
2068 printf_filtered (" -- ");
2069 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
),
2071 printf_filtered ("\n");
2072 printf_filtered (" psymtabs_addrmap_supported %s\n",
2073 (psymtab
->psymtabs_addrmap_supported
2075 printf_filtered (" globals ");
2076 if (psymtab
->n_global_syms
)
2078 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2079 host_address_to_string (objfile
->global_psymbols
.list
2080 + psymtab
->globals_offset
),
2081 psymtab
->n_global_syms
);
2084 printf_filtered ("(none)\n");
2085 printf_filtered (" statics ");
2086 if (psymtab
->n_static_syms
)
2088 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
2089 host_address_to_string (objfile
->static_psymbols
.list
2090 + psymtab
->statics_offset
),
2091 psymtab
->n_static_syms
);
2094 printf_filtered ("(none)\n");
2095 printf_filtered (" dependencies ");
2096 if (psymtab
->number_of_dependencies
)
2100 printf_filtered ("{\n");
2101 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2103 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2105 /* Note the string concatenation there --- no comma. */
2106 printf_filtered (" psymtab %s "
2107 "((struct partial_symtab *) %s)\n",
2109 host_address_to_string (dep
));
2111 printf_filtered (" }\n");
2114 printf_filtered ("(none)\n");
2115 printf_filtered (" }\n");
2119 if (printed_objfile_start
)
2120 printf_filtered ("}\n");
2124 /* Check consistency of currently expanded psymtabs vs symtabs. */
2127 maintenance_check_psymtabs (char *ignore
, int from_tty
)
2130 struct partial_symbol
**psym
;
2131 struct compunit_symtab
*cust
= NULL
;
2132 struct partial_symtab
*ps
;
2133 const struct blockvector
*bv
;
2134 struct objfile
*objfile
;
2138 ALL_PSYMTABS (objfile
, ps
)
2140 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2142 /* We don't call psymtab_to_symtab here because that may cause symtab
2143 expansion. When debugging a problem it helps if checkers leave
2144 things unchanged. */
2145 cust
= ps
->compunit_symtab
;
2147 /* First do some checks that don't require the associated symtab. */
2148 if (ps
->texthigh
< ps
->textlow
)
2150 printf_filtered ("Psymtab ");
2151 puts_filtered (ps
->filename
);
2152 printf_filtered (" covers bad range ");
2153 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2154 printf_filtered (" - ");
2155 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2156 printf_filtered ("\n");
2160 /* Now do checks requiring the associated symtab. */
2163 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2164 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2165 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2166 length
= ps
->n_static_syms
;
2169 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2170 SYMBOL_DOMAIN (*psym
));
2173 printf_filtered ("Static symbol `");
2174 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2175 printf_filtered ("' only found in ");
2176 puts_filtered (ps
->filename
);
2177 printf_filtered (" psymtab\n");
2181 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2182 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2183 length
= ps
->n_global_syms
;
2186 sym
= block_lookup_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2187 SYMBOL_DOMAIN (*psym
));
2190 printf_filtered ("Global symbol `");
2191 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2192 printf_filtered ("' only found in ");
2193 puts_filtered (ps
->filename
);
2194 printf_filtered (" psymtab\n");
2198 if (ps
->texthigh
!= 0
2199 && (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
)))
2201 printf_filtered ("Psymtab ");
2202 puts_filtered (ps
->filename
);
2203 printf_filtered (" covers ");
2204 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2205 printf_filtered (" - ");
2206 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2207 printf_filtered (" but symtab covers only ");
2208 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2209 printf_filtered (" - ");
2210 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2211 printf_filtered ("\n");
2218 extern initialize_file_ftype _initialize_psymtab
;
2221 _initialize_psymtab (void)
2223 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2224 Print dump of current partial symbol definitions.\n\
2225 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2226 If a SOURCE file is specified, dump only that file's partial symbols."),
2227 &maintenanceprintlist
);
2229 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2230 List the partial symbol tables for all object files.\n\
2231 This does not include information about individual partial symbols,\n\
2232 just the symbol table structures themselves."),
2233 &maintenanceinfolist
);
2235 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2237 Check consistency of currently expanded psymtabs versus symtabs."),