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