1 /* Partial symbol tables.
2
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "psympriv.h"
23 #include "objfiles.h"
24 #include "gdb_assert.h"
25 #include "block.h"
26 #include "filenames.h"
27 #include "source.h"
28 #include "addrmap.h"
29 #include "gdbtypes.h"
30 #include "bcache.h"
31 #include "ui-out.h"
32 #include "command.h"
33 #include "readline/readline.h"
34 #include "gdb_regex.h"
35 #include "dictionary.h"
36 #include "language.h"
37 #include "cp-support.h"
38 #include "gdbcmd.h"
39
40 #ifndef DEV_TTY
41 #define DEV_TTY "/dev/tty"
42 #endif
43
44 struct psymbol_bcache
45 {
46 struct bcache *bcache;
47 };
48
49 static struct partial_symbol *match_partial_symbol (struct objfile *,
50 struct partial_symtab *,
51 int,
52 const char *, domain_enum,
53 symbol_compare_ftype *,
54 symbol_compare_ftype *);
55
56 static struct partial_symbol *lookup_partial_symbol (struct objfile *,
57 struct partial_symtab *,
58 const char *, int,
59 domain_enum);
60
61 static const char *psymtab_to_fullname (struct partial_symtab *ps);
62
63 static struct partial_symbol *find_pc_sect_psymbol (struct objfile *,
64 struct partial_symtab *,
65 CORE_ADDR,
66 struct obj_section *);
67
68 static void fixup_psymbol_section (struct partial_symbol *psym,
69 struct objfile *objfile);
70
71 static struct symtab *psymtab_to_symtab (struct objfile *objfile,
72 struct partial_symtab *pst);
73
74 /* Ensure that the partial symbols for OBJFILE have been loaded. This
75 function always returns its argument, as a convenience. */
76
77 struct objfile *
require_partial_symbols(struct objfile * objfile,int verbose)78 require_partial_symbols (struct objfile *objfile, int verbose)
79 {
80 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
81 {
82 objfile->flags |= OBJF_PSYMTABS_READ;
83
84 if (objfile->sf->sym_read_psymbols)
85 {
86 if (verbose)
87 {
88 printf_unfiltered (_("Reading symbols from %s..."),
89 objfile->name);
90 gdb_flush (gdb_stdout);
91 }
92 (*objfile->sf->sym_read_psymbols) (objfile);
93 if (verbose)
94 {
95 if (!objfile_has_symbols (objfile))
96 {
97 wrap_here ("");
98 printf_unfiltered (_("(no debugging symbols found)..."));
99 wrap_here ("");
100 }
101
102 printf_unfiltered (_("done.\n"));
103 }
104 }
105 }
106
107 return objfile;
108 }
109
110 /* Traverse all psymtabs in one objfile, requiring that the psymtabs
111 be read in. */
112
113 #define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \
114 for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \
115 (p) != NULL; \
116 (p) = (p)->next)
117
118 /* We want to make sure this file always requires psymtabs. */
119
120 #undef ALL_OBJFILE_PSYMTABS
121
122 /* Traverse all psymtabs in all objfiles. */
123
124 #define ALL_PSYMTABS(objfile, p) \
125 ALL_OBJFILES (objfile) \
126 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
127
128 /* Helper function for partial_map_symtabs_matching_filename that
129 expands the symtabs and calls the iterator. */
130
131 static int
partial_map_expand_apply(struct objfile * objfile,const char * name,const char * real_path,struct partial_symtab * pst,int (* callback)(struct symtab *,void *),void * data)132 partial_map_expand_apply (struct objfile *objfile,
133 const char *name,
134 const char *real_path,
135 struct partial_symtab *pst,
136 int (*callback) (struct symtab *, void *),
137 void *data)
138 {
139 struct symtab *last_made = objfile->symtabs;
140
141 /* Shared psymtabs should never be seen here. Instead they should
142 be handled properly by the caller. */
143 gdb_assert (pst->user == NULL);
144
145 /* Don't visit already-expanded psymtabs. */
146 if (pst->readin)
147 return 0;
148
149 /* This may expand more than one symtab, and we want to iterate over
150 all of them. */
151 psymtab_to_symtab (objfile, pst);
152
153 return iterate_over_some_symtabs (name, real_path, callback, data,
154 objfile->symtabs, last_made);
155 }
156
157 /* Implementation of the map_symtabs_matching_filename method. */
158
159 static int
partial_map_symtabs_matching_filename(struct objfile * objfile,const char * name,const char * real_path,int (* callback)(struct symtab *,void *),void * data)160 partial_map_symtabs_matching_filename (struct objfile *objfile,
161 const char *name,
162 const char *real_path,
163 int (*callback) (struct symtab *,
164 void *),
165 void *data)
166 {
167 struct partial_symtab *pst;
168 const char *name_basename = lbasename (name);
169
170 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
171 {
172 /* We can skip shared psymtabs here, because any file name will be
173 attached to the unshared psymtab. */
174 if (pst->user != NULL)
175 continue;
176
177 /* Anonymous psymtabs don't have a file name. */
178 if (pst->anonymous)
179 continue;
180
181 if (compare_filenames_for_search (pst->filename, name))
182 {
183 if (partial_map_expand_apply (objfile, name, real_path,
184 pst, callback, data))
185 return 1;
186 }
187
188 /* Before we invoke realpath, which can get expensive when many
189 files are involved, do a quick comparison of the basenames. */
190 if (! basenames_may_differ
191 && FILENAME_CMP (name_basename, lbasename (pst->filename)) != 0)
192 continue;
193
194 if (compare_filenames_for_search (psymtab_to_fullname (pst), name))
195 {
196 if (partial_map_expand_apply (objfile, name, real_path,
197 pst, callback, data))
198 return 1;
199 }
200
201 /* If the user gave us an absolute path, try to find the file in
202 this symtab and use its absolute path. */
203 if (real_path != NULL)
204 {
205 gdb_assert (IS_ABSOLUTE_PATH (real_path));
206 gdb_assert (IS_ABSOLUTE_PATH (name));
207 if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0)
208 {
209 if (partial_map_expand_apply (objfile, name, real_path,
210 pst, callback, data))
211 return 1;
212 }
213 }
214 }
215
216 return 0;
217 }
218
219 /* Find which partial symtab contains PC and SECTION starting at psymtab PST.
220 We may find a different psymtab than PST. See FIND_PC_SECT_PSYMTAB. */
221
222 static struct partial_symtab *
find_pc_sect_psymtab_closer(struct objfile * objfile,CORE_ADDR pc,struct obj_section * section,struct partial_symtab * pst,struct minimal_symbol * msymbol)223 find_pc_sect_psymtab_closer (struct objfile *objfile,
224 CORE_ADDR pc, struct obj_section *section,
225 struct partial_symtab *pst,
226 struct minimal_symbol *msymbol)
227 {
228 struct partial_symtab *tpst;
229 struct partial_symtab *best_pst = pst;
230 CORE_ADDR best_addr = pst->textlow;
231
232 gdb_assert (!pst->psymtabs_addrmap_supported);
233
234 /* An objfile that has its functions reordered might have
235 many partial symbol tables containing the PC, but
236 we want the partial symbol table that contains the
237 function containing the PC. */
238 if (!(objfile->flags & OBJF_REORDERED) &&
239 section == 0) /* Can't validate section this way. */
240 return pst;
241
242 if (msymbol == NULL)
243 return (pst);
244
245 /* The code range of partial symtabs sometimes overlap, so, in
246 the loop below, we need to check all partial symtabs and
247 find the one that fits better for the given PC address. We
248 select the partial symtab that contains a symbol whose
249 address is closest to the PC address. By closest we mean
250 that find_pc_sect_symbol returns the symbol with address
251 that is closest and still less than the given PC. */
252 for (tpst = pst; tpst != NULL; tpst = tpst->next)
253 {
254 if (pc >= tpst->textlow && pc < tpst->texthigh)
255 {
256 struct partial_symbol *p;
257 CORE_ADDR this_addr;
258
259 /* NOTE: This assumes that every psymbol has a
260 corresponding msymbol, which is not necessarily
261 true; the debug info might be much richer than the
262 object's symbol table. */
263 p = find_pc_sect_psymbol (objfile, tpst, pc, section);
264 if (p != NULL
265 && SYMBOL_VALUE_ADDRESS (p)
266 == SYMBOL_VALUE_ADDRESS (msymbol))
267 return tpst;
268
269 /* Also accept the textlow value of a psymtab as a
270 "symbol", to provide some support for partial
271 symbol tables with line information but no debug
272 symbols (e.g. those produced by an assembler). */
273 if (p != NULL)
274 this_addr = SYMBOL_VALUE_ADDRESS (p);
275 else
276 this_addr = tpst->textlow;
277
278 /* Check whether it is closer than our current
279 BEST_ADDR. Since this symbol address is
280 necessarily lower or equal to PC, the symbol closer
281 to PC is the symbol which address is the highest.
282 This way we return the psymtab which contains such
283 best match symbol. This can help in cases where the
284 symbol information/debuginfo is not complete, like
285 for instance on IRIX6 with gcc, where no debug info
286 is emitted for statics. (See also the nodebug.exp
287 testcase.) */
288 if (this_addr > best_addr)
289 {
290 best_addr = this_addr;
291 best_pst = tpst;
292 }
293 }
294 }
295 return best_pst;
296 }
297
298 /* Find which partial symtab contains PC and SECTION. Return 0 if
299 none. We return the psymtab that contains a symbol whose address
300 exactly matches PC, or, if we cannot find an exact match, the
301 psymtab that contains a symbol whose address is closest to PC. */
302 static struct partial_symtab *
find_pc_sect_psymtab(struct objfile * objfile,CORE_ADDR pc,struct obj_section * section,struct minimal_symbol * msymbol)303 find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
304 struct obj_section *section,
305 struct minimal_symbol *msymbol)
306 {
307 struct partial_symtab *pst;
308
309 /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
310 than the later used TEXTLOW/TEXTHIGH one. */
311
312 if (objfile->psymtabs_addrmap != NULL)
313 {
314 pst = addrmap_find (objfile->psymtabs_addrmap, pc);
315 if (pst != NULL)
316 {
317 /* FIXME: addrmaps currently do not handle overlayed sections,
318 so fall back to the non-addrmap case if we're debugging
319 overlays and the addrmap returned the wrong section. */
320 if (overlay_debugging && msymbol && section)
321 {
322 struct partial_symbol *p;
323
324 /* NOTE: This assumes that every psymbol has a
325 corresponding msymbol, which is not necessarily
326 true; the debug info might be much richer than the
327 object's symbol table. */
328 p = find_pc_sect_psymbol (objfile, pst, pc, section);
329 if (!p
330 || SYMBOL_VALUE_ADDRESS (p)
331 != SYMBOL_VALUE_ADDRESS (msymbol))
332 goto next;
333 }
334
335 /* We do not try to call FIND_PC_SECT_PSYMTAB_CLOSER as
336 PSYMTABS_ADDRMAP we used has already the best 1-byte
337 granularity and FIND_PC_SECT_PSYMTAB_CLOSER may mislead us into
338 a worse chosen section due to the TEXTLOW/TEXTHIGH ranges
339 overlap. */
340
341 return pst;
342 }
343 }
344
345 next:
346
347 /* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
348 which still have no corresponding full SYMTABs read. But it is not
349 present for non-DWARF2 debug infos not supporting PSYMTABS_ADDRMAP in GDB
350 so far. */
351
352 /* Check even OBJFILE with non-zero PSYMTABS_ADDRMAP as only several of
353 its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying
354 debug info type in single OBJFILE. */
355
356 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
357 if (!pst->psymtabs_addrmap_supported
358 && pc >= pst->textlow && pc < pst->texthigh)
359 {
360 struct partial_symtab *best_pst;
361
362 best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
363 msymbol);
364 if (best_pst != NULL)
365 return best_pst;
366 }
367
368 return NULL;
369 }
370
371 static struct symtab *
find_pc_sect_symtab_from_partial(struct objfile * objfile,struct minimal_symbol * msymbol,CORE_ADDR pc,struct obj_section * section,int warn_if_readin)372 find_pc_sect_symtab_from_partial (struct objfile *objfile,
373 struct minimal_symbol *msymbol,
374 CORE_ADDR pc, struct obj_section *section,
375 int warn_if_readin)
376 {
377 struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, section,
378 msymbol);
379 if (ps)
380 {
381 if (warn_if_readin && ps->readin)
382 /* Might want to error() here (in case symtab is corrupt and
383 will cause a core dump), but maybe we can successfully
384 continue, so let's not. */
385 warning (_("\
386 (Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
387 paddress (get_objfile_arch (objfile), pc));
388 psymtab_to_symtab (objfile, ps);
389 return ps->symtab;
390 }
391 return NULL;
392 }
393
394 /* Find which partial symbol within a psymtab matches PC and SECTION.
395 Return 0 if none. */
396
397 static struct partial_symbol *
find_pc_sect_psymbol(struct objfile * objfile,struct partial_symtab * psymtab,CORE_ADDR pc,struct obj_section * section)398 find_pc_sect_psymbol (struct objfile *objfile,
399 struct partial_symtab *psymtab, CORE_ADDR pc,
400 struct obj_section *section)
401 {
402 struct partial_symbol *best = NULL, *p, **pp;
403 CORE_ADDR best_pc;
404
405 gdb_assert (psymtab != NULL);
406
407 /* Cope with programs that start at address 0. */
408 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
409
410 /* Search the global symbols as well as the static symbols, so that
411 find_pc_partial_function doesn't use a minimal symbol and thus
412 cache a bad endaddr. */
413 for (pp = objfile->global_psymbols.list + psymtab->globals_offset;
414 (pp - (objfile->global_psymbols.list + psymtab->globals_offset)
415 < psymtab->n_global_syms);
416 pp++)
417 {
418 p = *pp;
419 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
420 && SYMBOL_CLASS (p) == LOC_BLOCK
421 && pc >= SYMBOL_VALUE_ADDRESS (p)
422 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
423 || (psymtab->textlow == 0
424 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
425 {
426 if (section) /* Match on a specific section. */
427 {
428 fixup_psymbol_section (p, objfile);
429 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
430 continue;
431 }
432 best_pc = SYMBOL_VALUE_ADDRESS (p);
433 best = p;
434 }
435 }
436
437 for (pp = objfile->static_psymbols.list + psymtab->statics_offset;
438 (pp - (objfile->static_psymbols.list + psymtab->statics_offset)
439 < psymtab->n_static_syms);
440 pp++)
441 {
442 p = *pp;
443 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
444 && SYMBOL_CLASS (p) == LOC_BLOCK
445 && pc >= SYMBOL_VALUE_ADDRESS (p)
446 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
447 || (psymtab->textlow == 0
448 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
449 {
450 if (section) /* Match on a specific section. */
451 {
452 fixup_psymbol_section (p, objfile);
453 if (!matching_obj_sections (SYMBOL_OBJ_SECTION (p), section))
454 continue;
455 }
456 best_pc = SYMBOL_VALUE_ADDRESS (p);
457 best = p;
458 }
459 }
460
461 return best;
462 }
463
464 static void
fixup_psymbol_section(struct partial_symbol * psym,struct objfile * objfile)465 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
466 {
467 CORE_ADDR addr;
468
469 if (psym == NULL || SYMBOL_OBJ_SECTION (psym) != NULL)
470 return;
471
472 gdb_assert (objfile);
473
474 switch (SYMBOL_CLASS (psym))
475 {
476 case LOC_STATIC:
477 case LOC_LABEL:
478 case LOC_BLOCK:
479 addr = SYMBOL_VALUE_ADDRESS (psym);
480 break;
481 default:
482 /* Nothing else will be listed in the minsyms -- no use looking
483 it up. */
484 return;
485 }
486
487 fixup_section (&psym->ginfo, addr, objfile);
488 }
489
490 static struct symtab *
lookup_symbol_aux_psymtabs(struct objfile * objfile,int block_index,const char * name,const domain_enum domain)491 lookup_symbol_aux_psymtabs (struct objfile *objfile,
492 int block_index, const char *name,
493 const domain_enum domain)
494 {
495 struct partial_symtab *ps;
496 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
497 struct symtab *stab_best = NULL;
498
499 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
500 {
501 if (!ps->readin && lookup_partial_symbol (objfile, ps, name,
502 psymtab_index, domain))
503 {
504 struct symbol *sym = NULL;
505 struct symtab *stab = psymtab_to_symtab (objfile, ps);
506
507 /* Some caution must be observed with overloaded functions
508 and methods, since the psymtab will not contain any overload
509 information (but NAME might contain it). */
510 if (stab->primary)
511 {
512 struct blockvector *bv = BLOCKVECTOR (stab);
513 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
514
515 sym = lookup_block_symbol (block, name, domain);
516 }
517
518 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
519 {
520 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
521 return stab;
522
523 stab_best = stab;
524 }
525
526 /* Keep looking through other psymtabs. */
527 }
528 }
529
530 return stab_best;
531 }
532
533 /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
534 the global block of PST if GLOBAL, and otherwise the static block.
535 MATCH is the comparison operation that returns true iff MATCH (s,
536 NAME), where s is a SYMBOL_SEARCH_NAME. If ORDERED_COMPARE is
537 non-null, the symbols in the block are assumed to be ordered
538 according to it (allowing binary search). It must be compatible
539 with MATCH. Returns the symbol, if found, and otherwise NULL. */
540
541 static struct partial_symbol *
match_partial_symbol(struct objfile * objfile,struct partial_symtab * pst,int global,const char * name,domain_enum domain,symbol_compare_ftype * match,symbol_compare_ftype * ordered_compare)542 match_partial_symbol (struct objfile *objfile,
543 struct partial_symtab *pst, int global,
544 const char *name, domain_enum domain,
545 symbol_compare_ftype *match,
546 symbol_compare_ftype *ordered_compare)
547 {
548 struct partial_symbol **start, **psym;
549 struct partial_symbol **top, **real_top, **bottom, **center;
550 int length = (global ? pst->n_global_syms : pst->n_static_syms);
551 int do_linear_search = 1;
552
553 if (length == 0)
554 return NULL;
555 start = (global ?
556 objfile->global_psymbols.list + pst->globals_offset :
557 objfile->static_psymbols.list + pst->statics_offset);
558
559 if (global && ordered_compare) /* Can use a binary search. */
560 {
561 do_linear_search = 0;
562
563 /* Binary search. This search is guaranteed to end with center
564 pointing at the earliest partial symbol whose name might be
565 correct. At that point *all* partial symbols with an
566 appropriate name will be checked against the correct
567 domain. */
568
569 bottom = start;
570 top = start + length - 1;
571 real_top = top;
572 while (top > bottom)
573 {
574 center = bottom + (top - bottom) / 2;
575 gdb_assert (center < top);
576 if (!do_linear_search
577 && (SYMBOL_LANGUAGE (*center) == language_java))
578 do_linear_search = 1;
579 if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0)
580 top = center;
581 else
582 bottom = center + 1;
583 }
584 gdb_assert (top == bottom);
585
586 while (top <= real_top
587 && match (SYMBOL_SEARCH_NAME (*top), name) == 0)
588 {
589 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
590 SYMBOL_DOMAIN (*top), domain))
591 return *top;
592 top++;
593 }
594 }
595
596 /* Can't use a binary search or else we found during the binary search that
597 we should also do a linear search. */
598
599 if (do_linear_search)
600 {
601 for (psym = start; psym < start + length; psym++)
602 {
603 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
604 SYMBOL_DOMAIN (*psym), domain)
605 && match (SYMBOL_SEARCH_NAME (*psym), name) == 0)
606 return *psym;
607 }
608 }
609
610 return NULL;
611 }
612
613 /* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do
614 not contain any method/function instance information (since this would
615 force reading type information while reading psymtabs). Therefore,
616 if NAME contains overload information, it must be stripped before searching
617 psymtabs.
618
619 The caller is responsible for freeing the return result. */
620
621 static char *
psymtab_search_name(const char * name)622 psymtab_search_name (const char *name)
623 {
624 switch (current_language->la_language)
625 {
626 case language_cplus:
627 case language_java:
628 {
629 if (strchr (name, '('))
630 {
631 char *ret = cp_remove_params (name);
632
633 if (ret)
634 return ret;
635 }
636 }
637 break;
638
639 default:
640 break;
641 }
642
643 return xstrdup (name);
644 }
645
646 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
647 Check the global symbols if GLOBAL, the static symbols if not. */
648
649 static struct partial_symbol *
lookup_partial_symbol(struct objfile * objfile,struct partial_symtab * pst,const char * name,int global,domain_enum domain)650 lookup_partial_symbol (struct objfile *objfile,
651 struct partial_symtab *pst, const char *name,
652 int global, domain_enum domain)
653 {
654 struct partial_symbol **start, **psym;
655 struct partial_symbol **top, **real_top, **bottom, **center;
656 int length = (global ? pst->n_global_syms : pst->n_static_syms);
657 int do_linear_search = 1;
658 char *search_name;
659 struct cleanup *cleanup;
660
661 if (length == 0)
662 {
663 return (NULL);
664 }
665
666 search_name = psymtab_search_name (name);
667 cleanup = make_cleanup (xfree, search_name);
668 start = (global ?
669 objfile->global_psymbols.list + pst->globals_offset :
670 objfile->static_psymbols.list + pst->statics_offset);
671
672 if (global) /* This means we can use a binary search. */
673 {
674 do_linear_search = 0;
675
676 /* Binary search. This search is guaranteed to end with center
677 pointing at the earliest partial symbol whose name might be
678 correct. At that point *all* partial symbols with an
679 appropriate name will be checked against the correct
680 domain. */
681
682 bottom = start;
683 top = start + length - 1;
684 real_top = top;
685 while (top > bottom)
686 {
687 center = bottom + (top - bottom) / 2;
688 if (!(center < top))
689 internal_error (__FILE__, __LINE__,
690 _("failed internal consistency check"));
691 if (!do_linear_search
692 && SYMBOL_LANGUAGE (*center) == language_java)
693 {
694 do_linear_search = 1;
695 }
696 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center),
697 search_name) >= 0)
698 {
699 top = center;
700 }
701 else
702 {
703 bottom = center + 1;
704 }
705 }
706 if (!(top == bottom))
707 internal_error (__FILE__, __LINE__,
708 _("failed internal consistency check"));
709
710 /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will
711 search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */
712 while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
713 top--;
714
715 /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */
716 top++;
717
718 while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name))
719 {
720 if (symbol_matches_domain (SYMBOL_LANGUAGE (*top),
721 SYMBOL_DOMAIN (*top), domain))
722 {
723 do_cleanups (cleanup);
724 return (*top);
725 }
726 top++;
727 }
728 }
729
730 /* Can't use a binary search or else we found during the binary search that
731 we should also do a linear search. */
732
733 if (do_linear_search)
734 {
735 for (psym = start; psym < start + length; psym++)
736 {
737 if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym),
738 SYMBOL_DOMAIN (*psym), domain)
739 && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name))
740 {
741 do_cleanups (cleanup);
742 return (*psym);
743 }
744 }
745 }
746
747 do_cleanups (cleanup);
748 return (NULL);
749 }
750
751 /* Get the symbol table that corresponds to a partial_symtab.
752 This is fast after the first time you do it. */
753
754 static struct symtab *
psymtab_to_symtab(struct objfile * objfile,struct partial_symtab * pst)755 psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst)
756 {
757 /* If it is a shared psymtab, find an unshared psymtab that includes
758 it. Any such psymtab will do. */
759 while (pst->user != NULL)
760 pst = pst->user;
761
762 /* If it's been looked up before, return it. */
763 if (pst->symtab)
764 return pst->symtab;
765
766 /* If it has not yet been read in, read it. */
767 if (!pst->readin)
768 {
769 struct cleanup *back_to = increment_reading_symtab ();
770
771 (*pst->read_symtab) (pst, objfile);
772 do_cleanups (back_to);
773 }
774
775 return pst->symtab;
776 }
777
778 static void
relocate_psymtabs(struct objfile * objfile,struct section_offsets * new_offsets,struct section_offsets * delta)779 relocate_psymtabs (struct objfile *objfile,
780 struct section_offsets *new_offsets,
781 struct section_offsets *delta)
782 {
783 struct partial_symbol **psym;
784 struct partial_symtab *p;
785
786 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
787 {
788 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
789 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
790 }
791
792 for (psym = objfile->global_psymbols.list;
793 psym < objfile->global_psymbols.next;
794 psym++)
795 {
796 fixup_psymbol_section (*psym, objfile);
797 if (SYMBOL_SECTION (*psym) >= 0)
798 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
799 SYMBOL_SECTION (*psym));
800 }
801 for (psym = objfile->static_psymbols.list;
802 psym < objfile->static_psymbols.next;
803 psym++)
804 {
805 fixup_psymbol_section (*psym, objfile);
806 if (SYMBOL_SECTION (*psym) >= 0)
807 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
808 SYMBOL_SECTION (*psym));
809 }
810 }
811
812 static struct symtab *
find_last_source_symtab_from_partial(struct objfile * ofp)813 find_last_source_symtab_from_partial (struct objfile *ofp)
814 {
815 struct partial_symtab *ps;
816 struct partial_symtab *cs_pst = 0;
817
818 ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps)
819 {
820 const char *name = ps->filename;
821 int len = strlen (name);
822
823 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
824 || strcmp (name, "<<C++-namespaces>>") == 0)))
825 cs_pst = ps;
826 }
827
828 if (cs_pst)
829 {
830 if (cs_pst->readin)
831 {
832 internal_error (__FILE__, __LINE__,
833 _("select_source_symtab: "
834 "readin pst found and no symtabs."));
835 }
836 else
837 return psymtab_to_symtab (ofp, cs_pst);
838 }
839 return NULL;
840 }
841
842 static void
forget_cached_source_info_partial(struct objfile * objfile)843 forget_cached_source_info_partial (struct objfile *objfile)
844 {
845 struct partial_symtab *pst;
846
847 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
848 {
849 if (pst->fullname != NULL)
850 {
851 xfree (pst->fullname);
852 pst->fullname = NULL;
853 }
854 }
855 }
856
857 static void
print_partial_symbols(struct gdbarch * gdbarch,struct partial_symbol ** p,int count,char * what,struct ui_file * outfile)858 print_partial_symbols (struct gdbarch *gdbarch,
859 struct partial_symbol **p, int count, char *what,
860 struct ui_file *outfile)
861 {
862 fprintf_filtered (outfile, " %s partial symbols:\n", what);
863 while (count-- > 0)
864 {
865 QUIT;
866 fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p));
867 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
868 {
869 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
870 }
871 fputs_filtered (", ", outfile);
872 switch (SYMBOL_DOMAIN (*p))
873 {
874 case UNDEF_DOMAIN:
875 fputs_filtered ("undefined domain, ", outfile);
876 break;
877 case VAR_DOMAIN:
878 /* This is the usual thing -- don't print it. */
879 break;
880 case STRUCT_DOMAIN:
881 fputs_filtered ("struct domain, ", outfile);
882 break;
883 case LABEL_DOMAIN:
884 fputs_filtered ("label domain, ", outfile);
885 break;
886 default:
887 fputs_filtered ("<invalid domain>, ", outfile);
888 break;
889 }
890 switch (SYMBOL_CLASS (*p))
891 {
892 case LOC_UNDEF:
893 fputs_filtered ("undefined", outfile);
894 break;
895 case LOC_CONST:
896 fputs_filtered ("constant int", outfile);
897 break;
898 case LOC_STATIC:
899 fputs_filtered ("static", outfile);
900 break;
901 case LOC_REGISTER:
902 fputs_filtered ("register", outfile);
903 break;
904 case LOC_ARG:
905 fputs_filtered ("pass by value", outfile);
906 break;
907 case LOC_REF_ARG:
908 fputs_filtered ("pass by reference", outfile);
909 break;
910 case LOC_REGPARM_ADDR:
911 fputs_filtered ("register address parameter", outfile);
912 break;
913 case LOC_LOCAL:
914 fputs_filtered ("stack parameter", outfile);
915 break;
916 case LOC_TYPEDEF:
917 fputs_filtered ("type", outfile);
918 break;
919 case LOC_LABEL:
920 fputs_filtered ("label", outfile);
921 break;
922 case LOC_BLOCK:
923 fputs_filtered ("function", outfile);
924 break;
925 case LOC_CONST_BYTES:
926 fputs_filtered ("constant bytes", outfile);
927 break;
928 case LOC_UNRESOLVED:
929 fputs_filtered ("unresolved", outfile);
930 break;
931 case LOC_OPTIMIZED_OUT:
932 fputs_filtered ("optimized out", outfile);
933 break;
934 case LOC_COMPUTED:
935 fputs_filtered ("computed at runtime", outfile);
936 break;
937 default:
938 fputs_filtered ("<invalid location>", outfile);
939 break;
940 }
941 fputs_filtered (", ", outfile);
942 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
943 fprintf_filtered (outfile, "\n");
944 p++;
945 }
946 }
947
948 static void
dump_psymtab(struct objfile * objfile,struct partial_symtab * psymtab,struct ui_file * outfile)949 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
950 struct ui_file *outfile)
951 {
952 struct gdbarch *gdbarch = get_objfile_arch (objfile);
953 int i;
954
955 if (psymtab->anonymous)
956 {
957 fprintf_filtered (outfile, "\nAnonymous partial symtab (%s) ",
958 psymtab->filename);
959 }
960 else
961 {
962 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
963 psymtab->filename);
964 }
965 fprintf_filtered (outfile, "(object ");
966 gdb_print_host_address (psymtab, outfile);
967 fprintf_filtered (outfile, ")\n\n");
968 fprintf_unfiltered (outfile, " Read from object file %s (",
969 objfile->name);
970 gdb_print_host_address (objfile, outfile);
971 fprintf_unfiltered (outfile, ")\n");
972
973 if (psymtab->readin)
974 {
975 fprintf_filtered (outfile,
976 " Full symtab was read (at ");
977 gdb_print_host_address (psymtab->symtab, outfile);
978 fprintf_filtered (outfile, " by function at ");
979 gdb_print_host_address (psymtab->read_symtab, outfile);
980 fprintf_filtered (outfile, ")\n");
981 }
982
983 fprintf_filtered (outfile, " Relocate symbols by ");
984 for (i = 0; i < objfile->num_sections; ++i)
985 {
986 if (i != 0)
987 fprintf_filtered (outfile, ", ");
988 wrap_here (" ");
989 fputs_filtered (paddress (gdbarch,
990 ANOFFSET (psymtab->section_offsets, i)),
991 outfile);
992 }
993 fprintf_filtered (outfile, "\n");
994
995 fprintf_filtered (outfile, " Symbols cover text addresses ");
996 fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
997 fprintf_filtered (outfile, "-");
998 fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
999 fprintf_filtered (outfile, "\n");
1000 fprintf_filtered (outfile, " Address map supported - %s.\n",
1001 psymtab->psymtabs_addrmap_supported ? "yes" : "no");
1002 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
1003 psymtab->number_of_dependencies);
1004 for (i = 0; i < psymtab->number_of_dependencies; i++)
1005 {
1006 fprintf_filtered (outfile, " %d ", i);
1007 gdb_print_host_address (psymtab->dependencies[i], outfile);
1008 fprintf_filtered (outfile, " %s\n",
1009 psymtab->dependencies[i]->filename);
1010 }
1011 if (psymtab->user != NULL)
1012 {
1013 fprintf_filtered (outfile, " Shared partial symtab with user ");
1014 gdb_print_host_address (psymtab->user, outfile);
1015 fprintf_filtered (outfile, "\n");
1016 }
1017 if (psymtab->n_global_syms > 0)
1018 {
1019 print_partial_symbols (gdbarch,
1020 objfile->global_psymbols.list
1021 + psymtab->globals_offset,
1022 psymtab->n_global_syms, "Global", outfile);
1023 }
1024 if (psymtab->n_static_syms > 0)
1025 {
1026 print_partial_symbols (gdbarch,
1027 objfile->static_psymbols.list
1028 + psymtab->statics_offset,
1029 psymtab->n_static_syms, "Static", outfile);
1030 }
1031 fprintf_filtered (outfile, "\n");
1032 }
1033
1034 static void
print_psymtab_stats_for_objfile(struct objfile * objfile)1035 print_psymtab_stats_for_objfile (struct objfile *objfile)
1036 {
1037 int i;
1038 struct partial_symtab *ps;
1039
1040 i = 0;
1041 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1042 {
1043 if (ps->readin == 0)
1044 i++;
1045 }
1046 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
1047 }
1048
1049 static void
dump_psymtabs_for_objfile(struct objfile * objfile)1050 dump_psymtabs_for_objfile (struct objfile *objfile)
1051 {
1052 struct partial_symtab *psymtab;
1053
1054 if (objfile->psymtabs)
1055 {
1056 printf_filtered ("Psymtabs:\n");
1057 for (psymtab = objfile->psymtabs;
1058 psymtab != NULL;
1059 psymtab = psymtab->next)
1060 {
1061 printf_filtered ("%s at ",
1062 psymtab->filename);
1063 gdb_print_host_address (psymtab, gdb_stdout);
1064 printf_filtered (", ");
1065 wrap_here (" ");
1066 }
1067 printf_filtered ("\n\n");
1068 }
1069 }
1070
1071 /* Look through the partial symtabs for all symbols which begin
1072 by matching FUNC_NAME. Make sure we read that symbol table in. */
1073
1074 static void
read_symtabs_for_function(struct objfile * objfile,const char * func_name)1075 read_symtabs_for_function (struct objfile *objfile, const char *func_name)
1076 {
1077 struct partial_symtab *ps;
1078
1079 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1080 {
1081 if (ps->readin)
1082 continue;
1083
1084 if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN)
1085 != NULL)
1086 || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN)
1087 != NULL))
1088 psymtab_to_symtab (objfile, ps);
1089 }
1090 }
1091
1092 static void
expand_partial_symbol_tables(struct objfile * objfile)1093 expand_partial_symbol_tables (struct objfile *objfile)
1094 {
1095 struct partial_symtab *psymtab;
1096
1097 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1098 {
1099 psymtab_to_symtab (objfile, psymtab);
1100 }
1101 }
1102
1103 static void
read_psymtabs_with_fullname(struct objfile * objfile,const char * fullname)1104 read_psymtabs_with_fullname (struct objfile *objfile, const char *fullname)
1105 {
1106 struct partial_symtab *p;
1107
1108 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p)
1109 {
1110 /* Anonymous psymtabs don't have a name of a source file. */
1111 if (p->anonymous)
1112 continue;
1113
1114 /* psymtab_to_fullname tries to open the file which is slow.
1115 Don't call it if we know the basenames don't match. */
1116 if ((basenames_may_differ
1117 || filename_cmp (lbasename (fullname), lbasename (p->filename)) == 0)
1118 && filename_cmp (fullname, psymtab_to_fullname (p)) == 0)
1119 psymtab_to_symtab (objfile, p);
1120 }
1121 }
1122
1123 static void
map_symbol_filenames_psymtab(struct objfile * objfile,symbol_filename_ftype * fun,void * data,int need_fullname)1124 map_symbol_filenames_psymtab (struct objfile *objfile,
1125 symbol_filename_ftype *fun, void *data,
1126 int need_fullname)
1127 {
1128 struct partial_symtab *ps;
1129
1130 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1131 {
1132 const char *fullname;
1133
1134 if (ps->readin)
1135 continue;
1136
1137 /* We can skip shared psymtabs here, because any file name will be
1138 attached to the unshared psymtab. */
1139 if (ps->user != NULL)
1140 continue;
1141
1142 /* Anonymous psymtabs don't have a file name. */
1143 if (ps->anonymous)
1144 continue;
1145
1146 QUIT;
1147 if (need_fullname)
1148 fullname = psymtab_to_fullname (ps);
1149 else
1150 fullname = NULL;
1151 (*fun) (ps->filename, fullname, data);
1152 }
1153 }
1154
1155 /* Finds the fullname that a partial_symtab represents.
1156
1157 If this functions finds the fullname, it will save it in ps->fullname
1158 and it will also return the value.
1159
1160 If this function fails to find the file that this partial_symtab represents,
1161 NULL will be returned and ps->fullname will be set to NULL. */
1162
1163 static const char *
psymtab_to_fullname(struct partial_symtab * ps)1164 psymtab_to_fullname (struct partial_symtab *ps)
1165 {
1166 gdb_assert (!ps->anonymous);
1167
1168 /* Use cached copy if we have it.
1169 We rely on forget_cached_source_info being called appropriately
1170 to handle cases like the file being moved. */
1171 if (ps->fullname == NULL)
1172 {
1173 int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname);
1174
1175 if (fd >= 0)
1176 close (fd);
1177 else
1178 {
1179 char *fullname;
1180 struct cleanup *back_to;
1181
1182 /* rewrite_source_path would be applied by find_and_open_source, we
1183 should report the pathname where GDB tried to find the file. */
1184
1185 if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename))
1186 fullname = xstrdup (ps->filename);
1187 else
1188 fullname = concat (ps->dirname, SLASH_STRING, ps->filename, NULL);
1189
1190 back_to = make_cleanup (xfree, fullname);
1191 ps->fullname = rewrite_source_path (fullname);
1192 if (ps->fullname == NULL)
1193 ps->fullname = xstrdup (fullname);
1194 do_cleanups (back_to);
1195 }
1196 }
1197
1198 return ps->fullname;
1199 }
1200
1201 static const char *
find_symbol_file_from_partial(struct objfile * objfile,const char * name)1202 find_symbol_file_from_partial (struct objfile *objfile, const char *name)
1203 {
1204 struct partial_symtab *pst;
1205
1206 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst)
1207 {
1208 if (lookup_partial_symbol (objfile, pst, name, 1, VAR_DOMAIN))
1209 return pst->filename;
1210 }
1211 return NULL;
1212 }
1213
1214 /* For all symbols, s, in BLOCK that are in NAMESPACE and match NAME
1215 according to the function MATCH, call CALLBACK(BLOCK, s, DATA).
1216 BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK
1217 ever returns non-zero, and otherwise returns 0. */
1218
1219 static int
map_block(const char * name,domain_enum namespace,struct objfile * objfile,struct block * block,int (* callback)(struct block *,struct symbol *,void *),void * data,symbol_compare_ftype * match)1220 map_block (const char *name, domain_enum namespace, struct objfile *objfile,
1221 struct block *block,
1222 int (*callback) (struct block *, struct symbol *, void *),
1223 void *data, symbol_compare_ftype *match)
1224 {
1225 struct block_iterator iter;
1226 struct symbol *sym;
1227
1228 for (sym = block_iter_match_first (block, name, match, &iter);
1229 sym != NULL; sym = block_iter_match_next (name, match, &iter))
1230 {
1231 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1232 SYMBOL_DOMAIN (sym), namespace))
1233 {
1234 if (callback (block, sym, data))
1235 return 1;
1236 }
1237 }
1238
1239 return 0;
1240 }
1241
1242 /* Psymtab version of map_matching_symbols. See its definition in
1243 the definition of quick_symbol_functions in symfile.h. */
1244
1245 static void
map_matching_symbols_psymtab(const char * name,domain_enum namespace,struct objfile * objfile,int global,int (* callback)(struct block *,struct symbol *,void *),void * data,symbol_compare_ftype * match,symbol_compare_ftype * ordered_compare)1246 map_matching_symbols_psymtab (const char *name, domain_enum namespace,
1247 struct objfile *objfile, int global,
1248 int (*callback) (struct block *,
1249 struct symbol *, void *),
1250 void *data,
1251 symbol_compare_ftype *match,
1252 symbol_compare_ftype *ordered_compare)
1253 {
1254 const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK;
1255 struct partial_symtab *ps;
1256
1257 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1258 {
1259 QUIT;
1260 if (ps->readin
1261 || match_partial_symbol (objfile, ps, global, name, namespace, match,
1262 ordered_compare))
1263 {
1264 struct symtab *s = psymtab_to_symtab (objfile, ps);
1265 struct block *block;
1266
1267 if (s == NULL || !s->primary)
1268 continue;
1269 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind);
1270 if (map_block (name, namespace, objfile, block,
1271 callback, data, match))
1272 return;
1273 if (callback (block, NULL, data))
1274 return;
1275 }
1276 }
1277 }
1278
1279 /* A helper for expand_symtabs_matching_via_partial that handles
1280 searching included psymtabs. This returns 1 if a symbol is found,
1281 and zero otherwise. It also updates the 'searched_flag' on the
1282 various psymtabs that it searches. */
1283
1284 static int
recursively_search_psymtabs(struct partial_symtab * ps,struct objfile * objfile,enum search_domain kind,int (* name_matcher)(const char *,void *),void * data)1285 recursively_search_psymtabs (struct partial_symtab *ps,
1286 struct objfile *objfile,
1287 enum search_domain kind,
1288 int (*name_matcher) (const char *, void *),
1289 void *data)
1290 {
1291 struct partial_symbol **psym;
1292 struct partial_symbol **bound, **gbound, **sbound;
1293 int keep_going = 1;
1294 int result = PST_SEARCHED_AND_NOT_FOUND;
1295 int i;
1296
1297 if (ps->searched_flag != PST_NOT_SEARCHED)
1298 return ps->searched_flag == PST_SEARCHED_AND_FOUND;
1299
1300 /* Recurse into shared psymtabs first, because they may have already
1301 been searched, and this could save some time. */
1302 for (i = 0; i < ps->number_of_dependencies; ++i)
1303 {
1304 int r;
1305
1306 /* Skip non-shared dependencies, these are handled elsewhere. */
1307 if (ps->dependencies[i]->user == NULL)
1308 continue;
1309
1310 r = recursively_search_psymtabs (ps->dependencies[i],
1311 objfile, kind, name_matcher, data);
1312 if (r != 0)
1313 {
1314 ps->searched_flag = PST_SEARCHED_AND_FOUND;
1315 return 1;
1316 }
1317 }
1318
1319 gbound = (objfile->global_psymbols.list
1320 + ps->globals_offset + ps->n_global_syms);
1321 sbound = (objfile->static_psymbols.list
1322 + ps->statics_offset + ps->n_static_syms);
1323 bound = gbound;
1324
1325 /* Go through all of the symbols stored in a partial
1326 symtab in one loop. */
1327 psym = objfile->global_psymbols.list + ps->globals_offset;
1328 while (keep_going)
1329 {
1330 if (psym >= bound)
1331 {
1332 if (bound == gbound && ps->n_static_syms != 0)
1333 {
1334 psym = objfile->static_psymbols.list + ps->statics_offset;
1335 bound = sbound;
1336 }
1337 else
1338 keep_going = 0;
1339 continue;
1340 }
1341 else
1342 {
1343 QUIT;
1344
1345 if ((kind == ALL_DOMAIN
1346 || (kind == VARIABLES_DOMAIN
1347 && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
1348 && SYMBOL_CLASS (*psym) != LOC_BLOCK)
1349 || (kind == FUNCTIONS_DOMAIN
1350 && SYMBOL_CLASS (*psym) == LOC_BLOCK)
1351 || (kind == TYPES_DOMAIN
1352 && SYMBOL_CLASS (*psym) == LOC_TYPEDEF))
1353 && (*name_matcher) (SYMBOL_SEARCH_NAME (*psym), data))
1354 {
1355 /* Found a match, so notify our caller. */
1356 result = PST_SEARCHED_AND_FOUND;
1357 keep_going = 0;
1358 }
1359 }
1360 psym++;
1361 }
1362
1363 ps->searched_flag = result;
1364 return result == PST_SEARCHED_AND_FOUND;
1365 }
1366
1367 static void
expand_symtabs_matching_via_partial(struct objfile * objfile,int (* file_matcher)(const char *,void *,int basenames),int (* name_matcher)(const char *,void *),enum search_domain kind,void * data)1368 expand_symtabs_matching_via_partial
1369 (struct objfile *objfile,
1370 int (*file_matcher) (const char *, void *, int basenames),
1371 int (*name_matcher) (const char *, void *),
1372 enum search_domain kind,
1373 void *data)
1374 {
1375 struct partial_symtab *ps;
1376
1377 /* Clear the search flags. */
1378 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1379 {
1380 ps->searched_flag = PST_NOT_SEARCHED;
1381 }
1382
1383 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps)
1384 {
1385 if (ps->readin)
1386 continue;
1387
1388 /* We skip shared psymtabs because file-matching doesn't apply
1389 to them; but we search them later in the loop. */
1390 if (ps->user != NULL)
1391 continue;
1392
1393 if (file_matcher)
1394 {
1395 if (ps->anonymous)
1396 continue;
1397
1398 /* Before we invoke realpath, which can get expensive when many
1399 files are involved, do a quick comparison of the basenames. */
1400 if (!(*file_matcher) (ps->filename, data, 0)
1401 && (basenames_may_differ
1402 || (*file_matcher) (lbasename (ps->filename), data, 1))
1403 && !(*file_matcher) (psymtab_to_fullname (ps), data, 0))
1404 continue;
1405 }
1406
1407 if (recursively_search_psymtabs (ps, objfile, kind, name_matcher, data))
1408 psymtab_to_symtab (objfile, ps);
1409 }
1410 }
1411
1412 static int
objfile_has_psyms(struct objfile * objfile)1413 objfile_has_psyms (struct objfile *objfile)
1414 {
1415 return objfile->psymtabs != NULL;
1416 }
1417
1418 const struct quick_symbol_functions psym_functions =
1419 {
1420 objfile_has_psyms,
1421 find_last_source_symtab_from_partial,
1422 forget_cached_source_info_partial,
1423 partial_map_symtabs_matching_filename,
1424 lookup_symbol_aux_psymtabs,
1425 print_psymtab_stats_for_objfile,
1426 dump_psymtabs_for_objfile,
1427 relocate_psymtabs,
1428 read_symtabs_for_function,
1429 expand_partial_symbol_tables,
1430 read_psymtabs_with_fullname,
1431 find_symbol_file_from_partial,
1432 map_matching_symbols_psymtab,
1433 expand_symtabs_matching_via_partial,
1434 find_pc_sect_symtab_from_partial,
1435 map_symbol_filenames_psymtab
1436 };
1437
1438
1439
1440 /* This compares two partial symbols by names, using strcmp_iw_ordered
1441 for the comparison. */
1442
1443 static int
compare_psymbols(const void * s1p,const void * s2p)1444 compare_psymbols (const void *s1p, const void *s2p)
1445 {
1446 struct partial_symbol *const *s1 = s1p;
1447 struct partial_symbol *const *s2 = s2p;
1448
1449 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
1450 SYMBOL_SEARCH_NAME (*s2));
1451 }
1452
1453 void
sort_pst_symbols(struct objfile * objfile,struct partial_symtab * pst)1454 sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
1455 {
1456 /* Sort the global list; don't sort the static list. */
1457
1458 qsort (objfile->global_psymbols.list + pst->globals_offset,
1459 pst->n_global_syms, sizeof (struct partial_symbol *),
1460 compare_psymbols);
1461 }
1462
1463 /* Allocate and partially fill a partial symtab. It will be
1464 completely filled at the end of the symbol list.
1465
1466 FILENAME is the name of the symbol-file we are reading from. */
1467
1468 struct partial_symtab *
start_psymtab_common(struct objfile * objfile,struct section_offsets * section_offsets,const char * filename,CORE_ADDR textlow,struct partial_symbol ** global_syms,struct partial_symbol ** static_syms)1469 start_psymtab_common (struct objfile *objfile,
1470 struct section_offsets *section_offsets,
1471 const char *filename,
1472 CORE_ADDR textlow, struct partial_symbol **global_syms,
1473 struct partial_symbol **static_syms)
1474 {
1475 struct partial_symtab *psymtab;
1476
1477 psymtab = allocate_psymtab (filename, objfile);
1478 psymtab->section_offsets = section_offsets;
1479 psymtab->textlow = textlow;
1480 psymtab->texthigh = psymtab->textlow; /* default */
1481 psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
1482 psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
1483 return (psymtab);
1484 }
1485
1486 /* Calculate a hash code for the given partial symbol. The hash is
1487 calculated using the symbol's value, language, domain, class
1488 and name. These are the values which are set by
1489 add_psymbol_to_bcache. */
1490
1491 static unsigned long
psymbol_hash(const void * addr,int length)1492 psymbol_hash (const void *addr, int length)
1493 {
1494 unsigned long h = 0;
1495 struct partial_symbol *psymbol = (struct partial_symbol *) addr;
1496 unsigned int lang = psymbol->ginfo.language;
1497 unsigned int domain = PSYMBOL_DOMAIN (psymbol);
1498 unsigned int class = PSYMBOL_CLASS (psymbol);
1499
1500 h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h);
1501 h = hash_continue (&lang, sizeof (unsigned int), h);
1502 h = hash_continue (&domain, sizeof (unsigned int), h);
1503 h = hash_continue (&class, sizeof (unsigned int), h);
1504 h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h);
1505
1506 return h;
1507 }
1508
1509 /* Returns true if the symbol at addr1 equals the symbol at addr2.
1510 For the comparison this function uses a symbols value,
1511 language, domain, class and name. */
1512
1513 static int
psymbol_compare(const void * addr1,const void * addr2,int length)1514 psymbol_compare (const void *addr1, const void *addr2, int length)
1515 {
1516 struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
1517 struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
1518
1519 return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
1520 sizeof (sym1->ginfo.value)) == 0
1521 && sym1->ginfo.language == sym2->ginfo.language
1522 && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2)
1523 && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2)
1524 && sym1->ginfo.name == sym2->ginfo.name);
1525 }
1526
1527 /* Initialize a partial symbol bcache. */
1528
1529 struct psymbol_bcache *
psymbol_bcache_init(void)1530 psymbol_bcache_init (void)
1531 {
1532 struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache);
1533 bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
1534 return bcache;
1535 }
1536
1537 /* Free a partial symbol bcache. */
1538 void
psymbol_bcache_free(struct psymbol_bcache * bcache)1539 psymbol_bcache_free (struct psymbol_bcache *bcache)
1540 {
1541 if (bcache == NULL)
1542 return;
1543
1544 bcache_xfree (bcache->bcache);
1545 xfree (bcache);
1546 }
1547
1548 /* Return the internal bcache of the psymbol_bcache BCACHE. */
1549
1550 struct bcache *
psymbol_bcache_get_bcache(struct psymbol_bcache * bcache)1551 psymbol_bcache_get_bcache (struct psymbol_bcache *bcache)
1552 {
1553 return bcache->bcache;
1554 }
1555
1556 /* Find a copy of the SYM in BCACHE. If BCACHE has never seen this
1557 symbol before, add a copy to BCACHE. In either case, return a pointer
1558 to BCACHE's copy of the symbol. If optional ADDED is not NULL, return
1559 1 in case of new entry or 0 if returning an old entry. */
1560
1561 static const struct partial_symbol *
psymbol_bcache_full(struct partial_symbol * sym,struct psymbol_bcache * bcache,int * added)1562 psymbol_bcache_full (struct partial_symbol *sym,
1563 struct psymbol_bcache *bcache,
1564 int *added)
1565 {
1566 return bcache_full (sym,
1567 sizeof (struct partial_symbol),
1568 bcache->bcache,
1569 added);
1570 }
1571
1572 /* Helper function, initialises partial symbol structure and stashes
1573 it into objfile's bcache. Note that our caching mechanism will
1574 use all fields of struct partial_symbol to determine hash value of the
1575 structure. In other words, having two symbols with the same name but
1576 different domain (or address) is possible and correct. */
1577
1578 static const struct partial_symbol *
add_psymbol_to_bcache(const char * name,int namelength,int copy_name,domain_enum domain,enum address_class class,long val,CORE_ADDR coreaddr,enum language language,struct objfile * objfile,int * added)1579 add_psymbol_to_bcache (const char *name, int namelength, int copy_name,
1580 domain_enum domain,
1581 enum address_class class,
1582 long val, /* Value as a long */
1583 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1584 enum language language, struct objfile *objfile,
1585 int *added)
1586 {
1587 struct partial_symbol psymbol;
1588
1589 /* We must ensure that the entire 'value' field has been zeroed
1590 before assigning to it, because an assignment may not write the
1591 entire field. */
1592 memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
1593
1594 /* val and coreaddr are mutually exclusive, one of them *will* be zero. */
1595 if (val != 0)
1596 {
1597 SYMBOL_VALUE (&psymbol) = val;
1598 }
1599 else
1600 {
1601 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
1602 }
1603 SYMBOL_SECTION (&psymbol) = 0;
1604 SYMBOL_OBJ_SECTION (&psymbol) = NULL;
1605 SYMBOL_SET_LANGUAGE (&psymbol, language);
1606 PSYMBOL_DOMAIN (&psymbol) = domain;
1607 PSYMBOL_CLASS (&psymbol) = class;
1608
1609 SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
1610
1611 /* Stash the partial symbol away in the cache. */
1612 return psymbol_bcache_full (&psymbol,
1613 objfile->psymbol_cache,
1614 added);
1615 }
1616
1617 /* Increase the space allocated for LISTP, which is probably
1618 global_psymbols or static_psymbols. This space will eventually
1619 be freed in free_objfile(). */
1620
1621 static void
extend_psymbol_list(struct psymbol_allocation_list * listp,struct objfile * objfile)1622 extend_psymbol_list (struct psymbol_allocation_list *listp,
1623 struct objfile *objfile)
1624 {
1625 int new_size;
1626
1627 if (listp->size == 0)
1628 {
1629 new_size = 255;
1630 listp->list = (struct partial_symbol **)
1631 xmalloc (new_size * sizeof (struct partial_symbol *));
1632 }
1633 else
1634 {
1635 new_size = listp->size * 2;
1636 listp->list = (struct partial_symbol **)
1637 xrealloc ((char *) listp->list,
1638 new_size * sizeof (struct partial_symbol *));
1639 }
1640 /* Next assumes we only went one over. Should be good if
1641 program works correctly. */
1642 listp->next = listp->list + listp->size;
1643 listp->size = new_size;
1644 }
1645
1646 /* Helper function, adds partial symbol to the given partial symbol
1647 list. */
1648
1649 static void
append_psymbol_to_list(struct psymbol_allocation_list * list,const struct partial_symbol * psym,struct objfile * objfile)1650 append_psymbol_to_list (struct psymbol_allocation_list *list,
1651 const struct partial_symbol *psym,
1652 struct objfile *objfile)
1653 {
1654 if (list->next >= list->list + list->size)
1655 extend_psymbol_list (list, objfile);
1656 *list->next++ = (struct partial_symbol *) psym;
1657 OBJSTAT (objfile, n_psyms++);
1658 }
1659
1660 /* Add a symbol with a long value to a psymtab.
1661 Since one arg is a struct, we pass in a ptr and deref it (sigh).
1662 Return the partial symbol that has been added. */
1663
1664 void
add_psymbol_to_list(const char * name,int namelength,int copy_name,domain_enum domain,enum address_class class,struct psymbol_allocation_list * list,long val,CORE_ADDR coreaddr,enum language language,struct objfile * objfile)1665 add_psymbol_to_list (const char *name, int namelength, int copy_name,
1666 domain_enum domain,
1667 enum address_class class,
1668 struct psymbol_allocation_list *list,
1669 long val, /* Value as a long */
1670 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
1671 enum language language, struct objfile *objfile)
1672 {
1673 const struct partial_symbol *psym;
1674
1675 int added;
1676
1677 /* Stash the partial symbol away in the cache. */
1678 psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
1679 val, coreaddr, language, objfile, &added);
1680
1681 /* Do not duplicate global partial symbols. */
1682 if (list == &objfile->global_psymbols
1683 && !added)
1684 return;
1685
1686 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
1687 append_psymbol_to_list (list, psym, objfile);
1688 }
1689
1690 /* Initialize storage for partial symbols. */
1691
1692 void
init_psymbol_list(struct objfile * objfile,int total_symbols)1693 init_psymbol_list (struct objfile *objfile, int total_symbols)
1694 {
1695 /* Free any previously allocated psymbol lists. */
1696
1697 if (objfile->global_psymbols.list)
1698 {
1699 xfree (objfile->global_psymbols.list);
1700 }
1701 if (objfile->static_psymbols.list)
1702 {
1703 xfree (objfile->static_psymbols.list);
1704 }
1705
1706 /* Current best guess is that approximately a twentieth
1707 of the total symbols (in a debugging file) are global or static
1708 oriented symbols, then multiply that by slop factor of two. */
1709
1710 objfile->global_psymbols.size = total_symbols / 10;
1711 objfile->static_psymbols.size = total_symbols / 10;
1712
1713 if (objfile->global_psymbols.size > 0)
1714 {
1715 objfile->global_psymbols.next =
1716 objfile->global_psymbols.list = (struct partial_symbol **)
1717 xmalloc ((objfile->global_psymbols.size
1718 * sizeof (struct partial_symbol *)));
1719 }
1720 if (objfile->static_psymbols.size > 0)
1721 {
1722 objfile->static_psymbols.next =
1723 objfile->static_psymbols.list = (struct partial_symbol **)
1724 xmalloc ((objfile->static_psymbols.size
1725 * sizeof (struct partial_symbol *)));
1726 }
1727 }
1728
1729 struct partial_symtab *
allocate_psymtab(const char * filename,struct objfile * objfile)1730 allocate_psymtab (const char *filename, struct objfile *objfile)
1731 {
1732 struct partial_symtab *psymtab;
1733
1734 if (objfile->free_psymtabs)
1735 {
1736 psymtab = objfile->free_psymtabs;
1737 objfile->free_psymtabs = psymtab->next;
1738 }
1739 else
1740 psymtab = (struct partial_symtab *)
1741 obstack_alloc (&objfile->objfile_obstack,
1742 sizeof (struct partial_symtab));
1743
1744 memset (psymtab, 0, sizeof (struct partial_symtab));
1745 psymtab->filename = obstack_copy0 (&objfile->objfile_obstack,
1746 filename, strlen (filename));
1747 psymtab->symtab = NULL;
1748
1749 /* Prepend it to the psymtab list for the objfile it belongs to.
1750 Psymtabs are searched in most recent inserted -> least recent
1751 inserted order. */
1752
1753 psymtab->next = objfile->psymtabs;
1754 objfile->psymtabs = psymtab;
1755
1756 if (symtab_create_debug)
1757 {
1758 /* Be a bit clever with debugging messages, and don't print objfile
1759 every time, only when it changes. */
1760 static char *last_objfile_name = NULL;
1761
1762 if (last_objfile_name == NULL
1763 || strcmp (last_objfile_name, objfile->name) != 0)
1764 {
1765 xfree (last_objfile_name);
1766 last_objfile_name = xstrdup (objfile->name);
1767 fprintf_unfiltered (gdb_stdlog,
1768 "Creating one or more psymtabs for objfile %s ...\n",
1769 last_objfile_name);
1770 }
1771 fprintf_unfiltered (gdb_stdlog,
1772 "Created psymtab %s for module %s.\n",
1773 host_address_to_string (psymtab), filename);
1774 }
1775
1776 return (psymtab);
1777 }
1778
1779 void
discard_psymtab(struct objfile * objfile,struct partial_symtab * pst)1780 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
1781 {
1782 struct partial_symtab **prev_pst;
1783
1784 /* From dbxread.c:
1785 Empty psymtabs happen as a result of header files which don't
1786 have any symbols in them. There can be a lot of them. But this
1787 check is wrong, in that a psymtab with N_SLINE entries but
1788 nothing else is not empty, but we don't realize that. Fixing
1789 that without slowing things down might be tricky. */
1790
1791 /* First, snip it out of the psymtab chain. */
1792
1793 prev_pst = &(objfile->psymtabs);
1794 while ((*prev_pst) != pst)
1795 prev_pst = &((*prev_pst)->next);
1796 (*prev_pst) = pst->next;
1797
1798 /* Next, put it on a free list for recycling. */
1799
1800 pst->next = objfile->free_psymtabs;
1801 objfile->free_psymtabs = pst;
1802 }
1803
1804 /* An object of this type is passed to discard_psymtabs_upto. */
1805
1806 struct psymtab_state
1807 {
1808 /* The objfile where psymtabs are discarded. */
1809
1810 struct objfile *objfile;
1811
1812 /* The first psymtab to save. */
1813
1814 struct partial_symtab *save;
1815 };
1816
1817 /* A cleanup function used by make_cleanup_discard_psymtabs. */
1818
1819 static void
discard_psymtabs_upto(void * arg)1820 discard_psymtabs_upto (void *arg)
1821 {
1822 struct psymtab_state *state = arg;
1823
1824 while (state->objfile->psymtabs != state->save)
1825 discard_psymtab (state->objfile, state->objfile->psymtabs);
1826 }
1827
1828 /* Return a new cleanup that discards all psymtabs created in OBJFILE
1829 after this function is called. */
1830
1831 struct cleanup *
make_cleanup_discard_psymtabs(struct objfile * objfile)1832 make_cleanup_discard_psymtabs (struct objfile *objfile)
1833 {
1834 struct psymtab_state *state = XNEW (struct psymtab_state);
1835
1836 state->objfile = objfile;
1837 state->save = objfile->psymtabs;
1838
1839 return make_cleanup_dtor (discard_psymtabs_upto, state, xfree);
1840 }
1841
1842
1843
1844 static void
maintenance_print_psymbols(char * args,int from_tty)1845 maintenance_print_psymbols (char *args, int from_tty)
1846 {
1847 char **argv;
1848 struct ui_file *outfile;
1849 struct cleanup *cleanups;
1850 char *symname = NULL;
1851 char *filename = DEV_TTY;
1852 struct objfile *objfile;
1853 struct partial_symtab *ps;
1854
1855 dont_repeat ();
1856
1857 if (args == NULL)
1858 {
1859 error (_("\
1860 print-psymbols takes an output file name and optional symbol file name"));
1861 }
1862 argv = gdb_buildargv (args);
1863 cleanups = make_cleanup_freeargv (argv);
1864
1865 if (argv[0] != NULL)
1866 {
1867 filename = argv[0];
1868 /* If a second arg is supplied, it is a source file name to match on. */
1869 if (argv[1] != NULL)
1870 {
1871 symname = argv[1];
1872 }
1873 }
1874
1875 filename = tilde_expand (filename);
1876 make_cleanup (xfree, filename);
1877
1878 outfile = gdb_fopen (filename, FOPEN_WT);
1879 if (outfile == 0)
1880 perror_with_name (filename);
1881 make_cleanup_ui_file_delete (outfile);
1882
1883 ALL_PSYMTABS (objfile, ps)
1884 {
1885 QUIT;
1886 if (symname == NULL || filename_cmp (symname, ps->filename) == 0)
1887 dump_psymtab (objfile, ps, outfile);
1888 }
1889 do_cleanups (cleanups);
1890 }
1891
1892 /* List all the partial symbol tables whose names match REGEXP (optional). */
1893 static void
maintenance_info_psymtabs(char * regexp,int from_tty)1894 maintenance_info_psymtabs (char *regexp, int from_tty)
1895 {
1896 struct program_space *pspace;
1897 struct objfile *objfile;
1898
1899 if (regexp)
1900 re_comp (regexp);
1901
1902 ALL_PSPACES (pspace)
1903 ALL_PSPACE_OBJFILES (pspace, objfile)
1904 {
1905 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1906 struct partial_symtab *psymtab;
1907
1908 /* We don't want to print anything for this objfile until we
1909 actually find a symtab whose name matches. */
1910 int printed_objfile_start = 0;
1911
1912 ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab)
1913 {
1914 QUIT;
1915
1916 if (! regexp
1917 || re_exec (psymtab->filename))
1918 {
1919 if (! printed_objfile_start)
1920 {
1921 printf_filtered ("{ objfile %s ", objfile->name);
1922 wrap_here (" ");
1923 printf_filtered ("((struct objfile *) %s)\n",
1924 host_address_to_string (objfile));
1925 printed_objfile_start = 1;
1926 }
1927
1928 printf_filtered (" { psymtab %s ", psymtab->filename);
1929 wrap_here (" ");
1930 printf_filtered ("((struct partial_symtab *) %s)\n",
1931 host_address_to_string (psymtab));
1932
1933 printf_filtered (" readin %s\n",
1934 psymtab->readin ? "yes" : "no");
1935 printf_filtered (" fullname %s\n",
1936 psymtab->fullname
1937 ? psymtab->fullname : "(null)");
1938 printf_filtered (" text addresses ");
1939 fputs_filtered (paddress (gdbarch, psymtab->textlow),
1940 gdb_stdout);
1941 printf_filtered (" -- ");
1942 fputs_filtered (paddress (gdbarch, psymtab->texthigh),
1943 gdb_stdout);
1944 printf_filtered ("\n");
1945 printf_filtered (" psymtabs_addrmap_supported %s\n",
1946 (psymtab->psymtabs_addrmap_supported
1947 ? "yes" : "no"));
1948 printf_filtered (" globals ");
1949 if (psymtab->n_global_syms)
1950 {
1951 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1952 host_address_to_string (objfile->global_psymbols.list
1953 + psymtab->globals_offset),
1954 psymtab->n_global_syms);
1955 }
1956 else
1957 printf_filtered ("(none)\n");
1958 printf_filtered (" statics ");
1959 if (psymtab->n_static_syms)
1960 {
1961 printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n",
1962 host_address_to_string (objfile->static_psymbols.list
1963 + psymtab->statics_offset),
1964 psymtab->n_static_syms);
1965 }
1966 else
1967 printf_filtered ("(none)\n");
1968 printf_filtered (" dependencies ");
1969 if (psymtab->number_of_dependencies)
1970 {
1971 int i;
1972
1973 printf_filtered ("{\n");
1974 for (i = 0; i < psymtab->number_of_dependencies; i++)
1975 {
1976 struct partial_symtab *dep = psymtab->dependencies[i];
1977
1978 /* Note the string concatenation there --- no comma. */
1979 printf_filtered (" psymtab %s "
1980 "((struct partial_symtab *) %s)\n",
1981 dep->filename,
1982 host_address_to_string (dep));
1983 }
1984 printf_filtered (" }\n");
1985 }
1986 else
1987 printf_filtered ("(none)\n");
1988 printf_filtered (" }\n");
1989 }
1990 }
1991
1992 if (printed_objfile_start)
1993 printf_filtered ("}\n");
1994 }
1995 }
1996
1997 /* Check consistency of psymtabs and symtabs. */
1998
1999 static void
maintenance_check_symtabs(char * ignore,int from_tty)2000 maintenance_check_symtabs (char *ignore, int from_tty)
2001 {
2002 struct symbol *sym;
2003 struct partial_symbol **psym;
2004 struct symtab *s = NULL;
2005 struct partial_symtab *ps;
2006 struct blockvector *bv;
2007 struct objfile *objfile;
2008 struct block *b;
2009 int length;
2010
2011 ALL_PSYMTABS (objfile, ps)
2012 {
2013 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2014
2015 s = psymtab_to_symtab (objfile, ps);
2016 if (s == NULL)
2017 continue;
2018 bv = BLOCKVECTOR (s);
2019 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2020 psym = objfile->static_psymbols.list + ps->statics_offset;
2021 length = ps->n_static_syms;
2022 while (length--)
2023 {
2024 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2025 SYMBOL_DOMAIN (*psym));
2026 if (!sym)
2027 {
2028 printf_filtered ("Static symbol `");
2029 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2030 printf_filtered ("' only found in ");
2031 puts_filtered (ps->filename);
2032 printf_filtered (" psymtab\n");
2033 }
2034 psym++;
2035 }
2036 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2037 psym = objfile->global_psymbols.list + ps->globals_offset;
2038 length = ps->n_global_syms;
2039 while (length--)
2040 {
2041 sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
2042 SYMBOL_DOMAIN (*psym));
2043 if (!sym)
2044 {
2045 printf_filtered ("Global symbol `");
2046 puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
2047 printf_filtered ("' only found in ");
2048 puts_filtered (ps->filename);
2049 printf_filtered (" psymtab\n");
2050 }
2051 psym++;
2052 }
2053 if (ps->texthigh < ps->textlow)
2054 {
2055 printf_filtered ("Psymtab ");
2056 puts_filtered (ps->filename);
2057 printf_filtered (" covers bad range ");
2058 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2059 printf_filtered (" - ");
2060 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2061 printf_filtered ("\n");
2062 continue;
2063 }
2064 if (ps->texthigh == 0)
2065 continue;
2066 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
2067 {
2068 printf_filtered ("Psymtab ");
2069 puts_filtered (ps->filename);
2070 printf_filtered (" covers ");
2071 fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
2072 printf_filtered (" - ");
2073 fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
2074 printf_filtered (" but symtab covers only ");
2075 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
2076 printf_filtered (" - ");
2077 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
2078 printf_filtered ("\n");
2079 }
2080 }
2081 }
2082
2083
2084
2085 void
expand_partial_symbol_names(int (* fun)(const char *,void *),void * data)2086 expand_partial_symbol_names (int (*fun) (const char *, void *),
2087 void *data)
2088 {
2089 struct objfile *objfile;
2090
2091 ALL_OBJFILES (objfile)
2092 {
2093 if (objfile->sf)
2094 objfile->sf->qf->expand_symtabs_matching (objfile, NULL, fun,
2095 ALL_DOMAIN, data);
2096 }
2097 }
2098
2099 void
map_partial_symbol_filenames(symbol_filename_ftype * fun,void * data,int need_fullname)2100 map_partial_symbol_filenames (symbol_filename_ftype *fun, void *data,
2101 int need_fullname)
2102 {
2103 struct objfile *objfile;
2104
2105 ALL_OBJFILES (objfile)
2106 {
2107 if (objfile->sf)
2108 objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
2109 need_fullname);
2110 }
2111 }
2112
2113 extern initialize_file_ftype _initialize_psymtab;
2114
2115 void
_initialize_psymtab(void)2116 _initialize_psymtab (void)
2117 {
2118 add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
2119 Print dump of current partial symbol definitions.\n\
2120 Entries in the partial symbol table are dumped to file OUTFILE.\n\
2121 If a SOURCE file is specified, dump only that file's partial symbols."),
2122 &maintenanceprintlist);
2123
2124 add_cmd ("psymtabs", class_maintenance, maintenance_info_psymtabs, _("\
2125 List the partial symbol tables for all object files.\n\
2126 This does not include information about individual partial symbols,\n\
2127 just the symbol table structures themselves."),
2128 &maintenanceinfolist);
2129
2130 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
2131 _("Check consistency of psymtabs and symtabs."),
2132 &maintenancelist);
2133 }
2134