2004-02-14 Elena Zannoni <ezannoni@redhat.com>
[platform/upstream/binutils.git] / gdb / symtab.c
1 /* Symbol table lookup for the GNU debugger, GDB.
2
3    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5    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 2 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, write to the Free Software
21    Foundation, Inc., 59 Temple Place - Suite 330,
22    Boston, MA 02111-1307, USA.  */
23
24 #include "defs.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "gdbcore.h"
28 #include "frame.h"
29 #include "target.h"
30 #include "value.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "gdbcmd.h"
34 #include "call-cmds.h"
35 #include "gdb_regex.h"
36 #include "expression.h"
37 #include "language.h"
38 #include "demangle.h"
39 #include "inferior.h"
40 #include "linespec.h"
41 #include "source.h"
42 #include "filenames.h"          /* for FILENAME_CMP */
43 #include "objc-lang.h"
44
45 #include "hashtab.h"
46
47 #include "gdb_obstack.h"
48 #include "block.h"
49 #include "dictionary.h"
50
51 #include <sys/types.h>
52 #include <fcntl.h>
53 #include "gdb_string.h"
54 #include "gdb_stat.h"
55 #include <ctype.h>
56 #include "cp-abi.h"
57
58 /* Prototypes for local functions */
59
60 static void completion_list_add_name (char *, char *, int, char *, char *);
61
62 static void rbreak_command (char *, int);
63
64 static void types_info (char *, int);
65
66 static void functions_info (char *, int);
67
68 static void variables_info (char *, int);
69
70 static void sources_info (char *, int);
71
72 static void output_source_filename (char *, int *);
73
74 static int find_line_common (struct linetable *, int, int *);
75
76 /* This one is used by linespec.c */
77
78 char *operator_chars (char *p, char **end);
79
80 static struct symbol *lookup_symbol_aux (const char *name,
81                                          const char *linkage_name,
82                                          const struct block *block,
83                                          const domain_enum domain,
84                                          int *is_a_field_of_this,
85                                          struct symtab **symtab);
86
87 static
88 struct symbol *lookup_symbol_aux_local (const char *name,
89                                         const char *linkage_name,
90                                         const struct block *block,
91                                         const domain_enum domain,
92                                         struct symtab **symtab);
93
94 static
95 struct symbol *lookup_symbol_aux_symtabs (int block_index,
96                                           const char *name,
97                                           const char *linkage_name,
98                                           const domain_enum domain,
99                                           struct symtab **symtab);
100
101 static
102 struct symbol *lookup_symbol_aux_psymtabs (int block_index,
103                                            const char *name,
104                                            const char *linkage_name,
105                                            const domain_enum domain,
106                                            struct symtab **symtab);
107
108 #if 0
109 static
110 struct symbol *lookup_symbol_aux_minsyms (const char *name,
111                                           const char *linkage_name,
112                                           const domain_enum domain,
113                                           int *is_a_field_of_this,
114                                           struct symtab **symtab);
115 #endif
116
117 /* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */
118 /* Signals the presence of objects compiled by HP compilers */
119 int hp_som_som_object_present = 0;
120
121 static void fixup_section (struct general_symbol_info *, struct objfile *);
122
123 static int file_matches (char *, char **, int);
124
125 static void print_symbol_info (domain_enum,
126                                struct symtab *, struct symbol *, int, char *);
127
128 static void print_msymbol_info (struct minimal_symbol *);
129
130 static void symtab_symbol_info (char *, domain_enum, int);
131
132 void _initialize_symtab (void);
133
134 /* */
135
136 /* The single non-language-specific builtin type */
137 struct type *builtin_type_error;
138
139 /* Block in which the most recently searched-for symbol was found.
140    Might be better to make this a parameter to lookup_symbol and 
141    value_of_this. */
142
143 const struct block *block_found;
144
145 /* Check for a symtab of a specific name; first in symtabs, then in
146    psymtabs.  *If* there is no '/' in the name, a match after a '/'
147    in the symtab filename will also work.  */
148
149 struct symtab *
150 lookup_symtab (const char *name)
151 {
152   struct symtab *s;
153   struct partial_symtab *ps;
154   struct objfile *objfile;
155   char *real_path = NULL;
156   char *full_path = NULL;
157
158   /* Here we are interested in canonicalizing an absolute path, not
159      absolutizing a relative path.  */
160   if (IS_ABSOLUTE_PATH (name))
161     {
162       full_path = xfullpath (name);
163       make_cleanup (xfree, full_path);
164       real_path = gdb_realpath (name);
165       make_cleanup (xfree, real_path);
166     }
167
168 got_symtab:
169
170   /* First, search for an exact match */
171
172   ALL_SYMTABS (objfile, s)
173   {
174     if (FILENAME_CMP (name, s->filename) == 0)
175       {
176         return s;
177       }
178       
179     /* If the user gave us an absolute path, try to find the file in
180        this symtab and use its absolute path.  */
181     
182     if (full_path != NULL)
183       {
184         const char *fp = symtab_to_filename (s);
185         if (FILENAME_CMP (full_path, fp) == 0)
186           {
187             return s;
188           }
189       }
190
191     if (real_path != NULL)
192       {
193         char *rp = gdb_realpath (symtab_to_filename (s));
194         make_cleanup (xfree, rp);
195         if (FILENAME_CMP (real_path, rp) == 0)
196           {
197             return s;
198           }
199       }
200   }
201
202   /* Now, search for a matching tail (only if name doesn't have any dirs) */
203
204   if (lbasename (name) == name)
205     ALL_SYMTABS (objfile, s)
206     {
207       if (FILENAME_CMP (lbasename (s->filename), name) == 0)
208         return s;
209     }
210
211   /* Same search rules as above apply here, but now we look thru the
212      psymtabs.  */
213
214   ps = lookup_partial_symtab (name);
215   if (!ps)
216     return (NULL);
217
218   if (ps->readin)
219     error ("Internal: readin %s pst for `%s' found when no symtab found.",
220            ps->filename, name);
221
222   s = PSYMTAB_TO_SYMTAB (ps);
223
224   if (s)
225     return s;
226
227   /* At this point, we have located the psymtab for this file, but
228      the conversion to a symtab has failed.  This usually happens
229      when we are looking up an include file.  In this case,
230      PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
231      been created.  So, we need to run through the symtabs again in
232      order to find the file.
233      XXX - This is a crock, and should be fixed inside of the the
234      symbol parsing routines. */
235   goto got_symtab;
236 }
237
238 /* Lookup the partial symbol table of a source file named NAME.
239    *If* there is no '/' in the name, a match after a '/'
240    in the psymtab filename will also work.  */
241
242 struct partial_symtab *
243 lookup_partial_symtab (const char *name)
244 {
245   struct partial_symtab *pst;
246   struct objfile *objfile;
247   char *full_path = NULL;
248   char *real_path = NULL;
249
250   /* Here we are interested in canonicalizing an absolute path, not
251      absolutizing a relative path.  */
252   if (IS_ABSOLUTE_PATH (name))
253     {
254       full_path = xfullpath (name);
255       make_cleanup (xfree, full_path);
256       real_path = gdb_realpath (name);
257       make_cleanup (xfree, real_path);
258     }
259
260   ALL_PSYMTABS (objfile, pst)
261   {
262     if (FILENAME_CMP (name, pst->filename) == 0)
263       {
264         return (pst);
265       }
266
267     /* If the user gave us an absolute path, try to find the file in
268        this symtab and use its absolute path.  */
269     if (full_path != NULL)
270       {
271         if (pst->fullname == NULL)
272           source_full_path_of (pst->filename, &pst->fullname);
273         if (pst->fullname != NULL
274             && FILENAME_CMP (full_path, pst->fullname) == 0)
275           {
276             return pst;
277           }
278       }
279
280     if (real_path != NULL)
281       {
282         char *rp = NULL;
283         if (pst->fullname == NULL)
284           source_full_path_of (pst->filename, &pst->fullname);
285         if (pst->fullname != NULL)
286           {
287             rp = gdb_realpath (pst->fullname);
288             make_cleanup (xfree, rp);
289           }
290         if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
291           {
292             return pst;
293           }
294       }
295   }
296
297   /* Now, search for a matching tail (only if name doesn't have any dirs) */
298
299   if (lbasename (name) == name)
300     ALL_PSYMTABS (objfile, pst)
301     {
302       if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
303         return (pst);
304     }
305
306   return (NULL);
307 }
308 \f
309 /* Mangle a GDB method stub type.  This actually reassembles the pieces of the
310    full method name, which consist of the class name (from T), the unadorned
311    method name from METHOD_ID, and the signature for the specific overload,
312    specified by SIGNATURE_ID.  Note that this function is g++ specific. */
313
314 char *
315 gdb_mangle_name (struct type *type, int method_id, int signature_id)
316 {
317   int mangled_name_len;
318   char *mangled_name;
319   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
320   struct fn_field *method = &f[signature_id];
321   char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
322   char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
323   char *newname = type_name_no_tag (type);
324
325   /* Does the form of physname indicate that it is the full mangled name
326      of a constructor (not just the args)?  */
327   int is_full_physname_constructor;
328
329   int is_constructor;
330   int is_destructor = is_destructor_name (physname);
331   /* Need a new type prefix.  */
332   char *const_prefix = method->is_const ? "C" : "";
333   char *volatile_prefix = method->is_volatile ? "V" : "";
334   char buf[20];
335   int len = (newname == NULL ? 0 : strlen (newname));
336
337   /* Nothing to do if physname already contains a fully mangled v3 abi name
338      or an operator name.  */
339   if ((physname[0] == '_' && physname[1] == 'Z')
340       || is_operator_name (field_name))
341     return xstrdup (physname);
342
343   is_full_physname_constructor = is_constructor_name (physname);
344
345   is_constructor =
346     is_full_physname_constructor || (newname && strcmp (field_name, newname) == 0);
347
348   if (!is_destructor)
349     is_destructor = (strncmp (physname, "__dt", 4) == 0);
350
351   if (is_destructor || is_full_physname_constructor)
352     {
353       mangled_name = (char *) xmalloc (strlen (physname) + 1);
354       strcpy (mangled_name, physname);
355       return mangled_name;
356     }
357
358   if (len == 0)
359     {
360       sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
361     }
362   else if (physname[0] == 't' || physname[0] == 'Q')
363     {
364       /* The physname for template and qualified methods already includes
365          the class name.  */
366       sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
367       newname = NULL;
368       len = 0;
369     }
370   else
371     {
372       sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
373     }
374   mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
375                       + strlen (buf) + len + strlen (physname) + 1);
376
377     {
378       mangled_name = (char *) xmalloc (mangled_name_len);
379       if (is_constructor)
380         mangled_name[0] = '\0';
381       else
382         strcpy (mangled_name, field_name);
383     }
384   strcat (mangled_name, buf);
385   /* If the class doesn't have a name, i.e. newname NULL, then we just
386      mangle it using 0 for the length of the class.  Thus it gets mangled
387      as something starting with `::' rather than `classname::'. */
388   if (newname != NULL)
389     strcat (mangled_name, newname);
390
391   strcat (mangled_name, physname);
392   return (mangled_name);
393 }
394
395 \f
396 /* Initialize the language dependent portion of a symbol
397    depending upon the language for the symbol. */
398 void
399 symbol_init_language_specific (struct general_symbol_info *gsymbol,
400                                enum language language)
401 {
402   gsymbol->language = language;
403   if (gsymbol->language == language_cplus
404       || gsymbol->language == language_java
405       || gsymbol->language == language_objc)
406     {
407       gsymbol->language_specific.cplus_specific.demangled_name = NULL;
408     }
409   else
410     {
411       memset (&gsymbol->language_specific, 0,
412               sizeof (gsymbol->language_specific));
413     }
414 }
415
416 /* Functions to initialize a symbol's mangled name.  */
417
418 /* Create the hash table used for demangled names.  Each hash entry is
419    a pair of strings; one for the mangled name and one for the demangled
420    name.  The entry is hashed via just the mangled name.  */
421
422 static void
423 create_demangled_names_hash (struct objfile *objfile)
424 {
425   /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
426      The hash table code will round this up to the next prime number. 
427      Choosing a much larger table size wastes memory, and saves only about
428      1% in symbol reading.  */
429
430   objfile->demangled_names_hash = htab_create_alloc_ex
431     (256, htab_hash_string, (int (*) (const void *, const void *)) streq,
432      NULL, objfile->md, xmcalloc, xmfree);
433 }
434
435 /* Try to determine the demangled name for a symbol, based on the
436    language of that symbol.  If the language is set to language_auto,
437    it will attempt to find any demangling algorithm that works and
438    then set the language appropriately.  The returned name is allocated
439    by the demangler and should be xfree'd.  */
440
441 static char *
442 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
443                             const char *mangled)
444 {
445   char *demangled = NULL;
446
447   if (gsymbol->language == language_unknown)
448     gsymbol->language = language_auto;
449
450   if (gsymbol->language == language_objc
451       || gsymbol->language == language_auto)
452     {
453       demangled =
454         objc_demangle (mangled, 0);
455       if (demangled != NULL)
456         {
457           gsymbol->language = language_objc;
458           return demangled;
459         }
460     }
461   if (gsymbol->language == language_cplus
462       || gsymbol->language == language_auto)
463     {
464       demangled =
465         cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
466       if (demangled != NULL)
467         {
468           gsymbol->language = language_cplus;
469           return demangled;
470         }
471     }
472   if (gsymbol->language == language_java)
473     {
474       demangled =
475         cplus_demangle (mangled,
476                         DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
477       if (demangled != NULL)
478         {
479           gsymbol->language = language_java;
480           return demangled;
481         }
482     }
483   return NULL;
484 }
485
486 /* Set both the mangled and demangled (if any) names for GSYMBOL based
487    on LINKAGE_NAME and LEN.  The hash table corresponding to OBJFILE
488    is used, and the memory comes from that objfile's objfile_obstack.
489    LINKAGE_NAME is copied, so the pointer can be discarded after
490    calling this function.  */
491
492 /* We have to be careful when dealing with Java names: when we run
493    into a Java minimal symbol, we don't know it's a Java symbol, so it
494    gets demangled as a C++ name.  This is unfortunate, but there's not
495    much we can do about it: but when demangling partial symbols and
496    regular symbols, we'd better not reuse the wrong demangled name.
497    (See PR gdb/1039.)  We solve this by putting a distinctive prefix
498    on Java names when storing them in the hash table.  */
499
500 /* FIXME: carlton/2003-03-13: This is an unfortunate situation.  I
501    don't mind the Java prefix so much: different languages have
502    different demangling requirements, so it's only natural that we
503    need to keep language data around in our demangling cache.  But
504    it's not good that the minimal symbol has the wrong demangled name.
505    Unfortunately, I can't think of any easy solution to that
506    problem.  */
507
508 #define JAVA_PREFIX "##JAVA$$"
509 #define JAVA_PREFIX_LEN 8
510
511 void
512 symbol_set_names (struct general_symbol_info *gsymbol,
513                   const char *linkage_name, int len, struct objfile *objfile)
514 {
515   char **slot;
516   /* A 0-terminated copy of the linkage name.  */
517   const char *linkage_name_copy;
518   /* A copy of the linkage name that might have a special Java prefix
519      added to it, for use when looking names up in the hash table.  */
520   const char *lookup_name;
521   /* The length of lookup_name.  */
522   int lookup_len;
523
524   if (objfile->demangled_names_hash == NULL)
525     create_demangled_names_hash (objfile);
526
527   /* The stabs reader generally provides names that are not
528      NUL-terminated; most of the other readers don't do this, so we
529      can just use the given copy, unless we're in the Java case.  */
530   if (gsymbol->language == language_java)
531     {
532       char *alloc_name;
533       lookup_len = len + JAVA_PREFIX_LEN;
534
535       alloc_name = alloca (lookup_len + 1);
536       memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
537       memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
538       alloc_name[lookup_len] = '\0';
539
540       lookup_name = alloc_name;
541       linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
542     }
543   else if (linkage_name[len] != '\0')
544     {
545       char *alloc_name;
546       lookup_len = len;
547
548       alloc_name = alloca (lookup_len + 1);
549       memcpy (alloc_name, linkage_name, len);
550       alloc_name[lookup_len] = '\0';
551
552       lookup_name = alloc_name;
553       linkage_name_copy = alloc_name;
554     }
555   else
556     {
557       lookup_len = len;
558       lookup_name = linkage_name;
559       linkage_name_copy = linkage_name;
560     }
561
562   slot = (char **) htab_find_slot (objfile->demangled_names_hash,
563                                    lookup_name, INSERT);
564
565   /* If this name is not in the hash table, add it.  */
566   if (*slot == NULL)
567     {
568       char *demangled_name = symbol_find_demangled_name (gsymbol,
569                                                          linkage_name_copy);
570       int demangled_len = demangled_name ? strlen (demangled_name) : 0;
571
572       /* If there is a demangled name, place it right after the mangled name.
573          Otherwise, just place a second zero byte after the end of the mangled
574          name.  */
575       *slot = obstack_alloc (&objfile->objfile_obstack,
576                              lookup_len + demangled_len + 2);
577       memcpy (*slot, lookup_name, lookup_len + 1);
578       if (demangled_name != NULL)
579         {
580           memcpy (*slot + lookup_len + 1, demangled_name, demangled_len + 1);
581           xfree (demangled_name);
582         }
583       else
584         (*slot)[lookup_len + 1] = '\0';
585     }
586
587   gsymbol->name = *slot + lookup_len - len;
588   if ((*slot)[lookup_len + 1] != '\0')
589     gsymbol->language_specific.cplus_specific.demangled_name
590       = &(*slot)[lookup_len + 1];
591   else
592     gsymbol->language_specific.cplus_specific.demangled_name = NULL;
593 }
594
595 /* Initialize the demangled name of GSYMBOL if possible.  Any required space
596    to store the name is obtained from the specified obstack.  The function
597    symbol_set_names, above, should be used instead where possible for more
598    efficient memory usage.  */
599
600 void
601 symbol_init_demangled_name (struct general_symbol_info *gsymbol,
602                             struct obstack *obstack)
603 {
604   char *mangled = gsymbol->name;
605   char *demangled = NULL;
606
607   demangled = symbol_find_demangled_name (gsymbol, mangled);
608   if (gsymbol->language == language_cplus
609       || gsymbol->language == language_java
610       || gsymbol->language == language_objc)
611     {
612       if (demangled)
613         {
614           gsymbol->language_specific.cplus_specific.demangled_name
615             = obsavestring (demangled, strlen (demangled), obstack);
616           xfree (demangled);
617         }
618       else
619         gsymbol->language_specific.cplus_specific.demangled_name = NULL;
620     }
621   else
622     {
623       /* Unknown language; just clean up quietly.  */
624       if (demangled)
625         xfree (demangled);
626     }
627 }
628
629 /* Return the source code name of a symbol.  In languages where
630    demangling is necessary, this is the demangled name.  */
631
632 char *
633 symbol_natural_name (const struct general_symbol_info *gsymbol)
634 {
635   if ((gsymbol->language == language_cplus
636        || gsymbol->language == language_java
637        || gsymbol->language == language_objc)
638       && (gsymbol->language_specific.cplus_specific.demangled_name != NULL))
639     {
640       return gsymbol->language_specific.cplus_specific.demangled_name;
641     }
642   else
643     {
644       return gsymbol->name;
645     }
646 }
647
648 /* Return the demangled name for a symbol based on the language for
649    that symbol.  If no demangled name exists, return NULL. */
650 char *
651 symbol_demangled_name (struct general_symbol_info *gsymbol)
652 {
653   if (gsymbol->language == language_cplus
654       || gsymbol->language == language_java
655       || gsymbol->language == language_objc)
656     return gsymbol->language_specific.cplus_specific.demangled_name;
657
658   else 
659     return NULL;
660 }
661
662 /* Initialize the structure fields to zero values.  */
663 void
664 init_sal (struct symtab_and_line *sal)
665 {
666   sal->symtab = 0;
667   sal->section = 0;
668   sal->line = 0;
669   sal->pc = 0;
670   sal->end = 0;
671 }
672 \f
673
674
675 /* Find which partial symtab on contains PC and SECTION.  Return 0 if none.  */
676
677 struct partial_symtab *
678 find_pc_sect_psymtab (CORE_ADDR pc, asection *section)
679 {
680   struct partial_symtab *pst;
681   struct objfile *objfile;
682   struct minimal_symbol *msymbol;
683
684   /* If we know that this is not a text address, return failure.  This is
685      necessary because we loop based on texthigh and textlow, which do
686      not include the data ranges.  */
687   msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
688   if (msymbol
689       && (msymbol->type == mst_data
690           || msymbol->type == mst_bss
691           || msymbol->type == mst_abs
692           || msymbol->type == mst_file_data
693           || msymbol->type == mst_file_bss))
694     return NULL;
695
696   ALL_PSYMTABS (objfile, pst)
697   {
698     if (pc >= pst->textlow && pc < pst->texthigh)
699       {
700         struct partial_symtab *tpst;
701
702         /* An objfile that has its functions reordered might have
703            many partial symbol tables containing the PC, but
704            we want the partial symbol table that contains the
705            function containing the PC.  */
706         if (!(objfile->flags & OBJF_REORDERED) &&
707             section == 0)       /* can't validate section this way */
708           return (pst);
709
710         if (msymbol == NULL)
711           return (pst);
712
713         for (tpst = pst; tpst != NULL; tpst = tpst->next)
714           {
715             if (pc >= tpst->textlow && pc < tpst->texthigh)
716               {
717                 struct partial_symbol *p;
718
719                 p = find_pc_sect_psymbol (tpst, pc, section);
720                 if (p != NULL
721                     && SYMBOL_VALUE_ADDRESS (p)
722                     == SYMBOL_VALUE_ADDRESS (msymbol))
723                   return (tpst);
724               }
725           }
726         return (pst);
727       }
728   }
729   return (NULL);
730 }
731
732 /* Find which partial symtab contains PC.  Return 0 if none. 
733    Backward compatibility, no section */
734
735 struct partial_symtab *
736 find_pc_psymtab (CORE_ADDR pc)
737 {
738   return find_pc_sect_psymtab (pc, find_pc_mapped_section (pc));
739 }
740
741 /* Find which partial symbol within a psymtab matches PC and SECTION.  
742    Return 0 if none.  Check all psymtabs if PSYMTAB is 0.  */
743
744 struct partial_symbol *
745 find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
746                       asection *section)
747 {
748   struct partial_symbol *best = NULL, *p, **pp;
749   CORE_ADDR best_pc;
750
751   if (!psymtab)
752     psymtab = find_pc_sect_psymtab (pc, section);
753   if (!psymtab)
754     return 0;
755
756   /* Cope with programs that start at address 0 */
757   best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
758
759   /* Search the global symbols as well as the static symbols, so that
760      find_pc_partial_function doesn't use a minimal symbol and thus
761      cache a bad endaddr.  */
762   for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
763     (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
764      < psymtab->n_global_syms);
765        pp++)
766     {
767       p = *pp;
768       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
769           && SYMBOL_CLASS (p) == LOC_BLOCK
770           && pc >= SYMBOL_VALUE_ADDRESS (p)
771           && (SYMBOL_VALUE_ADDRESS (p) > best_pc
772               || (psymtab->textlow == 0
773                   && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
774         {
775           if (section)          /* match on a specific section */
776             {
777               fixup_psymbol_section (p, psymtab->objfile);
778               if (SYMBOL_BFD_SECTION (p) != section)
779                 continue;
780             }
781           best_pc = SYMBOL_VALUE_ADDRESS (p);
782           best = p;
783         }
784     }
785
786   for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
787     (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
788      < psymtab->n_static_syms);
789        pp++)
790     {
791       p = *pp;
792       if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
793           && SYMBOL_CLASS (p) == LOC_BLOCK
794           && pc >= SYMBOL_VALUE_ADDRESS (p)
795           && (SYMBOL_VALUE_ADDRESS (p) > best_pc
796               || (psymtab->textlow == 0
797                   && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
798         {
799           if (section)          /* match on a specific section */
800             {
801               fixup_psymbol_section (p, psymtab->objfile);
802               if (SYMBOL_BFD_SECTION (p) != section)
803                 continue;
804             }
805           best_pc = SYMBOL_VALUE_ADDRESS (p);
806           best = p;
807         }
808     }
809
810   return best;
811 }
812
813 /* Find which partial symbol within a psymtab matches PC.  Return 0 if none.  
814    Check all psymtabs if PSYMTAB is 0.  Backwards compatibility, no section. */
815
816 struct partial_symbol *
817 find_pc_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc)
818 {
819   return find_pc_sect_psymbol (psymtab, pc, find_pc_mapped_section (pc));
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 static void
826 fixup_section (struct general_symbol_info *ginfo, struct objfile *objfile)
827 {
828   struct minimal_symbol *msym;
829   msym = lookup_minimal_symbol (ginfo->name, NULL, objfile);
830
831   if (msym)
832     {
833       ginfo->bfd_section = SYMBOL_BFD_SECTION (msym);
834       ginfo->section = SYMBOL_SECTION (msym);
835     }
836 }
837
838 struct symbol *
839 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
840 {
841   if (!sym)
842     return NULL;
843
844   if (SYMBOL_BFD_SECTION (sym))
845     return sym;
846
847   fixup_section (&sym->ginfo, objfile);
848
849   return sym;
850 }
851
852 struct partial_symbol *
853 fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
854 {
855   if (!psym)
856     return NULL;
857
858   if (SYMBOL_BFD_SECTION (psym))
859     return psym;
860
861   fixup_section (&psym->ginfo, objfile);
862
863   return psym;
864 }
865
866 /* Find the definition for a specified symbol name NAME
867    in domain DOMAIN, visible from lexical block BLOCK.
868    Returns the struct symbol pointer, or zero if no symbol is found.
869    If SYMTAB is non-NULL, store the symbol table in which the
870    symbol was found there, or NULL if not found.
871    C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
872    NAME is a field of the current implied argument `this'.  If so set
873    *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero. 
874    BLOCK_FOUND is set to the block in which NAME is found (in the case of
875    a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
876
877 /* This function has a bunch of loops in it and it would seem to be
878    attractive to put in some QUIT's (though I'm not really sure
879    whether it can run long enough to be really important).  But there
880    are a few calls for which it would appear to be bad news to quit
881    out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c.  (Note
882    that there is C++ code below which can error(), but that probably
883    doesn't affect these calls since they are looking for a known
884    variable and thus can probably assume it will never hit the C++
885    code).  */
886
887 struct symbol *
888 lookup_symbol (const char *name, const struct block *block,
889                const domain_enum domain, int *is_a_field_of_this,
890                struct symtab **symtab)
891 {
892   char *demangled_name = NULL;
893   const char *modified_name = NULL;
894   const char *mangled_name = NULL;
895   int needtofreename = 0;
896   struct symbol *returnval;
897
898   modified_name = name;
899
900   /* If we are using C++ language, demangle the name before doing a lookup, so
901      we can always binary search. */
902   if (current_language->la_language == language_cplus)
903     {
904       demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
905       if (demangled_name)
906         {
907           mangled_name = name;
908           modified_name = demangled_name;
909           needtofreename = 1;
910         }
911     }
912
913   if (case_sensitivity == case_sensitive_off)
914     {
915       char *copy;
916       int len, i;
917
918       len = strlen (name);
919       copy = (char *) alloca (len + 1);
920       for (i= 0; i < len; i++)
921         copy[i] = tolower (name[i]);
922       copy[len] = 0;
923       modified_name = copy;
924     }
925
926   returnval = lookup_symbol_aux (modified_name, mangled_name, block,
927                                  domain, is_a_field_of_this, symtab);
928   if (needtofreename)
929     xfree (demangled_name);
930
931   return returnval;      
932 }
933
934 /* Behave like lookup_symbol_aux except that NAME is the natural name
935    of the symbol that we're looking for and, if LINKAGE_NAME is
936    non-NULL, ensure that the symbol's linkage name matches as
937    well.  */
938
939 static struct symbol *
940 lookup_symbol_aux (const char *name, const char *linkage_name,
941                    const struct block *block, const domain_enum domain,
942                    int *is_a_field_of_this, struct symtab **symtab)
943 {
944   struct symbol *sym;
945
946   /* Make sure we do something sensible with is_a_field_of_this, since
947      the callers that set this parameter to some non-null value will
948      certainly use it later and expect it to be either 0 or 1.
949      If we don't set it, the contents of is_a_field_of_this are
950      undefined.  */
951   if (is_a_field_of_this != NULL)
952     *is_a_field_of_this = 0;
953
954   /* Search specified block and its superiors.  Don't search
955      STATIC_BLOCK or GLOBAL_BLOCK.  */
956
957   sym = lookup_symbol_aux_local (name, linkage_name, block, domain,
958                                  symtab);
959   if (sym != NULL)
960     return sym;
961
962   /* If requested to do so by the caller and if appropriate for the
963      current language, check to see if NAME is a field of `this'. */
964
965   if (current_language->la_value_of_this != NULL
966       && is_a_field_of_this != NULL)
967     {
968       struct value *v = current_language->la_value_of_this (0);
969
970       if (v && check_field (v, name))
971         {
972           *is_a_field_of_this = 1;
973           if (symtab != NULL)
974             *symtab = NULL;
975           return NULL;
976         }
977     }
978
979   /* Now do whatever is appropriate for the current language to look
980      up static and global variables.  */
981
982   sym = current_language->la_lookup_symbol_nonlocal (name, linkage_name,
983                                                      block, domain,
984                                                      symtab);
985   if (sym != NULL)
986     return sym;
987
988   /* Now search all static file-level symbols.  Not strictly correct,
989      but more useful than an error.  Do the symtabs first, then check
990      the psymtabs.  If a psymtab indicates the existence of the
991      desired name as a file-level static, then do psymtab-to-symtab
992      conversion on the fly and return the found symbol. */
993
994   sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name,
995                                    domain, symtab);
996   if (sym != NULL)
997     return sym;
998   
999   sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name,
1000                                     domain, symtab);
1001   if (sym != NULL)
1002     return sym;
1003
1004   if (symtab != NULL)
1005     *symtab = NULL;
1006   return NULL;
1007 }
1008
1009 /* Check to see if the symbol is defined in BLOCK or its superiors.
1010    Don't search STATIC_BLOCK or GLOBAL_BLOCK.  */
1011
1012 static struct symbol *
1013 lookup_symbol_aux_local (const char *name, const char *linkage_name,
1014                          const struct block *block,
1015                          const domain_enum domain,
1016                          struct symtab **symtab)
1017 {
1018   struct symbol *sym;
1019   const struct block *static_block = block_static_block (block);
1020
1021   /* Check if either no block is specified or it's a global block.  */
1022
1023   if (static_block == NULL)
1024     return NULL;
1025
1026   while (block != static_block)
1027     {
1028       sym = lookup_symbol_aux_block (name, linkage_name, block, domain,
1029                                      symtab);
1030       if (sym != NULL)
1031         return sym;
1032       block = BLOCK_SUPERBLOCK (block);
1033     }
1034
1035   /* We've reached the static block without finding a result.  */
1036
1037   return NULL;
1038 }
1039
1040 /* Look up a symbol in a block; if found, locate its symtab, fixup the
1041    symbol, and set block_found appropriately.  */
1042
1043 struct symbol *
1044 lookup_symbol_aux_block (const char *name, const char *linkage_name,
1045                          const struct block *block,
1046                          const domain_enum domain,
1047                          struct symtab **symtab)
1048 {
1049   struct symbol *sym;
1050   struct objfile *objfile = NULL;
1051   struct blockvector *bv;
1052   struct block *b;
1053   struct symtab *s = NULL;
1054
1055   sym = lookup_block_symbol (block, name, linkage_name, domain);
1056   if (sym)
1057     {
1058       block_found = block;
1059       if (symtab != NULL)
1060         {
1061           /* Search the list of symtabs for one which contains the
1062              address of the start of this block.  */
1063           ALL_SYMTABS (objfile, s)
1064             {
1065               bv = BLOCKVECTOR (s);
1066               b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1067               if (BLOCK_START (b) <= BLOCK_START (block)
1068                   && BLOCK_END (b) > BLOCK_START (block))
1069                 goto found;
1070             }
1071         found:
1072           *symtab = s;
1073         }
1074       
1075       return fixup_symbol_section (sym, objfile);
1076     }
1077
1078   return NULL;
1079 }
1080
1081 /* Check to see if the symbol is defined in one of the symtabs.
1082    BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1083    depending on whether or not we want to search global symbols or
1084    static symbols.  */
1085
1086 static struct symbol *
1087 lookup_symbol_aux_symtabs (int block_index,
1088                            const char *name, const char *linkage_name,
1089                            const domain_enum domain,
1090                            struct symtab **symtab)
1091 {
1092   struct symbol *sym;
1093   struct objfile *objfile;
1094   struct blockvector *bv;
1095   const struct block *block;
1096   struct symtab *s;
1097
1098   ALL_SYMTABS (objfile, s)
1099   {
1100     bv = BLOCKVECTOR (s);
1101     block = BLOCKVECTOR_BLOCK (bv, block_index);
1102     sym = lookup_block_symbol (block, name, linkage_name, domain);
1103     if (sym)
1104       {
1105         block_found = block;
1106         if (symtab != NULL)
1107           *symtab = s;
1108         return fixup_symbol_section (sym, objfile);
1109       }
1110   }
1111
1112   return NULL;
1113 }
1114
1115 /* Check to see if the symbol is defined in one of the partial
1116    symtabs.  BLOCK_INDEX should be either GLOBAL_BLOCK or
1117    STATIC_BLOCK, depending on whether or not we want to search global
1118    symbols or static symbols.  */
1119
1120 static struct symbol *
1121 lookup_symbol_aux_psymtabs (int block_index, const char *name,
1122                             const char *linkage_name,
1123                             const domain_enum domain,
1124                             struct symtab **symtab)
1125 {
1126   struct symbol *sym;
1127   struct objfile *objfile;
1128   struct blockvector *bv;
1129   const struct block *block;
1130   struct partial_symtab *ps;
1131   struct symtab *s;
1132   const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
1133
1134   ALL_PSYMTABS (objfile, ps)
1135   {
1136     if (!ps->readin
1137         && lookup_partial_symbol (ps, name, linkage_name,
1138                                   psymtab_index, domain))
1139       {
1140         s = PSYMTAB_TO_SYMTAB (ps);
1141         bv = BLOCKVECTOR (s);
1142         block = BLOCKVECTOR_BLOCK (bv, block_index);
1143         sym = lookup_block_symbol (block, name, linkage_name, domain);
1144         if (!sym)
1145           {
1146             /* This shouldn't be necessary, but as a last resort try
1147                looking in the statics even though the psymtab claimed
1148                the symbol was global, or vice-versa. It's possible
1149                that the psymtab gets it wrong in some cases.  */
1150
1151             /* FIXME: carlton/2002-09-30: Should we really do that?
1152                If that happens, isn't it likely to be a GDB error, in
1153                which case we should fix the GDB error rather than
1154                silently dealing with it here?  So I'd vote for
1155                removing the check for the symbol in the other
1156                block.  */
1157             block = BLOCKVECTOR_BLOCK (bv,
1158                                        block_index == GLOBAL_BLOCK ?
1159                                        STATIC_BLOCK : GLOBAL_BLOCK);
1160             sym = lookup_block_symbol (block, name, linkage_name, domain);
1161             if (!sym)
1162               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>).",
1163                      block_index == GLOBAL_BLOCK ? "global" : "static",
1164                      name, ps->filename, name, name);
1165           }
1166         if (symtab != NULL)
1167           *symtab = s;
1168         return fixup_symbol_section (sym, objfile);
1169       }
1170   }
1171
1172   return NULL;
1173 }
1174
1175 #if 0
1176 /* Check for the possibility of the symbol being a function or a
1177    mangled variable that is stored in one of the minimal symbol
1178    tables.  Eventually, all global symbols might be resolved in this
1179    way.  */
1180
1181 /* NOTE: carlton/2002-12-05: At one point, this function was part of
1182    lookup_symbol_aux, and what are now 'return' statements within
1183    lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
1184    sym was NULL.  As far as I can tell, this was basically accidental;
1185    it didn't happen every time that msymbol was non-NULL, but only if
1186    some additional conditions held as well, and it caused problems
1187    with HP-generated symbol tables.  */
1188
1189 /* NOTE: carlton/2003-05-14: This function was once used as part of
1190    lookup_symbol.  It is currently unnecessary for correctness
1191    reasons, however, and using it doesn't seem to be any faster than
1192    using lookup_symbol_aux_psymtabs, so I'm commenting it out.  */
1193
1194 static struct symbol *
1195 lookup_symbol_aux_minsyms (const char *name,
1196                            const char *linkage_name,
1197                            const domain_enum domain,
1198                            int *is_a_field_of_this,
1199                            struct symtab **symtab)
1200 {
1201   struct symbol *sym;
1202   struct blockvector *bv;
1203   const struct block *block;
1204   struct minimal_symbol *msymbol;
1205   struct symtab *s;
1206
1207   if (domain == VAR_DOMAIN)
1208     {
1209       msymbol = lookup_minimal_symbol (name, NULL, NULL);
1210
1211       if (msymbol != NULL)
1212         {
1213           /* OK, we found a minimal symbol in spite of not finding any
1214              symbol. There are various possible explanations for
1215              this. One possibility is the symbol exists in code not
1216              compiled -g. Another possibility is that the 'psymtab'
1217              isn't doing its job.  A third possibility, related to #2,
1218              is that we were confused by name-mangling. For instance,
1219              maybe the psymtab isn't doing its job because it only
1220              know about demangled names, but we were given a mangled
1221              name...  */
1222
1223           /* We first use the address in the msymbol to try to locate
1224              the appropriate symtab. Note that find_pc_sect_symtab()
1225              has a side-effect of doing psymtab-to-symtab expansion,
1226              for the found symtab.  */
1227           s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
1228                                    SYMBOL_BFD_SECTION (msymbol));
1229           if (s != NULL)
1230             {
1231               /* This is a function which has a symtab for its address.  */
1232               bv = BLOCKVECTOR (s);
1233               block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1234
1235               /* This call used to pass `SYMBOL_LINKAGE_NAME (msymbol)' as the
1236                  `name' argument to lookup_block_symbol.  But the name
1237                  of a minimal symbol is always mangled, so that seems
1238                  to be clearly the wrong thing to pass as the
1239                  unmangled name.  */
1240               sym =
1241                 lookup_block_symbol (block, name, linkage_name, domain);
1242               /* We kept static functions in minimal symbol table as well as
1243                  in static scope. We want to find them in the symbol table. */
1244               if (!sym)
1245                 {
1246                   block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1247                   sym = lookup_block_symbol (block, name,
1248                                              linkage_name, domain);
1249                 }
1250
1251               /* NOTE: carlton/2002-12-04: The following comment was
1252                  taken from a time when two versions of this function
1253                  were part of the body of lookup_symbol_aux: this
1254                  comment was taken from the version of the function
1255                  that was #ifdef HPUXHPPA, and the comment was right
1256                  before the 'return NULL' part of lookup_symbol_aux.
1257                  (Hence the "Fall through and return 0" comment.)
1258                  Elena did some digging into the situation for
1259                  Fortran, and she reports:
1260
1261                  "I asked around (thanks to Jeff Knaggs), and I think
1262                  the story for Fortran goes like this:
1263
1264                  "Apparently, in older Fortrans, '_' was not part of
1265                  the user namespace.  g77 attached a final '_' to
1266                  procedure names as the exported symbols for linkage
1267                  (foo_) , but the symbols went in the debug info just
1268                  like 'foo'. The rationale behind this is not
1269                  completely clear, and maybe it was done to other
1270                  symbols as well, not just procedures."  */
1271
1272               /* If we get here with sym == 0, the symbol was 
1273                  found in the minimal symbol table
1274                  but not in the symtab.
1275                  Fall through and return 0 to use the msymbol 
1276                  definition of "foo_".
1277                  (Note that outer code generally follows up a call
1278                  to this routine with a call to lookup_minimal_symbol(),
1279                  so a 0 return means we'll just flow into that other routine).
1280
1281                  This happens for Fortran  "foo_" symbols,
1282                  which are "foo" in the symtab.
1283
1284                  This can also happen if "asm" is used to make a
1285                  regular symbol but not a debugging symbol, e.g.
1286                  asm(".globl _main");
1287                  asm("_main:");
1288                */
1289
1290               if (symtab != NULL && sym != NULL)
1291                 *symtab = s;
1292               return fixup_symbol_section (sym, s->objfile);
1293             }
1294         }
1295     }
1296
1297   return NULL;
1298 }
1299 #endif /* 0 */
1300
1301 /* A default version of lookup_symbol_nonlocal for use by languages
1302    that can't think of anything better to do.  This implements the C
1303    lookup rules.  */
1304
1305 struct symbol *
1306 basic_lookup_symbol_nonlocal (const char *name,
1307                               const char *linkage_name,
1308                               const struct block *block,
1309                               const domain_enum domain,
1310                               struct symtab **symtab)
1311 {
1312   struct symbol *sym;
1313
1314   /* NOTE: carlton/2003-05-19: The comments below were written when
1315      this (or what turned into this) was part of lookup_symbol_aux;
1316      I'm much less worried about these questions now, since these
1317      decisions have turned out well, but I leave these comments here
1318      for posterity.  */
1319
1320   /* NOTE: carlton/2002-12-05: There is a question as to whether or
1321      not it would be appropriate to search the current global block
1322      here as well.  (That's what this code used to do before the
1323      is_a_field_of_this check was moved up.)  On the one hand, it's
1324      redundant with the lookup_symbol_aux_symtabs search that happens
1325      next.  On the other hand, if decode_line_1 is passed an argument
1326      like filename:var, then the user presumably wants 'var' to be
1327      searched for in filename.  On the third hand, there shouldn't be
1328      multiple global variables all of which are named 'var', and it's
1329      not like decode_line_1 has ever restricted its search to only
1330      global variables in a single filename.  All in all, only
1331      searching the static block here seems best: it's correct and it's
1332      cleanest.  */
1333
1334   /* NOTE: carlton/2002-12-05: There's also a possible performance
1335      issue here: if you usually search for global symbols in the
1336      current file, then it would be slightly better to search the
1337      current global block before searching all the symtabs.  But there
1338      are other factors that have a much greater effect on performance
1339      than that one, so I don't think we should worry about that for
1340      now.  */
1341
1342   sym = lookup_symbol_static (name, linkage_name, block, domain, symtab);
1343   if (sym != NULL)
1344     return sym;
1345
1346   return lookup_symbol_global (name, linkage_name, domain, symtab);
1347 }
1348
1349 /* Lookup a symbol in the static block associated to BLOCK, if there
1350    is one; do nothing if BLOCK is NULL or a global block.  */
1351
1352 struct symbol *
1353 lookup_symbol_static (const char *name,
1354                       const char *linkage_name,
1355                       const struct block *block,
1356                       const domain_enum domain,
1357                       struct symtab **symtab)
1358 {
1359   const struct block *static_block = block_static_block (block);
1360
1361   if (static_block != NULL)
1362     return lookup_symbol_aux_block (name, linkage_name, static_block,
1363                                     domain, symtab);
1364   else
1365     return NULL;
1366 }
1367
1368 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1369    necessary).  */
1370
1371 struct symbol *
1372 lookup_symbol_global (const char *name,
1373                       const char *linkage_name,
1374                       const domain_enum domain,
1375                       struct symtab **symtab)
1376 {
1377   struct symbol *sym;
1378
1379   sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name,
1380                                    domain, symtab);
1381   if (sym != NULL)
1382     return sym;
1383
1384   return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name,
1385                                      domain, symtab);
1386 }
1387
1388 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1389    If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1390    linkage name matches it.  Check the global symbols if GLOBAL, the
1391    static symbols if not */
1392
1393 struct partial_symbol *
1394 lookup_partial_symbol (struct partial_symtab *pst, const char *name,
1395                        const char *linkage_name, int global,
1396                        domain_enum domain)
1397 {
1398   struct partial_symbol *temp;
1399   struct partial_symbol **start, **psym;
1400   struct partial_symbol **top, **real_top, **bottom, **center;
1401   int length = (global ? pst->n_global_syms : pst->n_static_syms);
1402   int do_linear_search = 1;
1403   
1404   if (length == 0)
1405     {
1406       return (NULL);
1407     }
1408   start = (global ?
1409            pst->objfile->global_psymbols.list + pst->globals_offset :
1410            pst->objfile->static_psymbols.list + pst->statics_offset);
1411   
1412   if (global)                   /* This means we can use a binary search. */
1413     {
1414       do_linear_search = 0;
1415
1416       /* Binary search.  This search is guaranteed to end with center
1417          pointing at the earliest partial symbol whose name might be
1418          correct.  At that point *all* partial symbols with an
1419          appropriate name will be checked against the correct
1420          domain.  */
1421
1422       bottom = start;
1423       top = start + length - 1;
1424       real_top = top;
1425       while (top > bottom)
1426         {
1427           center = bottom + (top - bottom) / 2;
1428           if (!(center < top))
1429             internal_error (__FILE__, __LINE__, "failed internal consistency check");
1430           if (!do_linear_search
1431               && (SYMBOL_LANGUAGE (*center) == language_java))
1432             {
1433               do_linear_search = 1;
1434             }
1435           if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center), name) >= 0)
1436             {
1437               top = center;
1438             }
1439           else
1440             {
1441               bottom = center + 1;
1442             }
1443         }
1444       if (!(top == bottom))
1445         internal_error (__FILE__, __LINE__, "failed internal consistency check");
1446
1447       while (top <= real_top
1448              && (linkage_name != NULL
1449                  ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0
1450                  : SYMBOL_MATCHES_NATURAL_NAME (*top,name)))
1451         {
1452           if (SYMBOL_DOMAIN (*top) == domain)
1453             {
1454                   return (*top);
1455             }
1456           top++;
1457         }
1458     }
1459
1460   /* Can't use a binary search or else we found during the binary search that
1461      we should also do a linear search. */
1462
1463   if (do_linear_search)
1464     {                   
1465       for (psym = start; psym < start + length; psym++)
1466         {
1467           if (domain == SYMBOL_DOMAIN (*psym))
1468             {
1469               if (linkage_name != NULL
1470                   ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0
1471                   : SYMBOL_MATCHES_NATURAL_NAME (*psym, name))
1472                 {
1473                   return (*psym);
1474                 }
1475             }
1476         }
1477     }
1478
1479   return (NULL);
1480 }
1481
1482 /* Look up a type named NAME in the struct_domain.  The type returned
1483    must not be opaque -- i.e., must have at least one field
1484    defined.  */
1485
1486 struct type *
1487 lookup_transparent_type (const char *name)
1488 {
1489   return current_language->la_lookup_transparent_type (name);
1490 }
1491
1492 /* The standard implementation of lookup_transparent_type.  This code
1493    was modeled on lookup_symbol -- the parts not relevant to looking
1494    up types were just left out.  In particular it's assumed here that
1495    types are available in struct_domain and only at file-static or
1496    global blocks.  */
1497
1498 struct type *
1499 basic_lookup_transparent_type (const char *name)
1500 {
1501   struct symbol *sym;
1502   struct symtab *s = NULL;
1503   struct partial_symtab *ps;
1504   struct blockvector *bv;
1505   struct objfile *objfile;
1506   struct block *block;
1507
1508   /* Now search all the global symbols.  Do the symtab's first, then
1509      check the psymtab's. If a psymtab indicates the existence
1510      of the desired name as a global, then do psymtab-to-symtab
1511      conversion on the fly and return the found symbol.  */
1512
1513   ALL_SYMTABS (objfile, s)
1514   {
1515     bv = BLOCKVECTOR (s);
1516     block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1517     sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1518     if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1519       {
1520         return SYMBOL_TYPE (sym);
1521       }
1522   }
1523
1524   ALL_PSYMTABS (objfile, ps)
1525   {
1526     if (!ps->readin && lookup_partial_symbol (ps, name, NULL,
1527                                               1, STRUCT_DOMAIN))
1528       {
1529         s = PSYMTAB_TO_SYMTAB (ps);
1530         bv = BLOCKVECTOR (s);
1531         block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1532         sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1533         if (!sym)
1534           {
1535             /* This shouldn't be necessary, but as a last resort
1536              * try looking in the statics even though the psymtab
1537              * claimed the symbol was global. It's possible that
1538              * the psymtab gets it wrong in some cases.
1539              */
1540             block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1541             sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1542             if (!sym)
1543               error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1544 %s may be an inlined function, or may be a template function\n\
1545 (if a template, try specifying an instantiation: %s<type>).",
1546                      name, ps->filename, name, name);
1547           }
1548         if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1549           return SYMBOL_TYPE (sym);
1550       }
1551   }
1552
1553   /* Now search the static file-level symbols.
1554      Not strictly correct, but more useful than an error.
1555      Do the symtab's first, then
1556      check the psymtab's. If a psymtab indicates the existence
1557      of the desired name as a file-level static, then do psymtab-to-symtab
1558      conversion on the fly and return the found symbol.
1559    */
1560
1561   ALL_SYMTABS (objfile, s)
1562   {
1563     bv = BLOCKVECTOR (s);
1564     block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1565     sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1566     if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1567       {
1568         return SYMBOL_TYPE (sym);
1569       }
1570   }
1571
1572   ALL_PSYMTABS (objfile, ps)
1573   {
1574     if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_DOMAIN))
1575       {
1576         s = PSYMTAB_TO_SYMTAB (ps);
1577         bv = BLOCKVECTOR (s);
1578         block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1579         sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1580         if (!sym)
1581           {
1582             /* This shouldn't be necessary, but as a last resort
1583              * try looking in the globals even though the psymtab
1584              * claimed the symbol was static. It's possible that
1585              * the psymtab gets it wrong in some cases.
1586              */
1587             block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1588             sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
1589             if (!sym)
1590               error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1591 %s may be an inlined function, or may be a template function\n\
1592 (if a template, try specifying an instantiation: %s<type>).",
1593                      name, ps->filename, name, name);
1594           }
1595         if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1596           return SYMBOL_TYPE (sym);
1597       }
1598   }
1599   return (struct type *) 0;
1600 }
1601
1602
1603 /* Find the psymtab containing main(). */
1604 /* FIXME:  What about languages without main() or specially linked
1605    executables that have no main() ? */
1606
1607 struct partial_symtab *
1608 find_main_psymtab (void)
1609 {
1610   struct partial_symtab *pst;
1611   struct objfile *objfile;
1612
1613   ALL_PSYMTABS (objfile, pst)
1614   {
1615     if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_DOMAIN))
1616       {
1617         return (pst);
1618       }
1619   }
1620   return (NULL);
1621 }
1622
1623 /* Search BLOCK for symbol NAME in DOMAIN.
1624
1625    Note that if NAME is the demangled form of a C++ symbol, we will fail
1626    to find a match during the binary search of the non-encoded names, but
1627    for now we don't worry about the slight inefficiency of looking for
1628    a match we'll never find, since it will go pretty quick.  Once the
1629    binary search terminates, we drop through and do a straight linear
1630    search on the symbols.  Each symbol which is marked as being a ObjC/C++
1631    symbol (language_cplus or language_objc set) has both the encoded and 
1632    non-encoded names tested for a match.
1633
1634    If LINKAGE_NAME is non-NULL, verify that any symbol we find has this
1635    particular mangled name.
1636 */
1637
1638 struct symbol *
1639 lookup_block_symbol (const struct block *block, const char *name,
1640                      const char *linkage_name,
1641                      const domain_enum domain)
1642 {
1643   struct dict_iterator iter;
1644   struct symbol *sym;
1645
1646   if (!BLOCK_FUNCTION (block))
1647     {
1648       for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1649            sym != NULL;
1650            sym = dict_iter_name_next (name, &iter))
1651         {
1652           if (SYMBOL_DOMAIN (sym) == domain
1653               && (linkage_name != NULL
1654                   ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
1655             return sym;
1656         }
1657       return NULL;
1658     }
1659   else
1660     {
1661       /* Note that parameter symbols do not always show up last in the
1662          list; this loop makes sure to take anything else other than
1663          parameter symbols first; it only uses parameter symbols as a
1664          last resort.  Note that this only takes up extra computation
1665          time on a match.  */
1666
1667       struct symbol *sym_found = NULL;
1668
1669       for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1670            sym != NULL;
1671            sym = dict_iter_name_next (name, &iter))
1672         {
1673           if (SYMBOL_DOMAIN (sym) == domain
1674               && (linkage_name != NULL
1675                   ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
1676             {
1677               sym_found = sym;
1678               if (SYMBOL_CLASS (sym) != LOC_ARG &&
1679                   SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
1680                   SYMBOL_CLASS (sym) != LOC_REF_ARG &&
1681                   SYMBOL_CLASS (sym) != LOC_REGPARM &&
1682                   SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
1683                   SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
1684                   SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
1685                 {
1686                   break;
1687                 }
1688             }
1689         }
1690       return (sym_found);       /* Will be NULL if not found. */
1691     }
1692 }
1693
1694 /* Find the symtab associated with PC and SECTION.  Look through the
1695    psymtabs and read in another symtab if necessary. */
1696
1697 struct symtab *
1698 find_pc_sect_symtab (CORE_ADDR pc, asection *section)
1699 {
1700   struct block *b;
1701   struct blockvector *bv;
1702   struct symtab *s = NULL;
1703   struct symtab *best_s = NULL;
1704   struct partial_symtab *ps;
1705   struct objfile *objfile;
1706   CORE_ADDR distance = 0;
1707   struct minimal_symbol *msymbol;
1708
1709   /* If we know that this is not a text address, return failure.  This is
1710      necessary because we loop based on the block's high and low code
1711      addresses, which do not include the data ranges, and because
1712      we call find_pc_sect_psymtab which has a similar restriction based
1713      on the partial_symtab's texthigh and textlow.  */
1714   msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1715   if (msymbol
1716       && (msymbol->type == mst_data
1717           || msymbol->type == mst_bss
1718           || msymbol->type == mst_abs
1719           || msymbol->type == mst_file_data
1720           || msymbol->type == mst_file_bss))
1721     return NULL;
1722
1723   /* Search all symtabs for the one whose file contains our address, and which
1724      is the smallest of all the ones containing the address.  This is designed
1725      to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1726      and symtab b is at 0x2000-0x3000.  So the GLOBAL_BLOCK for a is from
1727      0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1728
1729      This happens for native ecoff format, where code from included files
1730      gets its own symtab. The symtab for the included file should have
1731      been read in already via the dependency mechanism.
1732      It might be swifter to create several symtabs with the same name
1733      like xcoff does (I'm not sure).
1734
1735      It also happens for objfiles that have their functions reordered.
1736      For these, the symtab we are looking for is not necessarily read in.  */
1737
1738   ALL_SYMTABS (objfile, s)
1739   {
1740     bv = BLOCKVECTOR (s);
1741     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1742
1743     if (BLOCK_START (b) <= pc
1744         && BLOCK_END (b) > pc
1745         && (distance == 0
1746             || BLOCK_END (b) - BLOCK_START (b) < distance))
1747       {
1748         /* For an objfile that has its functions reordered,
1749            find_pc_psymtab will find the proper partial symbol table
1750            and we simply return its corresponding symtab.  */
1751         /* In order to better support objfiles that contain both
1752            stabs and coff debugging info, we continue on if a psymtab
1753            can't be found. */
1754         if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs)
1755           {
1756             ps = find_pc_sect_psymtab (pc, section);
1757             if (ps)
1758               return PSYMTAB_TO_SYMTAB (ps);
1759           }
1760         if (section != 0)
1761           {
1762             struct dict_iterator iter;
1763             struct symbol *sym = NULL;
1764
1765             ALL_BLOCK_SYMBOLS (b, iter, sym)
1766               {
1767                 fixup_symbol_section (sym, objfile);
1768                 if (section == SYMBOL_BFD_SECTION (sym))
1769                   break;
1770               }
1771             if (sym == NULL)
1772               continue;         /* no symbol in this symtab matches section */
1773           }
1774         distance = BLOCK_END (b) - BLOCK_START (b);
1775         best_s = s;
1776       }
1777   }
1778
1779   if (best_s != NULL)
1780     return (best_s);
1781
1782   s = NULL;
1783   ps = find_pc_sect_psymtab (pc, section);
1784   if (ps)
1785     {
1786       if (ps->readin)
1787         /* Might want to error() here (in case symtab is corrupt and
1788            will cause a core dump), but maybe we can successfully
1789            continue, so let's not.  */
1790         warning ("\
1791 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
1792                  paddr_nz (pc));
1793       s = PSYMTAB_TO_SYMTAB (ps);
1794     }
1795   return (s);
1796 }
1797
1798 /* Find the symtab associated with PC.  Look through the psymtabs and
1799    read in another symtab if necessary.  Backward compatibility, no section */
1800
1801 struct symtab *
1802 find_pc_symtab (CORE_ADDR pc)
1803 {
1804   return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
1805 }
1806 \f
1807
1808 /* Find the source file and line number for a given PC value and SECTION.
1809    Return a structure containing a symtab pointer, a line number,
1810    and a pc range for the entire source line.
1811    The value's .pc field is NOT the specified pc.
1812    NOTCURRENT nonzero means, if specified pc is on a line boundary,
1813    use the line that ends there.  Otherwise, in that case, the line
1814    that begins there is used.  */
1815
1816 /* The big complication here is that a line may start in one file, and end just
1817    before the start of another file.  This usually occurs when you #include
1818    code in the middle of a subroutine.  To properly find the end of a line's PC
1819    range, we must search all symtabs associated with this compilation unit, and
1820    find the one whose first PC is closer than that of the next line in this
1821    symtab.  */
1822
1823 /* If it's worth the effort, we could be using a binary search.  */
1824
1825 struct symtab_and_line
1826 find_pc_sect_line (CORE_ADDR pc, struct bfd_section *section, int notcurrent)
1827 {
1828   struct symtab *s;
1829   struct linetable *l;
1830   int len;
1831   int i;
1832   struct linetable_entry *item;
1833   struct symtab_and_line val;
1834   struct blockvector *bv;
1835   struct minimal_symbol *msymbol;
1836   struct minimal_symbol *mfunsym;
1837
1838   /* Info on best line seen so far, and where it starts, and its file.  */
1839
1840   struct linetable_entry *best = NULL;
1841   CORE_ADDR best_end = 0;
1842   struct symtab *best_symtab = 0;
1843
1844   /* Store here the first line number
1845      of a file which contains the line at the smallest pc after PC.
1846      If we don't find a line whose range contains PC,
1847      we will use a line one less than this,
1848      with a range from the start of that file to the first line's pc.  */
1849   struct linetable_entry *alt = NULL;
1850   struct symtab *alt_symtab = 0;
1851
1852   /* Info on best line seen in this file.  */
1853
1854   struct linetable_entry *prev;
1855
1856   /* If this pc is not from the current frame,
1857      it is the address of the end of a call instruction.
1858      Quite likely that is the start of the following statement.
1859      But what we want is the statement containing the instruction.
1860      Fudge the pc to make sure we get that.  */
1861
1862   init_sal (&val);              /* initialize to zeroes */
1863
1864   /* It's tempting to assume that, if we can't find debugging info for
1865      any function enclosing PC, that we shouldn't search for line
1866      number info, either.  However, GAS can emit line number info for
1867      assembly files --- very helpful when debugging hand-written
1868      assembly code.  In such a case, we'd have no debug info for the
1869      function, but we would have line info.  */
1870
1871   if (notcurrent)
1872     pc -= 1;
1873
1874   /* elz: added this because this function returned the wrong
1875      information if the pc belongs to a stub (import/export)
1876      to call a shlib function. This stub would be anywhere between
1877      two functions in the target, and the line info was erroneously 
1878      taken to be the one of the line before the pc. 
1879    */
1880   /* RT: Further explanation:
1881
1882    * We have stubs (trampolines) inserted between procedures.
1883    *
1884    * Example: "shr1" exists in a shared library, and a "shr1" stub also
1885    * exists in the main image.
1886    *
1887    * In the minimal symbol table, we have a bunch of symbols
1888    * sorted by start address. The stubs are marked as "trampoline",
1889    * the others appear as text. E.g.:
1890    *
1891    *  Minimal symbol table for main image 
1892    *     main:  code for main (text symbol)
1893    *     shr1: stub  (trampoline symbol)
1894    *     foo:   code for foo (text symbol)
1895    *     ...
1896    *  Minimal symbol table for "shr1" image:
1897    *     ...
1898    *     shr1: code for shr1 (text symbol)
1899    *     ...
1900    *
1901    * So the code below is trying to detect if we are in the stub
1902    * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
1903    * and if found,  do the symbolization from the real-code address
1904    * rather than the stub address.
1905    *
1906    * Assumptions being made about the minimal symbol table:
1907    *   1. lookup_minimal_symbol_by_pc() will return a trampoline only
1908    *      if we're really in the trampoline. If we're beyond it (say
1909    *      we're in "foo" in the above example), it'll have a closer 
1910    *      symbol (the "foo" text symbol for example) and will not
1911    *      return the trampoline.
1912    *   2. lookup_minimal_symbol_text() will find a real text symbol
1913    *      corresponding to the trampoline, and whose address will
1914    *      be different than the trampoline address. I put in a sanity
1915    *      check for the address being the same, to avoid an
1916    *      infinite recursion.
1917    */
1918   msymbol = lookup_minimal_symbol_by_pc (pc);
1919   if (msymbol != NULL)
1920     if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
1921       {
1922         mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
1923                                               NULL);
1924         if (mfunsym == NULL)
1925           /* I eliminated this warning since it is coming out
1926            * in the following situation:
1927            * gdb shmain // test program with shared libraries
1928            * (gdb) break shr1  // function in shared lib
1929            * Warning: In stub for ...
1930            * In the above situation, the shared lib is not loaded yet, 
1931            * so of course we can't find the real func/line info,
1932            * but the "break" still works, and the warning is annoying.
1933            * So I commented out the warning. RT */
1934           /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
1935         /* fall through */
1936         else if (SYMBOL_VALUE (mfunsym) == SYMBOL_VALUE (msymbol))
1937           /* Avoid infinite recursion */
1938           /* See above comment about why warning is commented out */
1939           /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
1940         /* fall through */
1941         else
1942           return find_pc_line (SYMBOL_VALUE (mfunsym), 0);
1943       }
1944
1945
1946   s = find_pc_sect_symtab (pc, section);
1947   if (!s)
1948     {
1949       /* if no symbol information, return previous pc */
1950       if (notcurrent)
1951         pc++;
1952       val.pc = pc;
1953       return val;
1954     }
1955
1956   bv = BLOCKVECTOR (s);
1957
1958   /* Look at all the symtabs that share this blockvector.
1959      They all have the same apriori range, that we found was right;
1960      but they have different line tables.  */
1961
1962   for (; s && BLOCKVECTOR (s) == bv; s = s->next)
1963     {
1964       /* Find the best line in this symtab.  */
1965       l = LINETABLE (s);
1966       if (!l)
1967         continue;
1968       len = l->nitems;
1969       if (len <= 0)
1970         {
1971           /* I think len can be zero if the symtab lacks line numbers
1972              (e.g. gcc -g1).  (Either that or the LINETABLE is NULL;
1973              I'm not sure which, and maybe it depends on the symbol
1974              reader).  */
1975           continue;
1976         }
1977
1978       prev = NULL;
1979       item = l->item;           /* Get first line info */
1980
1981       /* Is this file's first line closer than the first lines of other files?
1982          If so, record this file, and its first line, as best alternate.  */
1983       if (item->pc > pc && (!alt || item->pc < alt->pc))
1984         {
1985           alt = item;
1986           alt_symtab = s;
1987         }
1988
1989       for (i = 0; i < len; i++, item++)
1990         {
1991           /* Leave prev pointing to the linetable entry for the last line
1992              that started at or before PC.  */
1993           if (item->pc > pc)
1994             break;
1995
1996           prev = item;
1997         }
1998
1999       /* At this point, prev points at the line whose start addr is <= pc, and
2000          item points at the next line.  If we ran off the end of the linetable
2001          (pc >= start of the last line), then prev == item.  If pc < start of
2002          the first line, prev will not be set.  */
2003
2004       /* Is this file's best line closer than the best in the other files?
2005          If so, record this file, and its best line, as best so far.  Don't
2006          save prev if it represents the end of a function (i.e. line number
2007          0) instead of a real line.  */
2008
2009       if (prev && prev->line && (!best || prev->pc > best->pc))
2010         {
2011           best = prev;
2012           best_symtab = s;
2013
2014           /* Discard BEST_END if it's before the PC of the current BEST.  */
2015           if (best_end <= best->pc)
2016             best_end = 0;
2017         }
2018
2019       /* If another line (denoted by ITEM) is in the linetable and its
2020          PC is after BEST's PC, but before the current BEST_END, then
2021          use ITEM's PC as the new best_end.  */
2022       if (best && i < len && item->pc > best->pc
2023           && (best_end == 0 || best_end > item->pc))
2024         best_end = item->pc;
2025     }
2026
2027   if (!best_symtab)
2028     {
2029       if (!alt_symtab)
2030         {                       /* If we didn't find any line # info, just
2031                                    return zeros.  */
2032           val.pc = pc;
2033         }
2034       else
2035         {
2036           val.symtab = alt_symtab;
2037           val.line = alt->line - 1;
2038
2039           /* Don't return line 0, that means that we didn't find the line.  */
2040           if (val.line == 0)
2041             ++val.line;
2042
2043           val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2044           val.end = alt->pc;
2045         }
2046     }
2047   else if (best->line == 0)
2048     {
2049       /* If our best fit is in a range of PC's for which no line
2050          number info is available (line number is zero) then we didn't
2051          find any valid line information. */
2052       val.pc = pc;
2053     }
2054   else
2055     {
2056       val.symtab = best_symtab;
2057       val.line = best->line;
2058       val.pc = best->pc;
2059       if (best_end && (!alt || best_end < alt->pc))
2060         val.end = best_end;
2061       else if (alt)
2062         val.end = alt->pc;
2063       else
2064         val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2065     }
2066   val.section = section;
2067   return val;
2068 }
2069
2070 /* Backward compatibility (no section) */
2071
2072 struct symtab_and_line
2073 find_pc_line (CORE_ADDR pc, int notcurrent)
2074 {
2075   asection *section;
2076
2077   section = find_pc_overlay (pc);
2078   if (pc_in_unmapped_range (pc, section))
2079     pc = overlay_mapped_address (pc, section);
2080   return find_pc_sect_line (pc, section, notcurrent);
2081 }
2082 \f
2083 /* Find line number LINE in any symtab whose name is the same as
2084    SYMTAB.
2085
2086    If found, return the symtab that contains the linetable in which it was
2087    found, set *INDEX to the index in the linetable of the best entry
2088    found, and set *EXACT_MATCH nonzero if the value returned is an
2089    exact match.
2090
2091    If not found, return NULL.  */
2092
2093 struct symtab *
2094 find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match)
2095 {
2096   int exact;
2097
2098   /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2099      so far seen.  */
2100
2101   int best_index;
2102   struct linetable *best_linetable;
2103   struct symtab *best_symtab;
2104
2105   /* First try looking it up in the given symtab.  */
2106   best_linetable = LINETABLE (symtab);
2107   best_symtab = symtab;
2108   best_index = find_line_common (best_linetable, line, &exact);
2109   if (best_index < 0 || !exact)
2110     {
2111       /* Didn't find an exact match.  So we better keep looking for
2112          another symtab with the same name.  In the case of xcoff,
2113          multiple csects for one source file (produced by IBM's FORTRAN
2114          compiler) produce multiple symtabs (this is unavoidable
2115          assuming csects can be at arbitrary places in memory and that
2116          the GLOBAL_BLOCK of a symtab has a begin and end address).  */
2117
2118       /* BEST is the smallest linenumber > LINE so far seen,
2119          or 0 if none has been seen so far.
2120          BEST_INDEX and BEST_LINETABLE identify the item for it.  */
2121       int best;
2122
2123       struct objfile *objfile;
2124       struct symtab *s;
2125
2126       if (best_index >= 0)
2127         best = best_linetable->item[best_index].line;
2128       else
2129         best = 0;
2130
2131       ALL_SYMTABS (objfile, s)
2132       {
2133         struct linetable *l;
2134         int ind;
2135
2136         if (strcmp (symtab->filename, s->filename) != 0)
2137           continue;
2138         l = LINETABLE (s);
2139         ind = find_line_common (l, line, &exact);
2140         if (ind >= 0)
2141           {
2142             if (exact)
2143               {
2144                 best_index = ind;
2145                 best_linetable = l;
2146                 best_symtab = s;
2147                 goto done;
2148               }
2149             if (best == 0 || l->item[ind].line < best)
2150               {
2151                 best = l->item[ind].line;
2152                 best_index = ind;
2153                 best_linetable = l;
2154                 best_symtab = s;
2155               }
2156           }
2157       }
2158     }
2159 done:
2160   if (best_index < 0)
2161     return NULL;
2162
2163   if (index)
2164     *index = best_index;
2165   if (exact_match)
2166     *exact_match = exact;
2167
2168   return best_symtab;
2169 }
2170 \f
2171 /* Set the PC value for a given source file and line number and return true.
2172    Returns zero for invalid line number (and sets the PC to 0).
2173    The source file is specified with a struct symtab.  */
2174
2175 int
2176 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
2177 {
2178   struct linetable *l;
2179   int ind;
2180
2181   *pc = 0;
2182   if (symtab == 0)
2183     return 0;
2184
2185   symtab = find_line_symtab (symtab, line, &ind, NULL);
2186   if (symtab != NULL)
2187     {
2188       l = LINETABLE (symtab);
2189       *pc = l->item[ind].pc;
2190       return 1;
2191     }
2192   else
2193     return 0;
2194 }
2195
2196 /* Find the range of pc values in a line.
2197    Store the starting pc of the line into *STARTPTR
2198    and the ending pc (start of next line) into *ENDPTR.
2199    Returns 1 to indicate success.
2200    Returns 0 if could not find the specified line.  */
2201
2202 int
2203 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2204                     CORE_ADDR *endptr)
2205 {
2206   CORE_ADDR startaddr;
2207   struct symtab_and_line found_sal;
2208
2209   startaddr = sal.pc;
2210   if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
2211     return 0;
2212
2213   /* This whole function is based on address.  For example, if line 10 has
2214      two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2215      "info line *0x123" should say the line goes from 0x100 to 0x200
2216      and "info line *0x355" should say the line goes from 0x300 to 0x400.
2217      This also insures that we never give a range like "starts at 0x134
2218      and ends at 0x12c".  */
2219
2220   found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2221   if (found_sal.line != sal.line)
2222     {
2223       /* The specified line (sal) has zero bytes.  */
2224       *startptr = found_sal.pc;
2225       *endptr = found_sal.pc;
2226     }
2227   else
2228     {
2229       *startptr = found_sal.pc;
2230       *endptr = found_sal.end;
2231     }
2232   return 1;
2233 }
2234
2235 /* Given a line table and a line number, return the index into the line
2236    table for the pc of the nearest line whose number is >= the specified one.
2237    Return -1 if none is found.  The value is >= 0 if it is an index.
2238
2239    Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
2240
2241 static int
2242 find_line_common (struct linetable *l, int lineno,
2243                   int *exact_match)
2244 {
2245   int i;
2246   int len;
2247
2248   /* BEST is the smallest linenumber > LINENO so far seen,
2249      or 0 if none has been seen so far.
2250      BEST_INDEX identifies the item for it.  */
2251
2252   int best_index = -1;
2253   int best = 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
2281   *exact_match = 0;
2282   return best_index;
2283 }
2284
2285 int
2286 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
2287 {
2288   struct symtab_and_line sal;
2289   sal = find_pc_line (pc, 0);
2290   *startptr = sal.pc;
2291   *endptr = sal.end;
2292   return sal.symtab != 0;
2293 }
2294
2295 /* Given a function symbol SYM, find the symtab and line for the start
2296    of the function.
2297    If the argument FUNFIRSTLINE is nonzero, we want the first line
2298    of real code inside the function.  */
2299
2300 struct symtab_and_line
2301 find_function_start_sal (struct symbol *sym, int funfirstline)
2302 {
2303   CORE_ADDR pc;
2304   struct symtab_and_line sal;
2305
2306   pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2307   fixup_symbol_section (sym, NULL);
2308   if (funfirstline)
2309     {                           /* skip "first line" of function (which is actually its prologue) */
2310       asection *section = SYMBOL_BFD_SECTION (sym);
2311       /* If function is in an unmapped overlay, use its unmapped LMA
2312          address, so that SKIP_PROLOGUE has something unique to work on */
2313       if (section_is_overlay (section) &&
2314           !section_is_mapped (section))
2315         pc = overlay_unmapped_address (pc, section);
2316
2317       pc += FUNCTION_START_OFFSET;
2318       pc = SKIP_PROLOGUE (pc);
2319
2320       /* For overlays, map pc back into its mapped VMA range */
2321       pc = overlay_mapped_address (pc, section);
2322     }
2323   sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
2324
2325   /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2326      line is still part of the same function.  */
2327   if (sal.pc != pc
2328       && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end
2329       && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2330     {
2331       /* First pc of next line */
2332       pc = sal.end;
2333       /* Recalculate the line number (might not be N+1).  */
2334       sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
2335     }
2336   sal.pc = pc;
2337
2338   return sal;
2339 }
2340
2341 /* If P is of the form "operator[ \t]+..." where `...' is
2342    some legitimate operator text, return a pointer to the
2343    beginning of the substring of the operator text.
2344    Otherwise, return "".  */
2345 char *
2346 operator_chars (char *p, char **end)
2347 {
2348   *end = "";
2349   if (strncmp (p, "operator", 8))
2350     return *end;
2351   p += 8;
2352
2353   /* Don't get faked out by `operator' being part of a longer
2354      identifier.  */
2355   if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
2356     return *end;
2357
2358   /* Allow some whitespace between `operator' and the operator symbol.  */
2359   while (*p == ' ' || *p == '\t')
2360     p++;
2361
2362   /* Recognize 'operator TYPENAME'. */
2363
2364   if (isalpha (*p) || *p == '_' || *p == '$')
2365     {
2366       char *q = p + 1;
2367       while (isalnum (*q) || *q == '_' || *q == '$')
2368         q++;
2369       *end = q;
2370       return p;
2371     }
2372
2373   while (*p)
2374     switch (*p)
2375       {
2376       case '\\':                        /* regexp quoting */
2377         if (p[1] == '*')
2378           {
2379             if (p[2] == '=')    /* 'operator\*=' */
2380               *end = p + 3;
2381             else                        /* 'operator\*'  */
2382               *end = p + 2;
2383             return p;
2384           }
2385         else if (p[1] == '[')
2386           {
2387             if (p[2] == ']')
2388               error ("mismatched quoting on brackets, try 'operator\\[\\]'");
2389             else if (p[2] == '\\' && p[3] == ']')
2390               {
2391                 *end = p + 4;   /* 'operator\[\]' */
2392                 return p;
2393               }
2394             else
2395               error ("nothing is allowed between '[' and ']'");
2396           }
2397         else 
2398           {
2399             /* Gratuitous qoute: skip it and move on. */
2400             p++;
2401             continue;
2402           }
2403         break;
2404       case '!':
2405       case '=':
2406       case '*':
2407       case '/':
2408       case '%':
2409       case '^':
2410         if (p[1] == '=')
2411           *end = p + 2;
2412         else
2413           *end = p + 1;
2414         return p;
2415       case '<':
2416       case '>':
2417       case '+':
2418       case '-':
2419       case '&':
2420       case '|':
2421         if (p[0] == '-' && p[1] == '>')
2422           {
2423             /* Struct pointer member operator 'operator->'. */
2424             if (p[2] == '*')
2425               {
2426                 *end = p + 3;   /* 'operator->*' */
2427                 return p;
2428               }
2429             else if (p[2] == '\\')
2430               {
2431                 *end = p + 4;   /* Hopefully 'operator->\*' */
2432                 return p;
2433               }
2434             else
2435               {
2436                 *end = p + 2;   /* 'operator->' */
2437                 return p;
2438               }
2439           }
2440         if (p[1] == '=' || p[1] == p[0])
2441           *end = p + 2;
2442         else
2443           *end = p + 1;
2444         return p;
2445       case '~':
2446       case ',':
2447         *end = p + 1;
2448         return p;
2449       case '(':
2450         if (p[1] != ')')
2451           error ("`operator ()' must be specified without whitespace in `()'");
2452         *end = p + 2;
2453         return p;
2454       case '?':
2455         if (p[1] != ':')
2456           error ("`operator ?:' must be specified without whitespace in `?:'");
2457         *end = p + 2;
2458         return p;
2459       case '[':
2460         if (p[1] != ']')
2461           error ("`operator []' must be specified without whitespace in `[]'");
2462         *end = p + 2;
2463         return p;
2464       default:
2465         error ("`operator %s' not supported", p);
2466         break;
2467       }
2468
2469   *end = "";
2470   return *end;
2471 }
2472 \f
2473
2474 /* If FILE is not already in the table of files, return zero;
2475    otherwise return non-zero.  Optionally add FILE to the table if ADD
2476    is non-zero.  If *FIRST is non-zero, forget the old table
2477    contents.  */
2478 static int
2479 filename_seen (const char *file, int add, int *first)
2480 {
2481   /* Table of files seen so far.  */
2482   static const char **tab = NULL;
2483   /* Allocated size of tab in elements.
2484      Start with one 256-byte block (when using GNU malloc.c).
2485      24 is the malloc overhead when range checking is in effect.  */
2486   static int tab_alloc_size = (256 - 24) / sizeof (char *);
2487   /* Current size of tab in elements.  */
2488   static int tab_cur_size;
2489   const char **p;
2490
2491   if (*first)
2492     {
2493       if (tab == NULL)
2494         tab = (const char **) xmalloc (tab_alloc_size * sizeof (*tab));
2495       tab_cur_size = 0;
2496     }
2497
2498   /* Is FILE in tab?  */
2499   for (p = tab; p < tab + tab_cur_size; p++)
2500     if (strcmp (*p, file) == 0)
2501       return 1;
2502
2503   /* No; maybe add it to tab.  */
2504   if (add)
2505     {
2506       if (tab_cur_size == tab_alloc_size)
2507         {
2508           tab_alloc_size *= 2;
2509           tab = (const char **) xrealloc ((char *) tab,
2510                                           tab_alloc_size * sizeof (*tab));
2511         }
2512       tab[tab_cur_size++] = file;
2513     }
2514
2515   return 0;
2516 }
2517
2518 /* Slave routine for sources_info.  Force line breaks at ,'s.
2519    NAME is the name to print and *FIRST is nonzero if this is the first
2520    name printed.  Set *FIRST to zero.  */
2521 static void
2522 output_source_filename (char *name, int *first)
2523 {
2524   /* Since a single source file can result in several partial symbol
2525      tables, we need to avoid printing it more than once.  Note: if
2526      some of the psymtabs are read in and some are not, it gets
2527      printed both under "Source files for which symbols have been
2528      read" and "Source files for which symbols will be read in on
2529      demand".  I consider this a reasonable way to deal with the
2530      situation.  I'm not sure whether this can also happen for
2531      symtabs; it doesn't hurt to check.  */
2532
2533   /* Was NAME already seen?  */
2534   if (filename_seen (name, 1, first))
2535     {
2536       /* Yes; don't print it again.  */
2537       return;
2538     }
2539   /* No; print it and reset *FIRST.  */
2540   if (*first)
2541     {
2542       *first = 0;
2543     }
2544   else
2545     {
2546       printf_filtered (", ");
2547     }
2548
2549   wrap_here ("");
2550   fputs_filtered (name, gdb_stdout);
2551 }
2552
2553 static void
2554 sources_info (char *ignore, int from_tty)
2555 {
2556   struct symtab *s;
2557   struct partial_symtab *ps;
2558   struct objfile *objfile;
2559   int first;
2560
2561   if (!have_full_symbols () && !have_partial_symbols ())
2562     {
2563       error ("No symbol table is loaded.  Use the \"file\" command.");
2564     }
2565
2566   printf_filtered ("Source files for which symbols have been read in:\n\n");
2567
2568   first = 1;
2569   ALL_SYMTABS (objfile, s)
2570   {
2571     output_source_filename (s->filename, &first);
2572   }
2573   printf_filtered ("\n\n");
2574
2575   printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2576
2577   first = 1;
2578   ALL_PSYMTABS (objfile, ps)
2579   {
2580     if (!ps->readin)
2581       {
2582         output_source_filename (ps->filename, &first);
2583       }
2584   }
2585   printf_filtered ("\n");
2586 }
2587
2588 static int
2589 file_matches (char *file, char *files[], int nfiles)
2590 {
2591   int i;
2592
2593   if (file != NULL && nfiles != 0)
2594     {
2595       for (i = 0; i < nfiles; i++)
2596         {
2597           if (strcmp (files[i], lbasename (file)) == 0)
2598             return 1;
2599         }
2600     }
2601   else if (nfiles == 0)
2602     return 1;
2603   return 0;
2604 }
2605
2606 /* Free any memory associated with a search. */
2607 void
2608 free_search_symbols (struct symbol_search *symbols)
2609 {
2610   struct symbol_search *p;
2611   struct symbol_search *next;
2612
2613   for (p = symbols; p != NULL; p = next)
2614     {
2615       next = p->next;
2616       xfree (p);
2617     }
2618 }
2619
2620 static void
2621 do_free_search_symbols_cleanup (void *symbols)
2622 {
2623   free_search_symbols (symbols);
2624 }
2625
2626 struct cleanup *
2627 make_cleanup_free_search_symbols (struct symbol_search *symbols)
2628 {
2629   return make_cleanup (do_free_search_symbols_cleanup, symbols);
2630 }
2631
2632 /* Helper function for sort_search_symbols and qsort.  Can only
2633    sort symbols, not minimal symbols.  */
2634 static int
2635 compare_search_syms (const void *sa, const void *sb)
2636 {
2637   struct symbol_search **sym_a = (struct symbol_search **) sa;
2638   struct symbol_search **sym_b = (struct symbol_search **) sb;
2639
2640   return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
2641                  SYMBOL_PRINT_NAME ((*sym_b)->symbol));
2642 }
2643
2644 /* Sort the ``nfound'' symbols in the list after prevtail.  Leave
2645    prevtail where it is, but update its next pointer to point to
2646    the first of the sorted symbols.  */
2647 static struct symbol_search *
2648 sort_search_symbols (struct symbol_search *prevtail, int nfound)
2649 {
2650   struct symbol_search **symbols, *symp, *old_next;
2651   int i;
2652
2653   symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
2654                                                * nfound);
2655   symp = prevtail->next;
2656   for (i = 0; i < nfound; i++)
2657     {
2658       symbols[i] = symp;
2659       symp = symp->next;
2660     }
2661   /* Generally NULL.  */
2662   old_next = symp;
2663
2664   qsort (symbols, nfound, sizeof (struct symbol_search *),
2665          compare_search_syms);
2666
2667   symp = prevtail;
2668   for (i = 0; i < nfound; i++)
2669     {
2670       symp->next = symbols[i];
2671       symp = symp->next;
2672     }
2673   symp->next = old_next;
2674
2675   xfree (symbols);
2676   return symp;
2677 }
2678
2679 /* Search the symbol table for matches to the regular expression REGEXP,
2680    returning the results in *MATCHES.
2681
2682    Only symbols of KIND are searched:
2683    FUNCTIONS_DOMAIN - search all functions
2684    TYPES_DOMAIN     - search all type names
2685    METHODS_DOMAIN   - search all methods NOT IMPLEMENTED
2686    VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
2687    and constants (enums)
2688
2689    free_search_symbols should be called when *MATCHES is no longer needed.
2690
2691    The results are sorted locally; each symtab's global and static blocks are
2692    separately alphabetized.
2693  */
2694 void
2695 search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
2696                 struct symbol_search **matches)
2697 {
2698   struct symtab *s;
2699   struct partial_symtab *ps;
2700   struct blockvector *bv;
2701   struct blockvector *prev_bv = 0;
2702   struct block *b;
2703   int i = 0;
2704   struct dict_iterator iter;
2705   struct symbol *sym;
2706   struct partial_symbol **psym;
2707   struct objfile *objfile;
2708   struct minimal_symbol *msymbol;
2709   char *val;
2710   int found_misc = 0;
2711   static enum minimal_symbol_type types[]
2712   =
2713   {mst_data, mst_text, mst_abs, mst_unknown};
2714   static enum minimal_symbol_type types2[]
2715   =
2716   {mst_bss, mst_file_text, mst_abs, mst_unknown};
2717   static enum minimal_symbol_type types3[]
2718   =
2719   {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
2720   static enum minimal_symbol_type types4[]
2721   =
2722   {mst_file_bss, mst_text, mst_abs, mst_unknown};
2723   enum minimal_symbol_type ourtype;
2724   enum minimal_symbol_type ourtype2;
2725   enum minimal_symbol_type ourtype3;
2726   enum minimal_symbol_type ourtype4;
2727   struct symbol_search *sr;
2728   struct symbol_search *psr;
2729   struct symbol_search *tail;
2730   struct cleanup *old_chain = NULL;
2731
2732   if (kind < VARIABLES_DOMAIN)
2733     error ("must search on specific domain");
2734
2735   ourtype = types[(int) (kind - VARIABLES_DOMAIN)];
2736   ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)];
2737   ourtype3 = types3[(int) (kind - VARIABLES_DOMAIN)];
2738   ourtype4 = types4[(int) (kind - VARIABLES_DOMAIN)];
2739
2740   sr = *matches = NULL;
2741   tail = NULL;
2742
2743   if (regexp != NULL)
2744     {
2745       /* Make sure spacing is right for C++ operators.
2746          This is just a courtesy to make the matching less sensitive
2747          to how many spaces the user leaves between 'operator'
2748          and <TYPENAME> or <OPERATOR>. */
2749       char *opend;
2750       char *opname = operator_chars (regexp, &opend);
2751       if (*opname)
2752         {
2753           int fix = -1;         /* -1 means ok; otherwise number of spaces needed. */
2754           if (isalpha (*opname) || *opname == '_' || *opname == '$')
2755             {
2756               /* There should 1 space between 'operator' and 'TYPENAME'. */
2757               if (opname[-1] != ' ' || opname[-2] == ' ')
2758                 fix = 1;
2759             }
2760           else
2761             {
2762               /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2763               if (opname[-1] == ' ')
2764                 fix = 0;
2765             }
2766           /* If wrong number of spaces, fix it. */
2767           if (fix >= 0)
2768             {
2769               char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
2770               sprintf (tmp, "operator%.*s%s", fix, " ", opname);
2771               regexp = tmp;
2772             }
2773         }
2774
2775       if (0 != (val = re_comp (regexp)))
2776         error ("Invalid regexp (%s): %s", val, regexp);
2777     }
2778
2779   /* Search through the partial symtabs *first* for all symbols
2780      matching the regexp.  That way we don't have to reproduce all of
2781      the machinery below. */
2782
2783   ALL_PSYMTABS (objfile, ps)
2784   {
2785     struct partial_symbol **bound, **gbound, **sbound;
2786     int keep_going = 1;
2787
2788     if (ps->readin)
2789       continue;
2790
2791     gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2792     sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2793     bound = gbound;
2794
2795     /* Go through all of the symbols stored in a partial
2796        symtab in one loop. */
2797     psym = objfile->global_psymbols.list + ps->globals_offset;
2798     while (keep_going)
2799       {
2800         if (psym >= bound)
2801           {
2802             if (bound == gbound && ps->n_static_syms != 0)
2803               {
2804                 psym = objfile->static_psymbols.list + ps->statics_offset;
2805                 bound = sbound;
2806               }
2807             else
2808               keep_going = 0;
2809             continue;
2810           }
2811         else
2812           {
2813             QUIT;
2814
2815             /* If it would match (logic taken from loop below)
2816                load the file and go on to the next one */
2817             if (file_matches (ps->filename, files, nfiles)
2818                 && ((regexp == NULL
2819                      || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0)
2820                     && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
2821                          && SYMBOL_CLASS (*psym) != LOC_BLOCK)
2822                         || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK)
2823                         || (kind == TYPES_DOMAIN && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
2824                         || (kind == METHODS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK))))
2825               {
2826                 PSYMTAB_TO_SYMTAB (ps);
2827                 keep_going = 0;
2828               }
2829           }
2830         psym++;
2831       }
2832   }
2833
2834   /* Here, we search through the minimal symbol tables for functions
2835      and variables that match, and force their symbols to be read.
2836      This is in particular necessary for demangled variable names,
2837      which are no longer put into the partial symbol tables.
2838      The symbol will then be found during the scan of symtabs below.
2839
2840      For functions, find_pc_symtab should succeed if we have debug info
2841      for the function, for variables we have to call lookup_symbol
2842      to determine if the variable has debug info.
2843      If the lookup fails, set found_misc so that we will rescan to print
2844      any matching symbols without debug info.
2845    */
2846
2847   if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
2848     {
2849       ALL_MSYMBOLS (objfile, msymbol)
2850       {
2851         if (MSYMBOL_TYPE (msymbol) == ourtype ||
2852             MSYMBOL_TYPE (msymbol) == ourtype2 ||
2853             MSYMBOL_TYPE (msymbol) == ourtype3 ||
2854             MSYMBOL_TYPE (msymbol) == ourtype4)
2855           {
2856             if (regexp == NULL
2857                 || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
2858               {
2859                 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
2860                   {
2861                     /* FIXME: carlton/2003-02-04: Given that the
2862                        semantics of lookup_symbol keeps on changing
2863                        slightly, it would be a nice idea if we had a
2864                        function lookup_symbol_minsym that found the
2865                        symbol associated to a given minimal symbol (if
2866                        any).  */
2867                     if (kind == FUNCTIONS_DOMAIN
2868                         || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
2869                                           (struct block *) NULL,
2870                                           VAR_DOMAIN,
2871                                         0, (struct symtab **) NULL) == NULL)
2872                       found_misc = 1;
2873                   }
2874               }
2875           }
2876       }
2877     }
2878
2879   ALL_SYMTABS (objfile, s)
2880   {
2881     bv = BLOCKVECTOR (s);
2882     /* Often many files share a blockvector.
2883        Scan each blockvector only once so that
2884        we don't get every symbol many times.
2885        It happens that the first symtab in the list
2886        for any given blockvector is the main file.  */
2887     if (bv != prev_bv)
2888       for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
2889         {
2890           struct symbol_search *prevtail = tail;
2891           int nfound = 0;
2892           b = BLOCKVECTOR_BLOCK (bv, i);
2893           ALL_BLOCK_SYMBOLS (b, iter, sym)
2894             {
2895               QUIT;
2896               if (file_matches (s->filename, files, nfiles)
2897                   && ((regexp == NULL
2898                        || re_exec (SYMBOL_NATURAL_NAME (sym)) != 0)
2899                       && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF
2900                            && SYMBOL_CLASS (sym) != LOC_BLOCK
2901                            && SYMBOL_CLASS (sym) != LOC_CONST)
2902                           || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK)
2903                           || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2904                           || (kind == METHODS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK))))
2905                 {
2906                   /* match */
2907                   psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
2908                   psr->block = i;
2909                   psr->symtab = s;
2910                   psr->symbol = sym;
2911                   psr->msymbol = NULL;
2912                   psr->next = NULL;
2913                   if (tail == NULL)
2914                     sr = psr;
2915                   else
2916                     tail->next = psr;
2917                   tail = psr;
2918                   nfound ++;
2919                 }
2920             }
2921           if (nfound > 0)
2922             {
2923               if (prevtail == NULL)
2924                 {
2925                   struct symbol_search dummy;
2926
2927                   dummy.next = sr;
2928                   tail = sort_search_symbols (&dummy, nfound);
2929                   sr = dummy.next;
2930
2931                   old_chain = make_cleanup_free_search_symbols (sr);
2932                 }
2933               else
2934                 tail = sort_search_symbols (prevtail, nfound);
2935             }
2936         }
2937     prev_bv = bv;
2938   }
2939
2940   /* If there are no eyes, avoid all contact.  I mean, if there are
2941      no debug symbols, then print directly from the msymbol_vector.  */
2942
2943   if (found_misc || kind != FUNCTIONS_DOMAIN)
2944     {
2945       ALL_MSYMBOLS (objfile, msymbol)
2946       {
2947         if (MSYMBOL_TYPE (msymbol) == ourtype ||
2948             MSYMBOL_TYPE (msymbol) == ourtype2 ||
2949             MSYMBOL_TYPE (msymbol) == ourtype3 ||
2950             MSYMBOL_TYPE (msymbol) == ourtype4)
2951           {
2952             if (regexp == NULL
2953                 || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
2954               {
2955                 /* Functions:  Look up by address. */
2956                 if (kind != FUNCTIONS_DOMAIN ||
2957                     (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
2958                   {
2959                     /* Variables/Absolutes:  Look up by name */
2960                     if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
2961                                        (struct block *) NULL, VAR_DOMAIN,
2962                                        0, (struct symtab **) NULL) == NULL)
2963                       {
2964                         /* match */
2965                         psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
2966                         psr->block = i;
2967                         psr->msymbol = msymbol;
2968                         psr->symtab = NULL;
2969                         psr->symbol = NULL;
2970                         psr->next = NULL;
2971                         if (tail == NULL)
2972                           {
2973                             sr = psr;
2974                             old_chain = make_cleanup_free_search_symbols (sr);
2975                           }
2976                         else
2977                           tail->next = psr;
2978                         tail = psr;
2979                       }
2980                   }
2981               }
2982           }
2983       }
2984     }
2985
2986   *matches = sr;
2987   if (sr != NULL)
2988     discard_cleanups (old_chain);
2989 }
2990
2991 /* Helper function for symtab_symbol_info, this function uses
2992    the data returned from search_symbols() to print information
2993    regarding the match to gdb_stdout.
2994  */
2995 static void
2996 print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym,
2997                    int block, char *last)
2998 {
2999   if (last == NULL || strcmp (last, s->filename) != 0)
3000     {
3001       fputs_filtered ("\nFile ", gdb_stdout);
3002       fputs_filtered (s->filename, gdb_stdout);
3003       fputs_filtered (":\n", gdb_stdout);
3004     }
3005
3006   if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
3007     printf_filtered ("static ");
3008
3009   /* Typedef that is not a C++ class */
3010   if (kind == TYPES_DOMAIN
3011       && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
3012     typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
3013   /* variable, func, or typedef-that-is-c++-class */
3014   else if (kind < TYPES_DOMAIN ||
3015            (kind == TYPES_DOMAIN &&
3016             SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
3017     {
3018       type_print (SYMBOL_TYPE (sym),
3019                   (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3020                    ? "" : SYMBOL_PRINT_NAME (sym)),
3021                   gdb_stdout, 0);
3022
3023       printf_filtered (";\n");
3024     }
3025 }
3026
3027 /* This help function for symtab_symbol_info() prints information
3028    for non-debugging symbols to gdb_stdout.
3029  */
3030 static void
3031 print_msymbol_info (struct minimal_symbol *msymbol)
3032 {
3033   char *tmp;
3034
3035   if (TARGET_ADDR_BIT <= 32)
3036     tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3037                                    & (CORE_ADDR) 0xffffffff,
3038                                    "08l");
3039   else
3040     tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3041                                    "016l");
3042   printf_filtered ("%s  %s\n",
3043                    tmp, SYMBOL_PRINT_NAME (msymbol));
3044 }
3045
3046 /* This is the guts of the commands "info functions", "info types", and
3047    "info variables". It calls search_symbols to find all matches and then
3048    print_[m]symbol_info to print out some useful information about the
3049    matches.
3050  */
3051 static void
3052 symtab_symbol_info (char *regexp, domain_enum kind, int from_tty)
3053 {
3054   static char *classnames[]
3055   =
3056   {"variable", "function", "type", "method"};
3057   struct symbol_search *symbols;
3058   struct symbol_search *p;
3059   struct cleanup *old_chain;
3060   char *last_filename = NULL;
3061   int first = 1;
3062
3063   /* must make sure that if we're interrupted, symbols gets freed */
3064   search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
3065   old_chain = make_cleanup_free_search_symbols (symbols);
3066
3067   printf_filtered (regexp
3068                    ? "All %ss matching regular expression \"%s\":\n"
3069                    : "All defined %ss:\n",
3070                    classnames[(int) (kind - VARIABLES_DOMAIN)], regexp);
3071
3072   for (p = symbols; p != NULL; p = p->next)
3073     {
3074       QUIT;
3075
3076       if (p->msymbol != NULL)
3077         {
3078           if (first)
3079             {
3080               printf_filtered ("\nNon-debugging symbols:\n");
3081               first = 0;
3082             }
3083           print_msymbol_info (p->msymbol);
3084         }
3085       else
3086         {
3087           print_symbol_info (kind,
3088                              p->symtab,
3089                              p->symbol,
3090                              p->block,
3091                              last_filename);
3092           last_filename = p->symtab->filename;
3093         }
3094     }
3095
3096   do_cleanups (old_chain);
3097 }
3098
3099 static void
3100 variables_info (char *regexp, int from_tty)
3101 {
3102   symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
3103 }
3104
3105 static void
3106 functions_info (char *regexp, int from_tty)
3107 {
3108   symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
3109 }
3110
3111
3112 static void
3113 types_info (char *regexp, int from_tty)
3114 {
3115   symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
3116 }
3117
3118 /* Breakpoint all functions matching regular expression. */
3119
3120 void
3121 rbreak_command_wrapper (char *regexp, int from_tty)
3122 {
3123   rbreak_command (regexp, from_tty);
3124 }
3125
3126 static void
3127 rbreak_command (char *regexp, int from_tty)
3128 {
3129   struct symbol_search *ss;
3130   struct symbol_search *p;
3131   struct cleanup *old_chain;
3132
3133   search_symbols (regexp, FUNCTIONS_DOMAIN, 0, (char **) NULL, &ss);
3134   old_chain = make_cleanup_free_search_symbols (ss);
3135
3136   for (p = ss; p != NULL; p = p->next)
3137     {
3138       if (p->msymbol == NULL)
3139         {
3140           char *string = alloca (strlen (p->symtab->filename)
3141                                  + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3142                                  + 4);
3143           strcpy (string, p->symtab->filename);
3144           strcat (string, ":'");
3145           strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
3146           strcat (string, "'");
3147           break_command (string, from_tty);
3148           print_symbol_info (FUNCTIONS_DOMAIN,
3149                              p->symtab,
3150                              p->symbol,
3151                              p->block,
3152                              p->symtab->filename);
3153         }
3154       else
3155         {
3156           break_command (SYMBOL_LINKAGE_NAME (p->msymbol), from_tty);
3157           printf_filtered ("<function, no debug info> %s;\n",
3158                            SYMBOL_PRINT_NAME (p->msymbol));
3159         }
3160     }
3161
3162   do_cleanups (old_chain);
3163 }
3164 \f
3165
3166 /* Helper routine for make_symbol_completion_list.  */
3167
3168 static int return_val_size;
3169 static int return_val_index;
3170 static char **return_val;
3171
3172 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3173       completion_list_add_name \
3174         (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3175
3176 /*  Test to see if the symbol specified by SYMNAME (which is already
3177    demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3178    characters.  If so, add it to the current completion list. */
3179
3180 static void
3181 completion_list_add_name (char *symname, char *sym_text, int sym_text_len,
3182                           char *text, char *word)
3183 {
3184   int newsize;
3185   int i;
3186
3187   /* clip symbols that cannot match */
3188
3189   if (strncmp (symname, sym_text, sym_text_len) != 0)
3190     {
3191       return;
3192     }
3193
3194   /* We have a match for a completion, so add SYMNAME to the current list
3195      of matches. Note that the name is moved to freshly malloc'd space. */
3196
3197   {
3198     char *new;
3199     if (word == sym_text)
3200       {
3201         new = xmalloc (strlen (symname) + 5);
3202         strcpy (new, symname);
3203       }
3204     else if (word > sym_text)
3205       {
3206         /* Return some portion of symname.  */
3207         new = xmalloc (strlen (symname) + 5);
3208         strcpy (new, symname + (word - sym_text));
3209       }
3210     else
3211       {
3212         /* Return some of SYM_TEXT plus symname.  */
3213         new = xmalloc (strlen (symname) + (sym_text - word) + 5);
3214         strncpy (new, word, sym_text - word);
3215         new[sym_text - word] = '\0';
3216         strcat (new, symname);
3217       }
3218
3219     if (return_val_index + 3 > return_val_size)
3220       {
3221         newsize = (return_val_size *= 2) * sizeof (char *);
3222         return_val = (char **) xrealloc ((char *) return_val, newsize);
3223       }
3224     return_val[return_val_index++] = new;
3225     return_val[return_val_index] = NULL;
3226   }
3227 }
3228
3229 /* ObjC: In case we are completing on a selector, look as the msymbol
3230    again and feed all the selectors into the mill.  */
3231
3232 static void
3233 completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
3234                              int sym_text_len, char *text, char *word)
3235 {
3236   static char *tmp = NULL;
3237   static unsigned int tmplen = 0;
3238     
3239   char *method, *category, *selector;
3240   char *tmp2 = NULL;
3241     
3242   method = SYMBOL_NATURAL_NAME (msymbol);
3243
3244   /* Is it a method?  */
3245   if ((method[0] != '-') && (method[0] != '+'))
3246     return;
3247
3248   if (sym_text[0] == '[')
3249     /* Complete on shortened method method.  */
3250     completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
3251     
3252   while ((strlen (method) + 1) >= tmplen)
3253     {
3254       if (tmplen == 0)
3255         tmplen = 1024;
3256       else
3257         tmplen *= 2;
3258       tmp = xrealloc (tmp, tmplen);
3259     }
3260   selector = strchr (method, ' ');
3261   if (selector != NULL)
3262     selector++;
3263     
3264   category = strchr (method, '(');
3265     
3266   if ((category != NULL) && (selector != NULL))
3267     {
3268       memcpy (tmp, method, (category - method));
3269       tmp[category - method] = ' ';
3270       memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
3271       completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
3272       if (sym_text[0] == '[')
3273         completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
3274     }
3275     
3276   if (selector != NULL)
3277     {
3278       /* Complete on selector only.  */
3279       strcpy (tmp, selector);
3280       tmp2 = strchr (tmp, ']');
3281       if (tmp2 != NULL)
3282         *tmp2 = '\0';
3283         
3284       completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
3285     }
3286 }
3287
3288 /* Break the non-quoted text based on the characters which are in
3289    symbols. FIXME: This should probably be language-specific. */
3290
3291 static char *
3292 language_search_unquoted_string (char *text, char *p)
3293 {
3294   for (; p > text; --p)
3295     {
3296       if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3297         continue;
3298       else
3299         {
3300           if ((current_language->la_language == language_objc))
3301             {
3302               if (p[-1] == ':')     /* might be part of a method name */
3303                 continue;
3304               else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
3305                 p -= 2;             /* beginning of a method name */
3306               else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
3307                 {                   /* might be part of a method name */
3308                   char *t = p;
3309
3310                   /* Seeing a ' ' or a '(' is not conclusive evidence
3311                      that we are in the middle of a method name.  However,
3312                      finding "-[" or "+[" should be pretty un-ambiguous.
3313                      Unfortunately we have to find it now to decide.  */
3314
3315                   while (t > text)
3316                     if (isalnum (t[-1]) || t[-1] == '_' ||
3317                         t[-1] == ' '    || t[-1] == ':' ||
3318                         t[-1] == '('    || t[-1] == ')')
3319                       --t;
3320                     else
3321                       break;
3322
3323                   if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
3324                     p = t - 2;      /* method name detected */
3325                   /* else we leave with p unchanged */
3326                 }
3327             }
3328           break;
3329         }
3330     }
3331   return p;
3332 }
3333
3334
3335 /* Return a NULL terminated array of all symbols (regardless of class)
3336    which begin by matching TEXT.  If the answer is no symbols, then
3337    the return value is an array which contains only a NULL pointer.
3338
3339    Problem: All of the symbols have to be copied because readline frees them.
3340    I'm not going to worry about this; hopefully there won't be that many.  */
3341
3342 char **
3343 make_symbol_completion_list (char *text, char *word)
3344 {
3345   struct symbol *sym;
3346   struct symtab *s;
3347   struct partial_symtab *ps;
3348   struct minimal_symbol *msymbol;
3349   struct objfile *objfile;
3350   struct block *b, *surrounding_static_block = 0;
3351   struct dict_iterator iter;
3352   int j;
3353   struct partial_symbol **psym;
3354   /* The symbol we are completing on.  Points in same buffer as text.  */
3355   char *sym_text;
3356   /* Length of sym_text.  */
3357   int sym_text_len;
3358
3359   /* Now look for the symbol we are supposed to complete on.
3360      FIXME: This should be language-specific.  */
3361   {
3362     char *p;
3363     char quote_found;
3364     char *quote_pos = NULL;
3365
3366     /* First see if this is a quoted string.  */
3367     quote_found = '\0';
3368     for (p = text; *p != '\0'; ++p)
3369       {
3370         if (quote_found != '\0')
3371           {
3372             if (*p == quote_found)
3373               /* Found close quote.  */
3374               quote_found = '\0';
3375             else if (*p == '\\' && p[1] == quote_found)
3376               /* A backslash followed by the quote character
3377                  doesn't end the string.  */
3378               ++p;
3379           }
3380         else if (*p == '\'' || *p == '"')
3381           {
3382             quote_found = *p;
3383             quote_pos = p;
3384           }
3385       }
3386     if (quote_found == '\'')
3387       /* A string within single quotes can be a symbol, so complete on it.  */
3388       sym_text = quote_pos + 1;
3389     else if (quote_found == '"')
3390       /* A double-quoted string is never a symbol, nor does it make sense
3391          to complete it any other way.  */
3392       {
3393         return_val = (char **) xmalloc (sizeof (char *));
3394         return_val[0] = NULL;
3395         return return_val;
3396       }
3397     else
3398       {
3399         /* It is not a quoted string.  Break it based on the characters
3400            which are in symbols.  */
3401         while (p > text)
3402           {
3403             if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3404               --p;
3405             else
3406               break;
3407           }
3408         sym_text = p;
3409       }
3410   }
3411
3412   sym_text_len = strlen (sym_text);
3413
3414   return_val_size = 100;
3415   return_val_index = 0;
3416   return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3417   return_val[0] = NULL;
3418
3419   /* Look through the partial symtabs for all symbols which begin
3420      by matching SYM_TEXT.  Add each one that you find to the list.  */
3421
3422   ALL_PSYMTABS (objfile, ps)
3423   {
3424     /* If the psymtab's been read in we'll get it when we search
3425        through the blockvector.  */
3426     if (ps->readin)
3427       continue;
3428
3429     for (psym = objfile->global_psymbols.list + ps->globals_offset;
3430          psym < (objfile->global_psymbols.list + ps->globals_offset
3431                  + ps->n_global_syms);
3432          psym++)
3433       {
3434         /* If interrupted, then quit. */
3435         QUIT;
3436         COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
3437       }
3438
3439     for (psym = objfile->static_psymbols.list + ps->statics_offset;
3440          psym < (objfile->static_psymbols.list + ps->statics_offset
3441                  + ps->n_static_syms);
3442          psym++)
3443       {
3444         QUIT;
3445         COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
3446       }
3447   }
3448
3449   /* At this point scan through the misc symbol vectors and add each
3450      symbol you find to the list.  Eventually we want to ignore
3451      anything that isn't a text symbol (everything else will be
3452      handled by the psymtab code above).  */
3453
3454   ALL_MSYMBOLS (objfile, msymbol)
3455   {
3456     QUIT;
3457     COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
3458     
3459     completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text, word);
3460   }
3461
3462   /* Search upwards from currently selected frame (so that we can
3463      complete on local vars.  */
3464
3465   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
3466     {
3467       if (!BLOCK_SUPERBLOCK (b))
3468         {
3469           surrounding_static_block = b;         /* For elmin of dups */
3470         }
3471
3472       /* Also catch fields of types defined in this places which match our
3473          text string.  Only complete on types visible from current context. */
3474
3475       ALL_BLOCK_SYMBOLS (b, iter, sym)
3476         {
3477           QUIT;
3478           COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3479           if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3480             {
3481               struct type *t = SYMBOL_TYPE (sym);
3482               enum type_code c = TYPE_CODE (t);
3483
3484               if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
3485                 {
3486                   for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
3487                     {
3488                       if (TYPE_FIELD_NAME (t, j))
3489                         {
3490                           completion_list_add_name (TYPE_FIELD_NAME (t, j),
3491                                         sym_text, sym_text_len, text, word);
3492                         }
3493                     }
3494                 }
3495             }
3496         }
3497     }
3498
3499   /* Go through the symtabs and check the externs and statics for
3500      symbols which match.  */
3501
3502   ALL_SYMTABS (objfile, s)
3503   {
3504     QUIT;
3505     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
3506     ALL_BLOCK_SYMBOLS (b, iter, sym)
3507       {
3508         COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3509       }
3510   }
3511
3512   ALL_SYMTABS (objfile, s)
3513   {
3514     QUIT;
3515     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
3516     /* Don't do this block twice.  */
3517     if (b == surrounding_static_block)
3518       continue;
3519     ALL_BLOCK_SYMBOLS (b, iter, sym)
3520       {
3521         COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3522       }
3523   }
3524
3525   return (return_val);
3526 }
3527
3528 /* Like make_symbol_completion_list, but returns a list of symbols
3529    defined in a source file FILE.  */
3530
3531 char **
3532 make_file_symbol_completion_list (char *text, char *word, char *srcfile)
3533 {
3534   struct symbol *sym;
3535   struct symtab *s;
3536   struct block *b;
3537   struct dict_iterator iter;
3538   /* The symbol we are completing on.  Points in same buffer as text.  */
3539   char *sym_text;
3540   /* Length of sym_text.  */
3541   int sym_text_len;
3542
3543   /* Now look for the symbol we are supposed to complete on.
3544      FIXME: This should be language-specific.  */
3545   {
3546     char *p;
3547     char quote_found;
3548     char *quote_pos = NULL;
3549
3550     /* First see if this is a quoted string.  */
3551     quote_found = '\0';
3552     for (p = text; *p != '\0'; ++p)
3553       {
3554         if (quote_found != '\0')
3555           {
3556             if (*p == quote_found)
3557               /* Found close quote.  */
3558               quote_found = '\0';
3559             else if (*p == '\\' && p[1] == quote_found)
3560               /* A backslash followed by the quote character
3561                  doesn't end the string.  */
3562               ++p;
3563           }
3564         else if (*p == '\'' || *p == '"')
3565           {
3566             quote_found = *p;
3567             quote_pos = p;
3568           }
3569       }
3570     if (quote_found == '\'')
3571       /* A string within single quotes can be a symbol, so complete on it.  */
3572       sym_text = quote_pos + 1;
3573     else if (quote_found == '"')
3574       /* A double-quoted string is never a symbol, nor does it make sense
3575          to complete it any other way.  */
3576       {
3577         return_val = (char **) xmalloc (sizeof (char *));
3578         return_val[0] = NULL;
3579         return return_val;
3580       }
3581     else
3582       {
3583         /* Not a quoted string.  */
3584         sym_text = language_search_unquoted_string (text, p);
3585       }
3586   }
3587
3588   sym_text_len = strlen (sym_text);
3589
3590   return_val_size = 10;
3591   return_val_index = 0;
3592   return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3593   return_val[0] = NULL;
3594
3595   /* Find the symtab for SRCFILE (this loads it if it was not yet read
3596      in).  */
3597   s = lookup_symtab (srcfile);
3598   if (s == NULL)
3599     {
3600       /* Maybe they typed the file with leading directories, while the
3601          symbol tables record only its basename.  */
3602       const char *tail = lbasename (srcfile);
3603
3604       if (tail > srcfile)
3605         s = lookup_symtab (tail);
3606     }
3607
3608   /* If we have no symtab for that file, return an empty list.  */
3609   if (s == NULL)
3610     return (return_val);
3611
3612   /* Go through this symtab and check the externs and statics for
3613      symbols which match.  */
3614
3615   b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
3616   ALL_BLOCK_SYMBOLS (b, iter, sym)
3617     {
3618       COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3619     }
3620
3621   b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
3622   ALL_BLOCK_SYMBOLS (b, iter, sym)
3623     {
3624       COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3625     }
3626
3627   return (return_val);
3628 }
3629
3630 /* A helper function for make_source_files_completion_list.  It adds
3631    another file name to a list of possible completions, growing the
3632    list as necessary.  */
3633
3634 static void
3635 add_filename_to_list (const char *fname, char *text, char *word,
3636                       char ***list, int *list_used, int *list_alloced)
3637 {
3638   char *new;
3639   size_t fnlen = strlen (fname);
3640
3641   if (*list_used + 1 >= *list_alloced)
3642     {
3643       *list_alloced *= 2;
3644       *list = (char **) xrealloc ((char *) *list,
3645                                   *list_alloced * sizeof (char *));
3646     }
3647
3648   if (word == text)
3649     {
3650       /* Return exactly fname.  */
3651       new = xmalloc (fnlen + 5);
3652       strcpy (new, fname);
3653     }
3654   else if (word > text)
3655     {
3656       /* Return some portion of fname.  */
3657       new = xmalloc (fnlen + 5);
3658       strcpy (new, fname + (word - text));
3659     }
3660   else
3661     {
3662       /* Return some of TEXT plus fname.  */
3663       new = xmalloc (fnlen + (text - word) + 5);
3664       strncpy (new, word, text - word);
3665       new[text - word] = '\0';
3666       strcat (new, fname);
3667     }
3668   (*list)[*list_used] = new;
3669   (*list)[++*list_used] = NULL;
3670 }
3671
3672 static int
3673 not_interesting_fname (const char *fname)
3674 {
3675   static const char *illegal_aliens[] = {
3676     "_globals_",        /* inserted by coff_symtab_read */
3677     NULL
3678   };
3679   int i;
3680
3681   for (i = 0; illegal_aliens[i]; i++)
3682     {
3683       if (strcmp (fname, illegal_aliens[i]) == 0)
3684         return 1;
3685     }
3686   return 0;
3687 }
3688
3689 /* Return a NULL terminated array of all source files whose names
3690    begin with matching TEXT.  The file names are looked up in the
3691    symbol tables of this program.  If the answer is no matchess, then
3692    the return value is an array which contains only a NULL pointer.  */
3693
3694 char **
3695 make_source_files_completion_list (char *text, char *word)
3696 {
3697   struct symtab *s;
3698   struct partial_symtab *ps;
3699   struct objfile *objfile;
3700   int first = 1;
3701   int list_alloced = 1;
3702   int list_used = 0;
3703   size_t text_len = strlen (text);
3704   char **list = (char **) xmalloc (list_alloced * sizeof (char *));
3705   const char *base_name;
3706
3707   list[0] = NULL;
3708
3709   if (!have_full_symbols () && !have_partial_symbols ())
3710     return list;
3711
3712   ALL_SYMTABS (objfile, s)
3713     {
3714       if (not_interesting_fname (s->filename))
3715         continue;
3716       if (!filename_seen (s->filename, 1, &first)
3717 #if HAVE_DOS_BASED_FILE_SYSTEM
3718           && strncasecmp (s->filename, text, text_len) == 0
3719 #else
3720           && strncmp (s->filename, text, text_len) == 0
3721 #endif
3722           )
3723         {
3724           /* This file matches for a completion; add it to the current
3725              list of matches.  */
3726           add_filename_to_list (s->filename, text, word,
3727                                 &list, &list_used, &list_alloced);
3728         }
3729       else
3730         {
3731           /* NOTE: We allow the user to type a base name when the
3732              debug info records leading directories, but not the other
3733              way around.  This is what subroutines of breakpoint
3734              command do when they parse file names.  */
3735           base_name = lbasename (s->filename);
3736           if (base_name != s->filename
3737               && !filename_seen (base_name, 1, &first)
3738 #if HAVE_DOS_BASED_FILE_SYSTEM
3739               && strncasecmp (base_name, text, text_len) == 0
3740 #else
3741               && strncmp (base_name, text, text_len) == 0
3742 #endif
3743               )
3744             add_filename_to_list (base_name, text, word,
3745                                   &list, &list_used, &list_alloced);
3746         }
3747     }
3748
3749   ALL_PSYMTABS (objfile, ps)
3750     {
3751       if (not_interesting_fname (ps->filename))
3752         continue;
3753       if (!ps->readin)
3754         {
3755           if (!filename_seen (ps->filename, 1, &first)
3756 #if HAVE_DOS_BASED_FILE_SYSTEM
3757               && strncasecmp (ps->filename, text, text_len) == 0
3758 #else
3759               && strncmp (ps->filename, text, text_len) == 0
3760 #endif
3761               )
3762             {
3763               /* This file matches for a completion; add it to the
3764                  current list of matches.  */
3765               add_filename_to_list (ps->filename, text, word,
3766                                     &list, &list_used, &list_alloced);
3767
3768             }
3769           else
3770             {
3771               base_name = lbasename (ps->filename);
3772               if (base_name != ps->filename
3773                   && !filename_seen (base_name, 1, &first)
3774 #if HAVE_DOS_BASED_FILE_SYSTEM
3775                   && strncasecmp (base_name, text, text_len) == 0
3776 #else
3777                   && strncmp (base_name, text, text_len) == 0
3778 #endif
3779                   )
3780                 add_filename_to_list (base_name, text, word,
3781                                       &list, &list_used, &list_alloced);
3782             }
3783         }
3784     }
3785
3786   return list;
3787 }
3788
3789 /* Determine if PC is in the prologue of a function.  The prologue is the area
3790    between the first instruction of a function, and the first executable line.
3791    Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3792
3793    If non-zero, func_start is where we think the prologue starts, possibly
3794    by previous examination of symbol table information.
3795  */
3796
3797 int
3798 in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
3799 {
3800   struct symtab_and_line sal;
3801   CORE_ADDR func_addr, func_end;
3802
3803   /* We have several sources of information we can consult to figure
3804      this out.
3805      - Compilers usually emit line number info that marks the prologue
3806        as its own "source line".  So the ending address of that "line"
3807        is the end of the prologue.  If available, this is the most
3808        reliable method.
3809      - The minimal symbols and partial symbols, which can usually tell
3810        us the starting and ending addresses of a function.
3811      - If we know the function's start address, we can call the
3812        architecture-defined SKIP_PROLOGUE function to analyze the
3813        instruction stream and guess where the prologue ends.
3814      - Our `func_start' argument; if non-zero, this is the caller's
3815        best guess as to the function's entry point.  At the time of
3816        this writing, handle_inferior_event doesn't get this right, so
3817        it should be our last resort.  */
3818
3819   /* Consult the partial symbol table, to find which function
3820      the PC is in.  */
3821   if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
3822     {
3823       CORE_ADDR prologue_end;
3824
3825       /* We don't even have minsym information, so fall back to using
3826          func_start, if given.  */
3827       if (! func_start)
3828         return 1;               /* We *might* be in a prologue.  */
3829
3830       prologue_end = SKIP_PROLOGUE (func_start);
3831
3832       return func_start <= pc && pc < prologue_end;
3833     }
3834
3835   /* If we have line number information for the function, that's
3836      usually pretty reliable.  */
3837   sal = find_pc_line (func_addr, 0);
3838
3839   /* Now sal describes the source line at the function's entry point,
3840      which (by convention) is the prologue.  The end of that "line",
3841      sal.end, is the end of the prologue.
3842
3843      Note that, for functions whose source code is all on a single
3844      line, the line number information doesn't always end up this way.
3845      So we must verify that our purported end-of-prologue address is
3846      *within* the function, not at its start or end.  */
3847   if (sal.line == 0
3848       || sal.end <= func_addr
3849       || func_end <= sal.end)
3850     {
3851       /* We don't have any good line number info, so use the minsym
3852          information, together with the architecture-specific prologue
3853          scanning code.  */
3854       CORE_ADDR prologue_end = SKIP_PROLOGUE (func_addr);
3855
3856       return func_addr <= pc && pc < prologue_end;
3857     }
3858
3859   /* We have line number info, and it looks good.  */
3860   return func_addr <= pc && pc < sal.end;
3861 }
3862
3863 \f
3864 struct symtabs_and_lines
3865 decode_line_spec (char *string, int funfirstline)
3866 {
3867   struct symtabs_and_lines sals;
3868   struct symtab_and_line cursal;
3869   
3870   if (string == 0)
3871     error ("Empty line specification.");
3872     
3873   /* We use whatever is set as the current source line. We do not try
3874      and get a default  or it will recursively call us! */  
3875   cursal = get_current_source_symtab_and_line ();
3876   
3877   sals = decode_line_1 (&string, funfirstline,
3878                         cursal.symtab, cursal.line,
3879                         (char ***) NULL, NULL);
3880
3881   if (*string)
3882     error ("Junk at end of line specification: %s", string);
3883   return sals;
3884 }
3885
3886 /* Track MAIN */
3887 static char *name_of_main;
3888
3889 void
3890 set_main_name (const char *name)
3891 {
3892   if (name_of_main != NULL)
3893     {
3894       xfree (name_of_main);
3895       name_of_main = NULL;
3896     }
3897   if (name != NULL)
3898     {
3899       name_of_main = xstrdup (name);
3900     }
3901 }
3902
3903 char *
3904 main_name (void)
3905 {
3906   if (name_of_main != NULL)
3907     return name_of_main;
3908   else
3909     return "main";
3910 }
3911
3912
3913 void
3914 _initialize_symtab (void)
3915 {
3916   add_info ("variables", variables_info,
3917          "All global and static variable names, or those matching REGEXP.");
3918   if (dbx_commands)
3919     add_com ("whereis", class_info, variables_info,
3920          "All global and static variable names, or those matching REGEXP.");
3921
3922   add_info ("functions", functions_info,
3923             "All function names, or those matching REGEXP.");
3924
3925   
3926   /* FIXME:  This command has at least the following problems:
3927      1.  It prints builtin types (in a very strange and confusing fashion).
3928      2.  It doesn't print right, e.g. with
3929      typedef struct foo *FOO
3930      type_print prints "FOO" when we want to make it (in this situation)
3931      print "struct foo *".
3932      I also think "ptype" or "whatis" is more likely to be useful (but if
3933      there is much disagreement "info types" can be fixed).  */
3934   add_info ("types", types_info,
3935             "All type names, or those matching REGEXP.");
3936
3937   add_info ("sources", sources_info,
3938             "Source files in the program.");
3939
3940   add_com ("rbreak", class_breakpoint, rbreak_command,
3941            "Set a breakpoint for all functions matching REGEXP.");
3942
3943   if (xdb_commands)
3944     {
3945       add_com ("lf", class_info, sources_info, "Source files in the program");
3946       add_com ("lg", class_info, variables_info,
3947          "All global and static variable names, or those matching REGEXP.");
3948     }
3949
3950   /* Initialize the one built-in type that isn't language dependent... */
3951   builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
3952                                   "<unknown type>", (struct objfile *) NULL);
3953 }