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