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