1 /* Partial symbol tables.
3 Copyright (C) 2009-2013 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/>. */
24 #include "gdb_assert.h"
26 #include "filenames.h"
33 #include "readline/readline.h"
34 #include "gdb_regex.h"
35 #include "dictionary.h"
37 #include "cp-support.h"
41 #define DEV_TTY "/dev/tty"
46 struct bcache
*bcache
;
49 static struct partial_symbol
*match_partial_symbol (struct objfile
*,
50 struct partial_symtab
*,
52 const char *, domain_enum
,
53 symbol_compare_ftype
*,
54 symbol_compare_ftype
*);
56 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
57 struct partial_symtab
*,
61 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
63 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
64 struct partial_symtab
*,
66 struct obj_section
*);
68 static void fixup_psymbol_section (struct partial_symbol
*psym
,
69 struct objfile
*objfile
);
71 static struct symtab
*psymtab_to_symtab (struct objfile
*objfile
,
72 struct partial_symtab
*pst
);
74 /* Ensure that the partial symbols for OBJFILE have been loaded. This
75 function always returns its argument, as a convenience. */
78 require_partial_symbols (struct objfile
*objfile
, int verbose
)
80 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
82 objfile
->flags
|= OBJF_PSYMTABS_READ
;
84 if (objfile
->sf
->sym_read_psymbols
)
88 printf_unfiltered (_("Reading symbols from %s..."),
90 gdb_flush (gdb_stdout
);
92 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
95 if (!objfile_has_symbols (objfile
))
98 printf_unfiltered (_("(no debugging symbols found)..."));
102 printf_unfiltered (_("done.\n"));
110 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
113 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
114 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
118 /* We want to make sure this file always requires psymtabs. */
120 #undef ALL_OBJFILE_PSYMTABS
122 /* Traverse all psymtabs in all objfiles. */
124 #define ALL_PSYMTABS(objfile, p) \
125 ALL_OBJFILES (objfile) \
126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
128 /* Helper function for partial_map_symtabs_matching_filename that
129 expands the symtabs and calls the iterator. */
132 partial_map_expand_apply (struct objfile
*objfile
,
134 const char *full_path
,
135 const char *real_path
,
136 struct partial_symtab
*pst
,
137 int (*callback
) (struct symtab
*, void *),
140 struct symtab
*last_made
= objfile
->symtabs
;
142 /* Shared psymtabs should never be seen here. Instead they should
143 be handled properly by the caller. */
144 gdb_assert (pst
->user
== NULL
);
146 /* Don't visit already-expanded psymtabs. */
150 /* This may expand more than one symtab, and we want to iterate over
152 psymtab_to_symtab (objfile
, pst
);
154 return iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
155 objfile
->symtabs
, last_made
);
158 /* Implementation of the map_symtabs_matching_filename method. */
161 partial_map_symtabs_matching_filename (struct objfile
*objfile
,
163 const char *full_path
,
164 const char *real_path
,
165 int (*callback
) (struct symtab
*,
169 struct partial_symtab
*pst
;
170 const char *name_basename
= lbasename (name
);
171 int is_abs
= IS_ABSOLUTE_PATH (name
);
173 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
175 /* We can skip shared psymtabs here, because any file name will be
176 attached to the unshared psymtab. */
177 if (pst
->user
!= NULL
)
180 /* Anonymous psymtabs don't have a file name. */
184 if (FILENAME_CMP (name
, pst
->filename
) == 0
185 || (!is_abs
&& compare_filenames_for_search (pst
->filename
, name
)))
187 if (partial_map_expand_apply (objfile
, name
, full_path
, real_path
,
188 pst
, callback
, data
))
192 /* Before we invoke realpath, which can get expensive when many
193 files are involved, do a quick comparison of the basenames. */
194 if (! basenames_may_differ
195 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
198 /* If the user gave us an absolute path, try to find the file in
199 this symtab and use its absolute path. */
200 if (full_path
!= NULL
)
202 psymtab_to_fullname (pst
);
203 if (pst
->fullname
!= NULL
204 && (FILENAME_CMP (full_path
, pst
->fullname
) == 0
205 || (!is_abs
&& compare_filenames_for_search (pst
->fullname
,
208 if (partial_map_expand_apply (objfile
, name
, full_path
, real_path
,
209 pst
, callback
, data
))
214 if (real_path
!= NULL
)
217 psymtab_to_fullname (pst
);
218 if (pst
->fullname
!= NULL
)
220 rp
= gdb_realpath (pst
->fullname
);
221 make_cleanup (xfree
, rp
);
224 && (FILENAME_CMP (real_path
, rp
) == 0
225 || (!is_abs
&& compare_filenames_for_search (real_path
, name
))))
227 if (partial_map_expand_apply (objfile
, name
, full_path
, real_path
,
228 pst
, callback
, data
))
237 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
238 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
240 static struct partial_symtab
*
241 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
242 CORE_ADDR pc
, struct obj_section
*section
,
243 struct partial_symtab
*pst
,
244 struct minimal_symbol
*msymbol
)
246 struct partial_symtab
*tpst
;
247 struct partial_symtab
*best_pst
= pst
;
248 CORE_ADDR best_addr
= pst
->textlow
;
250 gdb_assert (!pst
->psymtabs_addrmap_supported
);
252 /* An objfile that has its functions reordered might have
253 many partial symbol tables containing the PC, but
254 we want the partial symbol table that contains the
255 function containing the PC. */
256 if (!(objfile
->flags
& OBJF_REORDERED
) &&
257 section
== 0) /* Can't validate section this way. */
263 /* The code range of partial symtabs sometimes overlap, so, in
264 the loop below, we need to check all partial symtabs and
265 find the one that fits better for the given PC address. We
266 select the partial symtab that contains a symbol whose
267 address is closest to the PC address. By closest we mean
268 that find_pc_sect_symbol returns the symbol with address
269 that is closest and still less than the given PC. */
270 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
272 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
274 struct partial_symbol
*p
;
277 /* NOTE: This assumes that every psymbol has a
278 corresponding msymbol, which is not necessarily
279 true; the debug info might be much richer than the
280 object's symbol table. */
281 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
283 && SYMBOL_VALUE_ADDRESS (p
)
284 == SYMBOL_VALUE_ADDRESS (msymbol
))
287 /* Also accept the textlow value of a psymtab as a
288 "symbol", to provide some support for partial
289 symbol tables with line information but no debug
290 symbols (e.g. those produced by an assembler). */
292 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
294 this_addr
= tpst
->textlow
;
296 /* Check whether it is closer than our current
297 BEST_ADDR. Since this symbol address is
298 necessarily lower or equal to PC, the symbol closer
299 to PC is the symbol which address is the highest.
300 This way we return the psymtab which contains such
301 best match symbol. This can help in cases where the
302 symbol information/debuginfo is not complete, like
303 for instance on IRIX6 with gcc, where no debug info
304 is emitted for statics. (See also the nodebug.exp
306 if (this_addr
> best_addr
)
308 best_addr
= this_addr
;
316 /* Find which partial symtab contains PC and SECTION. Return 0 if
317 none. We return the psymtab that contains a symbol whose address
318 exactly matches PC, or, if we cannot find an exact match, the
319 psymtab that contains a symbol whose address is closest to PC. */
320 static struct partial_symtab
*
321 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
322 struct obj_section
*section
,
323 struct minimal_symbol
*msymbol
)
325 struct partial_symtab
*pst
;
327 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
328 than the later used TEXTLOW/TEXTHIGH one. */
330 if (objfile
->psymtabs_addrmap
!= NULL
)
332 pst
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
335 /* FIXME: addrmaps currently do not handle overlayed sections,
336 so fall back to the non-addrmap case if we're debugging
337 overlays and the addrmap returned the wrong section. */
338 if (overlay_debugging
&& msymbol
&& section
)
340 struct partial_symbol
*p
;
342 /* NOTE: This assumes that every psymbol has a
343 corresponding msymbol, which is not necessarily
344 true; the debug info might be much richer than the
345 object's symbol table. */
346 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
348 || SYMBOL_VALUE_ADDRESS (p
)
349 != SYMBOL_VALUE_ADDRESS (msymbol
))
353 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
354 PSYMTABS_ADDRMAP we used has already the best 1-byte
355 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
356 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
365 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
366 which still have no corresponding full SYMTABs read. But it is not
367 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
370 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
371 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
372 debug info type in single OBJFILE. */
374 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
375 if (!pst
->psymtabs_addrmap_supported
376 && pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
378 struct partial_symtab
*best_pst
;
380 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
382 if (best_pst
!= NULL
)
389 static struct symtab
*
390 find_pc_sect_symtab_from_partial (struct objfile
*objfile
,
391 struct minimal_symbol
*msymbol
,
392 CORE_ADDR pc
, struct obj_section
*section
,
395 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
399 if (warn_if_readin
&& ps
->readin
)
400 /* Might want to error() here (in case symtab is corrupt and
401 will cause a core dump), but maybe we can successfully
402 continue, so let's not. */
404 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
405 paddress (get_objfile_arch (objfile
), pc
));
406 psymtab_to_symtab (objfile
, ps
);
412 /* Find which partial symbol within a psymtab matches PC and SECTION.
415 static struct partial_symbol
*
416 find_pc_sect_psymbol (struct objfile
*objfile
,
417 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
418 struct obj_section
*section
)
420 struct partial_symbol
*best
= NULL
, *p
, **pp
;
423 gdb_assert (psymtab
!= NULL
);
425 /* Cope with programs that start at address 0. */
426 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
428 /* Search the global symbols as well as the static symbols, so that
429 find_pc_partial_function doesn't use a minimal symbol and thus
430 cache a bad endaddr. */
431 for (pp
= objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
432 (pp
- (objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
433 < psymtab
->n_global_syms
);
437 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
438 && SYMBOL_CLASS (p
) == LOC_BLOCK
439 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
440 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
441 || (psymtab
->textlow
== 0
442 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
444 if (section
) /* Match on a specific section. */
446 fixup_psymbol_section (p
, objfile
);
447 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p
), section
))
450 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
455 for (pp
= objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
456 (pp
- (objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
457 < psymtab
->n_static_syms
);
461 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
462 && SYMBOL_CLASS (p
) == LOC_BLOCK
463 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
464 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
465 || (psymtab
->textlow
== 0
466 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
468 if (section
) /* Match on a specific section. */
470 fixup_psymbol_section (p
, objfile
);
471 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p
), section
))
474 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
483 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
487 if (psym
== NULL
|| SYMBOL_OBJ_SECTION (psym
) != NULL
)
490 gdb_assert (objfile
);
492 switch (SYMBOL_CLASS (psym
))
497 addr
= SYMBOL_VALUE_ADDRESS (psym
);
500 /* Nothing else will be listed in the minsyms -- no use looking
505 fixup_section (&psym
->ginfo
, addr
, objfile
);
508 static struct symtab
*
509 lookup_symbol_aux_psymtabs (struct objfile
*objfile
,
510 int block_index
, const char *name
,
511 const domain_enum domain
)
513 struct partial_symtab
*ps
;
514 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
515 struct symtab
*stab_best
= NULL
;
517 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
519 if (!ps
->readin
&& lookup_partial_symbol (objfile
, ps
, name
,
520 psymtab_index
, domain
))
522 struct symbol
*sym
= NULL
;
523 struct symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
525 /* Some caution must be observed with overloaded functions
526 and methods, since the psymtab will not contain any overload
527 information (but NAME might contain it). */
530 struct blockvector
*bv
= BLOCKVECTOR (stab
);
531 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
533 sym
= lookup_block_symbol (block
, name
, domain
);
536 if (sym
&& strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
538 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
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 (!do_linear_search
595 && (SYMBOL_LANGUAGE (*center
) == language_java
))
596 do_linear_search
= 1;
597 if (ordered_compare (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
602 gdb_assert (top
== bottom
);
604 while (top
<= real_top
605 && match (SYMBOL_SEARCH_NAME (*top
), name
) == 0)
607 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
608 SYMBOL_DOMAIN (*top
), domain
))
614 /* Can't use a binary search or else we found during the binary search that
615 we should also do a linear search. */
617 if (do_linear_search
)
619 for (psym
= start
; psym
< start
+ length
; psym
++)
621 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
622 SYMBOL_DOMAIN (*psym
), domain
)
623 && match (SYMBOL_SEARCH_NAME (*psym
), name
) == 0)
631 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
632 not contain any method/function instance information (since this would
633 force reading type information while reading psymtabs). Therefore,
634 if NAME contains overload information, it must be stripped before searching
637 The caller is responsible for freeing the return result. */
640 psymtab_search_name (const char *name
)
642 switch (current_language
->la_language
)
647 if (strchr (name
, '('))
649 char *ret
= cp_remove_params (name
);
661 return xstrdup (name
);
664 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
665 Check the global symbols if GLOBAL, the static symbols if not. */
667 static struct partial_symbol
*
668 lookup_partial_symbol (struct objfile
*objfile
,
669 struct partial_symtab
*pst
, const char *name
,
670 int global
, domain_enum domain
)
672 struct partial_symbol
**start
, **psym
;
673 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
674 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
675 int do_linear_search
= 1;
677 struct cleanup
*cleanup
;
684 search_name
= psymtab_search_name (name
);
685 cleanup
= make_cleanup (xfree
, search_name
);
687 objfile
->global_psymbols
.list
+ pst
->globals_offset
:
688 objfile
->static_psymbols
.list
+ pst
->statics_offset
);
690 if (global
) /* This means we can use a binary search. */
692 do_linear_search
= 0;
694 /* Binary search. This search is guaranteed to end with center
695 pointing at the earliest partial symbol whose name might be
696 correct. At that point *all* partial symbols with an
697 appropriate name will be checked against the correct
701 top
= start
+ length
- 1;
705 center
= bottom
+ (top
- bottom
) / 2;
707 internal_error (__FILE__
, __LINE__
,
708 _("failed internal consistency check"));
709 if (!do_linear_search
710 && SYMBOL_LANGUAGE (*center
) == language_java
)
712 do_linear_search
= 1;
714 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
),
724 if (!(top
== bottom
))
725 internal_error (__FILE__
, __LINE__
,
726 _("failed internal consistency check"));
728 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
729 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
730 while (top
>= start
&& SYMBOL_MATCHES_SEARCH_NAME (*top
, search_name
))
733 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
736 while (top
<= real_top
&& SYMBOL_MATCHES_SEARCH_NAME (*top
, search_name
))
738 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top
),
739 SYMBOL_DOMAIN (*top
), domain
))
741 do_cleanups (cleanup
);
748 /* Can't use a binary search or else we found during the binary search that
749 we should also do a linear search. */
751 if (do_linear_search
)
753 for (psym
= start
; psym
< start
+ length
; psym
++)
755 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym
),
756 SYMBOL_DOMAIN (*psym
), domain
)
757 && SYMBOL_MATCHES_SEARCH_NAME (*psym
, search_name
))
759 do_cleanups (cleanup
);
765 do_cleanups (cleanup
);
769 /* Get the symbol table that corresponds to a partial_symtab.
770 This is fast after the first time you do it. */
772 static struct symtab
*
773 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
775 /* If it is a shared psymtab, find an unshared psymtab that includes
776 it. Any such psymtab will do. */
777 while (pst
->user
!= NULL
)
780 /* If it's been looked up before, return it. */
784 /* If it has not yet been read in, read it. */
787 struct cleanup
*back_to
= increment_reading_symtab ();
789 (*pst
->read_symtab
) (pst
, objfile
);
790 do_cleanups (back_to
);
797 relocate_psymtabs (struct objfile
*objfile
,
798 struct section_offsets
*new_offsets
,
799 struct section_offsets
*delta
)
801 struct partial_symbol
**psym
;
802 struct partial_symtab
*p
;
804 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
806 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
807 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
810 for (psym
= objfile
->global_psymbols
.list
;
811 psym
< objfile
->global_psymbols
.next
;
814 fixup_psymbol_section (*psym
, objfile
);
815 if (SYMBOL_SECTION (*psym
) >= 0)
816 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
817 SYMBOL_SECTION (*psym
));
819 for (psym
= objfile
->static_psymbols
.list
;
820 psym
< objfile
->static_psymbols
.next
;
823 fixup_psymbol_section (*psym
, objfile
);
824 if (SYMBOL_SECTION (*psym
) >= 0)
825 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
826 SYMBOL_SECTION (*psym
));
830 static struct symtab
*
831 find_last_source_symtab_from_partial (struct objfile
*ofp
)
833 struct partial_symtab
*ps
;
834 struct partial_symtab
*cs_pst
= 0;
836 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp
, ps
)
838 const char *name
= ps
->filename
;
839 int len
= strlen (name
);
841 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
842 || strcmp (name
, "<<C++-namespaces>>") == 0)))
850 internal_error (__FILE__
, __LINE__
,
851 _("select_source_symtab: "
852 "readin pst found and no symtabs."));
855 return psymtab_to_symtab (ofp
, cs_pst
);
861 forget_cached_source_info_partial (struct objfile
*objfile
)
863 struct partial_symtab
*pst
;
865 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
867 if (pst
->fullname
!= NULL
)
869 xfree (pst
->fullname
);
870 pst
->fullname
= NULL
;
876 print_partial_symbols (struct gdbarch
*gdbarch
,
877 struct partial_symbol
**p
, int count
, char *what
,
878 struct ui_file
*outfile
)
880 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
884 fprintf_filtered (outfile
, " `%s'", SYMBOL_LINKAGE_NAME (*p
));
885 if (SYMBOL_DEMANGLED_NAME (*p
) != NULL
)
887 fprintf_filtered (outfile
, " `%s'", SYMBOL_DEMANGLED_NAME (*p
));
889 fputs_filtered (", ", outfile
);
890 switch (SYMBOL_DOMAIN (*p
))
893 fputs_filtered ("undefined domain, ", outfile
);
896 /* This is the usual thing -- don't print it. */
899 fputs_filtered ("struct domain, ", outfile
);
902 fputs_filtered ("label domain, ", outfile
);
905 fputs_filtered ("<invalid domain>, ", outfile
);
908 switch (SYMBOL_CLASS (*p
))
911 fputs_filtered ("undefined", outfile
);
914 fputs_filtered ("constant int", outfile
);
917 fputs_filtered ("static", outfile
);
920 fputs_filtered ("register", outfile
);
923 fputs_filtered ("pass by value", outfile
);
926 fputs_filtered ("pass by reference", outfile
);
928 case LOC_REGPARM_ADDR
:
929 fputs_filtered ("register address parameter", outfile
);
932 fputs_filtered ("stack parameter", outfile
);
935 fputs_filtered ("type", outfile
);
938 fputs_filtered ("label", outfile
);
941 fputs_filtered ("function", outfile
);
943 case LOC_CONST_BYTES
:
944 fputs_filtered ("constant bytes", outfile
);
947 fputs_filtered ("unresolved", outfile
);
949 case LOC_OPTIMIZED_OUT
:
950 fputs_filtered ("optimized out", outfile
);
953 fputs_filtered ("computed at runtime", outfile
);
956 fputs_filtered ("<invalid location>", outfile
);
959 fputs_filtered (", ", outfile
);
960 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (*p
)), outfile
);
961 fprintf_filtered (outfile
, "\n");
967 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
968 struct ui_file
*outfile
)
970 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
973 if (psymtab
->anonymous
)
975 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
980 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
983 fprintf_filtered (outfile
, "(object ");
984 gdb_print_host_address (psymtab
, outfile
);
985 fprintf_filtered (outfile
, ")\n\n");
986 fprintf_unfiltered (outfile
, " Read from object file %s (",
988 gdb_print_host_address (objfile
, outfile
);
989 fprintf_unfiltered (outfile
, ")\n");
993 fprintf_filtered (outfile
,
994 " Full symtab was read (at ");
995 gdb_print_host_address (psymtab
->symtab
, outfile
);
996 fprintf_filtered (outfile
, " by function at ");
997 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
998 fprintf_filtered (outfile
, ")\n");
1001 fprintf_filtered (outfile
, " Relocate symbols by ");
1002 for (i
= 0; i
< objfile
->num_sections
; ++i
)
1005 fprintf_filtered (outfile
, ", ");
1007 fputs_filtered (paddress (gdbarch
,
1008 ANOFFSET (psymtab
->section_offsets
, i
)),
1011 fprintf_filtered (outfile
, "\n");
1013 fprintf_filtered (outfile
, " Symbols cover text addresses ");
1014 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
), outfile
);
1015 fprintf_filtered (outfile
, "-");
1016 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
), outfile
);
1017 fprintf_filtered (outfile
, "\n");
1018 fprintf_filtered (outfile
, " Address map supported - %s.\n",
1019 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
1020 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
1021 psymtab
->number_of_dependencies
);
1022 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1024 fprintf_filtered (outfile
, " %d ", i
);
1025 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
1026 fprintf_filtered (outfile
, " %s\n",
1027 psymtab
->dependencies
[i
]->filename
);
1029 if (psymtab
->user
!= NULL
)
1031 fprintf_filtered (outfile
, " Shared partial symtab with user ");
1032 gdb_print_host_address (psymtab
->user
, outfile
);
1033 fprintf_filtered (outfile
, "\n");
1035 if (psymtab
->n_global_syms
> 0)
1037 print_partial_symbols (gdbarch
,
1038 objfile
->global_psymbols
.list
1039 + psymtab
->globals_offset
,
1040 psymtab
->n_global_syms
, "Global", outfile
);
1042 if (psymtab
->n_static_syms
> 0)
1044 print_partial_symbols (gdbarch
,
1045 objfile
->static_psymbols
.list
1046 + psymtab
->statics_offset
,
1047 psymtab
->n_static_syms
, "Static", outfile
);
1049 fprintf_filtered (outfile
, "\n");
1053 print_psymtab_stats_for_objfile (struct objfile
*objfile
)
1056 struct partial_symtab
*ps
;
1059 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1061 if (ps
->readin
== 0)
1064 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
1068 dump_psymtabs_for_objfile (struct objfile
*objfile
)
1070 struct partial_symtab
*psymtab
;
1072 if (objfile
->psymtabs
)
1074 printf_filtered ("Psymtabs:\n");
1075 for (psymtab
= objfile
->psymtabs
;
1077 psymtab
= psymtab
->next
)
1079 printf_filtered ("%s at ",
1081 gdb_print_host_address (psymtab
, gdb_stdout
);
1082 printf_filtered (", ");
1085 printf_filtered ("\n\n");
1089 /* Look through the partial symtabs for all symbols which begin
1090 by matching FUNC_NAME. Make sure we read that symbol table in. */
1093 read_symtabs_for_function (struct objfile
*objfile
, const char *func_name
)
1095 struct partial_symtab
*ps
;
1097 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1102 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1104 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1106 psymtab_to_symtab (objfile
, ps
);
1111 expand_partial_symbol_tables (struct objfile
*objfile
)
1113 struct partial_symtab
*psymtab
;
1115 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
1117 psymtab_to_symtab (objfile
, psymtab
);
1122 read_psymtabs_with_filename (struct objfile
*objfile
, const char *filename
)
1124 struct partial_symtab
*p
;
1126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, p
)
1128 /* Anonymous psymtabs don't have a name of a source file. */
1132 if (filename_cmp (filename
, p
->filename
) == 0)
1133 psymtab_to_symtab (objfile
, p
);
1138 map_symbol_filenames_psymtab (struct objfile
*objfile
,
1139 symbol_filename_ftype
*fun
, void *data
,
1142 struct partial_symtab
*ps
;
1144 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1146 const char *fullname
;
1151 /* We can skip shared psymtabs here, because any file name will be
1152 attached to the unshared psymtab. */
1153 if (ps
->user
!= NULL
)
1156 /* Anonymous psymtabs don't have a file name. */
1162 fullname
= psymtab_to_fullname (ps
);
1165 (*fun
) (ps
->filename
, fullname
, data
);
1169 /* Finds the fullname that a partial_symtab represents.
1171 If this functions finds the fullname, it will save it in ps->fullname
1172 and it will also return the value.
1174 If this function fails to find the file that this partial_symtab represents,
1175 NULL will be returned and ps->fullname will be set to NULL. */
1178 psymtab_to_fullname (struct partial_symtab
*ps
)
1187 /* Use cached copy if we have it.
1188 We rely on forget_cached_source_info being called appropriately
1189 to handle cases like the file being moved. */
1191 return ps
->fullname
;
1193 r
= find_and_open_source (ps
->filename
, ps
->dirname
, &ps
->fullname
);
1198 return ps
->fullname
;
1205 find_symbol_file_from_partial (struct objfile
*objfile
, const char *name
)
1207 struct partial_symtab
*pst
;
1209 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, pst
)
1211 if (lookup_partial_symbol (objfile
, pst
, name
, 1, VAR_DOMAIN
))
1212 return pst
->filename
;
1217 /* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1218 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1219 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1220 ever returns non-zero, and otherwise returns 0. */
1223 map_block (const char *name
, domain_enum
namespace, struct objfile
*objfile
,
1224 struct block
*block
,
1225 int (*callback
) (struct block
*, struct symbol
*, void *),
1226 void *data
, symbol_compare_ftype
*match
)
1228 struct block_iterator iter
;
1231 for (sym
= block_iter_match_first (block
, name
, match
, &iter
);
1232 sym
!= NULL
; sym
= block_iter_match_next (name
, match
, &iter
))
1234 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1235 SYMBOL_DOMAIN (sym
), namespace))
1237 if (callback (block
, sym
, data
))
1245 /* Psymtab version of map_matching_symbols. See its definition in
1246 the definition of quick_symbol_functions in symfile.h. */
1249 map_matching_symbols_psymtab (const char *name
, domain_enum
namespace,
1250 struct objfile
*objfile
, int global
,
1251 int (*callback
) (struct block
*,
1252 struct symbol
*, void *),
1254 symbol_compare_ftype
*match
,
1255 symbol_compare_ftype
*ordered_compare
)
1257 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1258 struct partial_symtab
*ps
;
1260 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1264 || match_partial_symbol (objfile
, ps
, global
, name
, namespace, match
,
1267 struct symtab
*s
= psymtab_to_symtab (objfile
, ps
);
1268 struct block
*block
;
1270 if (s
== NULL
|| !s
->primary
)
1272 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), block_kind
);
1273 if (map_block (name
, namespace, objfile
, block
,
1274 callback
, data
, match
))
1276 if (callback (block
, NULL
, data
))
1282 /* A helper for expand_symtabs_matching_via_partial that handles
1283 searching included psymtabs. This returns 1 if a symbol is found,
1284 and zero otherwise. It also updates the 'searched_flag' on the
1285 various psymtabs that it searches. */
1288 recursively_search_psymtabs (struct partial_symtab
*ps
,
1289 struct objfile
*objfile
,
1290 enum search_domain kind
,
1291 int (*name_matcher
) (const char *, void *),
1294 struct partial_symbol
**psym
;
1295 struct partial_symbol
**bound
, **gbound
, **sbound
;
1297 int result
= PST_SEARCHED_AND_NOT_FOUND
;
1300 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1301 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1303 /* Recurse into shared psymtabs first, because they may have already
1304 been searched, and this could save some time. */
1305 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1309 /* Skip non-shared dependencies, these are handled elsewhere. */
1310 if (ps
->dependencies
[i
]->user
== NULL
)
1313 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1314 objfile
, kind
, name_matcher
, data
);
1317 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1322 gbound
= (objfile
->global_psymbols
.list
1323 + ps
->globals_offset
+ ps
->n_global_syms
);
1324 sbound
= (objfile
->static_psymbols
.list
1325 + ps
->statics_offset
+ ps
->n_static_syms
);
1328 /* Go through all of the symbols stored in a partial
1329 symtab in one loop. */
1330 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
1335 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1337 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
1348 if ((kind
== ALL_DOMAIN
1349 || (kind
== VARIABLES_DOMAIN
1350 && SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
1351 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
1352 || (kind
== FUNCTIONS_DOMAIN
1353 && SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
1354 || (kind
== TYPES_DOMAIN
1355 && SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
))
1356 && (*name_matcher
) (SYMBOL_SEARCH_NAME (*psym
), data
))
1358 /* Found a match, so notify our caller. */
1359 result
= PST_SEARCHED_AND_FOUND
;
1366 ps
->searched_flag
= result
;
1367 return result
== PST_SEARCHED_AND_FOUND
;
1371 expand_symtabs_matching_via_partial
1372 (struct objfile
*objfile
,
1373 int (*file_matcher
) (const char *, void *),
1374 int (*name_matcher
) (const char *, void *),
1375 enum search_domain kind
,
1378 struct partial_symtab
*ps
;
1380 /* Clear the search flags. */
1381 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1383 ps
->searched_flag
= PST_NOT_SEARCHED
;
1386 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, ps
)
1391 /* We skip shared psymtabs because file-matching doesn't apply
1392 to them; but we search them later in the loop. */
1393 if (ps
->user
!= NULL
)
1400 if (! (*file_matcher
) (ps
->filename
, data
))
1404 if (recursively_search_psymtabs (ps
, objfile
, kind
, name_matcher
, data
))
1405 psymtab_to_symtab (objfile
, ps
);
1410 objfile_has_psyms (struct objfile
*objfile
)
1412 return objfile
->psymtabs
!= NULL
;
1415 const struct quick_symbol_functions psym_functions
=
1418 find_last_source_symtab_from_partial
,
1419 forget_cached_source_info_partial
,
1420 partial_map_symtabs_matching_filename
,
1421 lookup_symbol_aux_psymtabs
,
1422 print_psymtab_stats_for_objfile
,
1423 dump_psymtabs_for_objfile
,
1425 read_symtabs_for_function
,
1426 expand_partial_symbol_tables
,
1427 read_psymtabs_with_filename
,
1428 find_symbol_file_from_partial
,
1429 map_matching_symbols_psymtab
,
1430 expand_symtabs_matching_via_partial
,
1431 find_pc_sect_symtab_from_partial
,
1432 map_symbol_filenames_psymtab
1437 /* This compares two partial symbols by names, using strcmp_iw_ordered
1438 for the comparison. */
1441 compare_psymbols (const void *s1p
, const void *s2p
)
1443 struct partial_symbol
*const *s1
= s1p
;
1444 struct partial_symbol
*const *s2
= s2p
;
1446 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1
),
1447 SYMBOL_SEARCH_NAME (*s2
));
1451 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1453 /* Sort the global list; don't sort the static list. */
1455 qsort (objfile
->global_psymbols
.list
+ pst
->globals_offset
,
1456 pst
->n_global_syms
, sizeof (struct partial_symbol
*),
1460 /* Allocate and partially fill a partial symtab. It will be
1461 completely filled at the end of the symbol list.
1463 FILENAME is the name of the symbol-file we are reading from. */
1465 struct partial_symtab
*
1466 start_psymtab_common (struct objfile
*objfile
,
1467 struct section_offsets
*section_offsets
,
1468 const char *filename
,
1469 CORE_ADDR textlow
, struct partial_symbol
**global_syms
,
1470 struct partial_symbol
**static_syms
)
1472 struct partial_symtab
*psymtab
;
1474 psymtab
= allocate_psymtab (filename
, objfile
);
1475 psymtab
->section_offsets
= section_offsets
;
1476 psymtab
->textlow
= textlow
;
1477 psymtab
->texthigh
= psymtab
->textlow
; /* default */
1478 psymtab
->globals_offset
= global_syms
- objfile
->global_psymbols
.list
;
1479 psymtab
->statics_offset
= static_syms
- objfile
->static_psymbols
.list
;
1483 /* Calculate a hash code for the given partial symbol. The hash is
1484 calculated using the symbol's value, language, domain, class
1485 and name. These are the values which are set by
1486 add_psymbol_to_bcache. */
1488 static unsigned long
1489 psymbol_hash (const void *addr
, int length
)
1491 unsigned long h
= 0;
1492 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1493 unsigned int lang
= psymbol
->ginfo
.language
;
1494 unsigned int domain
= PSYMBOL_DOMAIN (psymbol
);
1495 unsigned int class = PSYMBOL_CLASS (psymbol
);
1497 h
= hash_continue (&psymbol
->ginfo
.value
, sizeof (psymbol
->ginfo
.value
), h
);
1498 h
= hash_continue (&lang
, sizeof (unsigned int), h
);
1499 h
= hash_continue (&domain
, sizeof (unsigned int), h
);
1500 h
= hash_continue (&class, sizeof (unsigned int), h
);
1501 h
= hash_continue (psymbol
->ginfo
.name
, strlen (psymbol
->ginfo
.name
), h
);
1506 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1507 For the comparison this function uses a symbols value,
1508 language, domain, class and name. */
1511 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1513 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1514 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1516 return (memcmp (&sym1
->ginfo
.value
, &sym1
->ginfo
.value
,
1517 sizeof (sym1
->ginfo
.value
)) == 0
1518 && sym1
->ginfo
.language
== sym2
->ginfo
.language
1519 && PSYMBOL_DOMAIN (sym1
) == PSYMBOL_DOMAIN (sym2
)
1520 && PSYMBOL_CLASS (sym1
) == PSYMBOL_CLASS (sym2
)
1521 && sym1
->ginfo
.name
== sym2
->ginfo
.name
);
1524 /* Initialize a partial symbol bcache. */
1526 struct psymbol_bcache
*
1527 psymbol_bcache_init (void)
1529 struct psymbol_bcache
*bcache
= XCALLOC (1, struct psymbol_bcache
);
1530 bcache
->bcache
= bcache_xmalloc (psymbol_hash
, psymbol_compare
);
1534 /* Free a partial symbol bcache. */
1536 psymbol_bcache_free (struct psymbol_bcache
*bcache
)
1541 bcache_xfree (bcache
->bcache
);
1545 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1548 psymbol_bcache_get_bcache (struct psymbol_bcache
*bcache
)
1550 return bcache
->bcache
;
1553 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1554 symbol before, add a copy to BCACHE. In either case, return a pointer
1555 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1556 1 in case of new entry or 0 if returning an old entry. */
1558 static const struct partial_symbol
*
1559 psymbol_bcache_full (struct partial_symbol
*sym
,
1560 struct psymbol_bcache
*bcache
,
1563 return bcache_full (sym
,
1564 sizeof (struct partial_symbol
),
1569 /* Helper function, initialises partial symbol structure and stashes
1570 it into objfile's bcache. Note that our caching mechanism will
1571 use all fields of struct partial_symbol to determine hash value of the
1572 structure. In other words, having two symbols with the same name but
1573 different domain (or address) is possible and correct. */
1575 static const struct partial_symbol
*
1576 add_psymbol_to_bcache (const char *name
, int namelength
, int copy_name
,
1578 enum address_class
class,
1579 long val
, /* Value as a long */
1580 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
1581 enum language language
, struct objfile
*objfile
,
1584 struct partial_symbol psymbol
;
1586 /* We must ensure that the entire 'value' field has been zeroed
1587 before assigning to it, because an assignment may not write the
1589 memset (&psymbol
.ginfo
.value
, 0, sizeof (psymbol
.ginfo
.value
));
1591 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1594 SYMBOL_VALUE (&psymbol
) = val
;
1598 SYMBOL_VALUE_ADDRESS (&psymbol
) = coreaddr
;
1600 SYMBOL_SECTION (&psymbol
) = 0;
1601 SYMBOL_OBJ_SECTION (&psymbol
) = NULL
;
1602 SYMBOL_SET_LANGUAGE (&psymbol
, language
);
1603 PSYMBOL_DOMAIN (&psymbol
) = domain
;
1604 PSYMBOL_CLASS (&psymbol
) = class;
1606 SYMBOL_SET_NAMES (&psymbol
, name
, namelength
, copy_name
, objfile
);
1608 /* Stash the partial symbol away in the cache. */
1609 return psymbol_bcache_full (&psymbol
,
1610 objfile
->psymbol_cache
,
1614 /* Increase the space allocated for LISTP, which is probably
1615 global_psymbols or static_psymbols. This space will eventually
1616 be freed in free_objfile(). */
1619 extend_psymbol_list (struct psymbol_allocation_list
*listp
,
1620 struct objfile
*objfile
)
1624 if (listp
->size
== 0)
1627 listp
->list
= (struct partial_symbol
**)
1628 xmalloc (new_size
* sizeof (struct partial_symbol
*));
1632 new_size
= listp
->size
* 2;
1633 listp
->list
= (struct partial_symbol
**)
1634 xrealloc ((char *) listp
->list
,
1635 new_size
* sizeof (struct partial_symbol
*));
1637 /* Next assumes we only went one over. Should be good if
1638 program works correctly. */
1639 listp
->next
= listp
->list
+ listp
->size
;
1640 listp
->size
= new_size
;
1643 /* Helper function, adds partial symbol to the given partial symbol
1647 append_psymbol_to_list (struct psymbol_allocation_list
*list
,
1648 const struct partial_symbol
*psym
,
1649 struct objfile
*objfile
)
1651 if (list
->next
>= list
->list
+ list
->size
)
1652 extend_psymbol_list (list
, objfile
);
1653 *list
->next
++ = (struct partial_symbol
*) psym
;
1654 OBJSTAT (objfile
, n_psyms
++);
1657 /* Add a symbol with a long value to a psymtab.
1658 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1659 Return the partial symbol that has been added. */
1662 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1664 enum address_class
class,
1665 struct psymbol_allocation_list
*list
,
1666 long val
, /* Value as a long */
1667 CORE_ADDR coreaddr
, /* Value as a CORE_ADDR */
1668 enum language language
, struct objfile
*objfile
)
1670 const struct partial_symbol
*psym
;
1674 /* Stash the partial symbol away in the cache. */
1675 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, class,
1676 val
, coreaddr
, language
, objfile
, &added
);
1678 /* Do not duplicate global partial symbols. */
1679 if (list
== &objfile
->global_psymbols
1683 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1684 append_psymbol_to_list (list
, psym
, objfile
);
1687 /* Initialize storage for partial symbols. */
1690 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1692 /* Free any previously allocated psymbol lists. */
1694 if (objfile
->global_psymbols
.list
)
1696 xfree (objfile
->global_psymbols
.list
);
1698 if (objfile
->static_psymbols
.list
)
1700 xfree (objfile
->static_psymbols
.list
);
1703 /* Current best guess is that approximately a twentieth
1704 of the total symbols (in a debugging file) are global or static
1705 oriented symbols, then multiply that by slop factor of two. */
1707 objfile
->global_psymbols
.size
= total_symbols
/ 10;
1708 objfile
->static_psymbols
.size
= total_symbols
/ 10;
1710 if (objfile
->global_psymbols
.size
> 0)
1712 objfile
->global_psymbols
.next
=
1713 objfile
->global_psymbols
.list
= (struct partial_symbol
**)
1714 xmalloc ((objfile
->global_psymbols
.size
1715 * sizeof (struct partial_symbol
*)));
1717 if (objfile
->static_psymbols
.size
> 0)
1719 objfile
->static_psymbols
.next
=
1720 objfile
->static_psymbols
.list
= (struct partial_symbol
**)
1721 xmalloc ((objfile
->static_psymbols
.size
1722 * sizeof (struct partial_symbol
*)));
1726 struct partial_symtab
*
1727 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1729 struct partial_symtab
*psymtab
;
1731 if (objfile
->free_psymtabs
)
1733 psymtab
= objfile
->free_psymtabs
;
1734 objfile
->free_psymtabs
= psymtab
->next
;
1737 psymtab
= (struct partial_symtab
*)
1738 obstack_alloc (&objfile
->objfile_obstack
,
1739 sizeof (struct partial_symtab
));
1741 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1742 psymtab
->filename
= obsavestring (filename
, strlen (filename
),
1743 &objfile
->objfile_obstack
);
1744 psymtab
->symtab
= NULL
;
1746 /* Prepend it to the psymtab list for the objfile it belongs to.
1747 Psymtabs are searched in most recent inserted -> least recent
1750 psymtab
->next
= objfile
->psymtabs
;
1751 objfile
->psymtabs
= psymtab
;
1753 if (symtab_create_debug
)
1755 /* Be a bit clever with debugging messages, and don't print objfile
1756 every time, only when it changes. */
1757 static char *last_objfile_name
= NULL
;
1759 if (last_objfile_name
== NULL
1760 || strcmp (last_objfile_name
, objfile
->name
) != 0)
1762 xfree (last_objfile_name
);
1763 last_objfile_name
= xstrdup (objfile
->name
);
1764 fprintf_unfiltered (gdb_stdlog
,
1765 "Creating one or more psymtabs for objfile %s ...\n",
1768 fprintf_unfiltered (gdb_stdlog
,
1769 "Created psymtab %s for module %s.\n",
1770 host_address_to_string (psymtab
), filename
);
1777 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1779 struct partial_symtab
**prev_pst
;
1782 Empty psymtabs happen as a result of header files which don't
1783 have any symbols in them. There can be a lot of them. But this
1784 check is wrong, in that a psymtab with N_SLINE entries but
1785 nothing else is not empty, but we don't realize that. Fixing
1786 that without slowing things down might be tricky. */
1788 /* First, snip it out of the psymtab chain. */
1790 prev_pst
= &(objfile
->psymtabs
);
1791 while ((*prev_pst
) != pst
)
1792 prev_pst
= &((*prev_pst
)->next
);
1793 (*prev_pst
) = pst
->next
;
1795 /* Next, put it on a free list for recycling. */
1797 pst
->next
= objfile
->free_psymtabs
;
1798 objfile
->free_psymtabs
= pst
;
1801 /* An object of this type is passed to discard_psymtabs_upto. */
1803 struct psymtab_state
1805 /* The objfile where psymtabs are discarded. */
1807 struct objfile
*objfile
;
1809 /* The first psymtab to save. */
1811 struct partial_symtab
*save
;
1814 /* A cleanup function used by make_cleanup_discard_psymtabs. */
1817 discard_psymtabs_upto (void *arg
)
1819 struct psymtab_state
*state
= arg
;
1821 while (state
->objfile
->psymtabs
!= state
->save
)
1822 discard_psymtab (state
->objfile
, state
->objfile
->psymtabs
);
1825 /* Return a new cleanup that discards all psymtabs created in OBJFILE
1826 after this function is called. */
1829 make_cleanup_discard_psymtabs (struct objfile
*objfile
)
1831 struct psymtab_state
*state
= XNEW (struct psymtab_state
);
1833 state
->objfile
= objfile
;
1834 state
->save
= objfile
->psymtabs
;
1836 return make_cleanup_dtor (discard_psymtabs_upto
, state
, xfree
);
1842 maintenance_print_psymbols (char *args
, int from_tty
)
1845 struct ui_file
*outfile
;
1846 struct cleanup
*cleanups
;
1847 char *symname
= NULL
;
1848 char *filename
= DEV_TTY
;
1849 struct objfile
*objfile
;
1850 struct partial_symtab
*ps
;
1857 print-psymbols takes an output file name and optional symbol file name"));
1859 argv
= gdb_buildargv (args
);
1860 cleanups
= make_cleanup_freeargv (argv
);
1862 if (argv
[0] != NULL
)
1865 /* If a second arg is supplied, it is a source file name to match on. */
1866 if (argv
[1] != NULL
)
1872 filename
= tilde_expand (filename
);
1873 make_cleanup (xfree
, filename
);
1875 outfile
= gdb_fopen (filename
, FOPEN_WT
);
1877 perror_with_name (filename
);
1878 make_cleanup_ui_file_delete (outfile
);
1880 ALL_PSYMTABS (objfile
, ps
)
1883 if (symname
== NULL
|| filename_cmp (symname
, ps
->filename
) == 0)
1884 dump_psymtab (objfile
, ps
, outfile
);
1886 do_cleanups (cleanups
);
1889 /* List all the partial symbol tables whose names match REGEXP (optional). */
1891 maintenance_info_psymtabs (char *regexp
, int from_tty
)
1893 struct program_space
*pspace
;
1894 struct objfile
*objfile
;
1899 ALL_PSPACES (pspace
)
1900 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1902 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1903 struct partial_symtab
*psymtab
;
1905 /* We don't want to print anything for this objfile until we
1906 actually find a symtab whose name matches. */
1907 int printed_objfile_start
= 0;
1909 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile
, psymtab
)
1914 || re_exec (psymtab
->filename
))
1916 if (! printed_objfile_start
)
1918 printf_filtered ("{ objfile %s ", objfile
->name
);
1920 printf_filtered ("((struct objfile *) %s)\n",
1921 host_address_to_string (objfile
));
1922 printed_objfile_start
= 1;
1925 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1927 printf_filtered ("((struct partial_symtab *) %s)\n",
1928 host_address_to_string (psymtab
));
1930 printf_filtered (" readin %s\n",
1931 psymtab
->readin
? "yes" : "no");
1932 printf_filtered (" fullname %s\n",
1934 ? psymtab
->fullname
: "(null)");
1935 printf_filtered (" text addresses ");
1936 fputs_filtered (paddress (gdbarch
, psymtab
->textlow
),
1938 printf_filtered (" -- ");
1939 fputs_filtered (paddress (gdbarch
, psymtab
->texthigh
),
1941 printf_filtered ("\n");
1942 printf_filtered (" psymtabs_addrmap_supported %s\n",
1943 (psymtab
->psymtabs_addrmap_supported
1945 printf_filtered (" globals ");
1946 if (psymtab
->n_global_syms
)
1948 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1949 host_address_to_string (objfile
->global_psymbols
.list
1950 + psymtab
->globals_offset
),
1951 psymtab
->n_global_syms
);
1954 printf_filtered ("(none)\n");
1955 printf_filtered (" statics ");
1956 if (psymtab
->n_static_syms
)
1958 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1959 host_address_to_string (objfile
->static_psymbols
.list
1960 + psymtab
->statics_offset
),
1961 psymtab
->n_static_syms
);
1964 printf_filtered ("(none)\n");
1965 printf_filtered (" dependencies ");
1966 if (psymtab
->number_of_dependencies
)
1970 printf_filtered ("{\n");
1971 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1973 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
1975 /* Note the string concatenation there --- no comma. */
1976 printf_filtered (" psymtab %s "
1977 "((struct partial_symtab *) %s)\n",
1979 host_address_to_string (dep
));
1981 printf_filtered (" }\n");
1984 printf_filtered ("(none)\n");
1985 printf_filtered (" }\n");
1989 if (printed_objfile_start
)
1990 printf_filtered ("}\n");
1994 /* Check consistency of psymtabs and symtabs. */
1997 maintenance_check_symtabs (char *ignore
, int from_tty
)
2000 struct partial_symbol
**psym
;
2001 struct symtab
*s
= NULL
;
2002 struct partial_symtab
*ps
;
2003 struct blockvector
*bv
;
2004 struct objfile
*objfile
;
2008 ALL_PSYMTABS (objfile
, ps
)
2010 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2012 s
= psymtab_to_symtab (objfile
, ps
);
2015 bv
= BLOCKVECTOR (s
);
2016 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2017 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2018 length
= ps
->n_static_syms
;
2021 sym
= lookup_block_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2022 SYMBOL_DOMAIN (*psym
));
2025 printf_filtered ("Static symbol `");
2026 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2027 printf_filtered ("' only found in ");
2028 puts_filtered (ps
->filename
);
2029 printf_filtered (" psymtab\n");
2033 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2034 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2035 length
= ps
->n_global_syms
;
2038 sym
= lookup_block_symbol (b
, SYMBOL_LINKAGE_NAME (*psym
),
2039 SYMBOL_DOMAIN (*psym
));
2042 printf_filtered ("Global symbol `");
2043 puts_filtered (SYMBOL_LINKAGE_NAME (*psym
));
2044 printf_filtered ("' only found in ");
2045 puts_filtered (ps
->filename
);
2046 printf_filtered (" psymtab\n");
2050 if (ps
->texthigh
< ps
->textlow
)
2052 printf_filtered ("Psymtab ");
2053 puts_filtered (ps
->filename
);
2054 printf_filtered (" covers bad range ");
2055 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2056 printf_filtered (" - ");
2057 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2058 printf_filtered ("\n");
2061 if (ps
->texthigh
== 0)
2063 if (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
))
2065 printf_filtered ("Psymtab ");
2066 puts_filtered (ps
->filename
);
2067 printf_filtered (" covers ");
2068 fputs_filtered (paddress (gdbarch
, ps
->textlow
), gdb_stdout
);
2069 printf_filtered (" - ");
2070 fputs_filtered (paddress (gdbarch
, ps
->texthigh
), gdb_stdout
);
2071 printf_filtered (" but symtab covers only ");
2072 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2073 printf_filtered (" - ");
2074 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2075 printf_filtered ("\n");
2083 expand_partial_symbol_names (int (*fun
) (const char *, void *),
2086 struct objfile
*objfile
;
2088 ALL_OBJFILES (objfile
)
2091 objfile
->sf
->qf
->expand_symtabs_matching (objfile
, NULL
, fun
,
2097 map_partial_symbol_filenames (symbol_filename_ftype
*fun
, void *data
,
2100 struct objfile
*objfile
;
2102 ALL_OBJFILES (objfile
)
2105 objfile
->sf
->qf
->map_symbol_filenames (objfile
, fun
, data
,
2110 extern initialize_file_ftype _initialize_psymtab
;
2113 _initialize_psymtab (void)
2115 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2116 Print dump of current partial symbol definitions.\n\
2117 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2118 If a SOURCE file is specified, dump only that file's partial symbols."),
2119 &maintenanceprintlist
);
2121 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2122 List the partial symbol tables for all object files.\n\
2123 This does not include information about individual partial symbols,\n\
2124 just the symbol table structures themselves."),
2125 &maintenanceinfolist
);
2127 add_cmd ("check-symtabs", class_maintenance
, maintenance_check_symtabs
,
2128 _("Check consistency of psymtabs and symtabs."),