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"
43 #include "cli/cli-utils.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
53 #include "gdb_string.h"
57 #include "cp-support.h"
59 #include "gdb_assert.h"
62 #include "macroscope.h"
65 #include "parser-defs.h"
67 /* Prototypes for local functions */
69 static void rbreak_command (char *, int);
71 static void types_info (char *, int);
73 static void functions_info (char *, int);
75 static void variables_info (char *, int);
77 static void sources_info (char *, int);
79 static int find_line_common (struct linetable *, int, int *, int);
81 static struct symbol *lookup_symbol_aux (const char *name,
82 const struct block *block,
83 const domain_enum domain,
84 enum language language,
85 struct field_of_this_result *is_a_field_of_this);
88 struct symbol *lookup_symbol_aux_local (const char *name,
89 const struct block *block,
90 const domain_enum domain,
91 enum language language);
94 struct symbol *lookup_symbol_aux_symtabs (int block_index,
96 const domain_enum domain);
99 struct symbol *lookup_symbol_aux_quick (struct objfile *objfile,
102 const domain_enum domain);
104 static void print_msymbol_info (struct minimal_symbol *);
106 void _initialize_symtab (void);
110 /* When non-zero, print debugging messages related to symtab creation. */
111 int symtab_create_debug = 0;
113 /* Non-zero if a file may be known by two different basenames.
114 This is the uncommon case, and significantly slows down gdb.
115 Default set to "off" to not slow down the common case. */
116 int basenames_may_differ = 0;
118 /* Allow the user to configure the debugger behavior with respect
119 to multiple-choice menus when more than one symbol matches during
122 const char multiple_symbols_ask[] = "ask";
123 const char multiple_symbols_all[] = "all";
124 const char multiple_symbols_cancel[] = "cancel";
125 static const char *const multiple_symbols_modes[] =
127 multiple_symbols_ask,
128 multiple_symbols_all,
129 multiple_symbols_cancel,
132 static const char *multiple_symbols_mode = multiple_symbols_all;
134 /* Read-only accessor to AUTO_SELECT_MODE. */
137 multiple_symbols_select_mode (void)
139 return multiple_symbols_mode;
142 /* Block in which the most recently searched-for symbol was found.
143 Might be better to make this a parameter to lookup_symbol and
146 const struct block *block_found;
148 /* See whether FILENAME matches SEARCH_NAME using the rule that we
149 advertise to the user. (The manual's description of linespecs
150 describes what we advertise). Returns true if they match, false
154 compare_filenames_for_search (const char *filename, const char *search_name)
156 int len = strlen (filename);
157 size_t search_len = strlen (search_name);
159 if (len < search_len)
162 /* The tail of FILENAME must match. */
163 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
166 /* Either the names must completely match, or the character
167 preceding the trailing SEARCH_NAME segment of FILENAME must be a
170 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
171 cannot match FILENAME "/path//dir/file.c" - as user has requested
172 absolute path. The sama applies for "c:\file.c" possibly
173 incorrectly hypothetically matching "d:\dir\c:\file.c".
175 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
176 compatible with SEARCH_NAME "file.c". In such case a compiler had
177 to put the "c:file.c" name into debug info. Such compatibility
178 works only on GDB built for DOS host. */
179 return (len == search_len
180 || (!IS_ABSOLUTE_PATH (search_name)
181 && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
182 || (HAS_DRIVE_SPEC (filename)
183 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
186 /* Check for a symtab of a specific name by searching some symtabs.
187 This is a helper function for callbacks of iterate_over_symtabs.
189 If NAME is not absolute, then REAL_PATH is NULL
190 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
192 The return value, NAME, REAL_PATH, CALLBACK, and DATA
193 are identical to the `map_symtabs_matching_filename' method of
194 quick_symbol_functions.
196 FIRST and AFTER_LAST indicate the range of symtabs to search.
197 AFTER_LAST is one past the last symtab to search; NULL means to
198 search until the end of the list. */
201 iterate_over_some_symtabs (const char *name,
202 const char *real_path,
203 int (*callback) (struct symtab *symtab,
206 struct symtab *first,
207 struct symtab *after_last)
209 struct symtab *s = NULL;
210 const char* base_name = lbasename (name);
212 for (s = first; s != NULL && s != after_last; s = s->next)
214 if (compare_filenames_for_search (s->filename, name))
216 if (callback (s, data))
221 /* Before we invoke realpath, which can get expensive when many
222 files are involved, do a quick comparison of the basenames. */
223 if (! basenames_may_differ
224 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
227 if (compare_filenames_for_search (symtab_to_fullname (s), name))
229 if (callback (s, data))
234 /* If the user gave us an absolute path, try to find the file in
235 this symtab and use its absolute path. */
236 if (real_path != NULL)
238 const char *fullname = symtab_to_fullname (s);
240 gdb_assert (IS_ABSOLUTE_PATH (real_path));
241 gdb_assert (IS_ABSOLUTE_PATH (name));
242 if (FILENAME_CMP (real_path, fullname) == 0)
244 if (callback (s, data))
254 /* Check for a symtab of a specific name; first in symtabs, then in
255 psymtabs. *If* there is no '/' in the name, a match after a '/'
256 in the symtab filename will also work.
258 Calls CALLBACK with each symtab that is found and with the supplied
259 DATA. If CALLBACK returns true, the search stops. */
262 iterate_over_symtabs (const char *name,
263 int (*callback) (struct symtab *symtab,
267 struct objfile *objfile;
268 char *real_path = NULL;
269 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
271 /* Here we are interested in canonicalizing an absolute path, not
272 absolutizing a relative path. */
273 if (IS_ABSOLUTE_PATH (name))
275 real_path = gdb_realpath (name);
276 make_cleanup (xfree, real_path);
277 gdb_assert (IS_ABSOLUTE_PATH (real_path));
280 ALL_OBJFILES (objfile)
282 if (iterate_over_some_symtabs (name, real_path, callback, data,
283 objfile->symtabs, NULL))
285 do_cleanups (cleanups);
290 /* Same search rules as above apply here, but now we look thru the
293 ALL_OBJFILES (objfile)
296 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
302 do_cleanups (cleanups);
307 do_cleanups (cleanups);
310 /* The callback function used by lookup_symtab. */
313 lookup_symtab_callback (struct symtab *symtab, void *data)
315 struct symtab **result_ptr = data;
317 *result_ptr = symtab;
321 /* A wrapper for iterate_over_symtabs that returns the first matching
325 lookup_symtab (const char *name)
327 struct symtab *result = NULL;
329 iterate_over_symtabs (name, lookup_symtab_callback, &result);
334 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
335 full method name, which consist of the class name (from T), the unadorned
336 method name from METHOD_ID, and the signature for the specific overload,
337 specified by SIGNATURE_ID. Note that this function is g++ specific. */
340 gdb_mangle_name (struct type *type, int method_id, int signature_id)
342 int mangled_name_len;
344 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
345 struct fn_field *method = &f[signature_id];
346 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
347 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
348 const char *newname = type_name_no_tag (type);
350 /* Does the form of physname indicate that it is the full mangled name
351 of a constructor (not just the args)? */
352 int is_full_physname_constructor;
355 int is_destructor = is_destructor_name (physname);
356 /* Need a new type prefix. */
357 char *const_prefix = method->is_const ? "C" : "";
358 char *volatile_prefix = method->is_volatile ? "V" : "";
360 int len = (newname == NULL ? 0 : strlen (newname));
362 /* Nothing to do if physname already contains a fully mangled v3 abi name
363 or an operator name. */
364 if ((physname[0] == '_' && physname[1] == 'Z')
365 || is_operator_name (field_name))
366 return xstrdup (physname);
368 is_full_physname_constructor = is_constructor_name (physname);
370 is_constructor = is_full_physname_constructor
371 || (newname && strcmp (field_name, newname) == 0);
374 is_destructor = (strncmp (physname, "__dt", 4) == 0);
376 if (is_destructor || is_full_physname_constructor)
378 mangled_name = (char *) xmalloc (strlen (physname) + 1);
379 strcpy (mangled_name, physname);
385 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
387 else if (physname[0] == 't' || physname[0] == 'Q')
389 /* The physname for template and qualified methods already includes
391 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
397 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
398 volatile_prefix, len);
400 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
401 + strlen (buf) + len + strlen (physname) + 1);
403 mangled_name = (char *) xmalloc (mangled_name_len);
405 mangled_name[0] = '\0';
407 strcpy (mangled_name, field_name);
409 strcat (mangled_name, buf);
410 /* If the class doesn't have a name, i.e. newname NULL, then we just
411 mangle it using 0 for the length of the class. Thus it gets mangled
412 as something starting with `::' rather than `classname::'. */
414 strcat (mangled_name, newname);
416 strcat (mangled_name, physname);
417 return (mangled_name);
420 /* Initialize the cplus_specific structure. 'cplus_specific' should
421 only be allocated for use with cplus symbols. */
424 symbol_init_cplus_specific (struct general_symbol_info *gsymbol,
425 struct obstack *obstack)
427 /* A language_specific structure should not have been previously
429 gdb_assert (gsymbol->language_specific.cplus_specific == NULL);
430 gdb_assert (obstack != NULL);
432 gsymbol->language_specific.cplus_specific =
433 OBSTACK_ZALLOC (obstack, struct cplus_specific);
436 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
437 correctly allocated. For C++ symbols a cplus_specific struct is
438 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
439 OBJFILE can be NULL. */
442 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
444 struct obstack *obstack)
446 if (gsymbol->language == language_cplus)
448 if (gsymbol->language_specific.cplus_specific == NULL)
449 symbol_init_cplus_specific (gsymbol, obstack);
451 gsymbol->language_specific.cplus_specific->demangled_name = name;
453 else if (gsymbol->language == language_ada)
457 gsymbol->ada_mangled = 0;
458 gsymbol->language_specific.obstack = obstack;
462 gsymbol->ada_mangled = 1;
463 gsymbol->language_specific.mangled_lang.demangled_name = name;
467 gsymbol->language_specific.mangled_lang.demangled_name = name;
470 /* Return the demangled name of GSYMBOL. */
473 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
475 if (gsymbol->language == language_cplus)
477 if (gsymbol->language_specific.cplus_specific != NULL)
478 return gsymbol->language_specific.cplus_specific->demangled_name;
482 else if (gsymbol->language == language_ada)
484 if (!gsymbol->ada_mangled)
489 return gsymbol->language_specific.mangled_lang.demangled_name;
493 /* Initialize the language dependent portion of a symbol
494 depending upon the language for the symbol. */
497 symbol_set_language (struct general_symbol_info *gsymbol,
498 enum language language,
499 struct obstack *obstack)
501 gsymbol->language = language;
502 if (gsymbol->language == language_d
503 || gsymbol->language == language_go
504 || gsymbol->language == language_java
505 || gsymbol->language == language_objc
506 || gsymbol->language == language_fortran)
508 symbol_set_demangled_name (gsymbol, NULL, obstack);
510 else if (gsymbol->language == language_ada)
512 gdb_assert (gsymbol->ada_mangled == 0);
513 gsymbol->language_specific.obstack = obstack;
515 else if (gsymbol->language == language_cplus)
516 gsymbol->language_specific.cplus_specific = NULL;
519 memset (&gsymbol->language_specific, 0,
520 sizeof (gsymbol->language_specific));
524 /* Functions to initialize a symbol's mangled name. */
526 /* Objects of this type are stored in the demangled name hash table. */
527 struct demangled_name_entry
533 /* Hash function for the demangled name hash. */
536 hash_demangled_name_entry (const void *data)
538 const struct demangled_name_entry *e = data;
540 return htab_hash_string (e->mangled);
543 /* Equality function for the demangled name hash. */
546 eq_demangled_name_entry (const void *a, const void *b)
548 const struct demangled_name_entry *da = a;
549 const struct demangled_name_entry *db = b;
551 return strcmp (da->mangled, db->mangled) == 0;
554 /* Create the hash table used for demangled names. Each hash entry is
555 a pair of strings; one for the mangled name and one for the demangled
556 name. The entry is hashed via just the mangled name. */
559 create_demangled_names_hash (struct objfile *objfile)
561 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
562 The hash table code will round this up to the next prime number.
563 Choosing a much larger table size wastes memory, and saves only about
564 1% in symbol reading. */
566 objfile->demangled_names_hash = htab_create_alloc
567 (256, hash_demangled_name_entry, eq_demangled_name_entry,
568 NULL, xcalloc, xfree);
571 /* Try to determine the demangled name for a symbol, based on the
572 language of that symbol. If the language is set to language_auto,
573 it will attempt to find any demangling algorithm that works and
574 then set the language appropriately. The returned name is allocated
575 by the demangler and should be xfree'd. */
578 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
581 char *demangled = NULL;
583 if (gsymbol->language == language_unknown)
584 gsymbol->language = language_auto;
586 if (gsymbol->language == language_objc
587 || gsymbol->language == language_auto)
590 objc_demangle (mangled, 0);
591 if (demangled != NULL)
593 gsymbol->language = language_objc;
597 if (gsymbol->language == language_cplus
598 || gsymbol->language == language_auto)
601 gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
602 if (demangled != NULL)
604 gsymbol->language = language_cplus;
608 if (gsymbol->language == language_java)
611 gdb_demangle (mangled,
612 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
613 if (demangled != NULL)
615 gsymbol->language = language_java;
619 if (gsymbol->language == language_d
620 || gsymbol->language == language_auto)
622 demangled = d_demangle(mangled, 0);
623 if (demangled != NULL)
625 gsymbol->language = language_d;
629 /* FIXME(dje): Continually adding languages here is clumsy.
630 Better to just call la_demangle if !auto, and if auto then call
631 a utility routine that tries successive languages in turn and reports
632 which one it finds. I realize the la_demangle options may be different
633 for different languages but there's already a FIXME for that. */
634 if (gsymbol->language == language_go
635 || gsymbol->language == language_auto)
637 demangled = go_demangle (mangled, 0);
638 if (demangled != NULL)
640 gsymbol->language = language_go;
645 /* We could support `gsymbol->language == language_fortran' here to provide
646 module namespaces also for inferiors with only minimal symbol table (ELF
647 symbols). Just the mangling standard is not standardized across compilers
648 and there is no DW_AT_producer available for inferiors with only the ELF
649 symbols to check the mangling kind. */
653 /* Set both the mangled and demangled (if any) names for GSYMBOL based
654 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
655 objfile's obstack; but if COPY_NAME is 0 and if NAME is
656 NUL-terminated, then this function assumes that NAME is already
657 correctly saved (either permanently or with a lifetime tied to the
658 objfile), and it will not be copied.
660 The hash table corresponding to OBJFILE is used, and the memory
661 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
662 so the pointer can be discarded after calling this function. */
664 /* We have to be careful when dealing with Java names: when we run
665 into a Java minimal symbol, we don't know it's a Java symbol, so it
666 gets demangled as a C++ name. This is unfortunate, but there's not
667 much we can do about it: but when demangling partial symbols and
668 regular symbols, we'd better not reuse the wrong demangled name.
669 (See PR gdb/1039.) We solve this by putting a distinctive prefix
670 on Java names when storing them in the hash table. */
672 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
673 don't mind the Java prefix so much: different languages have
674 different demangling requirements, so it's only natural that we
675 need to keep language data around in our demangling cache. But
676 it's not good that the minimal symbol has the wrong demangled name.
677 Unfortunately, I can't think of any easy solution to that
680 #define JAVA_PREFIX "##JAVA$$"
681 #define JAVA_PREFIX_LEN 8
684 symbol_set_names (struct general_symbol_info *gsymbol,
685 const char *linkage_name, int len, int copy_name,
686 struct objfile *objfile)
688 struct demangled_name_entry **slot;
689 /* A 0-terminated copy of the linkage name. */
690 const char *linkage_name_copy;
691 /* A copy of the linkage name that might have a special Java prefix
692 added to it, for use when looking names up in the hash table. */
693 const char *lookup_name;
694 /* The length of lookup_name. */
696 struct demangled_name_entry entry;
698 if (gsymbol->language == language_ada)
700 /* In Ada, we do the symbol lookups using the mangled name, so
701 we can save some space by not storing the demangled name.
703 As a side note, we have also observed some overlap between
704 the C++ mangling and Ada mangling, similarly to what has
705 been observed with Java. Because we don't store the demangled
706 name with the symbol, we don't need to use the same trick
709 gsymbol->name = linkage_name;
712 char *name = obstack_alloc (&objfile->objfile_obstack, len + 1);
714 memcpy (name, linkage_name, len);
716 gsymbol->name = name;
718 symbol_set_demangled_name (gsymbol, NULL, &objfile->objfile_obstack);
723 if (objfile->demangled_names_hash == NULL)
724 create_demangled_names_hash (objfile);
726 /* The stabs reader generally provides names that are not
727 NUL-terminated; most of the other readers don't do this, so we
728 can just use the given copy, unless we're in the Java case. */
729 if (gsymbol->language == language_java)
733 lookup_len = len + JAVA_PREFIX_LEN;
734 alloc_name = alloca (lookup_len + 1);
735 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
736 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
737 alloc_name[lookup_len] = '\0';
739 lookup_name = alloc_name;
740 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
742 else if (linkage_name[len] != '\0')
747 alloc_name = alloca (lookup_len + 1);
748 memcpy (alloc_name, linkage_name, len);
749 alloc_name[lookup_len] = '\0';
751 lookup_name = alloc_name;
752 linkage_name_copy = alloc_name;
757 lookup_name = linkage_name;
758 linkage_name_copy = linkage_name;
761 entry.mangled = lookup_name;
762 slot = ((struct demangled_name_entry **)
763 htab_find_slot (objfile->demangled_names_hash,
766 /* If this name is not in the hash table, add it. */
768 /* A C version of the symbol may have already snuck into the table.
769 This happens to, e.g., main.init (__go_init_main). Cope. */
770 || (gsymbol->language == language_go
771 && (*slot)->demangled[0] == '\0'))
773 char *demangled_name = symbol_find_demangled_name (gsymbol,
775 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
777 /* Suppose we have demangled_name==NULL, copy_name==0, and
778 lookup_name==linkage_name. In this case, we already have the
779 mangled name saved, and we don't have a demangled name. So,
780 you might think we could save a little space by not recording
781 this in the hash table at all.
783 It turns out that it is actually important to still save such
784 an entry in the hash table, because storing this name gives
785 us better bcache hit rates for partial symbols. */
786 if (!copy_name && lookup_name == linkage_name)
788 *slot = obstack_alloc (&objfile->objfile_obstack,
789 offsetof (struct demangled_name_entry,
791 + demangled_len + 1);
792 (*slot)->mangled = lookup_name;
798 /* If we must copy the mangled name, put it directly after
799 the demangled name so we can have a single
801 *slot = obstack_alloc (&objfile->objfile_obstack,
802 offsetof (struct demangled_name_entry,
804 + lookup_len + demangled_len + 2);
805 mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
806 strcpy (mangled_ptr, lookup_name);
807 (*slot)->mangled = mangled_ptr;
810 if (demangled_name != NULL)
812 strcpy ((*slot)->demangled, demangled_name);
813 xfree (demangled_name);
816 (*slot)->demangled[0] = '\0';
819 gsymbol->name = (*slot)->mangled + lookup_len - len;
820 if ((*slot)->demangled[0] != '\0')
821 symbol_set_demangled_name (gsymbol, (*slot)->demangled,
822 &objfile->objfile_obstack);
824 symbol_set_demangled_name (gsymbol, NULL, &objfile->objfile_obstack);
827 /* Return the source code name of a symbol. In languages where
828 demangling is necessary, this is the demangled name. */
831 symbol_natural_name (const struct general_symbol_info *gsymbol)
833 switch (gsymbol->language)
840 case language_fortran:
841 if (symbol_get_demangled_name (gsymbol) != NULL)
842 return symbol_get_demangled_name (gsymbol);
845 return ada_decode_symbol (gsymbol);
849 return gsymbol->name;
852 /* Return the demangled name for a symbol based on the language for
853 that symbol. If no demangled name exists, return NULL. */
856 symbol_demangled_name (const struct general_symbol_info *gsymbol)
858 const char *dem_name = NULL;
860 switch (gsymbol->language)
867 case language_fortran:
868 dem_name = symbol_get_demangled_name (gsymbol);
871 dem_name = ada_decode_symbol (gsymbol);
879 /* Return the search name of a symbol---generally the demangled or
880 linkage name of the symbol, depending on how it will be searched for.
881 If there is no distinct demangled name, then returns the same value
882 (same pointer) as SYMBOL_LINKAGE_NAME. */
885 symbol_search_name (const struct general_symbol_info *gsymbol)
887 if (gsymbol->language == language_ada)
888 return gsymbol->name;
890 return symbol_natural_name (gsymbol);
893 /* Initialize the structure fields to zero values. */
896 init_sal (struct symtab_and_line *sal)
904 sal->explicit_pc = 0;
905 sal->explicit_line = 0;
910 /* Return 1 if the two sections are the same, or if they could
911 plausibly be copies of each other, one in an original object
912 file and another in a separated debug file. */
915 matching_obj_sections (struct obj_section *obj_first,
916 struct obj_section *obj_second)
918 asection *first = obj_first? obj_first->the_bfd_section : NULL;
919 asection *second = obj_second? obj_second->the_bfd_section : NULL;
922 /* If they're the same section, then they match. */
926 /* If either is NULL, give up. */
927 if (first == NULL || second == NULL)
930 /* This doesn't apply to absolute symbols. */
931 if (first->owner == NULL || second->owner == NULL)
934 /* If they're in the same object file, they must be different sections. */
935 if (first->owner == second->owner)
938 /* Check whether the two sections are potentially corresponding. They must
939 have the same size, address, and name. We can't compare section indexes,
940 which would be more reliable, because some sections may have been
942 if (bfd_get_section_size (first) != bfd_get_section_size (second))
945 /* In-memory addresses may start at a different offset, relativize them. */
946 if (bfd_get_section_vma (first->owner, first)
947 - bfd_get_start_address (first->owner)
948 != bfd_get_section_vma (second->owner, second)
949 - bfd_get_start_address (second->owner))
952 if (bfd_get_section_name (first->owner, first) == NULL
953 || bfd_get_section_name (second->owner, second) == NULL
954 || strcmp (bfd_get_section_name (first->owner, first),
955 bfd_get_section_name (second->owner, second)) != 0)
958 /* Otherwise check that they are in corresponding objfiles. */
961 if (obj->obfd == first->owner)
963 gdb_assert (obj != NULL);
965 if (obj->separate_debug_objfile != NULL
966 && obj->separate_debug_objfile->obfd == second->owner)
968 if (obj->separate_debug_objfile_backlink != NULL
969 && obj->separate_debug_objfile_backlink->obfd == second->owner)
976 find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
978 struct objfile *objfile;
979 struct minimal_symbol *msymbol;
981 /* If we know that this is not a text address, return failure. This is
982 necessary because we loop based on texthigh and textlow, which do
983 not include the data ranges. */
984 msymbol = lookup_minimal_symbol_by_pc_section (pc, section).minsym;
986 && (MSYMBOL_TYPE (msymbol) == mst_data
987 || MSYMBOL_TYPE (msymbol) == mst_bss
988 || MSYMBOL_TYPE (msymbol) == mst_abs
989 || MSYMBOL_TYPE (msymbol) == mst_file_data
990 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
993 ALL_OBJFILES (objfile)
995 struct symtab *result = NULL;
998 result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
1007 /* Debug symbols usually don't have section information. We need to dig that
1008 out of the minimal symbols and stash that in the debug symbol. */
1011 fixup_section (struct general_symbol_info *ginfo,
1012 CORE_ADDR addr, struct objfile *objfile)
1014 struct minimal_symbol *msym;
1016 /* First, check whether a minimal symbol with the same name exists
1017 and points to the same address. The address check is required
1018 e.g. on PowerPC64, where the minimal symbol for a function will
1019 point to the function descriptor, while the debug symbol will
1020 point to the actual function code. */
1021 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1023 ginfo->section = SYMBOL_SECTION (msym);
1026 /* Static, function-local variables do appear in the linker
1027 (minimal) symbols, but are frequently given names that won't
1028 be found via lookup_minimal_symbol(). E.g., it has been
1029 observed in frv-uclinux (ELF) executables that a static,
1030 function-local variable named "foo" might appear in the
1031 linker symbols as "foo.6" or "foo.3". Thus, there is no
1032 point in attempting to extend the lookup-by-name mechanism to
1033 handle this case due to the fact that there can be multiple
1036 So, instead, search the section table when lookup by name has
1037 failed. The ``addr'' and ``endaddr'' fields may have already
1038 been relocated. If so, the relocation offset (i.e. the
1039 ANOFFSET value) needs to be subtracted from these values when
1040 performing the comparison. We unconditionally subtract it,
1041 because, when no relocation has been performed, the ANOFFSET
1042 value will simply be zero.
1044 The address of the symbol whose section we're fixing up HAS
1045 NOT BEEN adjusted (relocated) yet. It can't have been since
1046 the section isn't yet known and knowing the section is
1047 necessary in order to add the correct relocation value. In
1048 other words, we wouldn't even be in this function (attempting
1049 to compute the section) if it were already known.
1051 Note that it is possible to search the minimal symbols
1052 (subtracting the relocation value if necessary) to find the
1053 matching minimal symbol, but this is overkill and much less
1054 efficient. It is not necessary to find the matching minimal
1055 symbol, only its section.
1057 Note that this technique (of doing a section table search)
1058 can fail when unrelocated section addresses overlap. For
1059 this reason, we still attempt a lookup by name prior to doing
1060 a search of the section table. */
1062 struct obj_section *s;
1065 ALL_OBJFILE_OSECTIONS (objfile, s)
1067 int idx = s - objfile->sections;
1068 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1073 if (obj_section_addr (s) - offset <= addr
1074 && addr < obj_section_endaddr (s) - offset)
1076 ginfo->section = idx;
1081 /* If we didn't find the section, assume it is in the first
1082 section. If there is no allocated section, then it hardly
1083 matters what we pick, so just pick zero. */
1087 ginfo->section = fallback;
1092 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1099 /* We either have an OBJFILE, or we can get at it from the sym's
1100 symtab. Anything else is a bug. */
1101 gdb_assert (objfile || SYMBOL_SYMTAB (sym));
1103 if (objfile == NULL)
1104 objfile = SYMBOL_SYMTAB (sym)->objfile;
1106 if (SYMBOL_OBJ_SECTION (objfile, sym))
1109 /* We should have an objfile by now. */
1110 gdb_assert (objfile);
1112 switch (SYMBOL_CLASS (sym))
1116 addr = SYMBOL_VALUE_ADDRESS (sym);
1119 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1123 /* Nothing else will be listed in the minsyms -- no use looking
1128 fixup_section (&sym->ginfo, addr, objfile);
1133 /* Compute the demangled form of NAME as used by the various symbol
1134 lookup functions. The result is stored in *RESULT_NAME. Returns a
1135 cleanup which can be used to clean up the result.
1137 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1138 Normally, Ada symbol lookups are performed using the encoded name
1139 rather than the demangled name, and so it might seem to make sense
1140 for this function to return an encoded version of NAME.
1141 Unfortunately, we cannot do this, because this function is used in
1142 circumstances where it is not appropriate to try to encode NAME.
1143 For instance, when displaying the frame info, we demangle the name
1144 of each parameter, and then perform a symbol lookup inside our
1145 function using that demangled name. In Ada, certain functions
1146 have internally-generated parameters whose name contain uppercase
1147 characters. Encoding those name would result in those uppercase
1148 characters to become lowercase, and thus cause the symbol lookup
1152 demangle_for_lookup (const char *name, enum language lang,
1153 const char **result_name)
1155 char *demangled_name = NULL;
1156 const char *modified_name = NULL;
1157 struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
1159 modified_name = name;
1161 /* If we are using C++, D, Go, or Java, demangle the name before doing a
1162 lookup, so we can always binary search. */
1163 if (lang == language_cplus)
1165 demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1168 modified_name = demangled_name;
1169 make_cleanup (xfree, demangled_name);
1173 /* If we were given a non-mangled name, canonicalize it
1174 according to the language (so far only for C++). */
1175 demangled_name = cp_canonicalize_string (name);
1178 modified_name = demangled_name;
1179 make_cleanup (xfree, demangled_name);
1183 else if (lang == language_java)
1185 demangled_name = gdb_demangle (name,
1186 DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1189 modified_name = demangled_name;
1190 make_cleanup (xfree, demangled_name);
1193 else if (lang == language_d)
1195 demangled_name = d_demangle (name, 0);
1198 modified_name = demangled_name;
1199 make_cleanup (xfree, demangled_name);
1202 else if (lang == language_go)
1204 demangled_name = go_demangle (name, 0);
1207 modified_name = demangled_name;
1208 make_cleanup (xfree, demangled_name);
1212 *result_name = modified_name;
1216 /* Find the definition for a specified symbol name NAME
1217 in domain DOMAIN, visible from lexical block BLOCK.
1218 Returns the struct symbol pointer, or zero if no symbol is found.
1219 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1220 NAME is a field of the current implied argument `this'. If so set
1221 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1222 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1223 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1225 /* This function (or rather its subordinates) have a bunch of loops and
1226 it would seem to be attractive to put in some QUIT's (though I'm not really
1227 sure whether it can run long enough to be really important). But there
1228 are a few calls for which it would appear to be bad news to quit
1229 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1230 that there is C++ code below which can error(), but that probably
1231 doesn't affect these calls since they are looking for a known
1232 variable and thus can probably assume it will never hit the C++
1236 lookup_symbol_in_language (const char *name, const struct block *block,
1237 const domain_enum domain, enum language lang,
1238 struct field_of_this_result *is_a_field_of_this)
1240 const char *modified_name;
1241 struct symbol *returnval;
1242 struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
1244 returnval = lookup_symbol_aux (modified_name, block, domain, lang,
1245 is_a_field_of_this);
1246 do_cleanups (cleanup);
1251 /* Behave like lookup_symbol_in_language, but performed with the
1252 current language. */
1255 lookup_symbol (const char *name, const struct block *block,
1257 struct field_of_this_result *is_a_field_of_this)
1259 return lookup_symbol_in_language (name, block, domain,
1260 current_language->la_language,
1261 is_a_field_of_this);
1264 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1265 found, or NULL if not found. */
1268 lookup_language_this (const struct language_defn *lang,
1269 const struct block *block)
1271 if (lang->la_name_of_this == NULL || block == NULL)
1278 sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1281 block_found = block;
1284 if (BLOCK_FUNCTION (block))
1286 block = BLOCK_SUPERBLOCK (block);
1292 /* Given TYPE, a structure/union,
1293 return 1 if the component named NAME from the ultimate target
1294 structure/union is defined, otherwise, return 0. */
1297 check_field (struct type *type, const char *name,
1298 struct field_of_this_result *is_a_field_of_this)
1302 /* The type may be a stub. */
1303 CHECK_TYPEDEF (type);
1305 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1307 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1309 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1311 is_a_field_of_this->type = type;
1312 is_a_field_of_this->field = &TYPE_FIELD (type, i);
1317 /* C++: If it was not found as a data field, then try to return it
1318 as a pointer to a method. */
1320 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1322 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1324 is_a_field_of_this->type = type;
1325 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1330 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1331 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
1337 /* Behave like lookup_symbol except that NAME is the natural name
1338 (e.g., demangled name) of the symbol that we're looking for. */
1340 static struct symbol *
1341 lookup_symbol_aux (const char *name, const struct block *block,
1342 const domain_enum domain, enum language language,
1343 struct field_of_this_result *is_a_field_of_this)
1346 const struct language_defn *langdef;
1348 /* Make sure we do something sensible with is_a_field_of_this, since
1349 the callers that set this parameter to some non-null value will
1350 certainly use it later. If we don't set it, the contents of
1351 is_a_field_of_this are undefined. */
1352 if (is_a_field_of_this != NULL)
1353 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
1355 /* Search specified block and its superiors. Don't search
1356 STATIC_BLOCK or GLOBAL_BLOCK. */
1358 sym = lookup_symbol_aux_local (name, block, domain, language);
1362 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1363 check to see if NAME is a field of `this'. */
1365 langdef = language_def (language);
1367 /* Don't do this check if we are searching for a struct. It will
1368 not be found by check_field, but will be found by other
1370 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
1372 struct symbol *sym = lookup_language_this (langdef, block);
1376 struct type *t = sym->type;
1378 /* I'm not really sure that type of this can ever
1379 be typedefed; just be safe. */
1381 if (TYPE_CODE (t) == TYPE_CODE_PTR
1382 || TYPE_CODE (t) == TYPE_CODE_REF)
1383 t = TYPE_TARGET_TYPE (t);
1385 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1386 && TYPE_CODE (t) != TYPE_CODE_UNION)
1387 error (_("Internal error: `%s' is not an aggregate"),
1388 langdef->la_name_of_this);
1390 if (check_field (t, name, is_a_field_of_this))
1395 /* Now do whatever is appropriate for LANGUAGE to look
1396 up static and global variables. */
1398 sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
1402 /* Now search all static file-level symbols. Not strictly correct,
1403 but more useful than an error. */
1405 return lookup_static_symbol_aux (name, domain);
1408 /* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1409 first, then check the psymtabs. If a psymtab indicates the existence of the
1410 desired name as a file-level static, then do psymtab-to-symtab conversion on
1411 the fly and return the found symbol. */
1414 lookup_static_symbol_aux (const char *name, const domain_enum domain)
1416 struct objfile *objfile;
1419 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
1423 ALL_OBJFILES (objfile)
1425 sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
1433 /* Check to see if the symbol is defined in BLOCK or its superiors.
1434 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1436 static struct symbol *
1437 lookup_symbol_aux_local (const char *name, const struct block *block,
1438 const domain_enum domain,
1439 enum language language)
1442 const struct block *static_block = block_static_block (block);
1443 const char *scope = block_scope (block);
1445 /* Check if either no block is specified or it's a global block. */
1447 if (static_block == NULL)
1450 while (block != static_block)
1452 sym = lookup_symbol_aux_block (name, block, domain);
1456 if (language == language_cplus || language == language_fortran)
1458 sym = cp_lookup_symbol_imports_or_template (scope, name, block,
1464 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
1466 block = BLOCK_SUPERBLOCK (block);
1469 /* We've reached the edge of the function without finding a result. */
1474 /* Look up OBJFILE to BLOCK. */
1477 lookup_objfile_from_block (const struct block *block)
1479 struct objfile *obj;
1485 block = block_global_block (block);
1486 /* Go through SYMTABS. */
1487 ALL_SYMTABS (obj, s)
1488 if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
1490 if (obj->separate_debug_objfile_backlink)
1491 obj = obj->separate_debug_objfile_backlink;
1499 /* Look up a symbol in a block; if found, fixup the symbol, and set
1500 block_found appropriately. */
1503 lookup_symbol_aux_block (const char *name, const struct block *block,
1504 const domain_enum domain)
1508 sym = lookup_block_symbol (block, name, domain);
1511 block_found = block;
1512 return fixup_symbol_section (sym, NULL);
1518 /* Check all global symbols in OBJFILE in symtabs and
1522 lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
1524 const domain_enum domain)
1526 const struct objfile *objfile;
1528 struct blockvector *bv;
1529 const struct block *block;
1532 for (objfile = main_objfile;
1534 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
1536 /* Go through symtabs. */
1537 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1539 bv = BLOCKVECTOR (s);
1540 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1541 sym = lookup_block_symbol (block, name, domain);
1544 block_found = block;
1545 return fixup_symbol_section (sym, (struct objfile *)objfile);
1549 sym = lookup_symbol_aux_quick ((struct objfile *) objfile, GLOBAL_BLOCK,
1558 /* Check to see if the symbol is defined in one of the OBJFILE's
1559 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1560 depending on whether or not we want to search global symbols or
1563 static struct symbol *
1564 lookup_symbol_aux_objfile (struct objfile *objfile, int block_index,
1565 const char *name, const domain_enum domain)
1567 struct symbol *sym = NULL;
1568 struct blockvector *bv;
1569 const struct block *block;
1572 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1574 bv = BLOCKVECTOR (s);
1575 block = BLOCKVECTOR_BLOCK (bv, block_index);
1576 sym = lookup_block_symbol (block, name, domain);
1579 block_found = block;
1580 return fixup_symbol_section (sym, objfile);
1587 /* Same as lookup_symbol_aux_objfile, except that it searches all
1588 objfiles. Return the first match found. */
1590 static struct symbol *
1591 lookup_symbol_aux_symtabs (int block_index, const char *name,
1592 const domain_enum domain)
1595 struct objfile *objfile;
1597 ALL_OBJFILES (objfile)
1599 sym = lookup_symbol_aux_objfile (objfile, block_index, name, domain);
1607 /* Wrapper around lookup_symbol_aux_objfile for search_symbols.
1608 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1609 and all related objfiles. */
1611 static struct symbol *
1612 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
1613 const char *linkage_name,
1616 enum language lang = current_language->la_language;
1617 const char *modified_name;
1618 struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang,
1620 struct objfile *main_objfile, *cur_objfile;
1622 if (objfile->separate_debug_objfile_backlink)
1623 main_objfile = objfile->separate_debug_objfile_backlink;
1625 main_objfile = objfile;
1627 for (cur_objfile = main_objfile;
1629 cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
1633 sym = lookup_symbol_aux_objfile (cur_objfile, GLOBAL_BLOCK,
1634 modified_name, domain);
1636 sym = lookup_symbol_aux_objfile (cur_objfile, STATIC_BLOCK,
1637 modified_name, domain);
1640 do_cleanups (cleanup);
1645 do_cleanups (cleanup);
1649 /* A helper function that throws an exception when a symbol was found
1650 in a psymtab but not in a symtab. */
1652 static void ATTRIBUTE_NORETURN
1653 error_in_psymtab_expansion (int kind, const char *name, struct symtab *symtab)
1656 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1657 %s may be an inlined function, or may be a template function\n \
1658 (if a template, try specifying an instantiation: %s<type>)."),
1659 kind == GLOBAL_BLOCK ? "global" : "static",
1660 name, symtab_to_filename_for_display (symtab), name, name);
1663 /* A helper function for lookup_symbol_aux that interfaces with the
1664 "quick" symbol table functions. */
1666 static struct symbol *
1667 lookup_symbol_aux_quick (struct objfile *objfile, int kind,
1668 const char *name, const domain_enum domain)
1670 struct symtab *symtab;
1671 struct blockvector *bv;
1672 const struct block *block;
1677 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, domain);
1681 bv = BLOCKVECTOR (symtab);
1682 block = BLOCKVECTOR_BLOCK (bv, kind);
1683 sym = lookup_block_symbol (block, name, domain);
1685 error_in_psymtab_expansion (kind, name, symtab);
1686 return fixup_symbol_section (sym, objfile);
1689 /* A default version of lookup_symbol_nonlocal for use by languages
1690 that can't think of anything better to do. This implements the C
1694 basic_lookup_symbol_nonlocal (const char *name,
1695 const struct block *block,
1696 const domain_enum domain)
1700 /* NOTE: carlton/2003-05-19: The comments below were written when
1701 this (or what turned into this) was part of lookup_symbol_aux;
1702 I'm much less worried about these questions now, since these
1703 decisions have turned out well, but I leave these comments here
1706 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1707 not it would be appropriate to search the current global block
1708 here as well. (That's what this code used to do before the
1709 is_a_field_of_this check was moved up.) On the one hand, it's
1710 redundant with the lookup_symbol_aux_symtabs search that happens
1711 next. On the other hand, if decode_line_1 is passed an argument
1712 like filename:var, then the user presumably wants 'var' to be
1713 searched for in filename. On the third hand, there shouldn't be
1714 multiple global variables all of which are named 'var', and it's
1715 not like decode_line_1 has ever restricted its search to only
1716 global variables in a single filename. All in all, only
1717 searching the static block here seems best: it's correct and it's
1720 /* NOTE: carlton/2002-12-05: There's also a possible performance
1721 issue here: if you usually search for global symbols in the
1722 current file, then it would be slightly better to search the
1723 current global block before searching all the symtabs. But there
1724 are other factors that have a much greater effect on performance
1725 than that one, so I don't think we should worry about that for
1728 sym = lookup_symbol_static (name, block, domain);
1732 return lookup_symbol_global (name, block, domain);
1735 /* Lookup a symbol in the static block associated to BLOCK, if there
1736 is one; do nothing if BLOCK is NULL or a global block. */
1739 lookup_symbol_static (const char *name,
1740 const struct block *block,
1741 const domain_enum domain)
1743 const struct block *static_block = block_static_block (block);
1745 if (static_block != NULL)
1746 return lookup_symbol_aux_block (name, static_block, domain);
1751 /* Private data to be used with lookup_symbol_global_iterator_cb. */
1753 struct global_sym_lookup_data
1755 /* The name of the symbol we are searching for. */
1758 /* The domain to use for our search. */
1761 /* The field where the callback should store the symbol if found.
1762 It should be initialized to NULL before the search is started. */
1763 struct symbol *result;
1766 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1767 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1768 OBJFILE. The arguments for the search are passed via CB_DATA,
1769 which in reality is a pointer to struct global_sym_lookup_data. */
1772 lookup_symbol_global_iterator_cb (struct objfile *objfile,
1775 struct global_sym_lookup_data *data =
1776 (struct global_sym_lookup_data *) cb_data;
1778 gdb_assert (data->result == NULL);
1780 data->result = lookup_symbol_aux_objfile (objfile, GLOBAL_BLOCK,
1781 data->name, data->domain);
1782 if (data->result == NULL)
1783 data->result = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK,
1784 data->name, data->domain);
1786 /* If we found a match, tell the iterator to stop. Otherwise,
1788 return (data->result != NULL);
1791 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1795 lookup_symbol_global (const char *name,
1796 const struct block *block,
1797 const domain_enum domain)
1799 struct symbol *sym = NULL;
1800 struct objfile *objfile = NULL;
1801 struct global_sym_lookup_data lookup_data;
1803 /* Call library-specific lookup procedure. */
1804 objfile = lookup_objfile_from_block (block);
1805 if (objfile != NULL)
1806 sym = solib_global_lookup (objfile, name, domain);
1810 memset (&lookup_data, 0, sizeof (lookup_data));
1811 lookup_data.name = name;
1812 lookup_data.domain = domain;
1813 gdbarch_iterate_over_objfiles_in_search_order
1814 (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
1815 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
1817 return lookup_data.result;
1821 symbol_matches_domain (enum language symbol_language,
1822 domain_enum symbol_domain,
1825 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1826 A Java class declaration also defines a typedef for the class.
1827 Similarly, any Ada type declaration implicitly defines a typedef. */
1828 if (symbol_language == language_cplus
1829 || symbol_language == language_d
1830 || symbol_language == language_java
1831 || symbol_language == language_ada)
1833 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
1834 && symbol_domain == STRUCT_DOMAIN)
1837 /* For all other languages, strict match is required. */
1838 return (symbol_domain == domain);
1841 /* Look up a type named NAME in the struct_domain. The type returned
1842 must not be opaque -- i.e., must have at least one field
1846 lookup_transparent_type (const char *name)
1848 return current_language->la_lookup_transparent_type (name);
1851 /* A helper for basic_lookup_transparent_type that interfaces with the
1852 "quick" symbol table functions. */
1854 static struct type *
1855 basic_lookup_transparent_type_quick (struct objfile *objfile, int kind,
1858 struct symtab *symtab;
1859 struct blockvector *bv;
1860 struct block *block;
1865 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, STRUCT_DOMAIN);
1869 bv = BLOCKVECTOR (symtab);
1870 block = BLOCKVECTOR_BLOCK (bv, kind);
1871 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1873 error_in_psymtab_expansion (kind, name, symtab);
1875 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1876 return SYMBOL_TYPE (sym);
1881 /* The standard implementation of lookup_transparent_type. This code
1882 was modeled on lookup_symbol -- the parts not relevant to looking
1883 up types were just left out. In particular it's assumed here that
1884 types are available in struct_domain and only at file-static or
1888 basic_lookup_transparent_type (const char *name)
1891 struct symtab *s = NULL;
1892 struct blockvector *bv;
1893 struct objfile *objfile;
1894 struct block *block;
1897 /* Now search all the global symbols. Do the symtab's first, then
1898 check the psymtab's. If a psymtab indicates the existence
1899 of the desired name as a global, then do psymtab-to-symtab
1900 conversion on the fly and return the found symbol. */
1902 ALL_OBJFILES (objfile)
1904 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1906 bv = BLOCKVECTOR (s);
1907 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1908 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1909 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1911 return SYMBOL_TYPE (sym);
1916 ALL_OBJFILES (objfile)
1918 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
1923 /* Now search the static file-level symbols.
1924 Not strictly correct, but more useful than an error.
1925 Do the symtab's first, then
1926 check the psymtab's. If a psymtab indicates the existence
1927 of the desired name as a file-level static, then do psymtab-to-symtab
1928 conversion on the fly and return the found symbol. */
1930 ALL_OBJFILES (objfile)
1932 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1934 bv = BLOCKVECTOR (s);
1935 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1936 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1937 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1939 return SYMBOL_TYPE (sym);
1944 ALL_OBJFILES (objfile)
1946 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
1951 return (struct type *) 0;
1954 /* Find the name of the file containing main(). */
1955 /* FIXME: What about languages without main() or specially linked
1956 executables that have no main() ? */
1959 find_main_filename (void)
1961 struct objfile *objfile;
1962 char *name = main_name ();
1964 ALL_OBJFILES (objfile)
1970 result = objfile->sf->qf->find_symbol_file (objfile, name);
1977 /* Search BLOCK for symbol NAME in DOMAIN.
1979 Note that if NAME is the demangled form of a C++ symbol, we will fail
1980 to find a match during the binary search of the non-encoded names, but
1981 for now we don't worry about the slight inefficiency of looking for
1982 a match we'll never find, since it will go pretty quick. Once the
1983 binary search terminates, we drop through and do a straight linear
1984 search on the symbols. Each symbol which is marked as being a ObjC/C++
1985 symbol (language_cplus or language_objc set) has both the encoded and
1986 non-encoded names tested for a match. */
1989 lookup_block_symbol (const struct block *block, const char *name,
1990 const domain_enum domain)
1992 struct block_iterator iter;
1995 if (!BLOCK_FUNCTION (block))
1997 for (sym = block_iter_name_first (block, name, &iter);
1999 sym = block_iter_name_next (name, &iter))
2001 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2002 SYMBOL_DOMAIN (sym), domain))
2009 /* Note that parameter symbols do not always show up last in the
2010 list; this loop makes sure to take anything else other than
2011 parameter symbols first; it only uses parameter symbols as a
2012 last resort. Note that this only takes up extra computation
2015 struct symbol *sym_found = NULL;
2017 for (sym = block_iter_name_first (block, name, &iter);
2019 sym = block_iter_name_next (name, &iter))
2021 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2022 SYMBOL_DOMAIN (sym), domain))
2025 if (!SYMBOL_IS_ARGUMENT (sym))
2031 return (sym_found); /* Will be NULL if not found. */
2035 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2037 For each symbol that matches, CALLBACK is called. The symbol and
2038 DATA are passed to the callback.
2040 If CALLBACK returns zero, the iteration ends. Otherwise, the
2041 search continues. */
2044 iterate_over_symbols (const struct block *block, const char *name,
2045 const domain_enum domain,
2046 symbol_found_callback_ftype *callback,
2049 struct block_iterator iter;
2052 for (sym = block_iter_name_first (block, name, &iter);
2054 sym = block_iter_name_next (name, &iter))
2056 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2057 SYMBOL_DOMAIN (sym), domain))
2059 if (!callback (sym, data))
2065 /* Find the symtab associated with PC and SECTION. Look through the
2066 psymtabs and read in another symtab if necessary. */
2069 find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
2072 struct blockvector *bv;
2073 struct symtab *s = NULL;
2074 struct symtab *best_s = NULL;
2075 struct objfile *objfile;
2076 CORE_ADDR distance = 0;
2077 struct minimal_symbol *msymbol;
2079 /* If we know that this is not a text address, return failure. This is
2080 necessary because we loop based on the block's high and low code
2081 addresses, which do not include the data ranges, and because
2082 we call find_pc_sect_psymtab which has a similar restriction based
2083 on the partial_symtab's texthigh and textlow. */
2084 msymbol = lookup_minimal_symbol_by_pc_section (pc, section).minsym;
2086 && (MSYMBOL_TYPE (msymbol) == mst_data
2087 || MSYMBOL_TYPE (msymbol) == mst_bss
2088 || MSYMBOL_TYPE (msymbol) == mst_abs
2089 || MSYMBOL_TYPE (msymbol) == mst_file_data
2090 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
2093 /* Search all symtabs for the one whose file contains our address, and which
2094 is the smallest of all the ones containing the address. This is designed
2095 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2096 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2097 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2099 This happens for native ecoff format, where code from included files
2100 gets its own symtab. The symtab for the included file should have
2101 been read in already via the dependency mechanism.
2102 It might be swifter to create several symtabs with the same name
2103 like xcoff does (I'm not sure).
2105 It also happens for objfiles that have their functions reordered.
2106 For these, the symtab we are looking for is not necessarily read in. */
2108 ALL_PRIMARY_SYMTABS (objfile, s)
2110 bv = BLOCKVECTOR (s);
2111 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2113 if (BLOCK_START (b) <= pc
2114 && BLOCK_END (b) > pc
2116 || BLOCK_END (b) - BLOCK_START (b) < distance))
2118 /* For an objfile that has its functions reordered,
2119 find_pc_psymtab will find the proper partial symbol table
2120 and we simply return its corresponding symtab. */
2121 /* In order to better support objfiles that contain both
2122 stabs and coff debugging info, we continue on if a psymtab
2124 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2126 struct symtab *result;
2129 = objfile->sf->qf->find_pc_sect_symtab (objfile,
2138 struct block_iterator iter;
2139 struct symbol *sym = NULL;
2141 ALL_BLOCK_SYMBOLS (b, iter, sym)
2143 fixup_symbol_section (sym, objfile);
2144 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, sym),
2149 continue; /* No symbol in this symtab matches
2152 distance = BLOCK_END (b) - BLOCK_START (b);
2160 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2162 ALL_OBJFILES (objfile)
2164 struct symtab *result;
2168 result = objfile->sf->qf->find_pc_sect_symtab (objfile,
2179 /* Find the symtab associated with PC. Look through the psymtabs and read
2180 in another symtab if necessary. Backward compatibility, no section. */
2183 find_pc_symtab (CORE_ADDR pc)
2185 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
2189 /* Find the source file and line number for a given PC value and SECTION.
2190 Return a structure containing a symtab pointer, a line number,
2191 and a pc range for the entire source line.
2192 The value's .pc field is NOT the specified pc.
2193 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2194 use the line that ends there. Otherwise, in that case, the line
2195 that begins there is used. */
2197 /* The big complication here is that a line may start in one file, and end just
2198 before the start of another file. This usually occurs when you #include
2199 code in the middle of a subroutine. To properly find the end of a line's PC
2200 range, we must search all symtabs associated with this compilation unit, and
2201 find the one whose first PC is closer than that of the next line in this
2204 /* If it's worth the effort, we could be using a binary search. */
2206 struct symtab_and_line
2207 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
2210 struct linetable *l;
2213 struct linetable_entry *item;
2214 struct symtab_and_line val;
2215 struct blockvector *bv;
2216 struct bound_minimal_symbol msymbol;
2217 struct minimal_symbol *mfunsym;
2218 struct objfile *objfile;
2220 /* Info on best line seen so far, and where it starts, and its file. */
2222 struct linetable_entry *best = NULL;
2223 CORE_ADDR best_end = 0;
2224 struct symtab *best_symtab = 0;
2226 /* Store here the first line number
2227 of a file which contains the line at the smallest pc after PC.
2228 If we don't find a line whose range contains PC,
2229 we will use a line one less than this,
2230 with a range from the start of that file to the first line's pc. */
2231 struct linetable_entry *alt = NULL;
2233 /* Info on best line seen in this file. */
2235 struct linetable_entry *prev;
2237 /* If this pc is not from the current frame,
2238 it is the address of the end of a call instruction.
2239 Quite likely that is the start of the following statement.
2240 But what we want is the statement containing the instruction.
2241 Fudge the pc to make sure we get that. */
2243 init_sal (&val); /* initialize to zeroes */
2245 val.pspace = current_program_space;
2247 /* It's tempting to assume that, if we can't find debugging info for
2248 any function enclosing PC, that we shouldn't search for line
2249 number info, either. However, GAS can emit line number info for
2250 assembly files --- very helpful when debugging hand-written
2251 assembly code. In such a case, we'd have no debug info for the
2252 function, but we would have line info. */
2257 /* elz: added this because this function returned the wrong
2258 information if the pc belongs to a stub (import/export)
2259 to call a shlib function. This stub would be anywhere between
2260 two functions in the target, and the line info was erroneously
2261 taken to be the one of the line before the pc. */
2263 /* RT: Further explanation:
2265 * We have stubs (trampolines) inserted between procedures.
2267 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2268 * exists in the main image.
2270 * In the minimal symbol table, we have a bunch of symbols
2271 * sorted by start address. The stubs are marked as "trampoline",
2272 * the others appear as text. E.g.:
2274 * Minimal symbol table for main image
2275 * main: code for main (text symbol)
2276 * shr1: stub (trampoline symbol)
2277 * foo: code for foo (text symbol)
2279 * Minimal symbol table for "shr1" image:
2281 * shr1: code for shr1 (text symbol)
2284 * So the code below is trying to detect if we are in the stub
2285 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2286 * and if found, do the symbolization from the real-code address
2287 * rather than the stub address.
2289 * Assumptions being made about the minimal symbol table:
2290 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2291 * if we're really in the trampoline.s If we're beyond it (say
2292 * we're in "foo" in the above example), it'll have a closer
2293 * symbol (the "foo" text symbol for example) and will not
2294 * return the trampoline.
2295 * 2. lookup_minimal_symbol_text() will find a real text symbol
2296 * corresponding to the trampoline, and whose address will
2297 * be different than the trampoline address. I put in a sanity
2298 * check for the address being the same, to avoid an
2299 * infinite recursion.
2301 msymbol = lookup_minimal_symbol_by_pc (pc);
2302 if (msymbol.minsym != NULL)
2303 if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
2306 = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol.minsym),
2308 if (mfunsym == NULL)
2309 /* I eliminated this warning since it is coming out
2310 * in the following situation:
2311 * gdb shmain // test program with shared libraries
2312 * (gdb) break shr1 // function in shared lib
2313 * Warning: In stub for ...
2314 * In the above situation, the shared lib is not loaded yet,
2315 * so of course we can't find the real func/line info,
2316 * but the "break" still works, and the warning is annoying.
2317 * So I commented out the warning. RT */
2318 /* warning ("In stub for %s; unable to find real function/line info",
2319 SYMBOL_LINKAGE_NAME (msymbol)); */
2322 else if (SYMBOL_VALUE_ADDRESS (mfunsym)
2323 == SYMBOL_VALUE_ADDRESS (msymbol.minsym))
2324 /* Avoid infinite recursion */
2325 /* See above comment about why warning is commented out. */
2326 /* warning ("In stub for %s; unable to find real function/line info",
2327 SYMBOL_LINKAGE_NAME (msymbol)); */
2331 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
2335 s = find_pc_sect_symtab (pc, section);
2338 /* If no symbol information, return previous pc. */
2345 bv = BLOCKVECTOR (s);
2346 objfile = s->objfile;
2348 /* Look at all the symtabs that share this blockvector.
2349 They all have the same apriori range, that we found was right;
2350 but they have different line tables. */
2352 ALL_OBJFILE_SYMTABS (objfile, s)
2354 if (BLOCKVECTOR (s) != bv)
2357 /* Find the best line in this symtab. */
2364 /* I think len can be zero if the symtab lacks line numbers
2365 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2366 I'm not sure which, and maybe it depends on the symbol
2372 item = l->item; /* Get first line info. */
2374 /* Is this file's first line closer than the first lines of other files?
2375 If so, record this file, and its first line, as best alternate. */
2376 if (item->pc > pc && (!alt || item->pc < alt->pc))
2379 for (i = 0; i < len; i++, item++)
2381 /* Leave prev pointing to the linetable entry for the last line
2382 that started at or before PC. */
2389 /* At this point, prev points at the line whose start addr is <= pc, and
2390 item points at the next line. If we ran off the end of the linetable
2391 (pc >= start of the last line), then prev == item. If pc < start of
2392 the first line, prev will not be set. */
2394 /* Is this file's best line closer than the best in the other files?
2395 If so, record this file, and its best line, as best so far. Don't
2396 save prev if it represents the end of a function (i.e. line number
2397 0) instead of a real line. */
2399 if (prev && prev->line && (!best || prev->pc > best->pc))
2404 /* Discard BEST_END if it's before the PC of the current BEST. */
2405 if (best_end <= best->pc)
2409 /* If another line (denoted by ITEM) is in the linetable and its
2410 PC is after BEST's PC, but before the current BEST_END, then
2411 use ITEM's PC as the new best_end. */
2412 if (best && i < len && item->pc > best->pc
2413 && (best_end == 0 || best_end > item->pc))
2414 best_end = item->pc;
2419 /* If we didn't find any line number info, just return zeros.
2420 We used to return alt->line - 1 here, but that could be
2421 anywhere; if we don't have line number info for this PC,
2422 don't make some up. */
2425 else if (best->line == 0)
2427 /* If our best fit is in a range of PC's for which no line
2428 number info is available (line number is zero) then we didn't
2429 find any valid line information. */
2434 val.symtab = best_symtab;
2435 val.line = best->line;
2437 if (best_end && (!alt || best_end < alt->pc))
2442 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2444 val.section = section;
2448 /* Backward compatibility (no section). */
2450 struct symtab_and_line
2451 find_pc_line (CORE_ADDR pc, int notcurrent)
2453 struct obj_section *section;
2455 section = find_pc_overlay (pc);
2456 if (pc_in_unmapped_range (pc, section))
2457 pc = overlay_mapped_address (pc, section);
2458 return find_pc_sect_line (pc, section, notcurrent);
2461 /* Find line number LINE in any symtab whose name is the same as
2464 If found, return the symtab that contains the linetable in which it was
2465 found, set *INDEX to the index in the linetable of the best entry
2466 found, and set *EXACT_MATCH nonzero if the value returned is an
2469 If not found, return NULL. */
2472 find_line_symtab (struct symtab *symtab, int line,
2473 int *index, int *exact_match)
2475 int exact = 0; /* Initialized here to avoid a compiler warning. */
2477 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2481 struct linetable *best_linetable;
2482 struct symtab *best_symtab;
2484 /* First try looking it up in the given symtab. */
2485 best_linetable = LINETABLE (symtab);
2486 best_symtab = symtab;
2487 best_index = find_line_common (best_linetable, line, &exact, 0);
2488 if (best_index < 0 || !exact)
2490 /* Didn't find an exact match. So we better keep looking for
2491 another symtab with the same name. In the case of xcoff,
2492 multiple csects for one source file (produced by IBM's FORTRAN
2493 compiler) produce multiple symtabs (this is unavoidable
2494 assuming csects can be at arbitrary places in memory and that
2495 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2497 /* BEST is the smallest linenumber > LINE so far seen,
2498 or 0 if none has been seen so far.
2499 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2502 struct objfile *objfile;
2505 if (best_index >= 0)
2506 best = best_linetable->item[best_index].line;
2510 ALL_OBJFILES (objfile)
2513 objfile->sf->qf->expand_symtabs_with_fullname (objfile,
2514 symtab_to_fullname (symtab));
2517 ALL_SYMTABS (objfile, s)
2519 struct linetable *l;
2522 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
2524 if (FILENAME_CMP (symtab_to_fullname (symtab),
2525 symtab_to_fullname (s)) != 0)
2528 ind = find_line_common (l, line, &exact, 0);
2538 if (best == 0 || l->item[ind].line < best)
2540 best = l->item[ind].line;
2553 *index = best_index;
2555 *exact_match = exact;
2560 /* Given SYMTAB, returns all the PCs function in the symtab that
2561 exactly match LINE. Returns NULL if there are no exact matches,
2562 but updates BEST_ITEM in this case. */
2565 find_pcs_for_symtab_line (struct symtab *symtab, int line,
2566 struct linetable_entry **best_item)
2569 VEC (CORE_ADDR) *result = NULL;
2571 /* First, collect all the PCs that are at this line. */
2577 idx = find_line_common (LINETABLE (symtab), line, &was_exact, start);
2583 struct linetable_entry *item = &LINETABLE (symtab)->item[idx];
2585 if (*best_item == NULL || item->line < (*best_item)->line)
2591 VEC_safe_push (CORE_ADDR, result, LINETABLE (symtab)->item[idx].pc);
2599 /* Set the PC value for a given source file and line number and return true.
2600 Returns zero for invalid line number (and sets the PC to 0).
2601 The source file is specified with a struct symtab. */
2604 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
2606 struct linetable *l;
2613 symtab = find_line_symtab (symtab, line, &ind, NULL);
2616 l = LINETABLE (symtab);
2617 *pc = l->item[ind].pc;
2624 /* Find the range of pc values in a line.
2625 Store the starting pc of the line into *STARTPTR
2626 and the ending pc (start of next line) into *ENDPTR.
2627 Returns 1 to indicate success.
2628 Returns 0 if could not find the specified line. */
2631 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2634 CORE_ADDR startaddr;
2635 struct symtab_and_line found_sal;
2638 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
2641 /* This whole function is based on address. For example, if line 10 has
2642 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2643 "info line *0x123" should say the line goes from 0x100 to 0x200
2644 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2645 This also insures that we never give a range like "starts at 0x134
2646 and ends at 0x12c". */
2648 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2649 if (found_sal.line != sal.line)
2651 /* The specified line (sal) has zero bytes. */
2652 *startptr = found_sal.pc;
2653 *endptr = found_sal.pc;
2657 *startptr = found_sal.pc;
2658 *endptr = found_sal.end;
2663 /* Given a line table and a line number, return the index into the line
2664 table for the pc of the nearest line whose number is >= the specified one.
2665 Return -1 if none is found. The value is >= 0 if it is an index.
2666 START is the index at which to start searching the line table.
2668 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2671 find_line_common (struct linetable *l, int lineno,
2672 int *exact_match, int start)
2677 /* BEST is the smallest linenumber > LINENO so far seen,
2678 or 0 if none has been seen so far.
2679 BEST_INDEX identifies the item for it. */
2681 int best_index = -1;
2692 for (i = start; i < len; i++)
2694 struct linetable_entry *item = &(l->item[i]);
2696 if (item->line == lineno)
2698 /* Return the first (lowest address) entry which matches. */
2703 if (item->line > lineno && (best == 0 || item->line < best))
2710 /* If we got here, we didn't get an exact match. */
2715 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
2717 struct symtab_and_line sal;
2719 sal = find_pc_line (pc, 0);
2722 return sal.symtab != 0;
2725 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2726 address for that function that has an entry in SYMTAB's line info
2727 table. If such an entry cannot be found, return FUNC_ADDR
2731 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
2733 CORE_ADDR func_start, func_end;
2734 struct linetable *l;
2737 /* Give up if this symbol has no lineinfo table. */
2738 l = LINETABLE (symtab);
2742 /* Get the range for the function's PC values, or give up if we
2743 cannot, for some reason. */
2744 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
2747 /* Linetable entries are ordered by PC values, see the commentary in
2748 symtab.h where `struct linetable' is defined. Thus, the first
2749 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2750 address we are looking for. */
2751 for (i = 0; i < l->nitems; i++)
2753 struct linetable_entry *item = &(l->item[i]);
2755 /* Don't use line numbers of zero, they mark special entries in
2756 the table. See the commentary on symtab.h before the
2757 definition of struct linetable. */
2758 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
2765 /* Given a function symbol SYM, find the symtab and line for the start
2767 If the argument FUNFIRSTLINE is nonzero, we want the first line
2768 of real code inside the function. */
2770 struct symtab_and_line
2771 find_function_start_sal (struct symbol *sym, int funfirstline)
2773 struct symtab_and_line sal;
2775 fixup_symbol_section (sym, NULL);
2776 sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
2777 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym), 0);
2779 /* We always should have a line for the function start address.
2780 If we don't, something is odd. Create a plain SAL refering
2781 just the PC and hope that skip_prologue_sal (if requested)
2782 can find a line number for after the prologue. */
2783 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
2786 sal.pspace = current_program_space;
2787 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2788 sal.section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
2792 skip_prologue_sal (&sal);
2797 /* Adjust SAL to the first instruction past the function prologue.
2798 If the PC was explicitly specified, the SAL is not changed.
2799 If the line number was explicitly specified, at most the SAL's PC
2800 is updated. If SAL is already past the prologue, then do nothing. */
2803 skip_prologue_sal (struct symtab_and_line *sal)
2806 struct symtab_and_line start_sal;
2807 struct cleanup *old_chain;
2808 CORE_ADDR pc, saved_pc;
2809 struct obj_section *section;
2811 struct objfile *objfile;
2812 struct gdbarch *gdbarch;
2813 struct block *b, *function_block;
2814 int force_skip, skip;
2816 /* Do not change the SAL if PC was specified explicitly. */
2817 if (sal->explicit_pc)
2820 old_chain = save_current_space_and_thread ();
2821 switch_to_program_space_and_thread (sal->pspace);
2823 sym = find_pc_sect_function (sal->pc, sal->section);
2826 fixup_symbol_section (sym, NULL);
2828 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2829 section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
2830 name = SYMBOL_LINKAGE_NAME (sym);
2831 objfile = SYMBOL_SYMTAB (sym)->objfile;
2835 struct minimal_symbol *msymbol
2836 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section).minsym;
2838 if (msymbol == NULL)
2840 do_cleanups (old_chain);
2844 objfile = msymbol_objfile (msymbol);
2845 pc = SYMBOL_VALUE_ADDRESS (msymbol);
2846 section = SYMBOL_OBJ_SECTION (objfile, msymbol);
2847 name = SYMBOL_LINKAGE_NAME (msymbol);
2850 gdbarch = get_objfile_arch (objfile);
2852 /* Process the prologue in two passes. In the first pass try to skip the
2853 prologue (SKIP is true) and verify there is a real need for it (indicated
2854 by FORCE_SKIP). If no such reason was found run a second pass where the
2855 prologue is not skipped (SKIP is false). */
2860 /* Be conservative - allow direct PC (without skipping prologue) only if we
2861 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2862 have to be set by the caller so we use SYM instead. */
2863 if (sym && SYMBOL_SYMTAB (sym)->locations_valid)
2871 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2872 so that gdbarch_skip_prologue has something unique to work on. */
2873 if (section_is_overlay (section) && !section_is_mapped (section))
2874 pc = overlay_unmapped_address (pc, section);
2876 /* Skip "first line" of function (which is actually its prologue). */
2877 pc += gdbarch_deprecated_function_start_offset (gdbarch);
2879 pc = gdbarch_skip_prologue (gdbarch, pc);
2881 /* For overlays, map pc back into its mapped VMA range. */
2882 pc = overlay_mapped_address (pc, section);
2884 /* Calculate line number. */
2885 start_sal = find_pc_sect_line (pc, section, 0);
2887 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2888 line is still part of the same function. */
2889 if (skip && start_sal.pc != pc
2890 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
2891 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2892 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
2893 == lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
2895 /* First pc of next line */
2897 /* Recalculate the line number (might not be N+1). */
2898 start_sal = find_pc_sect_line (pc, section, 0);
2901 /* On targets with executable formats that don't have a concept of
2902 constructors (ELF with .init has, PE doesn't), gcc emits a call
2903 to `__main' in `main' between the prologue and before user
2905 if (gdbarch_skip_main_prologue_p (gdbarch)
2906 && name && strcmp_iw (name, "main") == 0)
2908 pc = gdbarch_skip_main_prologue (gdbarch, pc);
2909 /* Recalculate the line number (might not be N+1). */
2910 start_sal = find_pc_sect_line (pc, section, 0);
2914 while (!force_skip && skip--);
2916 /* If we still don't have a valid source line, try to find the first
2917 PC in the lineinfo table that belongs to the same function. This
2918 happens with COFF debug info, which does not seem to have an
2919 entry in lineinfo table for the code after the prologue which has
2920 no direct relation to source. For example, this was found to be
2921 the case with the DJGPP target using "gcc -gcoff" when the
2922 compiler inserted code after the prologue to make sure the stack
2924 if (!force_skip && sym && start_sal.symtab == NULL)
2926 pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
2927 /* Recalculate the line number. */
2928 start_sal = find_pc_sect_line (pc, section, 0);
2931 do_cleanups (old_chain);
2933 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2934 forward SAL to the end of the prologue. */
2939 sal->section = section;
2941 /* Unless the explicit_line flag was set, update the SAL line
2942 and symtab to correspond to the modified PC location. */
2943 if (sal->explicit_line)
2946 sal->symtab = start_sal.symtab;
2947 sal->line = start_sal.line;
2948 sal->end = start_sal.end;
2950 /* Check if we are now inside an inlined function. If we can,
2951 use the call site of the function instead. */
2952 b = block_for_pc_sect (sal->pc, sal->section);
2953 function_block = NULL;
2956 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
2958 else if (BLOCK_FUNCTION (b) != NULL)
2960 b = BLOCK_SUPERBLOCK (b);
2962 if (function_block != NULL
2963 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
2965 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
2966 sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
2970 /* If P is of the form "operator[ \t]+..." where `...' is
2971 some legitimate operator text, return a pointer to the
2972 beginning of the substring of the operator text.
2973 Otherwise, return "". */
2976 operator_chars (char *p, char **end)
2979 if (strncmp (p, "operator", 8))
2983 /* Don't get faked out by `operator' being part of a longer
2985 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
2988 /* Allow some whitespace between `operator' and the operator symbol. */
2989 while (*p == ' ' || *p == '\t')
2992 /* Recognize 'operator TYPENAME'. */
2994 if (isalpha (*p) || *p == '_' || *p == '$')
2998 while (isalnum (*q) || *q == '_' || *q == '$')
3007 case '\\': /* regexp quoting */
3010 if (p[2] == '=') /* 'operator\*=' */
3012 else /* 'operator\*' */
3016 else if (p[1] == '[')
3019 error (_("mismatched quoting on brackets, "
3020 "try 'operator\\[\\]'"));
3021 else if (p[2] == '\\' && p[3] == ']')
3023 *end = p + 4; /* 'operator\[\]' */
3027 error (_("nothing is allowed between '[' and ']'"));
3031 /* Gratuitous qoute: skip it and move on. */
3053 if (p[0] == '-' && p[1] == '>')
3055 /* Struct pointer member operator 'operator->'. */
3058 *end = p + 3; /* 'operator->*' */
3061 else if (p[2] == '\\')
3063 *end = p + 4; /* Hopefully 'operator->\*' */
3068 *end = p + 2; /* 'operator->' */
3072 if (p[1] == '=' || p[1] == p[0])
3083 error (_("`operator ()' must be specified "
3084 "without whitespace in `()'"));
3089 error (_("`operator ?:' must be specified "
3090 "without whitespace in `?:'"));
3095 error (_("`operator []' must be specified "
3096 "without whitespace in `[]'"));
3100 error (_("`operator %s' not supported"), p);
3109 /* Cache to watch for file names already seen by filename_seen. */
3111 struct filename_seen_cache
3113 /* Table of files seen so far. */
3115 /* Initial size of the table. It automagically grows from here. */
3116 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
3119 /* filename_seen_cache constructor. */
3121 static struct filename_seen_cache *
3122 create_filename_seen_cache (void)
3124 struct filename_seen_cache *cache;
3126 cache = XNEW (struct filename_seen_cache);
3127 cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
3128 filename_hash, filename_eq,
3129 NULL, xcalloc, xfree);
3134 /* Empty the cache, but do not delete it. */
3137 clear_filename_seen_cache (struct filename_seen_cache *cache)
3139 htab_empty (cache->tab);
3142 /* filename_seen_cache destructor.
3143 This takes a void * argument as it is generally used as a cleanup. */
3146 delete_filename_seen_cache (void *ptr)
3148 struct filename_seen_cache *cache = ptr;
3150 htab_delete (cache->tab);
3154 /* If FILE is not already in the table of files in CACHE, return zero;
3155 otherwise return non-zero. Optionally add FILE to the table if ADD
3158 NOTE: We don't manage space for FILE, we assume FILE lives as long
3159 as the caller needs. */
3162 filename_seen (struct filename_seen_cache *cache, const char *file, int add)
3166 /* Is FILE in tab? */
3167 slot = htab_find_slot (cache->tab, file, add ? INSERT : NO_INSERT);
3171 /* No; maybe add it to tab. */
3173 *slot = (char *) file;
3178 /* Data structure to maintain printing state for output_source_filename. */
3180 struct output_source_filename_data
3182 /* Cache of what we've seen so far. */
3183 struct filename_seen_cache *filename_seen_cache;
3185 /* Flag of whether we're printing the first one. */
3189 /* Slave routine for sources_info. Force line breaks at ,'s.
3190 NAME is the name to print.
3191 DATA contains the state for printing and watching for duplicates. */
3194 output_source_filename (const char *name,
3195 struct output_source_filename_data *data)
3197 /* Since a single source file can result in several partial symbol
3198 tables, we need to avoid printing it more than once. Note: if
3199 some of the psymtabs are read in and some are not, it gets
3200 printed both under "Source files for which symbols have been
3201 read" and "Source files for which symbols will be read in on
3202 demand". I consider this a reasonable way to deal with the
3203 situation. I'm not sure whether this can also happen for
3204 symtabs; it doesn't hurt to check. */
3206 /* Was NAME already seen? */
3207 if (filename_seen (data->filename_seen_cache, name, 1))
3209 /* Yes; don't print it again. */
3213 /* No; print it and reset *FIRST. */
3215 printf_filtered (", ");
3219 fputs_filtered (name, gdb_stdout);
3222 /* A callback for map_partial_symbol_filenames. */
3225 output_partial_symbol_filename (const char *filename, const char *fullname,
3228 output_source_filename (fullname ? fullname : filename, data);
3232 sources_info (char *ignore, int from_tty)
3235 struct objfile *objfile;
3236 struct output_source_filename_data data;
3237 struct cleanup *cleanups;
3239 if (!have_full_symbols () && !have_partial_symbols ())
3241 error (_("No symbol table is loaded. Use the \"file\" command."));
3244 data.filename_seen_cache = create_filename_seen_cache ();
3245 cleanups = make_cleanup (delete_filename_seen_cache,
3246 data.filename_seen_cache);
3248 printf_filtered ("Source files for which symbols have been read in:\n\n");
3251 ALL_SYMTABS (objfile, s)
3253 const char *fullname = symtab_to_fullname (s);
3255 output_source_filename (fullname, &data);
3257 printf_filtered ("\n\n");
3259 printf_filtered ("Source files for which symbols "
3260 "will be read in on demand:\n\n");
3262 clear_filename_seen_cache (data.filename_seen_cache);
3264 map_partial_symbol_filenames (output_partial_symbol_filename, &data,
3265 1 /*need_fullname*/);
3266 printf_filtered ("\n");
3268 do_cleanups (cleanups);
3271 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
3272 non-zero compare only lbasename of FILES. */
3275 file_matches (const char *file, char *files[], int nfiles, int basenames)
3279 if (file != NULL && nfiles != 0)
3281 for (i = 0; i < nfiles; i++)
3283 if (compare_filenames_for_search (file, (basenames
3284 ? lbasename (files[i])
3289 else if (nfiles == 0)
3294 /* Free any memory associated with a search. */
3297 free_search_symbols (struct symbol_search *symbols)
3299 struct symbol_search *p;
3300 struct symbol_search *next;
3302 for (p = symbols; p != NULL; p = next)
3310 do_free_search_symbols_cleanup (void *symbols)
3312 free_search_symbols (symbols);
3316 make_cleanup_free_search_symbols (struct symbol_search *symbols)
3318 return make_cleanup (do_free_search_symbols_cleanup, symbols);
3321 /* Helper function for sort_search_symbols and qsort. Can only
3322 sort symbols, not minimal symbols. */
3325 compare_search_syms (const void *sa, const void *sb)
3327 struct symbol_search **sym_a = (struct symbol_search **) sa;
3328 struct symbol_search **sym_b = (struct symbol_search **) sb;
3330 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
3331 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
3334 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
3335 prevtail where it is, but update its next pointer to point to
3336 the first of the sorted symbols. */
3338 static struct symbol_search *
3339 sort_search_symbols (struct symbol_search *prevtail, int nfound)
3341 struct symbol_search **symbols, *symp, *old_next;
3344 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
3346 symp = prevtail->next;
3347 for (i = 0; i < nfound; i++)
3352 /* Generally NULL. */
3355 qsort (symbols, nfound, sizeof (struct symbol_search *),
3356 compare_search_syms);
3359 for (i = 0; i < nfound; i++)
3361 symp->next = symbols[i];
3364 symp->next = old_next;
3370 /* An object of this type is passed as the user_data to the
3371 expand_symtabs_matching method. */
3372 struct search_symbols_data
3377 /* It is true if PREG contains valid data, false otherwise. */
3378 unsigned preg_p : 1;
3382 /* A callback for expand_symtabs_matching. */
3385 search_symbols_file_matches (const char *filename, void *user_data,
3388 struct search_symbols_data *data = user_data;
3390 return file_matches (filename, data->files, data->nfiles, basenames);
3393 /* A callback for expand_symtabs_matching. */
3396 search_symbols_name_matches (const char *symname, void *user_data)
3398 struct search_symbols_data *data = user_data;
3400 return !data->preg_p || regexec (&data->preg, symname, 0, NULL, 0) == 0;
3403 /* Search the symbol table for matches to the regular expression REGEXP,
3404 returning the results in *MATCHES.
3406 Only symbols of KIND are searched:
3407 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3408 and constants (enums)
3409 FUNCTIONS_DOMAIN - search all functions
3410 TYPES_DOMAIN - search all type names
3411 ALL_DOMAIN - an internal error for this function
3413 free_search_symbols should be called when *MATCHES is no longer needed.
3415 The results are sorted locally; each symtab's global and static blocks are
3416 separately alphabetized. */
3419 search_symbols (char *regexp, enum search_domain kind,
3420 int nfiles, char *files[],
3421 struct symbol_search **matches)
3424 struct blockvector *bv;
3427 struct block_iterator iter;
3429 struct objfile *objfile;
3430 struct minimal_symbol *msymbol;
3432 static const enum minimal_symbol_type types[]
3433 = {mst_data, mst_text, mst_abs};
3434 static const enum minimal_symbol_type types2[]
3435 = {mst_bss, mst_file_text, mst_abs};
3436 static const enum minimal_symbol_type types3[]
3437 = {mst_file_data, mst_solib_trampoline, mst_abs};
3438 static const enum minimal_symbol_type types4[]
3439 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
3440 enum minimal_symbol_type ourtype;
3441 enum minimal_symbol_type ourtype2;
3442 enum minimal_symbol_type ourtype3;
3443 enum minimal_symbol_type ourtype4;
3444 struct symbol_search *sr;
3445 struct symbol_search *psr;
3446 struct symbol_search *tail;
3447 struct search_symbols_data datum;
3449 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3450 CLEANUP_CHAIN is freed only in the case of an error. */
3451 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3452 struct cleanup *retval_chain;
3454 gdb_assert (kind <= TYPES_DOMAIN);
3456 ourtype = types[kind];
3457 ourtype2 = types2[kind];
3458 ourtype3 = types3[kind];
3459 ourtype4 = types4[kind];
3461 sr = *matches = NULL;
3467 /* Make sure spacing is right for C++ operators.
3468 This is just a courtesy to make the matching less sensitive
3469 to how many spaces the user leaves between 'operator'
3470 and <TYPENAME> or <OPERATOR>. */
3472 char *opname = operator_chars (regexp, &opend);
3477 int fix = -1; /* -1 means ok; otherwise number of
3480 if (isalpha (*opname) || *opname == '_' || *opname == '$')
3482 /* There should 1 space between 'operator' and 'TYPENAME'. */
3483 if (opname[-1] != ' ' || opname[-2] == ' ')
3488 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3489 if (opname[-1] == ' ')
3492 /* If wrong number of spaces, fix it. */
3495 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
3497 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
3502 errcode = regcomp (&datum.preg, regexp,
3503 REG_NOSUB | (case_sensitivity == case_sensitive_off
3507 char *err = get_regcomp_error (errcode, &datum.preg);
3509 make_cleanup (xfree, err);
3510 error (_("Invalid regexp (%s): %s"), err, regexp);
3513 make_regfree_cleanup (&datum.preg);
3516 /* Search through the partial symtabs *first* for all symbols
3517 matching the regexp. That way we don't have to reproduce all of
3518 the machinery below. */
3520 datum.nfiles = nfiles;
3521 datum.files = files;
3522 ALL_OBJFILES (objfile)
3525 objfile->sf->qf->expand_symtabs_matching (objfile,
3528 : search_symbols_file_matches),
3529 search_symbols_name_matches,
3534 retval_chain = make_cleanup (null_cleanup, NULL);
3536 /* Here, we search through the minimal symbol tables for functions
3537 and variables that match, and force their symbols to be read.
3538 This is in particular necessary for demangled variable names,
3539 which are no longer put into the partial symbol tables.
3540 The symbol will then be found during the scan of symtabs below.
3542 For functions, find_pc_symtab should succeed if we have debug info
3543 for the function, for variables we have to call
3544 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3546 If the lookup fails, set found_misc so that we will rescan to print
3547 any matching symbols without debug info.
3548 We only search the objfile the msymbol came from, we no longer search
3549 all objfiles. In large programs (1000s of shared libs) searching all
3550 objfiles is not worth the pain. */
3552 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
3554 ALL_MSYMBOLS (objfile, msymbol)
3558 if (msymbol->created_by_gdb)
3561 if (MSYMBOL_TYPE (msymbol) == ourtype
3562 || MSYMBOL_TYPE (msymbol) == ourtype2
3563 || MSYMBOL_TYPE (msymbol) == ourtype3
3564 || MSYMBOL_TYPE (msymbol) == ourtype4)
3567 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3570 /* Note: An important side-effect of these lookup functions
3571 is to expand the symbol table if msymbol is found, for the
3572 benefit of the next loop on ALL_PRIMARY_SYMTABS. */
3573 if (kind == FUNCTIONS_DOMAIN
3574 ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL
3575 : (lookup_symbol_in_objfile_from_linkage_name
3576 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3584 ALL_PRIMARY_SYMTABS (objfile, s)
3586 bv = BLOCKVECTOR (s);
3587 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3589 struct symbol_search *prevtail = tail;
3592 b = BLOCKVECTOR_BLOCK (bv, i);
3593 ALL_BLOCK_SYMBOLS (b, iter, sym)
3595 struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
3599 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
3600 a substring of symtab_to_fullname as it may contain "./" etc. */
3601 if ((file_matches (real_symtab->filename, files, nfiles, 0)
3602 || ((basenames_may_differ
3603 || file_matches (lbasename (real_symtab->filename),
3605 && file_matches (symtab_to_fullname (real_symtab),
3608 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
3610 && ((kind == VARIABLES_DOMAIN
3611 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3612 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
3613 && SYMBOL_CLASS (sym) != LOC_BLOCK
3614 /* LOC_CONST can be used for more than just enums,
3615 e.g., c++ static const members.
3616 We only want to skip enums here. */
3617 && !(SYMBOL_CLASS (sym) == LOC_CONST
3618 && TYPE_CODE (SYMBOL_TYPE (sym))
3620 || (kind == FUNCTIONS_DOMAIN
3621 && SYMBOL_CLASS (sym) == LOC_BLOCK)
3622 || (kind == TYPES_DOMAIN
3623 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
3626 psr = (struct symbol_search *)
3627 xmalloc (sizeof (struct symbol_search));
3629 psr->symtab = real_symtab;
3631 psr->msymbol = NULL;
3643 if (prevtail == NULL)
3645 struct symbol_search dummy;
3648 tail = sort_search_symbols (&dummy, nfound);
3651 make_cleanup_free_search_symbols (sr);
3654 tail = sort_search_symbols (prevtail, nfound);
3659 /* If there are no eyes, avoid all contact. I mean, if there are
3660 no debug symbols, then print directly from the msymbol_vector. */
3662 if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
3664 ALL_MSYMBOLS (objfile, msymbol)
3668 if (msymbol->created_by_gdb)
3671 if (MSYMBOL_TYPE (msymbol) == ourtype
3672 || MSYMBOL_TYPE (msymbol) == ourtype2
3673 || MSYMBOL_TYPE (msymbol) == ourtype3
3674 || MSYMBOL_TYPE (msymbol) == ourtype4)
3677 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3680 /* For functions we can do a quick check of whether the
3681 symbol might be found via find_pc_symtab. */
3682 if (kind != FUNCTIONS_DOMAIN
3683 || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
3685 if (lookup_symbol_in_objfile_from_linkage_name
3686 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3690 psr = (struct symbol_search *)
3691 xmalloc (sizeof (struct symbol_search));
3693 psr->msymbol = msymbol;
3700 make_cleanup_free_search_symbols (sr);
3712 discard_cleanups (retval_chain);
3713 do_cleanups (old_chain);
3717 /* Helper function for symtab_symbol_info, this function uses
3718 the data returned from search_symbols() to print information
3719 regarding the match to gdb_stdout. */
3722 print_symbol_info (enum search_domain kind,
3723 struct symtab *s, struct symbol *sym,
3724 int block, const char *last)
3726 const char *s_filename = symtab_to_filename_for_display (s);
3728 if (last == NULL || filename_cmp (last, s_filename) != 0)
3730 fputs_filtered ("\nFile ", gdb_stdout);
3731 fputs_filtered (s_filename, gdb_stdout);
3732 fputs_filtered (":\n", gdb_stdout);
3735 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
3736 printf_filtered ("static ");
3738 /* Typedef that is not a C++ class. */
3739 if (kind == TYPES_DOMAIN
3740 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
3741 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
3742 /* variable, func, or typedef-that-is-c++-class. */
3743 else if (kind < TYPES_DOMAIN
3744 || (kind == TYPES_DOMAIN
3745 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
3747 type_print (SYMBOL_TYPE (sym),
3748 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3749 ? "" : SYMBOL_PRINT_NAME (sym)),
3752 printf_filtered (";\n");
3756 /* This help function for symtab_symbol_info() prints information
3757 for non-debugging symbols to gdb_stdout. */
3760 print_msymbol_info (struct minimal_symbol *msymbol)
3762 struct gdbarch *gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
3765 if (gdbarch_addr_bit (gdbarch) <= 32)
3766 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3767 & (CORE_ADDR) 0xffffffff,
3770 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3772 printf_filtered ("%s %s\n",
3773 tmp, SYMBOL_PRINT_NAME (msymbol));
3776 /* This is the guts of the commands "info functions", "info types", and
3777 "info variables". It calls search_symbols to find all matches and then
3778 print_[m]symbol_info to print out some useful information about the
3782 symtab_symbol_info (char *regexp, enum search_domain kind, int from_tty)
3784 static const char * const classnames[] =
3785 {"variable", "function", "type"};
3786 struct symbol_search *symbols;
3787 struct symbol_search *p;
3788 struct cleanup *old_chain;
3789 const char *last_filename = NULL;
3792 gdb_assert (kind <= TYPES_DOMAIN);
3794 /* Must make sure that if we're interrupted, symbols gets freed. */
3795 search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
3796 old_chain = make_cleanup_free_search_symbols (symbols);
3799 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3800 classnames[kind], regexp);
3802 printf_filtered (_("All defined %ss:\n"), classnames[kind]);
3804 for (p = symbols; p != NULL; p = p->next)
3808 if (p->msymbol != NULL)
3812 printf_filtered (_("\nNon-debugging symbols:\n"));
3815 print_msymbol_info (p->msymbol);
3819 print_symbol_info (kind,
3824 last_filename = symtab_to_filename_for_display (p->symtab);
3828 do_cleanups (old_chain);
3832 variables_info (char *regexp, int from_tty)
3834 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
3838 functions_info (char *regexp, int from_tty)
3840 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
3845 types_info (char *regexp, int from_tty)
3847 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
3850 /* Breakpoint all functions matching regular expression. */
3853 rbreak_command_wrapper (char *regexp, int from_tty)
3855 rbreak_command (regexp, from_tty);
3858 /* A cleanup function that calls end_rbreak_breakpoints. */
3861 do_end_rbreak_breakpoints (void *ignore)
3863 end_rbreak_breakpoints ();
3867 rbreak_command (char *regexp, int from_tty)
3869 struct symbol_search *ss;
3870 struct symbol_search *p;
3871 struct cleanup *old_chain;
3872 char *string = NULL;
3874 char **files = NULL, *file_name;
3879 char *colon = strchr (regexp, ':');
3881 if (colon && *(colon + 1) != ':')
3885 colon_index = colon - regexp;
3886 file_name = alloca (colon_index + 1);
3887 memcpy (file_name, regexp, colon_index);
3888 file_name[colon_index--] = 0;
3889 while (isspace (file_name[colon_index]))
3890 file_name[colon_index--] = 0;
3893 regexp = skip_spaces (colon + 1);
3897 search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
3898 old_chain = make_cleanup_free_search_symbols (ss);
3899 make_cleanup (free_current_contents, &string);
3901 start_rbreak_breakpoints ();
3902 make_cleanup (do_end_rbreak_breakpoints, NULL);
3903 for (p = ss; p != NULL; p = p->next)
3905 if (p->msymbol == NULL)
3907 const char *fullname = symtab_to_fullname (p->symtab);
3909 int newlen = (strlen (fullname)
3910 + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3915 string = xrealloc (string, newlen);
3918 strcpy (string, fullname);
3919 strcat (string, ":'");
3920 strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
3921 strcat (string, "'");
3922 break_command (string, from_tty);
3923 print_symbol_info (FUNCTIONS_DOMAIN,
3927 symtab_to_filename_for_display (p->symtab));
3931 int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
3935 string = xrealloc (string, newlen);
3938 strcpy (string, "'");
3939 strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol));
3940 strcat (string, "'");
3942 break_command (string, from_tty);
3943 printf_filtered ("<function, no debug info> %s;\n",
3944 SYMBOL_PRINT_NAME (p->msymbol));
3948 do_cleanups (old_chain);
3952 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3954 Either sym_text[sym_text_len] != '(' and then we search for any
3955 symbol starting with SYM_TEXT text.
3957 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3958 be terminated at that point. Partial symbol tables do not have parameters
3962 compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
3964 int (*ncmp) (const char *, const char *, size_t);
3966 ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
3968 if (ncmp (name, sym_text, sym_text_len) != 0)
3971 if (sym_text[sym_text_len] == '(')
3973 /* User searches for `name(someth...'. Require NAME to be terminated.
3974 Normally psymtabs and gdbindex have no parameter types so '\0' will be
3975 present but accept even parameters presence. In this case this
3976 function is in fact strcmp_iw but whitespace skipping is not supported
3977 for tab completion. */
3979 if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
3986 /* Free any memory associated with a completion list. */
3989 free_completion_list (VEC (char_ptr) **list_ptr)
3994 for (i = 0; VEC_iterate (char_ptr, *list_ptr, i, p); ++i)
3996 VEC_free (char_ptr, *list_ptr);
3999 /* Callback for make_cleanup. */
4002 do_free_completion_list (void *list)
4004 free_completion_list (list);
4007 /* Helper routine for make_symbol_completion_list. */
4009 static VEC (char_ptr) *return_val;
4011 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4012 completion_list_add_name \
4013 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4015 /* Test to see if the symbol specified by SYMNAME (which is already
4016 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4017 characters. If so, add it to the current completion list. */
4020 completion_list_add_name (const char *symname,
4021 const char *sym_text, int sym_text_len,
4022 const char *text, const char *word)
4024 /* Clip symbols that cannot match. */
4025 if (!compare_symbol_name (symname, sym_text, sym_text_len))
4028 /* We have a match for a completion, so add SYMNAME to the current list
4029 of matches. Note that the name is moved to freshly malloc'd space. */
4034 if (word == sym_text)
4036 new = xmalloc (strlen (symname) + 5);
4037 strcpy (new, symname);
4039 else if (word > sym_text)
4041 /* Return some portion of symname. */
4042 new = xmalloc (strlen (symname) + 5);
4043 strcpy (new, symname + (word - sym_text));
4047 /* Return some of SYM_TEXT plus symname. */
4048 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
4049 strncpy (new, word, sym_text - word);
4050 new[sym_text - word] = '\0';
4051 strcat (new, symname);
4054 VEC_safe_push (char_ptr, return_val, new);
4058 /* ObjC: In case we are completing on a selector, look as the msymbol
4059 again and feed all the selectors into the mill. */
4062 completion_list_objc_symbol (struct minimal_symbol *msymbol,
4063 const char *sym_text, int sym_text_len,
4064 const char *text, const char *word)
4066 static char *tmp = NULL;
4067 static unsigned int tmplen = 0;
4069 const char *method, *category, *selector;
4072 method = SYMBOL_NATURAL_NAME (msymbol);
4074 /* Is it a method? */
4075 if ((method[0] != '-') && (method[0] != '+'))
4078 if (sym_text[0] == '[')
4079 /* Complete on shortened method method. */
4080 completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
4082 while ((strlen (method) + 1) >= tmplen)
4088 tmp = xrealloc (tmp, tmplen);
4090 selector = strchr (method, ' ');
4091 if (selector != NULL)
4094 category = strchr (method, '(');
4096 if ((category != NULL) && (selector != NULL))
4098 memcpy (tmp, method, (category - method));
4099 tmp[category - method] = ' ';
4100 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4101 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4102 if (sym_text[0] == '[')
4103 completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
4106 if (selector != NULL)
4108 /* Complete on selector only. */
4109 strcpy (tmp, selector);
4110 tmp2 = strchr (tmp, ']');
4114 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4118 /* Break the non-quoted text based on the characters which are in
4119 symbols. FIXME: This should probably be language-specific. */
4122 language_search_unquoted_string (const char *text, const char *p)
4124 for (; p > text; --p)
4126 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4130 if ((current_language->la_language == language_objc))
4132 if (p[-1] == ':') /* Might be part of a method name. */
4134 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
4135 p -= 2; /* Beginning of a method name. */
4136 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
4137 { /* Might be part of a method name. */
4140 /* Seeing a ' ' or a '(' is not conclusive evidence
4141 that we are in the middle of a method name. However,
4142 finding "-[" or "+[" should be pretty un-ambiguous.
4143 Unfortunately we have to find it now to decide. */
4146 if (isalnum (t[-1]) || t[-1] == '_' ||
4147 t[-1] == ' ' || t[-1] == ':' ||
4148 t[-1] == '(' || t[-1] == ')')
4153 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
4154 p = t - 2; /* Method name detected. */
4155 /* Else we leave with p unchanged. */
4165 completion_list_add_fields (struct symbol *sym, const char *sym_text,
4166 int sym_text_len, const char *text,
4169 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4171 struct type *t = SYMBOL_TYPE (sym);
4172 enum type_code c = TYPE_CODE (t);
4175 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4176 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4177 if (TYPE_FIELD_NAME (t, j))
4178 completion_list_add_name (TYPE_FIELD_NAME (t, j),
4179 sym_text, sym_text_len, text, word);
4183 /* Type of the user_data argument passed to add_macro_name or
4184 expand_partial_symbol_name. The contents are simply whatever is
4185 needed by completion_list_add_name. */
4186 struct add_name_data
4188 const char *sym_text;
4194 /* A callback used with macro_for_each and macro_for_each_in_scope.
4195 This adds a macro's name to the current completion list. */
4198 add_macro_name (const char *name, const struct macro_definition *ignore,
4199 struct macro_source_file *ignore2, int ignore3,
4202 struct add_name_data *datum = (struct add_name_data *) user_data;
4204 completion_list_add_name ((char *) name,
4205 datum->sym_text, datum->sym_text_len,
4206 datum->text, datum->word);
4209 /* A callback for expand_partial_symbol_names. */
4212 expand_partial_symbol_name (const char *name, void *user_data)
4214 struct add_name_data *datum = (struct add_name_data *) user_data;
4216 return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
4220 default_make_symbol_completion_list_break_on (const char *text,
4222 const char *break_on,
4223 enum type_code code)
4225 /* Problem: All of the symbols have to be copied because readline
4226 frees them. I'm not going to worry about this; hopefully there
4227 won't be that many. */
4231 struct minimal_symbol *msymbol;
4232 struct objfile *objfile;
4234 const struct block *surrounding_static_block, *surrounding_global_block;
4235 struct block_iterator iter;
4236 /* The symbol we are completing on. Points in same buffer as text. */
4237 const char *sym_text;
4238 /* Length of sym_text. */
4240 struct add_name_data datum;
4241 struct cleanup *back_to;
4243 /* Now look for the symbol we are supposed to complete on. */
4247 const char *quote_pos = NULL;
4249 /* First see if this is a quoted string. */
4251 for (p = text; *p != '\0'; ++p)
4253 if (quote_found != '\0')
4255 if (*p == quote_found)
4256 /* Found close quote. */
4258 else if (*p == '\\' && p[1] == quote_found)
4259 /* A backslash followed by the quote character
4260 doesn't end the string. */
4263 else if (*p == '\'' || *p == '"')
4269 if (quote_found == '\'')
4270 /* A string within single quotes can be a symbol, so complete on it. */
4271 sym_text = quote_pos + 1;
4272 else if (quote_found == '"')
4273 /* A double-quoted string is never a symbol, nor does it make sense
4274 to complete it any other way. */
4280 /* It is not a quoted string. Break it based on the characters
4281 which are in symbols. */
4284 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
4285 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
4294 sym_text_len = strlen (sym_text);
4296 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4298 if (current_language->la_language == language_cplus
4299 || current_language->la_language == language_java
4300 || current_language->la_language == language_fortran)
4302 /* These languages may have parameters entered by user but they are never
4303 present in the partial symbol tables. */
4305 const char *cs = memchr (sym_text, '(', sym_text_len);
4308 sym_text_len = cs - sym_text;
4310 gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
4313 back_to = make_cleanup (do_free_completion_list, &return_val);
4315 datum.sym_text = sym_text;
4316 datum.sym_text_len = sym_text_len;
4320 /* Look through the partial symtabs for all symbols which begin
4321 by matching SYM_TEXT. Expand all CUs that you find to the list.
4322 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4323 expand_partial_symbol_names (expand_partial_symbol_name, &datum);
4325 /* At this point scan through the misc symbol vectors and add each
4326 symbol you find to the list. Eventually we want to ignore
4327 anything that isn't a text symbol (everything else will be
4328 handled by the psymtab code above). */
4330 if (code == TYPE_CODE_UNDEF)
4332 ALL_MSYMBOLS (objfile, msymbol)
4335 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
4338 completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text,
4343 /* Search upwards from currently selected frame (so that we can
4344 complete on local vars). Also catch fields of types defined in
4345 this places which match our text string. Only complete on types
4346 visible from current context. */
4348 b = get_selected_block (0);
4349 surrounding_static_block = block_static_block (b);
4350 surrounding_global_block = block_global_block (b);
4351 if (surrounding_static_block != NULL)
4352 while (b != surrounding_static_block)
4356 ALL_BLOCK_SYMBOLS (b, iter, sym)
4358 if (code == TYPE_CODE_UNDEF)
4360 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4362 completion_list_add_fields (sym, sym_text, sym_text_len, text,
4365 else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4366 && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
4367 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4371 /* Stop when we encounter an enclosing function. Do not stop for
4372 non-inlined functions - the locals of the enclosing function
4373 are in scope for a nested function. */
4374 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
4376 b = BLOCK_SUPERBLOCK (b);
4379 /* Add fields from the file's types; symbols will be added below. */
4381 if (code == TYPE_CODE_UNDEF)
4383 if (surrounding_static_block != NULL)
4384 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
4385 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4387 if (surrounding_global_block != NULL)
4388 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
4389 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4392 /* Go through the symtabs and check the externs and statics for
4393 symbols which match. */
4395 ALL_PRIMARY_SYMTABS (objfile, s)
4398 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4399 ALL_BLOCK_SYMBOLS (b, iter, sym)
4401 if (code == TYPE_CODE_UNDEF
4402 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4403 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4404 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4408 ALL_PRIMARY_SYMTABS (objfile, s)
4411 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4412 ALL_BLOCK_SYMBOLS (b, iter, sym)
4414 if (code == TYPE_CODE_UNDEF
4415 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4416 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4417 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4421 /* Skip macros if we are completing a struct tag -- arguable but
4422 usually what is expected. */
4423 if (current_language->la_macro_expansion == macro_expansion_c
4424 && code == TYPE_CODE_UNDEF)
4426 struct macro_scope *scope;
4428 /* Add any macros visible in the default scope. Note that this
4429 may yield the occasional wrong result, because an expression
4430 might be evaluated in a scope other than the default. For
4431 example, if the user types "break file:line if <TAB>", the
4432 resulting expression will be evaluated at "file:line" -- but
4433 at there does not seem to be a way to detect this at
4435 scope = default_macro_scope ();
4438 macro_for_each_in_scope (scope->file, scope->line,
4439 add_macro_name, &datum);
4443 /* User-defined macros are always visible. */
4444 macro_for_each (macro_user_macros, add_macro_name, &datum);
4447 discard_cleanups (back_to);
4448 return (return_val);
4452 default_make_symbol_completion_list (const char *text, const char *word,
4453 enum type_code code)
4455 return default_make_symbol_completion_list_break_on (text, word, "", code);
4458 /* Return a vector of all symbols (regardless of class) which begin by
4459 matching TEXT. If the answer is no symbols, then the return value
4463 make_symbol_completion_list (const char *text, const char *word)
4465 return current_language->la_make_symbol_completion_list (text, word,
4469 /* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4470 symbols whose type code is CODE. */
4473 make_symbol_completion_type (const char *text, const char *word,
4474 enum type_code code)
4476 gdb_assert (code == TYPE_CODE_UNION
4477 || code == TYPE_CODE_STRUCT
4478 || code == TYPE_CODE_CLASS
4479 || code == TYPE_CODE_ENUM);
4480 return current_language->la_make_symbol_completion_list (text, word, code);
4483 /* Like make_symbol_completion_list, but suitable for use as a
4484 completion function. */
4487 make_symbol_completion_list_fn (struct cmd_list_element *ignore,
4488 const char *text, const char *word)
4490 return make_symbol_completion_list (text, word);
4493 /* Like make_symbol_completion_list, but returns a list of symbols
4494 defined in a source file FILE. */
4497 make_file_symbol_completion_list (const char *text, const char *word,
4498 const char *srcfile)
4503 struct block_iterator iter;
4504 /* The symbol we are completing on. Points in same buffer as text. */
4505 const char *sym_text;
4506 /* Length of sym_text. */
4509 /* Now look for the symbol we are supposed to complete on.
4510 FIXME: This should be language-specific. */
4514 const char *quote_pos = NULL;
4516 /* First see if this is a quoted string. */
4518 for (p = text; *p != '\0'; ++p)
4520 if (quote_found != '\0')
4522 if (*p == quote_found)
4523 /* Found close quote. */
4525 else if (*p == '\\' && p[1] == quote_found)
4526 /* A backslash followed by the quote character
4527 doesn't end the string. */
4530 else if (*p == '\'' || *p == '"')
4536 if (quote_found == '\'')
4537 /* A string within single quotes can be a symbol, so complete on it. */
4538 sym_text = quote_pos + 1;
4539 else if (quote_found == '"')
4540 /* A double-quoted string is never a symbol, nor does it make sense
4541 to complete it any other way. */
4547 /* Not a quoted string. */
4548 sym_text = language_search_unquoted_string (text, p);
4552 sym_text_len = strlen (sym_text);
4556 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4558 s = lookup_symtab (srcfile);
4561 /* Maybe they typed the file with leading directories, while the
4562 symbol tables record only its basename. */
4563 const char *tail = lbasename (srcfile);
4566 s = lookup_symtab (tail);
4569 /* If we have no symtab for that file, return an empty list. */
4571 return (return_val);
4573 /* Go through this symtab and check the externs and statics for
4574 symbols which match. */
4576 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4577 ALL_BLOCK_SYMBOLS (b, iter, sym)
4579 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4582 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4583 ALL_BLOCK_SYMBOLS (b, iter, sym)
4585 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4588 return (return_val);
4591 /* A helper function for make_source_files_completion_list. It adds
4592 another file name to a list of possible completions, growing the
4593 list as necessary. */
4596 add_filename_to_list (const char *fname, const char *text, const char *word,
4597 VEC (char_ptr) **list)
4600 size_t fnlen = strlen (fname);
4604 /* Return exactly fname. */
4605 new = xmalloc (fnlen + 5);
4606 strcpy (new, fname);
4608 else if (word > text)
4610 /* Return some portion of fname. */
4611 new = xmalloc (fnlen + 5);
4612 strcpy (new, fname + (word - text));
4616 /* Return some of TEXT plus fname. */
4617 new = xmalloc (fnlen + (text - word) + 5);
4618 strncpy (new, word, text - word);
4619 new[text - word] = '\0';
4620 strcat (new, fname);
4622 VEC_safe_push (char_ptr, *list, new);
4626 not_interesting_fname (const char *fname)
4628 static const char *illegal_aliens[] = {
4629 "_globals_", /* inserted by coff_symtab_read */
4634 for (i = 0; illegal_aliens[i]; i++)
4636 if (filename_cmp (fname, illegal_aliens[i]) == 0)
4642 /* An object of this type is passed as the user_data argument to
4643 map_partial_symbol_filenames. */
4644 struct add_partial_filename_data
4646 struct filename_seen_cache *filename_seen_cache;
4650 VEC (char_ptr) **list;
4653 /* A callback for map_partial_symbol_filenames. */
4656 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
4659 struct add_partial_filename_data *data = user_data;
4661 if (not_interesting_fname (filename))
4663 if (!filename_seen (data->filename_seen_cache, filename, 1)
4664 && filename_ncmp (filename, data->text, data->text_len) == 0)
4666 /* This file matches for a completion; add it to the
4667 current list of matches. */
4668 add_filename_to_list (filename, data->text, data->word, data->list);
4672 const char *base_name = lbasename (filename);
4674 if (base_name != filename
4675 && !filename_seen (data->filename_seen_cache, base_name, 1)
4676 && filename_ncmp (base_name, data->text, data->text_len) == 0)
4677 add_filename_to_list (base_name, data->text, data->word, data->list);
4681 /* Return a vector of all source files whose names begin with matching
4682 TEXT. The file names are looked up in the symbol tables of this
4683 program. If the answer is no matchess, then the return value is
4687 make_source_files_completion_list (const char *text, const char *word)
4690 struct objfile *objfile;
4691 size_t text_len = strlen (text);
4692 VEC (char_ptr) *list = NULL;
4693 const char *base_name;
4694 struct add_partial_filename_data datum;
4695 struct filename_seen_cache *filename_seen_cache;
4696 struct cleanup *back_to, *cache_cleanup;
4698 if (!have_full_symbols () && !have_partial_symbols ())
4701 back_to = make_cleanup (do_free_completion_list, &list);
4703 filename_seen_cache = create_filename_seen_cache ();
4704 cache_cleanup = make_cleanup (delete_filename_seen_cache,
4705 filename_seen_cache);
4707 ALL_SYMTABS (objfile, s)
4709 if (not_interesting_fname (s->filename))
4711 if (!filename_seen (filename_seen_cache, s->filename, 1)
4712 && filename_ncmp (s->filename, text, text_len) == 0)
4714 /* This file matches for a completion; add it to the current
4716 add_filename_to_list (s->filename, text, word, &list);
4720 /* NOTE: We allow the user to type a base name when the
4721 debug info records leading directories, but not the other
4722 way around. This is what subroutines of breakpoint
4723 command do when they parse file names. */
4724 base_name = lbasename (s->filename);
4725 if (base_name != s->filename
4726 && !filename_seen (filename_seen_cache, base_name, 1)
4727 && filename_ncmp (base_name, text, text_len) == 0)
4728 add_filename_to_list (base_name, text, word, &list);
4732 datum.filename_seen_cache = filename_seen_cache;
4735 datum.text_len = text_len;
4737 map_partial_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
4738 0 /*need_fullname*/);
4740 do_cleanups (cache_cleanup);
4741 discard_cleanups (back_to);
4746 /* Determine if PC is in the prologue of a function. The prologue is the area
4747 between the first instruction of a function, and the first executable line.
4748 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4750 If non-zero, func_start is where we think the prologue starts, possibly
4751 by previous examination of symbol table information. */
4754 in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
4756 struct symtab_and_line sal;
4757 CORE_ADDR func_addr, func_end;
4759 /* We have several sources of information we can consult to figure
4761 - Compilers usually emit line number info that marks the prologue
4762 as its own "source line". So the ending address of that "line"
4763 is the end of the prologue. If available, this is the most
4765 - The minimal symbols and partial symbols, which can usually tell
4766 us the starting and ending addresses of a function.
4767 - If we know the function's start address, we can call the
4768 architecture-defined gdbarch_skip_prologue function to analyze the
4769 instruction stream and guess where the prologue ends.
4770 - Our `func_start' argument; if non-zero, this is the caller's
4771 best guess as to the function's entry point. At the time of
4772 this writing, handle_inferior_event doesn't get this right, so
4773 it should be our last resort. */
4775 /* Consult the partial symbol table, to find which function
4777 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4779 CORE_ADDR prologue_end;
4781 /* We don't even have minsym information, so fall back to using
4782 func_start, if given. */
4784 return 1; /* We *might* be in a prologue. */
4786 prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
4788 return func_start <= pc && pc < prologue_end;
4791 /* If we have line number information for the function, that's
4792 usually pretty reliable. */
4793 sal = find_pc_line (func_addr, 0);
4795 /* Now sal describes the source line at the function's entry point,
4796 which (by convention) is the prologue. The end of that "line",
4797 sal.end, is the end of the prologue.
4799 Note that, for functions whose source code is all on a single
4800 line, the line number information doesn't always end up this way.
4801 So we must verify that our purported end-of-prologue address is
4802 *within* the function, not at its start or end. */
4804 || sal.end <= func_addr
4805 || func_end <= sal.end)
4807 /* We don't have any good line number info, so use the minsym
4808 information, together with the architecture-specific prologue
4810 CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
4812 return func_addr <= pc && pc < prologue_end;
4815 /* We have line number info, and it looks good. */
4816 return func_addr <= pc && pc < sal.end;
4819 /* Given PC at the function's start address, attempt to find the
4820 prologue end using SAL information. Return zero if the skip fails.
4822 A non-optimized prologue traditionally has one SAL for the function
4823 and a second for the function body. A single line function has
4824 them both pointing at the same line.
4826 An optimized prologue is similar but the prologue may contain
4827 instructions (SALs) from the instruction body. Need to skip those
4828 while not getting into the function body.
4830 The functions end point and an increasing SAL line are used as
4831 indicators of the prologue's endpoint.
4833 This code is based on the function refine_prologue_limit
4837 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
4839 struct symtab_and_line prologue_sal;
4844 /* Get an initial range for the function. */
4845 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
4846 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
4848 prologue_sal = find_pc_line (start_pc, 0);
4849 if (prologue_sal.line != 0)
4851 /* For languages other than assembly, treat two consecutive line
4852 entries at the same address as a zero-instruction prologue.
4853 The GNU assembler emits separate line notes for each instruction
4854 in a multi-instruction macro, but compilers generally will not
4856 if (prologue_sal.symtab->language != language_asm)
4858 struct linetable *linetable = LINETABLE (prologue_sal.symtab);
4861 /* Skip any earlier lines, and any end-of-sequence marker
4862 from a previous function. */
4863 while (linetable->item[idx].pc != prologue_sal.pc
4864 || linetable->item[idx].line == 0)
4867 if (idx+1 < linetable->nitems
4868 && linetable->item[idx+1].line != 0
4869 && linetable->item[idx+1].pc == start_pc)
4873 /* If there is only one sal that covers the entire function,
4874 then it is probably a single line function, like
4876 if (prologue_sal.end >= end_pc)
4879 while (prologue_sal.end < end_pc)
4881 struct symtab_and_line sal;
4883 sal = find_pc_line (prologue_sal.end, 0);
4886 /* Assume that a consecutive SAL for the same (or larger)
4887 line mark the prologue -> body transition. */
4888 if (sal.line >= prologue_sal.line)
4890 /* Likewise if we are in a different symtab altogether
4891 (e.g. within a file included via #include). */
4892 if (sal.symtab != prologue_sal.symtab)
4895 /* The line number is smaller. Check that it's from the
4896 same function, not something inlined. If it's inlined,
4897 then there is no point comparing the line numbers. */
4898 bl = block_for_pc (prologue_sal.end);
4901 if (block_inlined_p (bl))
4903 if (BLOCK_FUNCTION (bl))
4908 bl = BLOCK_SUPERBLOCK (bl);
4913 /* The case in which compiler's optimizer/scheduler has
4914 moved instructions into the prologue. We look ahead in
4915 the function looking for address ranges whose
4916 corresponding line number is less the first one that we
4917 found for the function. This is more conservative then
4918 refine_prologue_limit which scans a large number of SALs
4919 looking for any in the prologue. */
4924 if (prologue_sal.end < end_pc)
4925 /* Return the end of this line, or zero if we could not find a
4927 return prologue_sal.end;
4929 /* Don't return END_PC, which is past the end of the function. */
4930 return prologue_sal.pc;
4934 static char *name_of_main;
4935 enum language language_of_main = language_unknown;
4938 set_main_name (const char *name)
4940 if (name_of_main != NULL)
4942 xfree (name_of_main);
4943 name_of_main = NULL;
4944 language_of_main = language_unknown;
4948 name_of_main = xstrdup (name);
4949 language_of_main = language_unknown;
4953 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4957 find_main_name (void)
4959 const char *new_main_name;
4961 /* Try to see if the main procedure is in Ada. */
4962 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4963 be to add a new method in the language vector, and call this
4964 method for each language until one of them returns a non-empty
4965 name. This would allow us to remove this hard-coded call to
4966 an Ada function. It is not clear that this is a better approach
4967 at this point, because all methods need to be written in a way
4968 such that false positives never be returned. For instance, it is
4969 important that a method does not return a wrong name for the main
4970 procedure if the main procedure is actually written in a different
4971 language. It is easy to guaranty this with Ada, since we use a
4972 special symbol generated only when the main in Ada to find the name
4973 of the main procedure. It is difficult however to see how this can
4974 be guarantied for languages such as C, for instance. This suggests
4975 that order of call for these methods becomes important, which means
4976 a more complicated approach. */
4977 new_main_name = ada_main_name ();
4978 if (new_main_name != NULL)
4980 set_main_name (new_main_name);
4984 new_main_name = go_main_name ();
4985 if (new_main_name != NULL)
4987 set_main_name (new_main_name);
4991 new_main_name = pascal_main_name ();
4992 if (new_main_name != NULL)
4994 set_main_name (new_main_name);
4998 /* The languages above didn't identify the name of the main procedure.
4999 Fallback to "main". */
5000 set_main_name ("main");
5006 if (name_of_main == NULL)
5009 return name_of_main;
5012 /* Handle ``executable_changed'' events for the symtab module. */
5015 symtab_observer_executable_changed (void)
5017 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5018 set_main_name (NULL);
5021 /* Return 1 if the supplied producer string matches the ARM RealView
5022 compiler (armcc). */
5025 producer_is_realview (const char *producer)
5027 static const char *const arm_idents[] = {
5028 "ARM C Compiler, ADS",
5029 "Thumb C Compiler, ADS",
5030 "ARM C++ Compiler, ADS",
5031 "Thumb C++ Compiler, ADS",
5032 "ARM/Thumb C/C++ Compiler, RVCT",
5033 "ARM C/C++ Compiler, RVCT"
5037 if (producer == NULL)
5040 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5041 if (strncmp (producer, arm_idents[i], strlen (arm_idents[i])) == 0)
5049 /* The next index to hand out in response to a registration request. */
5051 static int next_aclass_value = LOC_FINAL_VALUE;
5053 /* The maximum number of "aclass" registrations we support. This is
5054 constant for convenience. */
5055 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5057 /* The objects representing the various "aclass" values. The elements
5058 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5059 elements are those registered at gdb initialization time. */
5061 static struct symbol_impl symbol_impl[MAX_SYMBOL_IMPLS];
5063 /* The globally visible pointer. This is separate from 'symbol_impl'
5064 so that it can be const. */
5066 const struct symbol_impl *symbol_impls = &symbol_impl[0];
5068 /* Make sure we saved enough room in struct symbol. */
5070 gdb_static_assert (MAX_SYMBOL_IMPLS <= (1 << SYMBOL_ACLASS_BITS));
5072 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5073 is the ops vector associated with this index. This returns the new
5074 index, which should be used as the aclass_index field for symbols
5078 register_symbol_computed_impl (enum address_class aclass,
5079 const struct symbol_computed_ops *ops)
5081 int result = next_aclass_value++;
5083 gdb_assert (aclass == LOC_COMPUTED);
5084 gdb_assert (result < MAX_SYMBOL_IMPLS);
5085 symbol_impl[result].aclass = aclass;
5086 symbol_impl[result].ops_computed = ops;
5088 /* Sanity check OPS. */
5089 gdb_assert (ops != NULL);
5090 gdb_assert (ops->tracepoint_var_ref != NULL);
5091 gdb_assert (ops->describe_location != NULL);
5092 gdb_assert (ops->read_needs_frame != NULL);
5093 gdb_assert (ops->read_variable != NULL);
5098 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5099 OPS is the ops vector associated with this index. This returns the
5100 new index, which should be used as the aclass_index field for symbols
5104 register_symbol_block_impl (enum address_class aclass,
5105 const struct symbol_block_ops *ops)
5107 int result = next_aclass_value++;
5109 gdb_assert (aclass == LOC_BLOCK);
5110 gdb_assert (result < MAX_SYMBOL_IMPLS);
5111 symbol_impl[result].aclass = aclass;
5112 symbol_impl[result].ops_block = ops;
5114 /* Sanity check OPS. */
5115 gdb_assert (ops != NULL);
5116 gdb_assert (ops->find_frame_base_location != NULL);
5121 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5122 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5123 this index. This returns the new index, which should be used as
5124 the aclass_index field for symbols of this type. */
5127 register_symbol_register_impl (enum address_class aclass,
5128 const struct symbol_register_ops *ops)
5130 int result = next_aclass_value++;
5132 gdb_assert (aclass == LOC_REGISTER || aclass == LOC_REGPARM_ADDR);
5133 gdb_assert (result < MAX_SYMBOL_IMPLS);
5134 symbol_impl[result].aclass = aclass;
5135 symbol_impl[result].ops_register = ops;
5140 /* Initialize elements of 'symbol_impl' for the constants in enum
5144 initialize_ordinary_address_classes (void)
5148 for (i = 0; i < LOC_FINAL_VALUE; ++i)
5149 symbol_impl[i].aclass = i;
5154 /* Initialize the symbol SYM. */
5157 initialize_symbol (struct symbol *sym)
5159 memset (sym, 0, sizeof (*sym));
5160 SYMBOL_SECTION (sym) = -1;
5163 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5167 allocate_symbol (struct objfile *objfile)
5169 struct symbol *result;
5171 result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
5172 SYMBOL_SECTION (result) = -1;
5177 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5180 struct template_symbol *
5181 allocate_template_symbol (struct objfile *objfile)
5183 struct template_symbol *result;
5185 result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
5186 SYMBOL_SECTION (&result->base) = -1;
5194 _initialize_symtab (void)
5196 initialize_ordinary_address_classes ();
5198 add_info ("variables", variables_info, _("\
5199 All global and static variable names, or those matching REGEXP."));
5201 add_com ("whereis", class_info, variables_info, _("\
5202 All global and static variable names, or those matching REGEXP."));
5204 add_info ("functions", functions_info,
5205 _("All function names, or those matching REGEXP."));
5207 /* FIXME: This command has at least the following problems:
5208 1. It prints builtin types (in a very strange and confusing fashion).
5209 2. It doesn't print right, e.g. with
5210 typedef struct foo *FOO
5211 type_print prints "FOO" when we want to make it (in this situation)
5212 print "struct foo *".
5213 I also think "ptype" or "whatis" is more likely to be useful (but if
5214 there is much disagreement "info types" can be fixed). */
5215 add_info ("types", types_info,
5216 _("All type names, or those matching REGEXP."));
5218 add_info ("sources", sources_info,
5219 _("Source files in the program."));
5221 add_com ("rbreak", class_breakpoint, rbreak_command,
5222 _("Set a breakpoint for all functions matching REGEXP."));
5226 add_com ("lf", class_info, sources_info,
5227 _("Source files in the program"));
5228 add_com ("lg", class_info, variables_info, _("\
5229 All global and static variable names, or those matching REGEXP."));
5232 add_setshow_enum_cmd ("multiple-symbols", no_class,
5233 multiple_symbols_modes, &multiple_symbols_mode,
5235 Set the debugger behavior when more than one symbol are possible matches\n\
5236 in an expression."), _("\
5237 Show how the debugger handles ambiguities in expressions."), _("\
5238 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5239 NULL, NULL, &setlist, &showlist);
5241 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5242 &basenames_may_differ, _("\
5243 Set whether a source file may have multiple base names."), _("\
5244 Show whether a source file may have multiple base names."), _("\
5245 (A \"base name\" is the name of a file with the directory part removed.\n\
5246 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5247 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5248 before comparing them. Canonicalization is an expensive operation,\n\
5249 but it allows the same file be known by more than one base name.\n\
5250 If not set (the default), all source files are assumed to have just\n\
5251 one base name, and gdb will do file name comparisons more efficiently."),
5253 &setlist, &showlist);
5255 add_setshow_boolean_cmd ("symtab-create", no_class, &symtab_create_debug,
5256 _("Set debugging of symbol table creation."),
5257 _("Show debugging of symbol table creation."), _("\
5258 When enabled, debugging messages are printed when building symbol tables."),
5261 &setdebuglist, &showdebuglist);
5263 observer_attach_executable_changed (symtab_observer_executable_changed);