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