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
43struct 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
52static 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
58static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
59						     const char *, int,
60						     domain_enum);
61
62static char *psymtab_to_fullname (struct partial_symtab *ps);
63
64static struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
65						    CORE_ADDR,
66						    struct obj_section *);
67
68static struct partial_symbol *fixup_psymbol_section (struct partial_symbol
69						     *psym,
70						     struct objfile *objfile);
71
72static 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
77struct objfile *
78require_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
132static struct partial_symtab *
133lookup_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
185static int
186lookup_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
207static struct partial_symtab *
208find_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.  */
285static struct partial_symtab *
286find_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
352static struct symtab *
353find_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
377static struct partial_symbol *
378find_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
443static struct partial_symbol *
444fixup_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
474static struct symtab *
475lookup_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
518static struct partial_symbol *
519match_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
589static void
590pre_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
605static char *
606psymtab_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
633static struct partial_symbol *
634lookup_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
732static struct symtab *
733psymtab_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
751static void
752relocate_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
785static struct symtab *
786find_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
815static void
816forget_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
830static void
831print_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
920static void
921dump_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
990static void
991print_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
1005static void
1006dump_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
1034static void
1035read_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
1052static void
1053expand_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
1063static void
1064read_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
1075static void
1076map_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
1095int 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.  */
1106static char *
1107psymtab_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
1127static const char *
1128find_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
1145static int
1146map_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
1171static void
1172map_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
1205static void
1206expand_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
1273static int
1274objfile_has_psyms (struct objfile *objfile)
1275{
1276  return objfile->psymtabs != NULL;
1277}
1278
1279const 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
1301
1302/* This compares two partial symbols by names, using strcmp_iw_ordered
1303   for the comparison.  */
1304
1305static int
1306compare_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
1315void
1316sort_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
1330struct partial_symtab *
1331start_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
1353static unsigned long
1354psymbol_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
1375static int
1376psymbol_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
1391struct psymbol_bcache *
1392psymbol_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.  */
1400void
1401psymbol_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
1412struct bcache *
1413psymbol_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
1423static const struct partial_symbol *
1424psymbol_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
1440static const struct partial_symbol *
1441add_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
1483static void
1484extend_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
1511static void
1512append_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
1537const struct partial_symbol *
1538add_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
1566void
1567init_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
1603struct partial_symtab *
1604allocate_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
1634void
1635discard_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
1660
1661void
1662maintenance_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 (_("\
1677print-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).  */
1709void
1710maintenance_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
1812void
1813maintenance_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
1897
1898void
1899expand_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
1911void
1912map_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}
1924