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