Import gdb-7.10.1
[dragonfly.git] / contrib / gdb-7 / gdb / symtab.c
1 /* Symbol table lookup for the GNU debugger, GDB.
2
3    Copyright (C) 1986-2015 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 "gdbtypes.h"
23 #include "gdbcore.h"
24 #include "frame.h"
25 #include "target.h"
26 #include "value.h"
27 #include "symfile.h"
28 #include "objfiles.h"
29 #include "gdbcmd.h"
30 #include "gdb_regex.h"
31 #include "expression.h"
32 #include "language.h"
33 #include "demangle.h"
34 #include "inferior.h"
35 #include "source.h"
36 #include "filenames.h"          /* for FILENAME_CMP */
37 #include "objc-lang.h"
38 #include "d-lang.h"
39 #include "ada-lang.h"
40 #include "go-lang.h"
41 #include "p-lang.h"
42 #include "addrmap.h"
43 #include "cli/cli-utils.h"
44
45 #include "hashtab.h"
46
47 #include "gdb_obstack.h"
48 #include "block.h"
49 #include "dictionary.h"
50
51 #include <sys/types.h>
52 #include <fcntl.h>
53 #include <sys/stat.h>
54 #include <ctype.h>
55 #include "cp-abi.h"
56 #include "cp-support.h"
57 #include "observer.h"
58 #include "solist.h"
59 #include "macrotab.h"
60 #include "macroscope.h"
61
62 #include "parser-defs.h"
63 #include "completer.h"
64
65 /* Forward declarations for local functions.  */
66
67 static void rbreak_command (char *, int);
68
69 static int find_line_common (struct linetable *, int, int *, int);
70
71 static struct symbol *lookup_symbol_aux (const char *name,
72                                          const struct block *block,
73                                          const domain_enum domain,
74                                          enum language language,
75                                          struct field_of_this_result *);
76
77 static
78 struct symbol *lookup_local_symbol (const char *name,
79                                     const struct block *block,
80                                     const domain_enum domain,
81                                     enum language language);
82
83 static struct symbol *
84   lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
85                             const char *name, const domain_enum domain);
86
87 extern initialize_file_ftype _initialize_symtab;
88
89 /* Program space key for finding name and language of "main".  */
90
91 static const struct program_space_data *main_progspace_key;
92
93 /* Type of the data stored on the program space.  */
94
95 struct main_info
96 {
97   /* Name of "main".  */
98
99   char *name_of_main;
100
101   /* Language of "main".  */
102
103   enum language language_of_main;
104 };
105
106 /* Program space key for finding its symbol cache.  */
107
108 static const struct program_space_data *symbol_cache_key;
109
110 /* The default symbol cache size.
111    There is no extra cpu cost for large N (except when flushing the cache,
112    which is rare).  The value here is just a first attempt.  A better default
113    value may be higher or lower.  A prime number can make up for a bad hash
114    computation, so that's why the number is what it is.  */
115 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
116
117 /* The maximum symbol cache size.
118    There's no method to the decision of what value to use here, other than
119    there's no point in allowing a user typo to make gdb consume all memory.  */
120 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
121
122 /* symbol_cache_lookup returns this if a previous lookup failed to find the
123    symbol in any objfile.  */
124 #define SYMBOL_LOOKUP_FAILED ((struct symbol *) 1)
125
126 /* Recording lookups that don't find the symbol is just as important, if not
127    more so, than recording found symbols.  */
128
129 enum symbol_cache_slot_state
130 {
131   SYMBOL_SLOT_UNUSED,
132   SYMBOL_SLOT_NOT_FOUND,
133   SYMBOL_SLOT_FOUND
134 };
135
136 struct symbol_cache_slot
137 {
138   enum symbol_cache_slot_state state;
139
140   /* The objfile that was current when the symbol was looked up.
141      This is only needed for global blocks, but for simplicity's sake
142      we allocate the space for both.  If data shows the extra space used
143      for static blocks is a problem, we can split things up then.
144
145      Global blocks need cache lookup to include the objfile context because
146      we need to account for gdbarch_iterate_over_objfiles_in_search_order
147      which can traverse objfiles in, effectively, any order, depending on
148      the current objfile, thus affecting which symbol is found.  Normally,
149      only the current objfile is searched first, and then the rest are
150      searched in recorded order; but putting cache lookup inside
151      gdbarch_iterate_over_objfiles_in_search_order would be awkward.
152      Instead we just make the current objfile part of the context of
153      cache lookup.  This means we can record the same symbol multiple times,
154      each with a different "current objfile" that was in effect when the
155      lookup was saved in the cache, but cache space is pretty cheap.  */
156   const struct objfile *objfile_context;
157
158   union
159   {
160     struct symbol *found;
161     struct
162     {
163       char *name;
164       domain_enum domain;
165     } not_found;
166   } value;
167 };
168
169 /* Symbols don't specify global vs static block.
170    So keep them in separate caches.  */
171
172 struct block_symbol_cache
173 {
174   unsigned int hits;
175   unsigned int misses;
176   unsigned int collisions;
177
178   /* SYMBOLS is a variable length array of this size.
179      One can imagine that in general one cache (global/static) should be a
180      fraction of the size of the other, but there's no data at the moment
181      on which to decide.  */
182   unsigned int size;
183
184   struct symbol_cache_slot symbols[1];
185 };
186
187 /* The symbol cache.
188
189    Searching for symbols in the static and global blocks over multiple objfiles
190    again and again can be slow, as can searching very big objfiles.  This is a
191    simple cache to improve symbol lookup performance, which is critical to
192    overall gdb performance.
193
194    Symbols are hashed on the name, its domain, and block.
195    They are also hashed on their objfile for objfile-specific lookups.  */
196
197 struct symbol_cache
198 {
199   struct block_symbol_cache *global_symbols;
200   struct block_symbol_cache *static_symbols;
201 };
202
203 /* When non-zero, print debugging messages related to symtab creation.  */
204 unsigned int symtab_create_debug = 0;
205
206 /* When non-zero, print debugging messages related to symbol lookup.  */
207 unsigned int symbol_lookup_debug = 0;
208
209 /* The size of the cache is staged here.  */
210 static unsigned int new_symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
211
212 /* The current value of the symbol cache size.
213    This is saved so that if the user enters a value too big we can restore
214    the original value from here.  */
215 static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
216
217 /* Non-zero if a file may be known by two different basenames.
218    This is the uncommon case, and significantly slows down gdb.
219    Default set to "off" to not slow down the common case.  */
220 int basenames_may_differ = 0;
221
222 /* Allow the user to configure the debugger behavior with respect
223    to multiple-choice menus when more than one symbol matches during
224    a symbol lookup.  */
225
226 const char multiple_symbols_ask[] = "ask";
227 const char multiple_symbols_all[] = "all";
228 const char multiple_symbols_cancel[] = "cancel";
229 static const char *const multiple_symbols_modes[] =
230 {
231   multiple_symbols_ask,
232   multiple_symbols_all,
233   multiple_symbols_cancel,
234   NULL
235 };
236 static const char *multiple_symbols_mode = multiple_symbols_all;
237
238 /* Read-only accessor to AUTO_SELECT_MODE.  */
239
240 const char *
241 multiple_symbols_select_mode (void)
242 {
243   return multiple_symbols_mode;
244 }
245
246 /* Block in which the most recently searched-for symbol was found.
247    Might be better to make this a parameter to lookup_symbol and
248    value_of_this.  */
249
250 const struct block *block_found;
251
252 /* Return the name of a domain_enum.  */
253
254 const char *
255 domain_name (domain_enum e)
256 {
257   switch (e)
258     {
259     case UNDEF_DOMAIN: return "UNDEF_DOMAIN";
260     case VAR_DOMAIN: return "VAR_DOMAIN";
261     case STRUCT_DOMAIN: return "STRUCT_DOMAIN";
262     case MODULE_DOMAIN: return "MODULE_DOMAIN";
263     case LABEL_DOMAIN: return "LABEL_DOMAIN";
264     case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN";
265     default: gdb_assert_not_reached ("bad domain_enum");
266     }
267 }
268
269 /* Return the name of a search_domain .  */
270
271 const char *
272 search_domain_name (enum search_domain e)
273 {
274   switch (e)
275     {
276     case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN";
277     case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN";
278     case TYPES_DOMAIN: return "TYPES_DOMAIN";
279     case ALL_DOMAIN: return "ALL_DOMAIN";
280     default: gdb_assert_not_reached ("bad search_domain");
281     }
282 }
283
284 /* See symtab.h.  */
285
286 struct symtab *
287 compunit_primary_filetab (const struct compunit_symtab *cust)
288 {
289   gdb_assert (COMPUNIT_FILETABS (cust) != NULL);
290
291   /* The primary file symtab is the first one in the list.  */
292   return COMPUNIT_FILETABS (cust);
293 }
294
295 /* See symtab.h.  */
296
297 enum language
298 compunit_language (const struct compunit_symtab *cust)
299 {
300   struct symtab *symtab = compunit_primary_filetab (cust);
301
302 /* The language of the compunit symtab is the language of its primary
303    source file.  */
304   return SYMTAB_LANGUAGE (symtab);
305 }
306
307 /* See whether FILENAME matches SEARCH_NAME using the rule that we
308    advertise to the user.  (The manual's description of linespecs
309    describes what we advertise).  Returns true if they match, false
310    otherwise.  */
311
312 int
313 compare_filenames_for_search (const char *filename, const char *search_name)
314 {
315   int len = strlen (filename);
316   size_t search_len = strlen (search_name);
317
318   if (len < search_len)
319     return 0;
320
321   /* The tail of FILENAME must match.  */
322   if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
323     return 0;
324
325   /* Either the names must completely match, or the character
326      preceding the trailing SEARCH_NAME segment of FILENAME must be a
327      directory separator.
328
329      The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
330      cannot match FILENAME "/path//dir/file.c" - as user has requested
331      absolute path.  The sama applies for "c:\file.c" possibly
332      incorrectly hypothetically matching "d:\dir\c:\file.c".
333
334      The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
335      compatible with SEARCH_NAME "file.c".  In such case a compiler had
336      to put the "c:file.c" name into debug info.  Such compatibility
337      works only on GDB built for DOS host.  */
338   return (len == search_len
339           || (!IS_ABSOLUTE_PATH (search_name)
340               && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
341           || (HAS_DRIVE_SPEC (filename)
342               && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
343 }
344
345 /* Check for a symtab of a specific name by searching some symtabs.
346    This is a helper function for callbacks of iterate_over_symtabs.
347
348    If NAME is not absolute, then REAL_PATH is NULL
349    If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
350
351    The return value, NAME, REAL_PATH, CALLBACK, and DATA
352    are identical to the `map_symtabs_matching_filename' method of
353    quick_symbol_functions.
354
355    FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
356    Each symtab within the specified compunit symtab is also searched.
357    AFTER_LAST is one past the last compunit symtab to search; NULL means to
358    search until the end of the list.  */
359
360 int
361 iterate_over_some_symtabs (const char *name,
362                            const char *real_path,
363                            int (*callback) (struct symtab *symtab,
364                                             void *data),
365                            void *data,
366                            struct compunit_symtab *first,
367                            struct compunit_symtab *after_last)
368 {
369   struct compunit_symtab *cust;
370   struct symtab *s;
371   const char* base_name = lbasename (name);
372
373   for (cust = first; cust != NULL && cust != after_last; cust = cust->next)
374     {
375       ALL_COMPUNIT_FILETABS (cust, s)
376         {
377           if (compare_filenames_for_search (s->filename, name))
378             {
379               if (callback (s, data))
380                 return 1;
381               continue;
382             }
383
384           /* Before we invoke realpath, which can get expensive when many
385              files are involved, do a quick comparison of the basenames.  */
386           if (! basenames_may_differ
387               && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
388             continue;
389
390           if (compare_filenames_for_search (symtab_to_fullname (s), name))
391             {
392               if (callback (s, data))
393                 return 1;
394               continue;
395             }
396
397           /* If the user gave us an absolute path, try to find the file in
398              this symtab and use its absolute path.  */
399           if (real_path != NULL)
400             {
401               const char *fullname = symtab_to_fullname (s);
402
403               gdb_assert (IS_ABSOLUTE_PATH (real_path));
404               gdb_assert (IS_ABSOLUTE_PATH (name));
405               if (FILENAME_CMP (real_path, fullname) == 0)
406                 {
407                   if (callback (s, data))
408                     return 1;
409                   continue;
410                 }
411             }
412         }
413     }
414
415   return 0;
416 }
417
418 /* Check for a symtab of a specific name; first in symtabs, then in
419    psymtabs.  *If* there is no '/' in the name, a match after a '/'
420    in the symtab filename will also work.
421
422    Calls CALLBACK with each symtab that is found and with the supplied
423    DATA.  If CALLBACK returns true, the search stops.  */
424
425 void
426 iterate_over_symtabs (const char *name,
427                       int (*callback) (struct symtab *symtab,
428                                        void *data),
429                       void *data)
430 {
431   struct objfile *objfile;
432   char *real_path = NULL;
433   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
434
435   /* Here we are interested in canonicalizing an absolute path, not
436      absolutizing a relative path.  */
437   if (IS_ABSOLUTE_PATH (name))
438     {
439       real_path = gdb_realpath (name);
440       make_cleanup (xfree, real_path);
441       gdb_assert (IS_ABSOLUTE_PATH (real_path));
442     }
443
444   ALL_OBJFILES (objfile)
445   {
446     if (iterate_over_some_symtabs (name, real_path, callback, data,
447                                    objfile->compunit_symtabs, NULL))
448       {
449         do_cleanups (cleanups);
450         return;
451       }
452   }
453
454   /* Same search rules as above apply here, but now we look thru the
455      psymtabs.  */
456
457   ALL_OBJFILES (objfile)
458   {
459     if (objfile->sf
460         && objfile->sf->qf->map_symtabs_matching_filename (objfile,
461                                                            name,
462                                                            real_path,
463                                                            callback,
464                                                            data))
465       {
466         do_cleanups (cleanups);
467         return;
468       }
469   }
470
471   do_cleanups (cleanups);
472 }
473
474 /* The callback function used by lookup_symtab.  */
475
476 static int
477 lookup_symtab_callback (struct symtab *symtab, void *data)
478 {
479   struct symtab **result_ptr = data;
480
481   *result_ptr = symtab;
482   return 1;
483 }
484
485 /* A wrapper for iterate_over_symtabs that returns the first matching
486    symtab, or NULL.  */
487
488 struct symtab *
489 lookup_symtab (const char *name)
490 {
491   struct symtab *result = NULL;
492
493   iterate_over_symtabs (name, lookup_symtab_callback, &result);
494   return result;
495 }
496
497 \f
498 /* Mangle a GDB method stub type.  This actually reassembles the pieces of the
499    full method name, which consist of the class name (from T), the unadorned
500    method name from METHOD_ID, and the signature for the specific overload,
501    specified by SIGNATURE_ID.  Note that this function is g++ specific.  */
502
503 char *
504 gdb_mangle_name (struct type *type, int method_id, int signature_id)
505 {
506   int mangled_name_len;
507   char *mangled_name;
508   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
509   struct fn_field *method = &f[signature_id];
510   const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
511   const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
512   const char *newname = type_name_no_tag (type);
513
514   /* Does the form of physname indicate that it is the full mangled name
515      of a constructor (not just the args)?  */
516   int is_full_physname_constructor;
517
518   int is_constructor;
519   int is_destructor = is_destructor_name (physname);
520   /* Need a new type prefix.  */
521   char *const_prefix = method->is_const ? "C" : "";
522   char *volatile_prefix = method->is_volatile ? "V" : "";
523   char buf[20];
524   int len = (newname == NULL ? 0 : strlen (newname));
525
526   /* Nothing to do if physname already contains a fully mangled v3 abi name
527      or an operator name.  */
528   if ((physname[0] == '_' && physname[1] == 'Z')
529       || is_operator_name (field_name))
530     return xstrdup (physname);
531
532   is_full_physname_constructor = is_constructor_name (physname);
533
534   is_constructor = is_full_physname_constructor 
535     || (newname && strcmp (field_name, newname) == 0);
536
537   if (!is_destructor)
538     is_destructor = (startswith (physname, "__dt"));
539
540   if (is_destructor || is_full_physname_constructor)
541     {
542       mangled_name = (char *) xmalloc (strlen (physname) + 1);
543       strcpy (mangled_name, physname);
544       return mangled_name;
545     }
546
547   if (len == 0)
548     {
549       xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
550     }
551   else if (physname[0] == 't' || physname[0] == 'Q')
552     {
553       /* The physname for template and qualified methods already includes
554          the class name.  */
555       xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
556       newname = NULL;
557       len = 0;
558     }
559   else
560     {
561       xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
562                  volatile_prefix, len);
563     }
564   mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
565                       + strlen (buf) + len + strlen (physname) + 1);
566
567   mangled_name = (char *) xmalloc (mangled_name_len);
568   if (is_constructor)
569     mangled_name[0] = '\0';
570   else
571     strcpy (mangled_name, field_name);
572
573   strcat (mangled_name, buf);
574   /* If the class doesn't have a name, i.e. newname NULL, then we just
575      mangle it using 0 for the length of the class.  Thus it gets mangled
576      as something starting with `::' rather than `classname::'.  */
577   if (newname != NULL)
578     strcat (mangled_name, newname);
579
580   strcat (mangled_name, physname);
581   return (mangled_name);
582 }
583
584 /* Set the demangled name of GSYMBOL to NAME.  NAME must be already
585    correctly allocated.  */
586
587 void
588 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
589                            const char *name,
590                            struct obstack *obstack)
591 {
592   if (gsymbol->language == language_ada)
593     {
594       if (name == NULL)
595         {
596           gsymbol->ada_mangled = 0;
597           gsymbol->language_specific.obstack = obstack;
598         }
599       else
600         {
601           gsymbol->ada_mangled = 1;
602           gsymbol->language_specific.mangled_lang.demangled_name = name;
603         }
604     }
605   else
606     gsymbol->language_specific.mangled_lang.demangled_name = name;
607 }
608
609 /* Return the demangled name of GSYMBOL.  */
610
611 const char *
612 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
613 {
614   if (gsymbol->language == language_ada)
615     {
616       if (!gsymbol->ada_mangled)
617         return NULL;
618       /* Fall through.  */
619     }
620
621   return gsymbol->language_specific.mangled_lang.demangled_name;
622 }
623
624 \f
625 /* Initialize the language dependent portion of a symbol
626    depending upon the language for the symbol.  */
627
628 void
629 symbol_set_language (struct general_symbol_info *gsymbol,
630                      enum language language,
631                      struct obstack *obstack)
632 {
633   gsymbol->language = language;
634   if (gsymbol->language == language_cplus
635       || gsymbol->language == language_d
636       || gsymbol->language == language_go
637       || gsymbol->language == language_java
638       || gsymbol->language == language_objc
639       || gsymbol->language == language_fortran)
640     {
641       symbol_set_demangled_name (gsymbol, NULL, obstack);
642     }
643   else if (gsymbol->language == language_ada)
644     {
645       gdb_assert (gsymbol->ada_mangled == 0);
646       gsymbol->language_specific.obstack = obstack;
647     }
648   else
649     {
650       memset (&gsymbol->language_specific, 0,
651               sizeof (gsymbol->language_specific));
652     }
653 }
654
655 /* Functions to initialize a symbol's mangled name.  */
656
657 /* Objects of this type are stored in the demangled name hash table.  */
658 struct demangled_name_entry
659 {
660   const char *mangled;
661   char demangled[1];
662 };
663
664 /* Hash function for the demangled name hash.  */
665
666 static hashval_t
667 hash_demangled_name_entry (const void *data)
668 {
669   const struct demangled_name_entry *e = data;
670
671   return htab_hash_string (e->mangled);
672 }
673
674 /* Equality function for the demangled name hash.  */
675
676 static int
677 eq_demangled_name_entry (const void *a, const void *b)
678 {
679   const struct demangled_name_entry *da = a;
680   const struct demangled_name_entry *db = b;
681
682   return strcmp (da->mangled, db->mangled) == 0;
683 }
684
685 /* Create the hash table used for demangled names.  Each hash entry is
686    a pair of strings; one for the mangled name and one for the demangled
687    name.  The entry is hashed via just the mangled name.  */
688
689 static void
690 create_demangled_names_hash (struct objfile *objfile)
691 {
692   /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
693      The hash table code will round this up to the next prime number.
694      Choosing a much larger table size wastes memory, and saves only about
695      1% in symbol reading.  */
696
697   objfile->per_bfd->demangled_names_hash = htab_create_alloc
698     (256, hash_demangled_name_entry, eq_demangled_name_entry,
699      NULL, xcalloc, xfree);
700 }
701
702 /* Try to determine the demangled name for a symbol, based on the
703    language of that symbol.  If the language is set to language_auto,
704    it will attempt to find any demangling algorithm that works and
705    then set the language appropriately.  The returned name is allocated
706    by the demangler and should be xfree'd.  */
707
708 static char *
709 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
710                             const char *mangled)
711 {
712   char *demangled = NULL;
713
714   if (gsymbol->language == language_unknown)
715     gsymbol->language = language_auto;
716
717   if (gsymbol->language == language_objc
718       || gsymbol->language == language_auto)
719     {
720       demangled =
721         objc_demangle (mangled, 0);
722       if (demangled != NULL)
723         {
724           gsymbol->language = language_objc;
725           return demangled;
726         }
727     }
728   if (gsymbol->language == language_cplus
729       || gsymbol->language == language_auto)
730     {
731       demangled =
732         gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
733       if (demangled != NULL)
734         {
735           gsymbol->language = language_cplus;
736           return demangled;
737         }
738     }
739   if (gsymbol->language == language_java)
740     {
741       demangled =
742         gdb_demangle (mangled,
743                       DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
744       if (demangled != NULL)
745         {
746           gsymbol->language = language_java;
747           return demangled;
748         }
749     }
750   if (gsymbol->language == language_d
751       || gsymbol->language == language_auto)
752     {
753       demangled = d_demangle(mangled, 0);
754       if (demangled != NULL)
755         {
756           gsymbol->language = language_d;
757           return demangled;
758         }
759     }
760   /* FIXME(dje): Continually adding languages here is clumsy.
761      Better to just call la_demangle if !auto, and if auto then call
762      a utility routine that tries successive languages in turn and reports
763      which one it finds.  I realize the la_demangle options may be different
764      for different languages but there's already a FIXME for that.  */
765   if (gsymbol->language == language_go
766       || gsymbol->language == language_auto)
767     {
768       demangled = go_demangle (mangled, 0);
769       if (demangled != NULL)
770         {
771           gsymbol->language = language_go;
772           return demangled;
773         }
774     }
775
776   /* We could support `gsymbol->language == language_fortran' here to provide
777      module namespaces also for inferiors with only minimal symbol table (ELF
778      symbols).  Just the mangling standard is not standardized across compilers
779      and there is no DW_AT_producer available for inferiors with only the ELF
780      symbols to check the mangling kind.  */
781
782   /* Check for Ada symbols last.  See comment below explaining why.  */
783
784   if (gsymbol->language == language_auto)
785    {
786      const char *demangled = ada_decode (mangled);
787
788      if (demangled != mangled && demangled != NULL && demangled[0] != '<')
789        {
790          /* Set the gsymbol language to Ada, but still return NULL.
791             Two reasons for that:
792
793               1. For Ada, we prefer computing the symbol's decoded name
794                  on the fly rather than pre-compute it, in order to save
795                  memory (Ada projects are typically very large).
796
797               2. There are some areas in the definition of the GNAT
798                  encoding where, with a bit of bad luck, we might be able
799                  to decode a non-Ada symbol, generating an incorrect
800                  demangled name (Eg: names ending with "TB" for instance
801                  are identified as task bodies and so stripped from
802                  the decoded name returned).
803
804                  Returning NULL, here, helps us get a little bit of
805                  the best of both worlds.  Because we're last, we should
806                  not affect any of the other languages that were able to
807                  demangle the symbol before us; we get to correctly tag
808                  Ada symbols as such; and even if we incorrectly tagged
809                  a non-Ada symbol, which should be rare, any routing
810                  through the Ada language should be transparent (Ada
811                  tries to behave much like C/C++ with non-Ada symbols).  */
812          gsymbol->language = language_ada;
813          return NULL;
814        }
815    }
816
817   return NULL;
818 }
819
820 /* Set both the mangled and demangled (if any) names for GSYMBOL based
821    on LINKAGE_NAME and LEN.  Ordinarily, NAME is copied onto the
822    objfile's obstack; but if COPY_NAME is 0 and if NAME is
823    NUL-terminated, then this function assumes that NAME is already
824    correctly saved (either permanently or with a lifetime tied to the
825    objfile), and it will not be copied.
826
827    The hash table corresponding to OBJFILE is used, and the memory
828    comes from the per-BFD storage_obstack.  LINKAGE_NAME is copied,
829    so the pointer can be discarded after calling this function.  */
830
831 /* We have to be careful when dealing with Java names: when we run
832    into a Java minimal symbol, we don't know it's a Java symbol, so it
833    gets demangled as a C++ name.  This is unfortunate, but there's not
834    much we can do about it: but when demangling partial symbols and
835    regular symbols, we'd better not reuse the wrong demangled name.
836    (See PR gdb/1039.)  We solve this by putting a distinctive prefix
837    on Java names when storing them in the hash table.  */
838
839 /* FIXME: carlton/2003-03-13: This is an unfortunate situation.  I
840    don't mind the Java prefix so much: different languages have
841    different demangling requirements, so it's only natural that we
842    need to keep language data around in our demangling cache.  But
843    it's not good that the minimal symbol has the wrong demangled name.
844    Unfortunately, I can't think of any easy solution to that
845    problem.  */
846
847 #define JAVA_PREFIX "##JAVA$$"
848 #define JAVA_PREFIX_LEN 8
849
850 void
851 symbol_set_names (struct general_symbol_info *gsymbol,
852                   const char *linkage_name, int len, int copy_name,
853                   struct objfile *objfile)
854 {
855   struct demangled_name_entry **slot;
856   /* A 0-terminated copy of the linkage name.  */
857   const char *linkage_name_copy;
858   /* A copy of the linkage name that might have a special Java prefix
859      added to it, for use when looking names up in the hash table.  */
860   const char *lookup_name;
861   /* The length of lookup_name.  */
862   int lookup_len;
863   struct demangled_name_entry entry;
864   struct objfile_per_bfd_storage *per_bfd = objfile->per_bfd;
865
866   if (gsymbol->language == language_ada)
867     {
868       /* In Ada, we do the symbol lookups using the mangled name, so
869          we can save some space by not storing the demangled name.
870
871          As a side note, we have also observed some overlap between
872          the C++ mangling and Ada mangling, similarly to what has
873          been observed with Java.  Because we don't store the demangled
874          name with the symbol, we don't need to use the same trick
875          as Java.  */
876       if (!copy_name)
877         gsymbol->name = linkage_name;
878       else
879         {
880           char *name = obstack_alloc (&per_bfd->storage_obstack, len + 1);
881
882           memcpy (name, linkage_name, len);
883           name[len] = '\0';
884           gsymbol->name = name;
885         }
886       symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
887
888       return;
889     }
890
891   if (per_bfd->demangled_names_hash == NULL)
892     create_demangled_names_hash (objfile);
893
894   /* The stabs reader generally provides names that are not
895      NUL-terminated; most of the other readers don't do this, so we
896      can just use the given copy, unless we're in the Java case.  */
897   if (gsymbol->language == language_java)
898     {
899       char *alloc_name;
900
901       lookup_len = len + JAVA_PREFIX_LEN;
902       alloc_name = alloca (lookup_len + 1);
903       memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
904       memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
905       alloc_name[lookup_len] = '\0';
906
907       lookup_name = alloc_name;
908       linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
909     }
910   else if (linkage_name[len] != '\0')
911     {
912       char *alloc_name;
913
914       lookup_len = len;
915       alloc_name = alloca (lookup_len + 1);
916       memcpy (alloc_name, linkage_name, len);
917       alloc_name[lookup_len] = '\0';
918
919       lookup_name = alloc_name;
920       linkage_name_copy = alloc_name;
921     }
922   else
923     {
924       lookup_len = len;
925       lookup_name = linkage_name;
926       linkage_name_copy = linkage_name;
927     }
928
929   entry.mangled = lookup_name;
930   slot = ((struct demangled_name_entry **)
931           htab_find_slot (per_bfd->demangled_names_hash,
932                           &entry, INSERT));
933
934   /* If this name is not in the hash table, add it.  */
935   if (*slot == NULL
936       /* A C version of the symbol may have already snuck into the table.
937          This happens to, e.g., main.init (__go_init_main).  Cope.  */
938       || (gsymbol->language == language_go
939           && (*slot)->demangled[0] == '\0'))
940     {
941       char *demangled_name = symbol_find_demangled_name (gsymbol,
942                                                          linkage_name_copy);
943       int demangled_len = demangled_name ? strlen (demangled_name) : 0;
944
945       /* Suppose we have demangled_name==NULL, copy_name==0, and
946          lookup_name==linkage_name.  In this case, we already have the
947          mangled name saved, and we don't have a demangled name.  So,
948          you might think we could save a little space by not recording
949          this in the hash table at all.
950          
951          It turns out that it is actually important to still save such
952          an entry in the hash table, because storing this name gives
953          us better bcache hit rates for partial symbols.  */
954       if (!copy_name && lookup_name == linkage_name)
955         {
956           *slot = obstack_alloc (&per_bfd->storage_obstack,
957                                  offsetof (struct demangled_name_entry,
958                                            demangled)
959                                  + demangled_len + 1);
960           (*slot)->mangled = lookup_name;
961         }
962       else
963         {
964           char *mangled_ptr;
965
966           /* If we must copy the mangled name, put it directly after
967              the demangled name so we can have a single
968              allocation.  */
969           *slot = obstack_alloc (&per_bfd->storage_obstack,
970                                  offsetof (struct demangled_name_entry,
971                                            demangled)
972                                  + lookup_len + demangled_len + 2);
973           mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
974           strcpy (mangled_ptr, lookup_name);
975           (*slot)->mangled = mangled_ptr;
976         }
977
978       if (demangled_name != NULL)
979         {
980           strcpy ((*slot)->demangled, demangled_name);
981           xfree (demangled_name);
982         }
983       else
984         (*slot)->demangled[0] = '\0';
985     }
986
987   gsymbol->name = (*slot)->mangled + lookup_len - len;
988   if ((*slot)->demangled[0] != '\0')
989     symbol_set_demangled_name (gsymbol, (*slot)->demangled,
990                                &per_bfd->storage_obstack);
991   else
992     symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
993 }
994
995 /* Return the source code name of a symbol.  In languages where
996    demangling is necessary, this is the demangled name.  */
997
998 const char *
999 symbol_natural_name (const struct general_symbol_info *gsymbol)
1000 {
1001   switch (gsymbol->language)
1002     {
1003     case language_cplus:
1004     case language_d:
1005     case language_go:
1006     case language_java:
1007     case language_objc:
1008     case language_fortran:
1009       if (symbol_get_demangled_name (gsymbol) != NULL)
1010         return symbol_get_demangled_name (gsymbol);
1011       break;
1012     case language_ada:
1013       return ada_decode_symbol (gsymbol);
1014     default:
1015       break;
1016     }
1017   return gsymbol->name;
1018 }
1019
1020 /* Return the demangled name for a symbol based on the language for
1021    that symbol.  If no demangled name exists, return NULL.  */
1022
1023 const char *
1024 symbol_demangled_name (const struct general_symbol_info *gsymbol)
1025 {
1026   const char *dem_name = NULL;
1027
1028   switch (gsymbol->language)
1029     {
1030     case language_cplus:
1031     case language_d:
1032     case language_go:
1033     case language_java:
1034     case language_objc:
1035     case language_fortran:
1036       dem_name = symbol_get_demangled_name (gsymbol);
1037       break;
1038     case language_ada:
1039       dem_name = ada_decode_symbol (gsymbol);
1040       break;
1041     default:
1042       break;
1043     }
1044   return dem_name;
1045 }
1046
1047 /* Return the search name of a symbol---generally the demangled or
1048    linkage name of the symbol, depending on how it will be searched for.
1049    If there is no distinct demangled name, then returns the same value
1050    (same pointer) as SYMBOL_LINKAGE_NAME.  */
1051
1052 const char *
1053 symbol_search_name (const struct general_symbol_info *gsymbol)
1054 {
1055   if (gsymbol->language == language_ada)
1056     return gsymbol->name;
1057   else
1058     return symbol_natural_name (gsymbol);
1059 }
1060
1061 /* Initialize the structure fields to zero values.  */
1062
1063 void
1064 init_sal (struct symtab_and_line *sal)
1065 {
1066   memset (sal, 0, sizeof (*sal));
1067 }
1068 \f
1069
1070 /* Return 1 if the two sections are the same, or if they could
1071    plausibly be copies of each other, one in an original object
1072    file and another in a separated debug file.  */
1073
1074 int
1075 matching_obj_sections (struct obj_section *obj_first,
1076                        struct obj_section *obj_second)
1077 {
1078   asection *first = obj_first? obj_first->the_bfd_section : NULL;
1079   asection *second = obj_second? obj_second->the_bfd_section : NULL;
1080   struct objfile *obj;
1081
1082   /* If they're the same section, then they match.  */
1083   if (first == second)
1084     return 1;
1085
1086   /* If either is NULL, give up.  */
1087   if (first == NULL || second == NULL)
1088     return 0;
1089
1090   /* This doesn't apply to absolute symbols.  */
1091   if (first->owner == NULL || second->owner == NULL)
1092     return 0;
1093
1094   /* If they're in the same object file, they must be different sections.  */
1095   if (first->owner == second->owner)
1096     return 0;
1097
1098   /* Check whether the two sections are potentially corresponding.  They must
1099      have the same size, address, and name.  We can't compare section indexes,
1100      which would be more reliable, because some sections may have been
1101      stripped.  */
1102   if (bfd_get_section_size (first) != bfd_get_section_size (second))
1103     return 0;
1104
1105   /* In-memory addresses may start at a different offset, relativize them.  */
1106   if (bfd_get_section_vma (first->owner, first)
1107       - bfd_get_start_address (first->owner)
1108       != bfd_get_section_vma (second->owner, second)
1109          - bfd_get_start_address (second->owner))
1110     return 0;
1111
1112   if (bfd_get_section_name (first->owner, first) == NULL
1113       || bfd_get_section_name (second->owner, second) == NULL
1114       || strcmp (bfd_get_section_name (first->owner, first),
1115                  bfd_get_section_name (second->owner, second)) != 0)
1116     return 0;
1117
1118   /* Otherwise check that they are in corresponding objfiles.  */
1119
1120   ALL_OBJFILES (obj)
1121     if (obj->obfd == first->owner)
1122       break;
1123   gdb_assert (obj != NULL);
1124
1125   if (obj->separate_debug_objfile != NULL
1126       && obj->separate_debug_objfile->obfd == second->owner)
1127     return 1;
1128   if (obj->separate_debug_objfile_backlink != NULL
1129       && obj->separate_debug_objfile_backlink->obfd == second->owner)
1130     return 1;
1131
1132   return 0;
1133 }
1134
1135 /* See symtab.h.  */
1136
1137 void
1138 expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
1139 {
1140   struct objfile *objfile;
1141   struct bound_minimal_symbol msymbol;
1142
1143   /* If we know that this is not a text address, return failure.  This is
1144      necessary because we loop based on texthigh and textlow, which do
1145      not include the data ranges.  */
1146   msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1147   if (msymbol.minsym
1148       && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
1149           || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
1150           || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
1151           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
1152           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
1153     return;
1154
1155   ALL_OBJFILES (objfile)
1156   {
1157     struct compunit_symtab *cust = NULL;
1158
1159     if (objfile->sf)
1160       cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
1161                                                             pc, section, 0);
1162     if (cust)
1163       return;
1164   }
1165 }
1166 \f
1167 /* Hash function for the symbol cache.  */
1168
1169 static unsigned int
1170 hash_symbol_entry (const struct objfile *objfile_context,
1171                    const char *name, domain_enum domain)
1172 {
1173   unsigned int hash = (uintptr_t) objfile_context;
1174
1175   if (name != NULL)
1176     hash += htab_hash_string (name);
1177
1178   /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1179      to map to the same slot.  */
1180   if (domain == STRUCT_DOMAIN)
1181     hash += VAR_DOMAIN * 7;
1182   else
1183     hash += domain * 7;
1184
1185   return hash;
1186 }
1187
1188 /* Equality function for the symbol cache.  */
1189
1190 static int
1191 eq_symbol_entry (const struct symbol_cache_slot *slot,
1192                  const struct objfile *objfile_context,
1193                  const char *name, domain_enum domain)
1194 {
1195   const char *slot_name;
1196   domain_enum slot_domain;
1197
1198   if (slot->state == SYMBOL_SLOT_UNUSED)
1199     return 0;
1200
1201   if (slot->objfile_context != objfile_context)
1202     return 0;
1203
1204   if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1205     {
1206       slot_name = slot->value.not_found.name;
1207       slot_domain = slot->value.not_found.domain;
1208     }
1209   else
1210     {
1211       slot_name = SYMBOL_SEARCH_NAME (slot->value.found);
1212       slot_domain = SYMBOL_DOMAIN (slot->value.found);
1213     }
1214
1215   /* NULL names match.  */
1216   if (slot_name == NULL && name == NULL)
1217     {
1218       /* But there's no point in calling symbol_matches_domain in the
1219          SYMBOL_SLOT_FOUND case.  */
1220       if (slot_domain != domain)
1221         return 0;
1222     }
1223   else if (slot_name != NULL && name != NULL)
1224     {
1225       /* It's important that we use the same comparison that was done the
1226          first time through.  If the slot records a found symbol, then this
1227          means using strcmp_iw on SYMBOL_SEARCH_NAME.  See dictionary.c.
1228          It also means using symbol_matches_domain for found symbols.
1229          See block.c.
1230
1231          If the slot records a not-found symbol, then require a precise match.
1232          We could still be lax with whitespace like strcmp_iw though.  */
1233
1234       if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1235         {
1236           if (strcmp (slot_name, name) != 0)
1237             return 0;
1238           if (slot_domain != domain)
1239             return 0;
1240         }
1241       else
1242         {
1243           struct symbol *sym = slot->value.found;
1244
1245           if (strcmp_iw (slot_name, name) != 0)
1246             return 0;
1247           if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1248                                       slot_domain, domain))
1249             return 0;
1250         }
1251     }
1252   else
1253     {
1254       /* Only one name is NULL.  */
1255       return 0;
1256     }
1257
1258   return 1;
1259 }
1260
1261 /* Given a cache of size SIZE, return the size of the struct (with variable
1262    length array) in bytes.  */
1263
1264 static size_t
1265 symbol_cache_byte_size (unsigned int size)
1266 {
1267   return (sizeof (struct block_symbol_cache)
1268           + ((size - 1) * sizeof (struct symbol_cache_slot)));
1269 }
1270
1271 /* Resize CACHE.  */
1272
1273 static void
1274 resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size)
1275 {
1276   /* If there's no change in size, don't do anything.
1277      All caches have the same size, so we can just compare with the size
1278      of the global symbols cache.  */
1279   if ((cache->global_symbols != NULL
1280        && cache->global_symbols->size == new_size)
1281       || (cache->global_symbols == NULL
1282           && new_size == 0))
1283     return;
1284
1285   xfree (cache->global_symbols);
1286   xfree (cache->static_symbols);
1287
1288   if (new_size == 0)
1289     {
1290       cache->global_symbols = NULL;
1291       cache->static_symbols = NULL;
1292     }
1293   else
1294     {
1295       size_t total_size = symbol_cache_byte_size (new_size);
1296
1297       cache->global_symbols = xcalloc (1, total_size);
1298       cache->static_symbols = xcalloc (1, total_size);
1299       cache->global_symbols->size = new_size;
1300       cache->static_symbols->size = new_size;
1301     }
1302 }
1303
1304 /* Make a symbol cache of size SIZE.  */
1305
1306 static struct symbol_cache *
1307 make_symbol_cache (unsigned int size)
1308 {
1309   struct symbol_cache *cache;
1310
1311   cache = XCNEW (struct symbol_cache);
1312   resize_symbol_cache (cache, symbol_cache_size);
1313   return cache;
1314 }
1315
1316 /* Free the space used by CACHE.  */
1317
1318 static void
1319 free_symbol_cache (struct symbol_cache *cache)
1320 {
1321   xfree (cache->global_symbols);
1322   xfree (cache->static_symbols);
1323   xfree (cache);
1324 }
1325
1326 /* Return the symbol cache of PSPACE.
1327    Create one if it doesn't exist yet.  */
1328
1329 static struct symbol_cache *
1330 get_symbol_cache (struct program_space *pspace)
1331 {
1332   struct symbol_cache *cache = program_space_data (pspace, symbol_cache_key);
1333
1334   if (cache == NULL)
1335     {
1336       cache = make_symbol_cache (symbol_cache_size);
1337       set_program_space_data (pspace, symbol_cache_key, cache);
1338     }
1339
1340   return cache;
1341 }
1342
1343 /* Delete the symbol cache of PSPACE.
1344    Called when PSPACE is destroyed.  */
1345
1346 static void
1347 symbol_cache_cleanup (struct program_space *pspace, void *data)
1348 {
1349   struct symbol_cache *cache = data;
1350
1351   free_symbol_cache (cache);
1352 }
1353
1354 /* Set the size of the symbol cache in all program spaces.  */
1355
1356 static void
1357 set_symbol_cache_size (unsigned int new_size)
1358 {
1359   struct program_space *pspace;
1360
1361   ALL_PSPACES (pspace)
1362     {
1363       struct symbol_cache *cache
1364         = program_space_data (pspace, symbol_cache_key);
1365
1366       /* The pspace could have been created but not have a cache yet.  */
1367       if (cache != NULL)
1368         resize_symbol_cache (cache, new_size);
1369     }
1370 }
1371
1372 /* Called when symbol-cache-size is set.  */
1373
1374 static void
1375 set_symbol_cache_size_handler (char *args, int from_tty,
1376                                struct cmd_list_element *c)
1377 {
1378   if (new_symbol_cache_size > MAX_SYMBOL_CACHE_SIZE)
1379     {
1380       /* Restore the previous value.
1381          This is the value the "show" command prints.  */
1382       new_symbol_cache_size = symbol_cache_size;
1383
1384       error (_("Symbol cache size is too large, max is %u."),
1385              MAX_SYMBOL_CACHE_SIZE);
1386     }
1387   symbol_cache_size = new_symbol_cache_size;
1388
1389   set_symbol_cache_size (symbol_cache_size);
1390 }
1391
1392 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1393    OBJFILE_CONTEXT is the current objfile, which may be NULL.
1394    The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1395    failed (and thus this one will too), or NULL if the symbol is not present
1396    in the cache.
1397    If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
1398    set to the cache and slot of the symbol to save the result of a full lookup
1399    attempt.  */
1400
1401 static struct symbol *
1402 symbol_cache_lookup (struct symbol_cache *cache,
1403                      struct objfile *objfile_context, int block,
1404                      const char *name, domain_enum domain,
1405                      struct block_symbol_cache **bsc_ptr,
1406                      struct symbol_cache_slot **slot_ptr)
1407 {
1408   struct block_symbol_cache *bsc;
1409   unsigned int hash;
1410   struct symbol_cache_slot *slot;
1411
1412   if (block == GLOBAL_BLOCK)
1413     bsc = cache->global_symbols;
1414   else
1415     bsc = cache->static_symbols;
1416   if (bsc == NULL)
1417     {
1418       *bsc_ptr = NULL;
1419       *slot_ptr = NULL;
1420       return NULL;
1421     }
1422
1423   hash = hash_symbol_entry (objfile_context, name, domain);
1424   slot = bsc->symbols + hash % bsc->size;
1425
1426   if (eq_symbol_entry (slot, objfile_context, name, domain))
1427     {
1428       if (symbol_lookup_debug)
1429         fprintf_unfiltered (gdb_stdlog,
1430                             "%s block symbol cache hit%s for %s, %s\n",
1431                             block == GLOBAL_BLOCK ? "Global" : "Static",
1432                             slot->state == SYMBOL_SLOT_NOT_FOUND
1433                             ? " (not found)" : "",
1434                             name, domain_name (domain));
1435       ++bsc->hits;
1436       if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1437         return SYMBOL_LOOKUP_FAILED;
1438       return slot->value.found;
1439     }
1440
1441   /* Symbol is not present in the cache.  */
1442
1443   *bsc_ptr = bsc;
1444   *slot_ptr = slot;
1445
1446   if (symbol_lookup_debug)
1447     {
1448       fprintf_unfiltered (gdb_stdlog,
1449                           "%s block symbol cache miss for %s, %s\n",
1450                           block == GLOBAL_BLOCK ? "Global" : "Static",
1451                           name, domain_name (domain));
1452     }
1453   ++bsc->misses;
1454   return NULL;
1455 }
1456
1457 /* Clear out SLOT.  */
1458
1459 static void
1460 symbol_cache_clear_slot (struct symbol_cache_slot *slot)
1461 {
1462   if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1463     xfree (slot->value.not_found.name);
1464   slot->state = SYMBOL_SLOT_UNUSED;
1465 }
1466
1467 /* Mark SYMBOL as found in SLOT.
1468    OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1469    if it's not needed to distinguish lookups (STATIC_BLOCK).  It is *not*
1470    necessarily the objfile the symbol was found in.  */
1471
1472 static void
1473 symbol_cache_mark_found (struct block_symbol_cache *bsc,
1474                          struct symbol_cache_slot *slot,
1475                          struct objfile *objfile_context,
1476                          struct symbol *symbol)
1477 {
1478   if (bsc == NULL)
1479     return;
1480   if (slot->state != SYMBOL_SLOT_UNUSED)
1481     {
1482       ++bsc->collisions;
1483       symbol_cache_clear_slot (slot);
1484     }
1485   slot->state = SYMBOL_SLOT_FOUND;
1486   slot->objfile_context = objfile_context;
1487   slot->value.found = symbol;
1488 }
1489
1490 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1491    OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1492    if it's not needed to distinguish lookups (STATIC_BLOCK).  */
1493
1494 static void
1495 symbol_cache_mark_not_found (struct block_symbol_cache *bsc,
1496                              struct symbol_cache_slot *slot,
1497                              struct objfile *objfile_context,
1498                              const char *name, domain_enum domain)
1499 {
1500   if (bsc == NULL)
1501     return;
1502   if (slot->state != SYMBOL_SLOT_UNUSED)
1503     {
1504       ++bsc->collisions;
1505       symbol_cache_clear_slot (slot);
1506     }
1507   slot->state = SYMBOL_SLOT_NOT_FOUND;
1508   slot->objfile_context = objfile_context;
1509   slot->value.not_found.name = xstrdup (name);
1510   slot->value.not_found.domain = domain;
1511 }
1512
1513 /* Flush the symbol cache of PSPACE.  */
1514
1515 static void
1516 symbol_cache_flush (struct program_space *pspace)
1517 {
1518   struct symbol_cache *cache = program_space_data (pspace, symbol_cache_key);
1519   int pass;
1520   size_t total_size;
1521
1522   if (cache == NULL)
1523     return;
1524   if (cache->global_symbols == NULL)
1525     {
1526       gdb_assert (symbol_cache_size == 0);
1527       gdb_assert (cache->static_symbols == NULL);
1528       return;
1529     }
1530
1531   /* If the cache is untouched since the last flush, early exit.
1532      This is important for performance during the startup of a program linked
1533      with 100s (or 1000s) of shared libraries.  */
1534   if (cache->global_symbols->misses == 0
1535       && cache->static_symbols->misses == 0)
1536     return;
1537
1538   gdb_assert (cache->global_symbols->size == symbol_cache_size);
1539   gdb_assert (cache->static_symbols->size == symbol_cache_size);
1540
1541   for (pass = 0; pass < 2; ++pass)
1542     {
1543       struct block_symbol_cache *bsc
1544         = pass == 0 ? cache->global_symbols : cache->static_symbols;
1545       unsigned int i;
1546
1547       for (i = 0; i < bsc->size; ++i)
1548         symbol_cache_clear_slot (&bsc->symbols[i]);
1549     }
1550
1551   cache->global_symbols->hits = 0;
1552   cache->global_symbols->misses = 0;
1553   cache->global_symbols->collisions = 0;
1554   cache->static_symbols->hits = 0;
1555   cache->static_symbols->misses = 0;
1556   cache->static_symbols->collisions = 0;
1557 }
1558
1559 /* Dump CACHE.  */
1560
1561 static void
1562 symbol_cache_dump (const struct symbol_cache *cache)
1563 {
1564   int pass;
1565
1566   if (cache->global_symbols == NULL)
1567     {
1568       printf_filtered ("  <disabled>\n");
1569       return;
1570     }
1571
1572   for (pass = 0; pass < 2; ++pass)
1573     {
1574       const struct block_symbol_cache *bsc
1575         = pass == 0 ? cache->global_symbols : cache->static_symbols;
1576       unsigned int i;
1577
1578       if (pass == 0)
1579         printf_filtered ("Global symbols:\n");
1580       else
1581         printf_filtered ("Static symbols:\n");
1582
1583       for (i = 0; i < bsc->size; ++i)
1584         {
1585           const struct symbol_cache_slot *slot = &bsc->symbols[i];
1586
1587           QUIT;
1588
1589           switch (slot->state)
1590             {
1591             case SYMBOL_SLOT_UNUSED:
1592               break;
1593             case SYMBOL_SLOT_NOT_FOUND:
1594               printf_filtered ("  [%4u] = %s, %s %s (not found)\n", i,
1595                                host_address_to_string (slot->objfile_context),
1596                                slot->value.not_found.name,
1597                                domain_name (slot->value.not_found.domain));
1598               break;
1599             case SYMBOL_SLOT_FOUND:
1600               printf_filtered ("  [%4u] = %s, %s %s\n", i,
1601                                host_address_to_string (slot->objfile_context),
1602                                SYMBOL_PRINT_NAME (slot->value.found),
1603                                domain_name (SYMBOL_DOMAIN (slot->value.found)));
1604               break;
1605             }
1606         }
1607     }
1608 }
1609
1610 /* The "mt print symbol-cache" command.  */
1611
1612 static void
1613 maintenance_print_symbol_cache (char *args, int from_tty)
1614 {
1615   struct program_space *pspace;
1616
1617   ALL_PSPACES (pspace)
1618     {
1619       struct symbol_cache *cache;
1620
1621       printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1622                        pspace->num,
1623                        pspace->symfile_object_file != NULL
1624                        ? objfile_name (pspace->symfile_object_file)
1625                        : "(no object file)");
1626
1627       /* If the cache hasn't been created yet, avoid creating one.  */
1628       cache = program_space_data (pspace, symbol_cache_key);
1629       if (cache == NULL)
1630         printf_filtered ("  <empty>\n");
1631       else
1632         symbol_cache_dump (cache);
1633     }
1634 }
1635
1636 /* The "mt flush-symbol-cache" command.  */
1637
1638 static void
1639 maintenance_flush_symbol_cache (char *args, int from_tty)
1640 {
1641   struct program_space *pspace;
1642
1643   ALL_PSPACES (pspace)
1644     {
1645       symbol_cache_flush (pspace);
1646     }
1647 }
1648
1649 /* Print usage statistics of CACHE.  */
1650
1651 static void
1652 symbol_cache_stats (struct symbol_cache *cache)
1653 {
1654   int pass;
1655
1656   if (cache->global_symbols == NULL)
1657     {
1658       printf_filtered ("  <disabled>\n");
1659       return;
1660     }
1661
1662   for (pass = 0; pass < 2; ++pass)
1663     {
1664       const struct block_symbol_cache *bsc
1665         = pass == 0 ? cache->global_symbols : cache->static_symbols;
1666
1667       QUIT;
1668
1669       if (pass == 0)
1670         printf_filtered ("Global block cache stats:\n");
1671       else
1672         printf_filtered ("Static block cache stats:\n");
1673
1674       printf_filtered ("  size:       %u\n", bsc->size);
1675       printf_filtered ("  hits:       %u\n", bsc->hits);
1676       printf_filtered ("  misses:     %u\n", bsc->misses);
1677       printf_filtered ("  collisions: %u\n", bsc->collisions);
1678     }
1679 }
1680
1681 /* The "mt print symbol-cache-statistics" command.  */
1682
1683 static void
1684 maintenance_print_symbol_cache_statistics (char *args, int from_tty)
1685 {
1686   struct program_space *pspace;
1687
1688   ALL_PSPACES (pspace)
1689     {
1690       struct symbol_cache *cache;
1691
1692       printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1693                        pspace->num,
1694                        pspace->symfile_object_file != NULL
1695                        ? objfile_name (pspace->symfile_object_file)
1696                        : "(no object file)");
1697
1698       /* If the cache hasn't been created yet, avoid creating one.  */
1699       cache = program_space_data (pspace, symbol_cache_key);
1700       if (cache == NULL)
1701         printf_filtered ("  empty, no stats available\n");
1702       else
1703         symbol_cache_stats (cache);
1704     }
1705 }
1706
1707 /* This module's 'new_objfile' observer.  */
1708
1709 static void
1710 symtab_new_objfile_observer (struct objfile *objfile)
1711 {
1712   /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL.  */
1713   symbol_cache_flush (current_program_space);
1714 }
1715
1716 /* This module's 'free_objfile' observer.  */
1717
1718 static void
1719 symtab_free_objfile_observer (struct objfile *objfile)
1720 {
1721   symbol_cache_flush (objfile->pspace);
1722 }
1723 \f
1724 /* Debug symbols usually don't have section information.  We need to dig that
1725    out of the minimal symbols and stash that in the debug symbol.  */
1726
1727 void
1728 fixup_section (struct general_symbol_info *ginfo,
1729                CORE_ADDR addr, struct objfile *objfile)
1730 {
1731   struct minimal_symbol *msym;
1732
1733   /* First, check whether a minimal symbol with the same name exists
1734      and points to the same address.  The address check is required
1735      e.g. on PowerPC64, where the minimal symbol for a function will
1736      point to the function descriptor, while the debug symbol will
1737      point to the actual function code.  */
1738   msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1739   if (msym)
1740     ginfo->section = MSYMBOL_SECTION (msym);
1741   else
1742     {
1743       /* Static, function-local variables do appear in the linker
1744          (minimal) symbols, but are frequently given names that won't
1745          be found via lookup_minimal_symbol().  E.g., it has been
1746          observed in frv-uclinux (ELF) executables that a static,
1747          function-local variable named "foo" might appear in the
1748          linker symbols as "foo.6" or "foo.3".  Thus, there is no
1749          point in attempting to extend the lookup-by-name mechanism to
1750          handle this case due to the fact that there can be multiple
1751          names.
1752
1753          So, instead, search the section table when lookup by name has
1754          failed.  The ``addr'' and ``endaddr'' fields may have already
1755          been relocated.  If so, the relocation offset (i.e. the
1756          ANOFFSET value) needs to be subtracted from these values when
1757          performing the comparison.  We unconditionally subtract it,
1758          because, when no relocation has been performed, the ANOFFSET
1759          value will simply be zero.
1760
1761          The address of the symbol whose section we're fixing up HAS
1762          NOT BEEN adjusted (relocated) yet.  It can't have been since
1763          the section isn't yet known and knowing the section is
1764          necessary in order to add the correct relocation value.  In
1765          other words, we wouldn't even be in this function (attempting
1766          to compute the section) if it were already known.
1767
1768          Note that it is possible to search the minimal symbols
1769          (subtracting the relocation value if necessary) to find the
1770          matching minimal symbol, but this is overkill and much less
1771          efficient.  It is not necessary to find the matching minimal
1772          symbol, only its section.
1773
1774          Note that this technique (of doing a section table search)
1775          can fail when unrelocated section addresses overlap.  For
1776          this reason, we still attempt a lookup by name prior to doing
1777          a search of the section table.  */
1778
1779       struct obj_section *s;
1780       int fallback = -1;
1781
1782       ALL_OBJFILE_OSECTIONS (objfile, s)
1783         {
1784           int idx = s - objfile->sections;
1785           CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1786
1787           if (fallback == -1)
1788             fallback = idx;
1789
1790           if (obj_section_addr (s) - offset <= addr
1791               && addr < obj_section_endaddr (s) - offset)
1792             {
1793               ginfo->section = idx;
1794               return;
1795             }
1796         }
1797
1798       /* If we didn't find the section, assume it is in the first
1799          section.  If there is no allocated section, then it hardly
1800          matters what we pick, so just pick zero.  */
1801       if (fallback == -1)
1802         ginfo->section = 0;
1803       else
1804         ginfo->section = fallback;
1805     }
1806 }
1807
1808 struct symbol *
1809 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1810 {
1811   CORE_ADDR addr;
1812
1813   if (!sym)
1814     return NULL;
1815
1816   if (!SYMBOL_OBJFILE_OWNED (sym))
1817     return sym;
1818
1819   /* We either have an OBJFILE, or we can get at it from the sym's
1820      symtab.  Anything else is a bug.  */
1821   gdb_assert (objfile || symbol_symtab (sym));
1822
1823   if (objfile == NULL)
1824     objfile = symbol_objfile (sym);
1825
1826   if (SYMBOL_OBJ_SECTION (objfile, sym))
1827     return sym;
1828
1829   /* We should have an objfile by now.  */
1830   gdb_assert (objfile);
1831
1832   switch (SYMBOL_CLASS (sym))
1833     {
1834     case LOC_STATIC:
1835     case LOC_LABEL:
1836       addr = SYMBOL_VALUE_ADDRESS (sym);
1837       break;
1838     case LOC_BLOCK:
1839       addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1840       break;
1841
1842     default:
1843       /* Nothing else will be listed in the minsyms -- no use looking
1844          it up.  */
1845       return sym;
1846     }
1847
1848   fixup_section (&sym->ginfo, addr, objfile);
1849
1850   return sym;
1851 }
1852
1853 /* Compute the demangled form of NAME as used by the various symbol
1854    lookup functions.  The result is stored in *RESULT_NAME.  Returns a
1855    cleanup which can be used to clean up the result.
1856
1857    For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1858    Normally, Ada symbol lookups are performed using the encoded name
1859    rather than the demangled name, and so it might seem to make sense
1860    for this function to return an encoded version of NAME.
1861    Unfortunately, we cannot do this, because this function is used in
1862    circumstances where it is not appropriate to try to encode NAME.
1863    For instance, when displaying the frame info, we demangle the name
1864    of each parameter, and then perform a symbol lookup inside our
1865    function using that demangled name.  In Ada, certain functions
1866    have internally-generated parameters whose name contain uppercase
1867    characters.  Encoding those name would result in those uppercase
1868    characters to become lowercase, and thus cause the symbol lookup
1869    to fail.  */
1870
1871 struct cleanup *
1872 demangle_for_lookup (const char *name, enum language lang,
1873                      const char **result_name)
1874 {
1875   char *demangled_name = NULL;
1876   const char *modified_name = NULL;
1877   struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
1878
1879   modified_name = name;
1880
1881   /* If we are using C++, D, Go, or Java, demangle the name before doing a
1882      lookup, so we can always binary search.  */
1883   if (lang == language_cplus)
1884     {
1885       demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1886       if (demangled_name)
1887         {
1888           modified_name = demangled_name;
1889           make_cleanup (xfree, demangled_name);
1890         }
1891       else
1892         {
1893           /* If we were given a non-mangled name, canonicalize it
1894              according to the language (so far only for C++).  */
1895           demangled_name = cp_canonicalize_string (name);
1896           if (demangled_name)
1897             {
1898               modified_name = demangled_name;
1899               make_cleanup (xfree, demangled_name);
1900             }
1901         }
1902     }
1903   else if (lang == language_java)
1904     {
1905       demangled_name = gdb_demangle (name,
1906                                      DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1907       if (demangled_name)
1908         {
1909           modified_name = demangled_name;
1910           make_cleanup (xfree, demangled_name);
1911         }
1912     }
1913   else if (lang == language_d)
1914     {
1915       demangled_name = d_demangle (name, 0);
1916       if (demangled_name)
1917         {
1918           modified_name = demangled_name;
1919           make_cleanup (xfree, demangled_name);
1920         }
1921     }
1922   else if (lang == language_go)
1923     {
1924       demangled_name = go_demangle (name, 0);
1925       if (demangled_name)
1926         {
1927           modified_name = demangled_name;
1928           make_cleanup (xfree, demangled_name);
1929         }
1930     }
1931
1932   *result_name = modified_name;
1933   return cleanup;
1934 }
1935
1936 /* See symtab.h.
1937
1938    This function (or rather its subordinates) have a bunch of loops and
1939    it would seem to be attractive to put in some QUIT's (though I'm not really
1940    sure whether it can run long enough to be really important).  But there
1941    are a few calls for which it would appear to be bad news to quit
1942    out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c.  (Note
1943    that there is C++ code below which can error(), but that probably
1944    doesn't affect these calls since they are looking for a known
1945    variable and thus can probably assume it will never hit the C++
1946    code).  */
1947
1948 struct symbol *
1949 lookup_symbol_in_language (const char *name, const struct block *block,
1950                            const domain_enum domain, enum language lang,
1951                            struct field_of_this_result *is_a_field_of_this)
1952 {
1953   const char *modified_name;
1954   struct symbol *returnval;
1955   struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
1956
1957   returnval = lookup_symbol_aux (modified_name, block, domain, lang,
1958                                  is_a_field_of_this);
1959   do_cleanups (cleanup);
1960
1961   return returnval;
1962 }
1963
1964 /* See symtab.h.  */
1965
1966 struct symbol *
1967 lookup_symbol (const char *name, const struct block *block,
1968                domain_enum domain,
1969                struct field_of_this_result *is_a_field_of_this)
1970 {
1971   return lookup_symbol_in_language (name, block, domain,
1972                                     current_language->la_language,
1973                                     is_a_field_of_this);
1974 }
1975
1976 /* See symtab.h.  */
1977
1978 struct symbol *
1979 lookup_language_this (const struct language_defn *lang,
1980                       const struct block *block)
1981 {
1982   if (lang->la_name_of_this == NULL || block == NULL)
1983     return NULL;
1984
1985   if (symbol_lookup_debug > 1)
1986     {
1987       struct objfile *objfile = lookup_objfile_from_block (block);
1988
1989       fprintf_unfiltered (gdb_stdlog,
1990                           "lookup_language_this (%s, %s (objfile %s))",
1991                           lang->la_name, host_address_to_string (block),
1992                           objfile_debug_name (objfile));
1993     }
1994
1995   while (block)
1996     {
1997       struct symbol *sym;
1998
1999       sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
2000       if (sym != NULL)
2001         {
2002           if (symbol_lookup_debug > 1)
2003             {
2004               fprintf_unfiltered (gdb_stdlog, " = %s (%s, block %s)\n",
2005                                   SYMBOL_PRINT_NAME (sym),
2006                                   host_address_to_string (sym),
2007                                   host_address_to_string (block));
2008             }
2009           block_found = block;
2010           return sym;
2011         }
2012       if (BLOCK_FUNCTION (block))
2013         break;
2014       block = BLOCK_SUPERBLOCK (block);
2015     }
2016
2017   if (symbol_lookup_debug > 1)
2018     fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2019   return NULL;
2020 }
2021
2022 /* Given TYPE, a structure/union,
2023    return 1 if the component named NAME from the ultimate target
2024    structure/union is defined, otherwise, return 0.  */
2025
2026 static int
2027 check_field (struct type *type, const char *name,
2028              struct field_of_this_result *is_a_field_of_this)
2029 {
2030   int i;
2031
2032   /* The type may be a stub.  */
2033   CHECK_TYPEDEF (type);
2034
2035   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2036     {
2037       const char *t_field_name = TYPE_FIELD_NAME (type, i);
2038
2039       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2040         {
2041           is_a_field_of_this->type = type;
2042           is_a_field_of_this->field = &TYPE_FIELD (type, i);
2043           return 1;
2044         }
2045     }
2046
2047   /* C++: If it was not found as a data field, then try to return it
2048      as a pointer to a method.  */
2049
2050   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2051     {
2052       if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2053         {
2054           is_a_field_of_this->type = type;
2055           is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
2056           return 1;
2057         }
2058     }
2059
2060   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2061     if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
2062       return 1;
2063
2064   return 0;
2065 }
2066
2067 /* Behave like lookup_symbol except that NAME is the natural name
2068    (e.g., demangled name) of the symbol that we're looking for.  */
2069
2070 static struct symbol *
2071 lookup_symbol_aux (const char *name, const struct block *block,
2072                    const domain_enum domain, enum language language,
2073                    struct field_of_this_result *is_a_field_of_this)
2074 {
2075   struct symbol *sym;
2076   const struct language_defn *langdef;
2077
2078   if (symbol_lookup_debug)
2079     {
2080       struct objfile *objfile = lookup_objfile_from_block (block);
2081
2082       fprintf_unfiltered (gdb_stdlog,
2083                           "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
2084                           name, host_address_to_string (block),
2085                           objfile != NULL
2086                           ? objfile_debug_name (objfile) : "NULL",
2087                           domain_name (domain), language_str (language));
2088     }
2089
2090   /* Initialize block_found so that the language la_lookup_symbol_nonlocal
2091      routines don't have to set it (to NULL) if a primitive type is found.
2092      We do this early so that block_found is also NULL if no symbol is
2093      found (though this is not part of the API, and callers cannot assume
2094      this).  */
2095   block_found = NULL;
2096
2097   /* Make sure we do something sensible with is_a_field_of_this, since
2098      the callers that set this parameter to some non-null value will
2099      certainly use it later.  If we don't set it, the contents of
2100      is_a_field_of_this are undefined.  */
2101   if (is_a_field_of_this != NULL)
2102     memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
2103
2104   /* Search specified block and its superiors.  Don't search
2105      STATIC_BLOCK or GLOBAL_BLOCK.  */
2106
2107   sym = lookup_local_symbol (name, block, domain, language);
2108   if (sym != NULL)
2109     {
2110       if (symbol_lookup_debug)
2111         {
2112           fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2113                               host_address_to_string (sym));
2114         }
2115       return sym;
2116     }
2117
2118   /* If requested to do so by the caller and if appropriate for LANGUAGE,
2119      check to see if NAME is a field of `this'.  */
2120
2121   langdef = language_def (language);
2122
2123   /* Don't do this check if we are searching for a struct.  It will
2124      not be found by check_field, but will be found by other
2125      means.  */
2126   if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
2127     {
2128       struct symbol *sym = lookup_language_this (langdef, block);
2129
2130       if (sym)
2131         {
2132           struct type *t = sym->type;
2133
2134           /* I'm not really sure that type of this can ever
2135              be typedefed; just be safe.  */
2136           CHECK_TYPEDEF (t);
2137           if (TYPE_CODE (t) == TYPE_CODE_PTR
2138               || TYPE_CODE (t) == TYPE_CODE_REF)
2139             t = TYPE_TARGET_TYPE (t);
2140
2141           if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2142               && TYPE_CODE (t) != TYPE_CODE_UNION)
2143             error (_("Internal error: `%s' is not an aggregate"),
2144                    langdef->la_name_of_this);
2145
2146           if (check_field (t, name, is_a_field_of_this))
2147             {
2148               if (symbol_lookup_debug)
2149                 {
2150                   fprintf_unfiltered (gdb_stdlog,
2151                                       "lookup_symbol_aux (...) = NULL\n");
2152                 }
2153               return NULL;
2154             }
2155         }
2156     }
2157
2158   /* Now do whatever is appropriate for LANGUAGE to look
2159      up static and global variables.  */
2160
2161   sym = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
2162   if (sym != NULL)
2163     {
2164       if (symbol_lookup_debug)
2165         {
2166           fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2167                               host_address_to_string (sym));
2168         }
2169       return sym;
2170     }
2171
2172   /* Now search all static file-level symbols.  Not strictly correct,
2173      but more useful than an error.  */
2174
2175   sym = lookup_static_symbol (name, domain);
2176   if (symbol_lookup_debug)
2177     {
2178       fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2179                           sym != NULL ? host_address_to_string (sym) : "NULL");
2180     }
2181   return sym;
2182 }
2183
2184 /* Check to see if the symbol is defined in BLOCK or its superiors.
2185    Don't search STATIC_BLOCK or GLOBAL_BLOCK.  */
2186
2187 static struct symbol *
2188 lookup_local_symbol (const char *name, const struct block *block,
2189                      const domain_enum domain,
2190                      enum language language)
2191 {
2192   struct symbol *sym;
2193   const struct block *static_block = block_static_block (block);
2194   const char *scope = block_scope (block);
2195   
2196   /* Check if either no block is specified or it's a global block.  */
2197
2198   if (static_block == NULL)
2199     return NULL;
2200
2201   while (block != static_block)
2202     {
2203       sym = lookup_symbol_in_block (name, block, domain);
2204       if (sym != NULL)
2205         return sym;
2206
2207       if (language == language_cplus || language == language_fortran)
2208         {
2209           sym = cp_lookup_symbol_imports_or_template (scope, name, block,
2210                                                       domain);
2211           if (sym != NULL)
2212             return sym;
2213         }
2214
2215       if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
2216         break;
2217       block = BLOCK_SUPERBLOCK (block);
2218     }
2219
2220   /* We've reached the end of the function without finding a result.  */
2221
2222   return NULL;
2223 }
2224
2225 /* See symtab.h.  */
2226
2227 struct objfile *
2228 lookup_objfile_from_block (const struct block *block)
2229 {
2230   struct objfile *obj;
2231   struct compunit_symtab *cust;
2232
2233   if (block == NULL)
2234     return NULL;
2235
2236   block = block_global_block (block);
2237   /* Look through all blockvectors.  */
2238   ALL_COMPUNITS (obj, cust)
2239     if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
2240                                     GLOBAL_BLOCK))
2241       {
2242         if (obj->separate_debug_objfile_backlink)
2243           obj = obj->separate_debug_objfile_backlink;
2244
2245         return obj;
2246       }
2247
2248   return NULL;
2249 }
2250
2251 /* See symtab.h.  */
2252
2253 struct symbol *
2254 lookup_symbol_in_block (const char *name, const struct block *block,
2255                         const domain_enum domain)
2256 {
2257   struct symbol *sym;
2258
2259   if (symbol_lookup_debug > 1)
2260     {
2261       struct objfile *objfile = lookup_objfile_from_block (block);
2262
2263       fprintf_unfiltered (gdb_stdlog,
2264                           "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2265                           name, host_address_to_string (block),
2266                           objfile_debug_name (objfile),
2267                           domain_name (domain));
2268     }
2269
2270   sym = block_lookup_symbol (block, name, domain);
2271   if (sym)
2272     {
2273       if (symbol_lookup_debug > 1)
2274         {
2275           fprintf_unfiltered (gdb_stdlog, " = %s\n",
2276                               host_address_to_string (sym));
2277         }
2278       block_found = block;
2279       return fixup_symbol_section (sym, NULL);
2280     }
2281
2282   if (symbol_lookup_debug > 1)
2283     fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2284   return NULL;
2285 }
2286
2287 /* See symtab.h.  */
2288
2289 struct symbol *
2290 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
2291                                    const char *name,
2292                                    const domain_enum domain)
2293 {
2294   struct objfile *objfile;
2295
2296   for (objfile = main_objfile;
2297        objfile;
2298        objfile = objfile_separate_debug_iterate (main_objfile, objfile))
2299     {
2300       struct symbol *sym = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
2301                                                      name, domain);
2302
2303       if (sym != NULL)
2304         return sym;
2305     }
2306
2307   return NULL;
2308 }
2309
2310 /* Check to see if the symbol is defined in one of the OBJFILE's
2311    symtabs.  BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2312    depending on whether or not we want to search global symbols or
2313    static symbols.  */
2314
2315 static struct symbol *
2316 lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
2317                                   const char *name, const domain_enum domain)
2318 {
2319   struct compunit_symtab *cust;
2320
2321   gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2322
2323   if (symbol_lookup_debug > 1)
2324     {
2325       fprintf_unfiltered (gdb_stdlog,
2326                           "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2327                           objfile_debug_name (objfile),
2328                           block_index == GLOBAL_BLOCK
2329                           ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2330                           name, domain_name (domain));
2331     }
2332
2333   ALL_OBJFILE_COMPUNITS (objfile, cust)
2334     {
2335       const struct blockvector *bv;
2336       const struct block *block;
2337       struct symbol *sym;
2338
2339       bv = COMPUNIT_BLOCKVECTOR (cust);
2340       block = BLOCKVECTOR_BLOCK (bv, block_index);
2341       sym = block_lookup_symbol_primary (block, name, domain);
2342       if (sym)
2343         {
2344           if (symbol_lookup_debug > 1)
2345             {
2346               fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n",
2347                                   host_address_to_string (sym),
2348                                   host_address_to_string (block));
2349             }
2350           block_found = block;
2351           return fixup_symbol_section (sym, objfile);
2352         }
2353     }
2354
2355   if (symbol_lookup_debug > 1)
2356     fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2357   return NULL;
2358 }
2359
2360 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2361    Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2362    and all associated separate debug objfiles.
2363
2364    Normally we only look in OBJFILE, and not any separate debug objfiles
2365    because the outer loop will cause them to be searched too.  This case is
2366    different.  Here we're called from search_symbols where it will only
2367    call us for the the objfile that contains a matching minsym.  */
2368
2369 static struct symbol *
2370 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
2371                                             const char *linkage_name,
2372                                             domain_enum domain)
2373 {
2374   enum language lang = current_language->la_language;
2375   const char *modified_name;
2376   struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang,
2377                                                  &modified_name);
2378   struct objfile *main_objfile, *cur_objfile;
2379
2380   if (objfile->separate_debug_objfile_backlink)
2381     main_objfile = objfile->separate_debug_objfile_backlink;
2382   else
2383     main_objfile = objfile;
2384
2385   for (cur_objfile = main_objfile;
2386        cur_objfile;
2387        cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
2388     {
2389       struct symbol *sym;
2390
2391       sym = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
2392                                               modified_name, domain);
2393       if (sym == NULL)
2394         sym = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
2395                                                 modified_name, domain);
2396       if (sym != NULL)
2397         {
2398           do_cleanups (cleanup);
2399           return sym;
2400         }
2401     }
2402
2403   do_cleanups (cleanup);
2404   return NULL;
2405 }
2406
2407 /* A helper function that throws an exception when a symbol was found
2408    in a psymtab but not in a symtab.  */
2409
2410 static void ATTRIBUTE_NORETURN
2411 error_in_psymtab_expansion (int block_index, const char *name,
2412                             struct compunit_symtab *cust)
2413 {
2414   error (_("\
2415 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2416 %s may be an inlined function, or may be a template function\n   \
2417 (if a template, try specifying an instantiation: %s<type>)."),
2418          block_index == GLOBAL_BLOCK ? "global" : "static",
2419          name,
2420          symtab_to_filename_for_display (compunit_primary_filetab (cust)),
2421          name, name);
2422 }
2423
2424 /* A helper function for various lookup routines that interfaces with
2425    the "quick" symbol table functions.  */
2426
2427 static struct symbol *
2428 lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index,
2429                              const char *name, const domain_enum domain)
2430 {
2431   struct compunit_symtab *cust;
2432   const struct blockvector *bv;
2433   const struct block *block;
2434   struct symbol *sym;
2435
2436   if (!objfile->sf)
2437     return NULL;
2438
2439   if (symbol_lookup_debug > 1)
2440     {
2441       fprintf_unfiltered (gdb_stdlog,
2442                           "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2443                           objfile_debug_name (objfile),
2444                           block_index == GLOBAL_BLOCK
2445                           ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2446                           name, domain_name (domain));
2447     }
2448
2449   cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, domain);
2450   if (cust == NULL)
2451     {
2452       if (symbol_lookup_debug > 1)
2453         {
2454           fprintf_unfiltered (gdb_stdlog,
2455                               "lookup_symbol_via_quick_fns (...) = NULL\n");
2456         }
2457       return NULL;
2458     }
2459
2460   bv = COMPUNIT_BLOCKVECTOR (cust);
2461   block = BLOCKVECTOR_BLOCK (bv, block_index);
2462   sym = block_lookup_symbol (block, name, domain);
2463   if (!sym)
2464     error_in_psymtab_expansion (block_index, name, cust);
2465
2466   if (symbol_lookup_debug > 1)
2467     {
2468       fprintf_unfiltered (gdb_stdlog,
2469                           "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2470                           host_address_to_string (sym),
2471                           host_address_to_string (block));
2472     }
2473
2474   block_found = block;
2475   return fixup_symbol_section (sym, objfile);
2476 }
2477
2478 /* See symtab.h.  */
2479
2480 struct symbol *
2481 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
2482                               const char *name,
2483                               const struct block *block,
2484                               const domain_enum domain)
2485 {
2486   struct symbol *sym;
2487
2488   /* NOTE: carlton/2003-05-19: The comments below were written when
2489      this (or what turned into this) was part of lookup_symbol_aux;
2490      I'm much less worried about these questions now, since these
2491      decisions have turned out well, but I leave these comments here
2492      for posterity.  */
2493
2494   /* NOTE: carlton/2002-12-05: There is a question as to whether or
2495      not it would be appropriate to search the current global block
2496      here as well.  (That's what this code used to do before the
2497      is_a_field_of_this check was moved up.)  On the one hand, it's
2498      redundant with the lookup in all objfiles search that happens
2499      next.  On the other hand, if decode_line_1 is passed an argument
2500      like filename:var, then the user presumably wants 'var' to be
2501      searched for in filename.  On the third hand, there shouldn't be
2502      multiple global variables all of which are named 'var', and it's
2503      not like decode_line_1 has ever restricted its search to only
2504      global variables in a single filename.  All in all, only
2505      searching the static block here seems best: it's correct and it's
2506      cleanest.  */
2507
2508   /* NOTE: carlton/2002-12-05: There's also a possible performance
2509      issue here: if you usually search for global symbols in the
2510      current file, then it would be slightly better to search the
2511      current global block before searching all the symtabs.  But there
2512      are other factors that have a much greater effect on performance
2513      than that one, so I don't think we should worry about that for
2514      now.  */
2515
2516   /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2517      the current objfile.  Searching the current objfile first is useful
2518      for both matching user expectations as well as performance.  */
2519
2520   sym = lookup_symbol_in_static_block (name, block, domain);
2521   if (sym != NULL)
2522     return sym;
2523
2524   /* If we didn't find a definition for a builtin type in the static block,
2525      search for it now.  This is actually the right thing to do and can be
2526      a massive performance win.  E.g., when debugging a program with lots of
2527      shared libraries we could search all of them only to find out the
2528      builtin type isn't defined in any of them.  This is common for types
2529      like "void".  */
2530   if (domain == VAR_DOMAIN)
2531     {
2532       struct gdbarch *gdbarch;
2533
2534       if (block == NULL)
2535         gdbarch = target_gdbarch ();
2536       else
2537         gdbarch = block_gdbarch (block);
2538       sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
2539       if (sym != NULL)
2540         return sym;
2541     }
2542
2543   return lookup_global_symbol (name, block, domain);
2544 }
2545
2546 /* See symtab.h.  */
2547
2548 struct symbol *
2549 lookup_symbol_in_static_block (const char *name,
2550                                const struct block *block,
2551                                const domain_enum domain)
2552 {
2553   const struct block *static_block = block_static_block (block);
2554   struct symbol *sym;
2555
2556   if (static_block == NULL)
2557     return NULL;
2558
2559   if (symbol_lookup_debug)
2560     {
2561       struct objfile *objfile = lookup_objfile_from_block (static_block);
2562
2563       fprintf_unfiltered (gdb_stdlog,
2564                           "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2565                           " %s)\n",
2566                           name,
2567                           host_address_to_string (block),
2568                           objfile_debug_name (objfile),
2569                           domain_name (domain));
2570     }
2571
2572   sym = lookup_symbol_in_block (name, static_block, domain);
2573   if (symbol_lookup_debug)
2574     {
2575       fprintf_unfiltered (gdb_stdlog,
2576                           "lookup_symbol_in_static_block (...) = %s\n",
2577                           sym != NULL ? host_address_to_string (sym) : "NULL");
2578     }
2579   return sym;
2580 }
2581
2582 /* Perform the standard symbol lookup of NAME in OBJFILE:
2583    1) First search expanded symtabs, and if not found
2584    2) Search the "quick" symtabs (partial or .gdb_index).
2585    BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK.  */
2586
2587 static struct symbol *
2588 lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
2589                           const char *name, const domain_enum domain)
2590 {
2591   struct symbol *result;
2592
2593   if (symbol_lookup_debug)
2594     {
2595       fprintf_unfiltered (gdb_stdlog,
2596                           "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2597                           objfile_debug_name (objfile),
2598                           block_index == GLOBAL_BLOCK
2599                           ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2600                           name, domain_name (domain));
2601     }
2602
2603   result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
2604                                              name, domain);
2605   if (result != NULL)
2606     {
2607       if (symbol_lookup_debug)
2608         {
2609           fprintf_unfiltered (gdb_stdlog,
2610                               "lookup_symbol_in_objfile (...) = %s"
2611                               " (in symtabs)\n",
2612                               host_address_to_string (result));
2613         }
2614       return result;
2615     }
2616
2617   result = lookup_symbol_via_quick_fns (objfile, block_index,
2618                                         name, domain);
2619   if (symbol_lookup_debug)
2620     {
2621       fprintf_unfiltered (gdb_stdlog,
2622                           "lookup_symbol_in_objfile (...) = %s%s\n",
2623                           result != NULL
2624                           ? host_address_to_string (result)
2625                           : "NULL",
2626                           result != NULL ? " (via quick fns)" : "");
2627     }
2628   return result;
2629 }
2630
2631 /* See symtab.h.  */
2632
2633 struct symbol *
2634 lookup_static_symbol (const char *name, const domain_enum domain)
2635 {
2636   struct symbol_cache *cache = get_symbol_cache (current_program_space);
2637   struct objfile *objfile;
2638   struct symbol *result;
2639   struct block_symbol_cache *bsc;
2640   struct symbol_cache_slot *slot;
2641
2642   /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
2643      NULL for OBJFILE_CONTEXT.  */
2644   result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
2645                                 &bsc, &slot);
2646   if (result != NULL)
2647     {
2648       if (result == SYMBOL_LOOKUP_FAILED)
2649         return NULL;
2650       return result;
2651     }
2652
2653   ALL_OBJFILES (objfile)
2654     {
2655       result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
2656       if (result != NULL)
2657         {
2658           /* Still pass NULL for OBJFILE_CONTEXT here.  */
2659           symbol_cache_mark_found (bsc, slot, NULL, result);
2660           return result;
2661         }
2662     }
2663
2664   /* Still pass NULL for OBJFILE_CONTEXT here.  */
2665   symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
2666   return NULL;
2667 }
2668
2669 /* Private data to be used with lookup_symbol_global_iterator_cb.  */
2670
2671 struct global_sym_lookup_data
2672 {
2673   /* The name of the symbol we are searching for.  */
2674   const char *name;
2675
2676   /* The domain to use for our search.  */
2677   domain_enum domain;
2678
2679   /* The field where the callback should store the symbol if found.
2680      It should be initialized to NULL before the search is started.  */
2681   struct symbol *result;
2682 };
2683
2684 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2685    It searches by name for a symbol in the GLOBAL_BLOCK of the given
2686    OBJFILE.  The arguments for the search are passed via CB_DATA,
2687    which in reality is a pointer to struct global_sym_lookup_data.  */
2688
2689 static int
2690 lookup_symbol_global_iterator_cb (struct objfile *objfile,
2691                                   void *cb_data)
2692 {
2693   struct global_sym_lookup_data *data =
2694     (struct global_sym_lookup_data *) cb_data;
2695
2696   gdb_assert (data->result == NULL);
2697
2698   data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
2699                                            data->name, data->domain);
2700
2701   /* If we found a match, tell the iterator to stop.  Otherwise,
2702      keep going.  */
2703   return (data->result != NULL);
2704 }
2705
2706 /* See symtab.h.  */
2707
2708 struct symbol *
2709 lookup_global_symbol (const char *name,
2710                       const struct block *block,
2711                       const domain_enum domain)
2712 {
2713   struct symbol_cache *cache = get_symbol_cache (current_program_space);
2714   struct symbol *sym;
2715   struct objfile *objfile;
2716   struct global_sym_lookup_data lookup_data;
2717   struct block_symbol_cache *bsc;
2718   struct symbol_cache_slot *slot;
2719
2720   objfile = lookup_objfile_from_block (block);
2721
2722   /* First see if we can find the symbol in the cache.
2723      This works because we use the current objfile to qualify the lookup.  */
2724   sym = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
2725                              &bsc, &slot);
2726   if (sym != NULL)
2727     {
2728       if (sym == SYMBOL_LOOKUP_FAILED)
2729         return NULL;
2730       return sym;
2731     }
2732
2733   /* Call library-specific lookup procedure.  */
2734   if (objfile != NULL)
2735     sym = solib_global_lookup (objfile, name, domain);
2736
2737   /* If that didn't work go a global search (of global blocks, heh).  */
2738   if (sym == NULL)
2739     {
2740       memset (&lookup_data, 0, sizeof (lookup_data));
2741       lookup_data.name = name;
2742       lookup_data.domain = domain;
2743       gdbarch_iterate_over_objfiles_in_search_order
2744         (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
2745          lookup_symbol_global_iterator_cb, &lookup_data, objfile);
2746       sym = lookup_data.result;
2747     }
2748
2749   if (sym != NULL)
2750     symbol_cache_mark_found (bsc, slot, objfile, sym);
2751   else
2752     symbol_cache_mark_not_found (bsc, slot, objfile, name, domain);
2753
2754   return sym;
2755 }
2756
2757 int
2758 symbol_matches_domain (enum language symbol_language,
2759                        domain_enum symbol_domain,
2760                        domain_enum domain)
2761 {
2762   /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2763      A Java class declaration also defines a typedef for the class.
2764      Similarly, any Ada type declaration implicitly defines a typedef.  */
2765   if (symbol_language == language_cplus
2766       || symbol_language == language_d
2767       || symbol_language == language_java
2768       || symbol_language == language_ada)
2769     {
2770       if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
2771           && symbol_domain == STRUCT_DOMAIN)
2772         return 1;
2773     }
2774   /* For all other languages, strict match is required.  */
2775   return (symbol_domain == domain);
2776 }
2777
2778 /* See symtab.h.  */
2779
2780 struct type *
2781 lookup_transparent_type (const char *name)
2782 {
2783   return current_language->la_lookup_transparent_type (name);
2784 }
2785
2786 /* A helper for basic_lookup_transparent_type that interfaces with the
2787    "quick" symbol table functions.  */
2788
2789 static struct type *
2790 basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index,
2791                                      const char *name)
2792 {
2793   struct compunit_symtab *cust;
2794   const struct blockvector *bv;
2795   struct block *block;
2796   struct symbol *sym;
2797
2798   if (!objfile->sf)
2799     return NULL;
2800   cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name,
2801                                          STRUCT_DOMAIN);
2802   if (cust == NULL)
2803     return NULL;
2804
2805   bv = COMPUNIT_BLOCKVECTOR (cust);
2806   block = BLOCKVECTOR_BLOCK (bv, block_index);
2807   sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2808                            block_find_non_opaque_type, NULL);
2809   if (sym == NULL)
2810     error_in_psymtab_expansion (block_index, name, cust);
2811   gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2812   return SYMBOL_TYPE (sym);
2813 }
2814
2815 /* Subroutine of basic_lookup_transparent_type to simplify it.
2816    Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2817    BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK.  */
2818
2819 static struct type *
2820 basic_lookup_transparent_type_1 (struct objfile *objfile, int block_index,
2821                                  const char *name)
2822 {
2823   const struct compunit_symtab *cust;
2824   const struct blockvector *bv;
2825   const struct block *block;
2826   const struct symbol *sym;
2827
2828   ALL_OBJFILE_COMPUNITS (objfile, cust)
2829     {
2830       bv = COMPUNIT_BLOCKVECTOR (cust);
2831       block = BLOCKVECTOR_BLOCK (bv, block_index);
2832       sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2833                                block_find_non_opaque_type, NULL);
2834       if (sym != NULL)
2835         {
2836           gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2837           return SYMBOL_TYPE (sym);
2838         }
2839     }
2840
2841   return NULL;
2842 }
2843
2844 /* The standard implementation of lookup_transparent_type.  This code
2845    was modeled on lookup_symbol -- the parts not relevant to looking
2846    up types were just left out.  In particular it's assumed here that
2847    types are available in STRUCT_DOMAIN and only in file-static or
2848    global blocks.  */
2849
2850 struct type *
2851 basic_lookup_transparent_type (const char *name)
2852 {
2853   struct symbol *sym;
2854   struct compunit_symtab *cust;
2855   const struct blockvector *bv;
2856   struct objfile *objfile;
2857   struct block *block;
2858   struct type *t;
2859
2860   /* Now search all the global symbols.  Do the symtab's first, then
2861      check the psymtab's.  If a psymtab indicates the existence
2862      of the desired name as a global, then do psymtab-to-symtab
2863      conversion on the fly and return the found symbol.  */
2864
2865   ALL_OBJFILES (objfile)
2866   {
2867     t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
2868     if (t)
2869       return t;
2870   }
2871
2872   ALL_OBJFILES (objfile)
2873   {
2874     t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
2875     if (t)
2876       return t;
2877   }
2878
2879   /* Now search the static file-level symbols.
2880      Not strictly correct, but more useful than an error.
2881      Do the symtab's first, then
2882      check the psymtab's.  If a psymtab indicates the existence
2883      of the desired name as a file-level static, then do psymtab-to-symtab
2884      conversion on the fly and return the found symbol.  */
2885
2886   ALL_OBJFILES (objfile)
2887   {
2888     t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
2889     if (t)
2890       return t;
2891   }
2892
2893   ALL_OBJFILES (objfile)
2894   {
2895     t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
2896     if (t)
2897       return t;
2898   }
2899
2900   return (struct type *) 0;
2901 }
2902
2903 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2904    
2905    For each symbol that matches, CALLBACK is called.  The symbol and
2906    DATA are passed to the callback.
2907    
2908    If CALLBACK returns zero, the iteration ends.  Otherwise, the
2909    search continues.  */
2910
2911 void
2912 iterate_over_symbols (const struct block *block, const char *name,
2913                       const domain_enum domain,
2914                       symbol_found_callback_ftype *callback,
2915                       void *data)
2916 {
2917   struct block_iterator iter;
2918   struct symbol *sym;
2919
2920   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
2921     {
2922       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2923                                  SYMBOL_DOMAIN (sym), domain))
2924         {
2925           if (!callback (sym, data))
2926             return;
2927         }
2928     }
2929 }
2930
2931 /* Find the compunit symtab associated with PC and SECTION.
2932    This will read in debug info as necessary.  */
2933
2934 struct compunit_symtab *
2935 find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
2936 {
2937   struct compunit_symtab *cust;
2938   struct compunit_symtab *best_cust = NULL;
2939   struct objfile *objfile;
2940   CORE_ADDR distance = 0;
2941   struct bound_minimal_symbol msymbol;
2942
2943   /* If we know that this is not a text address, return failure.  This is
2944      necessary because we loop based on the block's high and low code
2945      addresses, which do not include the data ranges, and because
2946      we call find_pc_sect_psymtab which has a similar restriction based
2947      on the partial_symtab's texthigh and textlow.  */
2948   msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2949   if (msymbol.minsym
2950       && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
2951           || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
2952           || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
2953           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
2954           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
2955     return NULL;
2956
2957   /* Search all symtabs for the one whose file contains our address, and which
2958      is the smallest of all the ones containing the address.  This is designed
2959      to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2960      and symtab b is at 0x2000-0x3000.  So the GLOBAL_BLOCK for a is from
2961      0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2962
2963      This happens for native ecoff format, where code from included files
2964      gets its own symtab.  The symtab for the included file should have
2965      been read in already via the dependency mechanism.
2966      It might be swifter to create several symtabs with the same name
2967      like xcoff does (I'm not sure).
2968
2969      It also happens for objfiles that have their functions reordered.
2970      For these, the symtab we are looking for is not necessarily read in.  */
2971
2972   ALL_COMPUNITS (objfile, cust)
2973   {
2974     struct block *b;
2975     const struct blockvector *bv;
2976
2977     bv = COMPUNIT_BLOCKVECTOR (cust);
2978     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2979
2980     if (BLOCK_START (b) <= pc
2981         && BLOCK_END (b) > pc
2982         && (distance == 0
2983             || BLOCK_END (b) - BLOCK_START (b) < distance))
2984       {
2985         /* For an objfile that has its functions reordered,
2986            find_pc_psymtab will find the proper partial symbol table
2987            and we simply return its corresponding symtab.  */
2988         /* In order to better support objfiles that contain both
2989            stabs and coff debugging info, we continue on if a psymtab
2990            can't be found.  */
2991         if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2992           {
2993             struct compunit_symtab *result;
2994
2995             result
2996               = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2997                                                                msymbol,
2998                                                                pc, section,
2999                                                                0);
3000             if (result != NULL)
3001               return result;
3002           }
3003         if (section != 0)
3004           {
3005             struct block_iterator iter;
3006             struct symbol *sym = NULL;
3007
3008             ALL_BLOCK_SYMBOLS (b, iter, sym)
3009               {
3010                 fixup_symbol_section (sym, objfile);
3011                 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, sym),
3012                                            section))
3013                   break;
3014               }
3015             if (sym == NULL)
3016               continue;         /* No symbol in this symtab matches
3017                                    section.  */
3018           }
3019         distance = BLOCK_END (b) - BLOCK_START (b);
3020         best_cust = cust;
3021       }
3022   }
3023
3024   if (best_cust != NULL)
3025     return best_cust;
3026
3027   /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs).  */
3028
3029   ALL_OBJFILES (objfile)
3030   {
3031     struct compunit_symtab *result;
3032
3033     if (!objfile->sf)
3034       continue;
3035     result = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
3036                                                             msymbol,
3037                                                             pc, section,
3038                                                             1);
3039     if (result != NULL)
3040       return result;
3041   }
3042
3043   return NULL;
3044 }
3045
3046 /* Find the compunit symtab associated with PC.
3047    This will read in debug info as necessary.
3048    Backward compatibility, no section.  */
3049
3050 struct compunit_symtab *
3051 find_pc_compunit_symtab (CORE_ADDR pc)
3052 {
3053   return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc));
3054 }
3055 \f
3056
3057 /* Find the source file and line number for a given PC value and SECTION.
3058    Return a structure containing a symtab pointer, a line number,
3059    and a pc range for the entire source line.
3060    The value's .pc field is NOT the specified pc.
3061    NOTCURRENT nonzero means, if specified pc is on a line boundary,
3062    use the line that ends there.  Otherwise, in that case, the line
3063    that begins there is used.  */
3064
3065 /* The big complication here is that a line may start in one file, and end just
3066    before the start of another file.  This usually occurs when you #include
3067    code in the middle of a subroutine.  To properly find the end of a line's PC
3068    range, we must search all symtabs associated with this compilation unit, and
3069    find the one whose first PC is closer than that of the next line in this
3070    symtab.  */
3071
3072 /* If it's worth the effort, we could be using a binary search.  */
3073
3074 struct symtab_and_line
3075 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
3076 {
3077   struct compunit_symtab *cust;
3078   struct symtab *iter_s;
3079   struct linetable *l;
3080   int len;
3081   int i;
3082   struct linetable_entry *item;
3083   struct symtab_and_line val;
3084   const struct blockvector *bv;
3085   struct bound_minimal_symbol msymbol;
3086
3087   /* Info on best line seen so far, and where it starts, and its file.  */
3088
3089   struct linetable_entry *best = NULL;
3090   CORE_ADDR best_end = 0;
3091   struct symtab *best_symtab = 0;
3092
3093   /* Store here the first line number
3094      of a file which contains the line at the smallest pc after PC.
3095      If we don't find a line whose range contains PC,
3096      we will use a line one less than this,
3097      with a range from the start of that file to the first line's pc.  */
3098   struct linetable_entry *alt = NULL;
3099
3100   /* Info on best line seen in this file.  */
3101
3102   struct linetable_entry *prev;
3103
3104   /* If this pc is not from the current frame,
3105      it is the address of the end of a call instruction.
3106      Quite likely that is the start of the following statement.
3107      But what we want is the statement containing the instruction.
3108      Fudge the pc to make sure we get that.  */
3109
3110   init_sal (&val);              /* initialize to zeroes */
3111
3112   val.pspace = current_program_space;
3113
3114   /* It's tempting to assume that, if we can't find debugging info for
3115      any function enclosing PC, that we shouldn't search for line
3116      number info, either.  However, GAS can emit line number info for
3117      assembly files --- very helpful when debugging hand-written
3118      assembly code.  In such a case, we'd have no debug info for the
3119      function, but we would have line info.  */
3120
3121   if (notcurrent)
3122     pc -= 1;
3123
3124   /* elz: added this because this function returned the wrong
3125      information if the pc belongs to a stub (import/export)
3126      to call a shlib function.  This stub would be anywhere between
3127      two functions in the target, and the line info was erroneously
3128      taken to be the one of the line before the pc.  */
3129
3130   /* RT: Further explanation:
3131
3132    * We have stubs (trampolines) inserted between procedures.
3133    *
3134    * Example: "shr1" exists in a shared library, and a "shr1" stub also
3135    * exists in the main image.
3136    *
3137    * In the minimal symbol table, we have a bunch of symbols
3138    * sorted by start address.  The stubs are marked as "trampoline",
3139    * the others appear as text. E.g.:
3140    *
3141    *  Minimal symbol table for main image
3142    *     main:  code for main (text symbol)
3143    *     shr1: stub  (trampoline symbol)
3144    *     foo:   code for foo (text symbol)
3145    *     ...
3146    *  Minimal symbol table for "shr1" image:
3147    *     ...
3148    *     shr1: code for shr1 (text symbol)
3149    *     ...
3150    *
3151    * So the code below is trying to detect if we are in the stub
3152    * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3153    * and if found,  do the symbolization from the real-code address
3154    * rather than the stub address.
3155    *
3156    * Assumptions being made about the minimal symbol table:
3157    *   1. lookup_minimal_symbol_by_pc() will return a trampoline only
3158    *      if we're really in the trampoline.s If we're beyond it (say
3159    *      we're in "foo" in the above example), it'll have a closer
3160    *      symbol (the "foo" text symbol for example) and will not
3161    *      return the trampoline.
3162    *   2. lookup_minimal_symbol_text() will find a real text symbol
3163    *      corresponding to the trampoline, and whose address will
3164    *      be different than the trampoline address.  I put in a sanity
3165    *      check for the address being the same, to avoid an
3166    *      infinite recursion.
3167    */
3168   msymbol = lookup_minimal_symbol_by_pc (pc);
3169   if (msymbol.minsym != NULL)
3170     if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
3171       {
3172         struct bound_minimal_symbol mfunsym
3173           = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
3174                                         NULL);
3175
3176         if (mfunsym.minsym == NULL)
3177           /* I eliminated this warning since it is coming out
3178            * in the following situation:
3179            * gdb shmain // test program with shared libraries
3180            * (gdb) break shr1  // function in shared lib
3181            * Warning: In stub for ...
3182            * In the above situation, the shared lib is not loaded yet,
3183            * so of course we can't find the real func/line info,
3184            * but the "break" still works, and the warning is annoying.
3185            * So I commented out the warning.  RT */
3186           /* warning ("In stub for %s; unable to find real function/line info",
3187              SYMBOL_LINKAGE_NAME (msymbol)); */
3188           ;
3189         /* fall through */
3190         else if (BMSYMBOL_VALUE_ADDRESS (mfunsym)
3191                  == BMSYMBOL_VALUE_ADDRESS (msymbol))
3192           /* Avoid infinite recursion */
3193           /* See above comment about why warning is commented out.  */
3194           /* warning ("In stub for %s; unable to find real function/line info",
3195              SYMBOL_LINKAGE_NAME (msymbol)); */
3196           ;
3197         /* fall through */
3198         else
3199           return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym), 0);
3200       }
3201
3202
3203   cust = find_pc_sect_compunit_symtab (pc, section);
3204   if (cust == NULL)
3205     {
3206       /* If no symbol information, return previous pc.  */
3207       if (notcurrent)
3208         pc++;
3209       val.pc = pc;
3210       return val;
3211     }
3212
3213   bv = COMPUNIT_BLOCKVECTOR (cust);
3214
3215   /* Look at all the symtabs that share this blockvector.
3216      They all have the same apriori range, that we found was right;
3217      but they have different line tables.  */
3218
3219   ALL_COMPUNIT_FILETABS (cust, iter_s)
3220     {
3221       /* Find the best line in this symtab.  */
3222       l = SYMTAB_LINETABLE (iter_s);
3223       if (!l)
3224         continue;
3225       len = l->nitems;
3226       if (len <= 0)
3227         {
3228           /* I think len can be zero if the symtab lacks line numbers
3229              (e.g. gcc -g1).  (Either that or the LINETABLE is NULL;
3230              I'm not sure which, and maybe it depends on the symbol
3231              reader).  */
3232           continue;
3233         }
3234
3235       prev = NULL;
3236       item = l->item;           /* Get first line info.  */
3237
3238       /* Is this file's first line closer than the first lines of other files?
3239          If so, record this file, and its first line, as best alternate.  */
3240       if (item->pc > pc && (!alt || item->pc < alt->pc))
3241         alt = item;
3242
3243       for (i = 0; i < len; i++, item++)
3244         {
3245           /* Leave prev pointing to the linetable entry for the last line
3246              that started at or before PC.  */
3247           if (item->pc > pc)
3248             break;
3249
3250           prev = item;
3251         }
3252
3253       /* At this point, prev points at the line whose start addr is <= pc, and
3254          item points at the next line.  If we ran off the end of the linetable
3255          (pc >= start of the last line), then prev == item.  If pc < start of
3256          the first line, prev will not be set.  */
3257
3258       /* Is this file's best line closer than the best in the other files?
3259          If so, record this file, and its best line, as best so far.  Don't
3260          save prev if it represents the end of a function (i.e. line number
3261          0) instead of a real line.  */
3262
3263       if (prev && prev->line && (!best || prev->pc > best->pc))
3264         {
3265           best = prev;
3266           best_symtab = iter_s;
3267
3268           /* Discard BEST_END if it's before the PC of the current BEST.  */
3269           if (best_end <= best->pc)
3270             best_end = 0;
3271         }
3272
3273       /* If another line (denoted by ITEM) is in the linetable and its
3274          PC is after BEST's PC, but before the current BEST_END, then
3275          use ITEM's PC as the new best_end.  */
3276       if (best && i < len && item->pc > best->pc
3277           && (best_end == 0 || best_end > item->pc))
3278         best_end = item->pc;
3279     }
3280
3281   if (!best_symtab)
3282     {
3283       /* If we didn't find any line number info, just return zeros.
3284          We used to return alt->line - 1 here, but that could be
3285          anywhere; if we don't have line number info for this PC,
3286          don't make some up.  */
3287       val.pc = pc;
3288     }
3289   else if (best->line == 0)
3290     {
3291       /* If our best fit is in a range of PC's for which no line
3292          number info is available (line number is zero) then we didn't
3293          find any valid line information.  */
3294       val.pc = pc;
3295     }
3296   else
3297     {
3298       val.symtab = best_symtab;
3299       val.line = best->line;
3300       val.pc = best->pc;
3301       if (best_end && (!alt || best_end < alt->pc))
3302         val.end = best_end;
3303       else if (alt)
3304         val.end = alt->pc;
3305       else
3306         val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
3307     }
3308   val.section = section;
3309   return val;
3310 }
3311
3312 /* Backward compatibility (no section).  */
3313
3314 struct symtab_and_line
3315 find_pc_line (CORE_ADDR pc, int notcurrent)
3316 {
3317   struct obj_section *section;
3318
3319   section = find_pc_overlay (pc);
3320   if (pc_in_unmapped_range (pc, section))
3321     pc = overlay_mapped_address (pc, section);
3322   return find_pc_sect_line (pc, section, notcurrent);
3323 }
3324
3325 /* See symtab.h.  */
3326
3327 struct symtab *
3328 find_pc_line_symtab (CORE_ADDR pc)
3329 {
3330   struct symtab_and_line sal;
3331
3332   /* This always passes zero for NOTCURRENT to find_pc_line.
3333      There are currently no callers that ever pass non-zero.  */
3334   sal = find_pc_line (pc, 0);
3335   return sal.symtab;
3336 }
3337 \f
3338 /* Find line number LINE in any symtab whose name is the same as
3339    SYMTAB.
3340
3341    If found, return the symtab that contains the linetable in which it was
3342    found, set *INDEX to the index in the linetable of the best entry
3343    found, and set *EXACT_MATCH nonzero if the value returned is an
3344    exact match.
3345
3346    If not found, return NULL.  */
3347
3348 struct symtab *
3349 find_line_symtab (struct symtab *symtab, int line,
3350                   int *index, int *exact_match)
3351 {
3352   int exact = 0;  /* Initialized here to avoid a compiler warning.  */
3353
3354   /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3355      so far seen.  */
3356
3357   int best_index;
3358   struct linetable *best_linetable;
3359   struct symtab *best_symtab;
3360
3361   /* First try looking it up in the given symtab.  */
3362   best_linetable = SYMTAB_LINETABLE (symtab);
3363   best_symtab = symtab;
3364   best_index = find_line_common (best_linetable, line, &exact, 0);
3365   if (best_index < 0 || !exact)
3366     {
3367       /* Didn't find an exact match.  So we better keep looking for
3368          another symtab with the same name.  In the case of xcoff,
3369          multiple csects for one source file (produced by IBM's FORTRAN
3370          compiler) produce multiple symtabs (this is unavoidable
3371          assuming csects can be at arbitrary places in memory and that
3372          the GLOBAL_BLOCK of a symtab has a begin and end address).  */
3373
3374       /* BEST is the smallest linenumber > LINE so far seen,
3375          or 0 if none has been seen so far.
3376          BEST_INDEX and BEST_LINETABLE identify the item for it.  */
3377       int best;
3378
3379       struct objfile *objfile;
3380       struct compunit_symtab *cu;
3381       struct symtab *s;
3382
3383       if (best_index >= 0)
3384         best = best_linetable->item[best_index].line;
3385       else
3386         best = 0;
3387
3388       ALL_OBJFILES (objfile)
3389       {
3390         if (objfile->sf)
3391           objfile->sf->qf->expand_symtabs_with_fullname (objfile,
3392                                                    symtab_to_fullname (symtab));
3393       }
3394
3395       ALL_FILETABS (objfile, cu, s)
3396       {
3397         struct linetable *l;
3398         int ind;
3399
3400         if (FILENAME_CMP (symtab->filename, s->filename) != 0)
3401           continue;
3402         if (FILENAME_CMP (symtab_to_fullname (symtab),
3403                           symtab_to_fullname (s)) != 0)
3404           continue;     
3405         l = SYMTAB_LINETABLE (s);
3406         ind = find_line_common (l, line, &exact, 0);
3407         if (ind >= 0)
3408           {
3409             if (exact)
3410               {
3411                 best_index = ind;
3412                 best_linetable = l;
3413                 best_symtab = s;
3414                 goto done;
3415               }
3416             if (best == 0 || l->item[ind].line < best)
3417               {
3418                 best = l->item[ind].line;
3419                 best_index = ind;
3420                 best_linetable = l;
3421                 best_symtab = s;
3422               }
3423           }
3424       }
3425     }
3426 done:
3427   if (best_index < 0)
3428     return NULL;
3429
3430   if (index)
3431     *index = best_index;
3432   if (exact_match)
3433     *exact_match = exact;
3434
3435   return best_symtab;
3436 }
3437
3438 /* Given SYMTAB, returns all the PCs function in the symtab that
3439    exactly match LINE.  Returns NULL if there are no exact matches,
3440    but updates BEST_ITEM in this case.  */
3441
3442 VEC (CORE_ADDR) *
3443 find_pcs_for_symtab_line (struct symtab *symtab, int line,
3444                           struct linetable_entry **best_item)
3445 {
3446   int start = 0;
3447   VEC (CORE_ADDR) *result = NULL;
3448
3449   /* First, collect all the PCs that are at this line.  */
3450   while (1)
3451     {
3452       int was_exact;
3453       int idx;
3454
3455       idx = find_line_common (SYMTAB_LINETABLE (symtab), line, &was_exact,
3456                               start);
3457       if (idx < 0)
3458         break;
3459
3460       if (!was_exact)
3461         {
3462           struct linetable_entry *item = &SYMTAB_LINETABLE (symtab)->item[idx];
3463
3464           if (*best_item == NULL || item->line < (*best_item)->line)
3465             *best_item = item;
3466
3467           break;
3468         }
3469
3470       VEC_safe_push (CORE_ADDR, result,
3471                      SYMTAB_LINETABLE (symtab)->item[idx].pc);
3472       start = idx + 1;
3473     }
3474
3475   return result;
3476 }
3477
3478 \f
3479 /* Set the PC value for a given source file and line number and return true.
3480    Returns zero for invalid line number (and sets the PC to 0).
3481    The source file is specified with a struct symtab.  */
3482
3483 int
3484 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
3485 {
3486   struct linetable *l;
3487   int ind;
3488
3489   *pc = 0;
3490   if (symtab == 0)
3491     return 0;
3492
3493   symtab = find_line_symtab (symtab, line, &ind, NULL);
3494   if (symtab != NULL)
3495     {
3496       l = SYMTAB_LINETABLE (symtab);
3497       *pc = l->item[ind].pc;
3498       return 1;
3499     }
3500   else
3501     return 0;
3502 }
3503
3504 /* Find the range of pc values in a line.
3505    Store the starting pc of the line into *STARTPTR
3506    and the ending pc (start of next line) into *ENDPTR.
3507    Returns 1 to indicate success.
3508    Returns 0 if could not find the specified line.  */
3509
3510 int
3511 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
3512                     CORE_ADDR *endptr)
3513 {
3514   CORE_ADDR startaddr;
3515   struct symtab_and_line found_sal;
3516
3517   startaddr = sal.pc;
3518   if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
3519     return 0;
3520
3521   /* This whole function is based on address.  For example, if line 10 has
3522      two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3523      "info line *0x123" should say the line goes from 0x100 to 0x200
3524      and "info line *0x355" should say the line goes from 0x300 to 0x400.
3525      This also insures that we never give a range like "starts at 0x134
3526      and ends at 0x12c".  */
3527
3528   found_sal = find_pc_sect_line (startaddr, sal.section, 0);
3529   if (found_sal.line != sal.line)
3530     {
3531       /* The specified line (sal) has zero bytes.  */
3532       *startptr = found_sal.pc;
3533       *endptr = found_sal.pc;
3534     }
3535   else
3536     {
3537       *startptr = found_sal.pc;
3538       *endptr = found_sal.end;
3539     }
3540   return 1;
3541 }
3542
3543 /* Given a line table and a line number, return the index into the line
3544    table for the pc of the nearest line whose number is >= the specified one.
3545    Return -1 if none is found.  The value is >= 0 if it is an index.
3546    START is the index at which to start searching the line table.
3547
3548    Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
3549
3550 static int
3551 find_line_common (struct linetable *l, int lineno,
3552                   int *exact_match, int start)
3553 {
3554   int i;
3555   int len;
3556
3557   /* BEST is the smallest linenumber > LINENO so far seen,
3558      or 0 if none has been seen so far.
3559      BEST_INDEX identifies the item for it.  */
3560
3561   int best_index = -1;
3562   int best = 0;
3563
3564   *exact_match = 0;
3565
3566   if (lineno <= 0)
3567     return -1;
3568   if (l == 0)
3569     return -1;
3570
3571   len = l->nitems;
3572   for (i = start; i < len; i++)
3573     {
3574       struct linetable_entry *item = &(l->item[i]);
3575
3576       if (item->line == lineno)
3577         {
3578           /* Return the first (lowest address) entry which matches.  */
3579           *exact_match = 1;
3580           return i;
3581         }
3582
3583       if (item->line > lineno && (best == 0 || item->line < best))
3584         {
3585           best = item->line;
3586           best_index = i;
3587         }
3588     }
3589
3590   /* If we got here, we didn't get an exact match.  */
3591   return best_index;
3592 }
3593
3594 int
3595 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
3596 {
3597   struct symtab_and_line sal;
3598
3599   sal = find_pc_line (pc, 0);
3600   *startptr = sal.pc;
3601   *endptr = sal.end;
3602   return sal.symtab != 0;
3603 }
3604
3605 /* Given a function symbol SYM, find the symtab and line for the start
3606    of the function.
3607    If the argument FUNFIRSTLINE is nonzero, we want the first line
3608    of real code inside the function.
3609    This function should return SALs matching those from minsym_found,
3610    otherwise false multiple-locations breakpoints could be placed.  */
3611
3612 struct symtab_and_line
3613 find_function_start_sal (struct symbol *sym, int funfirstline)
3614 {
3615   struct symtab_and_line sal;
3616   struct obj_section *section;
3617
3618   fixup_symbol_section (sym, NULL);
3619   section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
3620   sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
3621
3622   if (funfirstline && sal.symtab != NULL
3623       && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
3624           || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
3625     {
3626       sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3627       return sal;
3628     }
3629
3630   /* We always should have a line for the function start address.
3631      If we don't, something is odd.  Create a plain SAL refering
3632      just the PC and hope that skip_prologue_sal (if requested)
3633      can find a line number for after the prologue.  */
3634   if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
3635     {
3636       init_sal (&sal);
3637       sal.pspace = current_program_space;
3638       sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3639       sal.section = section;
3640     }
3641
3642   if (funfirstline)
3643     skip_prologue_sal (&sal);
3644
3645   return sal;
3646 }
3647
3648 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3649    address for that function that has an entry in SYMTAB's line info
3650    table.  If such an entry cannot be found, return FUNC_ADDR
3651    unaltered.  */
3652
3653 static CORE_ADDR
3654 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
3655 {
3656   CORE_ADDR func_start, func_end;
3657   struct linetable *l;
3658   int i;
3659
3660   /* Give up if this symbol has no lineinfo table.  */
3661   l = SYMTAB_LINETABLE (symtab);
3662   if (l == NULL)
3663     return func_addr;
3664
3665   /* Get the range for the function's PC values, or give up if we
3666      cannot, for some reason.  */
3667   if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
3668     return func_addr;
3669
3670   /* Linetable entries are ordered by PC values, see the commentary in
3671      symtab.h where `struct linetable' is defined.  Thus, the first
3672      entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3673      address we are looking for.  */
3674   for (i = 0; i < l->nitems; i++)
3675     {
3676       struct linetable_entry *item = &(l->item[i]);
3677
3678       /* Don't use line numbers of zero, they mark special entries in
3679          the table.  See the commentary on symtab.h before the
3680          definition of struct linetable.  */
3681       if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
3682         return item->pc;
3683     }
3684
3685   return func_addr;
3686 }
3687
3688 /* Adjust SAL to the first instruction past the function prologue.
3689    If the PC was explicitly specified, the SAL is not changed.
3690    If the line number was explicitly specified, at most the SAL's PC
3691    is updated.  If SAL is already past the prologue, then do nothing.  */
3692
3693 void
3694 skip_prologue_sal (struct symtab_and_line *sal)
3695 {
3696   struct symbol *sym;
3697   struct symtab_and_line start_sal;
3698   struct cleanup *old_chain;
3699   CORE_ADDR pc, saved_pc;
3700   struct obj_section *section;
3701   const char *name;
3702   struct objfile *objfile;
3703   struct gdbarch *gdbarch;
3704   const struct block *b, *function_block;
3705   int force_skip, skip;
3706
3707   /* Do not change the SAL if PC was specified explicitly.  */
3708   if (sal->explicit_pc)
3709     return;
3710
3711   old_chain = save_current_space_and_thread ();
3712   switch_to_program_space_and_thread (sal->pspace);
3713
3714   sym = find_pc_sect_function (sal->pc, sal->section);
3715   if (sym != NULL)
3716     {
3717       fixup_symbol_section (sym, NULL);
3718
3719       objfile = symbol_objfile (sym);
3720       pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3721       section = SYMBOL_OBJ_SECTION (objfile, sym);
3722       name = SYMBOL_LINKAGE_NAME (sym);
3723     }
3724   else
3725     {
3726       struct bound_minimal_symbol msymbol
3727         = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
3728
3729       if (msymbol.minsym == NULL)
3730         {
3731           do_cleanups (old_chain);
3732           return;
3733         }
3734
3735       objfile = msymbol.objfile;
3736       pc = BMSYMBOL_VALUE_ADDRESS (msymbol);
3737       section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
3738       name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
3739     }
3740
3741   gdbarch = get_objfile_arch (objfile);
3742
3743   /* Process the prologue in two passes.  In the first pass try to skip the
3744      prologue (SKIP is true) and verify there is a real need for it (indicated
3745      by FORCE_SKIP).  If no such reason was found run a second pass where the
3746      prologue is not skipped (SKIP is false).  */
3747
3748   skip = 1;
3749   force_skip = 1;
3750
3751   /* Be conservative - allow direct PC (without skipping prologue) only if we
3752      have proven the CU (Compilation Unit) supports it.  sal->SYMTAB does not
3753      have to be set by the caller so we use SYM instead.  */
3754   if (sym != NULL
3755       && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym))))
3756     force_skip = 0;
3757
3758   saved_pc = pc;
3759   do
3760     {
3761       pc = saved_pc;
3762
3763       /* If the function is in an unmapped overlay, use its unmapped LMA address,
3764          so that gdbarch_skip_prologue has something unique to work on.  */
3765       if (section_is_overlay (section) && !section_is_mapped (section))
3766         pc = overlay_unmapped_address (pc, section);
3767
3768       /* Skip "first line" of function (which is actually its prologue).  */
3769       pc += gdbarch_deprecated_function_start_offset (gdbarch);
3770       if (gdbarch_skip_entrypoint_p (gdbarch))
3771         pc = gdbarch_skip_entrypoint (gdbarch, pc);
3772       if (skip)
3773         pc = gdbarch_skip_prologue (gdbarch, pc);
3774
3775       /* For overlays, map pc back into its mapped VMA range.  */
3776       pc = overlay_mapped_address (pc, section);
3777
3778       /* Calculate line number.  */
3779       start_sal = find_pc_sect_line (pc, section, 0);
3780
3781       /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3782          line is still part of the same function.  */
3783       if (skip && start_sal.pc != pc
3784           && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
3785                      && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
3786               : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
3787                  == lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
3788         {
3789           /* First pc of next line */
3790           pc = start_sal.end;
3791           /* Recalculate the line number (might not be N+1).  */
3792           start_sal = find_pc_sect_line (pc, section, 0);
3793         }
3794
3795       /* On targets with executable formats that don't have a concept of
3796          constructors (ELF with .init has, PE doesn't), gcc emits a call
3797          to `__main' in `main' between the prologue and before user
3798          code.  */
3799       if (gdbarch_skip_main_prologue_p (gdbarch)
3800           && name && strcmp_iw (name, "main") == 0)
3801         {
3802           pc = gdbarch_skip_main_prologue (gdbarch, pc);
3803           /* Recalculate the line number (might not be N+1).  */
3804           start_sal = find_pc_sect_line (pc, section, 0);
3805           force_skip = 1;
3806         }
3807     }
3808   while (!force_skip && skip--);
3809
3810   /* If we still don't have a valid source line, try to find the first
3811      PC in the lineinfo table that belongs to the same function.  This
3812      happens with COFF debug info, which does not seem to have an
3813      entry in lineinfo table for the code after the prologue which has
3814      no direct relation to source.  For example, this was found to be
3815      the case with the DJGPP target using "gcc -gcoff" when the
3816      compiler inserted code after the prologue to make sure the stack
3817      is aligned.  */
3818   if (!force_skip && sym && start_sal.symtab == NULL)
3819     {
3820       pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
3821       /* Recalculate the line number.  */
3822       start_sal = find_pc_sect_line (pc, section, 0);
3823     }
3824
3825   do_cleanups (old_chain);
3826
3827   /* If we're already past the prologue, leave SAL unchanged.  Otherwise
3828      forward SAL to the end of the prologue.  */
3829   if (sal->pc >= pc)
3830     return;
3831
3832   sal->pc = pc;
3833   sal->section = section;
3834
3835   /* Unless the explicit_line flag was set, update the SAL line
3836      and symtab to correspond to the modified PC location.  */
3837   if (sal->explicit_line)
3838     return;
3839
3840   sal->symtab = start_sal.symtab;
3841   sal->line = start_sal.line;
3842   sal->end = start_sal.end;
3843
3844   /* Check if we are now inside an inlined function.  If we can,
3845      use the call site of the function instead.  */
3846   b = block_for_pc_sect (sal->pc, sal->section);
3847   function_block = NULL;
3848   while (b != NULL)
3849     {
3850       if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
3851         function_block = b;
3852       else if (BLOCK_FUNCTION (b) != NULL)
3853         break;
3854       b = BLOCK_SUPERBLOCK (b);
3855     }
3856   if (function_block != NULL
3857       && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
3858     {
3859       sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
3860       sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
3861     }
3862 }
3863
3864 /* Given PC at the function's start address, attempt to find the
3865    prologue end using SAL information.  Return zero if the skip fails.
3866
3867    A non-optimized prologue traditionally has one SAL for the function
3868    and a second for the function body.  A single line function has
3869    them both pointing at the same line.
3870
3871    An optimized prologue is similar but the prologue may contain
3872    instructions (SALs) from the instruction body.  Need to skip those
3873    while not getting into the function body.
3874
3875    The functions end point and an increasing SAL line are used as
3876    indicators of the prologue's endpoint.
3877
3878    This code is based on the function refine_prologue_limit
3879    (found in ia64).  */
3880
3881 CORE_ADDR
3882 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
3883 {
3884   struct symtab_and_line prologue_sal;
3885   CORE_ADDR start_pc;
3886   CORE_ADDR end_pc;
3887   const struct block *bl;
3888
3889   /* Get an initial range for the function.  */
3890   find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
3891   start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
3892
3893   prologue_sal = find_pc_line (start_pc, 0);
3894   if (prologue_sal.line != 0)
3895     {
3896       /* For languages other than assembly, treat two consecutive line
3897          entries at the same address as a zero-instruction prologue.
3898          The GNU assembler emits separate line notes for each instruction
3899          in a multi-instruction macro, but compilers generally will not
3900          do this.  */
3901       if (prologue_sal.symtab->language != language_asm)
3902         {
3903           struct linetable *linetable = SYMTAB_LINETABLE (prologue_sal.symtab);
3904           int idx = 0;
3905
3906           /* Skip any earlier lines, and any end-of-sequence marker
3907              from a previous function.  */
3908           while (linetable->item[idx].pc != prologue_sal.pc
3909                  || linetable->item[idx].line == 0)
3910             idx++;
3911
3912           if (idx+1 < linetable->nitems
3913               && linetable->item[idx+1].line != 0
3914               && linetable->item[idx+1].pc == start_pc)
3915             return start_pc;
3916         }
3917
3918       /* If there is only one sal that covers the entire function,
3919          then it is probably a single line function, like
3920          "foo(){}".  */
3921       if (prologue_sal.end >= end_pc)
3922         return 0;
3923
3924       while (prologue_sal.end < end_pc)
3925         {
3926           struct symtab_and_line sal;
3927
3928           sal = find_pc_line (prologue_sal.end, 0);
3929           if (sal.line == 0)
3930             break;
3931           /* Assume that a consecutive SAL for the same (or larger)
3932              line mark the prologue -> body transition.  */
3933           if (sal.line >= prologue_sal.line)
3934             break;
3935           /* Likewise if we are in a different symtab altogether
3936              (e.g. within a file included via #include).  */
3937           if (sal.symtab != prologue_sal.symtab)
3938             break;
3939
3940           /* The line number is smaller.  Check that it's from the
3941              same function, not something inlined.  If it's inlined,
3942              then there is no point comparing the line numbers.  */
3943           bl = block_for_pc (prologue_sal.end);
3944           while (bl)
3945             {
3946               if (block_inlined_p (bl))
3947                 break;
3948               if (BLOCK_FUNCTION (bl))
3949                 {
3950                   bl = NULL;
3951                   break;
3952                 }
3953               bl = BLOCK_SUPERBLOCK (bl);
3954             }
3955           if (bl != NULL)
3956             break;
3957
3958           /* The case in which compiler's optimizer/scheduler has
3959              moved instructions into the prologue.  We look ahead in
3960              the function looking for address ranges whose
3961              corresponding line number is less the first one that we
3962              found for the function.  This is more conservative then
3963              refine_prologue_limit which scans a large number of SALs
3964              looking for any in the prologue.  */
3965           prologue_sal = sal;
3966         }
3967     }
3968
3969   if (prologue_sal.end < end_pc)
3970     /* Return the end of this line, or zero if we could not find a
3971        line.  */
3972     return prologue_sal.end;
3973   else
3974     /* Don't return END_PC, which is past the end of the function.  */
3975     return prologue_sal.pc;
3976 }
3977 \f
3978 /* If P is of the form "operator[ \t]+..." where `...' is
3979    some legitimate operator text, return a pointer to the
3980    beginning of the substring of the operator text.
3981    Otherwise, return "".  */
3982
3983 static const char *
3984 operator_chars (const char *p, const char **end)
3985 {
3986   *end = "";
3987   if (!startswith (p, "operator"))
3988     return *end;
3989   p += 8;
3990
3991   /* Don't get faked out by `operator' being part of a longer
3992      identifier.  */
3993   if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
3994     return *end;
3995
3996   /* Allow some whitespace between `operator' and the operator symbol.  */
3997   while (*p == ' ' || *p == '\t')
3998     p++;
3999
4000   /* Recognize 'operator TYPENAME'.  */
4001
4002   if (isalpha (*p) || *p == '_' || *p == '$')
4003     {
4004       const char *q = p + 1;
4005
4006       while (isalnum (*q) || *q == '_' || *q == '$')
4007         q++;
4008       *end = q;
4009       return p;
4010     }
4011
4012   while (*p)
4013     switch (*p)
4014       {
4015       case '\\':                        /* regexp quoting */
4016         if (p[1] == '*')
4017           {
4018             if (p[2] == '=')            /* 'operator\*=' */
4019               *end = p + 3;
4020             else                        /* 'operator\*'  */
4021               *end = p + 2;
4022             return p;
4023           }
4024         else if (p[1] == '[')
4025           {
4026             if (p[2] == ']')
4027               error (_("mismatched quoting on brackets, "
4028                        "try 'operator\\[\\]'"));
4029             else if (p[2] == '\\' && p[3] == ']')
4030               {
4031                 *end = p + 4;   /* 'operator\[\]' */
4032                 return p;
4033               }
4034             else
4035               error (_("nothing is allowed between '[' and ']'"));
4036           }
4037         else
4038           {
4039             /* Gratuitous qoute: skip it and move on.  */
4040             p++;
4041             continue;
4042           }
4043         break;
4044       case '!':
4045       case '=':
4046       case '*':
4047       case '/':
4048       case '%':
4049       case '^':
4050         if (p[1] == '=')
4051           *end = p + 2;
4052         else
4053           *end = p + 1;
4054         return p;
4055       case '<':
4056       case '>':
4057       case '+':
4058       case '-':
4059       case '&':
4060       case '|':
4061         if (p[0] == '-' && p[1] == '>')
4062           {
4063             /* Struct pointer member operator 'operator->'.  */
4064             if (p[2] == '*')
4065               {
4066                 *end = p + 3;   /* 'operator->*' */
4067                 return p;
4068               }
4069             else if (p[2] == '\\')
4070               {
4071                 *end = p + 4;   /* Hopefully 'operator->\*' */
4072                 return p;
4073               }
4074             else
4075               {
4076                 *end = p + 2;   /* 'operator->' */
4077                 return p;
4078               }
4079           }
4080         if (p[1] == '=' || p[1] == p[0])
4081           *end = p + 2;
4082         else
4083           *end = p + 1;
4084         return p;
4085       case '~':
4086       case ',':
4087         *end = p + 1;
4088         return p;
4089       case '(':
4090         if (p[1] != ')')
4091           error (_("`operator ()' must be specified "
4092                    "without whitespace in `()'"));
4093         *end = p + 2;
4094         return p;
4095       case '?':
4096         if (p[1] != ':')
4097           error (_("`operator ?:' must be specified "
4098                    "without whitespace in `?:'"));
4099         *end = p + 2;
4100         return p;
4101       case '[':
4102         if (p[1] != ']')
4103           error (_("`operator []' must be specified "
4104                    "without whitespace in `[]'"));
4105         *end = p + 2;
4106         return p;
4107       default:
4108         error (_("`operator %s' not supported"), p);
4109         break;
4110       }
4111
4112   *end = "";
4113   return *end;
4114 }
4115 \f
4116
4117 /* Cache to watch for file names already seen by filename_seen.  */
4118
4119 struct filename_seen_cache
4120 {
4121   /* Table of files seen so far.  */
4122   htab_t tab;
4123   /* Initial size of the table.  It automagically grows from here.  */
4124 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
4125 };
4126
4127 /* filename_seen_cache constructor.  */
4128
4129 static struct filename_seen_cache *
4130 create_filename_seen_cache (void)
4131 {
4132   struct filename_seen_cache *cache;
4133
4134   cache = XNEW (struct filename_seen_cache);
4135   cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
4136                                   filename_hash, filename_eq,
4137                                   NULL, xcalloc, xfree);
4138
4139   return cache;
4140 }
4141
4142 /* Empty the cache, but do not delete it.  */
4143
4144 static void
4145 clear_filename_seen_cache (struct filename_seen_cache *cache)
4146 {
4147   htab_empty (cache->tab);
4148 }
4149
4150 /* filename_seen_cache destructor.
4151    This takes a void * argument as it is generally used as a cleanup.  */
4152
4153 static void
4154 delete_filename_seen_cache (void *ptr)
4155 {
4156   struct filename_seen_cache *cache = ptr;
4157
4158   htab_delete (cache->tab);
4159   xfree (cache);
4160 }
4161
4162 /* If FILE is not already in the table of files in CACHE, return zero;
4163    otherwise return non-zero.  Optionally add FILE to the table if ADD
4164    is non-zero.
4165
4166    NOTE: We don't manage space for FILE, we assume FILE lives as long
4167    as the caller needs.  */
4168
4169 static int
4170 filename_seen (struct filename_seen_cache *cache, const char *file, int add)
4171 {
4172   void **slot;
4173
4174   /* Is FILE in tab?  */
4175   slot = htab_find_slot (cache->tab, file, add ? INSERT : NO_INSERT);
4176   if (*slot != NULL)
4177     return 1;
4178
4179   /* No; maybe add it to tab.  */
4180   if (add)
4181     *slot = (char *) file;
4182
4183   return 0;
4184 }
4185
4186 /* Data structure to maintain printing state for output_source_filename.  */
4187
4188 struct output_source_filename_data
4189 {
4190   /* Cache of what we've seen so far.  */
4191   struct filename_seen_cache *filename_seen_cache;
4192
4193   /* Flag of whether we're printing the first one.  */
4194   int first;
4195 };
4196
4197 /* Slave routine for sources_info.  Force line breaks at ,'s.
4198    NAME is the name to print.
4199    DATA contains the state for printing and watching for duplicates.  */
4200
4201 static void
4202 output_source_filename (const char *name,
4203                         struct output_source_filename_data *data)
4204 {
4205   /* Since a single source file can result in several partial symbol
4206      tables, we need to avoid printing it more than once.  Note: if
4207      some of the psymtabs are read in and some are not, it gets
4208      printed both under "Source files for which symbols have been
4209      read" and "Source files for which symbols will be read in on
4210      demand".  I consider this a reasonable way to deal with the
4211      situation.  I'm not sure whether this can also happen for
4212      symtabs; it doesn't hurt to check.  */
4213
4214   /* Was NAME already seen?  */
4215   if (filename_seen (data->filename_seen_cache, name, 1))
4216     {
4217       /* Yes; don't print it again.  */
4218       return;
4219     }
4220
4221   /* No; print it and reset *FIRST.  */
4222   if (! data->first)
4223     printf_filtered (", ");
4224   data->first = 0;
4225
4226   wrap_here ("");
4227   fputs_filtered (name, gdb_stdout);
4228 }
4229
4230 /* A callback for map_partial_symbol_filenames.  */
4231
4232 static void
4233 output_partial_symbol_filename (const char *filename, const char *fullname,
4234                                 void *data)
4235 {
4236   output_source_filename (fullname ? fullname : filename, data);
4237 }
4238
4239 static void
4240 sources_info (char *ignore, int from_tty)
4241 {
4242   struct compunit_symtab *cu;
4243   struct symtab *s;
4244   struct objfile *objfile;
4245   struct output_source_filename_data data;
4246   struct cleanup *cleanups;
4247
4248   if (!have_full_symbols () && !have_partial_symbols ())
4249     {