1 /* Partial symbol tables.
3 Copyright (C) 2009-2019 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"
43 struct bcache
*bcache
;
46 static struct partial_symbol
*match_partial_symbol (struct objfile
*,
47 struct partial_symtab
*,
49 const char *, domain_enum
,
50 symbol_name_match_type
,
51 symbol_compare_ftype
*);
53 static struct partial_symbol
*lookup_partial_symbol (struct objfile
*,
54 struct partial_symtab
*,
58 static const char *psymtab_to_fullname (struct partial_symtab
*ps
);
60 static struct partial_symbol
*find_pc_sect_psymbol (struct objfile
*,
61 struct partial_symtab
*,
63 struct obj_section
*);
65 static struct compunit_symtab
*psymtab_to_symtab (struct objfile
*objfile
,
66 struct partial_symtab
*pst
);
71 require_partial_symbols (struct objfile
*objfile
, int verbose
)
73 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0)
75 objfile
->flags
|= OBJF_PSYMTABS_READ
;
77 if (objfile
->sf
->sym_read_psymbols
)
80 printf_filtered (_("Reading symbols from %s...\n"),
81 objfile_name (objfile
));
82 (*objfile
->sf
->sym_read_psymbols
) (objfile
);
84 /* Partial symbols list are not expected to changed after this
86 objfile
->global_psymbols
.shrink_to_fit ();
87 objfile
->static_psymbols
.shrink_to_fit ();
89 if (verbose
&& !objfile_has_symbols (objfile
))
90 printf_filtered (_("(No debugging symbols found in %s)\n"),
91 objfile_name (objfile
));
95 return objfile_psymtabs (objfile
);
98 /* Helper function for psym_map_symtabs_matching_filename that
99 expands the symtabs and calls the iterator. */
102 partial_map_expand_apply (struct objfile
*objfile
,
104 const char *real_path
,
105 struct partial_symtab
*pst
,
106 gdb::function_view
<bool (symtab
*)> callback
)
108 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
110 /* Shared psymtabs should never be seen here. Instead they should
111 be handled properly by the caller. */
112 gdb_assert (pst
->user
== NULL
);
114 /* Don't visit already-expanded psymtabs. */
118 /* This may expand more than one symtab, and we want to iterate over
120 psymtab_to_symtab (objfile
, pst
);
122 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
123 last_made
, callback
);
126 /* Psymtab version of map_symtabs_matching_filename. See its definition in
127 the definition of quick_symbol_functions in symfile.h. */
130 psym_map_symtabs_matching_filename
131 (struct objfile
*objfile
,
133 const char *real_path
,
134 gdb::function_view
<bool (symtab
*)> callback
)
136 const char *name_basename
= lbasename (name
);
138 for (partial_symtab
*pst
: require_partial_symbols (objfile
, 1))
140 /* We can skip shared psymtabs here, because any file name will be
141 attached to the unshared psymtab. */
142 if (pst
->user
!= NULL
)
145 /* Anonymous psymtabs don't have a file name. */
149 if (compare_filenames_for_search (pst
->filename
, name
))
151 if (partial_map_expand_apply (objfile
, name
, real_path
,
157 /* Before we invoke realpath, which can get expensive when many
158 files are involved, do a quick comparison of the basenames. */
159 if (! basenames_may_differ
160 && FILENAME_CMP (name_basename
, lbasename (pst
->filename
)) != 0)
163 if (compare_filenames_for_search (psymtab_to_fullname (pst
), name
))
165 if (partial_map_expand_apply (objfile
, name
, real_path
,
171 /* If the user gave us an absolute path, try to find the file in
172 this symtab and use its absolute path. */
173 if (real_path
!= NULL
)
175 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
176 gdb_assert (IS_ABSOLUTE_PATH (name
));
177 if (filename_cmp (psymtab_to_fullname (pst
), real_path
) == 0)
179 if (partial_map_expand_apply (objfile
, name
, real_path
,
190 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
191 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
193 static struct partial_symtab
*
194 find_pc_sect_psymtab_closer (struct objfile
*objfile
,
195 CORE_ADDR pc
, struct obj_section
*section
,
196 struct partial_symtab
*pst
,
197 struct bound_minimal_symbol msymbol
)
199 struct partial_symtab
*tpst
;
200 struct partial_symtab
*best_pst
= pst
;
201 CORE_ADDR best_addr
= pst
->text_low (objfile
);
203 gdb_assert (!pst
->psymtabs_addrmap_supported
);
205 /* An objfile that has its functions reordered might have
206 many partial symbol tables containing the PC, but
207 we want the partial symbol table that contains the
208 function containing the PC. */
209 if (!(objfile
->flags
& OBJF_REORDERED
)
210 && section
== NULL
) /* Can't validate section this way. */
213 if (msymbol
.minsym
== NULL
)
216 /* The code range of partial symtabs sometimes overlap, so, in
217 the loop below, we need to check all partial symtabs and
218 find the one that fits better for the given PC address. We
219 select the partial symtab that contains a symbol whose
220 address is closest to the PC address. By closest we mean
221 that find_pc_sect_symbol returns the symbol with address
222 that is closest and still less than the given PC. */
223 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
225 if (pc
>= tpst
->text_low (objfile
) && pc
< tpst
->text_high (objfile
))
227 struct partial_symbol
*p
;
230 /* NOTE: This assumes that every psymbol has a
231 corresponding msymbol, which is not necessarily
232 true; the debug info might be much richer than the
233 object's symbol table. */
234 p
= find_pc_sect_psymbol (objfile
, tpst
, pc
, section
);
236 && (p
->address (objfile
) == BMSYMBOL_VALUE_ADDRESS (msymbol
)))
239 /* Also accept the textlow value of a psymtab as a
240 "symbol", to provide some support for partial
241 symbol tables with line information but no debug
242 symbols (e.g. those produced by an assembler). */
244 this_addr
= p
->address (objfile
);
246 this_addr
= tpst
->text_low (objfile
);
248 /* Check whether it is closer than our current
249 BEST_ADDR. Since this symbol address is
250 necessarily lower or equal to PC, the symbol closer
251 to PC is the symbol which address is the highest.
252 This way we return the psymtab which contains such
253 best match symbol. This can help in cases where the
254 symbol information/debuginfo is not complete, like
255 for instance on IRIX6 with gcc, where no debug info
256 is emitted for statics. (See also the nodebug.exp
258 if (this_addr
> best_addr
)
260 best_addr
= this_addr
;
268 /* Find which partial symtab contains PC and SECTION. Return NULL if
269 none. We return the psymtab that contains a symbol whose address
270 exactly matches PC, or, if we cannot find an exact match, the
271 psymtab that contains a symbol whose address is closest to PC. */
273 static struct partial_symtab
*
274 find_pc_sect_psymtab (struct objfile
*objfile
, CORE_ADDR pc
,
275 struct obj_section
*section
,
276 struct bound_minimal_symbol msymbol
)
278 CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
279 SECT_OFF_TEXT (objfile
));
281 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
282 than the later used TEXTLOW/TEXTHIGH one. */
284 if (objfile
->psymtabs_addrmap
!= NULL
)
286 struct partial_symtab
*pst
287 = ((struct partial_symtab
*)
288 addrmap_find (objfile
->psymtabs_addrmap
, pc
- baseaddr
));
291 /* FIXME: addrmaps currently do not handle overlayed sections,
292 so fall back to the non-addrmap case if we're debugging
293 overlays and the addrmap returned the wrong section. */
294 if (overlay_debugging
&& msymbol
.minsym
!= NULL
&& section
!= NULL
)
296 struct partial_symbol
*p
;
298 /* NOTE: This assumes that every psymbol has a
299 corresponding msymbol, which is not necessarily
300 true; the debug info might be much richer than the
301 object's symbol table. */
302 p
= find_pc_sect_psymbol (objfile
, pst
, pc
, section
);
304 || (p
->address (objfile
)
305 != BMSYMBOL_VALUE_ADDRESS (msymbol
)))
309 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
310 PSYMTABS_ADDRMAP we used has already the best 1-byte
311 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
312 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
321 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
322 which still have no corresponding full SYMTABs read. But it is not
323 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
326 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
327 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
328 debug info type in single OBJFILE. */
330 for (partial_symtab
*pst
: require_partial_symbols (objfile
, 1))
331 if (!pst
->psymtabs_addrmap_supported
332 && pc
>= pst
->text_low (objfile
) && pc
< pst
->text_high (objfile
))
334 struct partial_symtab
*best_pst
;
336 best_pst
= find_pc_sect_psymtab_closer (objfile
, pc
, section
, pst
,
338 if (best_pst
!= NULL
)
345 /* Psymtab version of find_pc_sect_compunit_symtab. See its definition in
346 the definition of quick_symbol_functions in symfile.h. */
348 static struct compunit_symtab
*
349 psym_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
350 struct bound_minimal_symbol msymbol
,
352 struct obj_section
*section
,
355 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
, section
,
359 if (warn_if_readin
&& ps
->readin
)
360 /* Might want to error() here (in case symtab is corrupt and
361 will cause a core dump), but maybe we can successfully
362 continue, so let's not. */
364 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
365 paddress (get_objfile_arch (objfile
), pc
));
366 psymtab_to_symtab (objfile
, ps
);
367 return ps
->compunit_symtab
;
372 /* Find which partial symbol within a psymtab matches PC and SECTION.
373 Return NULL if none. */
375 static struct partial_symbol
*
376 find_pc_sect_psymbol (struct objfile
*objfile
,
377 struct partial_symtab
*psymtab
, CORE_ADDR pc
,
378 struct obj_section
*section
)
380 struct partial_symbol
*best
= NULL
;
382 const CORE_ADDR textlow
= psymtab
->text_low (objfile
);
384 gdb_assert (psymtab
!= NULL
);
386 /* Cope with programs that start at address 0. */
387 best_pc
= (textlow
!= 0) ? textlow
- 1 : 0;
389 /* Search the global symbols as well as the static symbols, so that
390 find_pc_partial_function doesn't use a minimal symbol and thus
391 cache a bad endaddr. */
392 for (int i
= 0; i
< psymtab
->n_global_syms
; i
++)
394 partial_symbol
*p
= objfile
->global_psymbols
[psymtab
->globals_offset
+ i
];
396 if (p
->domain
== VAR_DOMAIN
397 && p
->aclass
== LOC_BLOCK
398 && pc
>= p
->address (objfile
)
399 && (p
->address (objfile
) > best_pc
400 || (psymtab
->text_low (objfile
) == 0
401 && best_pc
== 0 && p
->address (objfile
) == 0)))
403 if (section
!= NULL
) /* Match on a specific section. */
405 if (!matching_obj_sections (p
->obj_section (objfile
),
409 best_pc
= p
->address (objfile
);
414 for (int i
= 0; i
< psymtab
->n_static_syms
; i
++)
416 partial_symbol
*p
= objfile
->static_psymbols
[psymtab
->statics_offset
+ i
];
418 if (p
->domain
== VAR_DOMAIN
419 && p
->aclass
== LOC_BLOCK
420 && pc
>= p
->address (objfile
)
421 && (p
->address (objfile
) > best_pc
422 || (psymtab
->text_low (objfile
) == 0
423 && best_pc
== 0 && p
->address (objfile
) == 0)))
425 if (section
!= NULL
) /* Match on a specific section. */
427 if (!matching_obj_sections (p
->obj_section (objfile
),
431 best_pc
= p
->address (objfile
);
439 /* Psymtab version of lookup_symbol. See its definition in
440 the definition of quick_symbol_functions in symfile.h. */
442 static struct compunit_symtab
*
443 psym_lookup_symbol (struct objfile
*objfile
,
444 int block_index
, const char *name
,
445 const domain_enum domain
)
447 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
448 struct compunit_symtab
*stab_best
= NULL
;
450 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
452 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
454 if (!ps
->readin
&& lookup_partial_symbol (objfile
, ps
, name
,
455 psymtab_index
, domain
))
457 struct symbol
*sym
, *with_opaque
= NULL
;
458 struct compunit_symtab
*stab
= psymtab_to_symtab (objfile
, ps
);
459 /* Note: While psymtab_to_symtab can return NULL if the
460 partial symtab is empty, we can assume it won't here
461 because lookup_partial_symbol succeeded. */
462 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
463 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
465 sym
= block_find_symbol (block
, name
, domain
,
466 block_find_non_opaque_type_preferred
,
469 /* Some caution must be observed with overloaded functions
470 and methods, since the index will not contain any overload
471 information (but NAME might contain it). */
474 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
476 if (with_opaque
!= NULL
477 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
480 /* Keep looking through other psymtabs. */
487 /* Returns true if PSYM matches LOOKUP_NAME. */
490 psymbol_name_matches (partial_symbol
*psym
,
491 const lookup_name_info
&lookup_name
)
493 const language_defn
*lang
= language_def (psym
->language
);
494 symbol_name_matcher_ftype
*name_match
495 = get_symbol_name_matcher (lang
, lookup_name
);
496 return name_match (symbol_search_name (psym
), lookup_name
, NULL
);
499 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
500 the global block of PST if GLOBAL, and otherwise the static block.
501 MATCH is the comparison operation that returns true iff MATCH (s,
502 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
503 non-null, the symbols in the block are assumed to be ordered
504 according to it (allowing binary search). It must be compatible
505 with MATCH. Returns the symbol, if found, and otherwise NULL. */
507 static struct partial_symbol
*
508 match_partial_symbol (struct objfile
*objfile
,
509 struct partial_symtab
*pst
, int global
,
510 const char *name
, domain_enum domain
,
511 symbol_name_match_type match_type
,
512 symbol_compare_ftype
*ordered_compare
)
514 struct partial_symbol
**start
, **psym
;
515 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
516 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
517 int do_linear_search
= 1;
522 lookup_name_info
lookup_name (name
, match_type
);
525 &objfile
->global_psymbols
[pst
->globals_offset
] :
526 &objfile
->static_psymbols
[pst
->statics_offset
]);
528 if (global
&& ordered_compare
) /* Can use a binary search. */
530 do_linear_search
= 0;
532 /* Binary search. This search is guaranteed to end with center
533 pointing at the earliest partial symbol whose name might be
534 correct. At that point *all* partial symbols with an
535 appropriate name will be checked against the correct
539 top
= start
+ length
- 1;
543 center
= bottom
+ (top
- bottom
) / 2;
544 gdb_assert (center
< top
);
546 enum language lang
= (*center
)->language
;
548 = lookup_name
.language_lookup_name (lang
).c_str ();
550 if (ordered_compare (symbol_search_name (*center
), lang_ln
) >= 0)
555 gdb_assert (top
== bottom
);
557 while (top
<= real_top
558 && psymbol_name_matches (*top
, lookup_name
))
560 if (symbol_matches_domain ((*top
)->language
,
561 (*top
)->domain
, domain
))
567 /* Can't use a binary search or else we found during the binary search that
568 we should also do a linear search. */
570 if (do_linear_search
)
572 for (psym
= start
; psym
< start
+ length
; psym
++)
574 if (symbol_matches_domain ((*psym
)->language
,
575 (*psym
)->domain
, domain
)
576 && psymbol_name_matches (*psym
, lookup_name
))
584 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
585 not contain any method/function instance information (since this would
586 force reading type information while reading psymtabs). Therefore,
587 if NAME contains overload information, it must be stripped before searching
590 static gdb::unique_xmalloc_ptr
<char>
591 psymtab_search_name (const char *name
)
593 switch (current_language
->la_language
)
597 if (strchr (name
, '('))
599 gdb::unique_xmalloc_ptr
<char> ret
= cp_remove_params (name
);
611 return gdb::unique_xmalloc_ptr
<char> (xstrdup (name
));
614 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
615 Check the global symbols if GLOBAL, the static symbols if not. */
617 static struct partial_symbol
*
618 lookup_partial_symbol (struct objfile
*objfile
,
619 struct partial_symtab
*pst
, const char *name
,
620 int global
, domain_enum domain
)
622 struct partial_symbol
**start
, **psym
;
623 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
624 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
625 int do_linear_search
= 1;
630 gdb::unique_xmalloc_ptr
<char> search_name
= psymtab_search_name (name
);
632 lookup_name_info
lookup_name (search_name
.get (), symbol_name_match_type::FULL
);
635 &objfile
->global_psymbols
[pst
->globals_offset
] :
636 &objfile
->static_psymbols
[pst
->statics_offset
]);
638 if (global
) /* This means we can use a binary search. */
640 do_linear_search
= 0;
642 /* Binary search. This search is guaranteed to end with center
643 pointing at the earliest partial symbol whose name might be
644 correct. At that point *all* partial symbols with an
645 appropriate name will be checked against the correct
649 top
= start
+ length
- 1;
653 center
= bottom
+ (top
- bottom
) / 2;
655 internal_error (__FILE__
, __LINE__
,
656 _("failed internal consistency check"));
657 if (strcmp_iw_ordered (symbol_search_name (*center
),
658 search_name
.get ()) >= 0)
667 if (!(top
== bottom
))
668 internal_error (__FILE__
, __LINE__
,
669 _("failed internal consistency check"));
671 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
672 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
673 while (top
>= start
&& symbol_matches_search_name (*top
, lookup_name
))
676 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
679 while (top
<= real_top
&& symbol_matches_search_name (*top
, lookup_name
))
681 if (symbol_matches_domain ((*top
)->language
,
682 (*top
)->domain
, domain
))
688 /* Can't use a binary search or else we found during the binary search that
689 we should also do a linear search. */
691 if (do_linear_search
)
693 for (psym
= start
; psym
< start
+ length
; psym
++)
695 if (symbol_matches_domain ((*psym
)->language
,
696 (*psym
)->domain
, domain
)
697 && symbol_matches_search_name (*psym
, lookup_name
))
705 /* Get the symbol table that corresponds to a partial_symtab.
706 This is fast after the first time you do it.
707 The result will be NULL if the primary symtab has no symbols,
708 which can happen. Otherwise the result is the primary symtab
709 that contains PST. */
711 static struct compunit_symtab
*
712 psymtab_to_symtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
714 /* If it is a shared psymtab, find an unshared psymtab that includes
715 it. Any such psymtab will do. */
716 while (pst
->user
!= NULL
)
719 /* If it's been looked up before, return it. */
720 if (pst
->compunit_symtab
)
721 return pst
->compunit_symtab
;
723 /* If it has not yet been read in, read it. */
726 scoped_restore decrementer
= increment_reading_symtab ();
728 (*pst
->read_symtab
) (pst
, objfile
);
731 return pst
->compunit_symtab
;
734 /* Psymtab version of find_last_source_symtab. See its definition in
735 the definition of quick_symbol_functions in symfile.h. */
737 static struct symtab
*
738 psym_find_last_source_symtab (struct objfile
*ofp
)
740 struct partial_symtab
*cs_pst
= NULL
;
742 for (partial_symtab
*ps
: require_partial_symbols (ofp
, 1))
744 const char *name
= ps
->filename
;
745 int len
= strlen (name
);
747 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
748 || strcmp (name
, "<<C++-namespaces>>") == 0)))
756 internal_error (__FILE__
, __LINE__
,
757 _("select_source_symtab: "
758 "readin pst found and no symtabs."));
762 struct compunit_symtab
*cust
= psymtab_to_symtab (ofp
, cs_pst
);
766 return compunit_primary_filetab (cust
);
772 /* Psymtab version of forget_cached_source_info. See its definition in
773 the definition of quick_symbol_functions in symfile.h. */
776 psym_forget_cached_source_info (struct objfile
*objfile
)
778 for (partial_symtab
*pst
: require_partial_symbols (objfile
, 1))
780 if (pst
->fullname
!= NULL
)
782 xfree (pst
->fullname
);
783 pst
->fullname
= NULL
;
789 print_partial_symbols (struct gdbarch
*gdbarch
, struct objfile
*objfile
,
790 struct partial_symbol
**p
, int count
, const char *what
,
791 struct ui_file
*outfile
)
793 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
797 fprintf_filtered (outfile
, " `%s'", (*p
)->name
);
798 if (symbol_demangled_name (*p
) != NULL
)
800 fprintf_filtered (outfile
, " `%s'", symbol_demangled_name (*p
));
802 fputs_filtered (", ", outfile
);
803 switch ((*p
)->domain
)
806 fputs_filtered ("undefined domain, ", outfile
);
809 /* This is the usual thing -- don't print it. */
812 fputs_filtered ("struct domain, ", outfile
);
815 fputs_filtered ("label domain, ", outfile
);
818 fputs_filtered ("<invalid domain>, ", outfile
);
821 switch ((*p
)->aclass
)
824 fputs_filtered ("undefined", outfile
);
827 fputs_filtered ("constant int", outfile
);
830 fputs_filtered ("static", outfile
);
833 fputs_filtered ("register", outfile
);
836 fputs_filtered ("pass by value", outfile
);
839 fputs_filtered ("pass by reference", outfile
);
841 case LOC_REGPARM_ADDR
:
842 fputs_filtered ("register address parameter", outfile
);
845 fputs_filtered ("stack parameter", outfile
);
848 fputs_filtered ("type", outfile
);
851 fputs_filtered ("label", outfile
);
854 fputs_filtered ("function", outfile
);
856 case LOC_CONST_BYTES
:
857 fputs_filtered ("constant bytes", outfile
);
860 fputs_filtered ("unresolved", outfile
);
862 case LOC_OPTIMIZED_OUT
:
863 fputs_filtered ("optimized out", outfile
);
866 fputs_filtered ("computed at runtime", outfile
);
869 fputs_filtered ("<invalid location>", outfile
);
872 fputs_filtered (", ", outfile
);
873 fputs_filtered (paddress (gdbarch
, (*p
)->unrelocated_address ()), outfile
);
874 fprintf_filtered (outfile
, "\n");
880 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
881 struct ui_file
*outfile
)
883 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
886 if (psymtab
->anonymous
)
888 fprintf_filtered (outfile
, "\nAnonymous partial symtab (%s) ",
893 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
896 fprintf_filtered (outfile
, "(object ");
897 gdb_print_host_address (psymtab
, outfile
);
898 fprintf_filtered (outfile
, ")\n\n");
899 fprintf_filtered (outfile
, " Read from object file %s (",
900 objfile_name (objfile
));
901 gdb_print_host_address (objfile
, outfile
);
902 fprintf_filtered (outfile
, ")\n");
906 fprintf_filtered (outfile
,
907 " Full symtab was read (at ");
908 gdb_print_host_address (psymtab
->compunit_symtab
, outfile
);
909 fprintf_filtered (outfile
, " by function at ");
910 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
911 fprintf_filtered (outfile
, ")\n");
914 fprintf_filtered (outfile
, " Symbols cover text addresses ");
915 fputs_filtered (paddress (gdbarch
, psymtab
->text_low (objfile
)), outfile
);
916 fprintf_filtered (outfile
, "-");
917 fputs_filtered (paddress (gdbarch
, psymtab
->text_high (objfile
)), outfile
);
918 fprintf_filtered (outfile
, "\n");
919 fprintf_filtered (outfile
, " Address map supported - %s.\n",
920 psymtab
->psymtabs_addrmap_supported
? "yes" : "no");
921 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
922 psymtab
->number_of_dependencies
);
923 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
925 fprintf_filtered (outfile
, " %d ", i
);
926 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
927 fprintf_filtered (outfile
, " %s\n",
928 psymtab
->dependencies
[i
]->filename
);
930 if (psymtab
->user
!= NULL
)
932 fprintf_filtered (outfile
, " Shared partial symtab with user ");
933 gdb_print_host_address (psymtab
->user
, outfile
);
934 fprintf_filtered (outfile
, "\n");
936 if (psymtab
->n_global_syms
> 0)
938 print_partial_symbols (gdbarch
, objfile
,
939 &objfile
->global_psymbols
[psymtab
->globals_offset
],
940 psymtab
->n_global_syms
, "Global", outfile
);
942 if (psymtab
->n_static_syms
> 0)
944 print_partial_symbols (gdbarch
, objfile
,
945 &objfile
->static_psymbols
[psymtab
->statics_offset
],
946 psymtab
->n_static_syms
, "Static", outfile
);
948 fprintf_filtered (outfile
, "\n");
951 /* Psymtab version of print_stats. See its definition in
952 the definition of quick_symbol_functions in symfile.h. */
955 psym_print_stats (struct objfile
*objfile
)
960 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
965 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i
);
968 /* Psymtab version of dump. See its definition in
969 the definition of quick_symbol_functions in symfile.h. */
972 psym_dump (struct objfile
*objfile
)
974 struct partial_symtab
*psymtab
;
976 if (objfile
->psymtabs
)
978 printf_filtered ("Psymtabs:\n");
979 for (psymtab
= objfile
->psymtabs
;
981 psymtab
= psymtab
->next
)
983 printf_filtered ("%s at ",
985 gdb_print_host_address (psymtab
, gdb_stdout
);
986 printf_filtered (", ");
989 printf_filtered ("\n\n");
993 /* Psymtab version of expand_symtabs_for_function. See its definition in
994 the definition of quick_symbol_functions in symfile.h. */
997 psym_expand_symtabs_for_function (struct objfile
*objfile
,
998 const char *func_name
)
1000 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
1005 if ((lookup_partial_symbol (objfile
, ps
, func_name
, 1, VAR_DOMAIN
)
1007 || (lookup_partial_symbol (objfile
, ps
, func_name
, 0, VAR_DOMAIN
)
1009 psymtab_to_symtab (objfile
, ps
);
1013 /* Psymtab version of expand_all_symtabs. See its definition in
1014 the definition of quick_symbol_functions in symfile.h. */
1017 psym_expand_all_symtabs (struct objfile
*objfile
)
1019 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, 1))
1020 psymtab_to_symtab (objfile
, psymtab
);
1023 /* Psymtab version of expand_symtabs_with_fullname. See its definition in
1024 the definition of quick_symbol_functions in symfile.h. */
1027 psym_expand_symtabs_with_fullname (struct objfile
*objfile
,
1028 const char *fullname
)
1030 for (partial_symtab
*p
: require_partial_symbols (objfile
, 1))
1032 /* Anonymous psymtabs don't have a name of a source file. */
1036 /* psymtab_to_fullname tries to open the file which is slow.
1037 Don't call it if we know the basenames don't match. */
1038 if ((basenames_may_differ
1039 || filename_cmp (lbasename (fullname
), lbasename (p
->filename
)) == 0)
1040 && filename_cmp (fullname
, psymtab_to_fullname (p
)) == 0)
1041 psymtab_to_symtab (objfile
, p
);
1045 /* Psymtab version of map_symbol_filenames. See its definition in
1046 the definition of quick_symbol_functions in symfile.h. */
1049 psym_map_symbol_filenames (struct objfile
*objfile
,
1050 symbol_filename_ftype
*fun
, void *data
,
1053 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
1055 const char *fullname
;
1060 /* We can skip shared psymtabs here, because any file name will be
1061 attached to the unshared psymtab. */
1062 if (ps
->user
!= NULL
)
1065 /* Anonymous psymtabs don't have a file name. */
1071 fullname
= psymtab_to_fullname (ps
);
1074 (*fun
) (ps
->filename
, fullname
, data
);
1078 /* Finds the fullname that a partial_symtab represents.
1080 If this functions finds the fullname, it will save it in ps->fullname
1081 and it will also return the value.
1083 If this function fails to find the file that this partial_symtab represents,
1084 NULL will be returned and ps->fullname will be set to NULL. */
1087 psymtab_to_fullname (struct partial_symtab
*ps
)
1089 gdb_assert (!ps
->anonymous
);
1091 /* Use cached copy if we have it.
1092 We rely on forget_cached_source_info being called appropriately
1093 to handle cases like the file being moved. */
1094 if (ps
->fullname
== NULL
)
1096 gdb::unique_xmalloc_ptr
<char> fullname
;
1097 scoped_fd fd
= find_and_open_source (ps
->filename
, ps
->dirname
,
1099 ps
->fullname
= fullname
.release ();
1103 /* rewrite_source_path would be applied by find_and_open_source, we
1104 should report the pathname where GDB tried to find the file. */
1106 if (ps
->dirname
== NULL
|| IS_ABSOLUTE_PATH (ps
->filename
))
1107 fullname
.reset (xstrdup (ps
->filename
));
1109 fullname
.reset (concat (ps
->dirname
, SLASH_STRING
,
1110 ps
->filename
, (char *) NULL
));
1112 ps
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1113 if (ps
->fullname
== NULL
)
1114 ps
->fullname
= fullname
.release ();
1118 return ps
->fullname
;
1121 /* For all symbols, s, in BLOCK that are in DOMAIN and match NAME
1122 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1123 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1124 ever returns non-zero, and otherwise returns 0. */
1127 map_block (const char *name
, domain_enum domain
, struct objfile
*objfile
,
1128 struct block
*block
,
1129 int (*callback
) (struct block
*, struct symbol
*, void *),
1130 void *data
, symbol_name_match_type match
)
1132 struct block_iterator iter
;
1135 lookup_name_info
lookup_name (name
, match
);
1137 for (sym
= block_iter_match_first (block
, lookup_name
, &iter
);
1139 sym
= block_iter_match_next (lookup_name
, &iter
))
1141 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1142 SYMBOL_DOMAIN (sym
), domain
))
1144 if (callback (block
, sym
, data
))
1152 /* Psymtab version of map_matching_symbols. See its definition in
1153 the definition of quick_symbol_functions in symfile.h. */
1156 psym_map_matching_symbols (struct objfile
*objfile
,
1157 const char *name
, domain_enum domain
,
1159 int (*callback
) (struct block
*,
1160 struct symbol
*, void *),
1162 symbol_name_match_type match
,
1163 symbol_compare_ftype
*ordered_compare
)
1165 const int block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
1167 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
1171 || match_partial_symbol (objfile
, ps
, global
, name
, domain
, match
,
1174 struct compunit_symtab
*cust
= psymtab_to_symtab (objfile
, ps
);
1175 struct block
*block
;
1179 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
1180 if (map_block (name
, domain
, objfile
, block
,
1181 callback
, data
, match
))
1183 if (callback (block
, NULL
, data
))
1189 /* A helper for psym_expand_symtabs_matching that handles searching
1190 included psymtabs. This returns true if a symbol is found, and
1191 false otherwise. It also updates the 'searched_flag' on the
1192 various psymtabs that it searches. */
1195 recursively_search_psymtabs
1196 (struct partial_symtab
*ps
,
1197 struct objfile
*objfile
,
1198 enum search_domain domain
,
1199 const lookup_name_info
&lookup_name
,
1200 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> sym_matcher
)
1203 enum psymtab_search_status result
= PST_SEARCHED_AND_NOT_FOUND
;
1206 if (ps
->searched_flag
!= PST_NOT_SEARCHED
)
1207 return ps
->searched_flag
== PST_SEARCHED_AND_FOUND
;
1209 /* Recurse into shared psymtabs first, because they may have already
1210 been searched, and this could save some time. */
1211 for (i
= 0; i
< ps
->number_of_dependencies
; ++i
)
1215 /* Skip non-shared dependencies, these are handled elsewhere. */
1216 if (ps
->dependencies
[i
]->user
== NULL
)
1219 r
= recursively_search_psymtabs (ps
->dependencies
[i
],
1220 objfile
, domain
, lookup_name
,
1224 ps
->searched_flag
= PST_SEARCHED_AND_FOUND
;
1229 partial_symbol
**gbound
1230 = objfile
->global_psymbols
.data () + ps
->globals_offset
+ ps
->n_global_syms
;
1231 partial_symbol
**sbound
1232 = objfile
->static_psymbols
.data () + ps
->statics_offset
+ ps
->n_static_syms
;
1233 partial_symbol
**bound
= gbound
;
1235 /* Go through all of the symbols stored in a partial
1236 symtab in one loop. */
1237 partial_symbol
**psym
= objfile
->global_psymbols
.data () + ps
->globals_offset
;
1242 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
1244 psym
= objfile
->static_psymbols
.data () + ps
->statics_offset
;
1255 if ((domain
== ALL_DOMAIN
1256 || (domain
== VARIABLES_DOMAIN
1257 && (*psym
)->aclass
!= LOC_TYPEDEF
1258 && (*psym
)->aclass
!= LOC_BLOCK
)
1259 || (domain
== FUNCTIONS_DOMAIN
1260 && (*psym
)->aclass
== LOC_BLOCK
)
1261 || (domain
== TYPES_DOMAIN
1262 && (*psym
)->aclass
== LOC_TYPEDEF
))
1263 && psymbol_name_matches (*psym
, lookup_name
)
1264 && (sym_matcher
== NULL
|| sym_matcher (symbol_search_name (*psym
))))
1266 /* Found a match, so notify our caller. */
1267 result
= PST_SEARCHED_AND_FOUND
;
1274 ps
->searched_flag
= result
;
1275 return result
== PST_SEARCHED_AND_FOUND
;
1278 /* Psymtab version of expand_symtabs_matching. See its definition in
1279 the definition of quick_symbol_functions in symfile.h. */
1282 psym_expand_symtabs_matching
1283 (struct objfile
*objfile
,
1284 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
1285 const lookup_name_info
&lookup_name_in
,
1286 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
1287 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
1288 enum search_domain domain
)
1290 lookup_name_info lookup_name
= lookup_name_in
.make_ignore_params ();
1292 /* Clear the search flags. */
1293 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
1294 ps
->searched_flag
= PST_NOT_SEARCHED
;
1296 for (partial_symtab
*ps
: objfile_psymtabs (objfile
))
1303 /* We skip shared psymtabs because file-matching doesn't apply
1304 to them; but we search them later in the loop. */
1305 if (ps
->user
!= NULL
)
1315 match
= file_matcher (ps
->filename
, false);
1318 /* Before we invoke realpath, which can get expensive when many
1319 files are involved, do a quick comparison of the basenames. */
1320 if (basenames_may_differ
1321 || file_matcher (lbasename (ps
->filename
), true))
1322 match
= file_matcher (psymtab_to_fullname (ps
), false);
1328 if (recursively_search_psymtabs (ps
, objfile
, domain
,
1329 lookup_name
, symbol_matcher
))
1331 struct compunit_symtab
*symtab
=
1332 psymtab_to_symtab (objfile
, ps
);
1334 if (expansion_notify
!= NULL
)
1335 expansion_notify (symtab
);
1340 /* Psymtab version of has_symbols. See its definition in
1341 the definition of quick_symbol_functions in symfile.h. */
1344 psym_has_symbols (struct objfile
*objfile
)
1346 return objfile
->psymtabs
!= NULL
;
1349 /* Helper function for psym_find_compunit_symtab_by_address that fills
1350 in psymbol_map for a given range of psymbols. */
1353 psym_fill_psymbol_map (struct objfile
*objfile
,
1354 struct partial_symtab
*psymtab
,
1355 std::set
<CORE_ADDR
> *seen_addrs
,
1356 const std::vector
<partial_symbol
*> &symbols
,
1360 for (int i
= 0; i
< length
; ++i
)
1362 struct partial_symbol
*psym
= symbols
[start
+ i
];
1364 if (psym
->aclass
== LOC_STATIC
)
1366 CORE_ADDR addr
= psym
->address (objfile
);
1367 if (seen_addrs
->find (addr
) == seen_addrs
->end ())
1369 seen_addrs
->insert (addr
);
1370 objfile
->psymbol_map
.emplace_back (addr
, psymtab
);
1376 /* See find_compunit_symtab_by_address in quick_symbol_functions, in
1379 static compunit_symtab
*
1380 psym_find_compunit_symtab_by_address (struct objfile
*objfile
,
1383 if (objfile
->psymbol_map
.empty ())
1385 std::set
<CORE_ADDR
> seen_addrs
;
1387 for (partial_symtab
*pst
: require_partial_symbols (objfile
, 1))
1389 psym_fill_psymbol_map (objfile
, pst
,
1391 objfile
->global_psymbols
,
1392 pst
->globals_offset
,
1393 pst
->n_global_syms
);
1394 psym_fill_psymbol_map (objfile
, pst
,
1396 objfile
->static_psymbols
,
1397 pst
->statics_offset
,
1398 pst
->n_static_syms
);
1401 objfile
->psymbol_map
.shrink_to_fit ();
1403 std::sort (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (),
1404 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1405 const std::pair
<CORE_ADDR
, partial_symtab
*> &b
)
1407 return a
.first
< b
.first
;
1411 auto iter
= std::lower_bound
1412 (objfile
->psymbol_map
.begin (), objfile
->psymbol_map
.end (), address
,
1413 [] (const std::pair
<CORE_ADDR
, partial_symtab
*> &a
,
1419 if (iter
== objfile
->psymbol_map
.end () || iter
->first
!= address
)
1422 return psymtab_to_symtab (objfile
, iter
->second
);
1425 const struct quick_symbol_functions psym_functions
=
1428 psym_find_last_source_symtab
,
1429 psym_forget_cached_source_info
,
1430 psym_map_symtabs_matching_filename
,
1434 psym_expand_symtabs_for_function
,
1435 psym_expand_all_symtabs
,
1436 psym_expand_symtabs_with_fullname
,
1437 psym_map_matching_symbols
,
1438 psym_expand_symtabs_matching
,
1439 psym_find_pc_sect_compunit_symtab
,
1440 psym_find_compunit_symtab_by_address
,
1441 psym_map_symbol_filenames
1447 sort_pst_symbols (struct objfile
*objfile
, struct partial_symtab
*pst
)
1449 /* Sort the global list; don't sort the static list. */
1450 auto begin
= objfile
->global_psymbols
.begin ();
1451 std::advance (begin
, pst
->globals_offset
);
1453 /* The psymbols for this partial_symtab are currently at the end of the
1455 auto end
= objfile
->global_psymbols
.end ();
1457 std::sort (begin
, end
, [] (partial_symbol
*s1
, partial_symbol
*s2
)
1459 return strcmp_iw_ordered (symbol_search_name (s1
),
1460 symbol_search_name (s2
)) < 0;
1464 /* Allocate and partially fill a partial symtab. It will be
1465 completely filled at the end of the symbol list.
1467 FILENAME is the name of the symbol-file we are reading from. */
1469 struct partial_symtab
*
1470 start_psymtab_common (struct objfile
*objfile
,
1471 const char *filename
,
1474 struct partial_symtab
*psymtab
;
1476 psymtab
= allocate_psymtab (filename
, objfile
);
1477 psymtab
->set_text_low (textlow
);
1478 psymtab
->set_text_high (psymtab
->raw_text_low ()); /* default */
1479 psymtab
->globals_offset
= objfile
->global_psymbols
.size ();
1480 psymtab
->statics_offset
= objfile
->static_psymbols
.size ();
1484 /* Perform "finishing up" operations of a partial symtab. */
1487 end_psymtab_common (struct objfile
*objfile
, struct partial_symtab
*pst
)
1489 pst
->n_global_syms
= objfile
->global_psymbols
.size () - pst
->globals_offset
;
1490 pst
->n_static_syms
= objfile
->static_psymbols
.size () - pst
->statics_offset
;
1492 sort_pst_symbols (objfile
, pst
);
1495 /* Calculate a hash code for the given partial symbol. The hash is
1496 calculated using the symbol's value, language, domain, class
1497 and name. These are the values which are set by
1498 add_psymbol_to_bcache. */
1500 static unsigned long
1501 psymbol_hash (const void *addr
, int length
)
1503 unsigned long h
= 0;
1504 struct partial_symbol
*psymbol
= (struct partial_symbol
*) addr
;
1505 unsigned int lang
= psymbol
->language
;
1506 unsigned int domain
= psymbol
->domain
;
1507 unsigned int theclass
= psymbol
->aclass
;
1509 h
= hash_continue (&psymbol
->value
, sizeof (psymbol
->value
), h
);
1510 h
= hash_continue (&lang
, sizeof (unsigned int), h
);
1511 h
= hash_continue (&domain
, sizeof (unsigned int), h
);
1512 h
= hash_continue (&theclass
, sizeof (unsigned int), h
);
1513 /* Note that psymbol names are interned via symbol_set_names, so
1514 there's no need to hash the contents of the name here. */
1515 h
= hash_continue (&psymbol
->name
,
1516 sizeof (psymbol
->name
), h
);
1521 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1522 For the comparison this function uses a symbols value,
1523 language, domain, class and name. */
1526 psymbol_compare (const void *addr1
, const void *addr2
, int length
)
1528 struct partial_symbol
*sym1
= (struct partial_symbol
*) addr1
;
1529 struct partial_symbol
*sym2
= (struct partial_symbol
*) addr2
;
1531 return (memcmp (&sym1
->value
, &sym2
->value
,
1532 sizeof (sym1
->value
)) == 0
1533 && sym1
->language
== sym2
->language
1534 && sym1
->domain
== sym2
->domain
1535 && sym1
->aclass
== sym2
->aclass
1536 /* Note that psymbol names are interned via
1537 symbol_set_names, so there's no need to compare the
1538 contents of the name here. */
1539 && sym1
->name
== sym2
->name
);
1542 /* Initialize a partial symbol bcache. */
1544 struct psymbol_bcache
*
1545 psymbol_bcache_init (void)
1547 struct psymbol_bcache
*bcache
= XCNEW (struct psymbol_bcache
);
1549 bcache
->bcache
= bcache_xmalloc (psymbol_hash
, psymbol_compare
);
1553 /* Free a partial symbol bcache. */
1556 psymbol_bcache_free (struct psymbol_bcache
*bcache
)
1561 bcache_xfree (bcache
->bcache
);
1565 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1568 psymbol_bcache_get_bcache (struct psymbol_bcache
*bcache
)
1570 return bcache
->bcache
;
1573 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1574 symbol before, add a copy to BCACHE. In either case, return a pointer
1575 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1576 1 in case of new entry or 0 if returning an old entry. */
1578 static struct partial_symbol
*
1579 psymbol_bcache_full (struct partial_symbol
*sym
,
1580 struct psymbol_bcache
*bcache
,
1583 return ((struct partial_symbol
*)
1584 bcache_full (sym
, sizeof (struct partial_symbol
), bcache
->bcache
,
1588 /* Helper function, initialises partial symbol structure and stashes
1589 it into objfile's bcache. Note that our caching mechanism will
1590 use all fields of struct partial_symbol to determine hash value of the
1591 structure. In other words, having two symbols with the same name but
1592 different domain (or address) is possible and correct. */
1594 static struct partial_symbol
*
1595 add_psymbol_to_bcache (const char *name
, int namelength
, int copy_name
,
1597 enum address_class theclass
,
1600 enum language language
, struct objfile
*objfile
,
1603 struct partial_symbol psymbol
;
1605 psymbol
.set_unrelocated_address (coreaddr
);
1606 psymbol
.section
= section
;
1607 psymbol
.domain
= domain
;
1608 psymbol
.aclass
= theclass
;
1610 memset (&psymbol
.language_specific
, 0, sizeof (psymbol
.language_specific
));
1611 psymbol
.ada_mangled
= 0;
1612 symbol_set_language (&psymbol
, language
, &objfile
->objfile_obstack
);
1613 symbol_set_names (&psymbol
, name
, namelength
, copy_name
, objfile
);
1615 /* Stash the partial symbol away in the cache. */
1616 return psymbol_bcache_full (&psymbol
, objfile
->psymbol_cache
, added
);
1619 /* Helper function, adds partial symbol to the given partial symbol list. */
1622 append_psymbol_to_list (std::vector
<partial_symbol
*> *list
,
1623 struct partial_symbol
*psym
,
1624 struct objfile
*objfile
)
1626 list
->push_back (psym
);
1627 OBJSTAT (objfile
, n_psyms
++);
1630 /* Add a symbol with a long value to a psymtab.
1631 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1632 The only value we need to store for psyms is an address.
1633 For all other psyms pass zero for COREADDR.
1634 Return the partial symbol that has been added. */
1637 add_psymbol_to_list (const char *name
, int namelength
, int copy_name
,
1639 enum address_class theclass
,
1641 psymbol_placement where
,
1643 enum language language
, struct objfile
*objfile
)
1645 struct partial_symbol
*psym
;
1649 /* Stash the partial symbol away in the cache. */
1650 psym
= add_psymbol_to_bcache (name
, namelength
, copy_name
, domain
, theclass
,
1651 section
, coreaddr
, language
, objfile
, &added
);
1653 /* Do not duplicate global partial symbols. */
1654 if (where
== psymbol_placement::GLOBAL
&& !added
)
1657 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1658 std::vector
<partial_symbol
*> *list
1659 = (where
== psymbol_placement::STATIC
1660 ? &objfile
->static_psymbols
1661 : &objfile
->global_psymbols
);
1662 append_psymbol_to_list (list
, psym
, objfile
);
1665 /* See psympriv.h. */
1668 init_psymbol_list (struct objfile
*objfile
, int total_symbols
)
1670 if (objfile
->global_psymbols
.capacity () == 0
1671 && objfile
->static_psymbols
.capacity () == 0)
1673 /* Current best guess is that approximately a twentieth of the
1674 total symbols (in a debugging file) are global or static
1675 oriented symbols, then multiply that by slop factor of
1677 objfile
->global_psymbols
.reserve (total_symbols
/ 10);
1678 objfile
->static_psymbols
.reserve (total_symbols
/ 10);
1682 /* See psympriv.h. */
1684 struct partial_symtab
*
1685 allocate_psymtab (const char *filename
, struct objfile
*objfile
)
1687 struct partial_symtab
*psymtab
;
1689 if (objfile
->free_psymtabs
)
1691 psymtab
= objfile
->free_psymtabs
;
1692 objfile
->free_psymtabs
= psymtab
->next
;
1695 psymtab
= XOBNEW (&objfile
->objfile_obstack
, partial_symtab
);
1697 memset (psymtab
, 0, sizeof (struct partial_symtab
));
1699 = (const char *) bcache (filename
, strlen (filename
) + 1,
1700 objfile
->per_bfd
->filename_cache
);
1701 psymtab
->compunit_symtab
= NULL
;
1703 /* Prepend it to the psymtab list for the objfile it belongs to.
1704 Psymtabs are searched in most recent inserted -> least recent
1707 psymtab
->next
= objfile
->psymtabs
;
1708 objfile
->psymtabs
= psymtab
;
1710 if (symtab_create_debug
)
1712 /* Be a bit clever with debugging messages, and don't print objfile
1713 every time, only when it changes. */
1714 static char *last_objfile_name
= NULL
;
1716 if (last_objfile_name
== NULL
1717 || strcmp (last_objfile_name
, objfile_name (objfile
)) != 0)
1719 xfree (last_objfile_name
);
1720 last_objfile_name
= xstrdup (objfile_name (objfile
));
1721 fprintf_filtered (gdb_stdlog
,
1722 "Creating one or more psymtabs for objfile %s ...\n",
1725 fprintf_filtered (gdb_stdlog
,
1726 "Created psymtab %s for module %s.\n",
1727 host_address_to_string (psymtab
), filename
);
1734 discard_psymtab (struct objfile
*objfile
, struct partial_symtab
*pst
)
1736 struct partial_symtab
**prev_pst
;
1739 Empty psymtabs happen as a result of header files which don't
1740 have any symbols in them. There can be a lot of them. But this
1741 check is wrong, in that a psymtab with N_SLINE entries but
1742 nothing else is not empty, but we don't realize that. Fixing
1743 that without slowing things down might be tricky. */
1745 /* First, snip it out of the psymtab chain. */
1747 prev_pst
= &(objfile
->psymtabs
);
1748 while ((*prev_pst
) != pst
)
1749 prev_pst
= &((*prev_pst
)->next
);
1750 (*prev_pst
) = pst
->next
;
1752 /* Next, put it on a free list for recycling. */
1754 pst
->next
= objfile
->free_psymtabs
;
1755 objfile
->free_psymtabs
= pst
;
1760 /* We need to pass a couple of items to the addrmap_foreach function,
1763 struct dump_psymtab_addrmap_data
1765 struct objfile
*objfile
;
1766 struct partial_symtab
*psymtab
;
1767 struct ui_file
*outfile
;
1769 /* Non-zero if the previously printed addrmap entry was for PSYMTAB.
1770 If so, we want to print the next one as well (since the next addrmap
1771 entry defines the end of the range). */
1772 int previous_matched
;
1775 /* Helper function for dump_psymtab_addrmap to print an addrmap entry. */
1778 dump_psymtab_addrmap_1 (void *datap
, CORE_ADDR start_addr
, void *obj
)
1780 struct dump_psymtab_addrmap_data
*data
1781 = (struct dump_psymtab_addrmap_data
*) datap
;
1782 struct gdbarch
*gdbarch
= get_objfile_arch (data
->objfile
);
1783 struct partial_symtab
*addrmap_psymtab
= (struct partial_symtab
*) obj
;
1784 const char *psymtab_address_or_end
= NULL
;
1788 if (data
->psymtab
== NULL
1789 || data
->psymtab
== addrmap_psymtab
)
1790 psymtab_address_or_end
= host_address_to_string (addrmap_psymtab
);
1791 else if (data
->previous_matched
)
1792 psymtab_address_or_end
= "<ends here>";
1794 if (data
->psymtab
== NULL
1795 || data
->psymtab
== addrmap_psymtab
1796 || data
->previous_matched
)
1798 fprintf_filtered (data
->outfile
, " %s%s %s\n",
1799 data
->psymtab
!= NULL
? " " : "",
1800 paddress (gdbarch
, start_addr
),
1801 psymtab_address_or_end
);
1804 data
->previous_matched
= (data
->psymtab
== NULL
1805 || data
->psymtab
== addrmap_psymtab
);
1810 /* Helper function for maintenance_print_psymbols to print the addrmap
1811 of PSYMTAB. If PSYMTAB is NULL print the entire addrmap. */
1814 dump_psymtab_addrmap (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
1815 struct ui_file
*outfile
)
1817 struct dump_psymtab_addrmap_data addrmap_dump_data
;
1819 if ((psymtab
== NULL
1820 || psymtab
->psymtabs_addrmap_supported
)
1821 && objfile
->psymtabs_addrmap
!= NULL
)
1823 addrmap_dump_data
.objfile
= objfile
;
1824 addrmap_dump_data
.psymtab
= psymtab
;
1825 addrmap_dump_data
.outfile
= outfile
;
1826 addrmap_dump_data
.previous_matched
= 0;
1827 fprintf_filtered (outfile
, "%sddress map:\n",
1828 psymtab
== NULL
? "Entire a" : " A");
1829 addrmap_foreach (objfile
->psymtabs_addrmap
, dump_psymtab_addrmap_1
,
1830 &addrmap_dump_data
);
1835 maintenance_print_psymbols (const char *args
, int from_tty
)
1837 struct ui_file
*outfile
= gdb_stdout
;
1838 char *address_arg
= NULL
, *source_arg
= NULL
, *objfile_arg
= NULL
;
1839 int i
, outfile_idx
, found
;
1841 struct obj_section
*section
= NULL
;
1845 gdb_argv
argv (args
);
1847 for (i
= 0; argv
!= NULL
&& argv
[i
] != NULL
; ++i
)
1849 if (strcmp (argv
[i
], "-pc") == 0)
1851 if (argv
[i
+ 1] == NULL
)
1852 error (_("Missing pc value"));
1853 address_arg
= argv
[++i
];
1855 else if (strcmp (argv
[i
], "-source") == 0)
1857 if (argv
[i
+ 1] == NULL
)
1858 error (_("Missing source file"));
1859 source_arg
= argv
[++i
];
1861 else if (strcmp (argv
[i
], "-objfile") == 0)
1863 if (argv
[i
+ 1] == NULL
)
1864 error (_("Missing objfile name"));
1865 objfile_arg
= argv
[++i
];
1867 else if (strcmp (argv
[i
], "--") == 0)
1869 /* End of options. */
1873 else if (argv
[i
][0] == '-')
1875 /* Future proofing: Don't allow OUTFILE to begin with "-". */
1876 error (_("Unknown option: %s"), argv
[i
]);
1883 if (address_arg
!= NULL
&& source_arg
!= NULL
)
1884 error (_("Must specify at most one of -pc and -source"));
1886 stdio_file arg_outfile
;
1888 if (argv
!= NULL
&& argv
[outfile_idx
] != NULL
)
1890 if (argv
[outfile_idx
+ 1] != NULL
)
1891 error (_("Junk at end of command"));
1892 gdb::unique_xmalloc_ptr
<char> outfile_name
1893 (tilde_expand (argv
[outfile_idx
]));
1894 if (!arg_outfile
.open (outfile_name
.get (), FOPEN_WT
))
1895 perror_with_name (outfile_name
.get ());
1896 outfile
= &arg_outfile
;
1899 if (address_arg
!= NULL
)
1901 pc
= parse_and_eval_address (address_arg
);
1902 /* If we fail to find a section, that's ok, try the lookup anyway. */
1903 section
= find_pc_section (pc
);
1907 for (objfile
*objfile
: all_objfiles (current_program_space
))
1909 int printed_objfile_header
= 0;
1910 int print_for_objfile
= 1;
1913 if (objfile_arg
!= NULL
)
1915 = compare_filenames_for_search (objfile_name (objfile
),
1917 if (!print_for_objfile
)
1920 if (address_arg
!= NULL
)
1922 struct bound_minimal_symbol msymbol
= { NULL
, NULL
};
1924 /* We don't assume each pc has a unique objfile (this is for
1926 struct partial_symtab
*ps
= find_pc_sect_psymtab (objfile
, pc
,
1930 if (!printed_objfile_header
)
1932 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1933 objfile_name (objfile
));
1934 printed_objfile_header
= 1;
1936 dump_psymtab (objfile
, ps
, outfile
);
1937 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1943 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
1945 int print_for_source
= 0;
1948 if (source_arg
!= NULL
)
1951 = compare_filenames_for_search (ps
->filename
, source_arg
);
1954 if (source_arg
== NULL
1955 || print_for_source
)
1957 if (!printed_objfile_header
)
1959 outfile
->printf ("\nPartial symtabs for objfile %s\n",
1960 objfile_name (objfile
));
1961 printed_objfile_header
= 1;
1963 dump_psymtab (objfile
, ps
, outfile
);
1964 dump_psymtab_addrmap (objfile
, ps
, outfile
);
1969 /* If we're printing all the objfile's symbols dump the full addrmap. */
1971 if (address_arg
== NULL
1972 && source_arg
== NULL
1973 && objfile
->psymtabs_addrmap
!= NULL
)
1975 outfile
->puts ("\n");
1976 dump_psymtab_addrmap (objfile
, NULL
, outfile
);
1982 if (address_arg
!= NULL
)
1983 error (_("No partial symtab for address: %s"), address_arg
);
1984 if (source_arg
!= NULL
)
1985 error (_("No partial symtab for source file: %s"), source_arg
);
1989 /* List all the partial symbol tables whose names match REGEXP (optional). */
1992 maintenance_info_psymtabs (const char *regexp
, int from_tty
)
1994 struct program_space
*pspace
;
1999 ALL_PSPACES (pspace
)
2000 for (objfile
*objfile
: all_objfiles (pspace
))
2002 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2004 /* We don't want to print anything for this objfile until we
2005 actually find a symtab whose name matches. */
2006 int printed_objfile_start
= 0;
2008 for (partial_symtab
*psymtab
: require_partial_symbols (objfile
, 1))
2013 || re_exec (psymtab
->filename
))
2015 if (! printed_objfile_start
)
2017 printf_filtered ("{ objfile %s ", objfile_name (objfile
));
2019 printf_filtered ("((struct objfile *) %s)\n",
2020 host_address_to_string (objfile
));
2021 printed_objfile_start
= 1;
2024 printf_filtered (" { psymtab %s ", psymtab
->filename
);
2026 printf_filtered ("((struct partial_symtab *) %s)\n",
2027 host_address_to_string (psymtab
));
2029 printf_filtered (" readin %s\n",
2030 psymtab
->readin
? "yes" : "no");
2031 printf_filtered (" fullname %s\n",
2033 ? psymtab
->fullname
: "(null)");
2034 printf_filtered (" text addresses ");
2035 fputs_filtered (paddress (gdbarch
,
2036 psymtab
->text_low (objfile
)),
2038 printf_filtered (" -- ");
2039 fputs_filtered (paddress (gdbarch
,
2040 psymtab
->text_high (objfile
)),
2042 printf_filtered ("\n");
2043 printf_filtered (" psymtabs_addrmap_supported %s\n",
2044 (psymtab
->psymtabs_addrmap_supported
2046 printf_filtered (" globals ");
2047 if (psymtab
->n_global_syms
)
2050 = &objfile
->global_psymbols
[psymtab
->globals_offset
];
2053 ("(* (struct partial_symbol **) %s @ %d)\n",
2054 host_address_to_string (p
),
2055 psymtab
->n_global_syms
);
2058 printf_filtered ("(none)\n");
2059 printf_filtered (" statics ");
2060 if (psymtab
->n_static_syms
)
2063 = &objfile
->static_psymbols
[psymtab
->statics_offset
];
2066 ("(* (struct partial_symbol **) %s @ %d)\n",
2067 host_address_to_string (p
),
2068 psymtab
->n_static_syms
);
2071 printf_filtered ("(none)\n");
2072 printf_filtered (" dependencies ");
2073 if (psymtab
->number_of_dependencies
)
2077 printf_filtered ("{\n");
2078 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
2080 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
2082 /* Note the string concatenation there --- no
2084 printf_filtered (" psymtab %s "
2085 "((struct partial_symtab *) %s)\n",
2087 host_address_to_string (dep
));
2089 printf_filtered (" }\n");
2092 printf_filtered ("(none)\n");
2093 printf_filtered (" }\n");
2097 if (printed_objfile_start
)
2098 printf_filtered ("}\n");
2102 /* Check consistency of currently expanded psymtabs vs symtabs. */
2105 maintenance_check_psymtabs (const char *ignore
, int from_tty
)
2108 struct compunit_symtab
*cust
= NULL
;
2109 const struct blockvector
*bv
;
2113 for (objfile
*objfile
: all_objfiles (current_program_space
))
2114 for (partial_symtab
*ps
: require_partial_symbols (objfile
, 1))
2116 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2118 /* We don't call psymtab_to_symtab here because that may cause symtab
2119 expansion. When debugging a problem it helps if checkers leave
2120 things unchanged. */
2121 cust
= ps
->compunit_symtab
;
2123 /* First do some checks that don't require the associated symtab. */
2124 if (ps
->text_high (objfile
) < ps
->text_low (objfile
))
2126 printf_filtered ("Psymtab ");
2127 puts_filtered (ps
->filename
);
2128 printf_filtered (" covers bad range ");
2129 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2131 printf_filtered (" - ");
2132 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2134 printf_filtered ("\n");
2138 /* Now do checks requiring the associated symtab. */
2141 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2142 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2143 partial_symbol
**psym
= &objfile
->static_psymbols
[ps
->statics_offset
];
2144 length
= ps
->n_static_syms
;
2147 sym
= block_lookup_symbol (b
, symbol_search_name (*psym
),
2148 symbol_name_match_type::SEARCH_NAME
,
2152 printf_filtered ("Static symbol `");
2153 puts_filtered ((*psym
)->name
);
2154 printf_filtered ("' only found in ");
2155 puts_filtered (ps
->filename
);
2156 printf_filtered (" psymtab\n");
2160 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2161 psym
= &objfile
->global_psymbols
[ps
->globals_offset
];
2162 length
= ps
->n_global_syms
;
2165 sym
= block_lookup_symbol (b
, symbol_search_name (*psym
),
2166 symbol_name_match_type::SEARCH_NAME
,
2170 printf_filtered ("Global symbol `");
2171 puts_filtered ((*psym
)->name
);
2172 printf_filtered ("' only found in ");
2173 puts_filtered (ps
->filename
);
2174 printf_filtered (" psymtab\n");
2178 if (ps
->raw_text_high () != 0
2179 && (ps
->text_low (objfile
) < BLOCK_START (b
)
2180 || ps
->text_high (objfile
) > BLOCK_END (b
)))
2182 printf_filtered ("Psymtab ");
2183 puts_filtered (ps
->filename
);
2184 printf_filtered (" covers ");
2185 fputs_filtered (paddress (gdbarch
, ps
->text_low (objfile
)),
2187 printf_filtered (" - ");
2188 fputs_filtered (paddress (gdbarch
, ps
->text_high (objfile
)),
2190 printf_filtered (" but symtab covers only ");
2191 fputs_filtered (paddress (gdbarch
, BLOCK_START (b
)), gdb_stdout
);
2192 printf_filtered (" - ");
2193 fputs_filtered (paddress (gdbarch
, BLOCK_END (b
)), gdb_stdout
);
2194 printf_filtered ("\n");
2200 _initialize_psymtab (void)
2202 add_cmd ("psymbols", class_maintenance
, maintenance_print_psymbols
, _("\
2203 Print dump of current partial symbol definitions.\n\
2204 Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\
2205 mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
2206 Entries in the partial symbol table are dumped to file OUTFILE,\n\
2207 or the terminal if OUTFILE is unspecified.\n\
2208 If ADDRESS is provided, dump only the file for that address.\n\
2209 If SOURCE is provided, dump only that file's symbols.\n\
2210 If OBJFILE is provided, dump only that file's minimal symbols."),
2211 &maintenanceprintlist
);
2213 add_cmd ("psymtabs", class_maintenance
, maintenance_info_psymtabs
, _("\
2214 List the partial symbol tables for all object files.\n\
2215 This does not include information about individual partial symbols,\n\
2216 just the symbol table structures themselves."),
2217 &maintenanceinfolist
);
2219 add_cmd ("check-psymtabs", class_maintenance
, maintenance_check_psymtabs
,
2221 Check consistency of currently expanded psymtabs versus symtabs."),