1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
30 #include "gdb_regex.h"
31 #include "expression.h"
36 #include "filenames.h" /* for FILENAME_CMP */
37 #include "objc-lang.h"
43 #include "cli/cli-utils.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
56 #include "cp-support.h"
60 #include "macroscope.h"
62 #include "parser-defs.h"
63 #include "completer.h"
64 #include "progspace-and-thread.h"
65 #include "common/gdb_optional.h"
66 #include "filename-seen-cache.h"
67 #include "arch-utils.h"
70 /* Forward declarations for local functions. */
72 static void rbreak_command (const char *, int);
74 static int find_line_common (struct linetable *, int, int *, int);
76 static struct block_symbol
77 lookup_symbol_aux (const char *name,
78 const struct block *block,
79 const domain_enum domain,
80 enum language language,
81 struct field_of_this_result *);
84 struct block_symbol lookup_local_symbol (const char *name,
85 const struct block *block,
86 const domain_enum domain,
87 enum language language);
89 static struct block_symbol
90 lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
91 const char *name, const domain_enum domain);
94 const struct block_symbol null_block_symbol = { NULL, NULL };
96 /* Program space key for finding name and language of "main". */
98 static const struct program_space_data *main_progspace_key;
100 /* Type of the data stored on the program space. */
104 /* Name of "main". */
108 /* Language of "main". */
110 enum language language_of_main;
113 /* Program space key for finding its symbol cache. */
115 static const struct program_space_data *symbol_cache_key;
117 /* The default symbol cache size.
118 There is no extra cpu cost for large N (except when flushing the cache,
119 which is rare). The value here is just a first attempt. A better default
120 value may be higher or lower. A prime number can make up for a bad hash
121 computation, so that's why the number is what it is. */
122 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
124 /* The maximum symbol cache size.
125 There's no method to the decision of what value to use here, other than
126 there's no point in allowing a user typo to make gdb consume all memory. */
127 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
129 /* symbol_cache_lookup returns this if a previous lookup failed to find the
130 symbol in any objfile. */
131 #define SYMBOL_LOOKUP_FAILED \
132 ((struct block_symbol) {(struct symbol *) 1, NULL})
133 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
135 /* Recording lookups that don't find the symbol is just as important, if not
136 more so, than recording found symbols. */
138 enum symbol_cache_slot_state
141 SYMBOL_SLOT_NOT_FOUND,
145 struct symbol_cache_slot
147 enum symbol_cache_slot_state state;
149 /* The objfile that was current when the symbol was looked up.
150 This is only needed for global blocks, but for simplicity's sake
151 we allocate the space for both. If data shows the extra space used
152 for static blocks is a problem, we can split things up then.
154 Global blocks need cache lookup to include the objfile context because
155 we need to account for gdbarch_iterate_over_objfiles_in_search_order
156 which can traverse objfiles in, effectively, any order, depending on
157 the current objfile, thus affecting which symbol is found. Normally,
158 only the current objfile is searched first, and then the rest are
159 searched in recorded order; but putting cache lookup inside
160 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
161 Instead we just make the current objfile part of the context of
162 cache lookup. This means we can record the same symbol multiple times,
163 each with a different "current objfile" that was in effect when the
164 lookup was saved in the cache, but cache space is pretty cheap. */
165 const struct objfile *objfile_context;
169 struct block_symbol found;
178 /* Symbols don't specify global vs static block.
179 So keep them in separate caches. */
181 struct block_symbol_cache
185 unsigned int collisions;
187 /* SYMBOLS is a variable length array of this size.
188 One can imagine that in general one cache (global/static) should be a
189 fraction of the size of the other, but there's no data at the moment
190 on which to decide. */
193 struct symbol_cache_slot symbols[1];
198 Searching for symbols in the static and global blocks over multiple objfiles
199 again and again can be slow, as can searching very big objfiles. This is a
200 simple cache to improve symbol lookup performance, which is critical to
201 overall gdb performance.
203 Symbols are hashed on the name, its domain, and block.
204 They are also hashed on their objfile for objfile-specific lookups. */
208 struct block_symbol_cache *global_symbols;
209 struct block_symbol_cache *static_symbols;
212 /* When non-zero, print debugging messages related to symtab creation. */
213 unsigned int symtab_create_debug = 0;
215 /* When non-zero, print debugging messages related to symbol lookup. */
216 unsigned int symbol_lookup_debug = 0;
218 /* The size of the cache is staged here. */
219 static unsigned int new_symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
221 /* The current value of the symbol cache size.
222 This is saved so that if the user enters a value too big we can restore
223 the original value from here. */
224 static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
226 /* Non-zero if a file may be known by two different basenames.
227 This is the uncommon case, and significantly slows down gdb.
228 Default set to "off" to not slow down the common case. */
229 int basenames_may_differ = 0;
231 /* Allow the user to configure the debugger behavior with respect
232 to multiple-choice menus when more than one symbol matches during
235 const char multiple_symbols_ask[] = "ask";
236 const char multiple_symbols_all[] = "all";
237 const char multiple_symbols_cancel[] = "cancel";
238 static const char *const multiple_symbols_modes[] =
240 multiple_symbols_ask,
241 multiple_symbols_all,
242 multiple_symbols_cancel,
245 static const char *multiple_symbols_mode = multiple_symbols_all;
247 /* Read-only accessor to AUTO_SELECT_MODE. */
250 multiple_symbols_select_mode (void)
252 return multiple_symbols_mode;
255 /* Return the name of a domain_enum. */
258 domain_name (domain_enum e)
262 case UNDEF_DOMAIN: return "UNDEF_DOMAIN";
263 case VAR_DOMAIN: return "VAR_DOMAIN";
264 case STRUCT_DOMAIN: return "STRUCT_DOMAIN";
265 case MODULE_DOMAIN: return "MODULE_DOMAIN";
266 case LABEL_DOMAIN: return "LABEL_DOMAIN";
267 case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN";
268 default: gdb_assert_not_reached ("bad domain_enum");
272 /* Return the name of a search_domain . */
275 search_domain_name (enum search_domain e)
279 case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN";
280 case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN";
281 case TYPES_DOMAIN: return "TYPES_DOMAIN";
282 case ALL_DOMAIN: return "ALL_DOMAIN";
283 default: gdb_assert_not_reached ("bad search_domain");
290 compunit_primary_filetab (const struct compunit_symtab *cust)
292 gdb_assert (COMPUNIT_FILETABS (cust) != NULL);
294 /* The primary file symtab is the first one in the list. */
295 return COMPUNIT_FILETABS (cust);
301 compunit_language (const struct compunit_symtab *cust)
303 struct symtab *symtab = compunit_primary_filetab (cust);
305 /* The language of the compunit symtab is the language of its primary
307 return SYMTAB_LANGUAGE (symtab);
310 /* See whether FILENAME matches SEARCH_NAME using the rule that we
311 advertise to the user. (The manual's description of linespecs
312 describes what we advertise). Returns true if they match, false
316 compare_filenames_for_search (const char *filename, const char *search_name)
318 int len = strlen (filename);
319 size_t search_len = strlen (search_name);
321 if (len < search_len)
324 /* The tail of FILENAME must match. */
325 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
328 /* Either the names must completely match, or the character
329 preceding the trailing SEARCH_NAME segment of FILENAME must be a
332 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
333 cannot match FILENAME "/path//dir/file.c" - as user has requested
334 absolute path. The sama applies for "c:\file.c" possibly
335 incorrectly hypothetically matching "d:\dir\c:\file.c".
337 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
338 compatible with SEARCH_NAME "file.c". In such case a compiler had
339 to put the "c:file.c" name into debug info. Such compatibility
340 works only on GDB built for DOS host. */
341 return (len == search_len
342 || (!IS_ABSOLUTE_PATH (search_name)
343 && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
344 || (HAS_DRIVE_SPEC (filename)
345 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
348 /* Same as compare_filenames_for_search, but for glob-style patterns.
349 Heads up on the order of the arguments. They match the order of
350 compare_filenames_for_search, but it's the opposite of the order of
351 arguments to gdb_filename_fnmatch. */
354 compare_glob_filenames_for_search (const char *filename,
355 const char *search_name)
357 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
358 all /s have to be explicitly specified. */
359 int file_path_elements = count_path_elements (filename);
360 int search_path_elements = count_path_elements (search_name);
362 if (search_path_elements > file_path_elements)
365 if (IS_ABSOLUTE_PATH (search_name))
367 return (search_path_elements == file_path_elements
368 && gdb_filename_fnmatch (search_name, filename,
369 FNM_FILE_NAME | FNM_NOESCAPE) == 0);
373 const char *file_to_compare
374 = strip_leading_path_elements (filename,
375 file_path_elements - search_path_elements);
377 return gdb_filename_fnmatch (search_name, file_to_compare,
378 FNM_FILE_NAME | FNM_NOESCAPE) == 0;
382 /* Check for a symtab of a specific name by searching some symtabs.
383 This is a helper function for callbacks of iterate_over_symtabs.
385 If NAME is not absolute, then REAL_PATH is NULL
386 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
388 The return value, NAME, REAL_PATH and CALLBACK are identical to the
389 `map_symtabs_matching_filename' method of quick_symbol_functions.
391 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
392 Each symtab within the specified compunit symtab is also searched.
393 AFTER_LAST is one past the last compunit symtab to search; NULL means to
394 search until the end of the list. */
397 iterate_over_some_symtabs (const char *name,
398 const char *real_path,
399 struct compunit_symtab *first,
400 struct compunit_symtab *after_last,
401 gdb::function_view<bool (symtab *)> callback)
403 struct compunit_symtab *cust;
405 const char* base_name = lbasename (name);
407 for (cust = first; cust != NULL && cust != after_last; cust = cust->next)
409 ALL_COMPUNIT_FILETABS (cust, s)
411 if (compare_filenames_for_search (s->filename, name))
418 /* Before we invoke realpath, which can get expensive when many
419 files are involved, do a quick comparison of the basenames. */
420 if (! basenames_may_differ
421 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
424 if (compare_filenames_for_search (symtab_to_fullname (s), name))
431 /* If the user gave us an absolute path, try to find the file in
432 this symtab and use its absolute path. */
433 if (real_path != NULL)
435 const char *fullname = symtab_to_fullname (s);
437 gdb_assert (IS_ABSOLUTE_PATH (real_path));
438 gdb_assert (IS_ABSOLUTE_PATH (name));
439 if (FILENAME_CMP (real_path, fullname) == 0)
452 /* Check for a symtab of a specific name; first in symtabs, then in
453 psymtabs. *If* there is no '/' in the name, a match after a '/'
454 in the symtab filename will also work.
456 Calls CALLBACK with each symtab that is found. If CALLBACK returns
457 true, the search stops. */
460 iterate_over_symtabs (const char *name,
461 gdb::function_view<bool (symtab *)> callback)
463 struct objfile *objfile;
464 gdb::unique_xmalloc_ptr<char> real_path;
466 /* Here we are interested in canonicalizing an absolute path, not
467 absolutizing a relative path. */
468 if (IS_ABSOLUTE_PATH (name))
470 real_path = gdb_realpath (name);
471 gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
474 ALL_OBJFILES (objfile)
476 if (iterate_over_some_symtabs (name, real_path.get (),
477 objfile->compunit_symtabs, NULL,
482 /* Same search rules as above apply here, but now we look thru the
485 ALL_OBJFILES (objfile)
488 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
496 /* A wrapper for iterate_over_symtabs that returns the first matching
500 lookup_symtab (const char *name)
502 struct symtab *result = NULL;
504 iterate_over_symtabs (name, [&] (symtab *symtab)
514 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
515 full method name, which consist of the class name (from T), the unadorned
516 method name from METHOD_ID, and the signature for the specific overload,
517 specified by SIGNATURE_ID. Note that this function is g++ specific. */
520 gdb_mangle_name (struct type *type, int method_id, int signature_id)
522 int mangled_name_len;
524 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
525 struct fn_field *method = &f[signature_id];
526 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
527 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
528 const char *newname = type_name_no_tag (type);
530 /* Does the form of physname indicate that it is the full mangled name
531 of a constructor (not just the args)? */
532 int is_full_physname_constructor;
535 int is_destructor = is_destructor_name (physname);
536 /* Need a new type prefix. */
537 const char *const_prefix = method->is_const ? "C" : "";
538 const char *volatile_prefix = method->is_volatile ? "V" : "";
540 int len = (newname == NULL ? 0 : strlen (newname));
542 /* Nothing to do if physname already contains a fully mangled v3 abi name
543 or an operator name. */
544 if ((physname[0] == '_' && physname[1] == 'Z')
545 || is_operator_name (field_name))
546 return xstrdup (physname);
548 is_full_physname_constructor = is_constructor_name (physname);
550 is_constructor = is_full_physname_constructor
551 || (newname && strcmp (field_name, newname) == 0);
554 is_destructor = (startswith (physname, "__dt"));
556 if (is_destructor || is_full_physname_constructor)
558 mangled_name = (char *) xmalloc (strlen (physname) + 1);
559 strcpy (mangled_name, physname);
565 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
567 else if (physname[0] == 't' || physname[0] == 'Q')
569 /* The physname for template and qualified methods already includes
571 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
577 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
578 volatile_prefix, len);
580 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
581 + strlen (buf) + len + strlen (physname) + 1);
583 mangled_name = (char *) xmalloc (mangled_name_len);
585 mangled_name[0] = '\0';
587 strcpy (mangled_name, field_name);
589 strcat (mangled_name, buf);
590 /* If the class doesn't have a name, i.e. newname NULL, then we just
591 mangle it using 0 for the length of the class. Thus it gets mangled
592 as something starting with `::' rather than `classname::'. */
594 strcat (mangled_name, newname);
596 strcat (mangled_name, physname);
597 return (mangled_name);
600 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
601 correctly allocated. */
604 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
606 struct obstack *obstack)
608 if (gsymbol->language == language_ada)
612 gsymbol->ada_mangled = 0;
613 gsymbol->language_specific.obstack = obstack;
617 gsymbol->ada_mangled = 1;
618 gsymbol->language_specific.demangled_name = name;
622 gsymbol->language_specific.demangled_name = name;
625 /* Return the demangled name of GSYMBOL. */
628 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
630 if (gsymbol->language == language_ada)
632 if (!gsymbol->ada_mangled)
637 return gsymbol->language_specific.demangled_name;
641 /* Initialize the language dependent portion of a symbol
642 depending upon the language for the symbol. */
645 symbol_set_language (struct general_symbol_info *gsymbol,
646 enum language language,
647 struct obstack *obstack)
649 gsymbol->language = language;
650 if (gsymbol->language == language_cplus
651 || gsymbol->language == language_d
652 || gsymbol->language == language_go
653 || gsymbol->language == language_objc
654 || gsymbol->language == language_fortran)
656 symbol_set_demangled_name (gsymbol, NULL, obstack);
658 else if (gsymbol->language == language_ada)
660 gdb_assert (gsymbol->ada_mangled == 0);
661 gsymbol->language_specific.obstack = obstack;
665 memset (&gsymbol->language_specific, 0,
666 sizeof (gsymbol->language_specific));
670 /* Functions to initialize a symbol's mangled name. */
672 /* Objects of this type are stored in the demangled name hash table. */
673 struct demangled_name_entry
679 /* Hash function for the demangled name hash. */
682 hash_demangled_name_entry (const void *data)
684 const struct demangled_name_entry *e
685 = (const struct demangled_name_entry *) data;
687 return htab_hash_string (e->mangled);
690 /* Equality function for the demangled name hash. */
693 eq_demangled_name_entry (const void *a, const void *b)
695 const struct demangled_name_entry *da
696 = (const struct demangled_name_entry *) a;
697 const struct demangled_name_entry *db
698 = (const struct demangled_name_entry *) b;
700 return strcmp (da->mangled, db->mangled) == 0;
703 /* Create the hash table used for demangled names. Each hash entry is
704 a pair of strings; one for the mangled name and one for the demangled
705 name. The entry is hashed via just the mangled name. */
708 create_demangled_names_hash (struct objfile *objfile)
710 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
711 The hash table code will round this up to the next prime number.
712 Choosing a much larger table size wastes memory, and saves only about
713 1% in symbol reading. */
715 objfile->per_bfd->demangled_names_hash = htab_create_alloc
716 (256, hash_demangled_name_entry, eq_demangled_name_entry,
717 NULL, xcalloc, xfree);
720 /* Try to determine the demangled name for a symbol, based on the
721 language of that symbol. If the language is set to language_auto,
722 it will attempt to find any demangling algorithm that works and
723 then set the language appropriately. The returned name is allocated
724 by the demangler and should be xfree'd. */
727 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
730 char *demangled = NULL;
734 if (gsymbol->language == language_unknown)
735 gsymbol->language = language_auto;
737 if (gsymbol->language != language_auto)
739 const struct language_defn *lang = language_def (gsymbol->language);
741 language_sniff_from_mangled_name (lang, mangled, &demangled);
745 for (i = language_unknown; i < nr_languages; ++i)
747 enum language l = (enum language) i;
748 const struct language_defn *lang = language_def (l);
750 if (language_sniff_from_mangled_name (lang, mangled, &demangled))
752 gsymbol->language = l;
760 /* Set both the mangled and demangled (if any) names for GSYMBOL based
761 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
762 objfile's obstack; but if COPY_NAME is 0 and if NAME is
763 NUL-terminated, then this function assumes that NAME is already
764 correctly saved (either permanently or with a lifetime tied to the
765 objfile), and it will not be copied.
767 The hash table corresponding to OBJFILE is used, and the memory
768 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
769 so the pointer can be discarded after calling this function. */
772 symbol_set_names (struct general_symbol_info *gsymbol,
773 const char *linkage_name, int len, int copy_name,
774 struct objfile *objfile)
776 struct demangled_name_entry **slot;
777 /* A 0-terminated copy of the linkage name. */
778 const char *linkage_name_copy;
779 struct demangled_name_entry entry;
780 struct objfile_per_bfd_storage *per_bfd = objfile->per_bfd;
782 if (gsymbol->language == language_ada)
784 /* In Ada, we do the symbol lookups using the mangled name, so
785 we can save some space by not storing the demangled name. */
787 gsymbol->name = linkage_name;
790 char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,
793 memcpy (name, linkage_name, len);
795 gsymbol->name = name;
797 symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
802 if (per_bfd->demangled_names_hash == NULL)
803 create_demangled_names_hash (objfile);
805 if (linkage_name[len] != '\0')
809 alloc_name = (char *) alloca (len + 1);
810 memcpy (alloc_name, linkage_name, len);
811 alloc_name[len] = '\0';
813 linkage_name_copy = alloc_name;
816 linkage_name_copy = linkage_name;
818 entry.mangled = linkage_name_copy;
819 slot = ((struct demangled_name_entry **)
820 htab_find_slot (per_bfd->demangled_names_hash,
823 /* If this name is not in the hash table, add it. */
825 /* A C version of the symbol may have already snuck into the table.
826 This happens to, e.g., main.init (__go_init_main). Cope. */
827 || (gsymbol->language == language_go
828 && (*slot)->demangled[0] == '\0'))
830 char *demangled_name = symbol_find_demangled_name (gsymbol,
832 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
834 /* Suppose we have demangled_name==NULL, copy_name==0, and
835 linkage_name_copy==linkage_name. In this case, we already have the
836 mangled name saved, and we don't have a demangled name. So,
837 you might think we could save a little space by not recording
838 this in the hash table at all.
840 It turns out that it is actually important to still save such
841 an entry in the hash table, because storing this name gives
842 us better bcache hit rates for partial symbols. */
843 if (!copy_name && linkage_name_copy == linkage_name)
846 = ((struct demangled_name_entry *)
847 obstack_alloc (&per_bfd->storage_obstack,
848 offsetof (struct demangled_name_entry, demangled)
849 + demangled_len + 1));
850 (*slot)->mangled = linkage_name;
856 /* If we must copy the mangled name, put it directly after
857 the demangled name so we can have a single
860 = ((struct demangled_name_entry *)
861 obstack_alloc (&per_bfd->storage_obstack,
862 offsetof (struct demangled_name_entry, demangled)
863 + len + demangled_len + 2));
864 mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
865 strcpy (mangled_ptr, linkage_name_copy);
866 (*slot)->mangled = mangled_ptr;
869 if (demangled_name != NULL)
871 strcpy ((*slot)->demangled, demangled_name);
872 xfree (demangled_name);
875 (*slot)->demangled[0] = '\0';
878 gsymbol->name = (*slot)->mangled;
879 if ((*slot)->demangled[0] != '\0')
880 symbol_set_demangled_name (gsymbol, (*slot)->demangled,
881 &per_bfd->storage_obstack);
883 symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
886 /* Return the source code name of a symbol. In languages where
887 demangling is necessary, this is the demangled name. */
890 symbol_natural_name (const struct general_symbol_info *gsymbol)
892 switch (gsymbol->language)
898 case language_fortran:
899 if (symbol_get_demangled_name (gsymbol) != NULL)
900 return symbol_get_demangled_name (gsymbol);
903 return ada_decode_symbol (gsymbol);
907 return gsymbol->name;
910 /* Return the demangled name for a symbol based on the language for
911 that symbol. If no demangled name exists, return NULL. */
914 symbol_demangled_name (const struct general_symbol_info *gsymbol)
916 const char *dem_name = NULL;
918 switch (gsymbol->language)
924 case language_fortran:
925 dem_name = symbol_get_demangled_name (gsymbol);
928 dem_name = ada_decode_symbol (gsymbol);
936 /* Return the search name of a symbol---generally the demangled or
937 linkage name of the symbol, depending on how it will be searched for.
938 If there is no distinct demangled name, then returns the same value
939 (same pointer) as SYMBOL_LINKAGE_NAME. */
942 symbol_search_name (const struct general_symbol_info *gsymbol)
944 if (gsymbol->language == language_ada)
945 return gsymbol->name;
947 return symbol_natural_name (gsymbol);
951 /* Return 1 if the two sections are the same, or if they could
952 plausibly be copies of each other, one in an original object
953 file and another in a separated debug file. */
956 matching_obj_sections (struct obj_section *obj_first,
957 struct obj_section *obj_second)
959 asection *first = obj_first? obj_first->the_bfd_section : NULL;
960 asection *second = obj_second? obj_second->the_bfd_section : NULL;
963 /* If they're the same section, then they match. */
967 /* If either is NULL, give up. */
968 if (first == NULL || second == NULL)
971 /* This doesn't apply to absolute symbols. */
972 if (first->owner == NULL || second->owner == NULL)
975 /* If they're in the same object file, they must be different sections. */
976 if (first->owner == second->owner)
979 /* Check whether the two sections are potentially corresponding. They must
980 have the same size, address, and name. We can't compare section indexes,
981 which would be more reliable, because some sections may have been
983 if (bfd_get_section_size (first) != bfd_get_section_size (second))
986 /* In-memory addresses may start at a different offset, relativize them. */
987 if (bfd_get_section_vma (first->owner, first)
988 - bfd_get_start_address (first->owner)
989 != bfd_get_section_vma (second->owner, second)
990 - bfd_get_start_address (second->owner))
993 if (bfd_get_section_name (first->owner, first) == NULL
994 || bfd_get_section_name (second->owner, second) == NULL
995 || strcmp (bfd_get_section_name (first->owner, first),
996 bfd_get_section_name (second->owner, second)) != 0)
999 /* Otherwise check that they are in corresponding objfiles. */
1002 if (obj->obfd == first->owner)
1004 gdb_assert (obj != NULL);
1006 if (obj->separate_debug_objfile != NULL
1007 && obj->separate_debug_objfile->obfd == second->owner)
1009 if (obj->separate_debug_objfile_backlink != NULL
1010 && obj->separate_debug_objfile_backlink->obfd == second->owner)
1019 expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
1021 struct objfile *objfile;
1022 struct bound_minimal_symbol msymbol;
1024 /* If we know that this is not a text address, return failure. This is
1025 necessary because we loop based on texthigh and textlow, which do
1026 not include the data ranges. */
1027 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1029 && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
1030 || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
1031 || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
1032 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
1033 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
1036 ALL_OBJFILES (objfile)
1038 struct compunit_symtab *cust = NULL;
1041 cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
1048 /* Hash function for the symbol cache. */
1051 hash_symbol_entry (const struct objfile *objfile_context,
1052 const char *name, domain_enum domain)
1054 unsigned int hash = (uintptr_t) objfile_context;
1057 hash += htab_hash_string (name);
1059 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1060 to map to the same slot. */
1061 if (domain == STRUCT_DOMAIN)
1062 hash += VAR_DOMAIN * 7;
1069 /* Equality function for the symbol cache. */
1072 eq_symbol_entry (const struct symbol_cache_slot *slot,
1073 const struct objfile *objfile_context,
1074 const char *name, domain_enum domain)
1076 const char *slot_name;
1077 domain_enum slot_domain;
1079 if (slot->state == SYMBOL_SLOT_UNUSED)
1082 if (slot->objfile_context != objfile_context)
1085 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1087 slot_name = slot->value.not_found.name;
1088 slot_domain = slot->value.not_found.domain;
1092 slot_name = SYMBOL_SEARCH_NAME (slot->value.found.symbol);
1093 slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol);
1096 /* NULL names match. */
1097 if (slot_name == NULL && name == NULL)
1099 /* But there's no point in calling symbol_matches_domain in the
1100 SYMBOL_SLOT_FOUND case. */
1101 if (slot_domain != domain)
1104 else if (slot_name != NULL && name != NULL)
1106 /* It's important that we use the same comparison that was done the
1107 first time through. If the slot records a found symbol, then this
1108 means using strcmp_iw on SYMBOL_SEARCH_NAME. See dictionary.c.
1109 It also means using symbol_matches_domain for found symbols.
1112 If the slot records a not-found symbol, then require a precise match.
1113 We could still be lax with whitespace like strcmp_iw though. */
1115 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1117 if (strcmp (slot_name, name) != 0)
1119 if (slot_domain != domain)
1124 struct symbol *sym = slot->value.found.symbol;
1126 if (strcmp_iw (slot_name, name) != 0)
1128 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1129 slot_domain, domain))
1135 /* Only one name is NULL. */
1142 /* Given a cache of size SIZE, return the size of the struct (with variable
1143 length array) in bytes. */
1146 symbol_cache_byte_size (unsigned int size)
1148 return (sizeof (struct block_symbol_cache)
1149 + ((size - 1) * sizeof (struct symbol_cache_slot)));
1155 resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size)
1157 /* If there's no change in size, don't do anything.
1158 All caches have the same size, so we can just compare with the size
1159 of the global symbols cache. */
1160 if ((cache->global_symbols != NULL
1161 && cache->global_symbols->size == new_size)
1162 || (cache->global_symbols == NULL
1166 xfree (cache->global_symbols);
1167 xfree (cache->static_symbols);
1171 cache->global_symbols = NULL;
1172 cache->static_symbols = NULL;
1176 size_t total_size = symbol_cache_byte_size (new_size);
1178 cache->global_symbols
1179 = (struct block_symbol_cache *) xcalloc (1, total_size);
1180 cache->static_symbols
1181 = (struct block_symbol_cache *) xcalloc (1, total_size);
1182 cache->global_symbols->size = new_size;
1183 cache->static_symbols->size = new_size;
1187 /* Make a symbol cache of size SIZE. */
1189 static struct symbol_cache *
1190 make_symbol_cache (unsigned int size)
1192 struct symbol_cache *cache;
1194 cache = XCNEW (struct symbol_cache);
1195 resize_symbol_cache (cache, symbol_cache_size);
1199 /* Free the space used by CACHE. */
1202 free_symbol_cache (struct symbol_cache *cache)
1204 xfree (cache->global_symbols);
1205 xfree (cache->static_symbols);
1209 /* Return the symbol cache of PSPACE.
1210 Create one if it doesn't exist yet. */
1212 static struct symbol_cache *
1213 get_symbol_cache (struct program_space *pspace)
1215 struct symbol_cache *cache
1216 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1220 cache = make_symbol_cache (symbol_cache_size);
1221 set_program_space_data (pspace, symbol_cache_key, cache);
1227 /* Delete the symbol cache of PSPACE.
1228 Called when PSPACE is destroyed. */
1231 symbol_cache_cleanup (struct program_space *pspace, void *data)
1233 struct symbol_cache *cache = (struct symbol_cache *) data;
1235 free_symbol_cache (cache);
1238 /* Set the size of the symbol cache in all program spaces. */
1241 set_symbol_cache_size (unsigned int new_size)
1243 struct program_space *pspace;
1245 ALL_PSPACES (pspace)
1247 struct symbol_cache *cache
1248 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1250 /* The pspace could have been created but not have a cache yet. */
1252 resize_symbol_cache (cache, new_size);
1256 /* Called when symbol-cache-size is set. */
1259 set_symbol_cache_size_handler (const char *args, int from_tty,
1260 struct cmd_list_element *c)
1262 if (new_symbol_cache_size > MAX_SYMBOL_CACHE_SIZE)
1264 /* Restore the previous value.
1265 This is the value the "show" command prints. */
1266 new_symbol_cache_size = symbol_cache_size;
1268 error (_("Symbol cache size is too large, max is %u."),
1269 MAX_SYMBOL_CACHE_SIZE);
1271 symbol_cache_size = new_symbol_cache_size;
1273 set_symbol_cache_size (symbol_cache_size);
1276 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1277 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1278 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1279 failed (and thus this one will too), or NULL if the symbol is not present
1281 If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
1282 set to the cache and slot of the symbol to save the result of a full lookup
1285 static struct block_symbol
1286 symbol_cache_lookup (struct symbol_cache *cache,
1287 struct objfile *objfile_context, int block,
1288 const char *name, domain_enum domain,
1289 struct block_symbol_cache **bsc_ptr,
1290 struct symbol_cache_slot **slot_ptr)
1292 struct block_symbol_cache *bsc;
1294 struct symbol_cache_slot *slot;
1296 if (block == GLOBAL_BLOCK)
1297 bsc = cache->global_symbols;
1299 bsc = cache->static_symbols;
1304 return (struct block_symbol) {NULL, NULL};
1307 hash = hash_symbol_entry (objfile_context, name, domain);
1308 slot = bsc->symbols + hash % bsc->size;
1310 if (eq_symbol_entry (slot, objfile_context, name, domain))
1312 if (symbol_lookup_debug)
1313 fprintf_unfiltered (gdb_stdlog,
1314 "%s block symbol cache hit%s for %s, %s\n",
1315 block == GLOBAL_BLOCK ? "Global" : "Static",
1316 slot->state == SYMBOL_SLOT_NOT_FOUND
1317 ? " (not found)" : "",
1318 name, domain_name (domain));
1320 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1321 return SYMBOL_LOOKUP_FAILED;
1322 return slot->value.found;
1325 /* Symbol is not present in the cache. */
1330 if (symbol_lookup_debug)
1332 fprintf_unfiltered (gdb_stdlog,
1333 "%s block symbol cache miss for %s, %s\n",
1334 block == GLOBAL_BLOCK ? "Global" : "Static",
1335 name, domain_name (domain));
1338 return (struct block_symbol) {NULL, NULL};
1341 /* Clear out SLOT. */
1344 symbol_cache_clear_slot (struct symbol_cache_slot *slot)
1346 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1347 xfree (slot->value.not_found.name);
1348 slot->state = SYMBOL_SLOT_UNUSED;
1351 /* Mark SYMBOL as found in SLOT.
1352 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1353 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1354 necessarily the objfile the symbol was found in. */
1357 symbol_cache_mark_found (struct block_symbol_cache *bsc,
1358 struct symbol_cache_slot *slot,
1359 struct objfile *objfile_context,
1360 struct symbol *symbol,
1361 const struct block *block)
1365 if (slot->state != SYMBOL_SLOT_UNUSED)
1368 symbol_cache_clear_slot (slot);
1370 slot->state = SYMBOL_SLOT_FOUND;
1371 slot->objfile_context = objfile_context;
1372 slot->value.found.symbol = symbol;
1373 slot->value.found.block = block;
1376 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1377 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1378 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1381 symbol_cache_mark_not_found (struct block_symbol_cache *bsc,
1382 struct symbol_cache_slot *slot,
1383 struct objfile *objfile_context,
1384 const char *name, domain_enum domain)
1388 if (slot->state != SYMBOL_SLOT_UNUSED)
1391 symbol_cache_clear_slot (slot);
1393 slot->state = SYMBOL_SLOT_NOT_FOUND;
1394 slot->objfile_context = objfile_context;
1395 slot->value.not_found.name = xstrdup (name);
1396 slot->value.not_found.domain = domain;
1399 /* Flush the symbol cache of PSPACE. */
1402 symbol_cache_flush (struct program_space *pspace)
1404 struct symbol_cache *cache
1405 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1410 if (cache->global_symbols == NULL)
1412 gdb_assert (symbol_cache_size == 0);
1413 gdb_assert (cache->static_symbols == NULL);
1417 /* If the cache is untouched since the last flush, early exit.
1418 This is important for performance during the startup of a program linked
1419 with 100s (or 1000s) of shared libraries. */
1420 if (cache->global_symbols->misses == 0
1421 && cache->static_symbols->misses == 0)
1424 gdb_assert (cache->global_symbols->size == symbol_cache_size);
1425 gdb_assert (cache->static_symbols->size == symbol_cache_size);
1427 for (pass = 0; pass < 2; ++pass)
1429 struct block_symbol_cache *bsc
1430 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1433 for (i = 0; i < bsc->size; ++i)
1434 symbol_cache_clear_slot (&bsc->symbols[i]);
1437 cache->global_symbols->hits = 0;
1438 cache->global_symbols->misses = 0;
1439 cache->global_symbols->collisions = 0;
1440 cache->static_symbols->hits = 0;
1441 cache->static_symbols->misses = 0;
1442 cache->static_symbols->collisions = 0;
1448 symbol_cache_dump (const struct symbol_cache *cache)
1452 if (cache->global_symbols == NULL)
1454 printf_filtered (" <disabled>\n");
1458 for (pass = 0; pass < 2; ++pass)
1460 const struct block_symbol_cache *bsc
1461 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1465 printf_filtered ("Global symbols:\n");
1467 printf_filtered ("Static symbols:\n");
1469 for (i = 0; i < bsc->size; ++i)
1471 const struct symbol_cache_slot *slot = &bsc->symbols[i];
1475 switch (slot->state)
1477 case SYMBOL_SLOT_UNUSED:
1479 case SYMBOL_SLOT_NOT_FOUND:
1480 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i,
1481 host_address_to_string (slot->objfile_context),
1482 slot->value.not_found.name,
1483 domain_name (slot->value.not_found.domain));
1485 case SYMBOL_SLOT_FOUND:
1487 struct symbol *found = slot->value.found.symbol;
1488 const struct objfile *context = slot->objfile_context;
1490 printf_filtered (" [%4u] = %s, %s %s\n", i,
1491 host_address_to_string (context),
1492 SYMBOL_PRINT_NAME (found),
1493 domain_name (SYMBOL_DOMAIN (found)));
1501 /* The "mt print symbol-cache" command. */
1504 maintenance_print_symbol_cache (const char *args, int from_tty)
1506 struct program_space *pspace;
1508 ALL_PSPACES (pspace)
1510 struct symbol_cache *cache;
1512 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1514 pspace->symfile_object_file != NULL
1515 ? objfile_name (pspace->symfile_object_file)
1516 : "(no object file)");
1518 /* If the cache hasn't been created yet, avoid creating one. */
1520 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1522 printf_filtered (" <empty>\n");
1524 symbol_cache_dump (cache);
1528 /* The "mt flush-symbol-cache" command. */
1531 maintenance_flush_symbol_cache (const char *args, int from_tty)
1533 struct program_space *pspace;
1535 ALL_PSPACES (pspace)
1537 symbol_cache_flush (pspace);
1541 /* Print usage statistics of CACHE. */
1544 symbol_cache_stats (struct symbol_cache *cache)
1548 if (cache->global_symbols == NULL)
1550 printf_filtered (" <disabled>\n");
1554 for (pass = 0; pass < 2; ++pass)
1556 const struct block_symbol_cache *bsc
1557 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1562 printf_filtered ("Global block cache stats:\n");
1564 printf_filtered ("Static block cache stats:\n");
1566 printf_filtered (" size: %u\n", bsc->size);
1567 printf_filtered (" hits: %u\n", bsc->hits);
1568 printf_filtered (" misses: %u\n", bsc->misses);
1569 printf_filtered (" collisions: %u\n", bsc->collisions);
1573 /* The "mt print symbol-cache-statistics" command. */
1576 maintenance_print_symbol_cache_statistics (const char *args, int from_tty)
1578 struct program_space *pspace;
1580 ALL_PSPACES (pspace)
1582 struct symbol_cache *cache;
1584 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1586 pspace->symfile_object_file != NULL
1587 ? objfile_name (pspace->symfile_object_file)
1588 : "(no object file)");
1590 /* If the cache hasn't been created yet, avoid creating one. */
1592 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1594 printf_filtered (" empty, no stats available\n");
1596 symbol_cache_stats (cache);
1600 /* This module's 'new_objfile' observer. */
1603 symtab_new_objfile_observer (struct objfile *objfile)
1605 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1606 symbol_cache_flush (current_program_space);
1609 /* This module's 'free_objfile' observer. */
1612 symtab_free_objfile_observer (struct objfile *objfile)
1614 symbol_cache_flush (objfile->pspace);
1617 /* Debug symbols usually don't have section information. We need to dig that
1618 out of the minimal symbols and stash that in the debug symbol. */
1621 fixup_section (struct general_symbol_info *ginfo,
1622 CORE_ADDR addr, struct objfile *objfile)
1624 struct minimal_symbol *msym;
1626 /* First, check whether a minimal symbol with the same name exists
1627 and points to the same address. The address check is required
1628 e.g. on PowerPC64, where the minimal symbol for a function will
1629 point to the function descriptor, while the debug symbol will
1630 point to the actual function code. */
1631 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1633 ginfo->section = MSYMBOL_SECTION (msym);
1636 /* Static, function-local variables do appear in the linker
1637 (minimal) symbols, but are frequently given names that won't
1638 be found via lookup_minimal_symbol(). E.g., it has been
1639 observed in frv-uclinux (ELF) executables that a static,
1640 function-local variable named "foo" might appear in the
1641 linker symbols as "foo.6" or "foo.3". Thus, there is no
1642 point in attempting to extend the lookup-by-name mechanism to
1643 handle this case due to the fact that there can be multiple
1646 So, instead, search the section table when lookup by name has
1647 failed. The ``addr'' and ``endaddr'' fields may have already
1648 been relocated. If so, the relocation offset (i.e. the
1649 ANOFFSET value) needs to be subtracted from these values when
1650 performing the comparison. We unconditionally subtract it,
1651 because, when no relocation has been performed, the ANOFFSET
1652 value will simply be zero.
1654 The address of the symbol whose section we're fixing up HAS
1655 NOT BEEN adjusted (relocated) yet. It can't have been since
1656 the section isn't yet known and knowing the section is
1657 necessary in order to add the correct relocation value. In
1658 other words, we wouldn't even be in this function (attempting
1659 to compute the section) if it were already known.
1661 Note that it is possible to search the minimal symbols
1662 (subtracting the relocation value if necessary) to find the
1663 matching minimal symbol, but this is overkill and much less
1664 efficient. It is not necessary to find the matching minimal
1665 symbol, only its section.
1667 Note that this technique (of doing a section table search)
1668 can fail when unrelocated section addresses overlap. For
1669 this reason, we still attempt a lookup by name prior to doing
1670 a search of the section table. */
1672 struct obj_section *s;
1675 ALL_OBJFILE_OSECTIONS (objfile, s)
1677 int idx = s - objfile->sections;
1678 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1683 if (obj_section_addr (s) - offset <= addr
1684 && addr < obj_section_endaddr (s) - offset)
1686 ginfo->section = idx;
1691 /* If we didn't find the section, assume it is in the first
1692 section. If there is no allocated section, then it hardly
1693 matters what we pick, so just pick zero. */
1697 ginfo->section = fallback;
1702 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1709 if (!SYMBOL_OBJFILE_OWNED (sym))
1712 /* We either have an OBJFILE, or we can get at it from the sym's
1713 symtab. Anything else is a bug. */
1714 gdb_assert (objfile || symbol_symtab (sym));
1716 if (objfile == NULL)
1717 objfile = symbol_objfile (sym);
1719 if (SYMBOL_OBJ_SECTION (objfile, sym))
1722 /* We should have an objfile by now. */
1723 gdb_assert (objfile);
1725 switch (SYMBOL_CLASS (sym))
1729 addr = SYMBOL_VALUE_ADDRESS (sym);
1732 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1736 /* Nothing else will be listed in the minsyms -- no use looking
1741 fixup_section (&sym->ginfo, addr, objfile);
1746 /* Compute the demangled form of NAME as used by the various symbol
1747 lookup functions. The result can either be the input NAME
1748 directly, or a pointer to a buffer owned by the STORAGE object.
1750 For Ada, this function just returns NAME, unmodified.
1751 Normally, Ada symbol lookups are performed using the encoded name
1752 rather than the demangled name, and so it might seem to make sense
1753 for this function to return an encoded version of NAME.
1754 Unfortunately, we cannot do this, because this function is used in
1755 circumstances where it is not appropriate to try to encode NAME.
1756 For instance, when displaying the frame info, we demangle the name
1757 of each parameter, and then perform a symbol lookup inside our
1758 function using that demangled name. In Ada, certain functions
1759 have internally-generated parameters whose name contain uppercase
1760 characters. Encoding those name would result in those uppercase
1761 characters to become lowercase, and thus cause the symbol lookup
1765 demangle_for_lookup (const char *name, enum language lang,
1766 demangle_result_storage &storage)
1768 /* If we are using C++, D, or Go, demangle the name before doing a
1769 lookup, so we can always binary search. */
1770 if (lang == language_cplus)
1772 char *demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1773 if (demangled_name != NULL)
1774 return storage.set_malloc_ptr (demangled_name);
1776 /* If we were given a non-mangled name, canonicalize it
1777 according to the language (so far only for C++). */
1778 std::string canon = cp_canonicalize_string (name);
1779 if (!canon.empty ())
1780 return storage.swap_string (canon);
1782 else if (lang == language_d)
1784 char *demangled_name = d_demangle (name, 0);
1785 if (demangled_name != NULL)
1786 return storage.set_malloc_ptr (demangled_name);
1788 else if (lang == language_go)
1790 char *demangled_name = go_demangle (name, 0);
1791 if (demangled_name != NULL)
1792 return storage.set_malloc_ptr (demangled_name);
1801 search_name_hash (enum language language, const char *search_name)
1803 return language_def (language)->la_search_name_hash (search_name);
1808 This function (or rather its subordinates) have a bunch of loops and
1809 it would seem to be attractive to put in some QUIT's (though I'm not really
1810 sure whether it can run long enough to be really important). But there
1811 are a few calls for which it would appear to be bad news to quit
1812 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1813 that there is C++ code below which can error(), but that probably
1814 doesn't affect these calls since they are looking for a known
1815 variable and thus can probably assume it will never hit the C++
1819 lookup_symbol_in_language (const char *name, const struct block *block,
1820 const domain_enum domain, enum language lang,
1821 struct field_of_this_result *is_a_field_of_this)
1823 demangle_result_storage storage;
1824 const char *modified_name = demangle_for_lookup (name, lang, storage);
1826 return lookup_symbol_aux (modified_name, block, domain, lang,
1827 is_a_field_of_this);
1833 lookup_symbol (const char *name, const struct block *block,
1835 struct field_of_this_result *is_a_field_of_this)
1837 return lookup_symbol_in_language (name, block, domain,
1838 current_language->la_language,
1839 is_a_field_of_this);
1845 lookup_language_this (const struct language_defn *lang,
1846 const struct block *block)
1848 if (lang->la_name_of_this == NULL || block == NULL)
1849 return (struct block_symbol) {NULL, NULL};
1851 if (symbol_lookup_debug > 1)
1853 struct objfile *objfile = lookup_objfile_from_block (block);
1855 fprintf_unfiltered (gdb_stdlog,
1856 "lookup_language_this (%s, %s (objfile %s))",
1857 lang->la_name, host_address_to_string (block),
1858 objfile_debug_name (objfile));
1865 sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1868 if (symbol_lookup_debug > 1)
1870 fprintf_unfiltered (gdb_stdlog, " = %s (%s, block %s)\n",
1871 SYMBOL_PRINT_NAME (sym),
1872 host_address_to_string (sym),
1873 host_address_to_string (block));
1875 return (struct block_symbol) {sym, block};
1877 if (BLOCK_FUNCTION (block))
1879 block = BLOCK_SUPERBLOCK (block);
1882 if (symbol_lookup_debug > 1)
1883 fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1884 return (struct block_symbol) {NULL, NULL};
1887 /* Given TYPE, a structure/union,
1888 return 1 if the component named NAME from the ultimate target
1889 structure/union is defined, otherwise, return 0. */
1892 check_field (struct type *type, const char *name,
1893 struct field_of_this_result *is_a_field_of_this)
1897 /* The type may be a stub. */
1898 type = check_typedef (type);
1900 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1902 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1904 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1906 is_a_field_of_this->type = type;
1907 is_a_field_of_this->field = &TYPE_FIELD (type, i);
1912 /* C++: If it was not found as a data field, then try to return it
1913 as a pointer to a method. */
1915 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1917 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1919 is_a_field_of_this->type = type;
1920 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1925 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1926 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
1932 /* Behave like lookup_symbol except that NAME is the natural name
1933 (e.g., demangled name) of the symbol that we're looking for. */
1935 static struct block_symbol
1936 lookup_symbol_aux (const char *name, const struct block *block,
1937 const domain_enum domain, enum language language,
1938 struct field_of_this_result *is_a_field_of_this)
1940 struct block_symbol result;
1941 const struct language_defn *langdef;
1943 if (symbol_lookup_debug)
1945 struct objfile *objfile = lookup_objfile_from_block (block);
1947 fprintf_unfiltered (gdb_stdlog,
1948 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
1949 name, host_address_to_string (block),
1951 ? objfile_debug_name (objfile) : "NULL",
1952 domain_name (domain), language_str (language));
1955 /* Make sure we do something sensible with is_a_field_of_this, since
1956 the callers that set this parameter to some non-null value will
1957 certainly use it later. If we don't set it, the contents of
1958 is_a_field_of_this are undefined. */
1959 if (is_a_field_of_this != NULL)
1960 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
1962 /* Search specified block and its superiors. Don't search
1963 STATIC_BLOCK or GLOBAL_BLOCK. */
1965 result = lookup_local_symbol (name, block, domain, language);
1966 if (result.symbol != NULL)
1968 if (symbol_lookup_debug)
1970 fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
1971 host_address_to_string (result.symbol));
1976 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1977 check to see if NAME is a field of `this'. */
1979 langdef = language_def (language);
1981 /* Don't do this check if we are searching for a struct. It will
1982 not be found by check_field, but will be found by other
1984 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
1986 result = lookup_language_this (langdef, block);
1990 struct type *t = result.symbol->type;
1992 /* I'm not really sure that type of this can ever
1993 be typedefed; just be safe. */
1994 t = check_typedef (t);
1995 if (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
1996 t = TYPE_TARGET_TYPE (t);
1998 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1999 && TYPE_CODE (t) != TYPE_CODE_UNION)
2000 error (_("Internal error: `%s' is not an aggregate"),
2001 langdef->la_name_of_this);
2003 if (check_field (t, name, is_a_field_of_this))
2005 if (symbol_lookup_debug)
2007 fprintf_unfiltered (gdb_stdlog,
2008 "lookup_symbol_aux (...) = NULL\n");
2010 return (struct block_symbol) {NULL, NULL};
2015 /* Now do whatever is appropriate for LANGUAGE to look
2016 up static and global variables. */
2018 result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
2019 if (result.symbol != NULL)
2021 if (symbol_lookup_debug)
2023 fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2024 host_address_to_string (result.symbol));
2029 /* Now search all static file-level symbols. Not strictly correct,
2030 but more useful than an error. */
2032 result = lookup_static_symbol (name, domain);
2033 if (symbol_lookup_debug)
2035 fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2036 result.symbol != NULL
2037 ? host_address_to_string (result.symbol)
2043 /* Check to see if the symbol is defined in BLOCK or its superiors.
2044 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2046 static struct block_symbol
2047 lookup_local_symbol (const char *name, const struct block *block,
2048 const domain_enum domain,
2049 enum language language)
2052 const struct block *static_block = block_static_block (block);
2053 const char *scope = block_scope (block);
2055 /* Check if either no block is specified or it's a global block. */
2057 if (static_block == NULL)
2058 return (struct block_symbol) {NULL, NULL};
2060 while (block != static_block)
2062 sym = lookup_symbol_in_block (name, block, domain);
2064 return (struct block_symbol) {sym, block};
2066 if (language == language_cplus || language == language_fortran)
2068 struct block_symbol sym
2069 = cp_lookup_symbol_imports_or_template (scope, name, block,
2072 if (sym.symbol != NULL)
2076 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
2078 block = BLOCK_SUPERBLOCK (block);
2081 /* We've reached the end of the function without finding a result. */
2083 return (struct block_symbol) {NULL, NULL};
2089 lookup_objfile_from_block (const struct block *block)
2091 struct objfile *obj;
2092 struct compunit_symtab *cust;
2097 block = block_global_block (block);
2098 /* Look through all blockvectors. */
2099 ALL_COMPUNITS (obj, cust)
2100 if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
2103 if (obj->separate_debug_objfile_backlink)
2104 obj = obj->separate_debug_objfile_backlink;
2115 lookup_symbol_in_block (const char *name, const struct block *block,
2116 const domain_enum domain)
2120 if (symbol_lookup_debug > 1)
2122 struct objfile *objfile = lookup_objfile_from_block (block);
2124 fprintf_unfiltered (gdb_stdlog,
2125 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2126 name, host_address_to_string (block),
2127 objfile_debug_name (objfile),
2128 domain_name (domain));
2131 sym = block_lookup_symbol (block, name, domain);
2134 if (symbol_lookup_debug > 1)
2136 fprintf_unfiltered (gdb_stdlog, " = %s\n",
2137 host_address_to_string (sym));
2139 return fixup_symbol_section (sym, NULL);
2142 if (symbol_lookup_debug > 1)
2143 fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2150 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
2152 const domain_enum domain)
2154 struct objfile *objfile;
2156 for (objfile = main_objfile;
2158 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
2160 struct block_symbol result
2161 = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, name, domain);
2163 if (result.symbol != NULL)
2167 return (struct block_symbol) {NULL, NULL};
2170 /* Check to see if the symbol is defined in one of the OBJFILE's
2171 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2172 depending on whether or not we want to search global symbols or
2175 static struct block_symbol
2176 lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
2177 const char *name, const domain_enum domain)
2179 struct compunit_symtab *cust;
2181 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2183 if (symbol_lookup_debug > 1)
2185 fprintf_unfiltered (gdb_stdlog,
2186 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2187 objfile_debug_name (objfile),
2188 block_index == GLOBAL_BLOCK
2189 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2190 name, domain_name (domain));
2193 ALL_OBJFILE_COMPUNITS (objfile, cust)
2195 const struct blockvector *bv;
2196 const struct block *block;
2197 struct block_symbol result;
2199 bv = COMPUNIT_BLOCKVECTOR (cust);
2200 block = BLOCKVECTOR_BLOCK (bv, block_index);
2201 result.symbol = block_lookup_symbol_primary (block, name, domain);
2202 result.block = block;
2203 if (result.symbol != NULL)
2205 if (symbol_lookup_debug > 1)
2207 fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n",
2208 host_address_to_string (result.symbol),
2209 host_address_to_string (block));
2211 result.symbol = fixup_symbol_section (result.symbol, objfile);
2217 if (symbol_lookup_debug > 1)
2218 fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2219 return (struct block_symbol) {NULL, NULL};
2222 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2223 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2224 and all associated separate debug objfiles.
2226 Normally we only look in OBJFILE, and not any separate debug objfiles
2227 because the outer loop will cause them to be searched too. This case is
2228 different. Here we're called from search_symbols where it will only
2229 call us for the the objfile that contains a matching minsym. */
2231 static struct block_symbol
2232 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
2233 const char *linkage_name,
2236 enum language lang = current_language->la_language;
2237 struct objfile *main_objfile, *cur_objfile;
2239 demangle_result_storage storage;
2240 const char *modified_name = demangle_for_lookup (linkage_name, lang, storage);
2242 if (objfile->separate_debug_objfile_backlink)
2243 main_objfile = objfile->separate_debug_objfile_backlink;
2245 main_objfile = objfile;
2247 for (cur_objfile = main_objfile;
2249 cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
2251 struct block_symbol result;
2253 result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
2254 modified_name, domain);
2255 if (result.symbol == NULL)
2256 result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
2257 modified_name, domain);
2258 if (result.symbol != NULL)
2262 return (struct block_symbol) {NULL, NULL};
2265 /* A helper function that throws an exception when a symbol was found
2266 in a psymtab but not in a symtab. */
2268 static void ATTRIBUTE_NORETURN
2269 error_in_psymtab_expansion (int block_index, const char *name,
2270 struct compunit_symtab *cust)
2273 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2274 %s may be an inlined function, or may be a template function\n \
2275 (if a template, try specifying an instantiation: %s<type>)."),
2276 block_index == GLOBAL_BLOCK ? "global" : "static",
2278 symtab_to_filename_for_display (compunit_primary_filetab (cust)),
2282 /* A helper function for various lookup routines that interfaces with
2283 the "quick" symbol table functions. */
2285 static struct block_symbol
2286 lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index,
2287 const char *name, const domain_enum domain)
2289 struct compunit_symtab *cust;
2290 const struct blockvector *bv;
2291 const struct block *block;
2292 struct block_symbol result;
2295 return (struct block_symbol) {NULL, NULL};
2297 if (symbol_lookup_debug > 1)
2299 fprintf_unfiltered (gdb_stdlog,
2300 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2301 objfile_debug_name (objfile),
2302 block_index == GLOBAL_BLOCK
2303 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2304 name, domain_name (domain));
2307 cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, domain);
2310 if (symbol_lookup_debug > 1)
2312 fprintf_unfiltered (gdb_stdlog,
2313 "lookup_symbol_via_quick_fns (...) = NULL\n");
2315 return (struct block_symbol) {NULL, NULL};
2318 bv = COMPUNIT_BLOCKVECTOR (cust);
2319 block = BLOCKVECTOR_BLOCK (bv, block_index);
2320 result.symbol = block_lookup_symbol (block, name, domain);
2321 if (result.symbol == NULL)
2322 error_in_psymtab_expansion (block_index, name, cust);
2324 if (symbol_lookup_debug > 1)
2326 fprintf_unfiltered (gdb_stdlog,
2327 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2328 host_address_to_string (result.symbol),
2329 host_address_to_string (block));
2332 result.symbol = fixup_symbol_section (result.symbol, objfile);
2333 result.block = block;
2340 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
2342 const struct block *block,
2343 const domain_enum domain)
2345 struct block_symbol result;
2347 /* NOTE: carlton/2003-05-19: The comments below were written when
2348 this (or what turned into this) was part of lookup_symbol_aux;
2349 I'm much less worried about these questions now, since these
2350 decisions have turned out well, but I leave these comments here
2353 /* NOTE: carlton/2002-12-05: There is a question as to whether or
2354 not it would be appropriate to search the current global block
2355 here as well. (That's what this code used to do before the
2356 is_a_field_of_this check was moved up.) On the one hand, it's
2357 redundant with the lookup in all objfiles search that happens
2358 next. On the other hand, if decode_line_1 is passed an argument
2359 like filename:var, then the user presumably wants 'var' to be
2360 searched for in filename. On the third hand, there shouldn't be
2361 multiple global variables all of which are named 'var', and it's
2362 not like decode_line_1 has ever restricted its search to only
2363 global variables in a single filename. All in all, only
2364 searching the static block here seems best: it's correct and it's
2367 /* NOTE: carlton/2002-12-05: There's also a possible performance
2368 issue here: if you usually search for global symbols in the
2369 current file, then it would be slightly better to search the
2370 current global block before searching all the symtabs. But there
2371 are other factors that have a much greater effect on performance
2372 than that one, so I don't think we should worry about that for
2375 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2376 the current objfile. Searching the current objfile first is useful
2377 for both matching user expectations as well as performance. */
2379 result = lookup_symbol_in_static_block (name, block, domain);
2380 if (result.symbol != NULL)
2383 /* If we didn't find a definition for a builtin type in the static block,
2384 search for it now. This is actually the right thing to do and can be
2385 a massive performance win. E.g., when debugging a program with lots of
2386 shared libraries we could search all of them only to find out the
2387 builtin type isn't defined in any of them. This is common for types
2389 if (domain == VAR_DOMAIN)
2391 struct gdbarch *gdbarch;
2394 gdbarch = target_gdbarch ();
2396 gdbarch = block_gdbarch (block);
2397 result.symbol = language_lookup_primitive_type_as_symbol (langdef,
2399 result.block = NULL;
2400 if (result.symbol != NULL)
2404 return lookup_global_symbol (name, block, domain);
2410 lookup_symbol_in_static_block (const char *name,
2411 const struct block *block,
2412 const domain_enum domain)
2414 const struct block *static_block = block_static_block (block);
2417 if (static_block == NULL)
2418 return (struct block_symbol) {NULL, NULL};
2420 if (symbol_lookup_debug)
2422 struct objfile *objfile = lookup_objfile_from_block (static_block);
2424 fprintf_unfiltered (gdb_stdlog,
2425 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2428 host_address_to_string (block),
2429 objfile_debug_name (objfile),
2430 domain_name (domain));
2433 sym = lookup_symbol_in_block (name, static_block, domain);
2434 if (symbol_lookup_debug)
2436 fprintf_unfiltered (gdb_stdlog,
2437 "lookup_symbol_in_static_block (...) = %s\n",
2438 sym != NULL ? host_address_to_string (sym) : "NULL");
2440 return (struct block_symbol) {sym, static_block};
2443 /* Perform the standard symbol lookup of NAME in OBJFILE:
2444 1) First search expanded symtabs, and if not found
2445 2) Search the "quick" symtabs (partial or .gdb_index).
2446 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2448 static struct block_symbol
2449 lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
2450 const char *name, const domain_enum domain)
2452 struct block_symbol result;
2454 if (symbol_lookup_debug)
2456 fprintf_unfiltered (gdb_stdlog,
2457 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2458 objfile_debug_name (objfile),
2459 block_index == GLOBAL_BLOCK
2460 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2461 name, domain_name (domain));
2464 result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
2466 if (result.symbol != NULL)
2468 if (symbol_lookup_debug)
2470 fprintf_unfiltered (gdb_stdlog,
2471 "lookup_symbol_in_objfile (...) = %s"
2473 host_address_to_string (result.symbol));
2478 result = lookup_symbol_via_quick_fns (objfile, block_index,
2480 if (symbol_lookup_debug)
2482 fprintf_unfiltered (gdb_stdlog,
2483 "lookup_symbol_in_objfile (...) = %s%s\n",
2484 result.symbol != NULL
2485 ? host_address_to_string (result.symbol)
2487 result.symbol != NULL ? " (via quick fns)" : "");
2495 lookup_static_symbol (const char *name, const domain_enum domain)
2497 struct symbol_cache *cache = get_symbol_cache (current_program_space);
2498 struct objfile *objfile;
2499 struct block_symbol result;
2500 struct block_symbol_cache *bsc;
2501 struct symbol_cache_slot *slot;
2503 /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
2504 NULL for OBJFILE_CONTEXT. */
2505 result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
2507 if (result.symbol != NULL)
2509 if (SYMBOL_LOOKUP_FAILED_P (result))
2510 return (struct block_symbol) {NULL, NULL};
2514 ALL_OBJFILES (objfile)
2516 result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
2517 if (result.symbol != NULL)
2519 /* Still pass NULL for OBJFILE_CONTEXT here. */
2520 symbol_cache_mark_found (bsc, slot, NULL, result.symbol,
2526 /* Still pass NULL for OBJFILE_CONTEXT here. */
2527 symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
2528 return (struct block_symbol) {NULL, NULL};
2531 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2533 struct global_sym_lookup_data
2535 /* The name of the symbol we are searching for. */
2538 /* The domain to use for our search. */
2541 /* The field where the callback should store the symbol if found.
2542 It should be initialized to {NULL, NULL} before the search is started. */
2543 struct block_symbol result;
2546 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2547 It searches by name for a symbol in the GLOBAL_BLOCK of the given
2548 OBJFILE. The arguments for the search are passed via CB_DATA,
2549 which in reality is a pointer to struct global_sym_lookup_data. */
2552 lookup_symbol_global_iterator_cb (struct objfile *objfile,
2555 struct global_sym_lookup_data *data =
2556 (struct global_sym_lookup_data *) cb_data;
2558 gdb_assert (data->result.symbol == NULL
2559 && data->result.block == NULL);
2561 data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
2562 data->name, data->domain);
2564 /* If we found a match, tell the iterator to stop. Otherwise,
2566 return (data->result.symbol != NULL);
2572 lookup_global_symbol (const char *name,
2573 const struct block *block,
2574 const domain_enum domain)
2576 struct symbol_cache *cache = get_symbol_cache (current_program_space);
2577 struct block_symbol result;
2578 struct objfile *objfile;
2579 struct global_sym_lookup_data lookup_data;
2580 struct block_symbol_cache *bsc;
2581 struct symbol_cache_slot *slot;
2583 objfile = lookup_objfile_from_block (block);
2585 /* First see if we can find the symbol in the cache.
2586 This works because we use the current objfile to qualify the lookup. */
2587 result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
2589 if (result.symbol != NULL)
2591 if (SYMBOL_LOOKUP_FAILED_P (result))
2592 return (struct block_symbol) {NULL, NULL};
2596 /* Call library-specific lookup procedure. */
2597 if (objfile != NULL)
2598 result = solib_global_lookup (objfile, name, domain);
2600 /* If that didn't work go a global search (of global blocks, heh). */
2601 if (result.symbol == NULL)
2603 memset (&lookup_data, 0, sizeof (lookup_data));
2604 lookup_data.name = name;
2605 lookup_data.domain = domain;
2606 gdbarch_iterate_over_objfiles_in_search_order
2607 (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
2608 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
2609 result = lookup_data.result;
2612 if (result.symbol != NULL)
2613 symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
2615 symbol_cache_mark_not_found (bsc, slot, objfile, name, domain);
2621 symbol_matches_domain (enum language symbol_language,
2622 domain_enum symbol_domain,
2625 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2626 Similarly, any Ada type declaration implicitly defines a typedef. */
2627 if (symbol_language == language_cplus
2628 || symbol_language == language_d
2629 || symbol_language == language_ada
2630 || symbol_language == language_rust)
2632 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
2633 && symbol_domain == STRUCT_DOMAIN)
2636 /* For all other languages, strict match is required. */
2637 return (symbol_domain == domain);
2643 lookup_transparent_type (const char *name)
2645 return current_language->la_lookup_transparent_type (name);
2648 /* A helper for basic_lookup_transparent_type that interfaces with the
2649 "quick" symbol table functions. */
2651 static struct type *
2652 basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index,
2655 struct compunit_symtab *cust;
2656 const struct blockvector *bv;
2657 struct block *block;
2662 cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name,
2667 bv = COMPUNIT_BLOCKVECTOR (cust);
2668 block = BLOCKVECTOR_BLOCK (bv, block_index);
2669 sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2670 block_find_non_opaque_type, NULL);
2672 error_in_psymtab_expansion (block_index, name, cust);
2673 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2674 return SYMBOL_TYPE (sym);
2677 /* Subroutine of basic_lookup_transparent_type to simplify it.
2678 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2679 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2681 static struct type *
2682 basic_lookup_transparent_type_1 (struct objfile *objfile, int block_index,
2685 const struct compunit_symtab *cust;
2686 const struct blockvector *bv;
2687 const struct block *block;
2688 const struct symbol *sym;
2690 ALL_OBJFILE_COMPUNITS (objfile, cust)
2692 bv = COMPUNIT_BLOCKVECTOR (cust);
2693 block = BLOCKVECTOR_BLOCK (bv, block_index);
2694 sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2695 block_find_non_opaque_type, NULL);
2698 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2699 return SYMBOL_TYPE (sym);
2706 /* The standard implementation of lookup_transparent_type. This code
2707 was modeled on lookup_symbol -- the parts not relevant to looking
2708 up types were just left out. In particular it's assumed here that
2709 types are available in STRUCT_DOMAIN and only in file-static or
2713 basic_lookup_transparent_type (const char *name)
2715 struct objfile *objfile;
2718 /* Now search all the global symbols. Do the symtab's first, then
2719 check the psymtab's. If a psymtab indicates the existence
2720 of the desired name as a global, then do psymtab-to-symtab
2721 conversion on the fly and return the found symbol. */
2723 ALL_OBJFILES (objfile)
2725 t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
2730 ALL_OBJFILES (objfile)
2732 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
2737 /* Now search the static file-level symbols.
2738 Not strictly correct, but more useful than an error.
2739 Do the symtab's first, then
2740 check the psymtab's. If a psymtab indicates the existence
2741 of the desired name as a file-level static, then do psymtab-to-symtab
2742 conversion on the fly and return the found symbol. */
2744 ALL_OBJFILES (objfile)
2746 t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
2751 ALL_OBJFILES (objfile)
2753 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
2758 return (struct type *) 0;
2761 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2763 For each symbol that matches, CALLBACK is called. The symbol is
2764 passed to the callback.
2766 If CALLBACK returns false, the iteration ends. Otherwise, the
2767 search continues. */
2770 iterate_over_symbols (const struct block *block, const char *name,
2771 const domain_enum domain,
2772 gdb::function_view<symbol_found_callback_ftype> callback)
2774 struct block_iterator iter;
2777 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
2779 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2780 SYMBOL_DOMAIN (sym), domain))
2782 if (!callback (sym))
2788 /* Find the compunit symtab associated with PC and SECTION.
2789 This will read in debug info as necessary. */
2791 struct compunit_symtab *
2792 find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
2794 struct compunit_symtab *cust;
2795 struct compunit_symtab *best_cust = NULL;
2796 struct objfile *objfile;
2797 CORE_ADDR distance = 0;
2798 struct bound_minimal_symbol msymbol;
2800 /* If we know that this is not a text address, return failure. This is
2801 necessary because we loop based on the block's high and low code
2802 addresses, which do not include the data ranges, and because
2803 we call find_pc_sect_psymtab which has a similar restriction based
2804 on the partial_symtab's texthigh and textlow. */
2805 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2807 && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
2808 || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
2809 || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
2810 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
2811 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
2814 /* Search all symtabs for the one whose file contains our address, and which
2815 is the smallest of all the ones containing the address. This is designed
2816 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2817 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2818 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2820 This happens for native ecoff format, where code from included files
2821 gets its own symtab. The symtab for the included file should have
2822 been read in already via the dependency mechanism.
2823 It might be swifter to create several symtabs with the same name
2824 like xcoff does (I'm not sure).
2826 It also happens for objfiles that have their functions reordered.
2827 For these, the symtab we are looking for is not necessarily read in. */
2829 ALL_COMPUNITS (objfile, cust)
2832 const struct blockvector *bv;
2834 bv = COMPUNIT_BLOCKVECTOR (cust);
2835 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2837 if (BLOCK_START (b) <= pc
2838 && BLOCK_END (b) > pc
2840 || BLOCK_END (b) - BLOCK_START (b) < distance))
2842 /* For an objfile that has its functions reordered,
2843 find_pc_psymtab will find the proper partial symbol table
2844 and we simply return its corresponding symtab. */
2845 /* In order to better support objfiles that contain both
2846 stabs and coff debugging info, we continue on if a psymtab
2848 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2850 struct compunit_symtab *result;
2853 = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2862 struct block_iterator iter;
2863 struct symbol *sym = NULL;
2865 ALL_BLOCK_SYMBOLS (b, iter, sym)
2867 fixup_symbol_section (sym, objfile);
2868 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, sym),
2873 continue; /* No symbol in this symtab matches
2876 distance = BLOCK_END (b) - BLOCK_START (b);
2881 if (best_cust != NULL)
2884 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2886 ALL_OBJFILES (objfile)
2888 struct compunit_symtab *result;
2892 result = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2903 /* Find the compunit symtab associated with PC.
2904 This will read in debug info as necessary.
2905 Backward compatibility, no section. */
2907 struct compunit_symtab *
2908 find_pc_compunit_symtab (CORE_ADDR pc)
2910 return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc));
2914 /* Find the source file and line number for a given PC value and SECTION.
2915 Return a structure containing a symtab pointer, a line number,
2916 and a pc range for the entire source line.
2917 The value's .pc field is NOT the specified pc.
2918 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2919 use the line that ends there. Otherwise, in that case, the line
2920 that begins there is used. */
2922 /* The big complication here is that a line may start in one file, and end just
2923 before the start of another file. This usually occurs when you #include
2924 code in the middle of a subroutine. To properly find the end of a line's PC
2925 range, we must search all symtabs associated with this compilation unit, and
2926 find the one whose first PC is closer than that of the next line in this
2929 /* If it's worth the effort, we could be using a binary search. */
2931 struct symtab_and_line
2932 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
2934 struct compunit_symtab *cust;
2935 struct symtab *iter_s;
2936 struct linetable *l;
2939 struct linetable_entry *item;
2940 const struct blockvector *bv;
2941 struct bound_minimal_symbol msymbol;
2943 /* Info on best line seen so far, and where it starts, and its file. */
2945 struct linetable_entry *best = NULL;
2946 CORE_ADDR best_end = 0;
2947 struct symtab *best_symtab = 0;
2949 /* Store here the first line number
2950 of a file which contains the line at the smallest pc after PC.
2951 If we don't find a line whose range contains PC,
2952 we will use a line one less than this,
2953 with a range from the start of that file to the first line's pc. */
2954 struct linetable_entry *alt = NULL;
2956 /* Info on best line seen in this file. */
2958 struct linetable_entry *prev;
2960 /* If this pc is not from the current frame,
2961 it is the address of the end of a call instruction.
2962 Quite likely that is the start of the following statement.
2963 But what we want is the statement containing the instruction.
2964 Fudge the pc to make sure we get that. */
2966 /* It's tempting to assume that, if we can't find debugging info for
2967 any function enclosing PC, that we shouldn't search for line
2968 number info, either. However, GAS can emit line number info for
2969 assembly files --- very helpful when debugging hand-written
2970 assembly code. In such a case, we'd have no debug info for the
2971 function, but we would have line info. */
2976 /* elz: added this because this function returned the wrong
2977 information if the pc belongs to a stub (import/export)
2978 to call a shlib function. This stub would be anywhere between
2979 two functions in the target, and the line info was erroneously
2980 taken to be the one of the line before the pc. */
2982 /* RT: Further explanation:
2984 * We have stubs (trampolines) inserted between procedures.
2986 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2987 * exists in the main image.
2989 * In the minimal symbol table, we have a bunch of symbols
2990 * sorted by start address. The stubs are marked as "trampoline",
2991 * the others appear as text. E.g.:
2993 * Minimal symbol table for main image
2994 * main: code for main (text symbol)
2995 * shr1: stub (trampoline symbol)
2996 * foo: code for foo (text symbol)
2998 * Minimal symbol table for "shr1" image:
3000 * shr1: code for shr1 (text symbol)
3003 * So the code below is trying to detect if we are in the stub
3004 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3005 * and if found, do the symbolization from the real-code address
3006 * rather than the stub address.
3008 * Assumptions being made about the minimal symbol table:
3009 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3010 * if we're really in the trampoline.s If we're beyond it (say
3011 * we're in "foo" in the above example), it'll have a closer
3012 * symbol (the "foo" text symbol for example) and will not
3013 * return the trampoline.
3014 * 2. lookup_minimal_symbol_text() will find a real text symbol
3015 * corresponding to the trampoline, and whose address will
3016 * be different than the trampoline address. I put in a sanity
3017 * check for the address being the same, to avoid an
3018 * infinite recursion.
3020 msymbol = lookup_minimal_symbol_by_pc (pc);
3021 if (msymbol.minsym != NULL)
3022 if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
3024 struct bound_minimal_symbol mfunsym
3025 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
3028 if (mfunsym.minsym == NULL)
3029 /* I eliminated this warning since it is coming out
3030 * in the following situation:
3031 * gdb shmain // test program with shared libraries
3032 * (gdb) break shr1 // function in shared lib
3033 * Warning: In stub for ...
3034 * In the above situation, the shared lib is not loaded yet,
3035 * so of course we can't find the real func/line info,
3036 * but the "break" still works, and the warning is annoying.
3037 * So I commented out the warning. RT */
3038 /* warning ("In stub for %s; unable to find real function/line info",
3039 SYMBOL_LINKAGE_NAME (msymbol)); */
3042 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym)
3043 == BMSYMBOL_VALUE_ADDRESS (msymbol))
3044 /* Avoid infinite recursion */
3045 /* See above comment about why warning is commented out. */
3046 /* warning ("In stub for %s; unable to find real function/line info",
3047 SYMBOL_LINKAGE_NAME (msymbol)); */
3051 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym), 0);
3054 symtab_and_line val;
3055 val.pspace = current_program_space;
3057 cust = find_pc_sect_compunit_symtab (pc, section);
3060 /* If no symbol information, return previous pc. */
3067 bv = COMPUNIT_BLOCKVECTOR (cust);
3069 /* Look at all the symtabs that share this blockvector.
3070 They all have the same apriori range, that we found was right;
3071 but they have different line tables. */
3073 ALL_COMPUNIT_FILETABS (cust, iter_s)
3075 /* Find the best line in this symtab. */
3076 l = SYMTAB_LINETABLE (iter_s);
3082 /* I think len can be zero if the symtab lacks line numbers
3083 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3084 I'm not sure which, and maybe it depends on the symbol
3090 item = l->item; /* Get first line info. */
3092 /* Is this file's first line closer than the first lines of other files?
3093 If so, record this file, and its first line, as best alternate. */
3094 if (item->pc > pc && (!alt || item->pc < alt->pc))
3097 for (i = 0; i < len; i++, item++)
3099 /* Leave prev pointing to the linetable entry for the last line
3100 that started at or before PC. */
3107 /* At this point, prev points at the line whose start addr is <= pc, and
3108 item points at the next line. If we ran off the end of the linetable
3109 (pc >= start of the last line), then prev == item. If pc < start of
3110 the first line, prev will not be set. */
3112 /* Is this file's best line closer than the best in the other files?
3113 If so, record this file, and its best line, as best so far. Don't
3114 save prev if it represents the end of a function (i.e. line number
3115 0) instead of a real line. */
3117 if (prev && prev->line && (!best || prev->pc > best->pc))
3120 best_symtab = iter_s;
3122 /* Discard BEST_END if it's before the PC of the current BEST. */
3123 if (best_end <= best->pc)
3127 /* If another line (denoted by ITEM) is in the linetable and its
3128 PC is after BEST's PC, but before the current BEST_END, then
3129 use ITEM's PC as the new best_end. */
3130 if (best && i < len && item->pc > best->pc
3131 && (best_end == 0 || best_end > item->pc))
3132 best_end = item->pc;
3137 /* If we didn't find any line number info, just return zeros.
3138 We used to return alt->line - 1 here, but that could be
3139 anywhere; if we don't have line number info for this PC,
3140 don't make some up. */
3143 else if (best->line == 0)
3145 /* If our best fit is in a range of PC's for which no line
3146 number info is available (line number is zero) then we didn't
3147 find any valid line information. */
3152 val.symtab = best_symtab;
3153 val.line = best->line;
3155 if (best_end && (!alt || best_end < alt->pc))
3160 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
3162 val.section = section;
3166 /* Backward compatibility (no section). */
3168 struct symtab_and_line
3169 find_pc_line (CORE_ADDR pc, int notcurrent)
3171 struct obj_section *section;
3173 section = find_pc_overlay (pc);
3174 if (pc_in_unmapped_range (pc, section))
3175 pc = overlay_mapped_address (pc, section);
3176 return find_pc_sect_line (pc, section, notcurrent);
3182 find_pc_line_symtab (CORE_ADDR pc)
3184 struct symtab_and_line sal;
3186 /* This always passes zero for NOTCURRENT to find_pc_line.
3187 There are currently no callers that ever pass non-zero. */
3188 sal = find_pc_line (pc, 0);
3192 /* Find line number LINE in any symtab whose name is the same as
3195 If found, return the symtab that contains the linetable in which it was
3196 found, set *INDEX to the index in the linetable of the best entry
3197 found, and set *EXACT_MATCH nonzero if the value returned is an
3200 If not found, return NULL. */
3203 find_line_symtab (struct symtab *symtab, int line,
3204 int *index, int *exact_match)
3206 int exact = 0; /* Initialized here to avoid a compiler warning. */
3208 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3212 struct linetable *best_linetable;
3213 struct symtab *best_symtab;
3215 /* First try looking it up in the given symtab. */
3216 best_linetable = SYMTAB_LINETABLE (symtab);
3217 best_symtab = symtab;
3218 best_index = find_line_common (best_linetable, line, &exact, 0);
3219 if (best_index < 0 || !exact)
3221 /* Didn't find an exact match. So we better keep looking for
3222 another symtab with the same name. In the case of xcoff,
3223 multiple csects for one source file (produced by IBM's FORTRAN
3224 compiler) produce multiple symtabs (this is unavoidable
3225 assuming csects can be at arbitrary places in memory and that
3226 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3228 /* BEST is the smallest linenumber > LINE so far seen,
3229 or 0 if none has been seen so far.
3230 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3233 struct objfile *objfile;
3234 struct compunit_symtab *cu;
3237 if (best_index >= 0)
3238 best = best_linetable->item[best_index].line;
3242 ALL_OBJFILES (objfile)
3245 objfile->sf->qf->expand_symtabs_with_fullname (objfile,
3246 symtab_to_fullname (symtab));
3249 ALL_FILETABS (objfile, cu, s)
3251 struct linetable *l;
3254 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
3256 if (FILENAME_CMP (symtab_to_fullname (symtab),
3257 symtab_to_fullname (s)) != 0)
3259 l = SYMTAB_LINETABLE (s);
3260 ind = find_line_common (l, line, &exact, 0);
3270 if (best == 0 || l->item[ind].line < best)
3272 best = l->item[ind].line;
3285 *index = best_index;
3287 *exact_match = exact;
3292 /* Given SYMTAB, returns all the PCs function in the symtab that
3293 exactly match LINE. Returns an empty vector if there are no exact
3294 matches, but updates BEST_ITEM in this case. */
3296 std::vector<CORE_ADDR>
3297 find_pcs_for_symtab_line (struct symtab *symtab, int line,
3298 struct linetable_entry **best_item)
3301 std::vector<CORE_ADDR> result;
3303 /* First, collect all the PCs that are at this line. */
3309 idx = find_line_common (SYMTAB_LINETABLE (symtab), line, &was_exact,
3316 struct linetable_entry *item = &SYMTAB_LINETABLE (symtab)->item[idx];
3318 if (*best_item == NULL || item->line < (*best_item)->line)
3324 result.push_back (SYMTAB_LINETABLE (symtab)->item[idx].pc);
3332 /* Set the PC value for a given source file and line number and return true.
3333 Returns zero for invalid line number (and sets the PC to 0).
3334 The source file is specified with a struct symtab. */
3337 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
3339 struct linetable *l;
3346 symtab = find_line_symtab (symtab, line, &ind, NULL);
3349 l = SYMTAB_LINETABLE (symtab);
3350 *pc = l->item[ind].pc;
3357 /* Find the range of pc values in a line.
3358 Store the starting pc of the line into *STARTPTR
3359 and the ending pc (start of next line) into *ENDPTR.
3360 Returns 1 to indicate success.
3361 Returns 0 if could not find the specified line. */
3364 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
3367 CORE_ADDR startaddr;
3368 struct symtab_and_line found_sal;
3371 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
3374 /* This whole function is based on address. For example, if line 10 has
3375 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3376 "info line *0x123" should say the line goes from 0x100 to 0x200
3377 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3378 This also insures that we never give a range like "starts at 0x134
3379 and ends at 0x12c". */
3381 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
3382 if (found_sal.line != sal.line)
3384 /* The specified line (sal) has zero bytes. */
3385 *startptr = found_sal.pc;
3386 *endptr = found_sal.pc;
3390 *startptr = found_sal.pc;
3391 *endptr = found_sal.end;
3396 /* Given a line table and a line number, return the index into the line
3397 table for the pc of the nearest line whose number is >= the specified one.
3398 Return -1 if none is found. The value is >= 0 if it is an index.
3399 START is the index at which to start searching the line table.
3401 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3404 find_line_common (struct linetable *l, int lineno,
3405 int *exact_match, int start)
3410 /* BEST is the smallest linenumber > LINENO so far seen,
3411 or 0 if none has been seen so far.
3412 BEST_INDEX identifies the item for it. */
3414 int best_index = -1;
3425 for (i = start; i < len; i++)
3427 struct linetable_entry *item = &(l->item[i]);
3429 if (item->line == lineno)
3431 /* Return the first (lowest address) entry which matches. */
3436 if (item->line > lineno && (best == 0 || item->line < best))
3443 /* If we got here, we didn't get an exact match. */
3448 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
3450 struct symtab_and_line sal;
3452 sal = find_pc_line (pc, 0);
3455 return sal.symtab != 0;
3458 /* Given a function symbol SYM, find the symtab and line for the start
3460 If the argument FUNFIRSTLINE is nonzero, we want the first line
3461 of real code inside the function.
3462 This function should return SALs matching those from minsym_found,
3463 otherwise false multiple-locations breakpoints could be placed. */
3465 struct symtab_and_line
3466 find_function_start_sal (struct symbol *sym, int funfirstline)
3468 fixup_symbol_section (sym, NULL);
3470 obj_section *section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
3472 = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
3475 if (funfirstline && sal.symtab != NULL
3476 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
3477 || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
3479 struct gdbarch *gdbarch = symbol_arch (sym);
3481 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3482 if (gdbarch_skip_entrypoint_p (gdbarch))
3483 sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
3487 /* We always should have a line for the function start address.
3488 If we don't, something is odd. Create a plain SAL refering
3489 just the PC and hope that skip_prologue_sal (if requested)
3490 can find a line number for after the prologue. */
3491 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
3494 sal.pspace = current_program_space;
3495 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3496 sal.section = section;
3501 skip_prologue_sal (&sal);
3506 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3507 address for that function that has an entry in SYMTAB's line info
3508 table. If such an entry cannot be found, return FUNC_ADDR
3512 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
3514 CORE_ADDR func_start, func_end;
3515 struct linetable *l;
3518 /* Give up if this symbol has no lineinfo table. */
3519 l = SYMTAB_LINETABLE (symtab);
3523 /* Get the range for the function's PC values, or give up if we
3524 cannot, for some reason. */
3525 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
3528 /* Linetable entries are ordered by PC values, see the commentary in
3529 symtab.h where `struct linetable' is defined. Thus, the first
3530 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3531 address we are looking for. */
3532 for (i = 0; i < l->nitems; i++)
3534 struct linetable_entry *item = &(l->item[i]);
3536 /* Don't use line numbers of zero, they mark special entries in
3537 the table. See the commentary on symtab.h before the
3538 definition of struct linetable. */
3539 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
3546 /* Adjust SAL to the first instruction past the function prologue.
3547 If the PC was explicitly specified, the SAL is not changed.
3548 If the line number was explicitly specified, at most the SAL's PC
3549 is updated. If SAL is already past the prologue, then do nothing. */
3552 skip_prologue_sal (struct symtab_and_line *sal)
3555 struct symtab_and_line start_sal;
3556 CORE_ADDR pc, saved_pc;
3557 struct obj_section *section;
3559 struct objfile *objfile;
3560 struct gdbarch *gdbarch;
3561 const struct block *b, *function_block;
3562 int force_skip, skip;
3564 /* Do not change the SAL if PC was specified explicitly. */
3565 if (sal->explicit_pc)
3568 scoped_restore_current_pspace_and_thread restore_pspace_thread;
3570 switch_to_program_space_and_thread (sal->pspace);
3572 sym = find_pc_sect_function (sal->pc, sal->section);
3575 fixup_symbol_section (sym, NULL);
3577 objfile = symbol_objfile (sym);
3578 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3579 section = SYMBOL_OBJ_SECTION (objfile, sym);
3580 name = SYMBOL_LINKAGE_NAME (sym);
3584 struct bound_minimal_symbol msymbol
3585 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
3587 if (msymbol.minsym == NULL)
3590 objfile = msymbol.objfile;
3591 pc = BMSYMBOL_VALUE_ADDRESS (msymbol);
3592 section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
3593 name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
3596 gdbarch = get_objfile_arch (objfile);
3598 /* Process the prologue in two passes. In the first pass try to skip the
3599 prologue (SKIP is true) and verify there is a real need for it (indicated
3600 by FORCE_SKIP). If no such reason was found run a second pass where the
3601 prologue is not skipped (SKIP is false). */
3606 /* Be conservative - allow direct PC (without skipping prologue) only if we
3607 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3608 have to be set by the caller so we use SYM instead. */
3610 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym))))
3618 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3619 so that gdbarch_skip_prologue has something unique to work on. */
3620 if (section_is_overlay (section) && !section_is_mapped (section))
3621 pc = overlay_unmapped_address (pc, section);
3623 /* Skip "first line" of function (which is actually its prologue). */
3624 pc += gdbarch_deprecated_function_start_offset (gdbarch);
3625 if (gdbarch_skip_entrypoint_p (gdbarch))
3626 pc = gdbarch_skip_entrypoint (gdbarch, pc);
3628 pc = gdbarch_skip_prologue_noexcept (gdbarch, pc);
3630 /* For overlays, map pc back into its mapped VMA range. */
3631 pc = overlay_mapped_address (pc, section);
3633 /* Calculate line number. */
3634 start_sal = find_pc_sect_line (pc, section, 0);
3636 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3637 line is still part of the same function. */
3638 if (skip && start_sal.pc != pc
3639 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
3640 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
3641 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
3642 == lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
3644 /* First pc of next line */
3646 /* Recalculate the line number (might not be N+1). */
3647 start_sal = find_pc_sect_line (pc, section, 0);
3650 /* On targets with executable formats that don't have a concept of
3651 constructors (ELF with .init has, PE doesn't), gcc emits a call
3652 to `__main' in `main' between the prologue and before user
3654 if (gdbarch_skip_main_prologue_p (gdbarch)
3655 && name && strcmp_iw (name, "main") == 0)
3657 pc = gdbarch_skip_main_prologue (gdbarch, pc);
3658 /* Recalculate the line number (might not be N+1). */
3659 start_sal = find_pc_sect_line (pc, section, 0);
3663 while (!force_skip && skip--);
3665 /* If we still don't have a valid source line, try to find the first
3666 PC in the lineinfo table that belongs to the same function. This
3667 happens with COFF debug info, which does not seem to have an
3668 entry in lineinfo table for the code after the prologue which has
3669 no direct relation to source. For example, this was found to be
3670 the case with the DJGPP target using "gcc -gcoff" when the
3671 compiler inserted code after the prologue to make sure the stack
3673 if (!force_skip && sym && start_sal.symtab == NULL)
3675 pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
3676 /* Recalculate the line number. */
3677 start_sal = find_pc_sect_line (pc, section, 0);
3680 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3681 forward SAL to the end of the prologue. */
3686 sal->section = section;
3688 /* Unless the explicit_line flag was set, update the SAL line
3689 and symtab to correspond to the modified PC location. */
3690 if (sal->explicit_line)
3693 sal->symtab = start_sal.symtab;
3694 sal->line = start_sal.line;
3695 sal->end = start_sal.end;
3697 /* Check if we are now inside an inlined function. If we can,
3698 use the call site of the function instead. */
3699 b = block_for_pc_sect (sal->pc, sal->section);
3700 function_block = NULL;
3703 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
3705 else if (BLOCK_FUNCTION (b) != NULL)
3707 b = BLOCK_SUPERBLOCK (b);
3709 if (function_block != NULL
3710 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
3712 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
3713 sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
3717 /* Given PC at the function's start address, attempt to find the
3718 prologue end using SAL information. Return zero if the skip fails.
3720 A non-optimized prologue traditionally has one SAL for the function
3721 and a second for the function body. A single line function has
3722 them both pointing at the same line.
3724 An optimized prologue is similar but the prologue may contain
3725 instructions (SALs) from the instruction body. Need to skip those
3726 while not getting into the function body.
3728 The functions end point and an increasing SAL line are used as
3729 indicators of the prologue's endpoint.
3731 This code is based on the function refine_prologue_limit
3735 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
3737 struct symtab_and_line prologue_sal;
3740 const struct block *bl;
3742 /* Get an initial range for the function. */
3743 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
3744 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
3746 prologue_sal = find_pc_line (start_pc, 0);
3747 if (prologue_sal.line != 0)
3749 /* For languages other than assembly, treat two consecutive line
3750 entries at the same address as a zero-instruction prologue.
3751 The GNU assembler emits separate line notes for each instruction
3752 in a multi-instruction macro, but compilers generally will not
3754 if (prologue_sal.symtab->language != language_asm)
3756 struct linetable *linetable = SYMTAB_LINETABLE (prologue_sal.symtab);
3759 /* Skip any earlier lines, and any end-of-sequence marker
3760 from a previous function. */
3761 while (linetable->item[idx].pc != prologue_sal.pc
3762 || linetable->item[idx].line == 0)
3765 if (idx+1 < linetable->nitems
3766 && linetable->item[idx+1].line != 0
3767 && linetable->item[idx+1].pc == start_pc)
3771 /* If there is only one sal that covers the entire function,
3772 then it is probably a single line function, like
3774 if (prologue_sal.end >= end_pc)
3777 while (prologue_sal.end < end_pc)
3779 struct symtab_and_line sal;
3781 sal = find_pc_line (prologue_sal.end, 0);
3784 /* Assume that a consecutive SAL for the same (or larger)
3785 line mark the prologue -> body transition. */
3786 if (sal.line >= prologue_sal.line)
3788 /* Likewise if we are in a different symtab altogether
3789 (e.g. within a file included via #include). */
3790 if (sal.symtab != prologue_sal.symtab)
3793 /* The line number is smaller. Check that it's from the
3794 same function, not something inlined. If it's inlined,
3795 then there is no point comparing the line numbers. */
3796 bl = block_for_pc (prologue_sal.end);
3799 if (block_inlined_p (bl))
3801 if (BLOCK_FUNCTION (bl))
3806 bl = BLOCK_SUPERBLOCK (bl);
3811 /* The case in which compiler's optimizer/scheduler has
3812 moved instructions into the prologue. We look ahead in
3813 the function looking for address ranges whose
3814 corresponding line number is less the first one that we
3815 found for the function. This is more conservative then
3816 refine_prologue_limit which scans a large number of SALs
3817 looking for any in the prologue. */
3822 if (prologue_sal.end < end_pc)
3823 /* Return the end of this line, or zero if we could not find a
3825 return prologue_sal.end;
3827 /* Don't return END_PC, which is past the end of the function. */
3828 return prologue_sal.pc;
3834 find_function_alias_target (bound_minimal_symbol msymbol)
3836 if (!msymbol_is_text (msymbol.minsym))
3839 CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
3840 symbol *sym = find_pc_function (addr);
3842 && SYMBOL_CLASS (sym) == LOC_BLOCK
3843 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == addr)
3850 /* If P is of the form "operator[ \t]+..." where `...' is
3851 some legitimate operator text, return a pointer to the
3852 beginning of the substring of the operator text.
3853 Otherwise, return "". */
3856 operator_chars (const char *p, const char **end)
3859 if (!startswith (p, CP_OPERATOR_STR))
3861 p += CP_OPERATOR_LEN;
3863 /* Don't get faked out by `operator' being part of a longer
3865 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
3868 /* Allow some whitespace between `operator' and the operator symbol. */
3869 while (*p == ' ' || *p == '\t')
3872 /* Recognize 'operator TYPENAME'. */
3874 if (isalpha (*p) || *p == '_' || *p == '$')
3876 const char *q = p + 1;
3878 while (isalnum (*q) || *q == '_' || *q == '$')
3887 case '\\': /* regexp quoting */
3890 if (p[2] == '=') /* 'operator\*=' */
3892 else /* 'operator\*' */
3896 else if (p[1] == '[')
3899 error (_("mismatched quoting on brackets, "
3900 "try 'operator\\[\\]'"));
3901 else if (p[2] == '\\' && p[3] == ']')
3903 *end = p + 4; /* 'operator\[\]' */
3907 error (_("nothing is allowed between '[' and ']'"));
3911 /* Gratuitous qoute: skip it and move on. */
3933 if (p[0] == '-' && p[1] == '>')
3935 /* Struct pointer member operator 'operator->'. */
3938 *end = p + 3; /* 'operator->*' */
3941 else if (p[2] == '\\')
3943 *end = p + 4; /* Hopefully 'operator->\*' */
3948 *end = p + 2; /* 'operator->' */
3952 if (p[1] == '=' || p[1] == p[0])
3963 error (_("`operator ()' must be specified "
3964 "without whitespace in `()'"));
3969 error (_("`operator ?:' must be specified "
3970 "without whitespace in `?:'"));
3975 error (_("`operator []' must be specified "
3976 "without whitespace in `[]'"));
3980 error (_("`operator %s' not supported"), p);
3989 /* Data structure to maintain printing state for output_source_filename. */
3991 struct output_source_filename_data
3993 /* Cache of what we've seen so far. */
3994 struct filename_seen_cache *filename_seen_cache;
3996 /* Flag of whether we're printing the first one. */
4000 /* Slave routine for sources_info. Force line breaks at ,'s.
4001 NAME is the name to print.
4002 DATA contains the state for printing and watching for duplicates. */
4005 output_source_filename (const char *name,
4006 struct output_source_filename_data *data)
4008 /* Since a single source file can result in several partial symbol
4009 tables, we need to avoid printing it more than once. Note: if
4010 some of the psymtabs are read in and some are not, it gets
4011 printed both under "Source files for which symbols have been
4012 read" and "Source files for which symbols will be read in on
4013 demand". I consider this a reasonable way to deal with the
4014 situation. I'm not sure whether this can also happen for
4015 symtabs; it doesn't hurt to check. */
4017 /* Was NAME already seen? */
4018 if (data->filename_seen_cache->seen (name))
4020 /* Yes; don't print it again. */
4024 /* No; print it and reset *FIRST. */
4026 printf_filtered (", ");
4030 fputs_filtered (name, gdb_stdout);
4033 /* A callback for map_partial_symbol_filenames. */
4036 output_partial_symbol_filename (const char *filename, const char *fullname,
4039 output_source_filename (fullname ? fullname : filename,
4040 (struct output_source_filename_data *) data);
4044 info_sources_command (const char *ignore, int from_tty)
4046 struct compunit_symtab *cu;
4048 struct objfile *objfile;
4049 struct output_source_filename_data data;
4051 if (!have_full_symbols () && !have_partial_symbols ())
4053 error (_("No symbol table is loaded. Use the \"file\" command."));
4056 filename_seen_cache filenames_seen;
4058 data.filename_seen_cache = &filenames_seen;
4060 printf_filtered ("Source files for which symbols have been read in:\n\n");
4063 ALL_FILETABS (objfile, cu, s)
4065 const char *fullname = symtab_to_fullname (s);
4067 output_source_filename (fullname, &data);
4069 printf_filtered ("\n\n");
4071 printf_filtered ("Source files for which symbols "
4072 "will be read in on demand:\n\n");
4074 filenames_seen.clear ();
4076 map_symbol_filenames (output_partial_symbol_filename, &data,
4077 1 /*need_fullname*/);
4078 printf_filtered ("\n");
4081 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4082 non-zero compare only lbasename of FILES. */
4085 file_matches (const char *file, const char *files[], int nfiles, int basenames)
4089 if (file != NULL && nfiles != 0)
4091 for (i = 0; i < nfiles; i++)
4093 if (compare_filenames_for_search (file, (basenames
4094 ? lbasename (files[i])
4099 else if (nfiles == 0)
4104 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4105 sort symbols, not minimal symbols. */
4108 symbol_search::compare_search_syms (const symbol_search &sym_a,
4109 const symbol_search &sym_b)
4113 c = FILENAME_CMP (symbol_symtab (sym_a.symbol)->filename,
4114 symbol_symtab (sym_b.symbol)->filename);
4118 if (sym_a.block != sym_b.block)
4119 return sym_a.block - sym_b.block;
4121 return strcmp (SYMBOL_PRINT_NAME (sym_a.symbol),
4122 SYMBOL_PRINT_NAME (sym_b.symbol));
4125 /* Sort the symbols in RESULT and remove duplicates. */
4128 sort_search_symbols_remove_dups (std::vector<symbol_search> *result)
4130 std::sort (result->begin (), result->end ());
4131 result->erase (std::unique (result->begin (), result->end ()),
4135 /* Search the symbol table for matches to the regular expression REGEXP,
4136 returning the results.
4138 Only symbols of KIND are searched:
4139 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4140 and constants (enums)
4141 FUNCTIONS_DOMAIN - search all functions
4142 TYPES_DOMAIN - search all type names
4143 ALL_DOMAIN - an internal error for this function
4145 Within each file the results are sorted locally; each symtab's global and
4146 static blocks are separately alphabetized.
4147 Duplicate entries are removed. */
4149 std::vector<symbol_search>
4150 search_symbols (const char *regexp, enum search_domain kind,
4151 int nfiles, const char *files[])
4153 struct compunit_symtab *cust;
4154 const struct blockvector *bv;
4157 struct block_iterator iter;
4159 struct objfile *objfile;
4160 struct minimal_symbol *msymbol;
4162 static const enum minimal_symbol_type types[]
4163 = {mst_data, mst_text, mst_abs};
4164 static const enum minimal_symbol_type types2[]
4165 = {mst_bss, mst_file_text, mst_abs};
4166 static const enum minimal_symbol_type types3[]
4167 = {mst_file_data, mst_solib_trampoline, mst_abs};
4168 static const enum minimal_symbol_type types4[]
4169 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
4170 enum minimal_symbol_type ourtype;
4171 enum minimal_symbol_type ourtype2;
4172 enum minimal_symbol_type ourtype3;
4173 enum minimal_symbol_type ourtype4;
4174 std::vector<symbol_search> result;
4175 gdb::optional<compiled_regex> preg;
4177 gdb_assert (kind <= TYPES_DOMAIN);
4179 ourtype = types[kind];
4180 ourtype2 = types2[kind];
4181 ourtype3 = types3[kind];
4182 ourtype4 = types4[kind];
4186 /* Make sure spacing is right for C++ operators.
4187 This is just a courtesy to make the matching less sensitive
4188 to how many spaces the user leaves between 'operator'
4189 and <TYPENAME> or <OPERATOR>. */
4191 const char *opname = operator_chars (regexp, &opend);
4196 int fix = -1; /* -1 means ok; otherwise number of
4199 if (isalpha (*opname) || *opname == '_' || *opname == '$')
4201 /* There should 1 space between 'operator' and 'TYPENAME'. */
4202 if (opname[-1] != ' ' || opname[-2] == ' ')
4207 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4208 if (opname[-1] == ' ')
4211 /* If wrong number of spaces, fix it. */
4214 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
4216 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
4221 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
4223 preg.emplace (regexp, cflags, _("Invalid regexp"));
4226 /* Search through the partial symtabs *first* for all symbols
4227 matching the regexp. That way we don't have to reproduce all of
4228 the machinery below. */
4229 expand_symtabs_matching ([&] (const char *filename, bool basenames)
4231 return file_matches (filename, files, nfiles,
4234 [&] (const char *symname)
4236 return (!preg || preg->exec (symname,
4242 /* Here, we search through the minimal symbol tables for functions
4243 and variables that match, and force their symbols to be read.
4244 This is in particular necessary for demangled variable names,
4245 which are no longer put into the partial symbol tables.
4246 The symbol will then be found during the scan of symtabs below.
4248 For functions, find_pc_symtab should succeed if we have debug info
4249 for the function, for variables we have to call
4250 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4252 If the lookup fails, set found_misc so that we will rescan to print
4253 any matching symbols without debug info.
4254 We only search the objfile the msymbol came from, we no longer search
4255 all objfiles. In large programs (1000s of shared libs) searching all
4256 objfiles is not worth the pain. */
4258 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
4260 ALL_MSYMBOLS (objfile, msymbol)
4264 if (msymbol->created_by_gdb)
4267 if (MSYMBOL_TYPE (msymbol) == ourtype
4268 || MSYMBOL_TYPE (msymbol) == ourtype2
4269 || MSYMBOL_TYPE (msymbol) == ourtype3
4270 || MSYMBOL_TYPE (msymbol) == ourtype4)
4273 || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
4276 /* Note: An important side-effect of these lookup functions
4277 is to expand the symbol table if msymbol is found, for the
4278 benefit of the next loop on ALL_COMPUNITS. */
4279 if (kind == FUNCTIONS_DOMAIN
4280 ? (find_pc_compunit_symtab
4281 (MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL)
4282 : (lookup_symbol_in_objfile_from_linkage_name
4283 (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
4291 ALL_COMPUNITS (objfile, cust)
4293 bv = COMPUNIT_BLOCKVECTOR (cust);
4294 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
4296 b = BLOCKVECTOR_BLOCK (bv, i);
4297 ALL_BLOCK_SYMBOLS (b, iter, sym)
4299 struct symtab *real_symtab = symbol_symtab (sym);
4303 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
4304 a substring of symtab_to_fullname as it may contain "./" etc. */
4305 if ((file_matches (real_symtab->filename, files, nfiles, 0)
4306 || ((basenames_may_differ
4307 || file_matches (lbasename (real_symtab->filename),
4309 && file_matches (symtab_to_fullname (real_symtab),
4312 || preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
4314 && ((kind == VARIABLES_DOMAIN
4315 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
4316 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
4317 && SYMBOL_CLASS (sym) != LOC_BLOCK
4318 /* LOC_CONST can be used for more than just enums,
4319 e.g., c++ static const members.
4320 We only want to skip enums here. */
4321 && !(SYMBOL_CLASS (sym) == LOC_CONST
4322 && (TYPE_CODE (SYMBOL_TYPE (sym))
4323 == TYPE_CODE_ENUM)))
4324 || (kind == FUNCTIONS_DOMAIN
4325 && SYMBOL_CLASS (sym) == LOC_BLOCK)
4326 || (kind == TYPES_DOMAIN
4327 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
4330 result.emplace_back (i, sym);
4336 if (!result.empty ())
4337 sort_search_symbols_remove_dups (&result);
4339 /* If there are no eyes, avoid all contact. I mean, if there are
4340 no debug symbols, then add matching minsyms. */
4342 if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
4344 ALL_MSYMBOLS (objfile, msymbol)
4348 if (msymbol->created_by_gdb)
4351 if (MSYMBOL_TYPE (msymbol) == ourtype
4352 || MSYMBOL_TYPE (msymbol) == ourtype2
4353 || MSYMBOL_TYPE (msymbol) == ourtype3
4354 || MSYMBOL_TYPE (msymbol) == ourtype4)
4356 if (!preg || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
4359 /* For functions we can do a quick check of whether the
4360 symbol might be found via find_pc_symtab. */
4361 if (kind != FUNCTIONS_DOMAIN
4362 || (find_pc_compunit_symtab
4363 (MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL))
4365 if (lookup_symbol_in_objfile_from_linkage_name
4366 (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
4370 result.emplace_back (i, msymbol, objfile);
4381 /* Helper function for symtab_symbol_info, this function uses
4382 the data returned from search_symbols() to print information
4383 regarding the match to gdb_stdout. */
4386 print_symbol_info (enum search_domain kind,
4388 int block, const char *last)
4390 struct symtab *s = symbol_symtab (sym);
4391 const char *s_filename = symtab_to_filename_for_display (s);
4393 if (last == NULL || filename_cmp (last, s_filename) != 0)
4395 fputs_filtered ("\nFile ", gdb_stdout);
4396 fputs_filtered (s_filename, gdb_stdout);
4397 fputs_filtered (":\n", gdb_stdout);
4400 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
4401 printf_filtered ("static ");
4403 /* Typedef that is not a C++ class. */
4404 if (kind == TYPES_DOMAIN
4405 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
4406 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
4407 /* variable, func, or typedef-that-is-c++-class. */
4408 else if (kind < TYPES_DOMAIN
4409 || (kind == TYPES_DOMAIN
4410 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
4412 type_print (SYMBOL_TYPE (sym),
4413 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4414 ? "" : SYMBOL_PRINT_NAME (sym)),
4417 printf_filtered (";\n");
4421 /* This help function for symtab_symbol_info() prints information
4422 for non-debugging symbols to gdb_stdout. */
4425 print_msymbol_info (struct bound_minimal_symbol msymbol)
4427 struct gdbarch *gdbarch = get_objfile_arch (msymbol.objfile);
4430 if (gdbarch_addr_bit (gdbarch) <= 32)
4431 tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol)
4432 & (CORE_ADDR) 0xffffffff,
4435 tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol),
4437 printf_filtered ("%s %s\n",
4438 tmp, MSYMBOL_PRINT_NAME (msymbol.minsym));
4441 /* This is the guts of the commands "info functions", "info types", and
4442 "info variables". It calls search_symbols to find all matches and then
4443 print_[m]symbol_info to print out some useful information about the
4447 symtab_symbol_info (const char *regexp, enum search_domain kind, int from_tty)
4449 static const char * const classnames[] =
4450 {"variable", "function", "type"};
4451 const char *last_filename = NULL;
4454 gdb_assert (kind <= TYPES_DOMAIN);
4456 /* Must make sure that if we're interrupted, symbols gets freed. */
4457 std::vector<symbol_search> symbols = search_symbols (regexp, kind, 0, NULL);
4460 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4461 classnames[kind], regexp);
4463 printf_filtered (_("All defined %ss:\n"), classnames[kind]);
4465 for (const symbol_search &p : symbols)
4469 if (p.msymbol.minsym != NULL)
4473 printf_filtered (_("\nNon-debugging symbols:\n"));
4476 print_msymbol_info (p.msymbol);
4480 print_symbol_info (kind,
4485 = symtab_to_filename_for_display (symbol_symtab (p.symbol));
4491 info_variables_command (const char *regexp, int from_tty)
4493 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
4497 info_functions_command (const char *regexp, int from_tty)
4499 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
4504 info_types_command (const char *regexp, int from_tty)
4506 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
4509 /* Breakpoint all functions matching regular expression. */
4512 rbreak_command_wrapper (char *regexp, int from_tty)
4514 rbreak_command (regexp, from_tty);
4518 rbreak_command (const char *regexp, int from_tty)
4521 const char **files = NULL;
4522 const char *file_name;
4527 const char *colon = strchr (regexp, ':');
4529 if (colon && *(colon + 1) != ':')
4534 colon_index = colon - regexp;
4535 local_name = (char *) alloca (colon_index + 1);
4536 memcpy (local_name, regexp, colon_index);
4537 local_name[colon_index--] = 0;
4538 while (isspace (local_name[colon_index]))
4539 local_name[colon_index--] = 0;
4540 file_name = local_name;
4543 regexp = skip_spaces (colon + 1);
4547 std::vector<symbol_search> symbols = search_symbols (regexp,
4551 scoped_rbreak_breakpoints finalize;
4552 for (const symbol_search &p : symbols)
4554 if (p.msymbol.minsym == NULL)
4556 struct symtab *symtab = symbol_symtab (p.symbol);
4557 const char *fullname = symtab_to_fullname (symtab);
4559 string = string_printf ("%s:'%s'", fullname,
4560 SYMBOL_LINKAGE_NAME (p.symbol));
4561 break_command (&string[0], from_tty);
4562 print_symbol_info (FUNCTIONS_DOMAIN,
4565 symtab_to_filename_for_display (symtab));
4569 string = string_printf ("'%s'",
4570 MSYMBOL_LINKAGE_NAME (p.msymbol.minsym));
4572 break_command (&string[0], from_tty);
4573 printf_filtered ("<function, no debug info> %s;\n",
4574 MSYMBOL_PRINT_NAME (p.msymbol.minsym));
4580 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
4582 Either sym_text[sym_text_len] != '(' and then we search for any
4583 symbol starting with SYM_TEXT text.
4585 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
4586 be terminated at that point. Partial symbol tables do not have parameters
4590 compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
4592 int (*ncmp) (const char *, const char *, size_t);
4594 ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
4596 if (ncmp (name, sym_text, sym_text_len) != 0)
4599 if (sym_text[sym_text_len] == '(')
4601 /* User searches for `name(someth...'. Require NAME to be terminated.
4602 Normally psymtabs and gdbindex have no parameter types so '\0' will be
4603 present but accept even parameters presence. In this case this
4604 function is in fact strcmp_iw but whitespace skipping is not supported
4605 for tab completion. */
4607 if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
4614 /* Test to see if the symbol specified by SYMNAME (which is already
4615 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4616 characters. If so, add it to the current completion list. */
4619 completion_list_add_name (completion_tracker &tracker,
4620 const char *symname,
4621 const char *sym_text, int sym_text_len,
4622 const char *text, const char *word)
4624 /* Clip symbols that cannot match. */
4625 if (!compare_symbol_name (symname, sym_text, sym_text_len))
4628 /* We have a match for a completion, so add SYMNAME to the current list
4629 of matches. Note that the name is moved to freshly malloc'd space. */
4634 if (word == sym_text)
4636 newobj = (char *) xmalloc (strlen (symname) + 5);
4637 strcpy (newobj, symname);
4639 else if (word > sym_text)
4641 /* Return some portion of symname. */
4642 newobj = (char *) xmalloc (strlen (symname) + 5);
4643 strcpy (newobj, symname + (word - sym_text));
4647 /* Return some of SYM_TEXT plus symname. */
4648 newobj = (char *) xmalloc (strlen (symname) + (sym_text - word) + 5);
4649 strncpy (newobj, word, sym_text - word);
4650 newobj[sym_text - word] = '\0';
4651 strcat (newobj, symname);
4654 gdb::unique_xmalloc_ptr<char> completion (newobj);
4656 tracker.add_completion (std::move (completion));
4660 /* completion_list_add_name wrapper for struct symbol. */
4663 completion_list_add_symbol (completion_tracker &tracker,
4665 const char *sym_text, int sym_text_len,
4666 const char *text, const char *word)
4668 completion_list_add_name (tracker, SYMBOL_NATURAL_NAME (sym),
4669 sym_text, sym_text_len, text, word);
4672 /* completion_list_add_name wrapper for struct minimal_symbol. */
4675 completion_list_add_msymbol (completion_tracker &tracker,
4676 minimal_symbol *sym,
4677 const char *sym_text, int sym_text_len,
4678 const char *text, const char *word)
4680 completion_list_add_name (tracker, MSYMBOL_NATURAL_NAME (sym),
4681 sym_text, sym_text_len, text, word);
4684 /* ObjC: In case we are completing on a selector, look as the msymbol
4685 again and feed all the selectors into the mill. */
4688 completion_list_objc_symbol (completion_tracker &tracker,
4689 struct minimal_symbol *msymbol,
4690 const char *sym_text, int sym_text_len,
4691 const char *text, const char *word)
4693 static char *tmp = NULL;
4694 static unsigned int tmplen = 0;
4696 const char *method, *category, *selector;
4699 method = MSYMBOL_NATURAL_NAME (msymbol);
4701 /* Is it a method? */
4702 if ((method[0] != '-') && (method[0] != '+'))
4705 if (sym_text[0] == '[')
4706 /* Complete on shortened method method. */
4707 completion_list_add_name (tracker, method + 1,
4708 sym_text, sym_text_len, text, word);
4710 while ((strlen (method) + 1) >= tmplen)
4716 tmp = (char *) xrealloc (tmp, tmplen);
4718 selector = strchr (method, ' ');
4719 if (selector != NULL)
4722 category = strchr (method, '(');
4724 if ((category != NULL) && (selector != NULL))
4726 memcpy (tmp, method, (category - method));
4727 tmp[category - method] = ' ';
4728 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4729 completion_list_add_name (tracker, tmp,
4730 sym_text, sym_text_len, text, word);
4731 if (sym_text[0] == '[')
4732 completion_list_add_name (tracker, tmp + 1,
4733 sym_text, sym_text_len, text, word);
4736 if (selector != NULL)
4738 /* Complete on selector only. */
4739 strcpy (tmp, selector);
4740 tmp2 = strchr (tmp, ']');
4744 completion_list_add_name (tracker, tmp,
4745 sym_text, sym_text_len, text, word);
4749 /* Break the non-quoted text based on the characters which are in
4750 symbols. FIXME: This should probably be language-specific. */
4753 language_search_unquoted_string (const char *text, const char *p)
4755 for (; p > text; --p)
4757 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4761 if ((current_language->la_language == language_objc))
4763 if (p[-1] == ':') /* Might be part of a method name. */
4765 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
4766 p -= 2; /* Beginning of a method name. */
4767 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
4768 { /* Might be part of a method name. */
4771 /* Seeing a ' ' or a '(' is not conclusive evidence
4772 that we are in the middle of a method name. However,
4773 finding "-[" or "+[" should be pretty un-ambiguous.
4774 Unfortunately we have to find it now to decide. */
4777 if (isalnum (t[-1]) || t[-1] == '_' ||
4778 t[-1] == ' ' || t[-1] == ':' ||
4779 t[-1] == '(' || t[-1] == ')')
4784 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
4785 p = t - 2; /* Method name detected. */
4786 /* Else we leave with p unchanged. */
4796 completion_list_add_fields (completion_tracker &tracker,
4798 const char *sym_text, int sym_text_len,
4799 const char *text, const char *word)
4801 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4803 struct type *t = SYMBOL_TYPE (sym);
4804 enum type_code c = TYPE_CODE (t);
4807 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4808 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4809 if (TYPE_FIELD_NAME (t, j))
4810 completion_list_add_name (tracker, TYPE_FIELD_NAME (t, j),
4811 sym_text, sym_text_len, text, word);
4815 /* Add matching symbols from SYMTAB to the current completion list. */
4818 add_symtab_completions (struct compunit_symtab *cust,
4819 completion_tracker &tracker,
4820 const char *sym_text, int sym_text_len,
4821 const char *text, const char *word,
4822 enum type_code code)
4825 const struct block *b;
4826 struct block_iterator iter;
4832 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
4835 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), i);
4836 ALL_BLOCK_SYMBOLS (b, iter, sym)
4838 if (code == TYPE_CODE_UNDEF
4839 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4840 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4841 completion_list_add_symbol (tracker, sym,
4842 sym_text, sym_text_len,
4849 default_collect_symbol_completion_matches_break_on
4850 (completion_tracker &tracker,
4851 complete_symbol_mode mode,
4852 const char *text, const char *word,
4853 const char *break_on, enum type_code code)
4855 /* Problem: All of the symbols have to be copied because readline
4856 frees them. I'm not going to worry about this; hopefully there
4857 won't be that many. */
4860 struct compunit_symtab *cust;
4861 struct minimal_symbol *msymbol;
4862 struct objfile *objfile;
4863 const struct block *b;
4864 const struct block *surrounding_static_block, *surrounding_global_block;
4865 struct block_iterator iter;
4866 /* The symbol we are completing on. Points in same buffer as text. */
4867 const char *sym_text;
4868 /* Length of sym_text. */
4871 /* Now look for the symbol we are supposed to complete on. */
4872 if (mode == complete_symbol_mode::LINESPEC)
4878 const char *quote_pos = NULL;
4880 /* First see if this is a quoted string. */
4882 for (p = text; *p != '\0'; ++p)
4884 if (quote_found != '\0')
4886 if (*p == quote_found)
4887 /* Found close quote. */
4889 else if (*p == '\\' && p[1] == quote_found)
4890 /* A backslash followed by the quote character
4891 doesn't end the string. */
4894 else if (*p == '\'' || *p == '"')
4900 if (quote_found == '\'')
4901 /* A string within single quotes can be a symbol, so complete on it. */
4902 sym_text = quote_pos + 1;
4903 else if (quote_found == '"')
4904 /* A double-quoted string is never a symbol, nor does it make sense
4905 to complete it any other way. */
4911 /* It is not a quoted string. Break it based on the characters
4912 which are in symbols. */
4915 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
4916 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
4925 sym_text_len = strlen (sym_text);
4927 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4929 if (current_language->la_language == language_cplus
4930 || current_language->la_language == language_fortran)
4932 /* These languages may have parameters entered by user but they are never
4933 present in the partial symbol tables. */
4935 const char *cs = (const char *) memchr (sym_text, '(', sym_text_len);
4938 sym_text_len = cs - sym_text;
4940 gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
4942 /* At this point scan through the misc symbol vectors and add each
4943 symbol you find to the list. Eventually we want to ignore
4944 anything that isn't a text symbol (everything else will be
4945 handled by the psymtab code below). */
4947 if (code == TYPE_CODE_UNDEF)
4949 ALL_MSYMBOLS (objfile, msymbol)
4953 completion_list_add_msymbol (tracker,
4954 msymbol, sym_text, sym_text_len,
4957 completion_list_objc_symbol (tracker,
4958 msymbol, sym_text, sym_text_len,
4963 /* Add completions for all currently loaded symbol tables. */
4964 ALL_COMPUNITS (objfile, cust)
4965 add_symtab_completions (cust, tracker,
4966 sym_text, sym_text_len, text, word, code);
4968 /* Look through the partial symtabs for all symbols which begin by
4969 matching SYM_TEXT. Expand all CUs that you find to the list. */
4970 expand_symtabs_matching (NULL,
4971 [&] (const char *name) /* symbol matcher */
4973 return compare_symbol_name (name,
4977 [&] (compunit_symtab *symtab) /* expansion notify */
4979 add_symtab_completions (symtab,
4981 sym_text, sym_text_len,
4986 /* Search upwards from currently selected frame (so that we can
4987 complete on local vars). Also catch fields of types defined in
4988 this places which match our text string. Only complete on types
4989 visible from current context. */
4991 b = get_selected_block (0);
4992 surrounding_static_block = block_static_block (b);
4993 surrounding_global_block = block_global_block (b);
4994 if (surrounding_static_block != NULL)
4995 while (b != surrounding_static_block)
4999 ALL_BLOCK_SYMBOLS (b, iter, sym)
5001 if (code == TYPE_CODE_UNDEF)
5003 completion_list_add_symbol (tracker, sym,
5004 sym_text, sym_text_len, text,
5006 completion_list_add_fields (tracker, sym,
5007 sym_text, sym_text_len, text,
5010 else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
5011 && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
5012 completion_list_add_symbol (tracker, sym,
5013 sym_text, sym_text_len, text,
5017 /* Stop when we encounter an enclosing function. Do not stop for
5018 non-inlined functions - the locals of the enclosing function
5019 are in scope for a nested function. */
5020 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
5022 b = BLOCK_SUPERBLOCK (b);
5025 /* Add fields from the file's types; symbols will be added below. */
5027 if (code == TYPE_CODE_UNDEF)
5029 if (surrounding_static_block != NULL)
5030 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
5031 completion_list_add_fields (tracker, sym,
5032 sym_text, sym_text_len, text, word);
5034 if (surrounding_global_block != NULL)
5035 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
5036 completion_list_add_fields (tracker, sym,
5037 sym_text, sym_text_len, text, word);
5040 /* Skip macros if we are completing a struct tag -- arguable but
5041 usually what is expected. */
5042 if (current_language->la_macro_expansion == macro_expansion_c
5043 && code == TYPE_CODE_UNDEF)
5045 struct macro_scope *scope;
5047 /* This adds a macro's name to the current completion list. */
5048 auto add_macro_name = [&] (const char *macro_name,
5049 const macro_definition *,
5050 macro_source_file *,
5053 completion_list_add_name (tracker, macro_name,
5054 sym_text, sym_text_len,
5058 /* Add any macros visible in the default scope. Note that this
5059 may yield the occasional wrong result, because an expression
5060 might be evaluated in a scope other than the default. For
5061 example, if the user types "break file:line if <TAB>", the
5062 resulting expression will be evaluated at "file:line" -- but
5063 at there does not seem to be a way to detect this at
5065 scope = default_macro_scope ();
5068 macro_for_each_in_scope (scope->file, scope->line,
5073 /* User-defined macros are always visible. */
5074 macro_for_each (macro_user_macros, add_macro_name);
5079 default_collect_symbol_completion_matches (completion_tracker &tracker,
5080 complete_symbol_mode mode,
5081 const char *text, const char *word,
5082 enum type_code code)
5084 return default_collect_symbol_completion_matches_break_on (tracker, mode,
5089 /* Collect all symbols (regardless of class) which begin by matching
5093 collect_symbol_completion_matches (completion_tracker &tracker,
5094 complete_symbol_mode mode,
5095 const char *text, const char *word)
5097 current_language->la_collect_symbol_completion_matches (tracker, mode,
5102 /* Like collect_symbol_completion_matches, but only collect
5103 STRUCT_DOMAIN symbols whose type code is CODE. */
5106 collect_symbol_completion_matches_type (completion_tracker &tracker,
5107 const char *text, const char *word,
5108 enum type_code code)
5110 complete_symbol_mode mode = complete_symbol_mode::EXPRESSION;
5112 gdb_assert (code == TYPE_CODE_UNION
5113 || code == TYPE_CODE_STRUCT
5114 || code == TYPE_CODE_ENUM);
5115 current_language->la_collect_symbol_completion_matches (tracker, mode,
5119 /* Like collect_symbol_completion_matches, but collects a list of
5120 symbols defined in all source files named SRCFILE. */
5123 collect_file_symbol_completion_matches (completion_tracker &tracker,
5124 complete_symbol_mode mode,
5125 const char *text, const char *word,
5126 const char *srcfile)
5128 /* The symbol we are completing on. Points in same buffer as text. */
5129 const char *sym_text;
5130 /* Length of sym_text. */
5133 /* Now look for the symbol we are supposed to complete on.
5134 FIXME: This should be language-specific. */
5135 if (mode == complete_symbol_mode::LINESPEC)
5141 const char *quote_pos = NULL;
5143 /* First see if this is a quoted string. */
5145 for (p = text; *p != '\0'; ++p)
5147 if (quote_found != '\0')
5149 if (*p == quote_found)
5150 /* Found close quote. */
5152 else if (*p == '\\' && p[1] == quote_found)
5153 /* A backslash followed by the quote character
5154 doesn't end the string. */
5157 else if (*p == '\'' || *p == '"')
5163 if (quote_found == '\'')
5164 /* A string within single quotes can be a symbol, so complete on it. */
5165 sym_text = quote_pos + 1;
5166 else if (quote_found == '"')
5167 /* A double-quoted string is never a symbol, nor does it make sense
5168 to complete it any other way. */
5174 /* Not a quoted string. */
5175 sym_text = language_search_unquoted_string (text, p);
5179 sym_text_len = strlen (sym_text);
5181 /* Go through symtabs for SRCFILE and check the externs and statics
5182 for symbols which match. */
5183 iterate_over_symtabs (srcfile, [&] (symtab *s)
5185 add_symtab_completions (SYMTAB_COMPUNIT (s),
5187 sym_text, sym_text_len,
5188 text, word, TYPE_CODE_UNDEF);
5193 /* A helper function for make_source_files_completion_list. It adds
5194 another file name to a list of possible completions, growing the
5195 list as necessary. */
5198 add_filename_to_list (const char *fname, const char *text, const char *word,
5199 completion_list *list)
5202 size_t fnlen = strlen (fname);
5206 /* Return exactly fname. */
5207 newobj = (char *) xmalloc (fnlen + 5);
5208 strcpy (newobj, fname);
5210 else if (word > text)
5212 /* Return some portion of fname. */
5213 newobj = (char *) xmalloc (fnlen + 5);
5214 strcpy (newobj, fname + (word - text));
5218 /* Return some of TEXT plus fname. */
5219 newobj = (char *) xmalloc (fnlen + (text - word) + 5);
5220 strncpy (newobj, word, text - word);
5221 newobj[text - word] = '\0';
5222 strcat (newobj, fname);
5224 list->emplace_back (newobj);
5228 not_interesting_fname (const char *fname)
5230 static const char *illegal_aliens[] = {
5231 "_globals_", /* inserted by coff_symtab_read */
5236 for (i = 0; illegal_aliens[i]; i++)
5238 if (filename_cmp (fname, illegal_aliens[i]) == 0)
5244 /* An object of this type is passed as the user_data argument to
5245 map_partial_symbol_filenames. */
5246 struct add_partial_filename_data
5248 struct filename_seen_cache *filename_seen_cache;
5252 completion_list *list;
5255 /* A callback for map_partial_symbol_filenames. */
5258 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
5261 struct add_partial_filename_data *data
5262 = (struct add_partial_filename_data *) user_data;
5264 if (not_interesting_fname (filename))
5266 if (!data->filename_seen_cache->seen (filename)
5267 && filename_ncmp (filename, data->text, data->text_len) == 0)
5269 /* This file matches for a completion; add it to the
5270 current list of matches. */
5271 add_filename_to_list (filename, data->text, data->word, data->list);
5275 const char *base_name = lbasename (filename);
5277 if (base_name != filename
5278 && !data->filename_seen_cache->seen (base_name)
5279 && filename_ncmp (base_name, data->text, data->text_len) == 0)
5280 add_filename_to_list (base_name, data->text, data->word, data->list);
5284 /* Return a list of all source files whose names begin with matching
5285 TEXT. The file names are looked up in the symbol tables of this
5289 make_source_files_completion_list (const char *text, const char *word)
5291 struct compunit_symtab *cu;
5293 struct objfile *objfile;
5294 size_t text_len = strlen (text);
5295 completion_list list;
5296 const char *base_name;
5297 struct add_partial_filename_data datum;
5299 if (!have_full_symbols () && !have_partial_symbols ())
5302 filename_seen_cache filenames_seen;
5304 ALL_FILETABS (objfile, cu, s)
5306 if (not_interesting_fname (s->filename))
5308 if (!filenames_seen.seen (s->filename)
5309 && filename_ncmp (s->filename, text, text_len) == 0)
5311 /* This file matches for a completion; add it to the current
5313 add_filename_to_list (s->filename, text, word, &list);
5317 /* NOTE: We allow the user to type a base name when the
5318 debug info records leading directories, but not the other
5319 way around. This is what subroutines of breakpoint
5320 command do when they parse file names. */
5321 base_name = lbasename (s->filename);
5322 if (base_name != s->filename
5323 && !filenames_seen.seen (base_name)
5324 && filename_ncmp (base_name, text, text_len) == 0)
5325 add_filename_to_list (base_name, text, word, &list);
5329 datum.filename_seen_cache = &filenames_seen;
5332 datum.text_len = text_len;
5334 map_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
5335 0 /*need_fullname*/);
5342 /* Return the "main_info" object for the current program space. If
5343 the object has not yet been created, create it and fill in some
5346 static struct main_info *
5347 get_main_info (void)
5349 struct main_info *info
5350 = (struct main_info *) program_space_data (current_program_space,
5351 main_progspace_key);
5355 /* It may seem strange to store the main name in the progspace
5356 and also in whatever objfile happens to see a main name in
5357 its debug info. The reason for this is mainly historical:
5358 gdb returned "main" as the name even if no function named
5359 "main" was defined the program; and this approach lets us
5360 keep compatibility. */
5361 info = XCNEW (struct main_info);
5362 info->language_of_main = language_unknown;
5363 set_program_space_data (current_program_space, main_progspace_key,
5370 /* A cleanup to destroy a struct main_info when a progspace is
5374 main_info_cleanup (struct program_space *pspace, void *data)
5376 struct main_info *info = (struct main_info *) data;
5379 xfree (info->name_of_main);
5384 set_main_name (const char *name, enum language lang)
5386 struct main_info *info = get_main_info ();
5388 if (info->name_of_main != NULL)
5390 xfree (info->name_of_main);
5391 info->name_of_main = NULL;
5392 info->language_of_main = language_unknown;
5396 info->name_of_main = xstrdup (name);
5397 info->language_of_main = lang;
5401 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5405 find_main_name (void)
5407 const char *new_main_name;
5408 struct objfile *objfile;
5410 /* First check the objfiles to see whether a debuginfo reader has
5411 picked up the appropriate main name. Historically the main name
5412 was found in a more or less random way; this approach instead
5413 relies on the order of objfile creation -- which still isn't
5414 guaranteed to get the correct answer, but is just probably more
5416 ALL_OBJFILES (objfile)
5418 if (objfile->per_bfd->name_of_main != NULL)
5420 set_main_name (objfile->per_bfd->name_of_main,
5421 objfile->per_bfd->language_of_main);
5426 /* Try to see if the main procedure is in Ada. */
5427 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5428 be to add a new method in the language vector, and call this
5429 method for each language until one of them returns a non-empty
5430 name. This would allow us to remove this hard-coded call to
5431 an Ada function. It is not clear that this is a better approach
5432 at this point, because all methods need to be written in a way
5433 such that false positives never be returned. For instance, it is
5434 important that a method does not return a wrong name for the main
5435 procedure if the main procedure is actually written in a different
5436 language. It is easy to guaranty this with Ada, since we use a
5437 special symbol generated only when the main in Ada to find the name
5438 of the main procedure. It is difficult however to see how this can
5439 be guarantied for languages such as C, for instance. This suggests
5440 that order of call for these methods becomes important, which means
5441 a more complicated approach. */
5442 new_main_name = ada_main_name ();
5443 if (new_main_name != NULL)
5445 set_main_name (new_main_name, language_ada);
5449 new_main_name = d_main_name ();
5450 if (new_main_name != NULL)
5452 set_main_name (new_main_name, language_d);
5456 new_main_name = go_main_name ();
5457 if (new_main_name != NULL)
5459 set_main_name (new_main_name, language_go);
5463 new_main_name = pascal_main_name ();
5464 if (new_main_name != NULL)
5466 set_main_name (new_main_name, language_pascal);
5470 /* The languages above didn't identify the name of the main procedure.
5471 Fallback to "main". */
5472 set_main_name ("main", language_unknown);
5478 struct main_info *info = get_main_info ();
5480 if (info->name_of_main == NULL)
5483 return info->name_of_main;
5486 /* Return the language of the main function. If it is not known,
5487 return language_unknown. */
5490 main_language (void)
5492 struct main_info *info = get_main_info ();
5494 if (info->name_of_main == NULL)
5497 return info->language_of_main;
5500 /* Handle ``executable_changed'' events for the symtab module. */
5503 symtab_observer_executable_changed (void)
5505 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5506 set_main_name (NULL, language_unknown);
5509 /* Return 1 if the supplied producer string matches the ARM RealView
5510 compiler (armcc). */
5513 producer_is_realview (const char *producer)
5515 static const char *const arm_idents[] = {
5516 "ARM C Compiler, ADS",
5517 "Thumb C Compiler, ADS",
5518 "ARM C++ Compiler, ADS",
5519 "Thumb C++ Compiler, ADS",
5520 "ARM/Thumb C/C++ Compiler, RVCT",
5521 "ARM C/C++ Compiler, RVCT"
5525 if (producer == NULL)
5528 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5529 if (startswith (producer, arm_idents[i]))
5537 /* The next index to hand out in response to a registration request. */
5539 static int next_aclass_value = LOC_FINAL_VALUE;
5541 /* The maximum number of "aclass" registrations we support. This is
5542 constant for convenience. */
5543 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5545 /* The objects representing the various "aclass" values. The elements
5546 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5547 elements are those registered at gdb initialization time. */
5549 static struct symbol_impl symbol_impl[MAX_SYMBOL_IMPLS];
5551 /* The globally visible pointer. This is separate from 'symbol_impl'
5552 so that it can be const. */
5554 const struct symbol_impl *symbol_impls = &symbol_impl[0];
5556 /* Make sure we saved enough room in struct symbol. */
5558 gdb_static_assert (MAX_SYMBOL_IMPLS <= (1 << SYMBOL_ACLASS_BITS));
5560 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5561 is the ops vector associated with this index. This returns the new
5562 index, which should be used as the aclass_index field for symbols
5566 register_symbol_computed_impl (enum address_class aclass,
5567 const struct symbol_computed_ops *ops)
5569 int result = next_aclass_value++;
5571 gdb_assert (aclass == LOC_COMPUTED);
5572 gdb_assert (result < MAX_SYMBOL_IMPLS);
5573 symbol_impl[result].aclass = aclass;
5574 symbol_impl[result].ops_computed = ops;
5576 /* Sanity check OPS. */
5577 gdb_assert (ops != NULL);
5578 gdb_assert (ops->tracepoint_var_ref != NULL);
5579 gdb_assert (ops->describe_location != NULL);
5580 gdb_assert (ops->get_symbol_read_needs != NULL);
5581 gdb_assert (ops->read_variable != NULL);
5586 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5587 OPS is the ops vector associated with this index. This returns the
5588 new index, which should be used as the aclass_index field for symbols
5592 register_symbol_block_impl (enum address_class aclass,
5593 const struct symbol_block_ops *ops)
5595 int result = next_aclass_value++;
5597 gdb_assert (aclass == LOC_BLOCK);
5598 gdb_assert (result < MAX_SYMBOL_IMPLS);
5599 symbol_impl[result].aclass = aclass;
5600 symbol_impl[result].ops_block = ops;
5602 /* Sanity check OPS. */
5603 gdb_assert (ops != NULL);
5604 gdb_assert (ops->find_frame_base_location != NULL);
5609 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5610 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5611 this index. This returns the new index, which should be used as
5612 the aclass_index field for symbols of this type. */
5615 register_symbol_register_impl (enum address_class aclass,
5616 const struct symbol_register_ops *ops)
5618 int result = next_aclass_value++;
5620 gdb_assert (aclass == LOC_REGISTER || aclass == LOC_REGPARM_ADDR);
5621 gdb_assert (result < MAX_SYMBOL_IMPLS);
5622 symbol_impl[result].aclass = aclass;
5623 symbol_impl[result].ops_register = ops;
5628 /* Initialize elements of 'symbol_impl' for the constants in enum
5632 initialize_ordinary_address_classes (void)
5636 for (i = 0; i < LOC_FINAL_VALUE; ++i)
5637 symbol_impl[i].aclass = (enum address_class) i;
5642 /* Helper function to initialize the fields of an objfile-owned symbol.
5643 It assumed that *SYM is already all zeroes. */
5646 initialize_objfile_symbol_1 (struct symbol *sym)
5648 SYMBOL_OBJFILE_OWNED (sym) = 1;
5649 SYMBOL_SECTION (sym) = -1;
5652 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
5655 initialize_objfile_symbol (struct symbol *sym)
5657 memset (sym, 0, sizeof (*sym));
5658 initialize_objfile_symbol_1 (sym);
5661 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5665 allocate_symbol (struct objfile *objfile)
5667 struct symbol *result;
5669 result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
5670 initialize_objfile_symbol_1 (result);
5675 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5678 struct template_symbol *
5679 allocate_template_symbol (struct objfile *objfile)
5681 struct template_symbol *result;
5683 result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
5684 initialize_objfile_symbol_1 (&result->base);
5692 symbol_objfile (const struct symbol *symbol)
5694 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5695 return SYMTAB_OBJFILE (symbol->owner.symtab);
5701 symbol_arch (const struct symbol *symbol)
5703 if (!SYMBOL_OBJFILE_OWNED (symbol))
5704 return symbol->owner.arch;
5705 return get_objfile_arch (SYMTAB_OBJFILE (symbol->owner.symtab));
5711 symbol_symtab (const struct symbol *symbol)
5713 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5714 return symbol->owner.symtab;
5720 symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
5722 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5723 symbol->owner.symtab = symtab;
5729 _initialize_symtab (void)
5731 initialize_ordinary_address_classes ();
5734 = register_program_space_data_with_cleanup (NULL, main_info_cleanup);
5737 = register_program_space_data_with_cleanup (NULL, symbol_cache_cleanup);
5739 add_info ("variables", info_variables_command, _("\
5740 All global and static variable names, or those matching REGEXP."));
5742 add_com ("whereis", class_info, info_variables_command, _("\
5743 All global and static variable names, or those matching REGEXP."));
5745 add_info ("functions", info_functions_command,
5746 _("All function names, or those matching REGEXP."));
5748 /* FIXME: This command has at least the following problems:
5749 1. It prints builtin types (in a very strange and confusing fashion).
5750 2. It doesn't print right, e.g. with
5751 typedef struct foo *FOO
5752 type_print prints "FOO" when we want to make it (in this situation)
5753 print "struct foo *".
5754 I also think "ptype" or "whatis" is more likely to be useful (but if
5755 there is much disagreement "info types" can be fixed). */
5756 add_info ("types", info_types_command,
5757 _("All type names, or those matching REGEXP."));
5759 add_info ("sources", info_sources_command,
5760 _("Source files in the program."));
5762 add_com ("rbreak", class_breakpoint, rbreak_command,
5763 _("Set a breakpoint for all functions matching REGEXP."));
5765 add_setshow_enum_cmd ("multiple-symbols", no_class,
5766 multiple_symbols_modes, &multiple_symbols_mode,
5768 Set the debugger behavior when more than one symbol are possible matches\n\
5769 in an expression."), _("\
5770 Show how the debugger handles ambiguities in expressions."), _("\
5771 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5772 NULL, NULL, &setlist, &showlist);
5774 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5775 &basenames_may_differ, _("\
5776 Set whether a source file may have multiple base names."), _("\
5777 Show whether a source file may have multiple base names."), _("\
5778 (A \"base name\" is the name of a file with the directory part removed.\n\
5779 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5780 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5781 before comparing them. Canonicalization is an expensive operation,\n\
5782 but it allows the same file be known by more than one base name.\n\
5783 If not set (the default), all source files are assumed to have just\n\
5784 one base name, and gdb will do file name comparisons more efficiently."),
5786 &setlist, &showlist);
5788 add_setshow_zuinteger_cmd ("symtab-create", no_class, &symtab_create_debug,
5789 _("Set debugging of symbol table creation."),
5790 _("Show debugging of symbol table creation."), _("\
5791 When enabled (non-zero), debugging messages are printed when building\n\
5792 symbol tables. A value of 1 (one) normally provides enough information.\n\
5793 A value greater than 1 provides more verbose information."),
5796 &setdebuglist, &showdebuglist);
5798 add_setshow_zuinteger_cmd ("symbol-lookup", no_class, &symbol_lookup_debug,
5800 Set debugging of symbol lookup."), _("\
5801 Show debugging of symbol lookup."), _("\
5802 When enabled (non-zero), symbol lookups are logged."),
5804 &setdebuglist, &showdebuglist);
5806 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class,
5807 &new_symbol_cache_size,
5808 _("Set the size of the symbol cache."),
5809 _("Show the size of the symbol cache."), _("\
5810 The size of the symbol cache.\n\
5811 If zero then the symbol cache is disabled."),
5812 set_symbol_cache_size_handler, NULL,
5813 &maintenance_set_cmdlist,
5814 &maintenance_show_cmdlist);
5816 add_cmd ("symbol-cache", class_maintenance, maintenance_print_symbol_cache,
5817 _("Dump the symbol cache for each program space."),
5818 &maintenanceprintlist);
5820 add_cmd ("symbol-cache-statistics", class_maintenance,
5821 maintenance_print_symbol_cache_statistics,
5822 _("Print symbol cache statistics for each program space."),
5823 &maintenanceprintlist);
5825 add_cmd ("flush-symbol-cache", class_maintenance,
5826 maintenance_flush_symbol_cache,
5827 _("Flush the symbol cache for each program space."),
5830 observer_attach_executable_changed (symtab_observer_executable_changed);
5831 observer_attach_new_objfile (symtab_new_objfile_observer);
5832 observer_attach_free_objfile (symtab_free_objfile_observer);