Make "list ambiguous" show symbol names too
[external/binutils.git] / gdb / symtab.c
1 /* Symbol table lookup for the GNU debugger, GDB.
2
3    Copyright (C) 1986-2017 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 #include "fnmatch.h"
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 #include "progspace-and-thread.h"
65 #include "common/gdb_optional.h"
66 #include "filename-seen-cache.h"
67 #include "arch-utils.h"
68
69 /* Forward declarations for local functions.  */
70
71 static void rbreak_command (char *, int);
72
73 static int find_line_common (struct linetable *, int, int *, int);
74
75 static struct block_symbol
76   lookup_symbol_aux (const char *name,
77                      const struct block *block,
78                      const domain_enum domain,
79                      enum language language,
80                      struct field_of_this_result *);
81
82 static
83 struct block_symbol lookup_local_symbol (const char *name,
84                                          const struct block *block,
85                                          const domain_enum domain,
86                                          enum language language);
87
88 static struct block_symbol
89   lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
90                             const char *name, const domain_enum domain);
91
92 /* See symtab.h.  */
93 const struct block_symbol null_block_symbol = { NULL, NULL };
94
95 /* Program space key for finding name and language of "main".  */
96
97 static const struct program_space_data *main_progspace_key;
98
99 /* Type of the data stored on the program space.  */
100
101 struct main_info
102 {
103   /* Name of "main".  */
104
105   char *name_of_main;
106
107   /* Language of "main".  */
108
109   enum language language_of_main;
110 };
111
112 /* Program space key for finding its symbol cache.  */
113
114 static const struct program_space_data *symbol_cache_key;
115
116 /* The default symbol cache size.
117    There is no extra cpu cost for large N (except when flushing the cache,
118    which is rare).  The value here is just a first attempt.  A better default
119    value may be higher or lower.  A prime number can make up for a bad hash
120    computation, so that's why the number is what it is.  */
121 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
122
123 /* The maximum symbol cache size.
124    There's no method to the decision of what value to use here, other than
125    there's no point in allowing a user typo to make gdb consume all memory.  */
126 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
127
128 /* symbol_cache_lookup returns this if a previous lookup failed to find the
129    symbol in any objfile.  */
130 #define SYMBOL_LOOKUP_FAILED \
131  ((struct block_symbol) {(struct symbol *) 1, NULL})
132 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
133
134 /* Recording lookups that don't find the symbol is just as important, if not
135    more so, than recording found symbols.  */
136
137 enum symbol_cache_slot_state
138 {
139   SYMBOL_SLOT_UNUSED,
140   SYMBOL_SLOT_NOT_FOUND,
141   SYMBOL_SLOT_FOUND
142 };
143
144 struct symbol_cache_slot
145 {
146   enum symbol_cache_slot_state state;
147
148   /* The objfile that was current when the symbol was looked up.
149      This is only needed for global blocks, but for simplicity's sake
150      we allocate the space for both.  If data shows the extra space used
151      for static blocks is a problem, we can split things up then.
152
153      Global blocks need cache lookup to include the objfile context because
154      we need to account for gdbarch_iterate_over_objfiles_in_search_order
155      which can traverse objfiles in, effectively, any order, depending on
156      the current objfile, thus affecting which symbol is found.  Normally,
157      only the current objfile is searched first, and then the rest are
158      searched in recorded order; but putting cache lookup inside
159      gdbarch_iterate_over_objfiles_in_search_order would be awkward.
160      Instead we just make the current objfile part of the context of
161      cache lookup.  This means we can record the same symbol multiple times,
162      each with a different "current objfile" that was in effect when the
163      lookup was saved in the cache, but cache space is pretty cheap.  */
164   const struct objfile *objfile_context;
165
166   union
167   {
168     struct block_symbol found;
169     struct
170     {
171       char *name;
172       domain_enum domain;
173     } not_found;
174   } value;
175 };
176
177 /* Symbols don't specify global vs static block.
178    So keep them in separate caches.  */
179
180 struct block_symbol_cache
181 {
182   unsigned int hits;
183   unsigned int misses;
184   unsigned int collisions;
185
186   /* SYMBOLS is a variable length array of this size.
187      One can imagine that in general one cache (global/static) should be a
188      fraction of the size of the other, but there's no data at the moment
189      on which to decide.  */
190   unsigned int size;
191
192   struct symbol_cache_slot symbols[1];
193 };
194
195 /* The symbol cache.
196
197    Searching for symbols in the static and global blocks over multiple objfiles
198    again and again can be slow, as can searching very big objfiles.  This is a
199    simple cache to improve symbol lookup performance, which is critical to
200    overall gdb performance.
201
202    Symbols are hashed on the name, its domain, and block.
203    They are also hashed on their objfile for objfile-specific lookups.  */
204
205 struct symbol_cache
206 {
207   struct block_symbol_cache *global_symbols;
208   struct block_symbol_cache *static_symbols;
209 };
210
211 /* When non-zero, print debugging messages related to symtab creation.  */
212 unsigned int symtab_create_debug = 0;
213
214 /* When non-zero, print debugging messages related to symbol lookup.  */
215 unsigned int symbol_lookup_debug = 0;
216
217 /* The size of the cache is staged here.  */
218 static unsigned int new_symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
219
220 /* The current value of the symbol cache size.
221    This is saved so that if the user enters a value too big we can restore
222    the original value from here.  */
223 static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
224
225 /* Non-zero if a file may be known by two different basenames.
226    This is the uncommon case, and significantly slows down gdb.
227    Default set to "off" to not slow down the common case.  */
228 int basenames_may_differ = 0;
229
230 /* Allow the user to configure the debugger behavior with respect
231    to multiple-choice menus when more than one symbol matches during
232    a symbol lookup.  */
233
234 const char multiple_symbols_ask[] = "ask";
235 const char multiple_symbols_all[] = "all";
236 const char multiple_symbols_cancel[] = "cancel";
237 static const char *const multiple_symbols_modes[] =
238 {
239   multiple_symbols_ask,
240   multiple_symbols_all,
241   multiple_symbols_cancel,
242   NULL
243 };
244 static const char *multiple_symbols_mode = multiple_symbols_all;
245
246 /* Read-only accessor to AUTO_SELECT_MODE.  */
247
248 const char *
249 multiple_symbols_select_mode (void)
250 {
251   return multiple_symbols_mode;
252 }
253
254 /* Return the name of a domain_enum.  */
255
256 const char *
257 domain_name (domain_enum e)
258 {
259   switch (e)
260     {
261     case UNDEF_DOMAIN: return "UNDEF_DOMAIN";
262     case VAR_DOMAIN: return "VAR_DOMAIN";
263     case STRUCT_DOMAIN: return "STRUCT_DOMAIN";
264     case MODULE_DOMAIN: return "MODULE_DOMAIN";
265     case LABEL_DOMAIN: return "LABEL_DOMAIN";
266     case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN";
267     default: gdb_assert_not_reached ("bad domain_enum");
268     }
269 }
270
271 /* Return the name of a search_domain .  */
272
273 const char *
274 search_domain_name (enum search_domain e)
275 {
276   switch (e)
277     {
278     case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN";
279     case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN";
280     case TYPES_DOMAIN: return "TYPES_DOMAIN";
281     case ALL_DOMAIN: return "ALL_DOMAIN";
282     default: gdb_assert_not_reached ("bad search_domain");
283     }
284 }
285
286 /* See symtab.h.  */
287
288 struct symtab *
289 compunit_primary_filetab (const struct compunit_symtab *cust)
290 {
291   gdb_assert (COMPUNIT_FILETABS (cust) != NULL);
292
293   /* The primary file symtab is the first one in the list.  */
294   return COMPUNIT_FILETABS (cust);
295 }
296
297 /* See symtab.h.  */
298
299 enum language
300 compunit_language (const struct compunit_symtab *cust)
301 {
302   struct symtab *symtab = compunit_primary_filetab (cust);
303
304 /* The language of the compunit symtab is the language of its primary
305    source file.  */
306   return SYMTAB_LANGUAGE (symtab);
307 }
308
309 /* See whether FILENAME matches SEARCH_NAME using the rule that we
310    advertise to the user.  (The manual's description of linespecs
311    describes what we advertise).  Returns true if they match, false
312    otherwise.  */
313
314 int
315 compare_filenames_for_search (const char *filename, const char *search_name)
316 {
317   int len = strlen (filename);
318   size_t search_len = strlen (search_name);
319
320   if (len < search_len)
321     return 0;
322
323   /* The tail of FILENAME must match.  */
324   if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
325     return 0;
326
327   /* Either the names must completely match, or the character
328      preceding the trailing SEARCH_NAME segment of FILENAME must be a
329      directory separator.
330
331      The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
332      cannot match FILENAME "/path//dir/file.c" - as user has requested
333      absolute path.  The sama applies for "c:\file.c" possibly
334      incorrectly hypothetically matching "d:\dir\c:\file.c".
335
336      The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
337      compatible with SEARCH_NAME "file.c".  In such case a compiler had
338      to put the "c:file.c" name into debug info.  Such compatibility
339      works only on GDB built for DOS host.  */
340   return (len == search_len
341           || (!IS_ABSOLUTE_PATH (search_name)
342               && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
343           || (HAS_DRIVE_SPEC (filename)
344               && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
345 }
346
347 /* Same as compare_filenames_for_search, but for glob-style patterns.
348    Heads up on the order of the arguments.  They match the order of
349    compare_filenames_for_search, but it's the opposite of the order of
350    arguments to gdb_filename_fnmatch.  */
351
352 int
353 compare_glob_filenames_for_search (const char *filename,
354                                    const char *search_name)
355 {
356   /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
357      all /s have to be explicitly specified.  */
358   int file_path_elements = count_path_elements (filename);
359   int search_path_elements = count_path_elements (search_name);
360
361   if (search_path_elements > file_path_elements)
362     return 0;
363
364   if (IS_ABSOLUTE_PATH (search_name))
365     {
366       return (search_path_elements == file_path_elements
367               && gdb_filename_fnmatch (search_name, filename,
368                                        FNM_FILE_NAME | FNM_NOESCAPE) == 0);
369     }
370
371   {
372     const char *file_to_compare
373       = strip_leading_path_elements (filename,
374                                      file_path_elements - search_path_elements);
375
376     return gdb_filename_fnmatch (search_name, file_to_compare,
377                                  FNM_FILE_NAME | FNM_NOESCAPE) == 0;
378   }
379 }
380
381 /* Check for a symtab of a specific name by searching some symtabs.
382    This is a helper function for callbacks of iterate_over_symtabs.
383
384    If NAME is not absolute, then REAL_PATH is NULL
385    If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
386
387    The return value, NAME, REAL_PATH and CALLBACK are identical to the
388    `map_symtabs_matching_filename' method of quick_symbol_functions.
389
390    FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
391    Each symtab within the specified compunit symtab is also searched.
392    AFTER_LAST is one past the last compunit symtab to search; NULL means to
393    search until the end of the list.  */
394
395 bool
396 iterate_over_some_symtabs (const char *name,
397                            const char *real_path,
398                            struct compunit_symtab *first,
399                            struct compunit_symtab *after_last,
400                            gdb::function_view<bool (symtab *)> callback)
401 {
402   struct compunit_symtab *cust;
403   struct symtab *s;
404   const char* base_name = lbasename (name);
405
406   for (cust = first; cust != NULL && cust != after_last; cust = cust->next)
407     {
408       ALL_COMPUNIT_FILETABS (cust, s)
409         {
410           if (compare_filenames_for_search (s->filename, name))
411             {
412               if (callback (s))
413                 return true;
414               continue;
415             }
416
417           /* Before we invoke realpath, which can get expensive when many
418              files are involved, do a quick comparison of the basenames.  */
419           if (! basenames_may_differ
420               && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
421             continue;
422
423           if (compare_filenames_for_search (symtab_to_fullname (s), name))
424             {
425               if (callback (s))
426                 return true;
427               continue;
428             }
429
430           /* If the user gave us an absolute path, try to find the file in
431              this symtab and use its absolute path.  */
432           if (real_path != NULL)
433             {
434               const char *fullname = symtab_to_fullname (s);
435
436               gdb_assert (IS_ABSOLUTE_PATH (real_path));
437               gdb_assert (IS_ABSOLUTE_PATH (name));
438               if (FILENAME_CMP (real_path, fullname) == 0)
439                 {
440                   if (callback (s))
441                     return true;
442                   continue;
443                 }
444             }
445         }
446     }
447
448   return false;
449 }
450
451 /* Check for a symtab of a specific name; first in symtabs, then in
452    psymtabs.  *If* there is no '/' in the name, a match after a '/'
453    in the symtab filename will also work.
454
455    Calls CALLBACK with each symtab that is found.  If CALLBACK returns
456    true, the search stops.  */
457
458 void
459 iterate_over_symtabs (const char *name,
460                       gdb::function_view<bool (symtab *)> callback)
461 {
462   struct objfile *objfile;
463   gdb::unique_xmalloc_ptr<char> real_path;
464
465   /* Here we are interested in canonicalizing an absolute path, not
466      absolutizing a relative path.  */
467   if (IS_ABSOLUTE_PATH (name))
468     {
469       real_path = gdb_realpath (name);
470       gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
471     }
472
473   ALL_OBJFILES (objfile)
474     {
475       if (iterate_over_some_symtabs (name, real_path.get (),
476                                      objfile->compunit_symtabs, NULL,
477                                      callback))
478         return;
479     }
480
481   /* Same search rules as above apply here, but now we look thru the
482      psymtabs.  */
483
484   ALL_OBJFILES (objfile)
485     {
486       if (objfile->sf
487           && objfile->sf->qf->map_symtabs_matching_filename (objfile,
488                                                              name,
489                                                              real_path.get (),
490                                                              callback))
491         return;
492     }
493 }
494
495 /* A wrapper for iterate_over_symtabs that returns the first matching
496    symtab, or NULL.  */
497
498 struct symtab *
499 lookup_symtab (const char *name)
500 {
501   struct symtab *result = NULL;
502
503   iterate_over_symtabs (name, [&] (symtab *symtab)
504     {
505       result = symtab;
506       return true;
507     });
508
509   return result;
510 }
511
512 \f
513 /* Mangle a GDB method stub type.  This actually reassembles the pieces of the
514    full method name, which consist of the class name (from T), the unadorned
515    method name from METHOD_ID, and the signature for the specific overload,
516    specified by SIGNATURE_ID.  Note that this function is g++ specific.  */
517
518 char *
519 gdb_mangle_name (struct type *type, int method_id, int signature_id)
520 {
521   int mangled_name_len;
522   char *mangled_name;
523   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
524   struct fn_field *method = &f[signature_id];
525   const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
526   const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
527   const char *newname = type_name_no_tag (type);
528
529   /* Does the form of physname indicate that it is the full mangled name
530      of a constructor (not just the args)?  */
531   int is_full_physname_constructor;
532
533   int is_constructor;
534   int is_destructor = is_destructor_name (physname);
535   /* Need a new type prefix.  */
536   const char *const_prefix = method->is_const ? "C" : "";
537   const char *volatile_prefix = method->is_volatile ? "V" : "";
538   char buf[20];
539   int len = (newname == NULL ? 0 : strlen (newname));
540
541   /* Nothing to do if physname already contains a fully mangled v3 abi name
542      or an operator name.  */
543   if ((physname[0] == '_' && physname[1] == 'Z')
544       || is_operator_name (field_name))
545     return xstrdup (physname);
546
547   is_full_physname_constructor = is_constructor_name (physname);
548
549   is_constructor = is_full_physname_constructor 
550     || (newname && strcmp (field_name, newname) == 0);
551
552   if (!is_destructor)
553     is_destructor = (startswith (physname, "__dt"));
554
555   if (is_destructor || is_full_physname_constructor)
556     {
557       mangled_name = (char *) xmalloc (strlen (physname) + 1);
558       strcpy (mangled_name, physname);
559       return mangled_name;
560     }
561
562   if (len == 0)
563     {
564       xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
565     }
566   else if (physname[0] == 't' || physname[0] == 'Q')
567     {
568       /* The physname for template and qualified methods already includes
569          the class name.  */
570       xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
571       newname = NULL;
572       len = 0;
573     }
574   else
575     {
576       xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
577                  volatile_prefix, len);
578     }
579   mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
580                       + strlen (buf) + len + strlen (physname) + 1);
581
582   mangled_name = (char *) xmalloc (mangled_name_len);
583   if (is_constructor)
584     mangled_name[0] = '\0';
585   else
586     strcpy (mangled_name, field_name);
587
588   strcat (mangled_name, buf);
589   /* If the class doesn't have a name, i.e. newname NULL, then we just
590      mangle it using 0 for the length of the class.  Thus it gets mangled
591      as something starting with `::' rather than `classname::'.  */
592   if (newname != NULL)
593     strcat (mangled_name, newname);
594
595   strcat (mangled_name, physname);
596   return (mangled_name);
597 }
598
599 /* Set the demangled name of GSYMBOL to NAME.  NAME must be already
600    correctly allocated.  */
601
602 void
603 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
604                            const char *name,
605                            struct obstack *obstack)
606 {
607   if (gsymbol->language == language_ada)
608     {
609       if (name == NULL)
610         {
611           gsymbol->ada_mangled = 0;
612           gsymbol->language_specific.obstack = obstack;
613         }
614       else
615         {
616           gsymbol->ada_mangled = 1;
617           gsymbol->language_specific.demangled_name = name;
618         }
619     }
620   else
621     gsymbol->language_specific.demangled_name = name;
622 }
623
624 /* Return the demangled name of GSYMBOL.  */
625
626 const char *
627 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
628 {
629   if (gsymbol->language == language_ada)
630     {
631       if (!gsymbol->ada_mangled)
632         return NULL;
633       /* Fall through.  */
634     }
635
636   return gsymbol->language_specific.demangled_name;
637 }
638
639 \f
640 /* Initialize the language dependent portion of a symbol
641    depending upon the language for the symbol.  */
642
643 void
644 symbol_set_language (struct general_symbol_info *gsymbol,
645                      enum language language,
646                      struct obstack *obstack)
647 {
648   gsymbol->language = language;
649   if (gsymbol->language == language_cplus
650       || gsymbol->language == language_d
651       || gsymbol->language == language_go
652       || gsymbol->language == language_objc
653       || gsymbol->language == language_fortran)
654     {
655       symbol_set_demangled_name (gsymbol, NULL, obstack);
656     }
657   else if (gsymbol->language == language_ada)
658     {
659       gdb_assert (gsymbol->ada_mangled == 0);
660       gsymbol->language_specific.obstack = obstack;
661     }
662   else
663     {
664       memset (&gsymbol->language_specific, 0,
665               sizeof (gsymbol->language_specific));
666     }
667 }
668
669 /* Functions to initialize a symbol's mangled name.  */
670
671 /* Objects of this type are stored in the demangled name hash table.  */
672 struct demangled_name_entry
673 {
674   const char *mangled;
675   char demangled[1];
676 };
677
678 /* Hash function for the demangled name hash.  */
679
680 static hashval_t
681 hash_demangled_name_entry (const void *data)
682 {
683   const struct demangled_name_entry *e
684     = (const struct demangled_name_entry *) data;
685
686   return htab_hash_string (e->mangled);
687 }
688
689 /* Equality function for the demangled name hash.  */
690
691 static int
692 eq_demangled_name_entry (const void *a, const void *b)
693 {
694   const struct demangled_name_entry *da
695     = (const struct demangled_name_entry *) a;
696   const struct demangled_name_entry *db
697     = (const struct demangled_name_entry *) b;
698
699   return strcmp (da->mangled, db->mangled) == 0;
700 }
701
702 /* Create the hash table used for demangled names.  Each hash entry is
703    a pair of strings; one for the mangled name and one for the demangled
704    name.  The entry is hashed via just the mangled name.  */
705
706 static void
707 create_demangled_names_hash (struct objfile *objfile)
708 {
709   /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
710      The hash table code will round this up to the next prime number.
711      Choosing a much larger table size wastes memory, and saves only about
712      1% in symbol reading.  */
713
714   objfile->per_bfd->demangled_names_hash = htab_create_alloc
715     (256, hash_demangled_name_entry, eq_demangled_name_entry,
716      NULL, xcalloc, xfree);
717 }
718
719 /* Try to determine the demangled name for a symbol, based on the
720    language of that symbol.  If the language is set to language_auto,
721    it will attempt to find any demangling algorithm that works and
722    then set the language appropriately.  The returned name is allocated
723    by the demangler and should be xfree'd.  */
724
725 static char *
726 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
727                             const char *mangled)
728 {
729   char *demangled = NULL;
730   int i;
731   int recognized;
732
733   if (gsymbol->language == language_unknown)
734     gsymbol->language = language_auto;
735
736   if (gsymbol->language != language_auto)
737     {
738       const struct language_defn *lang = language_def (gsymbol->language);
739
740       language_sniff_from_mangled_name (lang, mangled, &demangled);
741       return demangled;
742     }
743
744   for (i = language_unknown; i < nr_languages; ++i)
745     {
746       enum language l = (enum language) i;
747       const struct language_defn *lang = language_def (l);
748
749       if (language_sniff_from_mangled_name (lang, mangled, &demangled))
750         {
751           gsymbol->language = l;
752           return demangled;
753         }
754     }
755
756   return NULL;
757 }
758
759 /* Set both the mangled and demangled (if any) names for GSYMBOL based
760    on LINKAGE_NAME and LEN.  Ordinarily, NAME is copied onto the
761    objfile's obstack; but if COPY_NAME is 0 and if NAME is
762    NUL-terminated, then this function assumes that NAME is already
763    correctly saved (either permanently or with a lifetime tied to the
764    objfile), and it will not be copied.
765
766    The hash table corresponding to OBJFILE is used, and the memory
767    comes from the per-BFD storage_obstack.  LINKAGE_NAME is copied,
768    so the pointer can be discarded after calling this function.  */
769
770 void
771 symbol_set_names (struct general_symbol_info *gsymbol,
772                   const char *linkage_name, int len, int copy_name,
773                   struct objfile *objfile)
774 {
775   struct demangled_name_entry **slot;
776   /* A 0-terminated copy of the linkage name.  */
777   const char *linkage_name_copy;
778   struct demangled_name_entry entry;
779   struct objfile_per_bfd_storage *per_bfd = objfile->per_bfd;
780
781   if (gsymbol->language == language_ada)
782     {
783       /* In Ada, we do the symbol lookups using the mangled name, so
784          we can save some space by not storing the demangled name.  */
785       if (!copy_name)
786         gsymbol->name = linkage_name;
787       else
788         {
789           char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,
790                                                len + 1);
791
792           memcpy (name, linkage_name, len);
793           name[len] = '\0';
794           gsymbol->name = name;
795         }
796       symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
797
798       return;
799     }
800
801   if (per_bfd->demangled_names_hash == NULL)
802     create_demangled_names_hash (objfile);
803
804   if (linkage_name[len] != '\0')
805     {
806       char *alloc_name;
807
808       alloc_name = (char *) alloca (len + 1);
809       memcpy (alloc_name, linkage_name, len);
810       alloc_name[len] = '\0';
811
812       linkage_name_copy = alloc_name;
813     }
814   else
815     linkage_name_copy = linkage_name;
816
817   entry.mangled = linkage_name_copy;
818   slot = ((struct demangled_name_entry **)
819           htab_find_slot (per_bfd->demangled_names_hash,
820                           &entry, INSERT));
821
822   /* If this name is not in the hash table, add it.  */
823   if (*slot == NULL
824       /* A C version of the symbol may have already snuck into the table.
825          This happens to, e.g., main.init (__go_init_main).  Cope.  */
826       || (gsymbol->language == language_go
827           && (*slot)->demangled[0] == '\0'))
828     {
829       char *demangled_name = symbol_find_demangled_name (gsymbol,
830                                                          linkage_name_copy);
831       int demangled_len = demangled_name ? strlen (demangled_name) : 0;
832
833       /* Suppose we have demangled_name==NULL, copy_name==0, and
834          linkage_name_copy==linkage_name.  In this case, we already have the
835          mangled name saved, and we don't have a demangled name.  So,
836          you might think we could save a little space by not recording
837          this in the hash table at all.
838          
839          It turns out that it is actually important to still save such
840          an entry in the hash table, because storing this name gives
841          us better bcache hit rates for partial symbols.  */
842       if (!copy_name && linkage_name_copy == linkage_name)
843         {
844           *slot
845             = ((struct demangled_name_entry *)
846                obstack_alloc (&per_bfd->storage_obstack,
847                               offsetof (struct demangled_name_entry, demangled)
848                               + demangled_len + 1));
849           (*slot)->mangled = linkage_name;
850         }
851       else
852         {
853           char *mangled_ptr;
854
855           /* If we must copy the mangled name, put it directly after
856              the demangled name so we can have a single
857              allocation.  */
858           *slot
859             = ((struct demangled_name_entry *)
860                obstack_alloc (&per_bfd->storage_obstack,
861                               offsetof (struct demangled_name_entry, demangled)
862                               + len + demangled_len + 2));
863           mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
864           strcpy (mangled_ptr, linkage_name_copy);
865           (*slot)->mangled = mangled_ptr;
866         }
867
868       if (demangled_name != NULL)
869         {
870           strcpy ((*slot)->demangled, demangled_name);
871           xfree (demangled_name);
872         }
873       else
874         (*slot)->demangled[0] = '\0';
875     }
876
877   gsymbol->name = (*slot)->mangled;
878   if ((*slot)->demangled[0] != '\0')
879     symbol_set_demangled_name (gsymbol, (*slot)->demangled,
880                                &per_bfd->storage_obstack);
881   else
882     symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
883 }
884
885 /* Return the source code name of a symbol.  In languages where
886    demangling is necessary, this is the demangled name.  */
887
888 const char *
889 symbol_natural_name (const struct general_symbol_info *gsymbol)
890 {
891   switch (gsymbol->language)
892     {
893     case language_cplus:
894     case language_d:
895     case language_go:
896     case language_objc:
897     case language_fortran:
898       if (symbol_get_demangled_name (gsymbol) != NULL)
899         return symbol_get_demangled_name (gsymbol);
900       break;
901     case language_ada:
902       return ada_decode_symbol (gsymbol);
903     default:
904       break;
905     }
906   return gsymbol->name;
907 }
908
909 /* Return the demangled name for a symbol based on the language for
910    that symbol.  If no demangled name exists, return NULL.  */
911
912 const char *
913 symbol_demangled_name (const struct general_symbol_info *gsymbol)
914 {
915   const char *dem_name = NULL;
916
917   switch (gsymbol->language)
918     {
919     case language_cplus:
920     case language_d:
921     case language_go:
922     case language_objc:
923     case language_fortran:
924       dem_name = symbol_get_demangled_name (gsymbol);
925       break;
926     case language_ada:
927       dem_name = ada_decode_symbol (gsymbol);
928       break;
929     default:
930       break;
931     }
932   return dem_name;
933 }
934
935 /* Return the search name of a symbol---generally the demangled or
936    linkage name of the symbol, depending on how it will be searched for.
937    If there is no distinct demangled name, then returns the same value
938    (same pointer) as SYMBOL_LINKAGE_NAME.  */
939
940 const char *
941 symbol_search_name (const struct general_symbol_info *gsymbol)
942 {
943   if (gsymbol->language == language_ada)
944     return gsymbol->name;
945   else
946     return symbol_natural_name (gsymbol);
947 }
948 \f
949
950 /* Return 1 if the two sections are the same, or if they could
951    plausibly be copies of each other, one in an original object
952    file and another in a separated debug file.  */
953
954 int
955 matching_obj_sections (struct obj_section *obj_first,
956                        struct obj_section *obj_second)
957 {
958   asection *first = obj_first? obj_first->the_bfd_section : NULL;
959   asection *second = obj_second? obj_second->the_bfd_section : NULL;
960   struct objfile *obj;
961
962   /* If they're the same section, then they match.  */
963   if (first == second)
964     return 1;
965
966   /* If either is NULL, give up.  */
967   if (first == NULL || second == NULL)
968     return 0;
969
970   /* This doesn't apply to absolute symbols.  */
971   if (first->owner == NULL || second->owner == NULL)
972     return 0;
973
974   /* If they're in the same object file, they must be different sections.  */
975   if (first->owner == second->owner)
976     return 0;
977
978   /* Check whether the two sections are potentially corresponding.  They must
979      have the same size, address, and name.  We can't compare section indexes,
980      which would be more reliable, because some sections may have been
981      stripped.  */
982   if (bfd_get_section_size (first) != bfd_get_section_size (second))
983     return 0;
984
985   /* In-memory addresses may start at a different offset, relativize them.  */
986   if (bfd_get_section_vma (first->owner, first)
987       - bfd_get_start_address (first->owner)
988       != bfd_get_section_vma (second->owner, second)
989          - bfd_get_start_address (second->owner))
990     return 0;
991
992   if (bfd_get_section_name (first->owner, first) == NULL
993       || bfd_get_section_name (second->owner, second) == NULL
994       || strcmp (bfd_get_section_name (first->owner, first),
995                  bfd_get_section_name (second->owner, second)) != 0)
996     return 0;
997
998   /* Otherwise check that they are in corresponding objfiles.  */
999
1000   ALL_OBJFILES (obj)
1001     if (obj->obfd == first->owner)
1002       break;
1003   gdb_assert (obj != NULL);
1004
1005   if (obj->separate_debug_objfile != NULL
1006       && obj->separate_debug_objfile->obfd == second->owner)
1007     return 1;
1008   if (obj->separate_debug_objfile_backlink != NULL
1009       && obj->separate_debug_objfile_backlink->obfd == second->owner)
1010     return 1;
1011
1012   return 0;
1013 }
1014
1015 /* See symtab.h.  */
1016
1017 void
1018 expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
1019 {
1020   struct objfile *objfile;
1021   struct bound_minimal_symbol msymbol;
1022
1023   /* If we know that this is not a text address, return failure.  This is
1024      necessary because we loop based on texthigh and textlow, which do
1025      not include the data ranges.  */
1026   msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1027   if (msymbol.minsym
1028       && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
1029           || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
1030           || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
1031           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
1032           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
1033     return;
1034
1035   ALL_OBJFILES (objfile)
1036   {
1037     struct compunit_symtab *cust = NULL;
1038
1039     if (objfile->sf)
1040       cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
1041                                                             pc, section, 0);
1042     if (cust)
1043       return;
1044   }
1045 }
1046 \f
1047 /* Hash function for the symbol cache.  */
1048
1049 static unsigned int
1050 hash_symbol_entry (const struct objfile *objfile_context,
1051                    const char *name, domain_enum domain)
1052 {
1053   unsigned int hash = (uintptr_t) objfile_context;
1054
1055   if (name != NULL)
1056     hash += htab_hash_string (name);
1057
1058   /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1059      to map to the same slot.  */
1060   if (domain == STRUCT_DOMAIN)
1061     hash += VAR_DOMAIN * 7;
1062   else
1063     hash += domain * 7;
1064
1065   return hash;
1066 }
1067
1068 /* Equality function for the symbol cache.  */
1069
1070 static int
1071 eq_symbol_entry (const struct symbol_cache_slot *slot,
1072                  const struct objfile *objfile_context,
1073                  const char *name, domain_enum domain)
1074 {
1075   const char *slot_name;
1076   domain_enum slot_domain;
1077
1078   if (slot->state == SYMBOL_SLOT_UNUSED)
1079     return 0;
1080
1081   if (slot->objfile_context != objfile_context)
1082     return 0;
1083
1084   if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1085     {
1086       slot_name = slot->value.not_found.name;
1087       slot_domain = slot->value.not_found.domain;
1088     }
1089   else
1090     {
1091       slot_name = SYMBOL_SEARCH_NAME (slot->value.found.symbol);
1092       slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol);
1093     }
1094
1095   /* NULL names match.  */
1096   if (slot_name == NULL && name == NULL)
1097     {
1098       /* But there's no point in calling symbol_matches_domain in the
1099          SYMBOL_SLOT_FOUND case.  */
1100       if (slot_domain != domain)
1101         return 0;
1102     }
1103   else if (slot_name != NULL && name != NULL)
1104     {
1105       /* It's important that we use the same comparison that was done the
1106          first time through.  If the slot records a found symbol, then this
1107          means using strcmp_iw on SYMBOL_SEARCH_NAME.  See dictionary.c.
1108          It also means using symbol_matches_domain for found symbols.
1109          See block.c.
1110
1111          If the slot records a not-found symbol, then require a precise match.
1112          We could still be lax with whitespace like strcmp_iw though.  */
1113
1114       if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1115         {
1116           if (strcmp (slot_name, name) != 0)
1117             return 0;
1118           if (slot_domain != domain)
1119             return 0;
1120         }
1121       else
1122         {
1123           struct symbol *sym = slot->value.found.symbol;
1124
1125           if (strcmp_iw (slot_name, name) != 0)
1126             return 0;
1127           if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1128                                       slot_domain, domain))
1129             return 0;
1130         }
1131     }
1132   else
1133     {
1134       /* Only one name is NULL.  */
1135       return 0;
1136     }
1137
1138   return 1;
1139 }
1140
1141 /* Given a cache of size SIZE, return the size of the struct (with variable
1142    length array) in bytes.  */
1143
1144 static size_t
1145 symbol_cache_byte_size (unsigned int size)
1146 {
1147   return (sizeof (struct block_symbol_cache)
1148           + ((size - 1) * sizeof (struct symbol_cache_slot)));
1149 }
1150
1151 /* Resize CACHE.  */
1152
1153 static void
1154 resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size)
1155 {
1156   /* If there's no change in size, don't do anything.
1157      All caches have the same size, so we can just compare with the size
1158      of the global symbols cache.  */
1159   if ((cache->global_symbols != NULL
1160        && cache->global_symbols->size == new_size)
1161       || (cache->global_symbols == NULL
1162           && new_size == 0))
1163     return;
1164
1165   xfree (cache->global_symbols);
1166   xfree (cache->static_symbols);
1167
1168   if (new_size == 0)
1169     {
1170       cache->global_symbols = NULL;
1171       cache->static_symbols = NULL;
1172     }
1173   else
1174     {
1175       size_t total_size = symbol_cache_byte_size (new_size);
1176
1177       cache->global_symbols
1178         = (struct block_symbol_cache *) xcalloc (1, total_size);
1179       cache->static_symbols
1180         = (struct block_symbol_cache *) xcalloc (1, total_size);
1181       cache->global_symbols->size = new_size;
1182       cache->static_symbols->size = new_size;
1183     }
1184 }
1185
1186 /* Make a symbol cache of size SIZE.  */
1187
1188 static struct symbol_cache *
1189 make_symbol_cache (unsigned int size)
1190 {
1191   struct symbol_cache *cache;
1192
1193   cache = XCNEW (struct symbol_cache);
1194   resize_symbol_cache (cache, symbol_cache_size);
1195   return cache;
1196 }
1197
1198 /* Free the space used by CACHE.  */
1199
1200 static void
1201 free_symbol_cache (struct symbol_cache *cache)
1202 {
1203   xfree (cache->global_symbols);
1204   xfree (cache->static_symbols);
1205   xfree (cache);
1206 }
1207
1208 /* Return the symbol cache of PSPACE.
1209    Create one if it doesn't exist yet.  */
1210
1211 static struct symbol_cache *
1212 get_symbol_cache (struct program_space *pspace)
1213 {
1214   struct symbol_cache *cache
1215     = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1216
1217   if (cache == NULL)
1218     {
1219       cache = make_symbol_cache (symbol_cache_size);
1220       set_program_space_data (pspace, symbol_cache_key, cache);
1221     }
1222
1223   return cache;
1224 }
1225
1226 /* Delete the symbol cache of PSPACE.
1227    Called when PSPACE is destroyed.  */
1228
1229 static void
1230 symbol_cache_cleanup (struct program_space *pspace, void *data)
1231 {
1232   struct symbol_cache *cache = (struct symbol_cache *) data;
1233
1234   free_symbol_cache (cache);
1235 }
1236
1237 /* Set the size of the symbol cache in all program spaces.  */
1238
1239 static void
1240 set_symbol_cache_size (unsigned int new_size)
1241 {
1242   struct program_space *pspace;
1243
1244   ALL_PSPACES (pspace)
1245     {
1246       struct symbol_cache *cache
1247         = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1248
1249       /* The pspace could have been created but not have a cache yet.  */
1250       if (cache != NULL)
1251         resize_symbol_cache (cache, new_size);
1252     }
1253 }
1254
1255 /* Called when symbol-cache-size is set.  */
1256
1257 static void
1258 set_symbol_cache_size_handler (char *args, int from_tty,
1259                                struct cmd_list_element *c)
1260 {
1261   if (new_symbol_cache_size > MAX_SYMBOL_CACHE_SIZE)
1262     {
1263       /* Restore the previous value.
1264          This is the value the "show" command prints.  */
1265       new_symbol_cache_size = symbol_cache_size;
1266
1267       error (_("Symbol cache size is too large, max is %u."),
1268              MAX_SYMBOL_CACHE_SIZE);
1269     }
1270   symbol_cache_size = new_symbol_cache_size;
1271
1272   set_symbol_cache_size (symbol_cache_size);
1273 }
1274
1275 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1276    OBJFILE_CONTEXT is the current objfile, which may be NULL.
1277    The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1278    failed (and thus this one will too), or NULL if the symbol is not present
1279    in the cache.
1280    If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
1281    set to the cache and slot of the symbol to save the result of a full lookup
1282    attempt.  */
1283
1284 static struct block_symbol
1285 symbol_cache_lookup (struct symbol_cache *cache,
1286                      struct objfile *objfile_context, int block,
1287                      const char *name, domain_enum domain,
1288                      struct block_symbol_cache **bsc_ptr,
1289                      struct symbol_cache_slot **slot_ptr)
1290 {
1291   struct block_symbol_cache *bsc;
1292   unsigned int hash;
1293   struct symbol_cache_slot *slot;
1294
1295   if (block == GLOBAL_BLOCK)
1296     bsc = cache->global_symbols;
1297   else
1298     bsc = cache->static_symbols;
1299   if (bsc == NULL)
1300     {
1301       *bsc_ptr = NULL;
1302       *slot_ptr = NULL;
1303       return (struct block_symbol) {NULL, NULL};
1304     }
1305
1306   hash = hash_symbol_entry (objfile_context, name, domain);
1307   slot = bsc->symbols + hash % bsc->size;
1308
1309   if (eq_symbol_entry (slot, objfile_context, name, domain))
1310     {
1311       if (symbol_lookup_debug)
1312         fprintf_unfiltered (gdb_stdlog,
1313                             "%s block symbol cache hit%s for %s, %s\n",
1314                             block == GLOBAL_BLOCK ? "Global" : "Static",
1315                             slot->state == SYMBOL_SLOT_NOT_FOUND
1316                             ? " (not found)" : "",
1317                             name, domain_name (domain));
1318       ++bsc->hits;
1319       if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1320         return SYMBOL_LOOKUP_FAILED;
1321       return slot->value.found;
1322     }
1323
1324   /* Symbol is not present in the cache.  */
1325
1326   *bsc_ptr = bsc;
1327   *slot_ptr = slot;
1328
1329   if (symbol_lookup_debug)
1330     {
1331       fprintf_unfiltered (gdb_stdlog,
1332                           "%s block symbol cache miss for %s, %s\n",
1333                           block == GLOBAL_BLOCK ? "Global" : "Static",
1334                           name, domain_name (domain));
1335     }
1336   ++bsc->misses;
1337   return (struct block_symbol) {NULL, NULL};
1338 }
1339
1340 /* Clear out SLOT.  */
1341
1342 static void
1343 symbol_cache_clear_slot (struct symbol_cache_slot *slot)
1344 {
1345   if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1346     xfree (slot->value.not_found.name);
1347   slot->state = SYMBOL_SLOT_UNUSED;
1348 }
1349
1350 /* Mark SYMBOL as found in SLOT.
1351    OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1352    if it's not needed to distinguish lookups (STATIC_BLOCK).  It is *not*
1353    necessarily the objfile the symbol was found in.  */
1354
1355 static void
1356 symbol_cache_mark_found (struct block_symbol_cache *bsc,
1357                          struct symbol_cache_slot *slot,
1358                          struct objfile *objfile_context,
1359                          struct symbol *symbol,
1360                          const struct block *block)
1361 {
1362   if (bsc == NULL)
1363     return;
1364   if (slot->state != SYMBOL_SLOT_UNUSED)
1365     {
1366       ++bsc->collisions;
1367       symbol_cache_clear_slot (slot);
1368     }
1369   slot->state = SYMBOL_SLOT_FOUND;
1370   slot->objfile_context = objfile_context;
1371   slot->value.found.symbol = symbol;
1372   slot->value.found.block = block;
1373 }
1374
1375 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1376    OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1377    if it's not needed to distinguish lookups (STATIC_BLOCK).  */
1378
1379 static void
1380 symbol_cache_mark_not_found (struct block_symbol_cache *bsc,
1381                              struct symbol_cache_slot *slot,
1382                              struct objfile *objfile_context,
1383                              const char *name, domain_enum domain)
1384 {
1385   if (bsc == NULL)
1386     return;
1387   if (slot->state != SYMBOL_SLOT_UNUSED)
1388     {
1389       ++bsc->collisions;
1390       symbol_cache_clear_slot (slot);
1391     }
1392   slot->state = SYMBOL_SLOT_NOT_FOUND;
1393   slot->objfile_context = objfile_context;
1394   slot->value.not_found.name = xstrdup (name);
1395   slot->value.not_found.domain = domain;
1396 }
1397
1398 /* Flush the symbol cache of PSPACE.  */
1399
1400 static void
1401 symbol_cache_flush (struct program_space *pspace)
1402 {
1403   struct symbol_cache *cache
1404     = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1405   int pass;
1406
1407   if (cache == NULL)
1408     return;
1409   if (cache->global_symbols == NULL)
1410     {
1411       gdb_assert (symbol_cache_size == 0);
1412       gdb_assert (cache->static_symbols == NULL);
1413       return;
1414     }
1415
1416   /* If the cache is untouched since the last flush, early exit.
1417      This is important for performance during the startup of a program linked
1418      with 100s (or 1000s) of shared libraries.  */
1419   if (cache->global_symbols->misses == 0
1420       && cache->static_symbols->misses == 0)
1421     return;
1422
1423   gdb_assert (cache->global_symbols->size == symbol_cache_size);
1424   gdb_assert (cache->static_symbols->size == symbol_cache_size);
1425
1426   for (pass = 0; pass < 2; ++pass)
1427     {
1428       struct block_symbol_cache *bsc
1429         = pass == 0 ? cache->global_symbols : cache->static_symbols;
1430       unsigned int i;
1431
1432       for (i = 0; i < bsc->size; ++i)
1433         symbol_cache_clear_slot (&bsc->symbols[i]);
1434     }
1435
1436   cache->global_symbols->hits = 0;
1437   cache->global_symbols->misses = 0;
1438   cache->global_symbols->collisions = 0;
1439   cache->static_symbols->hits = 0;
1440   cache->static_symbols->misses = 0;
1441   cache->static_symbols->collisions = 0;
1442 }
1443
1444 /* Dump CACHE.  */
1445
1446 static void
1447 symbol_cache_dump (const struct symbol_cache *cache)
1448 {
1449   int pass;
1450
1451   if (cache->global_symbols == NULL)
1452     {
1453       printf_filtered ("  <disabled>\n");
1454       return;
1455     }
1456
1457   for (pass = 0; pass < 2; ++pass)
1458     {
1459       const struct block_symbol_cache *bsc
1460         = pass == 0 ? cache->global_symbols : cache->static_symbols;
1461       unsigned int i;
1462
1463       if (pass == 0)
1464         printf_filtered ("Global symbols:\n");
1465       else
1466         printf_filtered ("Static symbols:\n");
1467
1468       for (i = 0; i < bsc->size; ++i)
1469         {
1470           const struct symbol_cache_slot *slot = &bsc->symbols[i];
1471
1472           QUIT;
1473
1474           switch (slot->state)
1475             {
1476             case SYMBOL_SLOT_UNUSED:
1477               break;
1478             case SYMBOL_SLOT_NOT_FOUND:
1479               printf_filtered ("  [%4u] = %s, %s %s (not found)\n", i,
1480                                host_address_to_string (slot->objfile_context),
1481                                slot->value.not_found.name,
1482                                domain_name (slot->value.not_found.domain));
1483               break;
1484             case SYMBOL_SLOT_FOUND:
1485               {
1486                 struct symbol *found = slot->value.found.symbol;
1487                 const struct objfile *context = slot->objfile_context;
1488
1489                 printf_filtered ("  [%4u] = %s, %s %s\n", i,
1490                                  host_address_to_string (context),
1491                                  SYMBOL_PRINT_NAME (found),
1492                                  domain_name (SYMBOL_DOMAIN (found)));
1493                 break;
1494               }
1495             }
1496         }
1497     }
1498 }
1499
1500 /* The "mt print symbol-cache" command.  */
1501
1502 static void
1503 maintenance_print_symbol_cache (char *args, int from_tty)
1504 {
1505   struct program_space *pspace;
1506
1507   ALL_PSPACES (pspace)
1508     {
1509       struct symbol_cache *cache;
1510
1511       printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1512                        pspace->num,
1513                        pspace->symfile_object_file != NULL
1514                        ? objfile_name (pspace->symfile_object_file)
1515                        : "(no object file)");
1516
1517       /* If the cache hasn't been created yet, avoid creating one.  */
1518       cache
1519         = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1520       if (cache == NULL)
1521         printf_filtered ("  <empty>\n");
1522       else
1523         symbol_cache_dump (cache);
1524     }
1525 }
1526
1527 /* The "mt flush-symbol-cache" command.  */
1528
1529 static void
1530 maintenance_flush_symbol_cache (char *args, int from_tty)
1531 {
1532   struct program_space *pspace;
1533
1534   ALL_PSPACES (pspace)
1535     {
1536       symbol_cache_flush (pspace);
1537     }
1538 }
1539
1540 /* Print usage statistics of CACHE.  */
1541
1542 static void
1543 symbol_cache_stats (struct symbol_cache *cache)
1544 {
1545   int pass;
1546
1547   if (cache->global_symbols == NULL)
1548     {
1549       printf_filtered ("  <disabled>\n");
1550       return;
1551     }
1552
1553   for (pass = 0; pass < 2; ++pass)
1554     {
1555       const struct block_symbol_cache *bsc
1556         = pass == 0 ? cache->global_symbols : cache->static_symbols;
1557
1558       QUIT;
1559
1560       if (pass == 0)
1561         printf_filtered ("Global block cache stats:\n");
1562       else
1563         printf_filtered ("Static block cache stats:\n");
1564
1565       printf_filtered ("  size:       %u\n", bsc->size);
1566       printf_filtered ("  hits:       %u\n", bsc->hits);
1567       printf_filtered ("  misses:     %u\n", bsc->misses);
1568       printf_filtered ("  collisions: %u\n", bsc->collisions);
1569     }
1570 }
1571
1572 /* The "mt print symbol-cache-statistics" command.  */
1573
1574 static void
1575 maintenance_print_symbol_cache_statistics (char *args, int from_tty)
1576 {
1577   struct program_space *pspace;
1578
1579   ALL_PSPACES (pspace)
1580     {
1581       struct symbol_cache *cache;
1582
1583       printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1584                        pspace->num,
1585                        pspace->symfile_object_file != NULL
1586                        ? objfile_name (pspace->symfile_object_file)
1587                        : "(no object file)");
1588
1589       /* If the cache hasn't been created yet, avoid creating one.  */
1590       cache
1591         = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1592       if (cache == NULL)
1593         printf_filtered ("  empty, no stats available\n");
1594       else
1595         symbol_cache_stats (cache);
1596     }
1597 }
1598
1599 /* This module's 'new_objfile' observer.  */
1600
1601 static void
1602 symtab_new_objfile_observer (struct objfile *objfile)
1603 {
1604   /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL.  */
1605   symbol_cache_flush (current_program_space);
1606 }
1607
1608 /* This module's 'free_objfile' observer.  */
1609
1610 static void
1611 symtab_free_objfile_observer (struct objfile *objfile)
1612 {
1613   symbol_cache_flush (objfile->pspace);
1614 }
1615 \f
1616 /* Debug symbols usually don't have section information.  We need to dig that
1617    out of the minimal symbols and stash that in the debug symbol.  */
1618
1619 void
1620 fixup_section (struct general_symbol_info *ginfo,
1621                CORE_ADDR addr, struct objfile *objfile)
1622 {
1623   struct minimal_symbol *msym;
1624
1625   /* First, check whether a minimal symbol with the same name exists
1626      and points to the same address.  The address check is required
1627      e.g. on PowerPC64, where the minimal symbol for a function will
1628      point to the function descriptor, while the debug symbol will
1629      point to the actual function code.  */
1630   msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1631   if (msym)
1632     ginfo->section = MSYMBOL_SECTION (msym);
1633   else
1634     {
1635       /* Static, function-local variables do appear in the linker
1636          (minimal) symbols, but are frequently given names that won't
1637          be found via lookup_minimal_symbol().  E.g., it has been
1638          observed in frv-uclinux (ELF) executables that a static,
1639          function-local variable named "foo" might appear in the
1640          linker symbols as "foo.6" or "foo.3".  Thus, there is no
1641          point in attempting to extend the lookup-by-name mechanism to
1642          handle this case due to the fact that there can be multiple
1643          names.
1644
1645          So, instead, search the section table when lookup by name has
1646          failed.  The ``addr'' and ``endaddr'' fields may have already
1647          been relocated.  If so, the relocation offset (i.e. the
1648          ANOFFSET value) needs to be subtracted from these values when
1649          performing the comparison.  We unconditionally subtract it,
1650          because, when no relocation has been performed, the ANOFFSET
1651          value will simply be zero.
1652
1653          The address of the symbol whose section we're fixing up HAS
1654          NOT BEEN adjusted (relocated) yet.  It can't have been since
1655          the section isn't yet known and knowing the section is
1656          necessary in order to add the correct relocation value.  In
1657          other words, we wouldn't even be in this function (attempting
1658          to compute the section) if it were already known.
1659
1660          Note that it is possible to search the minimal symbols
1661          (subtracting the relocation value if necessary) to find the
1662          matching minimal symbol, but this is overkill and much less
1663          efficient.  It is not necessary to find the matching minimal
1664          symbol, only its section.
1665
1666          Note that this technique (of doing a section table search)
1667          can fail when unrelocated section addresses overlap.  For
1668          this reason, we still attempt a lookup by name prior to doing
1669          a search of the section table.  */
1670
1671       struct obj_section *s;
1672       int fallback = -1;
1673
1674       ALL_OBJFILE_OSECTIONS (objfile, s)
1675         {
1676           int idx = s - objfile->sections;
1677           CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1678
1679           if (fallback == -1)
1680             fallback = idx;
1681
1682           if (obj_section_addr (s) - offset <= addr
1683               && addr < obj_section_endaddr (s) - offset)
1684             {
1685               ginfo->section = idx;
1686               return;
1687             }
1688         }
1689
1690       /* If we didn't find the section, assume it is in the first
1691          section.  If there is no allocated section, then it hardly
1692          matters what we pick, so just pick zero.  */
1693       if (fallback == -1)
1694         ginfo->section = 0;
1695       else
1696         ginfo->section = fallback;
1697     }
1698 }
1699
1700 struct symbol *
1701 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1702 {
1703   CORE_ADDR addr;
1704
1705   if (!sym)
1706     return NULL;
1707
1708   if (!SYMBOL_OBJFILE_OWNED (sym))
1709     return sym;
1710
1711   /* We either have an OBJFILE, or we can get at it from the sym's
1712      symtab.  Anything else is a bug.  */
1713   gdb_assert (objfile || symbol_symtab (sym));
1714
1715   if (objfile == NULL)
1716     objfile = symbol_objfile (sym);
1717
1718   if (SYMBOL_OBJ_SECTION (objfile, sym))
1719     return sym;
1720
1721   /* We should have an objfile by now.  */
1722   gdb_assert (objfile);
1723
1724   switch (SYMBOL_CLASS (sym))
1725     {
1726     case LOC_STATIC:
1727     case LOC_LABEL:
1728       addr = SYMBOL_VALUE_ADDRESS (sym);
1729       break;
1730     case LOC_BLOCK:
1731       addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1732       break;
1733
1734     default:
1735       /* Nothing else will be listed in the minsyms -- no use looking
1736          it up.  */
1737       return sym;
1738     }
1739
1740   fixup_section (&sym->ginfo, addr, objfile);
1741
1742   return sym;
1743 }
1744
1745 /* Compute the demangled form of NAME as used by the various symbol
1746    lookup functions.  The result can either be the input NAME
1747    directly, or a pointer to a buffer owned by the STORAGE object.
1748
1749    For Ada, this function just returns NAME, unmodified.
1750    Normally, Ada symbol lookups are performed using the encoded name
1751    rather than the demangled name, and so it might seem to make sense
1752    for this function to return an encoded version of NAME.
1753    Unfortunately, we cannot do this, because this function is used in
1754    circumstances where it is not appropriate to try to encode NAME.
1755    For instance, when displaying the frame info, we demangle the name
1756    of each parameter, and then perform a symbol lookup inside our
1757    function using that demangled name.  In Ada, certain functions
1758    have internally-generated parameters whose name contain uppercase
1759    characters.  Encoding those name would result in those uppercase
1760    characters to become lowercase, and thus cause the symbol lookup
1761    to fail.  */
1762
1763 const char *
1764 demangle_for_lookup (const char *name, enum language lang,
1765                      demangle_result_storage &storage)
1766 {
1767   /* If we are using C++, D, or Go, demangle the name before doing a
1768      lookup, so we can always binary search.  */
1769   if (lang == language_cplus)
1770     {
1771       char *demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1772       if (demangled_name != NULL)
1773         return storage.set_malloc_ptr (demangled_name);
1774
1775       /* If we were given a non-mangled name, canonicalize it
1776          according to the language (so far only for C++).  */
1777       std::string canon = cp_canonicalize_string (name);
1778       if (!canon.empty ())
1779         return storage.swap_string (canon);
1780     }
1781   else if (lang == language_d)
1782     {
1783       char *demangled_name = d_demangle (name, 0);
1784       if (demangled_name != NULL)
1785         return storage.set_malloc_ptr (demangled_name);
1786     }
1787   else if (lang == language_go)
1788     {
1789       char *demangled_name = go_demangle (name, 0);
1790       if (demangled_name != NULL)
1791         return storage.set_malloc_ptr (demangled_name);
1792     }
1793
1794   return name;
1795 }
1796
1797 /* See symtab.h.
1798
1799    This function (or rather its subordinates) have a bunch of loops and
1800    it would seem to be attractive to put in some QUIT's (though I'm not really
1801    sure whether it can run long enough to be really important).  But there
1802    are a few calls for which it would appear to be bad news to quit
1803    out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c.  (Note
1804    that there is C++ code below which can error(), but that probably
1805    doesn't affect these calls since they are looking for a known
1806    variable and thus can probably assume it will never hit the C++
1807    code).  */
1808
1809 struct block_symbol
1810 lookup_symbol_in_language (const char *name, const struct block *block,
1811                            const domain_enum domain, enum language lang,
1812                            struct field_of_this_result *is_a_field_of_this)
1813 {
1814   demangle_result_storage storage;
1815   const char *modified_name = demangle_for_lookup (name, lang, storage);
1816
1817   return lookup_symbol_aux (modified_name, block, domain, lang,
1818                             is_a_field_of_this);
1819 }
1820
1821 /* See symtab.h.  */
1822
1823 struct block_symbol
1824 lookup_symbol (const char *name, const struct block *block,
1825                domain_enum domain,
1826                struct field_of_this_result *is_a_field_of_this)
1827 {
1828   return lookup_symbol_in_language (name, block, domain,
1829                                     current_language->la_language,
1830                                     is_a_field_of_this);
1831 }
1832
1833 /* See symtab.h.  */
1834
1835 struct block_symbol
1836 lookup_language_this (const struct language_defn *lang,
1837                       const struct block *block)
1838 {
1839   if (lang->la_name_of_this == NULL || block == NULL)
1840     return (struct block_symbol) {NULL, NULL};
1841
1842   if (symbol_lookup_debug > 1)
1843     {
1844       struct objfile *objfile = lookup_objfile_from_block (block);
1845
1846       fprintf_unfiltered (gdb_stdlog,
1847                           "lookup_language_this (%s, %s (objfile %s))",
1848                           lang->la_name, host_address_to_string (block),
1849                           objfile_debug_name (objfile));
1850     }
1851
1852   while (block)
1853     {
1854       struct symbol *sym;
1855
1856       sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1857       if (sym != NULL)
1858         {
1859           if (symbol_lookup_debug > 1)
1860             {
1861               fprintf_unfiltered (gdb_stdlog, " = %s (%s, block %s)\n",
1862                                   SYMBOL_PRINT_NAME (sym),
1863                                   host_address_to_string (sym),
1864                                   host_address_to_string (block));
1865             }
1866           return (struct block_symbol) {sym, block};
1867         }
1868       if (BLOCK_FUNCTION (block))
1869         break;
1870       block = BLOCK_SUPERBLOCK (block);
1871     }
1872
1873   if (symbol_lookup_debug > 1)
1874     fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1875   return (struct block_symbol) {NULL, NULL};
1876 }
1877
1878 /* Given TYPE, a structure/union,
1879    return 1 if the component named NAME from the ultimate target
1880    structure/union is defined, otherwise, return 0.  */
1881
1882 static int
1883 check_field (struct type *type, const char *name,
1884              struct field_of_this_result *is_a_field_of_this)
1885 {
1886   int i;
1887
1888   /* The type may be a stub.  */
1889   type = check_typedef (type);
1890
1891   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1892     {
1893       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1894
1895       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1896         {
1897           is_a_field_of_this->type = type;
1898           is_a_field_of_this->field = &TYPE_FIELD (type, i);
1899           return 1;
1900         }
1901     }
1902
1903   /* C++: If it was not found as a data field, then try to return it
1904      as a pointer to a method.  */
1905
1906   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1907     {
1908       if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1909         {
1910           is_a_field_of_this->type = type;
1911           is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1912           return 1;
1913         }
1914     }
1915
1916   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1917     if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
1918       return 1;
1919
1920   return 0;
1921 }
1922
1923 /* Behave like lookup_symbol except that NAME is the natural name
1924    (e.g., demangled name) of the symbol that we're looking for.  */
1925
1926 static struct block_symbol
1927 lookup_symbol_aux (const char *name, const struct block *block,
1928                    const domain_enum domain, enum language language,
1929                    struct field_of_this_result *is_a_field_of_this)
1930 {
1931   struct block_symbol result;
1932   const struct language_defn *langdef;
1933
1934   if (symbol_lookup_debug)
1935     {
1936       struct objfile *objfile = lookup_objfile_from_block (block);
1937
1938       fprintf_unfiltered (gdb_stdlog,
1939                           "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
1940                           name, host_address_to_string (block),
1941                           objfile != NULL
1942                           ? objfile_debug_name (objfile) : "NULL",
1943                           domain_name (domain), language_str (language));
1944     }
1945
1946   /* Make sure we do something sensible with is_a_field_of_this, since
1947      the callers that set this parameter to some non-null value will
1948      certainly use it later.  If we don't set it, the contents of
1949      is_a_field_of_this are undefined.  */
1950   if (is_a_field_of_this != NULL)
1951     memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
1952
1953   /* Search specified block and its superiors.  Don't search
1954      STATIC_BLOCK or GLOBAL_BLOCK.  */
1955
1956   result = lookup_local_symbol (name, block, domain, language);
1957   if (result.symbol != NULL)
1958     {
1959       if (symbol_lookup_debug)
1960         {
1961           fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
1962                               host_address_to_string (result.symbol));
1963         }
1964       return result;
1965     }
1966
1967   /* If requested to do so by the caller and if appropriate for LANGUAGE,
1968      check to see if NAME is a field of `this'.  */
1969
1970   langdef = language_def (language);
1971
1972   /* Don't do this check if we are searching for a struct.  It will
1973      not be found by check_field, but will be found by other
1974      means.  */
1975   if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
1976     {
1977       result = lookup_language_this (langdef, block);
1978
1979       if (result.symbol)
1980         {
1981           struct type *t = result.symbol->type;
1982
1983           /* I'm not really sure that type of this can ever
1984              be typedefed; just be safe.  */
1985           t = check_typedef (t);
1986           if (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
1987             t = TYPE_TARGET_TYPE (t);
1988
1989           if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1990               && TYPE_CODE (t) != TYPE_CODE_UNION)
1991             error (_("Internal error: `%s' is not an aggregate"),
1992                    langdef->la_name_of_this);
1993
1994           if (check_field (t, name, is_a_field_of_this))
1995             {
1996               if (symbol_lookup_debug)
1997                 {
1998                   fprintf_unfiltered (gdb_stdlog,
1999                                       "lookup_symbol_aux (...) = NULL\n");
2000                 }
2001               return (struct block_symbol) {NULL, NULL};
2002             }
2003         }
2004     }
2005
2006   /* Now do whatever is appropriate for LANGUAGE to look
2007      up static and global variables.  */
2008
2009   result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
2010   if (result.symbol != NULL)
2011     {
2012       if (symbol_lookup_debug)
2013         {
2014           fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2015                               host_address_to_string (result.symbol));
2016         }
2017       return result;
2018     }
2019
2020   /* Now search all static file-level symbols.  Not strictly correct,
2021      but more useful than an error.  */
2022
2023   result = lookup_static_symbol (name, domain);
2024   if (symbol_lookup_debug)
2025     {
2026       fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2027                           result.symbol != NULL
2028                             ? host_address_to_string (result.symbol)
2029                             : "NULL");
2030     }
2031   return result;
2032 }
2033
2034 /* Check to see if the symbol is defined in BLOCK or its superiors.
2035    Don't search STATIC_BLOCK or GLOBAL_BLOCK.  */
2036
2037 static struct block_symbol
2038 lookup_local_symbol (const char *name, const struct block *block,
2039                      const domain_enum domain,
2040                      enum language language)
2041 {
2042   struct symbol *sym;
2043   const struct block *static_block = block_static_block (block);
2044   const char *scope = block_scope (block);
2045   
2046   /* Check if either no block is specified or it's a global block.  */
2047
2048   if (static_block == NULL)
2049     return (struct block_symbol) {NULL, NULL};
2050
2051   while (block != static_block)
2052     {
2053       sym = lookup_symbol_in_block (name, block, domain);
2054       if (sym != NULL)
2055         return (struct block_symbol) {sym, block};
2056
2057       if (language == language_cplus || language == language_fortran)
2058         {
2059           struct block_symbol sym
2060             = cp_lookup_symbol_imports_or_template (scope, name, block,
2061                                                     domain);
2062
2063           if (sym.symbol != NULL)
2064             return sym;
2065         }
2066
2067       if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
2068         break;
2069       block = BLOCK_SUPERBLOCK (block);
2070     }
2071
2072   /* We've reached the end of the function without finding a result.  */
2073
2074   return (struct block_symbol) {NULL, NULL};
2075 }
2076
2077 /* See symtab.h.  */
2078
2079 struct objfile *
2080 lookup_objfile_from_block (const struct block *block)
2081 {
2082   struct objfile *obj;
2083   struct compunit_symtab *cust;
2084
2085   if (block == NULL)
2086     return NULL;
2087
2088   block = block_global_block (block);
2089   /* Look through all blockvectors.  */
2090   ALL_COMPUNITS (obj, cust)
2091     if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
2092                                     GLOBAL_BLOCK))
2093       {
2094         if (obj->separate_debug_objfile_backlink)
2095           obj = obj->separate_debug_objfile_backlink;
2096
2097         return obj;
2098       }
2099
2100   return NULL;
2101 }
2102
2103 /* See symtab.h.  */
2104
2105 struct symbol *
2106 lookup_symbol_in_block (const char *name, const struct block *block,
2107                         const domain_enum domain)
2108 {
2109   struct symbol *sym;
2110
2111   if (symbol_lookup_debug > 1)
2112     {
2113       struct objfile *objfile = lookup_objfile_from_block (block);
2114
2115       fprintf_unfiltered (gdb_stdlog,
2116                           "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2117                           name, host_address_to_string (block),
2118                           objfile_debug_name (objfile),
2119                           domain_name (domain));
2120     }
2121
2122   sym = block_lookup_symbol (block, name, domain);
2123   if (sym)
2124     {
2125       if (symbol_lookup_debug > 1)
2126         {
2127           fprintf_unfiltered (gdb_stdlog, " = %s\n",
2128                               host_address_to_string (sym));
2129         }
2130       return fixup_symbol_section (sym, NULL);
2131     }
2132
2133   if (symbol_lookup_debug > 1)
2134     fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2135   return NULL;
2136 }
2137
2138 /* See symtab.h.  */
2139
2140 struct block_symbol
2141 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
2142                                    const char *name,
2143                                    const domain_enum domain)
2144 {
2145   struct objfile *objfile;
2146
2147   for (objfile = main_objfile;
2148        objfile;
2149        objfile = objfile_separate_debug_iterate (main_objfile, objfile))
2150     {
2151       struct block_symbol result
2152         = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, name, domain);
2153
2154       if (result.symbol != NULL)
2155         return result;
2156     }
2157
2158   return (struct block_symbol) {NULL, NULL};
2159 }
2160
2161 /* Check to see if the symbol is defined in one of the OBJFILE's
2162    symtabs.  BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2163    depending on whether or not we want to search global symbols or
2164    static symbols.  */
2165
2166 static struct block_symbol
2167 lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
2168                                   const char *name, const domain_enum domain)
2169 {
2170   struct compunit_symtab *cust;
2171
2172   gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2173
2174   if (symbol_lookup_debug > 1)
2175     {
2176       fprintf_unfiltered (gdb_stdlog,
2177                           "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2178                           objfile_debug_name (objfile),
2179                           block_index == GLOBAL_BLOCK
2180                           ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2181                           name, domain_name (domain));
2182     }
2183
2184   ALL_OBJFILE_COMPUNITS (objfile, cust)
2185     {
2186       const struct blockvector *bv;
2187       const struct block *block;
2188       struct block_symbol result;
2189
2190       bv = COMPUNIT_BLOCKVECTOR (cust);
2191       block = BLOCKVECTOR_BLOCK (bv, block_index);
2192       result.symbol = block_lookup_symbol_primary (block, name, domain);
2193       result.block = block;
2194       if (result.symbol != NULL)
2195         {
2196           if (symbol_lookup_debug > 1)
2197             {
2198               fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n",
2199                                   host_address_to_string (result.symbol),
2200                                   host_address_to_string (block));
2201             }
2202           result.symbol = fixup_symbol_section (result.symbol, objfile);
2203           return result;
2204
2205         }
2206     }
2207
2208   if (symbol_lookup_debug > 1)
2209     fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2210   return (struct block_symbol) {NULL, NULL};
2211 }
2212
2213 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2214    Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2215    and all associated separate debug objfiles.
2216
2217    Normally we only look in OBJFILE, and not any separate debug objfiles
2218    because the outer loop will cause them to be searched too.  This case is
2219    different.  Here we're called from search_symbols where it will only
2220    call us for the the objfile that contains a matching minsym.  */
2221
2222 static struct block_symbol
2223 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
2224                                             const char *linkage_name,
2225                                             domain_enum domain)
2226 {
2227   enum language lang = current_language->la_language;
2228   struct objfile *main_objfile, *cur_objfile;
2229
2230   demangle_result_storage storage;
2231   const char *modified_name = demangle_for_lookup (linkage_name, lang, storage);
2232
2233   if (objfile->separate_debug_objfile_backlink)
2234     main_objfile = objfile->separate_debug_objfile_backlink;
2235   else
2236     main_objfile = objfile;
2237
2238   for (cur_objfile = main_objfile;
2239        cur_objfile;
2240        cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
2241     {
2242       struct block_symbol result;
2243
2244       result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
2245                                                  modified_name, domain);
2246       if (result.symbol == NULL)
2247         result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
2248                                                    modified_name, domain);
2249       if (result.symbol != NULL)
2250         return result;
2251     }
2252
2253   return (struct block_symbol) {NULL, NULL};
2254 }
2255
2256 /* A helper function that throws an exception when a symbol was found
2257    in a psymtab but not in a symtab.  */
2258
2259 static void ATTRIBUTE_NORETURN
2260 error_in_psymtab_expansion (int block_index, const char *name,
2261                             struct compunit_symtab *cust)
2262 {
2263   error (_("\
2264 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2265 %s may be an inlined function, or may be a template function\n   \
2266 (if a template, try specifying an instantiation: %s<type>)."),
2267          block_index == GLOBAL_BLOCK ? "global" : "static",
2268          name,
2269          symtab_to_filename_for_display (compunit_primary_filetab (cust)),
2270          name, name);
2271 }
2272
2273 /* A helper function for various lookup routines that interfaces with
2274    the "quick" symbol table functions.  */
2275
2276 static struct block_symbol
2277 lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index,
2278                              const char *name, const domain_enum domain)
2279 {
2280   struct compunit_symtab *cust;
2281   const struct blockvector *bv;
2282   const struct block *block;
2283   struct block_symbol result;
2284
2285   if (!objfile->sf)
2286     return (struct block_symbol) {NULL, NULL};
2287
2288   if (symbol_lookup_debug > 1)
2289     {
2290       fprintf_unfiltered (gdb_stdlog,
2291                           "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2292                           objfile_debug_name (objfile),
2293                           block_index == GLOBAL_BLOCK
2294                           ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2295                           name, domain_name (domain));
2296     }
2297
2298   cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, domain);
2299   if (cust == NULL)
2300     {
2301       if (symbol_lookup_debug > 1)
2302         {
2303           fprintf_unfiltered (gdb_stdlog,
2304                               "lookup_symbol_via_quick_fns (...) = NULL\n");
2305         }
2306       return (struct block_symbol) {NULL, NULL};
2307     }
2308
2309   bv = COMPUNIT_BLOCKVECTOR (cust);
2310   block = BLOCKVECTOR_BLOCK (bv, block_index);
2311   result.symbol = block_lookup_symbol (block, name, domain);
2312   if (result.symbol == NULL)
2313     error_in_psymtab_expansion (block_index, name, cust);
2314
2315   if (symbol_lookup_debug > 1)
2316     {
2317       fprintf_unfiltered (gdb_stdlog,
2318                           "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2319                           host_address_to_string (result.symbol),
2320                           host_address_to_string (block));
2321     }
2322
2323   result.symbol = fixup_symbol_section (result.symbol, objfile);
2324   result.block = block;
2325   return result;
2326 }
2327
2328 /* See symtab.h.  */
2329
2330 struct block_symbol
2331 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
2332                               const char *name,
2333                               const struct block *block,
2334                               const domain_enum domain)
2335 {
2336   struct block_symbol result;
2337
2338   /* NOTE: carlton/2003-05-19: The comments below were written when
2339      this (or what turned into this) was part of lookup_symbol_aux;
2340      I'm much less worried about these questions now, since these
2341      decisions have turned out well, but I leave these comments here
2342      for posterity.  */
2343
2344   /* NOTE: carlton/2002-12-05: There is a question as to whether or
2345      not it would be appropriate to search the current global block
2346      here as well.  (That's what this code used to do before the
2347      is_a_field_of_this check was moved up.)  On the one hand, it's
2348      redundant with the lookup in all objfiles search that happens
2349      next.  On the other hand, if decode_line_1 is passed an argument
2350      like filename:var, then the user presumably wants 'var' to be
2351      searched for in filename.  On the third hand, there shouldn't be
2352      multiple global variables all of which are named 'var', and it's
2353      not like decode_line_1 has ever restricted its search to only
2354      global variables in a single filename.  All in all, only
2355      searching the static block here seems best: it's correct and it's
2356      cleanest.  */
2357
2358   /* NOTE: carlton/2002-12-05: There's also a possible performance
2359      issue here: if you usually search for global symbols in the
2360      current file, then it would be slightly better to search the
2361      current global block before searching all the symtabs.  But there
2362      are other factors that have a much greater effect on performance
2363      than that one, so I don't think we should worry about that for
2364      now.  */
2365
2366   /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2367      the current objfile.  Searching the current objfile first is useful
2368      for both matching user expectations as well as performance.  */
2369
2370   result = lookup_symbol_in_static_block (name, block, domain);
2371   if (result.symbol != NULL)
2372     return result;
2373
2374   /* If we didn't find a definition for a builtin type in the static block,
2375      search for it now.  This is actually the right thing to do and can be
2376      a massive performance win.  E.g., when debugging a program with lots of
2377      shared libraries we could search all of them only to find out the
2378      builtin type isn't defined in any of them.  This is common for types
2379      like "void".  */
2380   if (domain == VAR_DOMAIN)
2381     {
2382       struct gdbarch *gdbarch;
2383
2384       if (block == NULL)
2385         gdbarch = target_gdbarch ();
2386       else
2387         gdbarch = block_gdbarch (block);
2388       result.symbol = language_lookup_primitive_type_as_symbol (langdef,
2389                                                                 gdbarch, name);
2390       result.block = NULL;
2391       if (result.symbol != NULL)
2392         return result;
2393     }
2394
2395   return lookup_global_symbol (name, block, domain);
2396 }
2397
2398 /* See symtab.h.  */
2399
2400 struct block_symbol
2401 lookup_symbol_in_static_block (const char *name,
2402                                const struct block *block,
2403                                const domain_enum domain)
2404 {
2405   const struct block *static_block = block_static_block (block);
2406   struct symbol *sym;
2407
2408   if (static_block == NULL)
2409     return (struct block_symbol) {NULL, NULL};
2410
2411   if (symbol_lookup_debug)
2412     {
2413       struct objfile *objfile = lookup_objfile_from_block (static_block);
2414
2415       fprintf_unfiltered (gdb_stdlog,
2416                           "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2417                           " %s)\n",
2418                           name,
2419                           host_address_to_string (block),
2420                           objfile_debug_name (objfile),
2421                           domain_name (domain));
2422     }
2423
2424   sym = lookup_symbol_in_block (name, static_block, domain);
2425   if (symbol_lookup_debug)
2426     {
2427       fprintf_unfiltered (gdb_stdlog,
2428                           "lookup_symbol_in_static_block (...) = %s\n",
2429                           sym != NULL ? host_address_to_string (sym) : "NULL");
2430     }
2431   return (struct block_symbol) {sym, static_block};
2432 }
2433
2434 /* Perform the standard symbol lookup of NAME in OBJFILE:
2435    1) First search expanded symtabs, and if not found
2436    2) Search the "quick" symtabs (partial or .gdb_index).
2437    BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK.  */
2438
2439 static struct block_symbol
2440 lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
2441                           const char *name, const domain_enum domain)
2442 {
2443   struct block_symbol result;
2444
2445   if (symbol_lookup_debug)
2446     {
2447       fprintf_unfiltered (gdb_stdlog,
2448                           "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2449                           objfile_debug_name (objfile),
2450                           block_index == GLOBAL_BLOCK
2451                           ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2452                           name, domain_name (domain));
2453     }
2454
2455   result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
2456                                              name, domain);
2457   if (result.symbol != NULL)
2458     {
2459       if (symbol_lookup_debug)
2460         {
2461           fprintf_unfiltered (gdb_stdlog,
2462                               "lookup_symbol_in_objfile (...) = %s"
2463                               " (in symtabs)\n",
2464                               host_address_to_string (result.symbol));
2465         }
2466       return result;
2467     }
2468
2469   result = lookup_symbol_via_quick_fns (objfile, block_index,
2470                                         name, domain);
2471   if (symbol_lookup_debug)
2472     {
2473       fprintf_unfiltered (gdb_stdlog,
2474                           "lookup_symbol_in_objfile (...) = %s%s\n",
2475                           result.symbol != NULL
2476                           ? host_address_to_string (result.symbol)
2477                           : "NULL",
2478                           result.symbol != NULL ? " (via quick fns)" : "");
2479     }
2480   return result;
2481 }
2482
2483 /* See symtab.h.  */
2484
2485 struct block_symbol
2486 lookup_static_symbol (const char *name, const domain_enum domain)
2487 {
2488   struct symbol_cache *cache = get_symbol_cache (current_program_space);
2489   struct objfile *objfile;
2490   struct block_symbol result;
2491   struct block_symbol_cache *bsc;
2492   struct symbol_cache_slot *slot;
2493
2494   /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
2495      NULL for OBJFILE_CONTEXT.  */
2496   result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
2497                                 &bsc, &slot);
2498   if (result.symbol != NULL)
2499     {
2500       if (SYMBOL_LOOKUP_FAILED_P (result))
2501         return (struct block_symbol) {NULL, NULL};
2502       return result;
2503     }
2504
2505   ALL_OBJFILES (objfile)
2506     {
2507       result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
2508       if (result.symbol != NULL)
2509         {
2510           /* Still pass NULL for OBJFILE_CONTEXT here.  */
2511           symbol_cache_mark_found (bsc, slot, NULL, result.symbol,
2512                                    result.block);
2513           return result;
2514         }
2515     }
2516
2517   /* Still pass NULL for OBJFILE_CONTEXT here.  */
2518   symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
2519   return (struct block_symbol) {NULL, NULL};
2520 }
2521
2522 /* Private data to be used with lookup_symbol_global_iterator_cb.  */
2523
2524 struct global_sym_lookup_data
2525 {
2526   /* The name of the symbol we are searching for.  */
2527   const char *name;
2528
2529   /* The domain to use for our search.  */
2530   domain_enum domain;
2531
2532   /* The field where the callback should store the symbol if found.
2533      It should be initialized to {NULL, NULL} before the search is started.  */
2534   struct block_symbol result;
2535 };
2536
2537 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2538    It searches by name for a symbol in the GLOBAL_BLOCK of the given
2539    OBJFILE.  The arguments for the search are passed via CB_DATA,
2540    which in reality is a pointer to struct global_sym_lookup_data.  */
2541
2542 static int
2543 lookup_symbol_global_iterator_cb (struct objfile *objfile,
2544                                   void *cb_data)
2545 {
2546   struct global_sym_lookup_data *data =
2547     (struct global_sym_lookup_data *) cb_data;
2548
2549   gdb_assert (data->result.symbol == NULL
2550               && data->result.block == NULL);
2551
2552   data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
2553                                            data->name, data->domain);
2554
2555   /* If we found a match, tell the iterator to stop.  Otherwise,
2556      keep going.  */
2557   return (data->result.symbol != NULL);
2558 }
2559
2560 /* See symtab.h.  */
2561
2562 struct block_symbol
2563 lookup_global_symbol (const char *name,
2564                       const struct block *block,
2565                       const domain_enum domain)
2566 {
2567   struct symbol_cache *cache = get_symbol_cache (current_program_space);
2568   struct block_symbol result;
2569   struct objfile *objfile;
2570   struct global_sym_lookup_data lookup_data;
2571   struct block_symbol_cache *bsc;
2572   struct symbol_cache_slot *slot;
2573
2574   objfile = lookup_objfile_from_block (block);
2575
2576   /* First see if we can find the symbol in the cache.
2577      This works because we use the current objfile to qualify the lookup.  */
2578   result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
2579                                 &bsc, &slot);
2580   if (result.symbol != NULL)
2581     {
2582       if (SYMBOL_LOOKUP_FAILED_P (result))
2583         return (struct block_symbol) {NULL, NULL};
2584       return result;
2585     }
2586
2587   /* Call library-specific lookup procedure.  */
2588   if (objfile != NULL)
2589     result = solib_global_lookup (objfile, name, domain);
2590
2591   /* If that didn't work go a global search (of global blocks, heh).  */
2592   if (result.symbol == NULL)
2593     {
2594       memset (&lookup_data, 0, sizeof (lookup_data));
2595       lookup_data.name = name;
2596       lookup_data.domain = domain;
2597       gdbarch_iterate_over_objfiles_in_search_order
2598         (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
2599          lookup_symbol_global_iterator_cb, &lookup_data, objfile);
2600       result = lookup_data.result;
2601     }
2602
2603   if (result.symbol != NULL)
2604     symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
2605   else
2606     symbol_cache_mark_not_found (bsc, slot, objfile, name, domain);
2607
2608   return result;
2609 }
2610
2611 int
2612 symbol_matches_domain (enum language symbol_language,
2613                        domain_enum symbol_domain,
2614                        domain_enum domain)
2615 {
2616   /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2617      Similarly, any Ada type declaration implicitly defines a typedef.  */
2618   if (symbol_language == language_cplus
2619       || symbol_language == language_d
2620       || symbol_language == language_ada
2621       || symbol_language == language_rust)
2622     {
2623       if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
2624           && symbol_domain == STRUCT_DOMAIN)
2625         return 1;
2626     }
2627   /* For all other languages, strict match is required.  */
2628   return (symbol_domain == domain);
2629 }
2630
2631 /* See symtab.h.  */
2632
2633 struct type *
2634 lookup_transparent_type (const char *name)
2635 {
2636   return current_language->la_lookup_transparent_type (name);
2637 }
2638
2639 /* A helper for basic_lookup_transparent_type that interfaces with the
2640    "quick" symbol table functions.  */
2641
2642 static struct type *
2643 basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index,
2644                                      const char *name)
2645 {
2646   struct compunit_symtab *cust;
2647   const struct blockvector *bv;
2648   struct block *block;
2649   struct symbol *sym;
2650
2651   if (!objfile->sf)
2652     return NULL;
2653   cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name,
2654                                          STRUCT_DOMAIN);
2655   if (cust == NULL)
2656     return NULL;
2657
2658   bv = COMPUNIT_BLOCKVECTOR (cust);
2659   block = BLOCKVECTOR_BLOCK (bv, block_index);
2660   sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2661                            block_find_non_opaque_type, NULL);
2662   if (sym == NULL)
2663     error_in_psymtab_expansion (block_index, name, cust);
2664   gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2665   return SYMBOL_TYPE (sym);
2666 }
2667
2668 /* Subroutine of basic_lookup_transparent_type to simplify it.
2669    Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2670    BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK.  */
2671
2672 static struct type *
2673 basic_lookup_transparent_type_1 (struct objfile *objfile, int block_index,
2674                                  const char *name)
2675 {
2676   const struct compunit_symtab *cust;
2677   const struct blockvector *bv;
2678   const struct block *block;
2679   const struct symbol *sym;
2680
2681   ALL_OBJFILE_COMPUNITS (objfile, cust)
2682     {
2683       bv = COMPUNIT_BLOCKVECTOR (cust);
2684       block = BLOCKVECTOR_BLOCK (bv, block_index);
2685       sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2686                                block_find_non_opaque_type, NULL);
2687       if (sym != NULL)
2688         {
2689           gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2690           return SYMBOL_TYPE (sym);
2691         }
2692     }
2693
2694   return NULL;
2695 }
2696
2697 /* The standard implementation of lookup_transparent_type.  This code
2698    was modeled on lookup_symbol -- the parts not relevant to looking
2699    up types were just left out.  In particular it's assumed here that
2700    types are available in STRUCT_DOMAIN and only in file-static or
2701    global blocks.  */
2702
2703 struct type *
2704 basic_lookup_transparent_type (const char *name)
2705 {
2706   struct objfile *objfile;
2707   struct type *t;
2708
2709   /* Now search all the global symbols.  Do the symtab's first, then
2710      check the psymtab's.  If a psymtab indicates the existence
2711      of the desired name as a global, then do psymtab-to-symtab
2712      conversion on the fly and return the found symbol.  */
2713
2714   ALL_OBJFILES (objfile)
2715   {
2716     t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
2717     if (t)
2718       return t;
2719   }
2720
2721   ALL_OBJFILES (objfile)
2722   {
2723     t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
2724     if (t)
2725       return t;
2726   }
2727
2728   /* Now search the static file-level symbols.
2729      Not strictly correct, but more useful than an error.
2730      Do the symtab's first, then
2731      check the psymtab's.  If a psymtab indicates the existence
2732      of the desired name as a file-level static, then do psymtab-to-symtab
2733      conversion on the fly and return the found symbol.  */
2734
2735   ALL_OBJFILES (objfile)
2736   {
2737     t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
2738     if (t)
2739       return t;
2740   }
2741
2742   ALL_OBJFILES (objfile)
2743   {
2744     t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
2745     if (t)
2746       return t;
2747   }
2748
2749   return (struct type *) 0;
2750 }
2751
2752 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2753
2754    For each symbol that matches, CALLBACK is called.  The symbol is
2755    passed to the callback.
2756
2757    If CALLBACK returns false, the iteration ends.  Otherwise, the
2758    search continues.  */
2759
2760 void
2761 iterate_over_symbols (const struct block *block, const char *name,
2762                       const domain_enum domain,
2763                       gdb::function_view<symbol_found_callback_ftype> callback)
2764 {
2765   struct block_iterator iter;
2766   struct symbol *sym;
2767
2768   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
2769     {
2770       if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2771                                  SYMBOL_DOMAIN (sym), domain))
2772         {
2773           if (!callback (sym))
2774             return;
2775         }
2776     }
2777 }
2778
2779 /* Find the compunit symtab associated with PC and SECTION.
2780    This will read in debug info as necessary.  */
2781
2782 struct compunit_symtab *
2783 find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
2784 {
2785   struct compunit_symtab *cust;
2786   struct compunit_symtab *best_cust = NULL;
2787   struct objfile *objfile;
2788   CORE_ADDR distance = 0;
2789   struct bound_minimal_symbol msymbol;
2790
2791   /* If we know that this is not a text address, return failure.  This is
2792      necessary because we loop based on the block's high and low code
2793      addresses, which do not include the data ranges, and because
2794      we call find_pc_sect_psymtab which has a similar restriction based
2795      on the partial_symtab's texthigh and textlow.  */
2796   msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2797   if (msymbol.minsym
2798       && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
2799           || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
2800           || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
2801           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
2802           || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
2803     return NULL;
2804
2805   /* Search all symtabs for the one whose file contains our address, and which
2806      is the smallest of all the ones containing the address.  This is designed
2807      to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2808      and symtab b is at 0x2000-0x3000.  So the GLOBAL_BLOCK for a is from
2809      0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2810
2811      This happens for native ecoff format, where code from included files
2812      gets its own symtab.  The symtab for the included file should have
2813      been read in already via the dependency mechanism.
2814      It might be swifter to create several symtabs with the same name
2815      like xcoff does (I'm not sure).
2816
2817      It also happens for objfiles that have their functions reordered.
2818      For these, the symtab we are looking for is not necessarily read in.  */
2819
2820   ALL_COMPUNITS (objfile, cust)
2821   {
2822     struct block *b;
2823     const struct blockvector *bv;
2824
2825     bv = COMPUNIT_BLOCKVECTOR (cust);
2826     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2827
2828     if (BLOCK_START (b) <= pc
2829         && BLOCK_END (b) > pc
2830         && (distance == 0
2831             || BLOCK_END (b) - BLOCK_START (b) < distance))
2832       {
2833         /* For an objfile that has its functions reordered,
2834            find_pc_psymtab will find the proper partial symbol table
2835            and we simply return its corresponding symtab.  */
2836         /* In order to better support objfiles that contain both
2837            stabs and coff debugging info, we continue on if a psymtab
2838            can't be found.  */
2839         if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2840           {
2841             struct compunit_symtab *result;
2842
2843             result
2844               = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2845                                                                msymbol,
2846                                                                pc, section,
2847                                                                0);
2848             if (result != NULL)
2849               return result;
2850           }
2851         if (section != 0)
2852           {
2853             struct block_iterator iter;
2854             struct symbol *sym = NULL;
2855
2856             ALL_BLOCK_SYMBOLS (b, iter, sym)
2857               {
2858                 fixup_symbol_section (sym, objfile);
2859                 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, sym),
2860                                            section))
2861                   break;
2862               }
2863             if (sym == NULL)
2864               continue;         /* No symbol in this symtab matches
2865                                    section.  */
2866           }
2867         distance = BLOCK_END (b) - BLOCK_START (b);
2868         best_cust = cust;
2869       }
2870   }
2871
2872   if (best_cust != NULL)
2873     return best_cust;
2874
2875   /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs).  */
2876
2877   ALL_OBJFILES (objfile)
2878   {
2879     struct compunit_symtab *result;
2880
2881     if (!objfile->sf)
2882       continue;
2883     result = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2884                                                             msymbol,
2885                                                             pc, section,
2886                                                             1);
2887     if (result != NULL)
2888       return result;
2889   }
2890
2891   return NULL;
2892 }
2893
2894 /* Find the compunit symtab associated with PC.
2895    This will read in debug info as necessary.
2896    Backward compatibility, no section.  */
2897
2898 struct compunit_symtab *
2899 find_pc_compunit_symtab (CORE_ADDR pc)
2900 {
2901   return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc));
2902 }
2903 \f
2904
2905 /* Find the source file and line number for a given PC value and SECTION.
2906    Return a structure containing a symtab pointer, a line number,
2907    and a pc range for the entire source line.
2908    The value's .pc field is NOT the specified pc.
2909    NOTCURRENT nonzero means, if specified pc is on a line boundary,
2910    use the line that ends there.  Otherwise, in that case, the line
2911    that begins there is used.  */
2912
2913 /* The big complication here is that a line may start in one file, and end just
2914    before the start of another file.  This usually occurs when you #include
2915    code in the middle of a subroutine.  To properly find the end of a line's PC
2916    range, we must search all symtabs associated with this compilation unit, and
2917    find the one whose first PC is closer than that of the next line in this
2918    symtab.  */
2919
2920 /* If it's worth the effort, we could be using a binary search.  */
2921
2922 struct symtab_and_line
2923 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
2924 {
2925   struct compunit_symtab *cust;
2926   struct symtab *iter_s;
2927   struct linetable *l;
2928   int len;
2929   int i;
2930   struct linetable_entry *item;
2931   const struct blockvector *bv;
2932   struct bound_minimal_symbol msymbol;
2933
2934   /* Info on best line seen so far, and where it starts, and its file.  */
2935
2936   struct linetable_entry *best = NULL;
2937   CORE_ADDR best_end = 0;
2938   struct symtab *best_symtab = 0;
2939
2940   /* Store here the first line number
2941      of a file which contains the line at the smallest pc after PC.
2942      If we don't find a line whose range contains PC,
2943      we will use a line one less than this,
2944      with a range from the start of that file to the first line's pc.  */
2945   struct linetable_entry *alt = NULL;
2946
2947   /* Info on best line seen in this file.  */
2948
2949   struct linetable_entry *prev;
2950
2951   /* If this pc is not from the current frame,
2952      it is the address of the end of a call instruction.
2953      Quite likely that is the start of the following statement.
2954      But what we want is the statement containing the instruction.
2955      Fudge the pc to make sure we get that.  */
2956
2957   /* It's tempting to assume that, if we can't find debugging info for
2958      any function enclosing PC, that we shouldn't search for line
2959      number info, either.  However, GAS can emit line number info for
2960      assembly files --- very helpful when debugging hand-written
2961      assembly code.  In such a case, we'd have no debug info for the
2962      function, but we would have line info.  */
2963
2964   if (notcurrent)
2965     pc -= 1;
2966
2967   /* elz: added this because this function returned the wrong
2968      information if the pc belongs to a stub (import/export)
2969      to call a shlib function.  This stub would be anywhere between
2970      two functions in the target, and the line info was erroneously
2971      taken to be the one of the line before the pc.  */
2972
2973   /* RT: Further explanation:
2974
2975    * We have stubs (trampolines) inserted between procedures.
2976    *
2977    * Example: "shr1" exists in a shared library, and a "shr1" stub also
2978    * exists in the main image.
2979    *
2980    * In the minimal symbol table, we have a bunch of symbols
2981    * sorted by start address.  The stubs are marked as "trampoline",
2982    * the others appear as text. E.g.:
2983    *
2984    *  Minimal symbol table for main image
2985    *     main:  code for main (text symbol)
2986    *     shr1: stub  (trampoline symbol)
2987    *     foo:   code for foo (text symbol)
2988    *     ...
2989    *  Minimal symbol table for "shr1" image:
2990    *     ...
2991    *     shr1: code for shr1 (text symbol)
2992    *     ...
2993    *
2994    * So the code below is trying to detect if we are in the stub
2995    * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2996    * and if found,  do the symbolization from the real-code address
2997    * rather than the stub address.
2998    *
2999    * Assumptions being made about the minimal symbol table:
3000    *   1. lookup_minimal_symbol_by_pc() will return a trampoline only
3001    *      if we're really in the trampoline.s If we're beyond it (say
3002    *      we're in "foo" in the above example), it'll have a closer
3003    *      symbol (the "foo" text symbol for example) and will not
3004    *      return the trampoline.
3005    *   2. lookup_minimal_symbol_text() will find a real text symbol
3006    *      corresponding to the trampoline, and whose address will
3007    *      be different than the trampoline address.  I put in a sanity
3008    *      check for the address being the same, to avoid an
3009    *      infinite recursion.
3010    */
3011   msymbol = lookup_minimal_symbol_by_pc (pc);
3012   if (msymbol.minsym != NULL)
3013     if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
3014       {
3015         struct bound_minimal_symbol mfunsym
3016           = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
3017                                         NULL);
3018
3019         if (mfunsym.minsym == NULL)
3020           /* I eliminated this warning since it is coming out
3021            * in the following situation:
3022            * gdb shmain // test program with shared libraries
3023            * (gdb) break shr1  // function in shared lib
3024            * Warning: In stub for ...
3025            * In the above situation, the shared lib is not loaded yet,
3026            * so of course we can't find the real func/line info,
3027            * but the "break" still works, and the warning is annoying.
3028            * So I commented out the warning.  RT */
3029           /* warning ("In stub for %s; unable to find real function/line info",
3030              SYMBOL_LINKAGE_NAME (msymbol)); */
3031           ;
3032         /* fall through */
3033         else if (BMSYMBOL_VALUE_ADDRESS (mfunsym)
3034                  == BMSYMBOL_VALUE_ADDRESS (msymbol))
3035           /* Avoid infinite recursion */
3036           /* See above comment about why warning is commented out.  */
3037           /* warning ("In stub for %s; unable to find real function/line info",
3038              SYMBOL_LINKAGE_NAME (msymbol)); */
3039           ;
3040         /* fall through */
3041         else
3042           return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym), 0);
3043       }
3044
3045   symtab_and_line val;
3046   val.pspace = current_program_space;
3047
3048   cust = find_pc_sect_compunit_symtab (pc, section);
3049   if (cust == NULL)
3050     {
3051       /* If no symbol information, return previous pc.  */
3052       if (notcurrent)
3053         pc++;
3054       val.pc = pc;
3055       return val;
3056     }
3057
3058   bv = COMPUNIT_BLOCKVECTOR (cust);
3059
3060   /* Look at all the symtabs that share this blockvector.
3061      They all have the same apriori range, that we found was right;
3062      but they have different line tables.  */
3063
3064   ALL_COMPUNIT_FILETABS (cust, iter_s)
3065     {
3066       /* Find the best line in this symtab.  */
3067       l = SYMTAB_LINETABLE (iter_s);
3068       if (!l)
3069         continue;
3070       len = l->nitems;
3071       if (len <= 0)
3072         {
3073           /* I think len can be zero if the symtab lacks line numbers
3074              (e.g. gcc -g1).  (Either that or the LINETABLE is NULL;
3075              I'm not sure which, and maybe it depends on the symbol
3076              reader).  */
3077           continue;
3078         }
3079
3080       prev = NULL;
3081       item = l->item;           /* Get first line info.  */
3082
3083       /* Is this file's first line closer than the first lines of other files?
3084          If so, record this file, and its first line, as best alternate.  */
3085       if (item->pc > pc && (!alt || item->pc < alt->pc))
3086         alt = item;
3087
3088       for (i = 0; i < len; i++, item++)
3089         {
3090           /* Leave prev pointing to the linetable entry for the last line
3091              that started at or before PC.  */
3092           if (item->pc > pc)
3093             break;
3094
3095           prev = item;
3096         }
3097
3098       /* At this point, prev points at the line whose start addr is <= pc, and
3099          item points at the next line.  If we ran off the end of the linetable
3100          (pc >= start of the last line), then prev == item.  If pc < start of
3101          the first line, prev will not be set.  */
3102
3103       /* Is this file's best line closer than the best in the other files?
3104          If so, record this file, and its best line, as best so far.  Don't
3105          save prev if it represents the end of a function (i.e. line number
3106          0) instead of a real line.  */
3107
3108       if (prev && prev->line && (!best || prev->pc > best->pc))
3109         {
3110           best = prev;
3111           best_symtab = iter_s;
3112
3113           /* Discard BEST_END if it's before the PC of the current BEST.  */
3114           if (best_end <= best->pc)
3115             best_end = 0;
3116         }
3117
3118       /* If another line (denoted by ITEM) is in the linetable and its
3119          PC is after BEST's PC, but before the current BEST_END, then
3120          use ITEM's PC as the new best_end.  */
3121       if (best && i < len && item->pc > best->pc
3122           && (best_end == 0 || best_end > item->pc))
3123         best_end = item->pc;
3124     }
3125
3126   if (!best_symtab)
3127     {
3128       /* If we didn't find any line number info, just return zeros.
3129          We used to return alt->line - 1 here, but that could be
3130          anywhere; if we don't have line number info for this PC,
3131          don't make some up.  */
3132       val.pc = pc;
3133     }
3134   else if (best->line == 0)
3135     {
3136       /* If our best fit is in a range of PC's for which no line
3137          number info is available (line number is zero) then we didn't
3138          find any valid line information.  */
3139       val.pc = pc;
3140     }
3141   else
3142     {
3143       val.symtab = best_symtab;
3144       val.line = best->line;
3145       val.pc = best->pc;
3146       if (best_end && (!alt || best_end < alt->pc))
3147         val.end = best_end;
3148       else if (alt)
3149         val.end = alt->pc;
3150       else
3151         val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
3152     }
3153   val.section = section;
3154   return val;
3155 }
3156
3157 /* Backward compatibility (no section).  */
3158
3159 struct symtab_and_line
3160 find_pc_line (CORE_ADDR pc, int notcurrent)
3161 {
3162   struct obj_section *section;
3163
3164   section = find_pc_overlay (pc);
3165   if (pc_in_unmapped_range (pc, section))
3166     pc = overlay_mapped_address (pc, section);
3167   return find_pc_sect_line (pc, section, notcurrent);
3168 }
3169
3170 /* See symtab.h.  */
3171
3172 struct symtab *
3173 find_pc_line_symtab (CORE_ADDR pc)
3174 {
3175   struct symtab_and_line sal;
3176
3177   /* This always passes zero for NOTCURRENT to find_pc_line.
3178      There are currently no callers that ever pass non-zero.  */
3179   sal = find_pc_line (pc, 0);
3180   return sal.symtab;
3181 }
3182 \f
3183 /* Find line number LINE in any symtab whose name is the same as
3184    SYMTAB.
3185
3186    If found, return the symtab that contains the linetable in which it was
3187    found, set *INDEX to the index in the linetable of the best entry
3188    found, and set *EXACT_MATCH nonzero if the value returned is an
3189    exact match.
3190
3191    If not found, return NULL.  */
3192
3193 struct symtab *
3194 find_line_symtab (struct symtab *symtab, int line,
3195                   int *index, int *exact_match)
3196 {
3197   int exact = 0;  /* Initialized here to avoid a compiler warning.  */
3198
3199   /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3200      so far seen.  */
3201
3202   int best_index;
3203   struct linetable *best_linetable;
3204   struct symtab *best_symtab;
3205
3206   /* First try looking it up in the given symtab.  */
3207   best_linetable = SYMTAB_LINETABLE (symtab);
3208   best_symtab = symtab;
3209   best_index = find_line_common (best_linetable, line, &exact, 0);
3210   if (best_index < 0 || !exact)
3211     {
3212       /* Didn't find an exact match.  So we better keep looking for
3213          another symtab with the same name.  In the case of xcoff,
3214          multiple csects for one source file (produced by IBM's FORTRAN
3215          compiler) produce multiple symtabs (this is unavoidable
3216          assuming csects can be at arbitrary places in memory and that
3217          the GLOBAL_BLOCK of a symtab has a begin and end address).  */
3218
3219       /* BEST is the smallest linenumber > LINE so far seen,
3220          or 0 if none has been seen so far.
3221          BEST_INDEX and BEST_LINETABLE identify the item for it.  */
3222       int best;
3223
3224       struct objfile *objfile;
3225       struct compunit_symtab *cu;
3226       struct symtab *s;
3227
3228       if (best_index >= 0)
3229         best = best_linetable->item[best_index].line;
3230       else
3231         best = 0;
3232
3233       ALL_OBJFILES (objfile)
3234       {
3235         if (objfile->sf)
3236           objfile->sf->qf->expand_symtabs_with_fullname (objfile,
3237                                                    symtab_to_fullname (symtab));
3238       }
3239
3240       ALL_FILETABS (objfile, cu, s)
3241       {
3242         struct linetable *l;
3243         int ind;
3244
3245         if (FILENAME_CMP (symtab->filename, s->filename) != 0)
3246           continue;
3247         if (FILENAME_CMP (symtab_to_fullname (symtab),
3248                           symtab_to_fullname (s)) != 0)
3249           continue;     
3250         l = SYMTAB_LINETABLE (s);
3251         ind = find_line_common (l, line, &exact, 0);
3252         if (ind >= 0)
3253           {
3254             if (exact)
3255               {
3256                 best_index = ind;
3257                 best_linetable = l;
3258                 best_symtab = s;
3259                 goto done;
3260               }
3261             if (best == 0 || l->item[ind].line < best)
3262               {
3263                 best = l->item[ind].line;
3264                 best_index = ind;
3265                 best_linetable = l;
3266                 best_symtab = s;
3267               }
3268           }
3269       }
3270     }
3271 done:
3272   if (best_index < 0)
3273     return NULL;
3274
3275   if (index)
3276     *index = best_index;
3277   if (exact_match)
3278     *exact_match = exact;
3279
3280   return best_symtab;
3281 }
3282
3283 /* Given SYMTAB, returns all the PCs function in the symtab that
3284    exactly match LINE.  Returns an empty vector if there are no exact
3285    matches, but updates BEST_ITEM in this case.  */
3286
3287 std::vector<CORE_ADDR>
3288 find_pcs_for_symtab_line (struct symtab *symtab, int line,
3289                           struct linetable_entry **best_item)
3290 {
3291   int start = 0;
3292   std::vector<CORE_ADDR> result;
3293
3294   /* First, collect all the PCs that are at this line.  */
3295   while (1)
3296     {
3297       int was_exact;
3298       int idx;
3299
3300       idx = find_line_common (SYMTAB_LINETABLE (symtab), line, &was_exact,
3301                               start);
3302       if (idx < 0)
3303         break;
3304
3305       if (!was_exact)
3306         {
3307           struct linetable_entry *item = &SYMTAB_LINETABLE (symtab)->item[idx];
3308
3309           if (*best_item == NULL || item->line < (*best_item)->line)
3310             *best_item = item;
3311
3312           break;
3313         }
3314
3315       result.push_back (SYMTAB_LINETABLE (symtab)->item[idx].pc);
3316       start = idx + 1;
3317     }
3318
3319   return result;
3320 }
3321
3322 \f
3323 /* Set the PC value for a given source file and line number and return true.
3324    Returns zero for invalid line number (and sets the PC to 0).
3325    The source file is specified with a struct symtab.  */
3326
3327 int
3328 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
3329 {
3330   struct linetable *l;
3331   int ind;
3332
3333   *pc = 0;
3334   if (symtab == 0)
3335     return 0;
3336
3337   symtab = find_line_symtab (symtab, line, &ind, NULL);
3338   if (symtab != NULL)
3339     {
3340       l = SYMTAB_LINETABLE (symtab);
3341       *pc = l->item[ind].pc;
3342       return 1;
3343     }
3344   else
3345     return 0;
3346 }
3347
3348 /* Find the range of pc values in a line.
3349    Store the starting pc of the line into *STARTPTR
3350    and the ending pc (start of next line) into *ENDPTR.
3351    Returns 1 to indicate success.
3352    Returns 0 if could not find the specified line.  */
3353
3354 int
3355 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
3356                     CORE_ADDR *endptr)
3357 {
3358   CORE_ADDR startaddr;
3359   struct symtab_and_line found_sal;
3360
3361   startaddr = sal.pc;
3362   if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
3363     return 0;
3364
3365   /* This whole function is based on address.  For example, if line 10 has
3366      two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3367      "info line *0x123" should say the line goes from 0x100 to 0x200
3368      and "info line *0x355" should say the line goes from 0x300 to 0x400.
3369      This also insures that we never give a range like "starts at 0x134
3370      and ends at 0x12c".  */
3371
3372   found_sal = find_pc_sect_line (startaddr, sal.section, 0);
3373   if (found_sal.line != sal.line)
3374     {
3375       /* The specified line (sal) has zero bytes.  */
3376       *startptr = found_sal.pc;
3377       *endptr = found_sal.pc;
3378     }
3379   else
3380     {
3381       *startptr = found_sal.pc;
3382       *endptr = found_sal.end;
3383     }
3384   return 1;
3385 }
3386
3387 /* Given a line table and a line number, return the index into the line
3388    table for the pc of the nearest line whose number is >= the specified one.
3389    Return -1 if none is found.  The value is >= 0 if it is an index.
3390    START is the index at which to start searching the line table.
3391
3392    Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
3393
3394 static int
3395 find_line_common (struct linetable *l, int lineno,
3396                   int *exact_match, int start)
3397 {
3398   int i;
3399   int len;
3400
3401   /* BEST is the smallest linenumber > LINENO so far seen,
3402      or 0 if none has been seen so far.
3403      BEST_INDEX identifies the item for it.  */
3404
3405   int best_index = -1;
3406   int best = 0;
3407
3408   *exact_match = 0;
3409
3410   if (lineno <= 0)
3411     return -1;
3412   if (l == 0)
3413     return -1;
3414
3415   len = l->nitems;
3416   for (i = start; i < len; i++)
3417     {
3418       struct linetable_entry *item = &(l->item[i]);
3419
3420       if (item->line == lineno)
3421         {
3422           /* Return the first (lowest address) entry which matches.  */
3423           *exact_match = 1;
3424           return i;
3425         }
3426
3427       if (item->line > lineno && (best == 0 || item->line < best))
3428         {
3429           best = item->line;
3430           best_index = i;
3431         }
3432     }
3433
3434   /* If we got here, we didn't get an exact match.  */
3435   return best_index;
3436 }
3437
3438 int
3439 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
3440 {
3441   struct symtab_and_line sal;
3442
3443   sal = find_pc_line (pc, 0);
3444   *startptr = sal.pc;
3445   *endptr = sal.end;
3446   return sal.symtab != 0;
3447 }
3448
3449 /* Given a function symbol SYM, find the symtab and line for the start
3450    of the function.
3451    If the argument FUNFIRSTLINE is nonzero, we want the first line
3452    of real code inside the function.
3453    This function should return SALs matching those from minsym_found,
3454    otherwise false multiple-locations breakpoints could be placed.  */
3455
3456 struct symtab_and_line
3457 find_function_start_sal (struct symbol *sym, int funfirstline)
3458 {
3459   fixup_symbol_section (sym, NULL);
3460
3461   obj_section *section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
3462   symtab_and_line sal
3463     = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
3464   sal.symbol = sym;
3465
3466   if (funfirstline && sal.symtab != NULL
3467       && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
3468           || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
3469     {
3470       struct gdbarch *gdbarch = symbol_arch (sym);
3471
3472       sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3473       if (gdbarch_skip_entrypoint_p (gdbarch))
3474         sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
3475       return sal;
3476     }
3477
3478   /* We always should have a line for the function start address.
3479      If we don't, something is odd.  Create a plain SAL refering
3480      just the PC and hope that skip_prologue_sal (if requested)
3481      can find a line number for after the prologue.  */
3482   if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
3483     {
3484       sal = {};
3485       sal.pspace = current_program_space;
3486       sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3487       sal.section = section;
3488       sal.symbol = sym;
3489     }
3490
3491   if (funfirstline)
3492     skip_prologue_sal (&sal);
3493
3494   return sal;
3495 }
3496
3497 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3498    address for that function that has an entry in SYMTAB's line info
3499    table.  If such an entry cannot be found, return FUNC_ADDR
3500    unaltered.  */
3501
3502 static CORE_ADDR
3503 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
3504 {
3505   CORE_ADDR func_start, func_end;
3506   struct linetable *l;
3507   int i;
3508
3509   /* Give up if this symbol has no lineinfo table.  */
3510   l = SYMTAB_LINETABLE (symtab);
3511   if (l == NULL)
3512     return func_addr;
3513
3514   /* Get the range for the function's PC values, or give up if we
3515      cannot, for some reason.  */
3516   if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
3517     return func_addr;
3518
3519   /* Linetable entries are ordered by PC values, see the commentary in
3520      symtab.h where `struct linetable' is defined.  Thus, the first
3521      entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3522      address we are looking for.  */
3523   for (i = 0; i < l->nitems; i++)
3524     {
3525       struct linetable_entry *item = &(l->item[i]);
3526
3527       /* Don't use line numbers of zero, they mark special entries in
3528          the table.  See the commentary on symtab.h before the
3529          definition of struct linetable.  */
3530       if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
3531         return item->pc;
3532     }
3533
3534   return func_addr;
3535 }
3536
3537 /* Adjust SAL to the first instruction past the function prologue.
3538    If the PC was explicitly specified, the SAL is not changed.
3539    If the line number was explicitly specified, at most the SAL's PC
3540    is updated.  If SAL is already past the prologue, then do nothing.  */
3541
3542 void
3543 skip_prologue_sal (struct symtab_and_line *sal)
3544 {
3545   struct symbol *sym;
3546   struct symtab_and_line start_sal;
3547   CORE_ADDR pc, saved_pc;
3548   struct obj_section *section;
3549   const char *name;
3550   struct objfile *objfile;
3551   struct gdbarch *gdbarch;
3552   const struct block *b, *function_block;
3553   int force_skip, skip;
3554
3555   /* Do not change the SAL if PC was specified explicitly.  */
3556   if (sal->explicit_pc)
3557     return;
3558
3559   scoped_restore_current_pspace_and_thread restore_pspace_thread;
3560
3561   switch_to_program_space_and_thread (sal->pspace);
3562
3563   sym = find_pc_sect_function (sal->pc, sal->section);
3564   if (sym != NULL)
3565     {
3566       fixup_symbol_section (sym, NULL);
3567
3568       objfile = symbol_objfile (sym);
3569       pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3570       section = SYMBOL_OBJ_SECTION (objfile, sym);
3571       name = SYMBOL_LINKAGE_NAME (sym);
3572     }
3573   else
3574     {
3575       struct bound_minimal_symbol msymbol
3576         = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
3577
3578       if (msymbol.minsym == NULL)
3579         return;
3580
3581       objfile = msymbol.objfile;
3582       pc = BMSYMBOL_VALUE_ADDRESS (msymbol);
3583       section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
3584       name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
3585     }
3586
3587   gdbarch = get_objfile_arch (objfile);
3588
3589   /* Process the prologue in two passes.  In the first pass try to skip the
3590      prologue (SKIP is true) and verify there is a real need for it (indicated
3591      by FORCE_SKIP).  If no such reason was found run a second pass where the
3592      prologue is not skipped (SKIP is false).  */
3593
3594   skip = 1;
3595   force_skip = 1;
3596
3597   /* Be conservative - allow direct PC (without skipping prologue) only if we
3598      have proven the CU (Compilation Unit) supports it.  sal->SYMTAB does not
3599      have to be set by the caller so we use SYM instead.  */
3600   if (sym != NULL
3601       && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym))))
3602     force_skip = 0;
3603
3604   saved_pc = pc;
3605   do
3606     {
3607       pc = saved_pc;
3608
3609       /* If the function is in an unmapped overlay, use its unmapped LMA address,
3610          so that gdbarch_skip_prologue has something unique to work on.  */
3611       if (section_is_overlay (section) && !section_is_mapped (section))
3612         pc = overlay_unmapped_address (pc, section);
3613
3614       /* Skip "first line" of function (which is actually its prologue).  */
3615       pc += gdbarch_deprecated_function_start_offset (gdbarch);
3616       if (gdbarch_skip_entrypoint_p (gdbarch))
3617         pc = gdbarch_skip_entrypoint (gdbarch, pc);
3618       if (skip)
3619         pc = gdbarch_skip_prologue_noexcept (gdbarch, pc);
3620
3621       /* For overlays, map pc back into its mapped VMA range.  */
3622       pc = overlay_mapped_address (pc, section);
3623
3624       /* Calculate line number.  */
3625       start_sal = find_pc_sect_line (pc, section, 0);
3626
3627       /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3628          line is still part of the same function.  */
3629       if (skip && start_sal.pc != pc
3630           && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
3631                      && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
3632               : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
3633                  == lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
3634         {
3635           /* First pc of next line */
3636           pc = start_sal.end;
3637           /* Recalculate the line number (might not be N+1).  */
3638           start_sal = find_pc_sect_line (pc, section, 0);
3639         }
3640
3641       /* On targets with executable formats that don't have a concept of
3642          constructors (ELF with .init has, PE doesn't), gcc emits a call
3643          to `__main' in `main' between the prologue and before user
3644          code.  */
3645       if (gdbarch_skip_main_prologue_p (gdbarch)
3646           && name && strcmp_iw (name, "main") == 0)
3647         {
3648           pc = gdbarch_skip_main_prologue (gdbarch, pc);
3649           /* Recalculate the line number (might not be N+1).  */
3650           start_sal = find_pc_sect_line (pc, section, 0);
3651           force_skip = 1;
3652         }
3653     }
3654   while (!force_skip && skip--);
3655
3656   /* If we still don't have a valid source line, try to find the first
3657      PC in the lineinfo table that belongs to the same function.  This
3658      happens with COFF debug info, which does not seem to have an
3659      entry in lineinfo table for the code after the prologue which has
3660      no direct relation to source.  For example, this was found to be
3661      the case with the DJGPP target using "gcc -gcoff" when the
3662      compiler inserted code after the prologue to make sure the stack
3663      is aligned.  */
3664   if (!force_skip && sym && start_sal.symtab == NULL)
3665     {
3666       pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
3667       /* Recalculate the line number.  */
3668       start_sal = find_pc_sect_line (pc, section, 0);
3669     }
3670
3671   /* If we're already past the prologue, leave SAL unchanged.  Otherwise
3672      forward SAL to the end of the prologue.  */
3673   if (sal->pc >= pc)
3674     return;
3675
3676   sal->pc = pc;
3677   sal->section = section;
3678
3679   /* Unless the explicit_line flag was set, update the SAL line
3680      and symtab to correspond to the modified PC location.  */
3681   if (sal->explicit_line)
3682     return;
3683
3684   sal->symtab = start_sal.symtab;
3685   sal->line = start_sal.line;
3686   sal->end = start_sal.end;
3687
3688   /* Check if we are now inside an inlined function.  If we can,
3689      use the call site of the function instead.  */
3690   b = block_for_pc_sect (sal->pc, sal->section);
3691   function_block = NULL;
3692   while (b != NULL)
3693     {
3694       if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
3695         function_block = b;
3696       else if (BLOCK_FUNCTION (b) != NULL)
3697         break;
3698       b = BLOCK_SUPERBLOCK (b);
3699     }
3700   if (function_block != NULL
3701       && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
3702     {
3703       sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
3704       sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
3705     }
3706 }
3707
3708 /* Given PC at the function's start address, attempt to find the
3709    prologue end using SAL information.  Return zero if the skip fails.
3710
3711    A non-optimized prologue traditionally has one SAL for the function
3712    and a second for the function body.  A single line function has
3713    them both pointing at the same line.
3714
3715    An optimized prologue is similar but the prologue may contain
3716    instructions (SALs) from the instruction body.  Need to skip those
3717    while not getting into the function body.
3718
3719    The functions end point and an increasing SAL line are used as
3720    indicators of the prologue's endpoint.
3721
3722    This code is based on the function refine_prologue_limit
3723    (found in ia64).  */
3724
3725 CORE_ADDR
3726 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
3727 {
3728   struct symtab_and_line prologue_sal;
3729   CORE_ADDR start_pc;
3730   CORE_ADDR end_pc;
3731   const struct block *bl;
3732
3733   /* Get an initial range for the function.  */
3734   find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
3735   start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
3736
3737   prologue_sal = find_pc_line (start_pc, 0);
3738   if (prologue_sal.line != 0)
3739     {
3740       /* For languages other than assembly, treat two consecutive line
3741          entries at the same address as a zero-instruction prologue.
3742          The GNU assembler emits separate line notes for each instruction
3743          in a multi-instruction macro, but compilers generally will not
3744          do this.  */
3745       if (prologue_sal.symtab->language != language_asm)
3746         {
3747           struct linetable *linetable = SYMTAB_LINETABLE (prologue_sal.symtab);
3748           int idx = 0;
3749
3750           /* Skip any earlier lines, and any end-of-sequence marker
3751              from a previous function.  */
3752           while (linetable->item[idx].pc != prologue_sal.pc
3753                  || linetable->item[idx].line == 0)
3754             idx++;
3755
3756           if (idx+1 < linetable->nitems
3757               && linetable->item[idx+1].line != 0
3758               && linetable->item[idx+1].pc == start_pc)
3759             return start_pc;
3760         }
3761
3762       /* If there is only one sal that covers the entire function,
3763          then it is probably a single line function, like
3764          "foo(){}".  */
3765       if (prologue_sal.end >= end_pc)
3766         return 0;
3767
3768       while (prologue_sal.end < end_pc)
3769         {
3770           struct symtab_and_line sal;
3771
3772           sal = find_pc_line (prologue_sal.end, 0);
3773           if (sal.line == 0)
3774             break;
3775           /* Assume that a consecutive SAL for the same (or larger)
3776              line mark the prologue -> body transition.  */
3777           if (sal.line >= prologue_sal.line)
3778             break;
3779           /* Likewise if we are in a different symtab altogether
3780              (e.g. within a file included via #include).  */
3781           if (sal.symtab != prologue_sal.symtab)
3782             break;
3783
3784           /* The line number is smaller.  Check that it's from the
3785              same function, not something inlined.  If it's inlined,
3786              then there is no point comparing the line numbers.  */
3787           bl = block_for_pc (prologue_sal.end);
3788           while (bl)
3789             {
3790               if (block_inlined_p (bl))
3791                 break;
3792               if (BLOCK_FUNCTION (bl))
3793                 {
3794                   bl = NULL;
3795                   break;
3796                 }
3797               bl = BLOCK_SUPERBLOCK (bl);
3798             }
3799           if (bl != NULL)
3800             break;
3801
3802           /* The case in which compiler's optimizer/scheduler has
3803              moved instructions into the prologue.  We look ahead in
3804              the function looking for address ranges whose
3805              corresponding line number is less the first one that we
3806              found for the function.  This is more conservative then
3807              refine_prologue_limit which scans a large number of SALs
3808              looking for any in the prologue.  */
3809           prologue_sal = sal;
3810         }
3811     }
3812
3813   if (prologue_sal.end < end_pc)
3814     /* Return the end of this line, or zero if we could not find a
3815        line.  */
3816     return prologue_sal.end;
3817   else
3818     /* Don't return END_PC, which is past the end of the function.  */
3819     return prologue_sal.pc;
3820 }
3821
3822 /* See symtab.h.  */
3823
3824 symbol *
3825 find_function_alias_target (bound_minimal_symbol msymbol)
3826 {
3827   if (!msymbol_is_text (msymbol.minsym))
3828     return NULL;
3829
3830   CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
3831   symbol *sym = find_pc_function (addr);
3832   if (sym != NULL
3833       && SYMBOL_CLASS (sym) == LOC_BLOCK
3834       && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == addr)
3835     return sym;
3836
3837   return NULL;
3838 }
3839
3840 \f
3841 /* If P is of the form "operator[ \t]+..." where `...' is
3842    some legitimate operator text, return a pointer to the
3843    beginning of the substring of the operator text.
3844    Otherwise, return "".  */
3845
3846 static const char *
3847 operator_chars (const char *p, const char **end)
3848 {
3849   *end = "";
3850   if (!startswith (p, CP_OPERATOR_STR))
3851     return *end;
3852   p += CP_OPERATOR_LEN;
3853
3854   /* Don't get faked out by `operator' being part of a longer
3855      identifier.  */
3856   if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
3857     return *end;
3858
3859   /* Allow some whitespace between `operator' and the operator symbol.  */
3860   while (*p == ' ' || *p == '\t')
3861     p++;
3862
3863   /* Recognize 'operator TYPENAME'.  */
3864
3865   if (isalpha (*p) || *p == '_' || *p == '$')
3866     {
3867       const char *q = p + 1;
3868
3869       while (isalnum (*q) || *q == '_' || *q == '$')
3870         q++;
3871       *end = q;
3872       return p;
3873     }
3874
3875   while (*p)
3876     switch (*p)
3877       {
3878       case '\\':                        /* regexp quoting */
3879         if (p[1] == '*')
3880           {
3881             if (p[2] == '=')            /* 'operator\*=' */
3882               *end = p + 3;
3883             else                        /* 'operator\*'  */
3884               *end = p + 2;
3885             return p;
3886           }
3887         else if (p[1] == '[')
3888           {
3889             if (p[2] == ']')
3890               error (_("mismatched quoting on brackets, "
3891                        "try 'operator\\[\\]'"));
3892             else if (p[2] == '\\' && p[3] == ']')
3893               {
3894                 *end = p + 4;   /* 'operator\[\]' */
3895                 return p;
3896               }
3897             else
3898               error (_("nothing is allowed between '[' and ']'"));
3899           }
3900         else
3901           {
3902             /* Gratuitous qoute: skip it and move on.  */
3903             p++;
3904             continue;
3905           }
3906         break;
3907       case '!':
3908       case '=':
3909       case '*':
3910       case '/':
3911       case '%':
3912       case '^':
3913         if (p[1] == '=')
3914           *end = p + 2;
3915         else
3916           *end = p + 1;
3917         return p;
3918       case '<':
3919       case '>':
3920       case '+':
3921       case '-':
3922       case '&':
3923       case '|':
3924         if (p[0] == '-' && p[1] == '>')
3925           {
3926             /* Struct pointer member operator 'operator->'.  */
3927             if (p[2] == '*')
3928               {
3929                 *end = p + 3;   /* 'operator->*' */
3930                 return p;
3931               }
3932             else if (p[2] == '\\')
3933               {
3934                 *end = p + 4;   /* Hopefully 'operator->\*' */
3935                 return p;
3936               }
3937             else
3938               {
3939                 *end = p + 2;   /* 'operator->' */
3940                 return p;
3941               }
3942           }
3943         if (p[1] == '=' || p[1] == p[0])
3944           *end = p + 2;
3945         else
3946           *end = p + 1;
3947         return p;
3948       case '~':
3949       case ',':
3950         *end = p + 1;
3951         return p;
3952       case '(':
3953         if (p[1] != ')')
3954           error (_("`operator ()' must be specified "
3955                    "without whitespace in `()'"));
3956         *end = p + 2;
3957         return p;
3958       case '?':
3959         if (p[1] != ':')
3960           error (_("`operator ?:' must be specified "
3961                    "without whitespace in `?:'"));
3962         *end = p + 2;
3963         return p;
3964       case '[':
3965         if (p[1] != ']')
3966           error (_("`operator []' must be specified "
3967                    "without whitespace in `[]'"));
3968         *end = p + 2;
3969         return p;
3970       default:
3971         error (_("`operator %s' not supported"), p);
3972         break;
3973       }
3974
3975   *end = "";
3976   return *end;
3977 }
3978 \f
3979
3980 /* Data structure to maintain printing state for output_source_filename.  */
3981
3982 struct output_source_filename_data
3983 {
3984   /* Cache of what we've seen so far.  */
3985   struct filename_seen_cache *filename_seen_cache;
3986
3987   /* Flag of whether we're printing the first one.  */
3988   int first;
3989 };
3990
3991 /* Slave routine for sources_info.  Force line breaks at ,'s.
3992    NAME is the name to print.
3993    DATA contains the state for printing and watching for duplicates.  */
3994
3995 static void
3996 output_source_filename (const char *name,
3997                         struct output_source_filename_data *data)
3998 {
3999   /* Since a single source file can result in several partial symbol
4000      tables, we need to avoid printing it more than once.  Note: if
4001      some of the psymtabs are read in and some are not, it gets
4002      printed both under "Source files for which symbols have been
4003      read" and "Source files for which symbols will be read in on
4004      demand".  I consider this a reasonable way to deal with the
4005      situation.  I'm not sure whether this can also happen for
4006      symtabs; it doesn't hurt to check.  */
4007
4008   /* Was NAME already seen?  */
4009   if (data->filename_seen_cache->seen (name))
4010     {
4011       /* Yes; don't print it again.  */
4012       return;
4013     }
4014
4015   /* No; print it and reset *FIRST.  */
4016   if (! data->first)
4017     printf_filtered (", ");
4018   data->first = 0;
4019
4020   wrap_here ("");
4021   fputs_filtered (name, gdb_stdout);
4022 }
4023
4024 /* A callback for map_partial_symbol_filenames.  */
4025
4026 static void
4027 output_partial_symbol_filename (const char *filename, const char *fullname,
4028                                 void *data)
4029 {
4030   output_source_filename (fullname ? fullname : filename,
4031                           (struct output_source_filename_data *) data);
4032 }
4033
4034 static void
4035 info_sources_command (char *ignore, int from_tty)
4036 {
4037   struct compunit_symtab *cu;
4038   struct symtab *s;
4039   struct objfile *objfile;
4040   struct output_source_filename_data data;
4041
4042   if (!have_full_symbols () && !have_partial_symbols ())
4043     {
4044       error (_("No symbol table is loaded.  Use the \"file\" command."));
4045     }
4046
4047   filename_seen_cache filenames_seen;
4048
4049   data.filename_seen_cache = &filenames_seen;
4050
4051   printf_filtered ("Source files for which symbols have been read in:\n\n");
4052
4053   data.first = 1;
4054   ALL_FILETABS (objfile, cu, s)
4055   {
4056     const char *fullname = symtab_to_fullname (s);
4057
4058     output_source_filename (fullname, &data);
4059   }
4060   printf_filtered ("\n\n");
4061
4062   printf_filtered ("Source files for which symbols "
4063                    "will be read in on demand:\n\n");
4064
4065   filenames_seen.clear ();
4066   data.first = 1;
4067   map_symbol_filenames (output_partial_symbol_filename, &data,
4068                         1 /*need_fullname*/);
4069   printf_filtered ("\n");
4070 }
4071
4072 /* Compare FILE against all the NFILES entries of FILES.  If BASENAMES is
4073    non-zero compare only lbasename of FILES.  */
4074
4075 static int
4076 file_matches (const char *file, const char *files[], int nfiles, int basenames)
4077 {
4078   int i;
4079
4080   if (file != NULL && nfiles != 0)
4081     {
4082       for (i = 0; i < nfiles; i++)
4083         {
4084           if (compare_filenames_for_search (file, (basenames
4085                                                    ? lbasename (files[i])
4086                                                    : files[i])))
4087             return 1;
4088         }
4089     }
4090   else if (nfiles == 0)
4091     return 1;
4092   return 0;
4093 }
4094
4095 /* Free any memory associated with a search.  */
4096
4097 void
4098 free_search_symbols (struct symbol_search *symbols)
4099 {
4100   struct symbol_search *p;
4101   struct symbol_search *next;
4102
4103   for (p = symbols; p != NULL; p = next)
4104     {
4105       next = p->next;
4106       xfree (p);
4107     }
4108 }
4109
4110 static void
4111 do_free_search_symbols_cleanup (void *symbolsp)
4112 {
4113   struct symbol_search *symbols = *(struct symbol_search **) symbolsp;
4114
4115   free_search_symbols (symbols);
4116 }
4117
4118 struct cleanup *
4119 make_cleanup_free_search_symbols (struct symbol_search **symbolsp)
4120 {
4121   return make_cleanup (do_free_search_symbols_cleanup, symbolsp);
4122 }
4123
4124 /* Helper function for sort_search_symbols_remove_dups and qsort.  Can only
4125    sort symbols, not minimal symbols.  */
4126
4127 static int
4128 compare_search_syms (const void *sa, const void *sb)
4129 {
4130   struct symbol_search *sym_a = *(struct symbol_search **) sa;
4131   struct symbol_search *sym_b = *(struct symbol_search **) sb;
4132   int c;
4133
4134   c = FILENAME_CMP (symbol_symtab (sym_a->symbol)->filename,
4135                     symbol_symtab (sym_b->symbol)->filename);
4136   if (c != 0)
4137     return c;
4138
4139   if (sym_a->block != sym_b->block)
4140     return sym_a->block - sym_b->block;
4141
4142   return strcmp (SYMBOL_PRINT_NAME (sym_a->symbol),
4143                  SYMBOL_PRINT_NAME (sym_b->symbol));
4144 }
4145
4146 /* Sort the NFOUND symbols in list FOUND and remove duplicates.
4147    The duplicates are freed, and the new list is returned in
4148    *NEW_HEAD, *NEW_TAIL.  */
4149
4150 static void
4151 sort_search_symbols_remove_dups (struct symbol_search *found, int nfound,
4152                                  struct symbol_search **new_head,
4153                                  struct symbol_search **new_tail)
4154 {
4155   struct symbol_search **symbols, *symp;
4156   int i, j, nunique;
4157
4158   gdb_assert (found != NULL && nfound > 0);
4159
4160   /* Build an array out of the list so we can easily sort them.  */
4161   symbols = XNEWVEC (struct symbol_search *, nfound);
4162
4163   symp = found;
4164   for (i = 0; i < nfound; i++)
4165     {
4166       gdb_assert (symp != NULL);
4167       gdb_assert (symp->block >= 0 && symp->block <= 1);
4168       symbols[i] = symp;
4169       symp = symp->next;
4170     }
4171   gdb_assert (symp == NULL);
4172
4173   qsort (symbols, nfound, sizeof (struct symbol_search *),
4174          compare_search_syms);
4175
4176   /* Collapse out the dups.  */
4177   for (i = 1, j = 1; i < nfound; ++i)
4178     {
4179       if (compare_search_syms (&symbols[j - 1], &symbols[i]) != 0)
4180         symbols[j++] = symbols[i];
4181       else
4182         xfree (symbols[i]);
4183     }
4184   nunique = j;
4185   symbols[j - 1]->next = NULL;
4186
4187   /* Rebuild the linked list.  */
4188   for (i = 0; i < nunique - 1; i++)
4189     symbols[i]->next = symbols[i + 1];
4190   symbols[nunique - 1]->next = NULL;
4191
4192   *new_head = symbols[0];
4193   *new_tail = symbols[nunique - 1];
4194   xfree (symbols);
4195 }
4196
4197 /* Search the symbol table for matches to the regular expression REGEXP,
4198    returning the results in *MATCHES.
4199
4200    Only symbols of KIND are searched:
4201    VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4202                       and constants (enums)
4203    FUNCTIONS_DOMAIN - search all functions
4204    TYPES_DOMAIN     - search all type names
4205    ALL_DOMAIN       - an internal error for this function
4206
4207    free_search_symbols should be called when *MATCHES is no longer needed.
4208
4209    Within each file the results are sorted locally; each symtab's global and
4210    static blocks are separately alphabetized.
4211    Duplicate entries are removed.  */
4212
4213 void
4214 search_symbols (const char *regexp, enum search_domain kind,
4215                 int nfiles, const char *files[],
4216                 struct symbol_search **matches)
4217 {
4218   struct compunit_symtab *cust;
4219   const struct blockvector *bv;
4220   struct block *b;
4221   int i = 0;
4222   struct block_iterator iter;
4223   struct symbol *sym;
4224   struct objfile *objfile;
4225   struct minimal_symbol *msymbol;
4226   int found_misc = 0;
4227   static const enum minimal_symbol_type types[]
4228     = {mst_data, mst_text, mst_abs};
4229   static const enum minimal_symbol_type types2[]
4230     = {mst_bss, mst_file_text, mst_abs};
4231   static const enum minimal_symbol_type types3[]
4232     = {mst_file_data, mst_solib_trampoline, mst_abs};
4233   static const enum minimal_symbol_type types4[]
4234     = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
4235   enum minimal_symbol_type ourtype;
4236   enum minimal_symbol_type ourtype2;
4237   enum minimal_symbol_type ourtype3;
4238   enum minimal_symbol_type ourtype4;
4239   struct symbol_search *found;
4240   struct symbol_search *tail;
4241   int nfound;
4242   gdb::optional<compiled_regex> preg;
4243
4244   /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
4245      CLEANUP_CHAIN is freed only in the case of an error.  */
4246   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
4247   struct cleanup *retval_chain;
4248
4249   gdb_assert (kind <= TYPES_DOMAIN);
4250
4251   ourtype = types[kind];
4252   ourtype2 = types2[kind];
4253   ourtype3 = types3[kind];
4254   ourtype4 = types4[kind];
4255
4256   *matches = NULL;
4257
4258   if (regexp != NULL)
4259     {
4260       /* Make sure spacing is right for C++ operators.
4261          This is just a courtesy to make the matching less sensitive
4262          to how many spaces the user leaves between 'operator'
4263          and <TYPENAME> or <OPERATOR>.  */
4264       const char *opend;
4265       const char *opname = operator_chars (regexp, &opend);
4266       int errcode;
4267
4268       if (*opname)
4269         {
4270           int fix = -1;         /* -1 means ok; otherwise number of
4271                                     spaces needed.  */
4272
4273           if (isalpha (*opname) || *opname == '_' || *opname == '$')
4274             {
4275               /* There should 1 space between 'operator' and 'TYPENAME'.  */
4276               if (opname[-1] != ' ' || opname[-2] == ' ')
4277                 fix = 1;
4278             }
4279           else
4280             {
4281               /* There should 0 spaces between 'operator' and 'OPERATOR'.  */
4282               if (opname[-1] == ' ')
4283                 fix = 0;
4284             }
4285           /* If wrong number of spaces, fix it.  */
4286           if (fix >= 0)
4287             {
4288               char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
4289
4290               sprintf (tmp, "operator%.*s%s", fix, " ", opname);
4291               regexp = tmp;
4292             }
4293         }
4294
4295       int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
4296                                 ? REG_ICASE : 0);
4297       preg.emplace (regexp, cflags, _("Invalid regexp"));
4298     }
4299
4300   /* Search through the partial symtabs *first* for all symbols
4301      matching the regexp.  That way we don't have to reproduce all of
4302      the machinery below.  */
4303   expand_symtabs_matching ([&] (const char *filename, bool basenames)
4304                            {
4305                              return file_matches (filename, files, nfiles,
4306                                                   basenames);
4307                            },
4308                            [&] (const char *symname)
4309                            {
4310                              return (!preg || preg->exec (symname,
4311                                                           0, NULL, 0) == 0);
4312                            },
4313                            NULL,
4314                            kind);
4315
4316   /* Here, we search through the minimal symbol tables for functions
4317      and variables that match, and force their symbols to be read.
4318      This is in particular necessary for demangled variable names,
4319      which are no longer put into the partial symbol tables.
4320      The symbol will then be found during the scan of symtabs below.
4321
4322      For functions, find_pc_symtab should succeed if we have debug info
4323      for the function, for variables we have to call
4324      lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4325      has debug info.
4326      If the lookup fails, set found_misc so that we will rescan to print
4327      any matching symbols without debug info.
4328      We only search the objfile the msymbol came from, we no longer search
4329      all objfiles.  In large programs (1000s of shared libs) searching all
4330      objfiles is not worth the pain.  */
4331
4332   if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
4333     {
4334       ALL_MSYMBOLS (objfile, msymbol)
4335       {
4336         QUIT;
4337
4338         if (msymbol->created_by_gdb)
4339           continue;
4340
4341         if (MSYMBOL_TYPE (msymbol) == ourtype
4342             || MSYMBOL_TYPE (msymbol) == ourtype2
4343             || MSYMBOL_TYPE (msymbol) == ourtype3
4344             || MSYMBOL_TYPE (msymbol) == ourtype4)
4345           {
4346             if (!preg
4347                 || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
4348                                NULL, 0) == 0)
4349               {
4350                 /* Note: An important side-effect of these lookup functions
4351                    is to expand the symbol table if msymbol is found, for the
4352                    benefit of the next loop on ALL_COMPUNITS.  */
4353                 if (kind == FUNCTIONS_DOMAIN
4354                     ? (find_pc_compunit_symtab
4355                        (MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL)
4356                     : (lookup_symbol_in_objfile_from_linkage_name
4357                        (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
4358                        .symbol == NULL))
4359                   found_misc = 1;
4360               }
4361           }
4362       }
4363     }
4364
4365   found = NULL;
4366   tail = NULL;
4367   nfound = 0;
4368   retval_chain = make_cleanup_free_search_symbols (&found);
4369
4370   ALL_COMPUNITS (objfile, cust)
4371   {
4372     bv = COMPUNIT_BLOCKVECTOR (cust);
4373     for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
4374       {
4375         b = BLOCKVECTOR_BLOCK (bv, i);
4376         ALL_BLOCK_SYMBOLS (b, iter, sym)
4377           {
4378             struct symtab *real_symtab = symbol_symtab (sym);
4379
4380             QUIT;
4381
4382             /* Check first sole REAL_SYMTAB->FILENAME.  It does not need to be
4383                a substring of symtab_to_fullname as it may contain "./" etc.  */
4384             if ((file_matches (real_symtab->filename, files, nfiles, 0)
4385                  || ((basenames_may_differ
4386                       || file_matches (lbasename (real_symtab->filename),
4387                                        files, nfiles, 1))
4388                      && file_matches (symtab_to_fullname (real_symtab),
4389                                       files, nfiles, 0)))
4390                 && ((!preg
4391                      || preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
4392                                     NULL, 0) == 0)
4393                     && ((kind == VARIABLES_DOMAIN
4394                          && SYMBOL_CLASS (sym) != LOC_TYPEDEF
4395                          && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
4396                          && SYMBOL_CLASS (sym) != LOC_BLOCK
4397                          /* LOC_CONST can be used for more than just enums,
4398                             e.g., c++ static const members.
4399                             We only want to skip enums here.  */
4400                          && !(SYMBOL_CLASS (sym) == LOC_CONST
4401                               && (TYPE_CODE (SYMBOL_TYPE (sym))
4402                                   == TYPE_CODE_ENUM)))
4403                         || (kind == FUNCTIONS_DOMAIN 
4404                             && SYMBOL_CLASS (sym) == LOC_BLOCK)
4405                         || (kind == TYPES_DOMAIN
4406                             && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
4407               {
4408                 /* match */
4409                 struct symbol_search *psr = XCNEW (struct symbol_search);
4410
4411                 psr->block = i;
4412                 psr->symbol = sym;
4413                 psr->next = NULL;
4414                 if (tail == NULL)
4415                   found = psr;
4416                 else
4417                   tail->next = psr;
4418                 tail = psr;
4419                 nfound ++;
4420               }
4421           }
4422       }
4423   }
4424
4425   if (found != NULL)
4426     {
4427       sort_search_symbols_remove_dups (found, nfound, &found, &tail);
4428       /* Note: nfound is no longer useful beyond this point.  */
4429     }
4430
4431   /* If there are no eyes, avoid all contact.  I mean, if there are
4432      no debug symbols, then add matching minsyms.  */
4433
4434   if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
4435     {
4436       ALL_MSYMBOLS (objfile, msymbol)
4437       {
4438         QUIT;
4439
4440         if (msymbol->created_by_gdb)
4441           continue;
4442
4443         if (MSYMBOL_TYPE (msymbol) == ourtype
4444             || MSYMBOL_TYPE (msymbol) == ourtype2
4445             || MSYMBOL_TYPE (msymbol) == ourtype3
4446             || MSYMBOL_TYPE (msymbol) == ourtype4)
4447           {
4448             if (!preg || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
4449                                      NULL, 0) == 0)
4450               {
4451                 /* For functions we can do a quick check of whether the
4452                    symbol might be found via find_pc_symtab.  */
4453                 if (kind != FUNCTIONS_DOMAIN
4454                     || (find_pc_compunit_symtab
4455                         (MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL))
4456                   {
4457                     if (lookup_symbol_in_objfile_from_linkage_name
4458                         (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
4459                         .symbol == NULL)
4460                       {
4461                         /* match */
4462                         struct symbol_search *psr = XNEW (struct symbol_search);
4463                         psr->block = i;
4464                         psr->msymbol.minsym = msymbol;
4465                         psr->msymbol.objfile = objfile;
4466                         psr->symbol = NULL;
4467                         psr->next = NULL;
4468                         if (tail == NULL)
4469                           found = psr;
4470                         else
4471                           tail->next = psr;
4472                         tail = psr;
4473                       }
4474                   }
4475               }
4476           }
4477       }
4478     }
4479
4480   discard_cleanups (retval_chain);
4481   do_cleanups (old_chain);
4482   *matches = found;
4483 }
4484
4485 /* Helper function for symtab_symbol_info, this function uses
4486    the data returned from search_symbols() to print information
4487    regarding the match to gdb_stdout.  */
4488
4489 static void
4490 print_symbol_info (enum search_domain kind,
4491                    struct symbol *sym,
4492                    int block, const char *last)
4493 {
4494   struct symtab *s = symbol_symtab (sym);
4495   const char *s_filename = symtab_to_filename_for_display (s);
4496
4497   if (last == NULL || filename_cmp (last, s_filename) != 0)
4498     {
4499       fputs_filtered ("\nFile ", gdb_stdout);
4500       fputs_filtered (s_filename, gdb_stdout);
4501       fputs_filtered (":\n", gdb_stdout);
4502     }
4503
4504   if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
4505     printf_filtered ("static ");
4506
4507   /* Typedef that is not a C++ class.  */
4508   if (kind == TYPES_DOMAIN
4509       && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
4510     typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
4511   /* variable, func, or typedef-that-is-c++-class.  */
4512   else if (kind < TYPES_DOMAIN
4513            || (kind == TYPES_DOMAIN
4514                && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
4515     {
4516       type_print (SYMBOL_TYPE (sym),
4517                   (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4518                    ? "" : SYMBOL_PRINT_NAME (sym)),
4519                   gdb_stdout, 0);
4520
4521       printf_filtered (";\n");
4522     }
4523 }
4524
4525 /* This help function for symtab_symbol_info() prints information
4526    for non-debugging symbols to gdb_stdout.  */
4527
4528 static void
4529 print_msymbol_info (struct bound_minimal_symbol msymbol)
4530 {
4531   struct gdbarch *gdbarch = get_objfile_arch (msymbol.objfile);
4532   char *tmp;
4533
4534   if (gdbarch_addr_bit (gdbarch) <= 32)
4535     tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol)
4536                              & (CORE_ADDR) 0xffffffff,
4537                              8);
4538   else
4539     tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol),
4540                              16);
4541   printf_filtered ("%s  %s\n",
4542                    tmp, MSYMBOL_PRINT_NAME (msymbol.minsym));
4543 }
4544
4545 /* This is the guts of the commands "info functions", "info types", and
4546    "info variables".  It calls search_symbols to find all matches and then
4547    print_[m]symbol_info to print out some useful information about the
4548    matches.  */
4549
4550 static void
4551 symtab_symbol_info (char *regexp, enum search_domain kind, int from_tty)
4552 {
4553   static const char * const classnames[] =
4554     {"variable", "function", "type"};
4555   struct symbol_search *symbols;
4556   struct symbol_search *p;
4557   struct cleanup *old_chain;
4558   const char *last_filename = NULL;
4559   int first = 1;
4560
4561   gdb_assert (kind <= TYPES_DOMAIN);
4562
4563   /* Must make sure that if we're interrupted, symbols gets freed.  */
4564   search_symbols (regexp, kind, 0, NULL, &symbols);
4565   old_chain = make_cleanup_free_search_symbols (&symbols);
4566
4567   if (regexp != NULL)
4568     printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4569                      classnames[kind], regexp);
4570   else
4571     printf_filtered (_("All defined %ss:\n"), classnames[kind]);
4572
4573   for (p = symbols; p != NULL; p = p->next)
4574     {
4575       QUIT;
4576
4577       if (p->msymbol.minsym != NULL)
4578         {
4579           if (first)
4580             {
4581               printf_filtered (_("\nNon-debugging symbols:\n"));
4582               first = 0;
4583             }
4584           print_msymbol_info (p->msymbol);
4585         }
4586       else
4587         {
4588           print_symbol_info (kind,
4589                              p->symbol,
4590                              p->block,
4591                              last_filename);
4592           last_filename
4593             = symtab_to_filename_for_display (symbol_symtab (p->symbol));
4594         }
4595     }
4596
4597   do_cleanups (old_chain);
4598 }
4599
4600 static void
4601 info_variables_command (char *regexp, int from_tty)
4602 {
4603   symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
4604 }
4605
4606 static void
4607 info_functions_command (char *regexp, int from_tty)
4608 {
4609   symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
4610 }
4611
4612
4613 static void
4614 info_types_command (char *regexp, int from_tty)
4615 {
4616   symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
4617 }
4618
4619 /* Breakpoint all functions matching regular expression.  */
4620
4621 void
4622 rbreak_command_wrapper (char *regexp, int from_tty)
4623 {
4624   rbreak_command (regexp, from_tty);
4625 }
4626
4627 /* A cleanup function that calls end_rbreak_breakpoints.  */
4628
4629 static void
4630 do_end_rbreak_breakpoints (void *ignore)
4631 {
4632   end_rbreak_breakpoints ();
4633 }
4634
4635 static void
4636 rbreak_command (char *regexp, int from_tty)
4637 {
4638   struct symbol_search *ss;
4639   struct symbol_search *p;
4640   struct cleanup *old_chain;
4641   char *string = NULL;
4642   int len = 0;
4643   const char **files = NULL;
4644   const char *file_name;
4645   int nfiles = 0;
4646
4647   if (regexp)
4648     {
4649       char *colon = strchr (regexp, ':');
4650
4651       if (colon && *(colon + 1) != ':')
4652         {
4653           int colon_index;
4654           char *local_name;
4655
4656           colon_index = colon - regexp;
4657           local_name = (char *) alloca (colon_index + 1);
4658           memcpy (local_name, regexp, colon_index);
4659           local_name[colon_index--] = 0;
4660           while (isspace (local_name[colon_index]))
4661             local_name[colon_index--] = 0;
4662           file_name = local_name;
4663           files = &file_name;
4664           nfiles = 1;
4665           regexp = skip_spaces (colon + 1);
4666         }
4667     }
4668
4669   search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
4670   old_chain = make_cleanup_free_search_symbols (&ss);
4671   make_cleanup (free_current_contents, &string);
4672
4673   start_rbreak_breakpoints ();
4674   make_cleanup (do_end_rbreak_breakpoints, NULL);
4675   for (p = ss; p != NULL; p = p->next)
4676     {
4677       if (p->msymbol.minsym == NULL)
4678         {
4679           struct symtab *symtab = symbol_symtab (p->symbol);
4680           const char *fullname = symtab_to_fullname (symtab);
4681
4682           int newlen = (strlen (fullname)
4683                         + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
4684                         + 4);
4685
4686           if (newlen > len)
4687             {
4688               string = (char *) xrealloc (string, newlen);
4689               len = newlen;
4690             }
4691           strcpy (string, fullname);
4692           strcat (string, ":'");
4693           strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
4694           strcat (string, "'");
4695           break_command (string, from_tty);
4696           print_symbol_info (FUNCTIONS_DOMAIN,
4697                              p->symbol,
4698                              p->block,
4699                              symtab_to_filename_for_display (symtab));
4700         }
4701       else
4702         {
4703           int newlen = (strlen (MSYMBOL_LINKAGE_NAME (p->msymbol.minsym)) + 3);
4704
4705           if (newlen > len)
4706             {
4707               string = (char *) xrealloc (string, newlen);
4708               len = newlen;
4709             }
4710           strcpy (string, "'");
4711           strcat (string, MSYMBOL_LINKAGE_NAME (p->msymbol.minsym));
4712           strcat (string, "'");
4713
4714           break_command (string, from_tty);
4715           printf_filtered ("<function, no debug info> %s;\n",
4716                            MSYMBOL_PRINT_NAME (p->msymbol.minsym));
4717         }
4718     }
4719
4720   do_cleanups (old_chain);
4721 }
4722 \f
4723
4724 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
4725
4726    Either sym_text[sym_text_len] != '(' and then we search for any
4727    symbol starting with SYM_TEXT text.
4728
4729    Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
4730    be terminated at that point.  Partial symbol tables do not have parameters
4731    information.  */
4732
4733 static int
4734 compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
4735 {
4736   int (*ncmp) (const char *, const char *, size_t);
4737
4738   ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
4739
4740   if (ncmp (name, sym_text, sym_text_len) != 0)
4741     return 0;
4742
4743   if (sym_text[sym_text_len] == '(')
4744     {
4745       /* User searches for `name(someth...'.  Require NAME to be terminated.
4746          Normally psymtabs and gdbindex have no parameter types so '\0' will be
4747          present but accept even parameters presence.  In this case this
4748          function is in fact strcmp_iw but whitespace skipping is not supported
4749          for tab completion.  */
4750
4751       if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
4752         return 0;
4753     }
4754
4755   return 1;
4756 }
4757
4758 /*  Test to see if the symbol specified by SYMNAME (which is already
4759    demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4760    characters.  If so, add it to the current completion list.  */
4761
4762 static void
4763 completion_list_add_name (completion_tracker &tracker,
4764                           const char *symname,
4765                           const char *sym_text, int sym_text_len,
4766                           const char *text, const char *word)
4767 {
4768   /* Clip symbols that cannot match.  */
4769   if (!compare_symbol_name (symname, sym_text, sym_text_len))
4770     return;
4771
4772   /* We have a match for a completion, so add SYMNAME to the current list
4773      of matches.  Note that the name is moved to freshly malloc'd space.  */
4774
4775   {
4776     char *newobj;
4777
4778     if (word == sym_text)
4779       {
4780         newobj = (char *) xmalloc (strlen (symname) + 5);
4781         strcpy (newobj, symname);
4782       }
4783     else if (word > sym_text)
4784       {
4785         /* Return some portion of symname.  */
4786         newobj = (char *) xmalloc (strlen (symname) + 5);
4787         strcpy (newobj, symname + (word - sym_text));
4788       }
4789     else
4790       {
4791         /* Return some of SYM_TEXT plus symname.  */
4792         newobj = (char *) xmalloc (strlen (symname) + (sym_text - word) + 5);
4793         strncpy (newobj, word, sym_text - word);
4794         newobj[sym_text - word] = '\0';
4795         strcat (newobj, symname);
4796       }
4797
4798     gdb::unique_xmalloc_ptr<char> completion (newobj);
4799
4800     tracker.add_completion (std::move (completion));
4801   }
4802 }
4803
4804 /* completion_list_add_name wrapper for struct symbol.  */
4805
4806 static void
4807 completion_list_add_symbol (completion_tracker &tracker,
4808                             symbol *sym,
4809                             const char *sym_text, int sym_text_len,
4810                             const char *text, const char *word)
4811 {
4812   completion_list_add_name (tracker, SYMBOL_NATURAL_NAME (sym),
4813                             sym_text, sym_text_len, text, word);
4814 }
4815
4816 /* completion_list_add_name wrapper for struct minimal_symbol.  */
4817
4818 static void
4819 completion_list_add_msymbol (completion_tracker &tracker,
4820                              minimal_symbol *sym,
4821                              const char *sym_text, int sym_text_len,
4822                              const char *text, const char *word)
4823 {
4824   completion_list_add_name (tracker, MSYMBOL_NATURAL_NAME (sym),
4825                             sym_text, sym_text_len, text, word);
4826 }
4827
4828 /* ObjC: In case we are completing on a selector, look as the msymbol
4829    again and feed all the selectors into the mill.  */
4830
4831 static void
4832 completion_list_objc_symbol (completion_tracker &tracker,
4833                              struct minimal_symbol *msymbol,
4834                              const char *sym_text, int sym_text_len,
4835                              const char *text, const char *word)
4836 {
4837   static char *tmp = NULL;
4838   static unsigned int tmplen = 0;
4839
4840   const char *method, *category, *selector;
4841   char *tmp2 = NULL;
4842
4843   method = MSYMBOL_NATURAL_NAME (msymbol);
4844
4845   /* Is it a method?  */
4846   if ((method[0] != '-') && (method[0] != '+'))
4847     return;
4848
4849   if (sym_text[0] == '[')
4850     /* Complete on shortened method method.  */
4851     completion_list_add_name (tracker, method + 1,
4852                               sym_text, sym_text_len, text, word);
4853
4854   while ((strlen (method) + 1) >= tmplen)
4855     {
4856       if (tmplen == 0)
4857         tmplen = 1024;
4858       else
4859         tmplen *= 2;
4860       tmp = (char *) xrealloc (tmp, tmplen);
4861     }
4862   selector = strchr (method, ' ');
4863   if (selector != NULL)
4864     selector++;
4865
4866   category = strchr (method, '(');
4867
4868   if ((category != NULL) && (selector != NULL))
4869     {
4870       memcpy (tmp, method, (category - method));
4871       tmp[category - method] = ' ';
4872       memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4873       completion_list_add_name (tracker, tmp,
4874                                 sym_text, sym_text_len, text, word);
4875       if (sym_text[0] == '[')
4876         completion_list_add_name (tracker, tmp + 1,
4877                                   sym_text, sym_text_len, text, word);
4878     }
4879
4880   if (selector != NULL)
4881     {
4882       /* Complete on selector only.  */
4883       strcpy (tmp, selector);
4884       tmp2 = strchr (tmp, ']');
4885       if (tmp2 != NULL)
4886         *tmp2 = '\0';
4887
4888       completion_list_add_name (tracker, tmp,
4889                                 sym_text, sym_text_len, text, word);
4890     }
4891 }
4892
4893 /* Break the non-quoted text based on the characters which are in
4894    symbols.  FIXME: This should probably be language-specific.  */
4895
4896 static const char *
4897 language_search_unquoted_string (const char *text, const char *p)
4898 {
4899   for (; p > text; --p)
4900     {
4901       if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4902         continue;
4903       else
4904         {
4905           if ((current_language->la_language == language_objc))
4906             {
4907               if (p[-1] == ':')     /* Might be part of a method name.  */
4908                 continue;
4909               else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
4910                 p -= 2;             /* Beginning of a method name.  */
4911               else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
4912                 {                   /* Might be part of a method name.  */
4913                   const char *t = p;
4914
4915                   /* Seeing a ' ' or a '(' is not conclusive evidence
4916                      that we are in the middle of a method name.  However,
4917                      finding "-[" or "+[" should be pretty un-ambiguous.
4918                      Unfortunately we have to find it now to decide.  */
4919
4920                   while (t > text)
4921                     if (isalnum (t[-1]) || t[-1] == '_' ||
4922                         t[-1] == ' '    || t[-1] == ':' ||
4923                         t[-1] == '('    || t[-1] == ')')
4924                       --t;
4925                     else
4926                       break;
4927
4928                   if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
4929                     p = t - 2;      /* Method name detected.  */
4930                   /* Else we leave with p unchanged.  */
4931                 }
4932             }
4933           break;
4934         }
4935     }
4936   return p;
4937 }
4938
4939 static void
4940 completion_list_add_fields (completion_tracker &tracker,
4941                             struct symbol *sym,
4942                             const char *sym_text, int sym_text_len,
4943                             const char *text, const char *word)
4944 {
4945   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4946     {
4947       struct type *t = SYMBOL_TYPE (sym);
4948       enum type_code c = TYPE_CODE (t);
4949       int j;
4950
4951       if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4952         for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4953           if (TYPE_FIELD_NAME (t, j))
4954             completion_list_add_name (tracker, TYPE_FIELD_NAME (t, j),
4955                                       sym_text, sym_text_len, text, word);
4956     }
4957 }
4958
4959 /* Add matching symbols from SYMTAB to the current completion list.  */
4960
4961 static void
4962 add_symtab_completions (struct compunit_symtab *cust,
4963                         completion_tracker &tracker,
4964                         const char *sym_text, int sym_text_len,
4965                         const char *text, const char *word,
4966                         enum type_code code)
4967 {
4968   struct symbol *sym;
4969   const struct block *b;
4970   struct block_iterator iter;
4971   int i;
4972
4973   if (cust == NULL)
4974     return;
4975
4976   for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
4977     {
4978       QUIT;
4979       b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), i);
4980       ALL_BLOCK_SYMBOLS (b, iter, sym)
4981         {
4982           if (code == TYPE_CODE_UNDEF
4983               || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4984                   && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4985             completion_list_add_symbol (tracker, sym,
4986                                         sym_text, sym_text_len,
4987                                         text, word);
4988         }
4989     }
4990 }
4991
4992 void
4993 default_collect_symbol_completion_matches_break_on
4994   (completion_tracker &tracker,
4995    complete_symbol_mode mode,
4996    const char *text, const char *word,
4997    const char *break_on, enum type_code code)
4998 {
4999   /* Problem: All of the symbols have to be copied because readline
5000      frees them.  I'm not going to worry about this; hopefully there
5001      won't be that many.  */
5002
5003   struct symbol *sym;
5004   struct compunit_symtab *cust;
5005   struct minimal_symbol *msymbol;
5006   struct objfile *objfile;
5007   const struct block *b;
5008   const struct block *surrounding_static_block, *surrounding_global_block;
5009   struct block_iterator iter;
5010   /* The symbol we are completing on.  Points in same buffer as text.  */
5011   const char *sym_text;
5012   /* Length of sym_text.  */
5013   int sym_text_len;
5014
5015   /* Now look for the symbol we are supposed to complete on.  */
5016   if (mode == complete_symbol_mode::LINESPEC)
5017     sym_text = text;
5018   else
5019   {
5020     const char *p;
5021     char quote_found;
5022     const char *quote_pos = NULL;
5023
5024     /* First see if this is a quoted string.  */
5025     quote_found = '\0';
5026     for (p = text; *p != '\0'; ++p)
5027       {
5028         if (quote_found != '\0')
5029           {
5030             if (*p == quote_found)
5031               /* Found close quote.  */
5032               quote_found = '\0';
5033             else if (*p == '\\' && p[1] == quote_found)
5034               /* A backslash followed by the quote character
5035                  doesn't end the string.  */
5036               ++p;
5037           }
5038         else if (*p == '\'' || *p == '"')
5039           {
5040             quote_found = *p;
5041             quote_pos = p;
5042           }
5043       }
5044     if (quote_found == '\'')
5045       /* A string within single quotes can be a symbol, so complete on it.  */
5046       sym_text = quote_pos + 1;
5047     else if (quote_found == '"')
5048       /* A double-quoted string is never a symbol, nor does it make sense
5049          to complete it any other way.  */
5050       {
5051         return;
5052       }
5053     else
5054       {
5055         /* It is not a quoted string.  Break it based on the characters
5056            which are in symbols.  */
5057         while (p > text)
5058           {
5059             if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
5060                 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
5061               --p;
5062             else
5063               break;
5064           }
5065         sym_text = p;
5066       }
5067   }
5068
5069   sym_text_len = strlen (sym_text);
5070
5071   /* Prepare SYM_TEXT_LEN for compare_symbol_name.  */
5072
5073   if (current_language->la_language == language_cplus
5074       || current_language->la_language == language_fortran)
5075     {
5076       /* These languages may have parameters entered by user but they are never
5077          present in the partial symbol tables.  */
5078
5079       const char *cs = (const char *) memchr (sym_text, '(', sym_text_len);
5080
5081       if (cs)
5082         sym_text_len = cs - sym_text;
5083     }
5084   gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
5085
5086   /* At this point scan through the misc symbol vectors and add each
5087      symbol you find to the list.  Eventually we want to ignore
5088      anything that isn't a text symbol (everything else will be
5089      handled by the psymtab code below).  */
5090
5091   if (code == TYPE_CODE_UNDEF)
5092     {
5093       ALL_MSYMBOLS (objfile, msymbol)
5094         {
5095           QUIT;
5096
5097           completion_list_add_msymbol (tracker,
5098                                        msymbol, sym_text, sym_text_len,
5099                                        text, word);
5100
5101           completion_list_objc_symbol (tracker,
5102                                        msymbol, sym_text, sym_text_len,
5103                                        text, word);
5104         }
5105     }
5106
5107   /* Add completions for all currently loaded symbol tables.  */
5108   ALL_COMPUNITS (objfile, cust)
5109     add_symtab_completions (cust, tracker,
5110                             sym_text, sym_text_len, text, word, code);
5111
5112   /* Look through the partial symtabs for all symbols which begin by
5113      matching SYM_TEXT.  Expand all CUs that you find to the list.  */
5114   expand_symtabs_matching (NULL,
5115                            [&] (const char *name) /* symbol matcher */
5116                              {
5117                                return compare_symbol_name (name,
5118                                                            sym_text,
5119                                                            sym_text_len);
5120                              },
5121                            [&] (compunit_symtab *symtab) /* expansion notify */
5122                              {
5123                                add_symtab_completions (symtab,
5124                                                        tracker,
5125                                                        sym_text, sym_text_len,
5126                                                        text, word, code);
5127                              },
5128                            ALL_DOMAIN);
5129
5130   /* Search upwards from currently selected frame (so that we can
5131      complete on local vars).  Also catch fields of types defined in
5132      this places which match our text string.  Only complete on types
5133      visible from current context.  */
5134
5135   b = get_selected_block (0);
5136   surrounding_static_block = block_static_block (b);
5137   surrounding_global_block = block_global_block (b);
5138   if (surrounding_static_block != NULL)
5139     while (b != surrounding_static_block)
5140       {
5141         QUIT;
5142
5143         ALL_BLOCK_SYMBOLS (b, iter, sym)
5144           {
5145             if (code == TYPE_CODE_UNDEF)
5146               {
5147                 completion_list_add_symbol (tracker, sym,
5148                                             sym_text, sym_text_len, text,
5149                                             word);
5150                 completion_list_add_fields (tracker, sym,
5151                                             sym_text, sym_text_len, text,
5152                                             word);
5153               }
5154             else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
5155                      && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
5156               completion_list_add_symbol (tracker, sym,
5157                                           sym_text, sym_text_len, text,
5158                                           word);
5159           }
5160
5161         /* Stop when we encounter an enclosing function.  Do not stop for
5162            non-inlined functions - the locals of the enclosing function
5163            are in scope for a nested function.  */
5164         if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
5165           break;
5166         b = BLOCK_SUPERBLOCK (b);
5167       }
5168
5169   /* Add fields from the file's types; symbols will be added below.  */
5170
5171   if (code == TYPE_CODE_UNDEF)
5172     {
5173       if (surrounding_static_block != NULL)
5174         ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
5175           completion_list_add_fields (tracker, sym,
5176                                       sym_text, sym_text_len, text, word);
5177
5178       if (surrounding_global_block != NULL)
5179         ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
5180           completion_list_add_fields (tracker, sym,
5181                                       sym_text, sym_text_len, text, word);
5182     }
5183
5184   /* Skip macros if we are completing a struct tag -- arguable but
5185      usually what is expected.  */
5186   if (current_language->la_macro_expansion == macro_expansion_c
5187       && code == TYPE_CODE_UNDEF)
5188     {
5189       struct macro_scope *scope;
5190
5191       /* This adds a macro's name to the current completion list.  */
5192       auto add_macro_name = [&] (const char *macro_name,
5193                                  const macro_definition *,
5194                                  macro_source_file *,
5195                                  int)
5196         {
5197           completion_list_add_name (tracker, macro_name,
5198                                     sym_text, sym_text_len,
5199                                     text, word);
5200         };
5201
5202       /* Add any macros visible in the default scope.  Note that this
5203          may yield the occasional wrong result, because an expression
5204          might be evaluated in a scope other than the default.  For
5205          example, if the user types "break file:line if <TAB>", the
5206          resulting expression will be evaluated at "file:line" -- but
5207          at there does not seem to be a way to detect this at
5208          completion time.  */
5209       scope = default_macro_scope ();
5210       if (scope)
5211         {
5212           macro_for_each_in_scope (scope->file, scope->line,
5213                                    add_macro_name);
5214           xfree (scope);
5215         }
5216
5217       /* User-defined macros are always visible.  */
5218       macro_for_each (macro_user_macros, add_macro_name);
5219     }
5220 }
5221
5222 void
5223 default_collect_symbol_completion_matches (completion_tracker &tracker,
5224                                            complete_symbol_mode mode,
5225                                            const char *text, const char *word,
5226                                            enum type_code code)
5227 {
5228   return default_collect_symbol_completion_matches_break_on (tracker, mode,
5229                                                              text, word, "",
5230                                                              code);
5231 }
5232
5233 /* Collect all symbols (regardless of class) which begin by matching
5234    TEXT.  */
5235
5236 void
5237 collect_symbol_completion_matches (completion_tracker &tracker,
5238                                    complete_symbol_mode mode,
5239                                    const char *text, const char *word)
5240 {
5241   current_language->la_collect_symbol_completion_matches (tracker, mode,
5242                                                           text, word,
5243                                                           TYPE_CODE_UNDEF);
5244 }
5245
5246 /* Like collect_symbol_completion_matches, but only collect
5247    STRUCT_DOMAIN symbols whose type code is CODE.  */
5248
5249 void
5250 collect_symbol_completion_matches_type (completion_tracker &tracker,
5251                                         const char *text, const char *word,
5252                                         enum type_code code)
5253 {
5254   complete_symbol_mode mode = complete_symbol_mode::EXPRESSION;
5255
5256   gdb_assert (code == TYPE_CODE_UNION
5257               || code == TYPE_CODE_STRUCT
5258               || code == TYPE_CODE_ENUM);
5259   current_language->la_collect_symbol_completion_matches (tracker, mode,
5260                                                           text, word, code);
5261 }
5262
5263 /* Like collect_symbol_completion_matches, but collects a list of
5264    symbols defined in all source files named SRCFILE.  */
5265
5266 void
5267 collect_file_symbol_completion_matches (completion_tracker &tracker,
5268                                         complete_symbol_mode mode,
5269                                         const char *text, const char *word,
5270                                         const char *srcfile)
5271 {
5272   /* The symbol we are completing on.  Points in same buffer as text.  */
5273   const char *sym_text;
5274   /* Length of sym_text.  */
5275   int sym_text_len;
5276
5277   /* Now look for the symbol we are supposed to complete on.
5278      FIXME: This should be language-specific.  */
5279   if (mode == complete_symbol_mode::LINESPEC)
5280     sym_text = text;
5281   else
5282   {
5283     const char *p;
5284     char quote_found;
5285     const char *quote_pos = NULL;
5286
5287     /* First see if this is a quoted string.  */
5288     quote_found = '\0';
5289     for (p = text; *p != '\0'; ++p)
5290       {
5291         if (quote_found != '\0')
5292           {
5293             if (*p == quote_found)
5294               /* Found close quote.  */
5295               quote_found = '\0';
5296             else if (*p == '\\' && p[1] == quote_found)
5297               /* A backslash followed by the quote character
5298                  doesn't end the string.  */
5299               ++p;
5300           }
5301         else if (*p == '\'' || *p == '"')
5302           {
5303             quote_found = *p;
5304             quote_pos = p;
5305           }
5306       }
5307     if (quote_found == '\'')
5308       /* A string within single quotes can be a symbol, so complete on it.  */
5309       sym_text = quote_pos + 1;
5310     else if (quote_found == '"')
5311       /* A double-quoted string is never a symbol, nor does it make sense
5312          to complete it any other way.  */
5313       {
5314         return;
5315       }
5316     else
5317       {
5318         /* Not a quoted string.  */
5319         sym_text = language_search_unquoted_string (text, p);
5320       }
5321   }
5322
5323   sym_text_len = strlen (sym_text);
5324
5325   /* Go through symtabs for SRCFILE and check the externs and statics
5326      for symbols which match.  */
5327   iterate_over_symtabs (srcfile, [&] (symtab *s)
5328     {
5329       add_symtab_completions (SYMTAB_COMPUNIT (s),
5330                               tracker,
5331                               sym_text, sym_text_len,
5332                               text, word, TYPE_CODE_UNDEF);
5333       return false;
5334     });
5335 }
5336
5337 /* A helper function for make_source_files_completion_list.  It adds
5338    another file name to a list of possible completions, growing the
5339    list as necessary.  */
5340
5341 static void
5342 add_filename_to_list (const char *fname, const char *text, const char *word,
5343                       completion_list *list)
5344 {
5345   char *newobj;
5346   size_t fnlen = strlen (fname);
5347
5348   if (word == text)
5349     {
5350       /* Return exactly fname.  */
5351       newobj = (char *) xmalloc (fnlen + 5);
5352       strcpy (newobj, fname);
5353     }
5354   else if (word > text)
5355     {
5356       /* Return some portion of fname.  */
5357       newobj = (char *) xmalloc (fnlen + 5);
5358       strcpy (newobj, fname + (word - text));
5359     }
5360   else
5361     {
5362       /* Return some of TEXT plus fname.  */
5363       newobj = (char *) xmalloc (fnlen + (text - word) + 5);
5364       strncpy (newobj, word, text - word);
5365       newobj[text - word] = '\0';
5366       strcat (newobj, fname);
5367     }
5368   list->emplace_back (newobj);
5369 }
5370
5371 static int
5372 not_interesting_fname (const char *fname)
5373 {
5374   static const char *illegal_aliens[] = {
5375     "_globals_",        /* inserted by coff_symtab_read */
5376     NULL
5377   };
5378   int i;
5379
5380   for (i = 0; illegal_aliens[i]; i++)
5381     {
5382       if (filename_cmp (fname, illegal_aliens[i]) == 0)
5383         return 1;
5384     }
5385   return 0;
5386 }
5387
5388 /* An object of this type is passed as the user_data argument to
5389    map_partial_symbol_filenames.  */
5390 struct add_partial_filename_data
5391 {
5392   struct filename_seen_cache *filename_seen_cache;
5393   const char *text;
5394   const char *word;
5395   int text_len;
5396   completion_list *list;
5397 };
5398
5399 /* A callback for map_partial_symbol_filenames.  */
5400
5401 static void
5402 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
5403                                    void *user_data)
5404 {
5405   struct add_partial_filename_data *data
5406     = (struct add_partial_filename_data *) user_data;
5407
5408   if (not_interesting_fname (filename))
5409     return;
5410   if (!data->filename_seen_cache->seen (filename)
5411       && filename_ncmp (filename, data->text, data->text_len) == 0)
5412     {
5413       /* This file matches for a completion; add it to the
5414          current list of matches.  */
5415       add_filename_to_list (filename, data->text, data->word, data->list);
5416     }
5417   else
5418     {
5419       const char *base_name = lbasename (filename);
5420
5421       if (base_name != filename
5422           && !data->filename_seen_cache->seen (base_name)
5423           && filename_ncmp (base_name, data->text, data->text_len) == 0)
5424         add_filename_to_list (base_name, data->text, data->word, data->list);
5425     }
5426 }
5427
5428 /* Return a list of all source files whose names begin with matching
5429    TEXT.  The file names are looked up in the symbol tables of this
5430    program.  */
5431
5432 completion_list
5433 make_source_files_completion_list (const char *text, const char *word)
5434 {
5435   struct compunit_symtab *cu;
5436   struct symtab *s;
5437   struct objfile *objfile;
5438   size_t text_len = strlen (text);
5439   completion_list list;
5440   const char *base_name;
5441   struct add_partial_filename_data datum;
5442   struct cleanup *back_to;
5443
5444   if (!have_full_symbols () && !have_partial_symbols ())
5445     return list;
5446
5447   filename_seen_cache filenames_seen;
5448
5449   ALL_FILETABS (objfile, cu, s)
5450     {
5451       if (not_interesting_fname (s->filename))
5452         continue;
5453       if (!filenames_seen.seen (s->filename)
5454           && filename_ncmp (s->filename, text, text_len) == 0)
5455         {
5456           /* This file matches for a completion; add it to the current
5457              list of matches.  */
5458           add_filename_to_list (s->filename, text, word, &list);
5459         }
5460       else
5461         {
5462           /* NOTE: We allow the user to type a base name when the
5463              debug info records leading directories, but not the other
5464              way around.  This is what subroutines of breakpoint
5465              command do when they parse file names.  */
5466           base_name = lbasename (s->filename);
5467           if (base_name != s->filename
5468               && !filenames_seen.seen (base_name)
5469               && filename_ncmp (base_name, text, text_len) == 0)
5470             add_filename_to_list (base_name, text, word, &list);
5471         }
5472     }
5473
5474   datum.filename_seen_cache = &filenames_seen;
5475   datum.text = text;
5476   datum.word = word;
5477   datum.text_len = text_len;
5478   datum.list = &list;
5479   map_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
5480                         0 /*need_fullname*/);
5481
5482   return list;
5483 }
5484 \f
5485 /* Track MAIN */
5486
5487 /* Return the "main_info" object for the current program space.  If
5488    the object has not yet been created, create it and fill in some
5489    default values.  */
5490
5491 static struct main_info *
5492 get_main_info (void)
5493 {
5494   struct main_info *info
5495     = (struct main_info *) program_space_data (current_program_space,
5496                                                main_progspace_key);
5497
5498   if (info == NULL)
5499     {
5500       /* It may seem strange to store the main name in the progspace
5501          and also in whatever objfile happens to see a main name in
5502          its debug info.  The reason for this is mainly historical:
5503          gdb returned "main" as the name even if no function named
5504          "main" was defined the program; and this approach lets us
5505          keep compatibility.  */
5506       info = XCNEW (struct main_info);
5507       info->language_of_main = language_unknown;
5508       set_program_space_data (current_program_space, main_progspace_key,
5509                               info);
5510     }
5511
5512   return info;
5513 }
5514
5515 /* A cleanup to destroy a struct main_info when a progspace is
5516    destroyed.  */
5517
5518 static void
5519 main_info_cleanup (struct program_space *pspace, void *data)
5520 {
5521   struct main_info *info = (struct main_info *) data;
5522
5523   if (info != NULL)
5524     xfree (info->name_of_main);
5525   xfree (info);
5526 }
5527
5528 static void
5529 set_main_name (const char *name, enum language lang)
5530 {
5531   struct main_info *info = get_main_info ();
5532
5533   if (info->name_of_main != NULL)
5534     {
5535       xfree (info->name_of_main);
5536       info->name_of_main = NULL;
5537       info->language_of_main = language_unknown;
5538     }
5539   if (name != NULL)
5540     {
5541       info->name_of_main = xstrdup (name);
5542       info->language_of_main = lang;
5543     }
5544 }
5545
5546 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5547    accordingly.  */
5548
5549 static void
5550 find_main_name (void)
5551 {
5552   const char *new_main_name;
5553   struct objfile *objfile;
5554
5555   /* First check the objfiles to see whether a debuginfo reader has
5556      picked up the appropriate main name.  Historically the main name
5557      was found in a more or less random way; this approach instead
5558      relies on the order of objfile creation -- which still isn't
5559      guaranteed to get the correct answer, but is just probably more
5560      accurate.  */
5561   ALL_OBJFILES (objfile)
5562   {
5563     if (objfile->per_bfd->name_of_main != NULL)
5564       {
5565         set_main_name (objfile->per_bfd->name_of_main,
5566                        objfile->per_bfd->language_of_main);
5567         return;
5568       }
5569   }
5570
5571   /* Try to see if the main procedure is in Ada.  */
5572   /* FIXME: brobecker/2005-03-07: Another way of doing this would
5573      be to add a new method in the language vector, and call this
5574      method for each language until one of them returns a non-empty
5575      name.  This would allow us to remove this hard-coded call to
5576      an Ada function.  It is not clear that this is a better approach
5577      at this point, because all methods need to be written in a way
5578      such that false positives never be returned.  For instance, it is
5579      important that a method does not return a wrong name for the main
5580      procedure if the main procedure is actually written in a different
5581      language.  It is easy to guaranty this with Ada, since we use a
5582      special symbol generated only when the main in Ada to find the name
5583      of the main procedure.  It is difficult however to see how this can
5584      be guarantied for languages such as C, for instance.  This suggests
5585      that order of call for these methods becomes important, which means
5586      a more complicated approach.  */
5587   new_main_name = ada_main_name ();
5588   if (new_main_name != NULL)
5589     {
5590       set_main_name (new_main_name, language_ada);
5591       return;
5592     }
5593
5594   new_main_name = d_main_name ();
5595   if (new_main_name != NULL)
5596     {
5597       set_main_name (new_main_name, language_d);
5598       return;
5599     }
5600
5601   new_main_name = go_main_name ();
5602   if (new_main_name != NULL)
5603     {
5604       set_main_name (new_main_name, language_go);
5605       return;
5606     }
5607
5608   new_main_name = pascal_main_name ();
5609   if (new_main_name != NULL)
5610     {
5611       set_main_name (new_main_name, language_pascal);
5612       return;
5613     }
5614
5615   /* The languages above didn't identify the name of the main procedure.
5616      Fallback to "main".  */
5617   set_main_name ("main", language_unknown);
5618 }
5619
5620 char *
5621 main_name (void)
5622 {
5623   struct main_info *info = get_main_info ();
5624
5625   if (info->name_of_main == NULL)
5626     find_main_name ();
5627
5628   return info->name_of_main;
5629 }
5630
5631 /* Return the language of the main function.  If it is not known,
5632    return language_unknown.  */
5633
5634 enum language
5635 main_language (void)
5636 {
5637   struct main_info *info = get_main_info ();
5638
5639   if (info->name_of_main == NULL)
5640     find_main_name ();
5641
5642   return info->language_of_main;
5643 }
5644
5645 /* Handle ``executable_changed'' events for the symtab module.  */
5646
5647 static void
5648 symtab_observer_executable_changed (void)
5649 {
5650   /* NAME_OF_MAIN may no longer be the same, so reset it for now.  */
5651   set_main_name (NULL, language_unknown);
5652 }
5653
5654 /* Return 1 if the supplied producer string matches the ARM RealView
5655    compiler (armcc).  */
5656
5657 int
5658 producer_is_realview (const char *producer)
5659 {
5660   static const char *const arm_idents[] = {
5661     "ARM C Compiler, ADS",
5662     "Thumb C Compiler, ADS",
5663     "ARM C++ Compiler, ADS",
5664     "Thumb C++ Compiler, ADS",
5665     "ARM/Thumb C/C++ Compiler, RVCT",
5666     "ARM C/C++ Compiler, RVCT"
5667   };
5668   int i;
5669
5670   if (producer == NULL)
5671     return 0;
5672
5673   for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5674     if (startswith (producer, arm_idents[i]))
5675       return 1;
5676
5677   return 0;
5678 }
5679
5680 \f
5681
5682 /* The next index to hand out in response to a registration request.  */
5683
5684 static int next_aclass_value = LOC_FINAL_VALUE;
5685
5686 /* The maximum number of "aclass" registrations we support.  This is
5687    constant for convenience.  */
5688 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5689
5690 /* The objects representing the various "aclass" values.  The elements
5691    from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5692    elements are those registered at gdb initialization time.  */
5693
5694 static struct symbol_impl symbol_impl[MAX_SYMBOL_IMPLS];
5695
5696 /* The globally visible pointer.  This is separate from 'symbol_impl'
5697    so that it can be const.  */
5698
5699 const struct symbol_impl *symbol_impls = &symbol_impl[0];
5700
5701 /* Make sure we saved enough room in struct symbol.  */
5702
5703 gdb_static_assert (MAX_SYMBOL_IMPLS <= (1 << SYMBOL_ACLASS_BITS));
5704
5705 /* Register a computed symbol type.  ACLASS must be LOC_COMPUTED.  OPS
5706    is the ops vector associated with this index.  This returns the new
5707    index, which should be used as the aclass_index field for symbols
5708    of this type.  */
5709
5710 int
5711 register_symbol_computed_impl (enum address_class aclass,
5712                                const struct symbol_computed_ops *ops)
5713 {
5714   int result = next_aclass_value++;
5715
5716   gdb_assert (aclass == LOC_COMPUTED);
5717   gdb_assert (result < MAX_SYMBOL_IMPLS);
5718   symbol_impl[result].aclass = aclass;
5719   symbol_impl[result].ops_computed = ops;
5720
5721   /* Sanity check OPS.  */
5722   gdb_assert (ops != NULL);
5723   gdb_assert (ops->tracepoint_var_ref != NULL);
5724   gdb_assert (ops->describe_location != NULL);
5725   gdb_assert (ops->get_symbol_read_needs != NULL);
5726   gdb_assert (ops->read_variable != NULL);
5727
5728   return result;
5729 }
5730
5731 /* Register a function with frame base type.  ACLASS must be LOC_BLOCK.
5732    OPS is the ops vector associated with this index.  This returns the
5733    new index, which should be used as the aclass_index field for symbols
5734    of this type.  */
5735
5736 int
5737 register_symbol_block_impl (enum address_class aclass,
5738                             const struct symbol_block_ops *ops)
5739 {
5740   int result = next_aclass_value++;
5741
5742   gdb_assert (aclass == LOC_BLOCK);
5743   gdb_assert (result < MAX_SYMBOL_IMPLS);
5744   symbol_impl[result].aclass = aclass;
5745   symbol_impl[result].ops_block = ops;
5746
5747   /* Sanity check OPS.  */
5748   gdb_assert (ops != NULL);
5749   gdb_assert (ops->find_frame_base_location != NULL);
5750
5751   return result;
5752 }
5753
5754 /* Register a register symbol type.  ACLASS must be LOC_REGISTER or
5755    LOC_REGPARM_ADDR.  OPS is the register ops vector associated with
5756    this index.  This returns the new index, which should be used as
5757    the aclass_index field for symbols of this type.  */
5758
5759 int
5760 register_symbol_register_impl (enum address_class aclass,
5761                                const struct symbol_register_ops *ops)
5762 {
5763   int result = next_aclass_value++;
5764
5765   gdb_assert (aclass == LOC_REGISTER || aclass == LOC_REGPARM_ADDR);
5766   gdb_assert (result < MAX_SYMBOL_IMPLS);
5767   symbol_impl[result].aclass = aclass;
5768   symbol_impl[result].ops_register = ops;
5769
5770   return result;
5771 }
5772
5773 /* Initialize elements of 'symbol_impl' for the constants in enum
5774    address_class.  */
5775
5776 static void
5777 initialize_ordinary_address_classes (void)
5778 {
5779   int i;
5780
5781   for (i = 0; i < LOC_FINAL_VALUE; ++i)
5782     symbol_impl[i].aclass = (enum address_class) i;
5783 }
5784
5785 \f
5786
5787 /* Helper function to initialize the fields of an objfile-owned symbol.
5788    It assumed that *SYM is already all zeroes.  */
5789
5790 static void
5791 initialize_objfile_symbol_1 (struct symbol *sym)
5792 {
5793   SYMBOL_OBJFILE_OWNED (sym) = 1;
5794   SYMBOL_SECTION (sym) = -1;
5795 }
5796
5797 /* Initialize the symbol SYM, and mark it as being owned by an objfile.  */
5798
5799 void
5800 initialize_objfile_symbol (struct symbol *sym)
5801 {
5802   memset (sym, 0, sizeof (*sym));
5803   initialize_objfile_symbol_1 (sym);
5804 }
5805
5806 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5807    obstack.  */
5808
5809 struct symbol *
5810 allocate_symbol (struct objfile *objfile)
5811 {
5812   struct symbol *result;
5813
5814   result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
5815   initialize_objfile_symbol_1 (result);
5816
5817   return result;
5818 }
5819
5820 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5821    obstack.  */
5822
5823 struct template_symbol *
5824 allocate_template_symbol (struct objfile *objfile)
5825 {
5826   struct template_symbol *result;
5827
5828   result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
5829   initialize_objfile_symbol_1 (&result->base);
5830
5831   return result;
5832 }
5833
5834 /* See symtab.h.  */
5835
5836 struct objfile *
5837 symbol_objfile (const struct symbol *symbol)
5838 {
5839   gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5840   return SYMTAB_OBJFILE (symbol->owner.symtab);
5841 }
5842
5843 /* See symtab.h.  */
5844
5845 struct gdbarch *
5846 symbol_arch (const struct symbol *symbol)
5847 {
5848   if (!SYMBOL_OBJFILE_OWNED (symbol))
5849     return symbol->owner.arch;
5850   return get_objfile_arch (SYMTAB_OBJFILE (symbol->owner.symtab));
5851 }
5852
5853 /* See symtab.h.  */
5854
5855 struct symtab *
5856 symbol_symtab (const struct symbol *symbol)
5857 {
5858   gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5859   return symbol->owner.symtab;
5860 }
5861
5862 /* See symtab.h.  */
5863
5864 void
5865 symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
5866 {
5867   gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5868   symbol->owner.symtab = symtab;
5869 }
5870
5871 \f
5872
5873 void
5874 _initialize_symtab (void)
5875 {
5876   initialize_ordinary_address_classes ();
5877
5878   main_progspace_key
5879     = register_program_space_data_with_cleanup (NULL, main_info_cleanup);
5880
5881   symbol_cache_key
5882     = register_program_space_data_with_cleanup (NULL, symbol_cache_cleanup);
5883
5884   add_info ("variables", info_variables_command, _("\
5885 All global and static variable names, or those matching REGEXP."));
5886   if (dbx_commands)
5887     add_com ("whereis", class_info, info_variables_command, _("\
5888 All global and static variable names, or those matching REGEXP."));
5889
5890   add_info ("functions", info_functions_command,
5891             _("All function names, or those matching REGEXP."));
5892
5893   /* FIXME:  This command has at least the following problems:
5894      1.  It prints builtin types (in a very strange and confusing fashion).
5895      2.  It doesn't print right, e.g. with
5896      typedef struct foo *FOO
5897      type_print prints "FOO" when we want to make it (in this situation)
5898      print "struct foo *".
5899      I also think "ptype" or "whatis" is more likely to be useful (but if
5900      there is much disagreement "info types" can be fixed).  */
5901   add_info ("types", info_types_command,
5902             _("All type names, or those matching REGEXP."));
5903
5904   add_info ("sources", info_sources_command,
5905             _("Source files in the program."));
5906
5907   add_com ("rbreak", class_breakpoint, rbreak_command,
5908            _("Set a breakpoint for all functions matching REGEXP."));
5909
5910   add_setshow_enum_cmd ("multiple-symbols", no_class,
5911                         multiple_symbols_modes, &multiple_symbols_mode,
5912                         _("\
5913 Set the debugger behavior when more than one symbol are possible matches\n\
5914 in an expression."), _("\
5915 Show how the debugger handles ambiguities in expressions."), _("\
5916 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5917                         NULL, NULL, &setlist, &showlist);
5918
5919   add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5920                            &basenames_may_differ, _("\
5921 Set whether a source file may have multiple base names."), _("\
5922 Show whether a source file may have multiple base names."), _("\
5923 (A \"base name\" is the name of a file with the directory part removed.\n\
5924 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5925 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5926 before comparing them.  Canonicalization is an expensive operation,\n\
5927 but it allows the same file be known by more than one base name.\n\
5928 If not set (the default), all source files are assumed to have just\n\
5929 one base name, and gdb will do file name comparisons more efficiently."),
5930                            NULL, NULL,
5931                            &setlist, &showlist);
5932
5933   add_setshow_zuinteger_cmd ("symtab-create", no_class, &symtab_create_debug,
5934                              _("Set debugging of symbol table creation."),
5935                              _("Show debugging of symbol table creation."), _("\
5936 When enabled (non-zero), debugging messages are printed when building\n\
5937 symbol tables.  A value of 1 (one) normally provides enough information.\n\
5938 A value greater than 1 provides more verbose information."),
5939                              NULL,
5940                              NULL,
5941                              &setdebuglist, &showdebuglist);
5942
5943   add_setshow_zuinteger_cmd ("symbol-lookup", no_class, &symbol_lookup_debug,
5944                            _("\
5945 Set debugging of symbol lookup."), _("\
5946 Show debugging of symbol lookup."), _("\
5947 When enabled (non-zero), symbol lookups are logged."),
5948                            NULL, NULL,
5949                            &setdebuglist, &showdebuglist);
5950
5951   add_setshow_zuinteger_cmd ("symbol-cache-size", no_class,
5952                              &new_symbol_cache_size,
5953                              _("Set the size of the symbol cache."),
5954                              _("Show the size of the symbol cache."), _("\
5955 The size of the symbol cache.\n\
5956 If zero then the symbol cache is disabled."),
5957                              set_symbol_cache_size_handler, NULL,
5958                              &maintenance_set_cmdlist,
5959                              &maintenance_show_cmdlist);
5960
5961   add_cmd ("symbol-cache", class_maintenance, maintenance_print_symbol_cache,
5962            _("Dump the symbol cache for each program space."),
5963            &maintenanceprintlist);
5964
5965   add_cmd ("symbol-cache-statistics", class_maintenance,
5966            maintenance_print_symbol_cache_statistics,
5967            _("Print symbol cache statistics for each program space."),
5968            &maintenanceprintlist);
5969
5970   add_cmd ("flush-symbol-cache", class_maintenance,
5971            maintenance_flush_symbol_cache,
5972            _("Flush the symbol cache for each program space."),
5973            &maintenancelist);
5974
5975   observer_attach_executable_changed (symtab_observer_executable_changed);
5976   observer_attach_new_objfile (symtab_new_objfile_observer);
5977   observer_attach_free_objfile (symtab_free_objfile_observer);
5978 }