1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2013 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"
46 #include "gdb_obstack.h"
48 #include "dictionary.h"
50 #include <sys/types.h>
52 #include "gdb_string.h"
56 #include "cp-support.h"
58 #include "gdb_assert.h"
61 #include "macroscope.h"
64 #include "parser-defs.h"
66 /* Prototypes for local functions */
68 static void rbreak_command (char *, int);
70 static void types_info (char *, int);
72 static void functions_info (char *, int);
74 static void variables_info (char *, int);
76 static void sources_info (char *, int);
78 static int find_line_common (struct linetable *, int, int *, int);
80 static struct symbol *lookup_symbol_aux (const char *name,
81 const struct block *block,
82 const domain_enum domain,
83 enum language language,
84 struct field_of_this_result *is_a_field_of_this);
87 struct symbol *lookup_symbol_aux_local (const char *name,
88 const struct block *block,
89 const domain_enum domain,
90 enum language language);
93 struct symbol *lookup_symbol_aux_symtabs (int block_index,
95 const domain_enum domain);
98 struct symbol *lookup_symbol_aux_quick (struct objfile *objfile,
101 const domain_enum domain);
103 static void print_msymbol_info (struct minimal_symbol *);
105 void _initialize_symtab (void);
109 /* When non-zero, print debugging messages related to symtab creation. */
110 int symtab_create_debug = 0;
112 /* Non-zero if a file may be known by two different basenames.
113 This is the uncommon case, and significantly slows down gdb.
114 Default set to "off" to not slow down the common case. */
115 int basenames_may_differ = 0;
117 /* Allow the user to configure the debugger behavior with respect
118 to multiple-choice menus when more than one symbol matches during
121 const char multiple_symbols_ask[] = "ask";
122 const char multiple_symbols_all[] = "all";
123 const char multiple_symbols_cancel[] = "cancel";
124 static const char *const multiple_symbols_modes[] =
126 multiple_symbols_ask,
127 multiple_symbols_all,
128 multiple_symbols_cancel,
131 static const char *multiple_symbols_mode = multiple_symbols_all;
133 /* Read-only accessor to AUTO_SELECT_MODE. */
136 multiple_symbols_select_mode (void)
138 return multiple_symbols_mode;
141 /* Block in which the most recently searched-for symbol was found.
142 Might be better to make this a parameter to lookup_symbol and
145 const struct block *block_found;
147 /* See whether FILENAME matches SEARCH_NAME using the rule that we
148 advertise to the user. (The manual's description of linespecs
149 describes what we advertise). We assume that SEARCH_NAME is
150 a relative path. Returns true if they match, false otherwise. */
153 compare_filenames_for_search (const char *filename, const char *search_name)
155 int len = strlen (filename);
156 size_t search_len = strlen (search_name);
158 if (len < search_len)
161 /* The tail of FILENAME must match. */
162 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
165 /* Either the names must completely match, or the character
166 preceding the trailing SEARCH_NAME segment of FILENAME must be a
169 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
170 compatible with SEARCH_NAME "file.c". In such case a compiler had
171 to put the "c:file.c" name into debug info. Such compatibility
172 works only on GDB built for DOS host. */
173 return (len == search_len
174 || IS_DIR_SEPARATOR (filename[len - search_len - 1])
175 || (HAS_DRIVE_SPEC (filename)
176 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
179 /* Check for a symtab of a specific name by searching some symtabs.
180 This is a helper function for callbacks of iterate_over_symtabs.
182 The return value, NAME, REAL_PATH, CALLBACK, and DATA
183 are identical to the `map_symtabs_matching_filename' method of
184 quick_symbol_functions.
186 FIRST and AFTER_LAST indicate the range of symtabs to search.
187 AFTER_LAST is one past the last symtab to search; NULL means to
188 search until the end of the list. */
191 iterate_over_some_symtabs (const char *name,
192 const char *real_path,
193 int (*callback) (struct symtab *symtab,
196 struct symtab *first,
197 struct symtab *after_last)
199 struct symtab *s = NULL;
200 const char* base_name = lbasename (name);
201 int is_abs = IS_ABSOLUTE_PATH (name);
203 for (s = first; s != NULL && s != after_last; s = s->next)
205 /* Exact match is always ok. */
206 if (FILENAME_CMP (name, s->filename) == 0)
208 if (callback (s, data))
212 if (!is_abs && compare_filenames_for_search (s->filename, name))
214 if (callback (s, data))
218 /* Before we invoke realpath, which can get expensive when many
219 files are involved, do a quick comparison of the basenames. */
220 if (! basenames_may_differ
221 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
224 /* If the user gave us an absolute path, try to find the file in
225 this symtab and use its absolute path. */
227 if (real_path != NULL)
229 const char *fullname = symtab_to_fullname (s);
231 if (FILENAME_CMP (real_path, fullname) == 0)
233 if (callback (s, data))
237 if (!is_abs && compare_filenames_for_search (fullname, name))
239 if (callback (s, data))
248 /* Check for a symtab of a specific name; first in symtabs, then in
249 psymtabs. *If* there is no '/' in the name, a match after a '/'
250 in the symtab filename will also work.
252 Calls CALLBACK with each symtab that is found and with the supplied
253 DATA. If CALLBACK returns true, the search stops. */
256 iterate_over_symtabs (const char *name,
257 int (*callback) (struct symtab *symtab,
261 struct objfile *objfile;
262 char *real_path = NULL;
263 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
265 /* Here we are interested in canonicalizing an absolute path, not
266 absolutizing a relative path. */
267 if (IS_ABSOLUTE_PATH (name))
269 real_path = gdb_realpath (name);
270 make_cleanup (xfree, real_path);
273 ALL_OBJFILES (objfile)
275 if (iterate_over_some_symtabs (name, real_path, callback, data,
276 objfile->symtabs, NULL))
278 do_cleanups (cleanups);
283 /* Same search rules as above apply here, but now we look thru the
286 ALL_OBJFILES (objfile)
289 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
295 do_cleanups (cleanups);
300 do_cleanups (cleanups);
303 /* The callback function used by lookup_symtab. */
306 lookup_symtab_callback (struct symtab *symtab, void *data)
308 struct symtab **result_ptr = data;
310 *result_ptr = symtab;
314 /* A wrapper for iterate_over_symtabs that returns the first matching
318 lookup_symtab (const char *name)
320 struct symtab *result = NULL;
322 iterate_over_symtabs (name, lookup_symtab_callback, &result);
327 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
328 full method name, which consist of the class name (from T), the unadorned
329 method name from METHOD_ID, and the signature for the specific overload,
330 specified by SIGNATURE_ID. Note that this function is g++ specific. */
333 gdb_mangle_name (struct type *type, int method_id, int signature_id)
335 int mangled_name_len;
337 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
338 struct fn_field *method = &f[signature_id];
339 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
340 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
341 const char *newname = type_name_no_tag (type);
343 /* Does the form of physname indicate that it is the full mangled name
344 of a constructor (not just the args)? */
345 int is_full_physname_constructor;
348 int is_destructor = is_destructor_name (physname);
349 /* Need a new type prefix. */
350 char *const_prefix = method->is_const ? "C" : "";
351 char *volatile_prefix = method->is_volatile ? "V" : "";
353 int len = (newname == NULL ? 0 : strlen (newname));
355 /* Nothing to do if physname already contains a fully mangled v3 abi name
356 or an operator name. */
357 if ((physname[0] == '_' && physname[1] == 'Z')
358 || is_operator_name (field_name))
359 return xstrdup (physname);
361 is_full_physname_constructor = is_constructor_name (physname);
363 is_constructor = is_full_physname_constructor
364 || (newname && strcmp (field_name, newname) == 0);
367 is_destructor = (strncmp (physname, "__dt", 4) == 0);
369 if (is_destructor || is_full_physname_constructor)
371 mangled_name = (char *) xmalloc (strlen (physname) + 1);
372 strcpy (mangled_name, physname);
378 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
380 else if (physname[0] == 't' || physname[0] == 'Q')
382 /* The physname for template and qualified methods already includes
384 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
390 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
391 volatile_prefix, len);
393 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
394 + strlen (buf) + len + strlen (physname) + 1);
396 mangled_name = (char *) xmalloc (mangled_name_len);
398 mangled_name[0] = '\0';
400 strcpy (mangled_name, field_name);
402 strcat (mangled_name, buf);
403 /* If the class doesn't have a name, i.e. newname NULL, then we just
404 mangle it using 0 for the length of the class. Thus it gets mangled
405 as something starting with `::' rather than `classname::'. */
407 strcat (mangled_name, newname);
409 strcat (mangled_name, physname);
410 return (mangled_name);
413 /* Initialize the cplus_specific structure. 'cplus_specific' should
414 only be allocated for use with cplus symbols. */
417 symbol_init_cplus_specific (struct general_symbol_info *gsymbol,
418 struct objfile *objfile)
420 /* A language_specific structure should not have been previously
422 gdb_assert (gsymbol->language_specific.cplus_specific == NULL);
423 gdb_assert (objfile != NULL);
425 gsymbol->language_specific.cplus_specific =
426 OBSTACK_ZALLOC (&objfile->objfile_obstack, struct cplus_specific);
429 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
430 correctly allocated. For C++ symbols a cplus_specific struct is
431 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
432 OBJFILE can be NULL. */
435 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
437 struct objfile *objfile)
439 if (gsymbol->language == language_cplus)
441 if (gsymbol->language_specific.cplus_specific == NULL)
442 symbol_init_cplus_specific (gsymbol, objfile);
444 gsymbol->language_specific.cplus_specific->demangled_name = name;
447 gsymbol->language_specific.mangled_lang.demangled_name = name;
450 /* Return the demangled name of GSYMBOL. */
453 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
455 if (gsymbol->language == language_cplus)
457 if (gsymbol->language_specific.cplus_specific != NULL)
458 return gsymbol->language_specific.cplus_specific->demangled_name;
463 return gsymbol->language_specific.mangled_lang.demangled_name;
467 /* Initialize the language dependent portion of a symbol
468 depending upon the language for the symbol. */
471 symbol_set_language (struct general_symbol_info *gsymbol,
472 enum language language)
474 gsymbol->language = language;
475 if (gsymbol->language == language_d
476 || gsymbol->language == language_go
477 || gsymbol->language == language_java
478 || gsymbol->language == language_objc
479 || gsymbol->language == language_fortran)
481 symbol_set_demangled_name (gsymbol, NULL, NULL);
483 else if (gsymbol->language == language_cplus)
484 gsymbol->language_specific.cplus_specific = NULL;
487 memset (&gsymbol->language_specific, 0,
488 sizeof (gsymbol->language_specific));
492 /* Functions to initialize a symbol's mangled name. */
494 /* Objects of this type are stored in the demangled name hash table. */
495 struct demangled_name_entry
501 /* Hash function for the demangled name hash. */
504 hash_demangled_name_entry (const void *data)
506 const struct demangled_name_entry *e = data;
508 return htab_hash_string (e->mangled);
511 /* Equality function for the demangled name hash. */
514 eq_demangled_name_entry (const void *a, const void *b)
516 const struct demangled_name_entry *da = a;
517 const struct demangled_name_entry *db = b;
519 return strcmp (da->mangled, db->mangled) == 0;
522 /* Create the hash table used for demangled names. Each hash entry is
523 a pair of strings; one for the mangled name and one for the demangled
524 name. The entry is hashed via just the mangled name. */
527 create_demangled_names_hash (struct objfile *objfile)
529 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
530 The hash table code will round this up to the next prime number.
531 Choosing a much larger table size wastes memory, and saves only about
532 1% in symbol reading. */
534 objfile->demangled_names_hash = htab_create_alloc
535 (256, hash_demangled_name_entry, eq_demangled_name_entry,
536 NULL, xcalloc, xfree);
539 /* Try to determine the demangled name for a symbol, based on the
540 language of that symbol. If the language is set to language_auto,
541 it will attempt to find any demangling algorithm that works and
542 then set the language appropriately. The returned name is allocated
543 by the demangler and should be xfree'd. */
546 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
549 char *demangled = NULL;
551 if (gsymbol->language == language_unknown)
552 gsymbol->language = language_auto;
554 if (gsymbol->language == language_objc
555 || gsymbol->language == language_auto)
558 objc_demangle (mangled, 0);
559 if (demangled != NULL)
561 gsymbol->language = language_objc;
565 if (gsymbol->language == language_cplus
566 || gsymbol->language == language_auto)
569 cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
570 if (demangled != NULL)
572 gsymbol->language = language_cplus;
576 if (gsymbol->language == language_java)
579 cplus_demangle (mangled,
580 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
581 if (demangled != NULL)
583 gsymbol->language = language_java;
587 if (gsymbol->language == language_d
588 || gsymbol->language == language_auto)
590 demangled = d_demangle(mangled, 0);
591 if (demangled != NULL)
593 gsymbol->language = language_d;
597 /* FIXME(dje): Continually adding languages here is clumsy.
598 Better to just call la_demangle if !auto, and if auto then call
599 a utility routine that tries successive languages in turn and reports
600 which one it finds. I realize the la_demangle options may be different
601 for different languages but there's already a FIXME for that. */
602 if (gsymbol->language == language_go
603 || gsymbol->language == language_auto)
605 demangled = go_demangle (mangled, 0);
606 if (demangled != NULL)
608 gsymbol->language = language_go;
613 /* We could support `gsymbol->language == language_fortran' here to provide
614 module namespaces also for inferiors with only minimal symbol table (ELF
615 symbols). Just the mangling standard is not standardized across compilers
616 and there is no DW_AT_producer available for inferiors with only the ELF
617 symbols to check the mangling kind. */
621 /* Set both the mangled and demangled (if any) names for GSYMBOL based
622 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
623 objfile's obstack; but if COPY_NAME is 0 and if NAME is
624 NUL-terminated, then this function assumes that NAME is already
625 correctly saved (either permanently or with a lifetime tied to the
626 objfile), and it will not be copied.
628 The hash table corresponding to OBJFILE is used, and the memory
629 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
630 so the pointer can be discarded after calling this function. */
632 /* We have to be careful when dealing with Java names: when we run
633 into a Java minimal symbol, we don't know it's a Java symbol, so it
634 gets demangled as a C++ name. This is unfortunate, but there's not
635 much we can do about it: but when demangling partial symbols and
636 regular symbols, we'd better not reuse the wrong demangled name.
637 (See PR gdb/1039.) We solve this by putting a distinctive prefix
638 on Java names when storing them in the hash table. */
640 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
641 don't mind the Java prefix so much: different languages have
642 different demangling requirements, so it's only natural that we
643 need to keep language data around in our demangling cache. But
644 it's not good that the minimal symbol has the wrong demangled name.
645 Unfortunately, I can't think of any easy solution to that
648 #define JAVA_PREFIX "##JAVA$$"
649 #define JAVA_PREFIX_LEN 8
652 symbol_set_names (struct general_symbol_info *gsymbol,
653 const char *linkage_name, int len, int copy_name,
654 struct objfile *objfile)
656 struct demangled_name_entry **slot;
657 /* A 0-terminated copy of the linkage name. */
658 const char *linkage_name_copy;
659 /* A copy of the linkage name that might have a special Java prefix
660 added to it, for use when looking names up in the hash table. */
661 const char *lookup_name;
662 /* The length of lookup_name. */
664 struct demangled_name_entry entry;
666 if (gsymbol->language == language_ada)
668 /* In Ada, we do the symbol lookups using the mangled name, so
669 we can save some space by not storing the demangled name.
671 As a side note, we have also observed some overlap between
672 the C++ mangling and Ada mangling, similarly to what has
673 been observed with Java. Because we don't store the demangled
674 name with the symbol, we don't need to use the same trick
677 gsymbol->name = linkage_name;
680 char *name = obstack_alloc (&objfile->objfile_obstack, len + 1);
682 memcpy (name, linkage_name, len);
684 gsymbol->name = name;
686 symbol_set_demangled_name (gsymbol, NULL, NULL);
691 if (objfile->demangled_names_hash == NULL)
692 create_demangled_names_hash (objfile);
694 /* The stabs reader generally provides names that are not
695 NUL-terminated; most of the other readers don't do this, so we
696 can just use the given copy, unless we're in the Java case. */
697 if (gsymbol->language == language_java)
701 lookup_len = len + JAVA_PREFIX_LEN;
702 alloc_name = alloca (lookup_len + 1);
703 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
704 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
705 alloc_name[lookup_len] = '\0';
707 lookup_name = alloc_name;
708 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
710 else if (linkage_name[len] != '\0')
715 alloc_name = alloca (lookup_len + 1);
716 memcpy (alloc_name, linkage_name, len);
717 alloc_name[lookup_len] = '\0';
719 lookup_name = alloc_name;
720 linkage_name_copy = alloc_name;
725 lookup_name = linkage_name;
726 linkage_name_copy = linkage_name;
729 entry.mangled = lookup_name;
730 slot = ((struct demangled_name_entry **)
731 htab_find_slot (objfile->demangled_names_hash,
734 /* If this name is not in the hash table, add it. */
736 /* A C version of the symbol may have already snuck into the table.
737 This happens to, e.g., main.init (__go_init_main). Cope. */
738 || (gsymbol->language == language_go
739 && (*slot)->demangled[0] == '\0'))
741 char *demangled_name = symbol_find_demangled_name (gsymbol,
743 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
745 /* Suppose we have demangled_name==NULL, copy_name==0, and
746 lookup_name==linkage_name. In this case, we already have the
747 mangled name saved, and we don't have a demangled name. So,
748 you might think we could save a little space by not recording
749 this in the hash table at all.
751 It turns out that it is actually important to still save such
752 an entry in the hash table, because storing this name gives
753 us better bcache hit rates for partial symbols. */
754 if (!copy_name && lookup_name == linkage_name)
756 *slot = obstack_alloc (&objfile->objfile_obstack,
757 offsetof (struct demangled_name_entry,
759 + demangled_len + 1);
760 (*slot)->mangled = lookup_name;
766 /* If we must copy the mangled name, put it directly after
767 the demangled name so we can have a single
769 *slot = obstack_alloc (&objfile->objfile_obstack,
770 offsetof (struct demangled_name_entry,
772 + lookup_len + demangled_len + 2);
773 mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
774 strcpy (mangled_ptr, lookup_name);
775 (*slot)->mangled = mangled_ptr;
778 if (demangled_name != NULL)
780 strcpy ((*slot)->demangled, demangled_name);
781 xfree (demangled_name);
784 (*slot)->demangled[0] = '\0';
787 gsymbol->name = (*slot)->mangled + lookup_len - len;
788 if ((*slot)->demangled[0] != '\0')
789 symbol_set_demangled_name (gsymbol, (*slot)->demangled, objfile);
791 symbol_set_demangled_name (gsymbol, NULL, objfile);
794 /* Return the source code name of a symbol. In languages where
795 demangling is necessary, this is the demangled name. */
798 symbol_natural_name (const struct general_symbol_info *gsymbol)
800 switch (gsymbol->language)
807 case language_fortran:
808 if (symbol_get_demangled_name (gsymbol) != NULL)
809 return symbol_get_demangled_name (gsymbol);
812 if (symbol_get_demangled_name (gsymbol) != NULL)
813 return symbol_get_demangled_name (gsymbol);
815 return ada_decode_symbol (gsymbol);
820 return gsymbol->name;
823 /* Return the demangled name for a symbol based on the language for
824 that symbol. If no demangled name exists, return NULL. */
827 symbol_demangled_name (const struct general_symbol_info *gsymbol)
829 const char *dem_name = NULL;
831 switch (gsymbol->language)
838 case language_fortran:
839 dem_name = symbol_get_demangled_name (gsymbol);
842 dem_name = symbol_get_demangled_name (gsymbol);
843 if (dem_name == NULL)
844 dem_name = ada_decode_symbol (gsymbol);
852 /* Return the search name of a symbol---generally the demangled or
853 linkage name of the symbol, depending on how it will be searched for.
854 If there is no distinct demangled name, then returns the same value
855 (same pointer) as SYMBOL_LINKAGE_NAME. */
858 symbol_search_name (const struct general_symbol_info *gsymbol)
860 if (gsymbol->language == language_ada)
861 return gsymbol->name;
863 return symbol_natural_name (gsymbol);
866 /* Initialize the structure fields to zero values. */
869 init_sal (struct symtab_and_line *sal)
877 sal->explicit_pc = 0;
878 sal->explicit_line = 0;
883 /* Return 1 if the two sections are the same, or if they could
884 plausibly be copies of each other, one in an original object
885 file and another in a separated debug file. */
888 matching_obj_sections (struct obj_section *obj_first,
889 struct obj_section *obj_second)
891 asection *first = obj_first? obj_first->the_bfd_section : NULL;
892 asection *second = obj_second? obj_second->the_bfd_section : NULL;
895 /* If they're the same section, then they match. */
899 /* If either is NULL, give up. */
900 if (first == NULL || second == NULL)
903 /* This doesn't apply to absolute symbols. */
904 if (first->owner == NULL || second->owner == NULL)
907 /* If they're in the same object file, they must be different sections. */
908 if (first->owner == second->owner)
911 /* Check whether the two sections are potentially corresponding. They must
912 have the same size, address, and name. We can't compare section indexes,
913 which would be more reliable, because some sections may have been
915 if (bfd_get_section_size (first) != bfd_get_section_size (second))
918 /* In-memory addresses may start at a different offset, relativize them. */
919 if (bfd_get_section_vma (first->owner, first)
920 - bfd_get_start_address (first->owner)
921 != bfd_get_section_vma (second->owner, second)
922 - bfd_get_start_address (second->owner))
925 if (bfd_get_section_name (first->owner, first) == NULL
926 || bfd_get_section_name (second->owner, second) == NULL
927 || strcmp (bfd_get_section_name (first->owner, first),
928 bfd_get_section_name (second->owner, second)) != 0)
931 /* Otherwise check that they are in corresponding objfiles. */
934 if (obj->obfd == first->owner)
936 gdb_assert (obj != NULL);
938 if (obj->separate_debug_objfile != NULL
939 && obj->separate_debug_objfile->obfd == second->owner)
941 if (obj->separate_debug_objfile_backlink != NULL
942 && obj->separate_debug_objfile_backlink->obfd == second->owner)
949 find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
951 struct objfile *objfile;
952 struct minimal_symbol *msymbol;
954 /* If we know that this is not a text address, return failure. This is
955 necessary because we loop based on texthigh and textlow, which do
956 not include the data ranges. */
957 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
959 && (MSYMBOL_TYPE (msymbol) == mst_data
960 || MSYMBOL_TYPE (msymbol) == mst_bss
961 || MSYMBOL_TYPE (msymbol) == mst_abs
962 || MSYMBOL_TYPE (msymbol) == mst_file_data
963 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
966 ALL_OBJFILES (objfile)
968 struct symtab *result = NULL;
971 result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
980 /* Debug symbols usually don't have section information. We need to dig that
981 out of the minimal symbols and stash that in the debug symbol. */
984 fixup_section (struct general_symbol_info *ginfo,
985 CORE_ADDR addr, struct objfile *objfile)
987 struct minimal_symbol *msym;
989 /* First, check whether a minimal symbol with the same name exists
990 and points to the same address. The address check is required
991 e.g. on PowerPC64, where the minimal symbol for a function will
992 point to the function descriptor, while the debug symbol will
993 point to the actual function code. */
994 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
997 ginfo->obj_section = SYMBOL_OBJ_SECTION (msym);
998 ginfo->section = SYMBOL_SECTION (msym);
1002 /* Static, function-local variables do appear in the linker
1003 (minimal) symbols, but are frequently given names that won't
1004 be found via lookup_minimal_symbol(). E.g., it has been
1005 observed in frv-uclinux (ELF) executables that a static,
1006 function-local variable named "foo" might appear in the
1007 linker symbols as "foo.6" or "foo.3". Thus, there is no
1008 point in attempting to extend the lookup-by-name mechanism to
1009 handle this case due to the fact that there can be multiple
1012 So, instead, search the section table when lookup by name has
1013 failed. The ``addr'' and ``endaddr'' fields may have already
1014 been relocated. If so, the relocation offset (i.e. the
1015 ANOFFSET value) needs to be subtracted from these values when
1016 performing the comparison. We unconditionally subtract it,
1017 because, when no relocation has been performed, the ANOFFSET
1018 value will simply be zero.
1020 The address of the symbol whose section we're fixing up HAS
1021 NOT BEEN adjusted (relocated) yet. It can't have been since
1022 the section isn't yet known and knowing the section is
1023 necessary in order to add the correct relocation value. In
1024 other words, we wouldn't even be in this function (attempting
1025 to compute the section) if it were already known.
1027 Note that it is possible to search the minimal symbols
1028 (subtracting the relocation value if necessary) to find the
1029 matching minimal symbol, but this is overkill and much less
1030 efficient. It is not necessary to find the matching minimal
1031 symbol, only its section.
1033 Note that this technique (of doing a section table search)
1034 can fail when unrelocated section addresses overlap. For
1035 this reason, we still attempt a lookup by name prior to doing
1036 a search of the section table. */
1038 struct obj_section *s;
1040 ALL_OBJFILE_OSECTIONS (objfile, s)
1042 int idx = s->the_bfd_section->index;
1043 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1045 if (obj_section_addr (s) - offset <= addr
1046 && addr < obj_section_endaddr (s) - offset)
1048 ginfo->obj_section = s;
1049 ginfo->section = idx;
1057 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1064 if (SYMBOL_OBJ_SECTION (sym))
1067 /* We either have an OBJFILE, or we can get at it from the sym's
1068 symtab. Anything else is a bug. */
1069 gdb_assert (objfile || SYMBOL_SYMTAB (sym));
1071 if (objfile == NULL)
1072 objfile = SYMBOL_SYMTAB (sym)->objfile;
1074 /* We should have an objfile by now. */
1075 gdb_assert (objfile);
1077 switch (SYMBOL_CLASS (sym))
1081 addr = SYMBOL_VALUE_ADDRESS (sym);
1084 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1088 /* Nothing else will be listed in the minsyms -- no use looking
1093 fixup_section (&sym->ginfo, addr, objfile);
1098 /* Compute the demangled form of NAME as used by the various symbol
1099 lookup functions. The result is stored in *RESULT_NAME. Returns a
1100 cleanup which can be used to clean up the result.
1102 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1103 Normally, Ada symbol lookups are performed using the encoded name
1104 rather than the demangled name, and so it might seem to make sense
1105 for this function to return an encoded version of NAME.
1106 Unfortunately, we cannot do this, because this function is used in
1107 circumstances where it is not appropriate to try to encode NAME.
1108 For instance, when displaying the frame info, we demangle the name
1109 of each parameter, and then perform a symbol lookup inside our
1110 function using that demangled name. In Ada, certain functions
1111 have internally-generated parameters whose name contain uppercase
1112 characters. Encoding those name would result in those uppercase
1113 characters to become lowercase, and thus cause the symbol lookup
1117 demangle_for_lookup (const char *name, enum language lang,
1118 const char **result_name)
1120 char *demangled_name = NULL;
1121 const char *modified_name = NULL;
1122 struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
1124 modified_name = name;
1126 /* If we are using C++, D, Go, or Java, demangle the name before doing a
1127 lookup, so we can always binary search. */
1128 if (lang == language_cplus)
1130 demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1133 modified_name = demangled_name;
1134 make_cleanup (xfree, demangled_name);
1138 /* If we were given a non-mangled name, canonicalize it
1139 according to the language (so far only for C++). */
1140 demangled_name = cp_canonicalize_string (name);
1143 modified_name = demangled_name;
1144 make_cleanup (xfree, demangled_name);
1148 else if (lang == language_java)
1150 demangled_name = cplus_demangle (name,
1151 DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1154 modified_name = demangled_name;
1155 make_cleanup (xfree, demangled_name);
1158 else if (lang == language_d)
1160 demangled_name = d_demangle (name, 0);
1163 modified_name = demangled_name;
1164 make_cleanup (xfree, demangled_name);
1167 else if (lang == language_go)
1169 demangled_name = go_demangle (name, 0);
1172 modified_name = demangled_name;
1173 make_cleanup (xfree, demangled_name);
1177 *result_name = modified_name;
1181 /* Find the definition for a specified symbol name NAME
1182 in domain DOMAIN, visible from lexical block BLOCK.
1183 Returns the struct symbol pointer, or zero if no symbol is found.
1184 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1185 NAME is a field of the current implied argument `this'. If so set
1186 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1187 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1188 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1190 /* This function (or rather its subordinates) have a bunch of loops and
1191 it would seem to be attractive to put in some QUIT's (though I'm not really
1192 sure whether it can run long enough to be really important). But there
1193 are a few calls for which it would appear to be bad news to quit
1194 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1195 that there is C++ code below which can error(), but that probably
1196 doesn't affect these calls since they are looking for a known
1197 variable and thus can probably assume it will never hit the C++
1201 lookup_symbol_in_language (const char *name, const struct block *block,
1202 const domain_enum domain, enum language lang,
1203 struct field_of_this_result *is_a_field_of_this)
1205 const char *modified_name;
1206 struct symbol *returnval;
1207 struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
1209 returnval = lookup_symbol_aux (modified_name, block, domain, lang,
1210 is_a_field_of_this);
1211 do_cleanups (cleanup);
1216 /* Behave like lookup_symbol_in_language, but performed with the
1217 current language. */
1220 lookup_symbol (const char *name, const struct block *block,
1222 struct field_of_this_result *is_a_field_of_this)
1224 return lookup_symbol_in_language (name, block, domain,
1225 current_language->la_language,
1226 is_a_field_of_this);
1229 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1230 found, or NULL if not found. */
1233 lookup_language_this (const struct language_defn *lang,
1234 const struct block *block)
1236 if (lang->la_name_of_this == NULL || block == NULL)
1243 sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1246 block_found = block;
1249 if (BLOCK_FUNCTION (block))
1251 block = BLOCK_SUPERBLOCK (block);
1257 /* Given TYPE, a structure/union,
1258 return 1 if the component named NAME from the ultimate target
1259 structure/union is defined, otherwise, return 0. */
1262 check_field (struct type *type, const char *name,
1263 struct field_of_this_result *is_a_field_of_this)
1267 /* The type may be a stub. */
1268 CHECK_TYPEDEF (type);
1270 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1272 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1274 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1276 is_a_field_of_this->type = type;
1277 is_a_field_of_this->field = &TYPE_FIELD (type, i);
1282 /* C++: If it was not found as a data field, then try to return it
1283 as a pointer to a method. */
1285 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1287 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1289 is_a_field_of_this->type = type;
1290 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1295 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1296 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
1302 /* Behave like lookup_symbol except that NAME is the natural name
1303 (e.g., demangled name) of the symbol that we're looking for. */
1305 static struct symbol *
1306 lookup_symbol_aux (const char *name, const struct block *block,
1307 const domain_enum domain, enum language language,
1308 struct field_of_this_result *is_a_field_of_this)
1311 const struct language_defn *langdef;
1313 /* Make sure we do something sensible with is_a_field_of_this, since
1314 the callers that set this parameter to some non-null value will
1315 certainly use it later. If we don't set it, the contents of
1316 is_a_field_of_this are undefined. */
1317 if (is_a_field_of_this != NULL)
1318 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
1320 /* Search specified block and its superiors. Don't search
1321 STATIC_BLOCK or GLOBAL_BLOCK. */
1323 sym = lookup_symbol_aux_local (name, block, domain, language);
1327 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1328 check to see if NAME is a field of `this'. */
1330 langdef = language_def (language);
1332 /* Don't do this check if we are searching for a struct. It will
1333 not be found by check_field, but will be found by other
1335 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
1337 struct symbol *sym = lookup_language_this (langdef, block);
1341 struct type *t = sym->type;
1343 /* I'm not really sure that type of this can ever
1344 be typedefed; just be safe. */
1346 if (TYPE_CODE (t) == TYPE_CODE_PTR
1347 || TYPE_CODE (t) == TYPE_CODE_REF)
1348 t = TYPE_TARGET_TYPE (t);
1350 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1351 && TYPE_CODE (t) != TYPE_CODE_UNION)
1352 error (_("Internal error: `%s' is not an aggregate"),
1353 langdef->la_name_of_this);
1355 if (check_field (t, name, is_a_field_of_this))
1360 /* Now do whatever is appropriate for LANGUAGE to look
1361 up static and global variables. */
1363 sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
1367 /* Now search all static file-level symbols. Not strictly correct,
1368 but more useful than an error. */
1370 return lookup_static_symbol_aux (name, domain);
1373 /* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1374 first, then check the psymtabs. If a psymtab indicates the existence of the
1375 desired name as a file-level static, then do psymtab-to-symtab conversion on
1376 the fly and return the found symbol. */
1379 lookup_static_symbol_aux (const char *name, const domain_enum domain)
1381 struct objfile *objfile;
1384 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
1388 ALL_OBJFILES (objfile)
1390 sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
1398 /* Check to see if the symbol is defined in BLOCK or its superiors.
1399 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1401 static struct symbol *
1402 lookup_symbol_aux_local (const char *name, const struct block *block,
1403 const domain_enum domain,
1404 enum language language)
1407 const struct block *static_block = block_static_block (block);
1408 const char *scope = block_scope (block);
1410 /* Check if either no block is specified or it's a global block. */
1412 if (static_block == NULL)
1415 while (block != static_block)
1417 sym = lookup_symbol_aux_block (name, block, domain);
1421 if (language == language_cplus || language == language_fortran)
1423 sym = cp_lookup_symbol_imports_or_template (scope, name, block,
1429 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
1431 block = BLOCK_SUPERBLOCK (block);
1434 /* We've reached the edge of the function without finding a result. */
1439 /* Look up OBJFILE to BLOCK. */
1442 lookup_objfile_from_block (const struct block *block)
1444 struct objfile *obj;
1450 block = block_global_block (block);
1451 /* Go through SYMTABS. */
1452 ALL_SYMTABS (obj, s)
1453 if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
1455 if (obj->separate_debug_objfile_backlink)
1456 obj = obj->separate_debug_objfile_backlink;
1464 /* Look up a symbol in a block; if found, fixup the symbol, and set
1465 block_found appropriately. */
1468 lookup_symbol_aux_block (const char *name, const struct block *block,
1469 const domain_enum domain)
1473 sym = lookup_block_symbol (block, name, domain);
1476 block_found = block;
1477 return fixup_symbol_section (sym, NULL);
1483 /* Check all global symbols in OBJFILE in symtabs and
1487 lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
1489 const domain_enum domain)
1491 const struct objfile *objfile;
1493 struct blockvector *bv;
1494 const struct block *block;
1497 for (objfile = main_objfile;
1499 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
1501 /* Go through symtabs. */
1502 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1504 bv = BLOCKVECTOR (s);
1505 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1506 sym = lookup_block_symbol (block, name, domain);
1509 block_found = block;
1510 return fixup_symbol_section (sym, (struct objfile *)objfile);
1514 sym = lookup_symbol_aux_quick ((struct objfile *) objfile, GLOBAL_BLOCK,
1523 /* Check to see if the symbol is defined in one of the OBJFILE's
1524 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1525 depending on whether or not we want to search global symbols or
1528 static struct symbol *
1529 lookup_symbol_aux_objfile (struct objfile *objfile, int block_index,
1530 const char *name, const domain_enum domain)
1532 struct symbol *sym = NULL;
1533 struct blockvector *bv;
1534 const struct block *block;
1537 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1539 bv = BLOCKVECTOR (s);
1540 block = BLOCKVECTOR_BLOCK (bv, block_index);
1541 sym = lookup_block_symbol (block, name, domain);
1544 block_found = block;
1545 return fixup_symbol_section (sym, objfile);
1552 /* Same as lookup_symbol_aux_objfile, except that it searches all
1553 objfiles. Return the first match found. */
1555 static struct symbol *
1556 lookup_symbol_aux_symtabs (int block_index, const char *name,
1557 const domain_enum domain)
1560 struct objfile *objfile;
1562 ALL_OBJFILES (objfile)
1564 sym = lookup_symbol_aux_objfile (objfile, block_index, name, domain);
1572 /* Wrapper around lookup_symbol_aux_objfile for search_symbols.
1573 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1574 and all related objfiles. */
1576 static struct symbol *
1577 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
1578 const char *linkage_name,
1581 enum language lang = current_language->la_language;
1582 const char *modified_name;
1583 struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang,
1585 struct objfile *main_objfile, *cur_objfile;
1587 if (objfile->separate_debug_objfile_backlink)
1588 main_objfile = objfile->separate_debug_objfile_backlink;
1590 main_objfile = objfile;
1592 for (cur_objfile = main_objfile;
1594 cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
1598 sym = lookup_symbol_aux_objfile (cur_objfile, GLOBAL_BLOCK,
1599 modified_name, domain);
1601 sym = lookup_symbol_aux_objfile (cur_objfile, STATIC_BLOCK,
1602 modified_name, domain);
1605 do_cleanups (cleanup);
1610 do_cleanups (cleanup);
1614 /* A helper function for lookup_symbol_aux that interfaces with the
1615 "quick" symbol table functions. */
1617 static struct symbol *
1618 lookup_symbol_aux_quick (struct objfile *objfile, int kind,
1619 const char *name, const domain_enum domain)
1621 struct symtab *symtab;
1622 struct blockvector *bv;
1623 const struct block *block;
1628 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, domain);
1632 bv = BLOCKVECTOR (symtab);
1633 block = BLOCKVECTOR_BLOCK (bv, kind);
1634 sym = lookup_block_symbol (block, name, domain);
1637 /* This shouldn't be necessary, but as a last resort try
1638 looking in the statics even though the psymtab claimed
1639 the symbol was global, or vice-versa. It's possible
1640 that the psymtab gets it wrong in some cases. */
1642 /* FIXME: carlton/2002-09-30: Should we really do that?
1643 If that happens, isn't it likely to be a GDB error, in
1644 which case we should fix the GDB error rather than
1645 silently dealing with it here? So I'd vote for
1646 removing the check for the symbol in the other
1648 block = BLOCKVECTOR_BLOCK (bv,
1649 kind == GLOBAL_BLOCK ?
1650 STATIC_BLOCK : GLOBAL_BLOCK);
1651 sym = lookup_block_symbol (block, name, domain);
1654 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1655 %s may be an inlined function, or may be a template function\n\
1656 (if a template, try specifying an instantiation: %s<type>)."),
1657 kind == GLOBAL_BLOCK ? "global" : "static",
1658 name, symtab->filename, name, name);
1660 return fixup_symbol_section (sym, objfile);
1663 /* A default version of lookup_symbol_nonlocal for use by languages
1664 that can't think of anything better to do. This implements the C
1668 basic_lookup_symbol_nonlocal (const char *name,
1669 const struct block *block,
1670 const domain_enum domain)
1674 /* NOTE: carlton/2003-05-19: The comments below were written when
1675 this (or what turned into this) was part of lookup_symbol_aux;
1676 I'm much less worried about these questions now, since these
1677 decisions have turned out well, but I leave these comments here
1680 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1681 not it would be appropriate to search the current global block
1682 here as well. (That's what this code used to do before the
1683 is_a_field_of_this check was moved up.) On the one hand, it's
1684 redundant with the lookup_symbol_aux_symtabs search that happens
1685 next. On the other hand, if decode_line_1 is passed an argument
1686 like filename:var, then the user presumably wants 'var' to be
1687 searched for in filename. On the third hand, there shouldn't be
1688 multiple global variables all of which are named 'var', and it's
1689 not like decode_line_1 has ever restricted its search to only
1690 global variables in a single filename. All in all, only
1691 searching the static block here seems best: it's correct and it's
1694 /* NOTE: carlton/2002-12-05: There's also a possible performance
1695 issue here: if you usually search for global symbols in the
1696 current file, then it would be slightly better to search the
1697 current global block before searching all the symtabs. But there
1698 are other factors that have a much greater effect on performance
1699 than that one, so I don't think we should worry about that for
1702 sym = lookup_symbol_static (name, block, domain);
1706 return lookup_symbol_global (name, block, domain);
1709 /* Lookup a symbol in the static block associated to BLOCK, if there
1710 is one; do nothing if BLOCK is NULL or a global block. */
1713 lookup_symbol_static (const char *name,
1714 const struct block *block,
1715 const domain_enum domain)
1717 const struct block *static_block = block_static_block (block);
1719 if (static_block != NULL)
1720 return lookup_symbol_aux_block (name, static_block, domain);
1725 /* Private data to be used with lookup_symbol_global_iterator_cb. */
1727 struct global_sym_lookup_data
1729 /* The name of the symbol we are searching for. */
1732 /* The domain to use for our search. */
1735 /* The field where the callback should store the symbol if found.
1736 It should be initialized to NULL before the search is started. */
1737 struct symbol *result;
1740 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1741 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1742 OBJFILE. The arguments for the search are passed via CB_DATA,
1743 which in reality is a pointer to struct global_sym_lookup_data. */
1746 lookup_symbol_global_iterator_cb (struct objfile *objfile,
1749 struct global_sym_lookup_data *data =
1750 (struct global_sym_lookup_data *) cb_data;
1752 gdb_assert (data->result == NULL);
1754 data->result = lookup_symbol_aux_objfile (objfile, GLOBAL_BLOCK,
1755 data->name, data->domain);
1756 if (data->result == NULL)
1757 data->result = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK,
1758 data->name, data->domain);
1760 /* If we found a match, tell the iterator to stop. Otherwise,
1762 return (data->result != NULL);
1765 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1769 lookup_symbol_global (const char *name,
1770 const struct block *block,
1771 const domain_enum domain)
1773 struct symbol *sym = NULL;
1774 struct objfile *objfile = NULL;
1775 struct global_sym_lookup_data lookup_data;
1777 /* Call library-specific lookup procedure. */
1778 objfile = lookup_objfile_from_block (block);
1779 if (objfile != NULL)
1780 sym = solib_global_lookup (objfile, name, domain);
1784 memset (&lookup_data, 0, sizeof (lookup_data));
1785 lookup_data.name = name;
1786 lookup_data.domain = domain;
1787 gdbarch_iterate_over_objfiles_in_search_order
1788 (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
1789 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
1791 return lookup_data.result;
1795 symbol_matches_domain (enum language symbol_language,
1796 domain_enum symbol_domain,
1799 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1800 A Java class declaration also defines a typedef for the class.
1801 Similarly, any Ada type declaration implicitly defines a typedef. */
1802 if (symbol_language == language_cplus
1803 || symbol_language == language_d
1804 || symbol_language == language_java
1805 || symbol_language == language_ada)
1807 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
1808 && symbol_domain == STRUCT_DOMAIN)
1811 /* For all other languages, strict match is required. */
1812 return (symbol_domain == domain);
1815 /* Look up a type named NAME in the struct_domain. The type returned
1816 must not be opaque -- i.e., must have at least one field
1820 lookup_transparent_type (const char *name)
1822 return current_language->la_lookup_transparent_type (name);
1825 /* A helper for basic_lookup_transparent_type that interfaces with the
1826 "quick" symbol table functions. */
1828 static struct type *
1829 basic_lookup_transparent_type_quick (struct objfile *objfile, int kind,
1832 struct symtab *symtab;
1833 struct blockvector *bv;
1834 struct block *block;
1839 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, STRUCT_DOMAIN);
1843 bv = BLOCKVECTOR (symtab);
1844 block = BLOCKVECTOR_BLOCK (bv, kind);
1845 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1848 int other_kind = kind == GLOBAL_BLOCK ? STATIC_BLOCK : GLOBAL_BLOCK;
1850 /* This shouldn't be necessary, but as a last resort
1851 * try looking in the 'other kind' even though the psymtab
1852 * claimed the symbol was one thing. It's possible that
1853 * the psymtab gets it wrong in some cases.
1855 block = BLOCKVECTOR_BLOCK (bv, other_kind);
1856 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1858 /* FIXME; error is wrong in one case. */
1860 Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1861 %s may be an inlined function, or may be a template function\n\
1862 (if a template, try specifying an instantiation: %s<type>)."),
1863 name, symtab->filename, name, name);
1865 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1866 return SYMBOL_TYPE (sym);
1871 /* The standard implementation of lookup_transparent_type. This code
1872 was modeled on lookup_symbol -- the parts not relevant to looking
1873 up types were just left out. In particular it's assumed here that
1874 types are available in struct_domain and only at file-static or
1878 basic_lookup_transparent_type (const char *name)
1881 struct symtab *s = NULL;
1882 struct blockvector *bv;
1883 struct objfile *objfile;
1884 struct block *block;
1887 /* Now search all the global symbols. Do the symtab's first, then
1888 check the psymtab's. If a psymtab indicates the existence
1889 of the desired name as a global, then do psymtab-to-symtab
1890 conversion on the fly and return the found symbol. */
1892 ALL_OBJFILES (objfile)
1894 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1896 bv = BLOCKVECTOR (s);
1897 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1898 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1899 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1901 return SYMBOL_TYPE (sym);
1906 ALL_OBJFILES (objfile)
1908 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
1913 /* Now search the static file-level symbols.
1914 Not strictly correct, but more useful than an error.
1915 Do the symtab's first, then
1916 check the psymtab's. If a psymtab indicates the existence
1917 of the desired name as a file-level static, then do psymtab-to-symtab
1918 conversion on the fly and return the found symbol. */
1920 ALL_OBJFILES (objfile)
1922 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1924 bv = BLOCKVECTOR (s);
1925 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1926 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1927 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1929 return SYMBOL_TYPE (sym);
1934 ALL_OBJFILES (objfile)
1936 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
1941 return (struct type *) 0;
1944 /* Find the name of the file containing main(). */
1945 /* FIXME: What about languages without main() or specially linked
1946 executables that have no main() ? */
1949 find_main_filename (void)
1951 struct objfile *objfile;
1952 char *name = main_name ();
1954 ALL_OBJFILES (objfile)
1960 result = objfile->sf->qf->find_symbol_file (objfile, name);
1967 /* Search BLOCK for symbol NAME in DOMAIN.
1969 Note that if NAME is the demangled form of a C++ symbol, we will fail
1970 to find a match during the binary search of the non-encoded names, but
1971 for now we don't worry about the slight inefficiency of looking for
1972 a match we'll never find, since it will go pretty quick. Once the
1973 binary search terminates, we drop through and do a straight linear
1974 search on the symbols. Each symbol which is marked as being a ObjC/C++
1975 symbol (language_cplus or language_objc set) has both the encoded and
1976 non-encoded names tested for a match. */
1979 lookup_block_symbol (const struct block *block, const char *name,
1980 const domain_enum domain)
1982 struct block_iterator iter;
1985 if (!BLOCK_FUNCTION (block))
1987 for (sym = block_iter_name_first (block, name, &iter);
1989 sym = block_iter_name_next (name, &iter))
1991 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1992 SYMBOL_DOMAIN (sym), domain))
1999 /* Note that parameter symbols do not always show up last in the
2000 list; this loop makes sure to take anything else other than
2001 parameter symbols first; it only uses parameter symbols as a
2002 last resort. Note that this only takes up extra computation
2005 struct symbol *sym_found = NULL;
2007 for (sym = block_iter_name_first (block, name, &iter);
2009 sym = block_iter_name_next (name, &iter))
2011 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2012 SYMBOL_DOMAIN (sym), domain))
2015 if (!SYMBOL_IS_ARGUMENT (sym))
2021 return (sym_found); /* Will be NULL if not found. */
2025 /* Iterate over the symbols named NAME, matching DOMAIN, starting with
2028 For each symbol that matches, CALLBACK is called. The symbol and
2029 DATA are passed to the callback.
2031 If CALLBACK returns zero, the iteration ends. Otherwise, the
2032 search continues. This function iterates upward through blocks.
2033 When the outermost block has been finished, the function
2037 iterate_over_symbols (const struct block *block, const char *name,
2038 const domain_enum domain,
2039 symbol_found_callback_ftype *callback,
2044 struct block_iterator iter;
2047 for (sym = block_iter_name_first (block, name, &iter);
2049 sym = block_iter_name_next (name, &iter))
2051 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2052 SYMBOL_DOMAIN (sym), domain))
2054 if (!callback (sym, data))
2059 block = BLOCK_SUPERBLOCK (block);
2063 /* Find the symtab associated with PC and SECTION. Look through the
2064 psymtabs and read in another symtab if necessary. */
2067 find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
2070 struct blockvector *bv;
2071 struct symtab *s = NULL;
2072 struct symtab *best_s = NULL;
2073 struct objfile *objfile;
2074 CORE_ADDR distance = 0;
2075 struct minimal_symbol *msymbol;
2077 /* If we know that this is not a text address, return failure. This is
2078 necessary because we loop based on the block's high and low code
2079 addresses, which do not include the data ranges, and because
2080 we call find_pc_sect_psymtab which has a similar restriction based
2081 on the partial_symtab's texthigh and textlow. */
2082 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2084 && (MSYMBOL_TYPE (msymbol) == mst_data
2085 || MSYMBOL_TYPE (msymbol) == mst_bss
2086 || MSYMBOL_TYPE (msymbol) == mst_abs
2087 || MSYMBOL_TYPE (msymbol) == mst_file_data
2088 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
2091 /* Search all symtabs for the one whose file contains our address, and which
2092 is the smallest of all the ones containing the address. This is designed
2093 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2094 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2095 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2097 This happens for native ecoff format, where code from included files
2098 gets its own symtab. The symtab for the included file should have
2099 been read in already via the dependency mechanism.
2100 It might be swifter to create several symtabs with the same name
2101 like xcoff does (I'm not sure).
2103 It also happens for objfiles that have their functions reordered.
2104 For these, the symtab we are looking for is not necessarily read in. */
2106 ALL_PRIMARY_SYMTABS (objfile, s)
2108 bv = BLOCKVECTOR (s);
2109 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2111 if (BLOCK_START (b) <= pc
2112 && BLOCK_END (b) > pc
2114 || BLOCK_END (b) - BLOCK_START (b) < distance))
2116 /* For an objfile that has its functions reordered,
2117 find_pc_psymtab will find the proper partial symbol table
2118 and we simply return its corresponding symtab. */
2119 /* In order to better support objfiles that contain both
2120 stabs and coff debugging info, we continue on if a psymtab
2122 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2124 struct symtab *result;
2127 = objfile->sf->qf->find_pc_sect_symtab (objfile,
2136 struct block_iterator iter;
2137 struct symbol *sym = NULL;
2139 ALL_BLOCK_SYMBOLS (b, iter, sym)
2141 fixup_symbol_section (sym, objfile);
2142 if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym), section))
2146 continue; /* No symbol in this symtab matches
2149 distance = BLOCK_END (b) - BLOCK_START (b);
2157 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2159 ALL_OBJFILES (objfile)
2161 struct symtab *result;
2165 result = objfile->sf->qf->find_pc_sect_symtab (objfile,
2176 /* Find the symtab associated with PC. Look through the psymtabs and read
2177 in another symtab if necessary. Backward compatibility, no section. */
2180 find_pc_symtab (CORE_ADDR pc)
2182 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
2186 /* Find the source file and line number for a given PC value and SECTION.
2187 Return a structure containing a symtab pointer, a line number,
2188 and a pc range for the entire source line.
2189 The value's .pc field is NOT the specified pc.
2190 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2191 use the line that ends there. Otherwise, in that case, the line
2192 that begins there is used. */
2194 /* The big complication here is that a line may start in one file, and end just
2195 before the start of another file. This usually occurs when you #include
2196 code in the middle of a subroutine. To properly find the end of a line's PC
2197 range, we must search all symtabs associated with this compilation unit, and
2198 find the one whose first PC is closer than that of the next line in this
2201 /* If it's worth the effort, we could be using a binary search. */
2203 struct symtab_and_line
2204 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
2207 struct linetable *l;
2210 struct linetable_entry *item;
2211 struct symtab_and_line val;
2212 struct blockvector *bv;
2213 struct minimal_symbol *msymbol;
2214 struct minimal_symbol *mfunsym;
2215 struct objfile *objfile;
2217 /* Info on best line seen so far, and where it starts, and its file. */
2219 struct linetable_entry *best = NULL;
2220 CORE_ADDR best_end = 0;
2221 struct symtab *best_symtab = 0;
2223 /* Store here the first line number
2224 of a file which contains the line at the smallest pc after PC.
2225 If we don't find a line whose range contains PC,
2226 we will use a line one less than this,
2227 with a range from the start of that file to the first line's pc. */
2228 struct linetable_entry *alt = NULL;
2230 /* Info on best line seen in this file. */
2232 struct linetable_entry *prev;
2234 /* If this pc is not from the current frame,
2235 it is the address of the end of a call instruction.
2236 Quite likely that is the start of the following statement.
2237 But what we want is the statement containing the instruction.
2238 Fudge the pc to make sure we get that. */
2240 init_sal (&val); /* initialize to zeroes */
2242 val.pspace = current_program_space;
2244 /* It's tempting to assume that, if we can't find debugging info for
2245 any function enclosing PC, that we shouldn't search for line
2246 number info, either. However, GAS can emit line number info for
2247 assembly files --- very helpful when debugging hand-written
2248 assembly code. In such a case, we'd have no debug info for the
2249 function, but we would have line info. */
2254 /* elz: added this because this function returned the wrong
2255 information if the pc belongs to a stub (import/export)
2256 to call a shlib function. This stub would be anywhere between
2257 two functions in the target, and the line info was erroneously
2258 taken to be the one of the line before the pc. */
2260 /* RT: Further explanation:
2262 * We have stubs (trampolines) inserted between procedures.
2264 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2265 * exists in the main image.
2267 * In the minimal symbol table, we have a bunch of symbols
2268 * sorted by start address. The stubs are marked as "trampoline",
2269 * the others appear as text. E.g.:
2271 * Minimal symbol table for main image
2272 * main: code for main (text symbol)
2273 * shr1: stub (trampoline symbol)
2274 * foo: code for foo (text symbol)
2276 * Minimal symbol table for "shr1" image:
2278 * shr1: code for shr1 (text symbol)
2281 * So the code below is trying to detect if we are in the stub
2282 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2283 * and if found, do the symbolization from the real-code address
2284 * rather than the stub address.
2286 * Assumptions being made about the minimal symbol table:
2287 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2288 * if we're really in the trampoline.s If we're beyond it (say
2289 * we're in "foo" in the above example), it'll have a closer
2290 * symbol (the "foo" text symbol for example) and will not
2291 * return the trampoline.
2292 * 2. lookup_minimal_symbol_text() will find a real text symbol
2293 * corresponding to the trampoline, and whose address will
2294 * be different than the trampoline address. I put in a sanity
2295 * check for the address being the same, to avoid an
2296 * infinite recursion.
2298 msymbol = lookup_minimal_symbol_by_pc (pc);
2299 if (msymbol != NULL)
2300 if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
2302 mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
2304 if (mfunsym == NULL)
2305 /* I eliminated this warning since it is coming out
2306 * in the following situation:
2307 * gdb shmain // test program with shared libraries
2308 * (gdb) break shr1 // function in shared lib
2309 * Warning: In stub for ...
2310 * In the above situation, the shared lib is not loaded yet,
2311 * so of course we can't find the real func/line info,
2312 * but the "break" still works, and the warning is annoying.
2313 * So I commented out the warning. RT */
2314 /* warning ("In stub for %s; unable to find real function/line info",
2315 SYMBOL_LINKAGE_NAME (msymbol)); */
2318 else if (SYMBOL_VALUE_ADDRESS (mfunsym)
2319 == SYMBOL_VALUE_ADDRESS (msymbol))
2320 /* Avoid infinite recursion */
2321 /* See above comment about why warning is commented out. */
2322 /* warning ("In stub for %s; unable to find real function/line info",
2323 SYMBOL_LINKAGE_NAME (msymbol)); */
2327 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
2331 s = find_pc_sect_symtab (pc, section);
2334 /* If no symbol information, return previous pc. */
2341 bv = BLOCKVECTOR (s);
2342 objfile = s->objfile;
2344 /* Look at all the symtabs that share this blockvector.
2345 They all have the same apriori range, that we found was right;
2346 but they have different line tables. */
2348 ALL_OBJFILE_SYMTABS (objfile, s)
2350 if (BLOCKVECTOR (s) != bv)
2353 /* Find the best line in this symtab. */
2360 /* I think len can be zero if the symtab lacks line numbers
2361 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2362 I'm not sure which, and maybe it depends on the symbol
2368 item = l->item; /* Get first line info. */
2370 /* Is this file's first line closer than the first lines of other files?
2371 If so, record this file, and its first line, as best alternate. */
2372 if (item->pc > pc && (!alt || item->pc < alt->pc))
2375 for (i = 0; i < len; i++, item++)
2377 /* Leave prev pointing to the linetable entry for the last line
2378 that started at or before PC. */
2385 /* At this point, prev points at the line whose start addr is <= pc, and
2386 item points at the next line. If we ran off the end of the linetable
2387 (pc >= start of the last line), then prev == item. If pc < start of
2388 the first line, prev will not be set. */
2390 /* Is this file's best line closer than the best in the other files?
2391 If so, record this file, and its best line, as best so far. Don't
2392 save prev if it represents the end of a function (i.e. line number
2393 0) instead of a real line. */
2395 if (prev && prev->line && (!best || prev->pc > best->pc))
2400 /* Discard BEST_END if it's before the PC of the current BEST. */
2401 if (best_end <= best->pc)
2405 /* If another line (denoted by ITEM) is in the linetable and its
2406 PC is after BEST's PC, but before the current BEST_END, then
2407 use ITEM's PC as the new best_end. */
2408 if (best && i < len && item->pc > best->pc
2409 && (best_end == 0 || best_end > item->pc))
2410 best_end = item->pc;
2415 /* If we didn't find any line number info, just return zeros.
2416 We used to return alt->line - 1 here, but that could be
2417 anywhere; if we don't have line number info for this PC,
2418 don't make some up. */
2421 else if (best->line == 0)
2423 /* If our best fit is in a range of PC's for which no line
2424 number info is available (line number is zero) then we didn't
2425 find any valid line information. */
2430 val.symtab = best_symtab;
2431 val.line = best->line;
2433 if (best_end && (!alt || best_end < alt->pc))
2438 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2440 val.section = section;
2444 /* Backward compatibility (no section). */
2446 struct symtab_and_line
2447 find_pc_line (CORE_ADDR pc, int notcurrent)
2449 struct obj_section *section;
2451 section = find_pc_overlay (pc);
2452 if (pc_in_unmapped_range (pc, section))
2453 pc = overlay_mapped_address (pc, section);
2454 return find_pc_sect_line (pc, section, notcurrent);
2457 /* Find line number LINE in any symtab whose name is the same as
2460 If found, return the symtab that contains the linetable in which it was
2461 found, set *INDEX to the index in the linetable of the best entry
2462 found, and set *EXACT_MATCH nonzero if the value returned is an
2465 If not found, return NULL. */
2468 find_line_symtab (struct symtab *symtab, int line,
2469 int *index, int *exact_match)
2471 int exact = 0; /* Initialized here to avoid a compiler warning. */
2473 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2477 struct linetable *best_linetable;
2478 struct symtab *best_symtab;
2480 /* First try looking it up in the given symtab. */
2481 best_linetable = LINETABLE (symtab);
2482 best_symtab = symtab;
2483 best_index = find_line_common (best_linetable, line, &exact, 0);
2484 if (best_index < 0 || !exact)
2486 /* Didn't find an exact match. So we better keep looking for
2487 another symtab with the same name. In the case of xcoff,
2488 multiple csects for one source file (produced by IBM's FORTRAN
2489 compiler) produce multiple symtabs (this is unavoidable
2490 assuming csects can be at arbitrary places in memory and that
2491 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2493 /* BEST is the smallest linenumber > LINE so far seen,
2494 or 0 if none has been seen so far.
2495 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2498 struct objfile *objfile;
2501 if (best_index >= 0)
2502 best = best_linetable->item[best_index].line;
2506 ALL_OBJFILES (objfile)
2509 objfile->sf->qf->expand_symtabs_with_filename (objfile,
2513 ALL_SYMTABS (objfile, s)
2515 struct linetable *l;
2518 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
2520 if (FILENAME_CMP (symtab_to_fullname (symtab),
2521 symtab_to_fullname (s)) != 0)
2524 ind = find_line_common (l, line, &exact, 0);
2534 if (best == 0 || l->item[ind].line < best)
2536 best = l->item[ind].line;
2549 *index = best_index;
2551 *exact_match = exact;
2556 /* Given SYMTAB, returns all the PCs function in the symtab that
2557 exactly match LINE. Returns NULL if there are no exact matches,
2558 but updates BEST_ITEM in this case. */
2561 find_pcs_for_symtab_line (struct symtab *symtab, int line,
2562 struct linetable_entry **best_item)
2565 VEC (CORE_ADDR) *result = NULL;
2567 /* First, collect all the PCs that are at this line. */
2573 idx = find_line_common (LINETABLE (symtab), line, &was_exact, start);
2579 struct linetable_entry *item = &LINETABLE (symtab)->item[idx];
2581 if (*best_item == NULL || item->line < (*best_item)->line)
2587 VEC_safe_push (CORE_ADDR, result, LINETABLE (symtab)->item[idx].pc);
2595 /* Set the PC value for a given source file and line number and return true.
2596 Returns zero for invalid line number (and sets the PC to 0).
2597 The source file is specified with a struct symtab. */
2600 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
2602 struct linetable *l;
2609 symtab = find_line_symtab (symtab, line, &ind, NULL);
2612 l = LINETABLE (symtab);
2613 *pc = l->item[ind].pc;
2620 /* Find the range of pc values in a line.
2621 Store the starting pc of the line into *STARTPTR
2622 and the ending pc (start of next line) into *ENDPTR.
2623 Returns 1 to indicate success.
2624 Returns 0 if could not find the specified line. */
2627 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2630 CORE_ADDR startaddr;
2631 struct symtab_and_line found_sal;
2634 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
2637 /* This whole function is based on address. For example, if line 10 has
2638 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2639 "info line *0x123" should say the line goes from 0x100 to 0x200
2640 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2641 This also insures that we never give a range like "starts at 0x134
2642 and ends at 0x12c". */
2644 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2645 if (found_sal.line != sal.line)
2647 /* The specified line (sal) has zero bytes. */
2648 *startptr = found_sal.pc;
2649 *endptr = found_sal.pc;
2653 *startptr = found_sal.pc;
2654 *endptr = found_sal.end;
2659 /* Given a line table and a line number, return the index into the line
2660 table for the pc of the nearest line whose number is >= the specified one.
2661 Return -1 if none is found. The value is >= 0 if it is an index.
2662 START is the index at which to start searching the line table.
2664 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2667 find_line_common (struct linetable *l, int lineno,
2668 int *exact_match, int start)
2673 /* BEST is the smallest linenumber > LINENO so far seen,
2674 or 0 if none has been seen so far.
2675 BEST_INDEX identifies the item for it. */
2677 int best_index = -1;
2688 for (i = start; i < len; i++)
2690 struct linetable_entry *item = &(l->item[i]);
2692 if (item->line == lineno)
2694 /* Return the first (lowest address) entry which matches. */
2699 if (item->line > lineno && (best == 0 || item->line < best))
2706 /* If we got here, we didn't get an exact match. */
2711 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
2713 struct symtab_and_line sal;
2715 sal = find_pc_line (pc, 0);
2718 return sal.symtab != 0;
2721 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2722 address for that function that has an entry in SYMTAB's line info
2723 table. If such an entry cannot be found, return FUNC_ADDR
2727 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
2729 CORE_ADDR func_start, func_end;
2730 struct linetable *l;
2733 /* Give up if this symbol has no lineinfo table. */
2734 l = LINETABLE (symtab);
2738 /* Get the range for the function's PC values, or give up if we
2739 cannot, for some reason. */
2740 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
2743 /* Linetable entries are ordered by PC values, see the commentary in
2744 symtab.h where `struct linetable' is defined. Thus, the first
2745 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2746 address we are looking for. */
2747 for (i = 0; i < l->nitems; i++)
2749 struct linetable_entry *item = &(l->item[i]);
2751 /* Don't use line numbers of zero, they mark special entries in
2752 the table. See the commentary on symtab.h before the
2753 definition of struct linetable. */
2754 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
2761 /* Given a function symbol SYM, find the symtab and line for the start
2763 If the argument FUNFIRSTLINE is nonzero, we want the first line
2764 of real code inside the function. */
2766 struct symtab_and_line
2767 find_function_start_sal (struct symbol *sym, int funfirstline)
2769 struct symtab_and_line sal;
2771 fixup_symbol_section (sym, NULL);
2772 sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
2773 SYMBOL_OBJ_SECTION (sym), 0);
2775 /* We always should have a line for the function start address.
2776 If we don't, something is odd. Create a plain SAL refering
2777 just the PC and hope that skip_prologue_sal (if requested)
2778 can find a line number for after the prologue. */
2779 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
2782 sal.pspace = current_program_space;
2783 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2784 sal.section = SYMBOL_OBJ_SECTION (sym);
2788 skip_prologue_sal (&sal);
2793 /* Adjust SAL to the first instruction past the function prologue.
2794 If the PC was explicitly specified, the SAL is not changed.
2795 If the line number was explicitly specified, at most the SAL's PC
2796 is updated. If SAL is already past the prologue, then do nothing. */
2799 skip_prologue_sal (struct symtab_and_line *sal)
2802 struct symtab_and_line start_sal;
2803 struct cleanup *old_chain;
2804 CORE_ADDR pc, saved_pc;
2805 struct obj_section *section;
2807 struct objfile *objfile;
2808 struct gdbarch *gdbarch;
2809 struct block *b, *function_block;
2810 int force_skip, skip;
2812 /* Do not change the SAL if PC was specified explicitly. */
2813 if (sal->explicit_pc)
2816 old_chain = save_current_space_and_thread ();
2817 switch_to_program_space_and_thread (sal->pspace);
2819 sym = find_pc_sect_function (sal->pc, sal->section);
2822 fixup_symbol_section (sym, NULL);
2824 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2825 section = SYMBOL_OBJ_SECTION (sym);
2826 name = SYMBOL_LINKAGE_NAME (sym);
2827 objfile = SYMBOL_SYMTAB (sym)->objfile;
2831 struct minimal_symbol *msymbol
2832 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
2834 if (msymbol == NULL)
2836 do_cleanups (old_chain);
2840 pc = SYMBOL_VALUE_ADDRESS (msymbol);
2841 section = SYMBOL_OBJ_SECTION (msymbol);
2842 name = SYMBOL_LINKAGE_NAME (msymbol);
2843 objfile = msymbol_objfile (msymbol);
2846 gdbarch = get_objfile_arch (objfile);
2848 /* Process the prologue in two passes. In the first pass try to skip the
2849 prologue (SKIP is true) and verify there is a real need for it (indicated
2850 by FORCE_SKIP). If no such reason was found run a second pass where the
2851 prologue is not skipped (SKIP is false). */
2856 /* Be conservative - allow direct PC (without skipping prologue) only if we
2857 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2858 have to be set by the caller so we use SYM instead. */
2859 if (sym && SYMBOL_SYMTAB (sym)->locations_valid)
2867 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2868 so that gdbarch_skip_prologue has something unique to work on. */
2869 if (section_is_overlay (section) && !section_is_mapped (section))
2870 pc = overlay_unmapped_address (pc, section);
2872 /* Skip "first line" of function (which is actually its prologue). */
2873 pc += gdbarch_deprecated_function_start_offset (gdbarch);
2875 pc = gdbarch_skip_prologue (gdbarch, pc);
2877 /* For overlays, map pc back into its mapped VMA range. */
2878 pc = overlay_mapped_address (pc, section);
2880 /* Calculate line number. */
2881 start_sal = find_pc_sect_line (pc, section, 0);
2883 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2884 line is still part of the same function. */
2885 if (skip && start_sal.pc != pc
2886 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
2887 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2888 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section)
2889 == lookup_minimal_symbol_by_pc_section (pc, section))))
2891 /* First pc of next line */
2893 /* Recalculate the line number (might not be N+1). */
2894 start_sal = find_pc_sect_line (pc, section, 0);
2897 /* On targets with executable formats that don't have a concept of
2898 constructors (ELF with .init has, PE doesn't), gcc emits a call
2899 to `__main' in `main' between the prologue and before user
2901 if (gdbarch_skip_main_prologue_p (gdbarch)
2902 && name && strcmp_iw (name, "main") == 0)
2904 pc = gdbarch_skip_main_prologue (gdbarch, pc);
2905 /* Recalculate the line number (might not be N+1). */
2906 start_sal = find_pc_sect_line (pc, section, 0);
2910 while (!force_skip && skip--);
2912 /* If we still don't have a valid source line, try to find the first
2913 PC in the lineinfo table that belongs to the same function. This
2914 happens with COFF debug info, which does not seem to have an
2915 entry in lineinfo table for the code after the prologue which has
2916 no direct relation to source. For example, this was found to be
2917 the case with the DJGPP target using "gcc -gcoff" when the
2918 compiler inserted code after the prologue to make sure the stack
2920 if (!force_skip && sym && start_sal.symtab == NULL)
2922 pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
2923 /* Recalculate the line number. */
2924 start_sal = find_pc_sect_line (pc, section, 0);
2927 do_cleanups (old_chain);
2929 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2930 forward SAL to the end of the prologue. */
2935 sal->section = section;
2937 /* Unless the explicit_line flag was set, update the SAL line
2938 and symtab to correspond to the modified PC location. */
2939 if (sal->explicit_line)
2942 sal->symtab = start_sal.symtab;
2943 sal->line = start_sal.line;
2944 sal->end = start_sal.end;
2946 /* Check if we are now inside an inlined function. If we can,
2947 use the call site of the function instead. */
2948 b = block_for_pc_sect (sal->pc, sal->section);
2949 function_block = NULL;
2952 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
2954 else if (BLOCK_FUNCTION (b) != NULL)
2956 b = BLOCK_SUPERBLOCK (b);
2958 if (function_block != NULL
2959 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
2961 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
2962 sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
2966 /* If P is of the form "operator[ \t]+..." where `...' is
2967 some legitimate operator text, return a pointer to the
2968 beginning of the substring of the operator text.
2969 Otherwise, return "". */
2972 operator_chars (char *p, char **end)
2975 if (strncmp (p, "operator", 8))
2979 /* Don't get faked out by `operator' being part of a longer
2981 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
2984 /* Allow some whitespace between `operator' and the operator symbol. */
2985 while (*p == ' ' || *p == '\t')
2988 /* Recognize 'operator TYPENAME'. */
2990 if (isalpha (*p) || *p == '_' || *p == '$')
2994 while (isalnum (*q) || *q == '_' || *q == '$')
3003 case '\\': /* regexp quoting */
3006 if (p[2] == '=') /* 'operator\*=' */
3008 else /* 'operator\*' */
3012 else if (p[1] == '[')
3015 error (_("mismatched quoting on brackets, "
3016 "try 'operator\\[\\]'"));
3017 else if (p[2] == '\\' && p[3] == ']')
3019 *end = p + 4; /* 'operator\[\]' */
3023 error (_("nothing is allowed between '[' and ']'"));
3027 /* Gratuitous qoute: skip it and move on. */
3049 if (p[0] == '-' && p[1] == '>')
3051 /* Struct pointer member operator 'operator->'. */
3054 *end = p + 3; /* 'operator->*' */
3057 else if (p[2] == '\\')
3059 *end = p + 4; /* Hopefully 'operator->\*' */
3064 *end = p + 2; /* 'operator->' */
3068 if (p[1] == '=' || p[1] == p[0])
3079 error (_("`operator ()' must be specified "
3080 "without whitespace in `()'"));
3085 error (_("`operator ?:' must be specified "
3086 "without whitespace in `?:'"));
3091 error (_("`operator []' must be specified "
3092 "without whitespace in `[]'"));
3096 error (_("`operator %s' not supported"), p);
3105 /* Cache to watch for file names already seen by filename_seen. */
3107 struct filename_seen_cache
3109 /* Table of files seen so far. */
3111 /* Initial size of the table. It automagically grows from here. */
3112 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
3115 /* filename_seen_cache constructor. */
3117 static struct filename_seen_cache *
3118 create_filename_seen_cache (void)
3120 struct filename_seen_cache *cache;
3122 cache = XNEW (struct filename_seen_cache);
3123 cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
3124 filename_hash, filename_eq,
3125 NULL, xcalloc, xfree);
3130 /* Empty the cache, but do not delete it. */
3133 clear_filename_seen_cache (struct filename_seen_cache *cache)
3135 htab_empty (cache->tab);
3138 /* filename_seen_cache destructor.
3139 This takes a void * argument as it is generally used as a cleanup. */
3142 delete_filename_seen_cache (void *ptr)
3144 struct filename_seen_cache *cache = ptr;
3146 htab_delete (cache->tab);
3150 /* If FILE is not already in the table of files in CACHE, return zero;
3151 otherwise return non-zero. Optionally add FILE to the table if ADD
3154 NOTE: We don't manage space for FILE, we assume FILE lives as long
3155 as the caller needs. */
3158 filename_seen (struct filename_seen_cache *cache, const char *file, int add)
3162 /* Is FILE in tab? */
3163 slot = htab_find_slot (cache->tab, file, add ? INSERT : NO_INSERT);
3167 /* No; maybe add it to tab. */
3169 *slot = (char *) file;
3174 /* Data structure to maintain printing state for output_source_filename. */
3176 struct output_source_filename_data
3178 /* Cache of what we've seen so far. */
3179 struct filename_seen_cache *filename_seen_cache;
3181 /* Flag of whether we're printing the first one. */
3185 /* Slave routine for sources_info. Force line breaks at ,'s.
3186 NAME is the name to print.
3187 DATA contains the state for printing and watching for duplicates. */
3190 output_source_filename (const char *name,
3191 struct output_source_filename_data *data)
3193 /* Since a single source file can result in several partial symbol
3194 tables, we need to avoid printing it more than once. Note: if
3195 some of the psymtabs are read in and some are not, it gets
3196 printed both under "Source files for which symbols have been
3197 read" and "Source files for which symbols will be read in on
3198 demand". I consider this a reasonable way to deal with the
3199 situation. I'm not sure whether this can also happen for
3200 symtabs; it doesn't hurt to check. */
3202 /* Was NAME already seen? */
3203 if (filename_seen (data->filename_seen_cache, name, 1))
3205 /* Yes; don't print it again. */
3209 /* No; print it and reset *FIRST. */
3211 printf_filtered (", ");
3215 fputs_filtered (name, gdb_stdout);
3218 /* A callback for map_partial_symbol_filenames. */
3221 output_partial_symbol_filename (const char *filename, const char *fullname,
3224 output_source_filename (fullname ? fullname : filename, data);
3228 sources_info (char *ignore, int from_tty)
3231 struct objfile *objfile;
3232 struct output_source_filename_data data;
3233 struct cleanup *cleanups;
3235 if (!have_full_symbols () && !have_partial_symbols ())
3237 error (_("No symbol table is loaded. Use the \"file\" command."));
3240 data.filename_seen_cache = create_filename_seen_cache ();
3241 cleanups = make_cleanup (delete_filename_seen_cache,
3242 data.filename_seen_cache);
3244 printf_filtered ("Source files for which symbols have been read in:\n\n");
3247 ALL_SYMTABS (objfile, s)
3249 const char *fullname = symtab_to_fullname (s);
3251 output_source_filename (fullname, &data);
3253 printf_filtered ("\n\n");
3255 printf_filtered ("Source files for which symbols "
3256 "will be read in on demand:\n\n");
3258 clear_filename_seen_cache (data.filename_seen_cache);
3260 map_partial_symbol_filenames (output_partial_symbol_filename, &data,
3261 1 /*need_fullname*/);
3262 printf_filtered ("\n");
3264 do_cleanups (cleanups);
3268 file_matches (const char *file, char *files[], int nfiles)
3272 if (file != NULL && nfiles != 0)
3274 for (i = 0; i < nfiles; i++)
3276 if (filename_cmp (files[i], lbasename (file)) == 0)
3280 else if (nfiles == 0)
3285 /* Free any memory associated with a search. */
3288 free_search_symbols (struct symbol_search *symbols)
3290 struct symbol_search *p;
3291 struct symbol_search *next;
3293 for (p = symbols; p != NULL; p = next)
3301 do_free_search_symbols_cleanup (void *symbols)
3303 free_search_symbols (symbols);
3307 make_cleanup_free_search_symbols (struct symbol_search *symbols)
3309 return make_cleanup (do_free_search_symbols_cleanup, symbols);
3312 /* Helper function for sort_search_symbols and qsort. Can only
3313 sort symbols, not minimal symbols. */
3316 compare_search_syms (const void *sa, const void *sb)
3318 struct symbol_search **sym_a = (struct symbol_search **) sa;
3319 struct symbol_search **sym_b = (struct symbol_search **) sb;
3321 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
3322 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
3325 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
3326 prevtail where it is, but update its next pointer to point to
3327 the first of the sorted symbols. */
3329 static struct symbol_search *
3330 sort_search_symbols (struct symbol_search *prevtail, int nfound)
3332 struct symbol_search **symbols, *symp, *old_next;
3335 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
3337 symp = prevtail->next;
3338 for (i = 0; i < nfound; i++)
3343 /* Generally NULL. */
3346 qsort (symbols, nfound, sizeof (struct symbol_search *),
3347 compare_search_syms);
3350 for (i = 0; i < nfound; i++)
3352 symp->next = symbols[i];
3355 symp->next = old_next;
3361 /* An object of this type is passed as the user_data to the
3362 expand_symtabs_matching method. */
3363 struct search_symbols_data
3368 /* It is true if PREG contains valid data, false otherwise. */
3369 unsigned preg_p : 1;
3373 /* A callback for expand_symtabs_matching. */
3376 search_symbols_file_matches (const char *filename, void *user_data)
3378 struct search_symbols_data *data = user_data;
3380 return file_matches (filename, data->files, data->nfiles);
3383 /* A callback for expand_symtabs_matching. */
3386 search_symbols_name_matches (const char *symname, void *user_data)
3388 struct search_symbols_data *data = user_data;
3390 return !data->preg_p || regexec (&data->preg, symname, 0, NULL, 0) == 0;
3393 /* Search the symbol table for matches to the regular expression REGEXP,
3394 returning the results in *MATCHES.
3396 Only symbols of KIND are searched:
3397 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3398 and constants (enums)
3399 FUNCTIONS_DOMAIN - search all functions
3400 TYPES_DOMAIN - search all type names
3401 ALL_DOMAIN - an internal error for this function
3403 free_search_symbols should be called when *MATCHES is no longer needed.
3405 The results are sorted locally; each symtab's global and static blocks are
3406 separately alphabetized. */
3409 search_symbols (char *regexp, enum search_domain kind,
3410 int nfiles, char *files[],
3411 struct symbol_search **matches)
3414 struct blockvector *bv;
3417 struct block_iterator iter;
3419 struct objfile *objfile;
3420 struct minimal_symbol *msymbol;
3422 static const enum minimal_symbol_type types[]
3423 = {mst_data, mst_text, mst_abs};
3424 static const enum minimal_symbol_type types2[]
3425 = {mst_bss, mst_file_text, mst_abs};
3426 static const enum minimal_symbol_type types3[]
3427 = {mst_file_data, mst_solib_trampoline, mst_abs};
3428 static const enum minimal_symbol_type types4[]
3429 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
3430 enum minimal_symbol_type ourtype;
3431 enum minimal_symbol_type ourtype2;
3432 enum minimal_symbol_type ourtype3;
3433 enum minimal_symbol_type ourtype4;
3434 struct symbol_search *sr;
3435 struct symbol_search *psr;
3436 struct symbol_search *tail;
3437 struct search_symbols_data datum;
3439 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3440 CLEANUP_CHAIN is freed only in the case of an error. */
3441 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3442 struct cleanup *retval_chain;
3444 gdb_assert (kind <= TYPES_DOMAIN);
3446 ourtype = types[kind];
3447 ourtype2 = types2[kind];
3448 ourtype3 = types3[kind];
3449 ourtype4 = types4[kind];
3451 sr = *matches = NULL;
3457 /* Make sure spacing is right for C++ operators.
3458 This is just a courtesy to make the matching less sensitive
3459 to how many spaces the user leaves between 'operator'
3460 and <TYPENAME> or <OPERATOR>. */
3462 char *opname = operator_chars (regexp, &opend);
3467 int fix = -1; /* -1 means ok; otherwise number of
3470 if (isalpha (*opname) || *opname == '_' || *opname == '$')
3472 /* There should 1 space between 'operator' and 'TYPENAME'. */
3473 if (opname[-1] != ' ' || opname[-2] == ' ')
3478 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3479 if (opname[-1] == ' ')
3482 /* If wrong number of spaces, fix it. */
3485 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
3487 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
3492 errcode = regcomp (&datum.preg, regexp,
3493 REG_NOSUB | (case_sensitivity == case_sensitive_off
3497 char *err = get_regcomp_error (errcode, &datum.preg);
3499 make_cleanup (xfree, err);
3500 error (_("Invalid regexp (%s): %s"), err, regexp);
3503 make_regfree_cleanup (&datum.preg);
3506 /* Search through the partial symtabs *first* for all symbols
3507 matching the regexp. That way we don't have to reproduce all of
3508 the machinery below. */
3510 datum.nfiles = nfiles;
3511 datum.files = files;
3512 ALL_OBJFILES (objfile)
3515 objfile->sf->qf->expand_symtabs_matching (objfile,
3518 : search_symbols_file_matches),
3519 search_symbols_name_matches,
3524 retval_chain = old_chain;
3526 /* Here, we search through the minimal symbol tables for functions
3527 and variables that match, and force their symbols to be read.
3528 This is in particular necessary for demangled variable names,
3529 which are no longer put into the partial symbol tables.
3530 The symbol will then be found during the scan of symtabs below.
3532 For functions, find_pc_symtab should succeed if we have debug info
3533 for the function, for variables we have to call
3534 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3536 If the lookup fails, set found_misc so that we will rescan to print
3537 any matching symbols without debug info.
3538 We only search the objfile the msymbol came from, we no longer search
3539 all objfiles. In large programs (1000s of shared libs) searching all
3540 objfiles is not worth the pain. */
3542 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
3544 ALL_MSYMBOLS (objfile, msymbol)
3548 if (msymbol->created_by_gdb)
3551 if (MSYMBOL_TYPE (msymbol) == ourtype
3552 || MSYMBOL_TYPE (msymbol) == ourtype2
3553 || MSYMBOL_TYPE (msymbol) == ourtype3
3554 || MSYMBOL_TYPE (msymbol) == ourtype4)
3557 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3560 /* Note: An important side-effect of these lookup functions
3561 is to expand the symbol table if msymbol is found, for the
3562 benefit of the next loop on ALL_PRIMARY_SYMTABS. */
3563 if (kind == FUNCTIONS_DOMAIN
3564 ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL
3565 : (lookup_symbol_in_objfile_from_linkage_name
3566 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3574 ALL_PRIMARY_SYMTABS (objfile, s)
3576 bv = BLOCKVECTOR (s);
3577 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3579 struct symbol_search *prevtail = tail;
3582 b = BLOCKVECTOR_BLOCK (bv, i);
3583 ALL_BLOCK_SYMBOLS (b, iter, sym)
3585 struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
3589 if (file_matches (real_symtab->filename, files, nfiles)
3591 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
3593 && ((kind == VARIABLES_DOMAIN
3594 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3595 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
3596 && SYMBOL_CLASS (sym) != LOC_BLOCK
3597 /* LOC_CONST can be used for more than just enums,
3598 e.g., c++ static const members.
3599 We only want to skip enums here. */
3600 && !(SYMBOL_CLASS (sym) == LOC_CONST
3601 && TYPE_CODE (SYMBOL_TYPE (sym))
3603 || (kind == FUNCTIONS_DOMAIN
3604 && SYMBOL_CLASS (sym) == LOC_BLOCK)
3605 || (kind == TYPES_DOMAIN
3606 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
3609 psr = (struct symbol_search *)
3610 xmalloc (sizeof (struct symbol_search));
3612 psr->symtab = real_symtab;
3614 psr->msymbol = NULL;
3626 if (prevtail == NULL)
3628 struct symbol_search dummy;
3631 tail = sort_search_symbols (&dummy, nfound);
3634 make_cleanup_free_search_symbols (sr);
3637 tail = sort_search_symbols (prevtail, nfound);
3642 /* If there are no eyes, avoid all contact. I mean, if there are
3643 no debug symbols, then print directly from the msymbol_vector. */
3645 if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
3647 ALL_MSYMBOLS (objfile, msymbol)
3651 if (msymbol->created_by_gdb)
3654 if (MSYMBOL_TYPE (msymbol) == ourtype
3655 || MSYMBOL_TYPE (msymbol) == ourtype2
3656 || MSYMBOL_TYPE (msymbol) == ourtype3
3657 || MSYMBOL_TYPE (msymbol) == ourtype4)
3660 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3663 /* For functions we can do a quick check of whether the
3664 symbol might be found via find_pc_symtab. */
3665 if (kind != FUNCTIONS_DOMAIN
3666 || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
3668 if (lookup_symbol_in_objfile_from_linkage_name
3669 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3673 psr = (struct symbol_search *)
3674 xmalloc (sizeof (struct symbol_search));
3676 psr->msymbol = msymbol;
3683 make_cleanup_free_search_symbols (sr);
3695 discard_cleanups (retval_chain);
3696 do_cleanups (old_chain);
3700 /* Helper function for symtab_symbol_info, this function uses
3701 the data returned from search_symbols() to print information
3702 regarding the match to gdb_stdout. */
3705 print_symbol_info (enum search_domain kind,
3706 struct symtab *s, struct symbol *sym,
3707 int block, char *last)
3709 if (last == NULL || filename_cmp (last, s->filename) != 0)
3711 fputs_filtered ("\nFile ", gdb_stdout);
3712 fputs_filtered (s->filename, gdb_stdout);
3713 fputs_filtered (":\n", gdb_stdout);
3716 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
3717 printf_filtered ("static ");
3719 /* Typedef that is not a C++ class. */
3720 if (kind == TYPES_DOMAIN
3721 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
3722 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
3723 /* variable, func, or typedef-that-is-c++-class. */
3724 else if (kind < TYPES_DOMAIN
3725 || (kind == TYPES_DOMAIN
3726 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
3728 type_print (SYMBOL_TYPE (sym),
3729 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3730 ? "" : SYMBOL_PRINT_NAME (sym)),
3733 printf_filtered (";\n");
3737 /* This help function for symtab_symbol_info() prints information
3738 for non-debugging symbols to gdb_stdout. */
3741 print_msymbol_info (struct minimal_symbol *msymbol)
3743 struct gdbarch *gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
3746 if (gdbarch_addr_bit (gdbarch) <= 32)
3747 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3748 & (CORE_ADDR) 0xffffffff,
3751 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3753 printf_filtered ("%s %s\n",
3754 tmp, SYMBOL_PRINT_NAME (msymbol));
3757 /* This is the guts of the commands "info functions", "info types", and
3758 "info variables". It calls search_symbols to find all matches and then
3759 print_[m]symbol_info to print out some useful information about the
3763 symtab_symbol_info (char *regexp, enum search_domain kind, int from_tty)
3765 static const char * const classnames[] =
3766 {"variable", "function", "type"};
3767 struct symbol_search *symbols;
3768 struct symbol_search *p;
3769 struct cleanup *old_chain;
3770 char *last_filename = NULL;
3773 gdb_assert (kind <= TYPES_DOMAIN);
3775 /* Must make sure that if we're interrupted, symbols gets freed. */
3776 search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
3777 old_chain = make_cleanup_free_search_symbols (symbols);
3780 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3781 classnames[kind], regexp);
3783 printf_filtered (_("All defined %ss:\n"), classnames[kind]);
3785 for (p = symbols; p != NULL; p = p->next)
3789 if (p->msymbol != NULL)
3793 printf_filtered (_("\nNon-debugging symbols:\n"));
3796 print_msymbol_info (p->msymbol);
3800 print_symbol_info (kind,
3805 last_filename = p->symtab->filename;
3809 do_cleanups (old_chain);
3813 variables_info (char *regexp, int from_tty)
3815 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
3819 functions_info (char *regexp, int from_tty)
3821 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
3826 types_info (char *regexp, int from_tty)
3828 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
3831 /* Breakpoint all functions matching regular expression. */
3834 rbreak_command_wrapper (char *regexp, int from_tty)
3836 rbreak_command (regexp, from_tty);
3839 /* A cleanup function that calls end_rbreak_breakpoints. */
3842 do_end_rbreak_breakpoints (void *ignore)
3844 end_rbreak_breakpoints ();
3848 rbreak_command (char *regexp, int from_tty)
3850 struct symbol_search *ss;
3851 struct symbol_search *p;
3852 struct cleanup *old_chain;
3853 char *string = NULL;
3855 char **files = NULL, *file_name;
3860 char *colon = strchr (regexp, ':');
3862 if (colon && *(colon + 1) != ':')
3866 colon_index = colon - regexp;
3867 file_name = alloca (colon_index + 1);
3868 memcpy (file_name, regexp, colon_index);
3869 file_name[colon_index--] = 0;
3870 while (isspace (file_name[colon_index]))
3871 file_name[colon_index--] = 0;
3875 while (isspace (*regexp)) regexp++;
3879 search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
3880 old_chain = make_cleanup_free_search_symbols (ss);
3881 make_cleanup (free_current_contents, &string);
3883 start_rbreak_breakpoints ();
3884 make_cleanup (do_end_rbreak_breakpoints, NULL);
3885 for (p = ss; p != NULL; p = p->next)
3887 if (p->msymbol == NULL)
3889 int newlen = (strlen (p->symtab->filename)
3890 + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3895 string = xrealloc (string, newlen);
3898 strcpy (string, p->symtab->filename);
3899 strcat (string, ":'");
3900 strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
3901 strcat (string, "'");
3902 break_command (string, from_tty);
3903 print_symbol_info (FUNCTIONS_DOMAIN,
3907 p->symtab->filename);
3911 int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
3915 string = xrealloc (string, newlen);
3918 strcpy (string, "'");
3919 strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol));
3920 strcat (string, "'");
3922 break_command (string, from_tty);
3923 printf_filtered ("<function, no debug info> %s;\n",
3924 SYMBOL_PRINT_NAME (p->msymbol));
3928 do_cleanups (old_chain);
3932 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3934 Either sym_text[sym_text_len] != '(' and then we search for any
3935 symbol starting with SYM_TEXT text.
3937 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3938 be terminated at that point. Partial symbol tables do not have parameters
3942 compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
3944 int (*ncmp) (const char *, const char *, size_t);
3946 ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
3948 if (ncmp (name, sym_text, sym_text_len) != 0)
3951 if (sym_text[sym_text_len] == '(')
3953 /* User searches for `name(someth...'. Require NAME to be terminated.
3954 Normally psymtabs and gdbindex have no parameter types so '\0' will be
3955 present but accept even parameters presence. In this case this
3956 function is in fact strcmp_iw but whitespace skipping is not supported
3957 for tab completion. */
3959 if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
3966 /* Free any memory associated with a completion list. */
3969 free_completion_list (VEC (char_ptr) **list_ptr)
3974 for (i = 0; VEC_iterate (char_ptr, *list_ptr, i, p); ++i)
3976 VEC_free (char_ptr, *list_ptr);
3979 /* Callback for make_cleanup. */
3982 do_free_completion_list (void *list)
3984 free_completion_list (list);
3987 /* Helper routine for make_symbol_completion_list. */
3989 static VEC (char_ptr) *return_val;
3991 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3992 completion_list_add_name \
3993 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3995 /* Test to see if the symbol specified by SYMNAME (which is already
3996 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3997 characters. If so, add it to the current completion list. */
4000 completion_list_add_name (const char *symname,
4001 const char *sym_text, int sym_text_len,
4002 const char *text, const char *word)
4004 /* Clip symbols that cannot match. */
4005 if (!compare_symbol_name (symname, sym_text, sym_text_len))
4008 /* We have a match for a completion, so add SYMNAME to the current list
4009 of matches. Note that the name is moved to freshly malloc'd space. */
4014 if (word == sym_text)
4016 new = xmalloc (strlen (symname) + 5);
4017 strcpy (new, symname);
4019 else if (word > sym_text)
4021 /* Return some portion of symname. */
4022 new = xmalloc (strlen (symname) + 5);
4023 strcpy (new, symname + (word - sym_text));
4027 /* Return some of SYM_TEXT plus symname. */
4028 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
4029 strncpy (new, word, sym_text - word);
4030 new[sym_text - word] = '\0';
4031 strcat (new, symname);
4034 VEC_safe_push (char_ptr, return_val, new);
4038 /* ObjC: In case we are completing on a selector, look as the msymbol
4039 again and feed all the selectors into the mill. */
4042 completion_list_objc_symbol (struct minimal_symbol *msymbol,
4043 const char *sym_text, int sym_text_len,
4044 const char *text, const char *word)
4046 static char *tmp = NULL;
4047 static unsigned int tmplen = 0;
4049 const char *method, *category, *selector;
4052 method = SYMBOL_NATURAL_NAME (msymbol);
4054 /* Is it a method? */
4055 if ((method[0] != '-') && (method[0] != '+'))
4058 if (sym_text[0] == '[')
4059 /* Complete on shortened method method. */
4060 completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
4062 while ((strlen (method) + 1) >= tmplen)
4068 tmp = xrealloc (tmp, tmplen);
4070 selector = strchr (method, ' ');
4071 if (selector != NULL)
4074 category = strchr (method, '(');
4076 if ((category != NULL) && (selector != NULL))
4078 memcpy (tmp, method, (category - method));
4079 tmp[category - method] = ' ';
4080 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4081 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4082 if (sym_text[0] == '[')
4083 completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
4086 if (selector != NULL)
4088 /* Complete on selector only. */
4089 strcpy (tmp, selector);
4090 tmp2 = strchr (tmp, ']');
4094 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4098 /* Break the non-quoted text based on the characters which are in
4099 symbols. FIXME: This should probably be language-specific. */
4102 language_search_unquoted_string (char *text, char *p)
4104 for (; p > text; --p)
4106 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4110 if ((current_language->la_language == language_objc))
4112 if (p[-1] == ':') /* Might be part of a method name. */
4114 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
4115 p -= 2; /* Beginning of a method name. */
4116 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
4117 { /* Might be part of a method name. */
4120 /* Seeing a ' ' or a '(' is not conclusive evidence
4121 that we are in the middle of a method name. However,
4122 finding "-[" or "+[" should be pretty un-ambiguous.
4123 Unfortunately we have to find it now to decide. */
4126 if (isalnum (t[-1]) || t[-1] == '_' ||
4127 t[-1] == ' ' || t[-1] == ':' ||
4128 t[-1] == '(' || t[-1] == ')')
4133 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
4134 p = t - 2; /* Method name detected. */
4135 /* Else we leave with p unchanged. */
4145 completion_list_add_fields (struct symbol *sym, char *sym_text,
4146 int sym_text_len, char *text, char *word)
4148 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4150 struct type *t = SYMBOL_TYPE (sym);
4151 enum type_code c = TYPE_CODE (t);
4154 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4155 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4156 if (TYPE_FIELD_NAME (t, j))
4157 completion_list_add_name (TYPE_FIELD_NAME (t, j),
4158 sym_text, sym_text_len, text, word);
4162 /* Type of the user_data argument passed to add_macro_name or
4163 expand_partial_symbol_name. The contents are simply whatever is
4164 needed by completion_list_add_name. */
4165 struct add_name_data
4173 /* A callback used with macro_for_each and macro_for_each_in_scope.
4174 This adds a macro's name to the current completion list. */
4177 add_macro_name (const char *name, const struct macro_definition *ignore,
4178 struct macro_source_file *ignore2, int ignore3,
4181 struct add_name_data *datum = (struct add_name_data *) user_data;
4183 completion_list_add_name ((char *) name,
4184 datum->sym_text, datum->sym_text_len,
4185 datum->text, datum->word);
4188 /* A callback for expand_partial_symbol_names. */
4191 expand_partial_symbol_name (const char *name, void *user_data)
4193 struct add_name_data *datum = (struct add_name_data *) user_data;
4195 return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
4199 default_make_symbol_completion_list_break_on (char *text, char *word,
4200 const char *break_on,
4201 enum type_code code)
4203 /* Problem: All of the symbols have to be copied because readline
4204 frees them. I'm not going to worry about this; hopefully there
4205 won't be that many. */
4209 struct minimal_symbol *msymbol;
4210 struct objfile *objfile;
4212 const struct block *surrounding_static_block, *surrounding_global_block;
4213 struct block_iterator iter;
4214 /* The symbol we are completing on. Points in same buffer as text. */
4216 /* Length of sym_text. */
4218 struct add_name_data datum;
4219 struct cleanup *back_to;
4221 /* Now look for the symbol we are supposed to complete on. */
4225 char *quote_pos = NULL;
4227 /* First see if this is a quoted string. */
4229 for (p = text; *p != '\0'; ++p)
4231 if (quote_found != '\0')
4233 if (*p == quote_found)
4234 /* Found close quote. */
4236 else if (*p == '\\' && p[1] == quote_found)
4237 /* A backslash followed by the quote character
4238 doesn't end the string. */
4241 else if (*p == '\'' || *p == '"')
4247 if (quote_found == '\'')
4248 /* A string within single quotes can be a symbol, so complete on it. */
4249 sym_text = quote_pos + 1;
4250 else if (quote_found == '"')
4251 /* A double-quoted string is never a symbol, nor does it make sense
4252 to complete it any other way. */
4258 /* It is not a quoted string. Break it based on the characters
4259 which are in symbols. */
4262 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
4263 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
4272 sym_text_len = strlen (sym_text);
4274 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4276 if (current_language->la_language == language_cplus
4277 || current_language->la_language == language_java
4278 || current_language->la_language == language_fortran)
4280 /* These languages may have parameters entered by user but they are never
4281 present in the partial symbol tables. */
4283 const char *cs = memchr (sym_text, '(', sym_text_len);
4286 sym_text_len = cs - sym_text;
4288 gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
4291 back_to = make_cleanup (do_free_completion_list, &return_val);
4293 datum.sym_text = sym_text;
4294 datum.sym_text_len = sym_text_len;
4298 /* Look through the partial symtabs for all symbols which begin
4299 by matching SYM_TEXT. Expand all CUs that you find to the list.
4300 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4301 expand_partial_symbol_names (expand_partial_symbol_name, &datum);
4303 /* At this point scan through the misc symbol vectors and add each
4304 symbol you find to the list. Eventually we want to ignore
4305 anything that isn't a text symbol (everything else will be
4306 handled by the psymtab code above). */
4308 if (code == TYPE_CODE_UNDEF)
4310 ALL_MSYMBOLS (objfile, msymbol)
4313 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
4316 completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text,
4321 /* Search upwards from currently selected frame (so that we can
4322 complete on local vars). Also catch fields of types defined in
4323 this places which match our text string. Only complete on types
4324 visible from current context. */
4326 b = get_selected_block (0);
4327 surrounding_static_block = block_static_block (b);
4328 surrounding_global_block = block_global_block (b);
4329 if (surrounding_static_block != NULL)
4330 while (b != surrounding_static_block)
4334 ALL_BLOCK_SYMBOLS (b, iter, sym)
4336 if (code == TYPE_CODE_UNDEF)
4338 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4340 completion_list_add_fields (sym, sym_text, sym_text_len, text,
4343 else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4344 && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
4345 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4349 /* Stop when we encounter an enclosing function. Do not stop for
4350 non-inlined functions - the locals of the enclosing function
4351 are in scope for a nested function. */
4352 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
4354 b = BLOCK_SUPERBLOCK (b);
4357 /* Add fields from the file's types; symbols will be added below. */
4359 if (code == TYPE_CODE_UNDEF)
4361 if (surrounding_static_block != NULL)
4362 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
4363 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4365 if (surrounding_global_block != NULL)
4366 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
4367 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4370 /* Go through the symtabs and check the externs and statics for
4371 symbols which match. */
4373 ALL_PRIMARY_SYMTABS (objfile, s)
4376 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4377 ALL_BLOCK_SYMBOLS (b, iter, sym)
4379 if (code == TYPE_CODE_UNDEF
4380 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4381 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4382 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4386 ALL_PRIMARY_SYMTABS (objfile, s)
4389 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4390 ALL_BLOCK_SYMBOLS (b, iter, sym)
4392 if (code == TYPE_CODE_UNDEF
4393 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4394 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4395 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4399 /* Skip macros if we are completing a struct tag -- arguable but
4400 usually what is expected. */
4401 if (current_language->la_macro_expansion == macro_expansion_c
4402 && code == TYPE_CODE_UNDEF)
4404 struct macro_scope *scope;
4406 /* Add any macros visible in the default scope. Note that this
4407 may yield the occasional wrong result, because an expression
4408 might be evaluated in a scope other than the default. For
4409 example, if the user types "break file:line if <TAB>", the
4410 resulting expression will be evaluated at "file:line" -- but
4411 at there does not seem to be a way to detect this at
4413 scope = default_macro_scope ();
4416 macro_for_each_in_scope (scope->file, scope->line,
4417 add_macro_name, &datum);
4421 /* User-defined macros are always visible. */
4422 macro_for_each (macro_user_macros, add_macro_name, &datum);
4425 discard_cleanups (back_to);
4426 return (return_val);
4430 default_make_symbol_completion_list (char *text, char *word,
4431 enum type_code code)
4433 return default_make_symbol_completion_list_break_on (text, word, "", code);
4436 /* Return a vector of all symbols (regardless of class) which begin by
4437 matching TEXT. If the answer is no symbols, then the return value
4441 make_symbol_completion_list (char *text, char *word)
4443 return current_language->la_make_symbol_completion_list (text, word,
4447 /* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4448 symbols whose type code is CODE. */
4451 make_symbol_completion_type (char *text, char *word, enum type_code code)
4453 gdb_assert (code == TYPE_CODE_UNION
4454 || code == TYPE_CODE_STRUCT
4455 || code == TYPE_CODE_CLASS
4456 || code == TYPE_CODE_ENUM);
4457 return current_language->la_make_symbol_completion_list (text, word, code);
4460 /* Like make_symbol_completion_list, but suitable for use as a
4461 completion function. */
4464 make_symbol_completion_list_fn (struct cmd_list_element *ignore,
4465 char *text, char *word)
4467 return make_symbol_completion_list (text, word);
4470 /* Like make_symbol_completion_list, but returns a list of symbols
4471 defined in a source file FILE. */
4474 make_file_symbol_completion_list (char *text, char *word, char *srcfile)
4479 struct block_iterator iter;
4480 /* The symbol we are completing on. Points in same buffer as text. */
4482 /* Length of sym_text. */
4485 /* Now look for the symbol we are supposed to complete on.
4486 FIXME: This should be language-specific. */
4490 char *quote_pos = NULL;
4492 /* First see if this is a quoted string. */
4494 for (p = text; *p != '\0'; ++p)
4496 if (quote_found != '\0')
4498 if (*p == quote_found)
4499 /* Found close quote. */
4501 else if (*p == '\\' && p[1] == quote_found)
4502 /* A backslash followed by the quote character
4503 doesn't end the string. */
4506 else if (*p == '\'' || *p == '"')
4512 if (quote_found == '\'')
4513 /* A string within single quotes can be a symbol, so complete on it. */
4514 sym_text = quote_pos + 1;
4515 else if (quote_found == '"')
4516 /* A double-quoted string is never a symbol, nor does it make sense
4517 to complete it any other way. */
4523 /* Not a quoted string. */
4524 sym_text = language_search_unquoted_string (text, p);
4528 sym_text_len = strlen (sym_text);
4532 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4534 s = lookup_symtab (srcfile);
4537 /* Maybe they typed the file with leading directories, while the
4538 symbol tables record only its basename. */
4539 const char *tail = lbasename (srcfile);
4542 s = lookup_symtab (tail);
4545 /* If we have no symtab for that file, return an empty list. */
4547 return (return_val);
4549 /* Go through this symtab and check the externs and statics for
4550 symbols which match. */
4552 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4553 ALL_BLOCK_SYMBOLS (b, iter, sym)
4555 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4558 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4559 ALL_BLOCK_SYMBOLS (b, iter, sym)
4561 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4564 return (return_val);
4567 /* A helper function for make_source_files_completion_list. It adds
4568 another file name to a list of possible completions, growing the
4569 list as necessary. */
4572 add_filename_to_list (const char *fname, char *text, char *word,
4573 VEC (char_ptr) **list)
4576 size_t fnlen = strlen (fname);
4580 /* Return exactly fname. */
4581 new = xmalloc (fnlen + 5);
4582 strcpy (new, fname);
4584 else if (word > text)
4586 /* Return some portion of fname. */
4587 new = xmalloc (fnlen + 5);
4588 strcpy (new, fname + (word - text));
4592 /* Return some of TEXT plus fname. */
4593 new = xmalloc (fnlen + (text - word) + 5);
4594 strncpy (new, word, text - word);
4595 new[text - word] = '\0';
4596 strcat (new, fname);
4598 VEC_safe_push (char_ptr, *list, new);
4602 not_interesting_fname (const char *fname)
4604 static const char *illegal_aliens[] = {
4605 "_globals_", /* inserted by coff_symtab_read */
4610 for (i = 0; illegal_aliens[i]; i++)
4612 if (filename_cmp (fname, illegal_aliens[i]) == 0)
4618 /* An object of this type is passed as the user_data argument to
4619 map_partial_symbol_filenames. */
4620 struct add_partial_filename_data
4622 struct filename_seen_cache *filename_seen_cache;
4626 VEC (char_ptr) **list;
4629 /* A callback for map_partial_symbol_filenames. */
4632 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
4635 struct add_partial_filename_data *data = user_data;
4637 if (not_interesting_fname (filename))
4639 if (!filename_seen (data->filename_seen_cache, filename, 1)
4640 && filename_ncmp (filename, data->text, data->text_len) == 0)
4642 /* This file matches for a completion; add it to the
4643 current list of matches. */
4644 add_filename_to_list (filename, data->text, data->word, data->list);
4648 const char *base_name = lbasename (filename);
4650 if (base_name != filename
4651 && !filename_seen (data->filename_seen_cache, base_name, 1)
4652 && filename_ncmp (base_name, data->text, data->text_len) == 0)
4653 add_filename_to_list (base_name, data->text, data->word, data->list);
4657 /* Return a vector of all source files whose names begin with matching
4658 TEXT. The file names are looked up in the symbol tables of this
4659 program. If the answer is no matchess, then the return value is
4663 make_source_files_completion_list (char *text, char *word)
4666 struct objfile *objfile;
4667 size_t text_len = strlen (text);
4668 VEC (char_ptr) *list = NULL;
4669 const char *base_name;
4670 struct add_partial_filename_data datum;
4671 struct filename_seen_cache *filename_seen_cache;
4672 struct cleanup *back_to, *cache_cleanup;
4674 if (!have_full_symbols () && !have_partial_symbols ())
4677 back_to = make_cleanup (do_free_completion_list, &list);
4679 filename_seen_cache = create_filename_seen_cache ();
4680 cache_cleanup = make_cleanup (delete_filename_seen_cache,
4681 filename_seen_cache);
4683 ALL_SYMTABS (objfile, s)
4685 if (not_interesting_fname (s->filename))
4687 if (!filename_seen (filename_seen_cache, s->filename, 1)
4688 && filename_ncmp (s->filename, text, text_len) == 0)
4690 /* This file matches for a completion; add it to the current
4692 add_filename_to_list (s->filename, text, word, &list);
4696 /* NOTE: We allow the user to type a base name when the
4697 debug info records leading directories, but not the other
4698 way around. This is what subroutines of breakpoint
4699 command do when they parse file names. */
4700 base_name = lbasename (s->filename);
4701 if (base_name != s->filename
4702 && !filename_seen (filename_seen_cache, base_name, 1)
4703 && filename_ncmp (base_name, text, text_len) == 0)
4704 add_filename_to_list (base_name, text, word, &list);
4708 datum.filename_seen_cache = filename_seen_cache;
4711 datum.text_len = text_len;
4713 map_partial_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
4714 0 /*need_fullname*/);
4716 do_cleanups (cache_cleanup);
4717 discard_cleanups (back_to);
4722 /* Determine if PC is in the prologue of a function. The prologue is the area
4723 between the first instruction of a function, and the first executable line.
4724 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4726 If non-zero, func_start is where we think the prologue starts, possibly
4727 by previous examination of symbol table information. */
4730 in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
4732 struct symtab_and_line sal;
4733 CORE_ADDR func_addr, func_end;
4735 /* We have several sources of information we can consult to figure
4737 - Compilers usually emit line number info that marks the prologue
4738 as its own "source line". So the ending address of that "line"
4739 is the end of the prologue. If available, this is the most
4741 - The minimal symbols and partial symbols, which can usually tell
4742 us the starting and ending addresses of a function.
4743 - If we know the function's start address, we can call the
4744 architecture-defined gdbarch_skip_prologue function to analyze the
4745 instruction stream and guess where the prologue ends.
4746 - Our `func_start' argument; if non-zero, this is the caller's
4747 best guess as to the function's entry point. At the time of
4748 this writing, handle_inferior_event doesn't get this right, so
4749 it should be our last resort. */
4751 /* Consult the partial symbol table, to find which function
4753 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4755 CORE_ADDR prologue_end;
4757 /* We don't even have minsym information, so fall back to using
4758 func_start, if given. */
4760 return 1; /* We *might* be in a prologue. */
4762 prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
4764 return func_start <= pc && pc < prologue_end;
4767 /* If we have line number information for the function, that's
4768 usually pretty reliable. */
4769 sal = find_pc_line (func_addr, 0);
4771 /* Now sal describes the source line at the function's entry point,
4772 which (by convention) is the prologue. The end of that "line",
4773 sal.end, is the end of the prologue.
4775 Note that, for functions whose source code is all on a single
4776 line, the line number information doesn't always end up this way.
4777 So we must verify that our purported end-of-prologue address is
4778 *within* the function, not at its start or end. */
4780 || sal.end <= func_addr
4781 || func_end <= sal.end)
4783 /* We don't have any good line number info, so use the minsym
4784 information, together with the architecture-specific prologue
4786 CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
4788 return func_addr <= pc && pc < prologue_end;
4791 /* We have line number info, and it looks good. */
4792 return func_addr <= pc && pc < sal.end;
4795 /* Given PC at the function's start address, attempt to find the
4796 prologue end using SAL information. Return zero if the skip fails.
4798 A non-optimized prologue traditionally has one SAL for the function
4799 and a second for the function body. A single line function has
4800 them both pointing at the same line.
4802 An optimized prologue is similar but the prologue may contain
4803 instructions (SALs) from the instruction body. Need to skip those
4804 while not getting into the function body.
4806 The functions end point and an increasing SAL line are used as
4807 indicators of the prologue's endpoint.
4809 This code is based on the function refine_prologue_limit
4813 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
4815 struct symtab_and_line prologue_sal;
4820 /* Get an initial range for the function. */
4821 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
4822 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
4824 prologue_sal = find_pc_line (start_pc, 0);
4825 if (prologue_sal.line != 0)
4827 /* For languages other than assembly, treat two consecutive line
4828 entries at the same address as a zero-instruction prologue.
4829 The GNU assembler emits separate line notes for each instruction
4830 in a multi-instruction macro, but compilers generally will not
4832 if (prologue_sal.symtab->language != language_asm)
4834 struct linetable *linetable = LINETABLE (prologue_sal.symtab);
4837 /* Skip any earlier lines, and any end-of-sequence marker
4838 from a previous function. */
4839 while (linetable->item[idx].pc != prologue_sal.pc
4840 || linetable->item[idx].line == 0)
4843 if (idx+1 < linetable->nitems
4844 && linetable->item[idx+1].line != 0
4845 && linetable->item[idx+1].pc == start_pc)
4849 /* If there is only one sal that covers the entire function,
4850 then it is probably a single line function, like
4852 if (prologue_sal.end >= end_pc)
4855 while (prologue_sal.end < end_pc)
4857 struct symtab_and_line sal;
4859 sal = find_pc_line (prologue_sal.end, 0);
4862 /* Assume that a consecutive SAL for the same (or larger)
4863 line mark the prologue -> body transition. */
4864 if (sal.line >= prologue_sal.line)
4866 /* Likewise if we are in a different symtab altogether
4867 (e.g. within a file included via #include). */
4868 if (sal.symtab != prologue_sal.symtab)
4871 /* The line number is smaller. Check that it's from the
4872 same function, not something inlined. If it's inlined,
4873 then there is no point comparing the line numbers. */
4874 bl = block_for_pc (prologue_sal.end);
4877 if (block_inlined_p (bl))
4879 if (BLOCK_FUNCTION (bl))
4884 bl = BLOCK_SUPERBLOCK (bl);
4889 /* The case in which compiler's optimizer/scheduler has
4890 moved instructions into the prologue. We look ahead in
4891 the function looking for address ranges whose
4892 corresponding line number is less the first one that we
4893 found for the function. This is more conservative then
4894 refine_prologue_limit which scans a large number of SALs
4895 looking for any in the prologue. */
4900 if (prologue_sal.end < end_pc)
4901 /* Return the end of this line, or zero if we could not find a
4903 return prologue_sal.end;
4905 /* Don't return END_PC, which is past the end of the function. */
4906 return prologue_sal.pc;
4910 static char *name_of_main;
4911 enum language language_of_main = language_unknown;
4914 set_main_name (const char *name)
4916 if (name_of_main != NULL)
4918 xfree (name_of_main);
4919 name_of_main = NULL;
4920 language_of_main = language_unknown;
4924 name_of_main = xstrdup (name);
4925 language_of_main = language_unknown;
4929 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4933 find_main_name (void)
4935 const char *new_main_name;
4937 /* Try to see if the main procedure is in Ada. */
4938 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4939 be to add a new method in the language vector, and call this
4940 method for each language until one of them returns a non-empty
4941 name. This would allow us to remove this hard-coded call to
4942 an Ada function. It is not clear that this is a better approach
4943 at this point, because all methods need to be written in a way
4944 such that false positives never be returned. For instance, it is
4945 important that a method does not return a wrong name for the main
4946 procedure if the main procedure is actually written in a different
4947 language. It is easy to guaranty this with Ada, since we use a
4948 special symbol generated only when the main in Ada to find the name
4949 of the main procedure. It is difficult however to see how this can
4950 be guarantied for languages such as C, for instance. This suggests
4951 that order of call for these methods becomes important, which means
4952 a more complicated approach. */
4953 new_main_name = ada_main_name ();
4954 if (new_main_name != NULL)
4956 set_main_name (new_main_name);
4960 new_main_name = go_main_name ();
4961 if (new_main_name != NULL)
4963 set_main_name (new_main_name);
4967 new_main_name = pascal_main_name ();
4968 if (new_main_name != NULL)
4970 set_main_name (new_main_name);
4974 /* The languages above didn't identify the name of the main procedure.
4975 Fallback to "main". */
4976 set_main_name ("main");
4982 if (name_of_main == NULL)
4985 return name_of_main;
4988 /* Handle ``executable_changed'' events for the symtab module. */
4991 symtab_observer_executable_changed (void)
4993 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
4994 set_main_name (NULL);
4997 /* Return 1 if the supplied producer string matches the ARM RealView
4998 compiler (armcc). */
5001 producer_is_realview (const char *producer)
5003 static const char *const arm_idents[] = {
5004 "ARM C Compiler, ADS",
5005 "Thumb C Compiler, ADS",
5006 "ARM C++ Compiler, ADS",
5007 "Thumb C++ Compiler, ADS",
5008 "ARM/Thumb C/C++ Compiler, RVCT",
5009 "ARM C/C++ Compiler, RVCT"
5013 if (producer == NULL)
5016 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5017 if (strncmp (producer, arm_idents[i], strlen (arm_idents[i])) == 0)
5024 _initialize_symtab (void)
5026 add_info ("variables", variables_info, _("\
5027 All global and static variable names, or those matching REGEXP."));
5029 add_com ("whereis", class_info, variables_info, _("\
5030 All global and static variable names, or those matching REGEXP."));
5032 add_info ("functions", functions_info,
5033 _("All function names, or those matching REGEXP."));
5035 /* FIXME: This command has at least the following problems:
5036 1. It prints builtin types (in a very strange and confusing fashion).
5037 2. It doesn't print right, e.g. with
5038 typedef struct foo *FOO
5039 type_print prints "FOO" when we want to make it (in this situation)
5040 print "struct foo *".
5041 I also think "ptype" or "whatis" is more likely to be useful (but if
5042 there is much disagreement "info types" can be fixed). */
5043 add_info ("types", types_info,
5044 _("All type names, or those matching REGEXP."));
5046 add_info ("sources", sources_info,
5047 _("Source files in the program."));
5049 add_com ("rbreak", class_breakpoint, rbreak_command,
5050 _("Set a breakpoint for all functions matching REGEXP."));
5054 add_com ("lf", class_info, sources_info,
5055 _("Source files in the program"));
5056 add_com ("lg", class_info, variables_info, _("\
5057 All global and static variable names, or those matching REGEXP."));
5060 add_setshow_enum_cmd ("multiple-symbols", no_class,
5061 multiple_symbols_modes, &multiple_symbols_mode,
5063 Set the debugger behavior when more than one symbol are possible matches\n\
5064 in an expression."), _("\
5065 Show how the debugger handles ambiguities in expressions."), _("\
5066 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5067 NULL, NULL, &setlist, &showlist);
5069 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5070 &basenames_may_differ, _("\
5071 Set whether a source file may have multiple base names."), _("\
5072 Show whether a source file may have multiple base names."), _("\
5073 (A \"base name\" is the name of a file with the directory part removed.\n\
5074 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5075 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5076 before comparing them. Canonicalization is an expensive operation,\n\
5077 but it allows the same file be known by more than one base name.\n\
5078 If not set (the default), all source files are assumed to have just\n\
5079 one base name, and gdb will do file name comparisons more efficiently."),
5081 &setlist, &showlist);
5083 add_setshow_boolean_cmd ("symtab-create", no_class, &symtab_create_debug,
5084 _("Set debugging of symbol table creation."),
5085 _("Show debugging of symbol table creation."), _("\
5086 When enabled, debugging messages are printed when building symbol tables."),
5089 &setdebuglist, &showdebuglist);
5091 observer_attach_executable_changed (symtab_observer_executable_changed);