1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2004, 2007-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdb_regex.h"
31 #include "expression.h"
36 #include "filenames.h" /* for FILENAME_CMP */
37 #include "objc-lang.h"
46 #include "gdb_obstack.h"
48 #include "dictionary.h"
50 #include <sys/types.h>
52 #include "gdb_string.h"
56 #include "cp-support.h"
58 #include "gdb_assert.h"
61 #include "macroscope.h"
64 #include "parser-defs.h"
66 /* Prototypes for local functions */
68 static void rbreak_command (char *, int);
70 static void types_info (char *, int);
72 static void functions_info (char *, int);
74 static void variables_info (char *, int);
76 static void sources_info (char *, int);
78 static int find_line_common (struct linetable *, int, int *, int);
80 static struct symbol *lookup_symbol_aux (const char *name,
81 const struct block *block,
82 const domain_enum domain,
83 enum language language,
84 struct field_of_this_result *is_a_field_of_this);
87 struct symbol *lookup_symbol_aux_local (const char *name,
88 const struct block *block,
89 const domain_enum domain,
90 enum language language);
93 struct symbol *lookup_symbol_aux_symtabs (int block_index,
95 const domain_enum domain);
98 struct symbol *lookup_symbol_aux_quick (struct objfile *objfile,
101 const domain_enum domain);
103 static void print_msymbol_info (struct minimal_symbol *);
105 void _initialize_symtab (void);
109 /* When non-zero, print debugging messages related to symtab creation. */
110 int symtab_create_debug = 0;
112 /* Non-zero if a file may be known by two different basenames.
113 This is the uncommon case, and significantly slows down gdb.
114 Default set to "off" to not slow down the common case. */
115 int basenames_may_differ = 0;
117 /* Allow the user to configure the debugger behavior with respect
118 to multiple-choice menus when more than one symbol matches during
121 const char multiple_symbols_ask[] = "ask";
122 const char multiple_symbols_all[] = "all";
123 const char multiple_symbols_cancel[] = "cancel";
124 static const char *const multiple_symbols_modes[] =
126 multiple_symbols_ask,
127 multiple_symbols_all,
128 multiple_symbols_cancel,
131 static const char *multiple_symbols_mode = multiple_symbols_all;
133 /* Read-only accessor to AUTO_SELECT_MODE. */
136 multiple_symbols_select_mode (void)
138 return multiple_symbols_mode;
141 /* Block in which the most recently searched-for symbol was found.
142 Might be better to make this a parameter to lookup_symbol and
145 const struct block *block_found;
147 /* See whether FILENAME matches SEARCH_NAME using the rule that we
148 advertise to the user. (The manual's description of linespecs
149 describes what we advertise). We assume that SEARCH_NAME is
150 a relative path. Returns true if they match, false otherwise. */
153 compare_filenames_for_search (const char *filename, const char *search_name)
155 int len = strlen (filename);
156 size_t search_len = strlen (search_name);
158 if (len < search_len)
161 /* The tail of FILENAME must match. */
162 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
165 /* Either the names must completely match, or the character
166 preceding the trailing SEARCH_NAME segment of FILENAME must be a
167 directory separator. */
168 return (len == search_len
169 || IS_DIR_SEPARATOR (filename[len - search_len - 1])
170 || (HAS_DRIVE_SPEC (filename)
171 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
174 /* Check for a symtab of a specific name by searching some symtabs.
175 This is a helper function for callbacks of iterate_over_symtabs.
177 The return value, NAME, FULL_PATH, REAL_PATH, CALLBACK, and DATA
178 are identical to the `map_symtabs_matching_filename' method of
179 quick_symbol_functions.
181 FIRST and AFTER_LAST indicate the range of symtabs to search.
182 AFTER_LAST is one past the last symtab to search; NULL means to
183 search until the end of the list. */
186 iterate_over_some_symtabs (const char *name,
187 const char *full_path,
188 const char *real_path,
189 int (*callback) (struct symtab *symtab,
192 struct symtab *first,
193 struct symtab *after_last)
195 struct symtab *s = NULL;
196 const char* base_name = lbasename (name);
197 int is_abs = IS_ABSOLUTE_PATH (name);
199 for (s = first; s != NULL && s != after_last; s = s->next)
201 /* Exact match is always ok. */
202 if (FILENAME_CMP (name, s->filename) == 0)
204 if (callback (s, data))
208 if (!is_abs && compare_filenames_for_search (s->filename, name))
210 if (callback (s, data))
214 /* Before we invoke realpath, which can get expensive when many
215 files are involved, do a quick comparison of the basenames. */
216 if (! basenames_may_differ
217 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
220 /* If the user gave us an absolute path, try to find the file in
221 this symtab and use its absolute path. */
223 if (full_path != NULL)
225 const char *fp = symtab_to_fullname (s);
227 if (fp != NULL && FILENAME_CMP (full_path, fp) == 0)
229 if (callback (s, data))
233 if (fp != NULL && !is_abs && compare_filenames_for_search (fp, name))
235 if (callback (s, data))
240 if (real_path != NULL)
242 const char *fullname = symtab_to_fullname (s);
244 if (fullname != NULL)
246 char *rp = gdb_realpath (fullname);
248 make_cleanup (xfree, rp);
249 if (FILENAME_CMP (real_path, rp) == 0)
251 if (callback (s, data))
255 if (!is_abs && compare_filenames_for_search (rp, name))
257 if (callback (s, data))
267 /* Check for a symtab of a specific name; first in symtabs, then in
268 psymtabs. *If* there is no '/' in the name, a match after a '/'
269 in the symtab filename will also work.
271 Calls CALLBACK with each symtab that is found and with the supplied
272 DATA. If CALLBACK returns true, the search stops. */
275 iterate_over_symtabs (const char *name,
276 int (*callback) (struct symtab *symtab,
280 struct symtab *s = NULL;
281 struct objfile *objfile;
282 char *real_path = NULL;
283 char *full_path = NULL;
284 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
286 /* Here we are interested in canonicalizing an absolute path, not
287 absolutizing a relative path. */
288 if (IS_ABSOLUTE_PATH (name))
290 full_path = xfullpath (name);
291 make_cleanup (xfree, full_path);
292 real_path = gdb_realpath (name);
293 make_cleanup (xfree, real_path);
296 ALL_OBJFILES (objfile)
298 if (iterate_over_some_symtabs (name, full_path, real_path, callback, data,
299 objfile->symtabs, NULL))
301 do_cleanups (cleanups);
306 /* Same search rules as above apply here, but now we look thru the
309 ALL_OBJFILES (objfile)
312 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
319 do_cleanups (cleanups);
324 do_cleanups (cleanups);
327 /* The callback function used by lookup_symtab. */
330 lookup_symtab_callback (struct symtab *symtab, void *data)
332 struct symtab **result_ptr = data;
334 *result_ptr = symtab;
338 /* A wrapper for iterate_over_symtabs that returns the first matching
342 lookup_symtab (const char *name)
344 struct symtab *result = NULL;
346 iterate_over_symtabs (name, lookup_symtab_callback, &result);
351 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
352 full method name, which consist of the class name (from T), the unadorned
353 method name from METHOD_ID, and the signature for the specific overload,
354 specified by SIGNATURE_ID. Note that this function is g++ specific. */
357 gdb_mangle_name (struct type *type, int method_id, int signature_id)
359 int mangled_name_len;
361 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
362 struct fn_field *method = &f[signature_id];
363 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
364 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
365 const char *newname = type_name_no_tag (type);
367 /* Does the form of physname indicate that it is the full mangled name
368 of a constructor (not just the args)? */
369 int is_full_physname_constructor;
372 int is_destructor = is_destructor_name (physname);
373 /* Need a new type prefix. */
374 char *const_prefix = method->is_const ? "C" : "";
375 char *volatile_prefix = method->is_volatile ? "V" : "";
377 int len = (newname == NULL ? 0 : strlen (newname));
379 /* Nothing to do if physname already contains a fully mangled v3 abi name
380 or an operator name. */
381 if ((physname[0] == '_' && physname[1] == 'Z')
382 || is_operator_name (field_name))
383 return xstrdup (physname);
385 is_full_physname_constructor = is_constructor_name (physname);
387 is_constructor = is_full_physname_constructor
388 || (newname && strcmp (field_name, newname) == 0);
391 is_destructor = (strncmp (physname, "__dt", 4) == 0);
393 if (is_destructor || is_full_physname_constructor)
395 mangled_name = (char *) xmalloc (strlen (physname) + 1);
396 strcpy (mangled_name, physname);
402 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
404 else if (physname[0] == 't' || physname[0] == 'Q')
406 /* The physname for template and qualified methods already includes
408 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
414 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
415 volatile_prefix, len);
417 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
418 + strlen (buf) + len + strlen (physname) + 1);
420 mangled_name = (char *) xmalloc (mangled_name_len);
422 mangled_name[0] = '\0';
424 strcpy (mangled_name, field_name);
426 strcat (mangled_name, buf);
427 /* If the class doesn't have a name, i.e. newname NULL, then we just
428 mangle it using 0 for the length of the class. Thus it gets mangled
429 as something starting with `::' rather than `classname::'. */
431 strcat (mangled_name, newname);
433 strcat (mangled_name, physname);
434 return (mangled_name);
437 /* Initialize the cplus_specific structure. 'cplus_specific' should
438 only be allocated for use with cplus symbols. */
441 symbol_init_cplus_specific (struct general_symbol_info *gsymbol,
442 struct objfile *objfile)
444 /* A language_specific structure should not have been previously
446 gdb_assert (gsymbol->language_specific.cplus_specific == NULL);
447 gdb_assert (objfile != NULL);
449 gsymbol->language_specific.cplus_specific =
450 OBSTACK_ZALLOC (&objfile->objfile_obstack, struct cplus_specific);
453 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
454 correctly allocated. For C++ symbols a cplus_specific struct is
455 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
456 OBJFILE can be NULL. */
459 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
461 struct objfile *objfile)
463 if (gsymbol->language == language_cplus)
465 if (gsymbol->language_specific.cplus_specific == NULL)
466 symbol_init_cplus_specific (gsymbol, objfile);
468 gsymbol->language_specific.cplus_specific->demangled_name = name;
471 gsymbol->language_specific.mangled_lang.demangled_name = name;
474 /* Return the demangled name of GSYMBOL. */
477 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
479 if (gsymbol->language == language_cplus)
481 if (gsymbol->language_specific.cplus_specific != NULL)
482 return gsymbol->language_specific.cplus_specific->demangled_name;
487 return gsymbol->language_specific.mangled_lang.demangled_name;
491 /* Initialize the language dependent portion of a symbol
492 depending upon the language for the symbol. */
495 symbol_set_language (struct general_symbol_info *gsymbol,
496 enum language language)
498 gsymbol->language = language;
499 if (gsymbol->language == language_d
500 || gsymbol->language == language_go
501 || gsymbol->language == language_java
502 || gsymbol->language == language_objc
503 || gsymbol->language == language_fortran)
505 symbol_set_demangled_name (gsymbol, NULL, NULL);
507 else if (gsymbol->language == language_cplus)
508 gsymbol->language_specific.cplus_specific = NULL;
511 memset (&gsymbol->language_specific, 0,
512 sizeof (gsymbol->language_specific));
516 /* Functions to initialize a symbol's mangled name. */
518 /* Objects of this type are stored in the demangled name hash table. */
519 struct demangled_name_entry
525 /* Hash function for the demangled name hash. */
528 hash_demangled_name_entry (const void *data)
530 const struct demangled_name_entry *e = data;
532 return htab_hash_string (e->mangled);
535 /* Equality function for the demangled name hash. */
538 eq_demangled_name_entry (const void *a, const void *b)
540 const struct demangled_name_entry *da = a;
541 const struct demangled_name_entry *db = b;
543 return strcmp (da->mangled, db->mangled) == 0;
546 /* Create the hash table used for demangled names. Each hash entry is
547 a pair of strings; one for the mangled name and one for the demangled
548 name. The entry is hashed via just the mangled name. */
551 create_demangled_names_hash (struct objfile *objfile)
553 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
554 The hash table code will round this up to the next prime number.
555 Choosing a much larger table size wastes memory, and saves only about
556 1% in symbol reading. */
558 objfile->demangled_names_hash = htab_create_alloc
559 (256, hash_demangled_name_entry, eq_demangled_name_entry,
560 NULL, xcalloc, xfree);
563 /* Try to determine the demangled name for a symbol, based on the
564 language of that symbol. If the language is set to language_auto,
565 it will attempt to find any demangling algorithm that works and
566 then set the language appropriately. The returned name is allocated
567 by the demangler and should be xfree'd. */
570 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
573 char *demangled = NULL;
575 if (gsymbol->language == language_unknown)
576 gsymbol->language = language_auto;
578 if (gsymbol->language == language_objc
579 || gsymbol->language == language_auto)
582 objc_demangle (mangled, 0);
583 if (demangled != NULL)
585 gsymbol->language = language_objc;
589 if (gsymbol->language == language_cplus
590 || gsymbol->language == language_auto)
593 cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
594 if (demangled != NULL)
596 gsymbol->language = language_cplus;
600 if (gsymbol->language == language_java)
603 cplus_demangle (mangled,
604 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
605 if (demangled != NULL)
607 gsymbol->language = language_java;
611 if (gsymbol->language == language_d
612 || gsymbol->language == language_auto)
614 demangled = d_demangle(mangled, 0);
615 if (demangled != NULL)
617 gsymbol->language = language_d;
621 /* FIXME(dje): Continually adding languages here is clumsy.
622 Better to just call la_demangle if !auto, and if auto then call
623 a utility routine that tries successive languages in turn and reports
624 which one it finds. I realize the la_demangle options may be different
625 for different languages but there's already a FIXME for that. */
626 if (gsymbol->language == language_go
627 || gsymbol->language == language_auto)
629 demangled = go_demangle (mangled, 0);
630 if (demangled != NULL)
632 gsymbol->language = language_go;
637 /* We could support `gsymbol->language == language_fortran' here to provide
638 module namespaces also for inferiors with only minimal symbol table (ELF
639 symbols). Just the mangling standard is not standardized across compilers
640 and there is no DW_AT_producer available for inferiors with only the ELF
641 symbols to check the mangling kind. */
645 /* Set both the mangled and demangled (if any) names for GSYMBOL based
646 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
647 objfile's obstack; but if COPY_NAME is 0 and if NAME is
648 NUL-terminated, then this function assumes that NAME is already
649 correctly saved (either permanently or with a lifetime tied to the
650 objfile), and it will not be copied.
652 The hash table corresponding to OBJFILE is used, and the memory
653 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
654 so the pointer can be discarded after calling this function. */
656 /* We have to be careful when dealing with Java names: when we run
657 into a Java minimal symbol, we don't know it's a Java symbol, so it
658 gets demangled as a C++ name. This is unfortunate, but there's not
659 much we can do about it: but when demangling partial symbols and
660 regular symbols, we'd better not reuse the wrong demangled name.
661 (See PR gdb/1039.) We solve this by putting a distinctive prefix
662 on Java names when storing them in the hash table. */
664 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
665 don't mind the Java prefix so much: different languages have
666 different demangling requirements, so it's only natural that we
667 need to keep language data around in our demangling cache. But
668 it's not good that the minimal symbol has the wrong demangled name.
669 Unfortunately, I can't think of any easy solution to that
672 #define JAVA_PREFIX "##JAVA$$"
673 #define JAVA_PREFIX_LEN 8
676 symbol_set_names (struct general_symbol_info *gsymbol,
677 const char *linkage_name, int len, int copy_name,
678 struct objfile *objfile)
680 struct demangled_name_entry **slot;
681 /* A 0-terminated copy of the linkage name. */
682 const char *linkage_name_copy;
683 /* A copy of the linkage name that might have a special Java prefix
684 added to it, for use when looking names up in the hash table. */
685 const char *lookup_name;
686 /* The length of lookup_name. */
688 struct demangled_name_entry entry;
690 if (gsymbol->language == language_ada)
692 /* In Ada, we do the symbol lookups using the mangled name, so
693 we can save some space by not storing the demangled name.
695 As a side note, we have also observed some overlap between
696 the C++ mangling and Ada mangling, similarly to what has
697 been observed with Java. Because we don't store the demangled
698 name with the symbol, we don't need to use the same trick
701 gsymbol->name = linkage_name;
704 char *name = obstack_alloc (&objfile->objfile_obstack, len + 1);
706 memcpy (name, linkage_name, len);
708 gsymbol->name = name;
710 symbol_set_demangled_name (gsymbol, NULL, NULL);
715 if (objfile->demangled_names_hash == NULL)
716 create_demangled_names_hash (objfile);
718 /* The stabs reader generally provides names that are not
719 NUL-terminated; most of the other readers don't do this, so we
720 can just use the given copy, unless we're in the Java case. */
721 if (gsymbol->language == language_java)
725 lookup_len = len + JAVA_PREFIX_LEN;
726 alloc_name = alloca (lookup_len + 1);
727 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
728 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
729 alloc_name[lookup_len] = '\0';
731 lookup_name = alloc_name;
732 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
734 else if (linkage_name[len] != '\0')
739 alloc_name = alloca (lookup_len + 1);
740 memcpy (alloc_name, linkage_name, len);
741 alloc_name[lookup_len] = '\0';
743 lookup_name = alloc_name;
744 linkage_name_copy = alloc_name;
749 lookup_name = linkage_name;
750 linkage_name_copy = linkage_name;
753 entry.mangled = (char *) lookup_name;
754 slot = ((struct demangled_name_entry **)
755 htab_find_slot (objfile->demangled_names_hash,
758 /* If this name is not in the hash table, add it. */
760 /* A C version of the symbol may have already snuck into the table.
761 This happens to, e.g., main.init (__go_init_main). Cope. */
762 || (gsymbol->language == language_go
763 && (*slot)->demangled[0] == '\0'))
765 char *demangled_name = symbol_find_demangled_name (gsymbol,
767 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
769 /* Suppose we have demangled_name==NULL, copy_name==0, and
770 lookup_name==linkage_name. In this case, we already have the
771 mangled name saved, and we don't have a demangled name. So,
772 you might think we could save a little space by not recording
773 this in the hash table at all.
775 It turns out that it is actually important to still save such
776 an entry in the hash table, because storing this name gives
777 us better bcache hit rates for partial symbols. */
778 if (!copy_name && lookup_name == linkage_name)
780 *slot = obstack_alloc (&objfile->objfile_obstack,
781 offsetof (struct demangled_name_entry,
783 + demangled_len + 1);
784 (*slot)->mangled = (char *) lookup_name;
788 /* If we must copy the mangled name, put it directly after
789 the demangled name so we can have a single
791 *slot = obstack_alloc (&objfile->objfile_obstack,
792 offsetof (struct demangled_name_entry,
794 + lookup_len + demangled_len + 2);
795 (*slot)->mangled = &((*slot)->demangled[demangled_len + 1]);
796 strcpy ((*slot)->mangled, lookup_name);
799 if (demangled_name != NULL)
801 strcpy ((*slot)->demangled, demangled_name);
802 xfree (demangled_name);
805 (*slot)->demangled[0] = '\0';
808 gsymbol->name = (*slot)->mangled + lookup_len - len;
809 if ((*slot)->demangled[0] != '\0')
810 symbol_set_demangled_name (gsymbol, (*slot)->demangled, objfile);
812 symbol_set_demangled_name (gsymbol, NULL, objfile);
815 /* Return the source code name of a symbol. In languages where
816 demangling is necessary, this is the demangled name. */
819 symbol_natural_name (const struct general_symbol_info *gsymbol)
821 switch (gsymbol->language)
828 case language_fortran:
829 if (symbol_get_demangled_name (gsymbol) != NULL)
830 return symbol_get_demangled_name (gsymbol);
833 if (symbol_get_demangled_name (gsymbol) != NULL)
834 return symbol_get_demangled_name (gsymbol);
836 return ada_decode_symbol (gsymbol);
841 return gsymbol->name;
844 /* Return the demangled name for a symbol based on the language for
845 that symbol. If no demangled name exists, return NULL. */
848 symbol_demangled_name (const struct general_symbol_info *gsymbol)
850 const char *dem_name = NULL;
852 switch (gsymbol->language)
859 case language_fortran:
860 dem_name = symbol_get_demangled_name (gsymbol);
863 dem_name = symbol_get_demangled_name (gsymbol);
864 if (dem_name == NULL)
865 dem_name = ada_decode_symbol (gsymbol);
873 /* Return the search name of a symbol---generally the demangled or
874 linkage name of the symbol, depending on how it will be searched for.
875 If there is no distinct demangled name, then returns the same value
876 (same pointer) as SYMBOL_LINKAGE_NAME. */
879 symbol_search_name (const struct general_symbol_info *gsymbol)
881 if (gsymbol->language == language_ada)
882 return gsymbol->name;
884 return symbol_natural_name (gsymbol);
887 /* Initialize the structure fields to zero values. */
890 init_sal (struct symtab_and_line *sal)
898 sal->explicit_pc = 0;
899 sal->explicit_line = 0;
904 /* Return 1 if the two sections are the same, or if they could
905 plausibly be copies of each other, one in an original object
906 file and another in a separated debug file. */
909 matching_obj_sections (struct obj_section *obj_first,
910 struct obj_section *obj_second)
912 asection *first = obj_first? obj_first->the_bfd_section : NULL;
913 asection *second = obj_second? obj_second->the_bfd_section : NULL;
916 /* If they're the same section, then they match. */
920 /* If either is NULL, give up. */
921 if (first == NULL || second == NULL)
924 /* This doesn't apply to absolute symbols. */
925 if (first->owner == NULL || second->owner == NULL)
928 /* If they're in the same object file, they must be different sections. */
929 if (first->owner == second->owner)
932 /* Check whether the two sections are potentially corresponding. They must
933 have the same size, address, and name. We can't compare section indexes,
934 which would be more reliable, because some sections may have been
936 if (bfd_get_section_size (first) != bfd_get_section_size (second))
939 /* In-memory addresses may start at a different offset, relativize them. */
940 if (bfd_get_section_vma (first->owner, first)
941 - bfd_get_start_address (first->owner)
942 != bfd_get_section_vma (second->owner, second)
943 - bfd_get_start_address (second->owner))
946 if (bfd_get_section_name (first->owner, first) == NULL
947 || bfd_get_section_name (second->owner, second) == NULL
948 || strcmp (bfd_get_section_name (first->owner, first),
949 bfd_get_section_name (second->owner, second)) != 0)
952 /* Otherwise check that they are in corresponding objfiles. */
955 if (obj->obfd == first->owner)
957 gdb_assert (obj != NULL);
959 if (obj->separate_debug_objfile != NULL
960 && obj->separate_debug_objfile->obfd == second->owner)
962 if (obj->separate_debug_objfile_backlink != NULL
963 && obj->separate_debug_objfile_backlink->obfd == second->owner)
970 find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
972 struct objfile *objfile;
973 struct minimal_symbol *msymbol;
975 /* If we know that this is not a text address, return failure. This is
976 necessary because we loop based on texthigh and textlow, which do
977 not include the data ranges. */
978 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
980 && (MSYMBOL_TYPE (msymbol) == mst_data
981 || MSYMBOL_TYPE (msymbol) == mst_bss
982 || MSYMBOL_TYPE (msymbol) == mst_abs
983 || MSYMBOL_TYPE (msymbol) == mst_file_data
984 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
987 ALL_OBJFILES (objfile)
989 struct symtab *result = NULL;
992 result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
1001 /* Debug symbols usually don't have section information. We need to dig that
1002 out of the minimal symbols and stash that in the debug symbol. */
1005 fixup_section (struct general_symbol_info *ginfo,
1006 CORE_ADDR addr, struct objfile *objfile)
1008 struct minimal_symbol *msym;
1010 /* First, check whether a minimal symbol with the same name exists
1011 and points to the same address. The address check is required
1012 e.g. on PowerPC64, where the minimal symbol for a function will
1013 point to the function descriptor, while the debug symbol will
1014 point to the actual function code. */
1015 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1018 ginfo->obj_section = SYMBOL_OBJ_SECTION (msym);
1019 ginfo->section = SYMBOL_SECTION (msym);
1023 /* Static, function-local variables do appear in the linker
1024 (minimal) symbols, but are frequently given names that won't
1025 be found via lookup_minimal_symbol(). E.g., it has been
1026 observed in frv-uclinux (ELF) executables that a static,
1027 function-local variable named "foo" might appear in the
1028 linker symbols as "foo.6" or "foo.3". Thus, there is no
1029 point in attempting to extend the lookup-by-name mechanism to
1030 handle this case due to the fact that there can be multiple
1033 So, instead, search the section table when lookup by name has
1034 failed. The ``addr'' and ``endaddr'' fields may have already
1035 been relocated. If so, the relocation offset (i.e. the
1036 ANOFFSET value) needs to be subtracted from these values when
1037 performing the comparison. We unconditionally subtract it,
1038 because, when no relocation has been performed, the ANOFFSET
1039 value will simply be zero.
1041 The address of the symbol whose section we're fixing up HAS
1042 NOT BEEN adjusted (relocated) yet. It can't have been since
1043 the section isn't yet known and knowing the section is
1044 necessary in order to add the correct relocation value. In
1045 other words, we wouldn't even be in this function (attempting
1046 to compute the section) if it were already known.
1048 Note that it is possible to search the minimal symbols
1049 (subtracting the relocation value if necessary) to find the
1050 matching minimal symbol, but this is overkill and much less
1051 efficient. It is not necessary to find the matching minimal
1052 symbol, only its section.
1054 Note that this technique (of doing a section table search)
1055 can fail when unrelocated section addresses overlap. For
1056 this reason, we still attempt a lookup by name prior to doing
1057 a search of the section table. */
1059 struct obj_section *s;
1061 ALL_OBJFILE_OSECTIONS (objfile, s)
1063 int idx = s->the_bfd_section->index;
1064 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1066 if (obj_section_addr (s) - offset <= addr
1067 && addr < obj_section_endaddr (s) - offset)
1069 ginfo->obj_section = s;
1070 ginfo->section = idx;
1078 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1085 if (SYMBOL_OBJ_SECTION (sym))
1088 /* We either have an OBJFILE, or we can get at it from the sym's
1089 symtab. Anything else is a bug. */
1090 gdb_assert (objfile || SYMBOL_SYMTAB (sym));
1092 if (objfile == NULL)
1093 objfile = SYMBOL_SYMTAB (sym)->objfile;
1095 /* We should have an objfile by now. */
1096 gdb_assert (objfile);
1098 switch (SYMBOL_CLASS (sym))
1102 addr = SYMBOL_VALUE_ADDRESS (sym);
1105 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1109 /* Nothing else will be listed in the minsyms -- no use looking
1114 fixup_section (&sym->ginfo, addr, objfile);
1119 /* Compute the demangled form of NAME as used by the various symbol
1120 lookup functions. The result is stored in *RESULT_NAME. Returns a
1121 cleanup which can be used to clean up the result.
1123 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1124 Normally, Ada symbol lookups are performed using the encoded name
1125 rather than the demangled name, and so it might seem to make sense
1126 for this function to return an encoded version of NAME.
1127 Unfortunately, we cannot do this, because this function is used in
1128 circumstances where it is not appropriate to try to encode NAME.
1129 For instance, when displaying the frame info, we demangle the name
1130 of each parameter, and then perform a symbol lookup inside our
1131 function using that demangled name. In Ada, certain functions
1132 have internally-generated parameters whose name contain uppercase
1133 characters. Encoding those name would result in those uppercase
1134 characters to become lowercase, and thus cause the symbol lookup
1138 demangle_for_lookup (const char *name, enum language lang,
1139 const char **result_name)
1141 char *demangled_name = NULL;
1142 const char *modified_name = NULL;
1143 struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
1145 modified_name = name;
1147 /* If we are using C++, D, Go, or Java, demangle the name before doing a
1148 lookup, so we can always binary search. */
1149 if (lang == language_cplus)
1151 demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1154 modified_name = demangled_name;
1155 make_cleanup (xfree, demangled_name);
1159 /* If we were given a non-mangled name, canonicalize it
1160 according to the language (so far only for C++). */
1161 demangled_name = cp_canonicalize_string (name);
1164 modified_name = demangled_name;
1165 make_cleanup (xfree, demangled_name);
1169 else if (lang == language_java)
1171 demangled_name = cplus_demangle (name,
1172 DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1175 modified_name = demangled_name;
1176 make_cleanup (xfree, demangled_name);
1179 else if (lang == language_d)
1181 demangled_name = d_demangle (name, 0);
1184 modified_name = demangled_name;
1185 make_cleanup (xfree, demangled_name);
1188 else if (lang == language_go)
1190 demangled_name = go_demangle (name, 0);
1193 modified_name = demangled_name;
1194 make_cleanup (xfree, demangled_name);
1198 *result_name = modified_name;
1202 /* Find the definition for a specified symbol name NAME
1203 in domain DOMAIN, visible from lexical block BLOCK.
1204 Returns the struct symbol pointer, or zero if no symbol is found.
1205 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1206 NAME is a field of the current implied argument `this'. If so set
1207 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1208 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1209 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1211 /* This function (or rather its subordinates) have a bunch of loops and
1212 it would seem to be attractive to put in some QUIT's (though I'm not really
1213 sure whether it can run long enough to be really important). But there
1214 are a few calls for which it would appear to be bad news to quit
1215 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1216 that there is C++ code below which can error(), but that probably
1217 doesn't affect these calls since they are looking for a known
1218 variable and thus can probably assume it will never hit the C++
1222 lookup_symbol_in_language (const char *name, const struct block *block,
1223 const domain_enum domain, enum language lang,
1224 struct field_of_this_result *is_a_field_of_this)
1226 const char *modified_name;
1227 struct symbol *returnval;
1228 struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
1230 returnval = lookup_symbol_aux (modified_name, block, domain, lang,
1231 is_a_field_of_this);
1232 do_cleanups (cleanup);
1237 /* Behave like lookup_symbol_in_language, but performed with the
1238 current language. */
1241 lookup_symbol (const char *name, const struct block *block,
1243 struct field_of_this_result *is_a_field_of_this)
1245 return lookup_symbol_in_language (name, block, domain,
1246 current_language->la_language,
1247 is_a_field_of_this);
1250 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1251 found, or NULL if not found. */
1254 lookup_language_this (const struct language_defn *lang,
1255 const struct block *block)
1257 if (lang->la_name_of_this == NULL || block == NULL)
1264 sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1267 block_found = block;
1270 if (BLOCK_FUNCTION (block))
1272 block = BLOCK_SUPERBLOCK (block);
1278 /* Given TYPE, a structure/union,
1279 return 1 if the component named NAME from the ultimate target
1280 structure/union is defined, otherwise, return 0. */
1283 check_field (struct type *type, const char *name,
1284 struct field_of_this_result *is_a_field_of_this)
1288 /* The type may be a stub. */
1289 CHECK_TYPEDEF (type);
1291 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1293 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1295 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1297 is_a_field_of_this->type = type;
1298 is_a_field_of_this->field = &TYPE_FIELD (type, i);
1303 /* C++: If it was not found as a data field, then try to return it
1304 as a pointer to a method. */
1306 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1308 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1310 is_a_field_of_this->type = type;
1311 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1316 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1317 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
1323 /* Behave like lookup_symbol except that NAME is the natural name
1324 (e.g., demangled name) of the symbol that we're looking for. */
1326 static struct symbol *
1327 lookup_symbol_aux (const char *name, const struct block *block,
1328 const domain_enum domain, enum language language,
1329 struct field_of_this_result *is_a_field_of_this)
1332 const struct language_defn *langdef;
1334 /* Make sure we do something sensible with is_a_field_of_this, since
1335 the callers that set this parameter to some non-null value will
1336 certainly use it later. If we don't set it, the contents of
1337 is_a_field_of_this are undefined. */
1338 if (is_a_field_of_this != NULL)
1339 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
1341 /* Search specified block and its superiors. Don't search
1342 STATIC_BLOCK or GLOBAL_BLOCK. */
1344 sym = lookup_symbol_aux_local (name, block, domain, language);
1348 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1349 check to see if NAME is a field of `this'. */
1351 langdef = language_def (language);
1353 /* Don't do this check if we are searching for a struct. It will
1354 not be found by check_field, but will be found by other
1356 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
1358 struct symbol *sym = lookup_language_this (langdef, block);
1362 struct type *t = sym->type;
1364 /* I'm not really sure that type of this can ever
1365 be typedefed; just be safe. */
1367 if (TYPE_CODE (t) == TYPE_CODE_PTR
1368 || TYPE_CODE (t) == TYPE_CODE_REF)
1369 t = TYPE_TARGET_TYPE (t);
1371 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1372 && TYPE_CODE (t) != TYPE_CODE_UNION)
1373 error (_("Internal error: `%s' is not an aggregate"),
1374 langdef->la_name_of_this);
1376 if (check_field (t, name, is_a_field_of_this))
1381 /* Now do whatever is appropriate for LANGUAGE to look
1382 up static and global variables. */
1384 sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
1388 /* Now search all static file-level symbols. Not strictly correct,
1389 but more useful than an error. */
1391 return lookup_static_symbol_aux (name, domain);
1394 /* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1395 first, then check the psymtabs. If a psymtab indicates the existence of the
1396 desired name as a file-level static, then do psymtab-to-symtab conversion on
1397 the fly and return the found symbol. */
1400 lookup_static_symbol_aux (const char *name, const domain_enum domain)
1402 struct objfile *objfile;
1405 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
1409 ALL_OBJFILES (objfile)
1411 sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
1419 /* Check to see if the symbol is defined in BLOCK or its superiors.
1420 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1422 static struct symbol *
1423 lookup_symbol_aux_local (const char *name, const struct block *block,
1424 const domain_enum domain,
1425 enum language language)
1428 const struct block *static_block = block_static_block (block);
1429 const char *scope = block_scope (block);
1431 /* Check if either no block is specified or it's a global block. */
1433 if (static_block == NULL)
1436 while (block != static_block)
1438 sym = lookup_symbol_aux_block (name, block, domain);
1442 if (language == language_cplus || language == language_fortran)
1444 sym = cp_lookup_symbol_imports_or_template (scope, name, block,
1450 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
1452 block = BLOCK_SUPERBLOCK (block);
1455 /* We've reached the edge of the function without finding a result. */
1460 /* Look up OBJFILE to BLOCK. */
1463 lookup_objfile_from_block (const struct block *block)
1465 struct objfile *obj;
1471 block = block_global_block (block);
1472 /* Go through SYMTABS. */
1473 ALL_SYMTABS (obj, s)
1474 if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
1476 if (obj->separate_debug_objfile_backlink)
1477 obj = obj->separate_debug_objfile_backlink;
1485 /* Look up a symbol in a block; if found, fixup the symbol, and set
1486 block_found appropriately. */
1489 lookup_symbol_aux_block (const char *name, const struct block *block,
1490 const domain_enum domain)
1494 sym = lookup_block_symbol (block, name, domain);
1497 block_found = block;
1498 return fixup_symbol_section (sym, NULL);
1504 /* Check all global symbols in OBJFILE in symtabs and
1508 lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
1510 const domain_enum domain)
1512 const struct objfile *objfile;
1514 struct blockvector *bv;
1515 const struct block *block;
1518 for (objfile = main_objfile;
1520 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
1522 /* Go through symtabs. */
1523 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1525 bv = BLOCKVECTOR (s);
1526 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1527 sym = lookup_block_symbol (block, name, domain);
1530 block_found = block;
1531 return fixup_symbol_section (sym, (struct objfile *)objfile);
1535 sym = lookup_symbol_aux_quick ((struct objfile *) objfile, GLOBAL_BLOCK,
1544 /* Check to see if the symbol is defined in one of the OBJFILE's
1545 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1546 depending on whether or not we want to search global symbols or
1549 static struct symbol *
1550 lookup_symbol_aux_objfile (struct objfile *objfile, int block_index,
1551 const char *name, const domain_enum domain)
1553 struct symbol *sym = NULL;
1554 struct blockvector *bv;
1555 const struct block *block;
1559 objfile->sf->qf->pre_expand_symtabs_matching (objfile, block_index,
1562 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1564 bv = BLOCKVECTOR (s);
1565 block = BLOCKVECTOR_BLOCK (bv, block_index);
1566 sym = lookup_block_symbol (block, name, domain);
1569 block_found = block;
1570 return fixup_symbol_section (sym, objfile);
1577 /* Same as lookup_symbol_aux_objfile, except that it searches all
1578 objfiles. Return the first match found. */
1580 static struct symbol *
1581 lookup_symbol_aux_symtabs (int block_index, const char *name,
1582 const domain_enum domain)
1585 struct objfile *objfile;
1587 ALL_OBJFILES (objfile)
1589 sym = lookup_symbol_aux_objfile (objfile, block_index, name, domain);
1597 /* Wrapper around lookup_symbol_aux_objfile for search_symbols.
1598 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1599 and all related objfiles. */
1601 static struct symbol *
1602 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
1603 const char *linkage_name,
1606 enum language lang = current_language->la_language;
1607 const char *modified_name;
1608 struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang,
1610 struct objfile *main_objfile, *cur_objfile;
1612 if (objfile->separate_debug_objfile_backlink)
1613 main_objfile = objfile->separate_debug_objfile_backlink;
1615 main_objfile = objfile;
1617 for (cur_objfile = main_objfile;
1619 cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
1623 sym = lookup_symbol_aux_objfile (cur_objfile, GLOBAL_BLOCK,
1624 modified_name, domain);
1626 sym = lookup_symbol_aux_objfile (cur_objfile, STATIC_BLOCK,
1627 modified_name, domain);
1630 do_cleanups (cleanup);
1635 do_cleanups (cleanup);
1639 /* A helper function for lookup_symbol_aux that interfaces with the
1640 "quick" symbol table functions. */
1642 static struct symbol *
1643 lookup_symbol_aux_quick (struct objfile *objfile, int kind,
1644 const char *name, const domain_enum domain)
1646 struct symtab *symtab;
1647 struct blockvector *bv;
1648 const struct block *block;
1653 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, domain);
1657 bv = BLOCKVECTOR (symtab);
1658 block = BLOCKVECTOR_BLOCK (bv, kind);
1659 sym = lookup_block_symbol (block, name, domain);
1662 /* This shouldn't be necessary, but as a last resort try
1663 looking in the statics even though the psymtab claimed
1664 the symbol was global, or vice-versa. It's possible
1665 that the psymtab gets it wrong in some cases. */
1667 /* FIXME: carlton/2002-09-30: Should we really do that?
1668 If that happens, isn't it likely to be a GDB error, in
1669 which case we should fix the GDB error rather than
1670 silently dealing with it here? So I'd vote for
1671 removing the check for the symbol in the other
1673 block = BLOCKVECTOR_BLOCK (bv,
1674 kind == GLOBAL_BLOCK ?
1675 STATIC_BLOCK : GLOBAL_BLOCK);
1676 sym = lookup_block_symbol (block, name, domain);
1679 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1680 %s may be an inlined function, or may be a template function\n\
1681 (if a template, try specifying an instantiation: %s<type>)."),
1682 kind == GLOBAL_BLOCK ? "global" : "static",
1683 name, symtab->filename, name, name);
1685 return fixup_symbol_section (sym, objfile);
1688 /* A default version of lookup_symbol_nonlocal for use by languages
1689 that can't think of anything better to do. This implements the C
1693 basic_lookup_symbol_nonlocal (const char *name,
1694 const struct block *block,
1695 const domain_enum domain)
1699 /* NOTE: carlton/2003-05-19: The comments below were written when
1700 this (or what turned into this) was part of lookup_symbol_aux;
1701 I'm much less worried about these questions now, since these
1702 decisions have turned out well, but I leave these comments here
1705 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1706 not it would be appropriate to search the current global block
1707 here as well. (That's what this code used to do before the
1708 is_a_field_of_this check was moved up.) On the one hand, it's
1709 redundant with the lookup_symbol_aux_symtabs search that happens
1710 next. On the other hand, if decode_line_1 is passed an argument
1711 like filename:var, then the user presumably wants 'var' to be
1712 searched for in filename. On the third hand, there shouldn't be
1713 multiple global variables all of which are named 'var', and it's
1714 not like decode_line_1 has ever restricted its search to only
1715 global variables in a single filename. All in all, only
1716 searching the static block here seems best: it's correct and it's
1719 /* NOTE: carlton/2002-12-05: There's also a possible performance
1720 issue here: if you usually search for global symbols in the
1721 current file, then it would be slightly better to search the
1722 current global block before searching all the symtabs. But there
1723 are other factors that have a much greater effect on performance
1724 than that one, so I don't think we should worry about that for
1727 sym = lookup_symbol_static (name, block, domain);
1731 return lookup_symbol_global (name, block, domain);
1734 /* Lookup a symbol in the static block associated to BLOCK, if there
1735 is one; do nothing if BLOCK is NULL or a global block. */
1738 lookup_symbol_static (const char *name,
1739 const struct block *block,
1740 const domain_enum domain)
1742 const struct block *static_block = block_static_block (block);
1744 if (static_block != NULL)
1745 return lookup_symbol_aux_block (name, static_block, domain);
1750 /* Private data to be used with lookup_symbol_global_iterator_cb. */
1752 struct global_sym_lookup_data
1754 /* The name of the symbol we are searching for. */
1757 /* The domain to use for our search. */
1760 /* The field where the callback should store the symbol if found.
1761 It should be initialized to NULL before the search is started. */
1762 struct symbol *result;
1765 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1766 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1767 OBJFILE. The arguments for the search are passed via CB_DATA,
1768 which in reality is a pointer to struct global_sym_lookup_data. */
1771 lookup_symbol_global_iterator_cb (struct objfile *objfile,
1774 struct global_sym_lookup_data *data =
1775 (struct global_sym_lookup_data *) cb_data;
1777 gdb_assert (data->result == NULL);
1779 data->result = lookup_symbol_aux_objfile (objfile, GLOBAL_BLOCK,
1780 data->name, data->domain);
1781 if (data->result == NULL)
1782 data->result = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK,
1783 data->name, data->domain);
1785 /* If we found a match, tell the iterator to stop. Otherwise,
1787 return (data->result != NULL);
1790 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1794 lookup_symbol_global (const char *name,
1795 const struct block *block,
1796 const domain_enum domain)
1798 struct symbol *sym = NULL;
1799 struct objfile *objfile = NULL;
1800 struct global_sym_lookup_data lookup_data;
1802 /* Call library-specific lookup procedure. */
1803 objfile = lookup_objfile_from_block (block);
1804 if (objfile != NULL)
1805 sym = solib_global_lookup (objfile, name, domain);
1809 memset (&lookup_data, 0, sizeof (lookup_data));
1810 lookup_data.name = name;
1811 lookup_data.domain = domain;
1812 gdbarch_iterate_over_objfiles_in_search_order
1813 (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
1814 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
1816 return lookup_data.result;
1820 symbol_matches_domain (enum language symbol_language,
1821 domain_enum symbol_domain,
1824 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1825 A Java class declaration also defines a typedef for the class.
1826 Similarly, any Ada type declaration implicitly defines a typedef. */
1827 if (symbol_language == language_cplus
1828 || symbol_language == language_d
1829 || symbol_language == language_java
1830 || symbol_language == language_ada)
1832 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
1833 && symbol_domain == STRUCT_DOMAIN)
1836 /* For all other languages, strict match is required. */
1837 return (symbol_domain == domain);
1840 /* Look up a type named NAME in the struct_domain. The type returned
1841 must not be opaque -- i.e., must have at least one field
1845 lookup_transparent_type (const char *name)
1847 return current_language->la_lookup_transparent_type (name);
1850 /* A helper for basic_lookup_transparent_type that interfaces with the
1851 "quick" symbol table functions. */
1853 static struct type *
1854 basic_lookup_transparent_type_quick (struct objfile *objfile, int kind,
1857 struct symtab *symtab;
1858 struct blockvector *bv;
1859 struct block *block;
1864 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, STRUCT_DOMAIN);
1868 bv = BLOCKVECTOR (symtab);
1869 block = BLOCKVECTOR_BLOCK (bv, kind);
1870 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1873 int other_kind = kind == GLOBAL_BLOCK ? STATIC_BLOCK : GLOBAL_BLOCK;
1875 /* This shouldn't be necessary, but as a last resort
1876 * try looking in the 'other kind' even though the psymtab
1877 * claimed the symbol was one thing. It's possible that
1878 * the psymtab gets it wrong in some cases.
1880 block = BLOCKVECTOR_BLOCK (bv, other_kind);
1881 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1883 /* FIXME; error is wrong in one case. */
1885 Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1886 %s may be an inlined function, or may be a template function\n\
1887 (if a template, try specifying an instantiation: %s<type>)."),
1888 name, symtab->filename, name, name);
1890 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1891 return SYMBOL_TYPE (sym);
1896 /* The standard implementation of lookup_transparent_type. This code
1897 was modeled on lookup_symbol -- the parts not relevant to looking
1898 up types were just left out. In particular it's assumed here that
1899 types are available in struct_domain and only at file-static or
1903 basic_lookup_transparent_type (const char *name)
1906 struct symtab *s = NULL;
1907 struct blockvector *bv;
1908 struct objfile *objfile;
1909 struct block *block;
1912 /* Now search all the global symbols. Do the symtab's first, then
1913 check the psymtab's. If a psymtab indicates the existence
1914 of the desired name as a global, then do psymtab-to-symtab
1915 conversion on the fly and return the found symbol. */
1917 ALL_OBJFILES (objfile)
1920 objfile->sf->qf->pre_expand_symtabs_matching (objfile,
1922 name, STRUCT_DOMAIN);
1924 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1926 bv = BLOCKVECTOR (s);
1927 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1928 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1929 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1931 return SYMBOL_TYPE (sym);
1936 ALL_OBJFILES (objfile)
1938 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
1943 /* Now search the static file-level symbols.
1944 Not strictly correct, but more useful than an error.
1945 Do the symtab's first, then
1946 check the psymtab's. If a psymtab indicates the existence
1947 of the desired name as a file-level static, then do psymtab-to-symtab
1948 conversion on the fly and return the found symbol. */
1950 ALL_OBJFILES (objfile)
1953 objfile->sf->qf->pre_expand_symtabs_matching (objfile, STATIC_BLOCK,
1954 name, STRUCT_DOMAIN);
1956 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1958 bv = BLOCKVECTOR (s);
1959 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1960 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1961 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1963 return SYMBOL_TYPE (sym);
1968 ALL_OBJFILES (objfile)
1970 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
1975 return (struct type *) 0;
1978 /* Find the name of the file containing main(). */
1979 /* FIXME: What about languages without main() or specially linked
1980 executables that have no main() ? */
1983 find_main_filename (void)
1985 struct objfile *objfile;
1986 char *name = main_name ();
1988 ALL_OBJFILES (objfile)
1994 result = objfile->sf->qf->find_symbol_file (objfile, name);
2001 /* Search BLOCK for symbol NAME in DOMAIN.
2003 Note that if NAME is the demangled form of a C++ symbol, we will fail
2004 to find a match during the binary search of the non-encoded names, but
2005 for now we don't worry about the slight inefficiency of looking for
2006 a match we'll never find, since it will go pretty quick. Once the
2007 binary search terminates, we drop through and do a straight linear
2008 search on the symbols. Each symbol which is marked as being a ObjC/C++
2009 symbol (language_cplus or language_objc set) has both the encoded and
2010 non-encoded names tested for a match. */
2013 lookup_block_symbol (const struct block *block, const char *name,
2014 const domain_enum domain)
2016 struct block_iterator iter;
2019 if (!BLOCK_FUNCTION (block))
2021 for (sym = block_iter_name_first (block, name, &iter);
2023 sym = block_iter_name_next (name, &iter))
2025 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2026 SYMBOL_DOMAIN (sym), domain))
2033 /* Note that parameter symbols do not always show up last in the
2034 list; this loop makes sure to take anything else other than
2035 parameter symbols first; it only uses parameter symbols as a
2036 last resort. Note that this only takes up extra computation
2039 struct symbol *sym_found = NULL;
2041 for (sym = block_iter_name_first (block, name, &iter);
2043 sym = block_iter_name_next (name, &iter))
2045 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2046 SYMBOL_DOMAIN (sym), domain))
2049 if (!SYMBOL_IS_ARGUMENT (sym))
2055 return (sym_found); /* Will be NULL if not found. */
2059 /* Iterate over the symbols named NAME, matching DOMAIN, starting with
2062 For each symbol that matches, CALLBACK is called. The symbol and
2063 DATA are passed to the callback.
2065 If CALLBACK returns zero, the iteration ends. Otherwise, the
2066 search continues. This function iterates upward through blocks.
2067 When the outermost block has been finished, the function
2071 iterate_over_symbols (const struct block *block, const char *name,
2072 const domain_enum domain,
2073 symbol_found_callback_ftype *callback,
2078 struct block_iterator iter;
2081 for (sym = block_iter_name_first (block, name, &iter);
2083 sym = block_iter_name_next (name, &iter))
2085 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2086 SYMBOL_DOMAIN (sym), domain))
2088 if (!callback (sym, data))
2093 block = BLOCK_SUPERBLOCK (block);
2097 /* Find the symtab associated with PC and SECTION. Look through the
2098 psymtabs and read in another symtab if necessary. */
2101 find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
2104 struct blockvector *bv;
2105 struct symtab *s = NULL;
2106 struct symtab *best_s = NULL;
2107 struct objfile *objfile;
2108 struct program_space *pspace;
2109 CORE_ADDR distance = 0;
2110 struct minimal_symbol *msymbol;
2112 pspace = current_program_space;
2114 /* If we know that this is not a text address, return failure. This is
2115 necessary because we loop based on the block's high and low code
2116 addresses, which do not include the data ranges, and because
2117 we call find_pc_sect_psymtab which has a similar restriction based
2118 on the partial_symtab's texthigh and textlow. */
2119 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2121 && (MSYMBOL_TYPE (msymbol) == mst_data
2122 || MSYMBOL_TYPE (msymbol) == mst_bss
2123 || MSYMBOL_TYPE (msymbol) == mst_abs
2124 || MSYMBOL_TYPE (msymbol) == mst_file_data
2125 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
2128 /* Search all symtabs for the one whose file contains our address, and which
2129 is the smallest of all the ones containing the address. This is designed
2130 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2131 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2132 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2134 This happens for native ecoff format, where code from included files
2135 gets its own symtab. The symtab for the included file should have
2136 been read in already via the dependency mechanism.
2137 It might be swifter to create several symtabs with the same name
2138 like xcoff does (I'm not sure).
2140 It also happens for objfiles that have their functions reordered.
2141 For these, the symtab we are looking for is not necessarily read in. */
2143 ALL_PRIMARY_SYMTABS (objfile, s)
2145 bv = BLOCKVECTOR (s);
2146 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2148 if (BLOCK_START (b) <= pc
2149 && BLOCK_END (b) > pc
2151 || BLOCK_END (b) - BLOCK_START (b) < distance))
2153 /* For an objfile that has its functions reordered,
2154 find_pc_psymtab will find the proper partial symbol table
2155 and we simply return its corresponding symtab. */
2156 /* In order to better support objfiles that contain both
2157 stabs and coff debugging info, we continue on if a psymtab
2159 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2161 struct symtab *result;
2164 = objfile->sf->qf->find_pc_sect_symtab (objfile,
2173 struct block_iterator iter;
2174 struct symbol *sym = NULL;
2176 ALL_BLOCK_SYMBOLS (b, iter, sym)
2178 fixup_symbol_section (sym, objfile);
2179 if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym), section))
2183 continue; /* No symbol in this symtab matches
2186 distance = BLOCK_END (b) - BLOCK_START (b);
2194 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2196 ALL_OBJFILES (objfile)
2198 struct symtab *result;
2202 result = objfile->sf->qf->find_pc_sect_symtab (objfile,
2213 /* Find the symtab associated with PC. Look through the psymtabs and read
2214 in another symtab if necessary. Backward compatibility, no section. */
2217 find_pc_symtab (CORE_ADDR pc)
2219 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
2223 /* Find the source file and line number for a given PC value and SECTION.
2224 Return a structure containing a symtab pointer, a line number,
2225 and a pc range for the entire source line.
2226 The value's .pc field is NOT the specified pc.
2227 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2228 use the line that ends there. Otherwise, in that case, the line
2229 that begins there is used. */
2231 /* The big complication here is that a line may start in one file, and end just
2232 before the start of another file. This usually occurs when you #include
2233 code in the middle of a subroutine. To properly find the end of a line's PC
2234 range, we must search all symtabs associated with this compilation unit, and
2235 find the one whose first PC is closer than that of the next line in this
2238 /* If it's worth the effort, we could be using a binary search. */
2240 struct symtab_and_line
2241 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
2244 struct linetable *l;
2247 struct linetable_entry *item;
2248 struct symtab_and_line val;
2249 struct blockvector *bv;
2250 struct minimal_symbol *msymbol;
2251 struct minimal_symbol *mfunsym;
2252 struct objfile *objfile;
2254 /* Info on best line seen so far, and where it starts, and its file. */
2256 struct linetable_entry *best = NULL;
2257 CORE_ADDR best_end = 0;
2258 struct symtab *best_symtab = 0;
2260 /* Store here the first line number
2261 of a file which contains the line at the smallest pc after PC.
2262 If we don't find a line whose range contains PC,
2263 we will use a line one less than this,
2264 with a range from the start of that file to the first line's pc. */
2265 struct linetable_entry *alt = NULL;
2266 struct symtab *alt_symtab = 0;
2268 /* Info on best line seen in this file. */
2270 struct linetable_entry *prev;
2272 /* If this pc is not from the current frame,
2273 it is the address of the end of a call instruction.
2274 Quite likely that is the start of the following statement.
2275 But what we want is the statement containing the instruction.
2276 Fudge the pc to make sure we get that. */
2278 init_sal (&val); /* initialize to zeroes */
2280 val.pspace = current_program_space;
2282 /* It's tempting to assume that, if we can't find debugging info for
2283 any function enclosing PC, that we shouldn't search for line
2284 number info, either. However, GAS can emit line number info for
2285 assembly files --- very helpful when debugging hand-written
2286 assembly code. In such a case, we'd have no debug info for the
2287 function, but we would have line info. */
2292 /* elz: added this because this function returned the wrong
2293 information if the pc belongs to a stub (import/export)
2294 to call a shlib function. This stub would be anywhere between
2295 two functions in the target, and the line info was erroneously
2296 taken to be the one of the line before the pc. */
2298 /* RT: Further explanation:
2300 * We have stubs (trampolines) inserted between procedures.
2302 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2303 * exists in the main image.
2305 * In the minimal symbol table, we have a bunch of symbols
2306 * sorted by start address. The stubs are marked as "trampoline",
2307 * the others appear as text. E.g.:
2309 * Minimal symbol table for main image
2310 * main: code for main (text symbol)
2311 * shr1: stub (trampoline symbol)
2312 * foo: code for foo (text symbol)
2314 * Minimal symbol table for "shr1" image:
2316 * shr1: code for shr1 (text symbol)
2319 * So the code below is trying to detect if we are in the stub
2320 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2321 * and if found, do the symbolization from the real-code address
2322 * rather than the stub address.
2324 * Assumptions being made about the minimal symbol table:
2325 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2326 * if we're really in the trampoline.s If we're beyond it (say
2327 * we're in "foo" in the above example), it'll have a closer
2328 * symbol (the "foo" text symbol for example) and will not
2329 * return the trampoline.
2330 * 2. lookup_minimal_symbol_text() will find a real text symbol
2331 * corresponding to the trampoline, and whose address will
2332 * be different than the trampoline address. I put in a sanity
2333 * check for the address being the same, to avoid an
2334 * infinite recursion.
2336 msymbol = lookup_minimal_symbol_by_pc (pc);
2337 if (msymbol != NULL)
2338 if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
2340 mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
2342 if (mfunsym == NULL)
2343 /* I eliminated this warning since it is coming out
2344 * in the following situation:
2345 * gdb shmain // test program with shared libraries
2346 * (gdb) break shr1 // function in shared lib
2347 * Warning: In stub for ...
2348 * In the above situation, the shared lib is not loaded yet,
2349 * so of course we can't find the real func/line info,
2350 * but the "break" still works, and the warning is annoying.
2351 * So I commented out the warning. RT */
2352 /* warning ("In stub for %s; unable to find real function/line info",
2353 SYMBOL_LINKAGE_NAME (msymbol)); */
2356 else if (SYMBOL_VALUE_ADDRESS (mfunsym)
2357 == SYMBOL_VALUE_ADDRESS (msymbol))
2358 /* Avoid infinite recursion */
2359 /* See above comment about why warning is commented out. */
2360 /* warning ("In stub for %s; unable to find real function/line info",
2361 SYMBOL_LINKAGE_NAME (msymbol)); */
2365 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
2369 s = find_pc_sect_symtab (pc, section);
2372 /* If no symbol information, return previous pc. */
2379 bv = BLOCKVECTOR (s);
2380 objfile = s->objfile;
2382 /* Look at all the symtabs that share this blockvector.
2383 They all have the same apriori range, that we found was right;
2384 but they have different line tables. */
2386 ALL_OBJFILE_SYMTABS (objfile, s)
2388 if (BLOCKVECTOR (s) != bv)
2391 /* Find the best line in this symtab. */
2398 /* I think len can be zero if the symtab lacks line numbers
2399 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2400 I'm not sure which, and maybe it depends on the symbol
2406 item = l->item; /* Get first line info. */
2408 /* Is this file's first line closer than the first lines of other files?
2409 If so, record this file, and its first line, as best alternate. */
2410 if (item->pc > pc && (!alt || item->pc < alt->pc))
2416 for (i = 0; i < len; i++, item++)
2418 /* Leave prev pointing to the linetable entry for the last line
2419 that started at or before PC. */
2426 /* At this point, prev points at the line whose start addr is <= pc, and
2427 item points at the next line. If we ran off the end of the linetable
2428 (pc >= start of the last line), then prev == item. If pc < start of
2429 the first line, prev will not be set. */
2431 /* Is this file's best line closer than the best in the other files?
2432 If so, record this file, and its best line, as best so far. Don't
2433 save prev if it represents the end of a function (i.e. line number
2434 0) instead of a real line. */
2436 if (prev && prev->line && (!best || prev->pc > best->pc))
2441 /* Discard BEST_END if it's before the PC of the current BEST. */
2442 if (best_end <= best->pc)
2446 /* If another line (denoted by ITEM) is in the linetable and its
2447 PC is after BEST's PC, but before the current BEST_END, then
2448 use ITEM's PC as the new best_end. */
2449 if (best && i < len && item->pc > best->pc
2450 && (best_end == 0 || best_end > item->pc))
2451 best_end = item->pc;
2456 /* If we didn't find any line number info, just return zeros.
2457 We used to return alt->line - 1 here, but that could be
2458 anywhere; if we don't have line number info for this PC,
2459 don't make some up. */
2462 else if (best->line == 0)
2464 /* If our best fit is in a range of PC's for which no line
2465 number info is available (line number is zero) then we didn't
2466 find any valid line information. */
2471 val.symtab = best_symtab;
2472 val.line = best->line;
2474 if (best_end && (!alt || best_end < alt->pc))
2479 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2481 val.section = section;
2485 /* Backward compatibility (no section). */
2487 struct symtab_and_line
2488 find_pc_line (CORE_ADDR pc, int notcurrent)
2490 struct obj_section *section;
2492 section = find_pc_overlay (pc);
2493 if (pc_in_unmapped_range (pc, section))
2494 pc = overlay_mapped_address (pc, section);
2495 return find_pc_sect_line (pc, section, notcurrent);
2498 /* Find line number LINE in any symtab whose name is the same as
2501 If found, return the symtab that contains the linetable in which it was
2502 found, set *INDEX to the index in the linetable of the best entry
2503 found, and set *EXACT_MATCH nonzero if the value returned is an
2506 If not found, return NULL. */
2509 find_line_symtab (struct symtab *symtab, int line,
2510 int *index, int *exact_match)
2512 int exact = 0; /* Initialized here to avoid a compiler warning. */
2514 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2518 struct linetable *best_linetable;
2519 struct symtab *best_symtab;
2521 /* First try looking it up in the given symtab. */
2522 best_linetable = LINETABLE (symtab);
2523 best_symtab = symtab;
2524 best_index = find_line_common (best_linetable, line, &exact, 0);
2525 if (best_index < 0 || !exact)
2527 /* Didn't find an exact match. So we better keep looking for
2528 another symtab with the same name. In the case of xcoff,
2529 multiple csects for one source file (produced by IBM's FORTRAN
2530 compiler) produce multiple symtabs (this is unavoidable
2531 assuming csects can be at arbitrary places in memory and that
2532 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2534 /* BEST is the smallest linenumber > LINE so far seen,
2535 or 0 if none has been seen so far.
2536 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2539 struct objfile *objfile;
2542 if (best_index >= 0)
2543 best = best_linetable->item[best_index].line;
2547 ALL_OBJFILES (objfile)
2550 objfile->sf->qf->expand_symtabs_with_filename (objfile,
2554 /* Get symbol full file name if possible. */
2555 symtab_to_fullname (symtab);
2557 ALL_SYMTABS (objfile, s)
2559 struct linetable *l;
2562 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
2564 if (symtab->fullname != NULL
2565 && symtab_to_fullname (s) != NULL
2566 && FILENAME_CMP (symtab->fullname, s->fullname) != 0)
2569 ind = find_line_common (l, line, &exact, 0);
2579 if (best == 0 || l->item[ind].line < best)
2581 best = l->item[ind].line;
2594 *index = best_index;
2596 *exact_match = exact;
2601 /* Given SYMTAB, returns all the PCs function in the symtab that
2602 exactly match LINE. Returns NULL if there are no exact matches,
2603 but updates BEST_ITEM in this case. */
2606 find_pcs_for_symtab_line (struct symtab *symtab, int line,
2607 struct linetable_entry **best_item)
2610 struct symbol *previous_function = NULL;
2611 VEC (CORE_ADDR) *result = NULL;
2613 /* First, collect all the PCs that are at this line. */
2619 idx = find_line_common (LINETABLE (symtab), line, &was_exact, start);
2625 struct linetable_entry *item = &LINETABLE (symtab)->item[idx];
2627 if (*best_item == NULL || item->line < (*best_item)->line)
2633 VEC_safe_push (CORE_ADDR, result, LINETABLE (symtab)->item[idx].pc);
2641 /* Set the PC value for a given source file and line number and return true.
2642 Returns zero for invalid line number (and sets the PC to 0).
2643 The source file is specified with a struct symtab. */
2646 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
2648 struct linetable *l;
2655 symtab = find_line_symtab (symtab, line, &ind, NULL);
2658 l = LINETABLE (symtab);
2659 *pc = l->item[ind].pc;
2666 /* Find the range of pc values in a line.
2667 Store the starting pc of the line into *STARTPTR
2668 and the ending pc (start of next line) into *ENDPTR.
2669 Returns 1 to indicate success.
2670 Returns 0 if could not find the specified line. */
2673 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2676 CORE_ADDR startaddr;
2677 struct symtab_and_line found_sal;
2680 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
2683 /* This whole function is based on address. For example, if line 10 has
2684 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2685 "info line *0x123" should say the line goes from 0x100 to 0x200
2686 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2687 This also insures that we never give a range like "starts at 0x134
2688 and ends at 0x12c". */
2690 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2691 if (found_sal.line != sal.line)
2693 /* The specified line (sal) has zero bytes. */
2694 *startptr = found_sal.pc;
2695 *endptr = found_sal.pc;
2699 *startptr = found_sal.pc;
2700 *endptr = found_sal.end;
2705 /* Given a line table and a line number, return the index into the line
2706 table for the pc of the nearest line whose number is >= the specified one.
2707 Return -1 if none is found. The value is >= 0 if it is an index.
2708 START is the index at which to start searching the line table.
2710 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2713 find_line_common (struct linetable *l, int lineno,
2714 int *exact_match, int start)
2719 /* BEST is the smallest linenumber > LINENO so far seen,
2720 or 0 if none has been seen so far.
2721 BEST_INDEX identifies the item for it. */
2723 int best_index = -1;
2734 for (i = start; i < len; i++)
2736 struct linetable_entry *item = &(l->item[i]);
2738 if (item->line == lineno)
2740 /* Return the first (lowest address) entry which matches. */
2745 if (item->line > lineno && (best == 0 || item->line < best))
2752 /* If we got here, we didn't get an exact match. */
2757 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
2759 struct symtab_and_line sal;
2761 sal = find_pc_line (pc, 0);
2764 return sal.symtab != 0;
2767 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2768 address for that function that has an entry in SYMTAB's line info
2769 table. If such an entry cannot be found, return FUNC_ADDR
2773 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
2775 CORE_ADDR func_start, func_end;
2776 struct linetable *l;
2779 /* Give up if this symbol has no lineinfo table. */
2780 l = LINETABLE (symtab);
2784 /* Get the range for the function's PC values, or give up if we
2785 cannot, for some reason. */
2786 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
2789 /* Linetable entries are ordered by PC values, see the commentary in
2790 symtab.h where `struct linetable' is defined. Thus, the first
2791 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2792 address we are looking for. */
2793 for (i = 0; i < l->nitems; i++)
2795 struct linetable_entry *item = &(l->item[i]);
2797 /* Don't use line numbers of zero, they mark special entries in
2798 the table. See the commentary on symtab.h before the
2799 definition of struct linetable. */
2800 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
2807 /* Given a function symbol SYM, find the symtab and line for the start
2809 If the argument FUNFIRSTLINE is nonzero, we want the first line
2810 of real code inside the function. */
2812 struct symtab_and_line
2813 find_function_start_sal (struct symbol *sym, int funfirstline)
2815 struct symtab_and_line sal;
2817 fixup_symbol_section (sym, NULL);
2818 sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
2819 SYMBOL_OBJ_SECTION (sym), 0);
2821 /* We always should have a line for the function start address.
2822 If we don't, something is odd. Create a plain SAL refering
2823 just the PC and hope that skip_prologue_sal (if requested)
2824 can find a line number for after the prologue. */
2825 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
2828 sal.pspace = current_program_space;
2829 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2830 sal.section = SYMBOL_OBJ_SECTION (sym);
2834 skip_prologue_sal (&sal);
2839 /* Adjust SAL to the first instruction past the function prologue.
2840 If the PC was explicitly specified, the SAL is not changed.
2841 If the line number was explicitly specified, at most the SAL's PC
2842 is updated. If SAL is already past the prologue, then do nothing. */
2845 skip_prologue_sal (struct symtab_and_line *sal)
2848 struct symtab_and_line start_sal;
2849 struct cleanup *old_chain;
2850 CORE_ADDR pc, saved_pc;
2851 struct obj_section *section;
2853 struct objfile *objfile;
2854 struct gdbarch *gdbarch;
2855 struct block *b, *function_block;
2856 int force_skip, skip;
2858 /* Do not change the SAL if PC was specified explicitly. */
2859 if (sal->explicit_pc)
2862 old_chain = save_current_space_and_thread ();
2863 switch_to_program_space_and_thread (sal->pspace);
2865 sym = find_pc_sect_function (sal->pc, sal->section);
2868 fixup_symbol_section (sym, NULL);
2870 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2871 section = SYMBOL_OBJ_SECTION (sym);
2872 name = SYMBOL_LINKAGE_NAME (sym);
2873 objfile = SYMBOL_SYMTAB (sym)->objfile;
2877 struct minimal_symbol *msymbol
2878 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
2880 if (msymbol == NULL)
2882 do_cleanups (old_chain);
2886 pc = SYMBOL_VALUE_ADDRESS (msymbol);
2887 section = SYMBOL_OBJ_SECTION (msymbol);
2888 name = SYMBOL_LINKAGE_NAME (msymbol);
2889 objfile = msymbol_objfile (msymbol);
2892 gdbarch = get_objfile_arch (objfile);
2894 /* Process the prologue in two passes. In the first pass try to skip the
2895 prologue (SKIP is true) and verify there is a real need for it (indicated
2896 by FORCE_SKIP). If no such reason was found run a second pass where the
2897 prologue is not skipped (SKIP is false). */
2902 /* Be conservative - allow direct PC (without skipping prologue) only if we
2903 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2904 have to be set by the caller so we use SYM instead. */
2905 if (sym && SYMBOL_SYMTAB (sym)->locations_valid)
2913 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2914 so that gdbarch_skip_prologue has something unique to work on. */
2915 if (section_is_overlay (section) && !section_is_mapped (section))
2916 pc = overlay_unmapped_address (pc, section);
2918 /* Skip "first line" of function (which is actually its prologue). */
2919 pc += gdbarch_deprecated_function_start_offset (gdbarch);
2921 pc = gdbarch_skip_prologue (gdbarch, pc);
2923 /* For overlays, map pc back into its mapped VMA range. */
2924 pc = overlay_mapped_address (pc, section);
2926 /* Calculate line number. */
2927 start_sal = find_pc_sect_line (pc, section, 0);
2929 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2930 line is still part of the same function. */
2931 if (skip && start_sal.pc != pc
2932 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
2933 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2934 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section)
2935 == lookup_minimal_symbol_by_pc_section (pc, section))))
2937 /* First pc of next line */
2939 /* Recalculate the line number (might not be N+1). */
2940 start_sal = find_pc_sect_line (pc, section, 0);
2943 /* On targets with executable formats that don't have a concept of
2944 constructors (ELF with .init has, PE doesn't), gcc emits a call
2945 to `__main' in `main' between the prologue and before user
2947 if (gdbarch_skip_main_prologue_p (gdbarch)
2948 && name && strcmp_iw (name, "main") == 0)
2950 pc = gdbarch_skip_main_prologue (gdbarch, pc);
2951 /* Recalculate the line number (might not be N+1). */
2952 start_sal = find_pc_sect_line (pc, section, 0);
2956 while (!force_skip && skip--);
2958 /* If we still don't have a valid source line, try to find the first
2959 PC in the lineinfo table that belongs to the same function. This
2960 happens with COFF debug info, which does not seem to have an
2961 entry in lineinfo table for the code after the prologue which has
2962 no direct relation to source. For example, this was found to be
2963 the case with the DJGPP target using "gcc -gcoff" when the
2964 compiler inserted code after the prologue to make sure the stack
2966 if (!force_skip && sym && start_sal.symtab == NULL)
2968 pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
2969 /* Recalculate the line number. */
2970 start_sal = find_pc_sect_line (pc, section, 0);
2973 do_cleanups (old_chain);
2975 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2976 forward SAL to the end of the prologue. */
2981 sal->section = section;
2983 /* Unless the explicit_line flag was set, update the SAL line
2984 and symtab to correspond to the modified PC location. */
2985 if (sal->explicit_line)
2988 sal->symtab = start_sal.symtab;
2989 sal->line = start_sal.line;
2990 sal->end = start_sal.end;
2992 /* Check if we are now inside an inlined function. If we can,
2993 use the call site of the function instead. */
2994 b = block_for_pc_sect (sal->pc, sal->section);
2995 function_block = NULL;
2998 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
3000 else if (BLOCK_FUNCTION (b) != NULL)
3002 b = BLOCK_SUPERBLOCK (b);
3004 if (function_block != NULL
3005 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
3007 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
3008 sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
3012 /* If P is of the form "operator[ \t]+..." where `...' is
3013 some legitimate operator text, return a pointer to the
3014 beginning of the substring of the operator text.
3015 Otherwise, return "". */
3018 operator_chars (char *p, char **end)
3021 if (strncmp (p, "operator", 8))
3025 /* Don't get faked out by `operator' being part of a longer
3027 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
3030 /* Allow some whitespace between `operator' and the operator symbol. */
3031 while (*p == ' ' || *p == '\t')
3034 /* Recognize 'operator TYPENAME'. */
3036 if (isalpha (*p) || *p == '_' || *p == '$')
3040 while (isalnum (*q) || *q == '_' || *q == '$')
3049 case '\\': /* regexp quoting */
3052 if (p[2] == '=') /* 'operator\*=' */
3054 else /* 'operator\*' */
3058 else if (p[1] == '[')
3061 error (_("mismatched quoting on brackets, "
3062 "try 'operator\\[\\]'"));
3063 else if (p[2] == '\\' && p[3] == ']')
3065 *end = p + 4; /* 'operator\[\]' */
3069 error (_("nothing is allowed between '[' and ']'"));
3073 /* Gratuitous qoute: skip it and move on. */
3095 if (p[0] == '-' && p[1] == '>')
3097 /* Struct pointer member operator 'operator->'. */
3100 *end = p + 3; /* 'operator->*' */
3103 else if (p[2] == '\\')
3105 *end = p + 4; /* Hopefully 'operator->\*' */
3110 *end = p + 2; /* 'operator->' */
3114 if (p[1] == '=' || p[1] == p[0])
3125 error (_("`operator ()' must be specified "
3126 "without whitespace in `()'"));
3131 error (_("`operator ?:' must be specified "
3132 "without whitespace in `?:'"));
3137 error (_("`operator []' must be specified "
3138 "without whitespace in `[]'"));
3142 error (_("`operator %s' not supported"), p);
3151 /* Cache to watch for file names already seen by filename_seen. */
3153 struct filename_seen_cache
3155 /* Table of files seen so far. */
3157 /* Initial size of the table. It automagically grows from here. */
3158 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
3161 /* filename_seen_cache constructor. */
3163 static struct filename_seen_cache *
3164 create_filename_seen_cache (void)
3166 struct filename_seen_cache *cache;
3168 cache = XNEW (struct filename_seen_cache);
3169 cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
3170 filename_hash, filename_eq,
3171 NULL, xcalloc, xfree);
3176 /* Empty the cache, but do not delete it. */
3179 clear_filename_seen_cache (struct filename_seen_cache *cache)
3181 htab_empty (cache->tab);
3184 /* filename_seen_cache destructor.
3185 This takes a void * argument as it is generally used as a cleanup. */
3188 delete_filename_seen_cache (void *ptr)
3190 struct filename_seen_cache *cache = ptr;
3192 htab_delete (cache->tab);
3196 /* If FILE is not already in the table of files in CACHE, return zero;
3197 otherwise return non-zero. Optionally add FILE to the table if ADD
3200 NOTE: We don't manage space for FILE, we assume FILE lives as long
3201 as the caller needs. */
3204 filename_seen (struct filename_seen_cache *cache, const char *file, int add)
3208 /* Is FILE in tab? */
3209 slot = htab_find_slot (cache->tab, file, add ? INSERT : NO_INSERT);
3213 /* No; maybe add it to tab. */
3215 *slot = (char *) file;
3220 /* Data structure to maintain printing state for output_source_filename. */
3222 struct output_source_filename_data
3224 /* Cache of what we've seen so far. */
3225 struct filename_seen_cache *filename_seen_cache;
3227 /* Flag of whether we're printing the first one. */
3231 /* Slave routine for sources_info. Force line breaks at ,'s.
3232 NAME is the name to print.
3233 DATA contains the state for printing and watching for duplicates. */
3236 output_source_filename (const char *name,
3237 struct output_source_filename_data *data)
3239 /* Since a single source file can result in several partial symbol
3240 tables, we need to avoid printing it more than once. Note: if
3241 some of the psymtabs are read in and some are not, it gets
3242 printed both under "Source files for which symbols have been
3243 read" and "Source files for which symbols will be read in on
3244 demand". I consider this a reasonable way to deal with the
3245 situation. I'm not sure whether this can also happen for
3246 symtabs; it doesn't hurt to check. */
3248 /* Was NAME already seen? */
3249 if (filename_seen (data->filename_seen_cache, name, 1))
3251 /* Yes; don't print it again. */
3255 /* No; print it and reset *FIRST. */
3257 printf_filtered (", ");
3261 fputs_filtered (name, gdb_stdout);
3264 /* A callback for map_partial_symbol_filenames. */
3267 output_partial_symbol_filename (const char *filename, const char *fullname,
3270 output_source_filename (fullname ? fullname : filename, data);
3274 sources_info (char *ignore, int from_tty)
3277 struct objfile *objfile;
3278 struct output_source_filename_data data;
3279 struct cleanup *cleanups;
3281 if (!have_full_symbols () && !have_partial_symbols ())
3283 error (_("No symbol table is loaded. Use the \"file\" command."));
3286 data.filename_seen_cache = create_filename_seen_cache ();
3287 cleanups = make_cleanup (delete_filename_seen_cache,
3288 data.filename_seen_cache);
3290 printf_filtered ("Source files for which symbols have been read in:\n\n");
3293 ALL_SYMTABS (objfile, s)
3295 const char *fullname = symtab_to_fullname (s);
3297 output_source_filename (fullname ? fullname : s->filename, &data);
3299 printf_filtered ("\n\n");
3301 printf_filtered ("Source files for which symbols "
3302 "will be read in on demand:\n\n");
3304 clear_filename_seen_cache (data.filename_seen_cache);
3306 map_partial_symbol_filenames (output_partial_symbol_filename, &data,
3307 1 /*need_fullname*/);
3308 printf_filtered ("\n");
3310 do_cleanups (cleanups);
3314 file_matches (const char *file, char *files[], int nfiles)
3318 if (file != NULL && nfiles != 0)
3320 for (i = 0; i < nfiles; i++)
3322 if (filename_cmp (files[i], lbasename (file)) == 0)
3326 else if (nfiles == 0)
3331 /* Free any memory associated with a search. */
3334 free_search_symbols (struct symbol_search *symbols)
3336 struct symbol_search *p;
3337 struct symbol_search *next;
3339 for (p = symbols; p != NULL; p = next)
3347 do_free_search_symbols_cleanup (void *symbols)
3349 free_search_symbols (symbols);
3353 make_cleanup_free_search_symbols (struct symbol_search *symbols)
3355 return make_cleanup (do_free_search_symbols_cleanup, symbols);
3358 /* Helper function for sort_search_symbols and qsort. Can only
3359 sort symbols, not minimal symbols. */
3362 compare_search_syms (const void *sa, const void *sb)
3364 struct symbol_search **sym_a = (struct symbol_search **) sa;
3365 struct symbol_search **sym_b = (struct symbol_search **) sb;
3367 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
3368 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
3371 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
3372 prevtail where it is, but update its next pointer to point to
3373 the first of the sorted symbols. */
3375 static struct symbol_search *
3376 sort_search_symbols (struct symbol_search *prevtail, int nfound)
3378 struct symbol_search **symbols, *symp, *old_next;
3381 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
3383 symp = prevtail->next;
3384 for (i = 0; i < nfound; i++)
3389 /* Generally NULL. */
3392 qsort (symbols, nfound, sizeof (struct symbol_search *),
3393 compare_search_syms);
3396 for (i = 0; i < nfound; i++)
3398 symp->next = symbols[i];
3401 symp->next = old_next;
3407 /* An object of this type is passed as the user_data to the
3408 expand_symtabs_matching method. */
3409 struct search_symbols_data
3414 /* It is true if PREG contains valid data, false otherwise. */
3415 unsigned preg_p : 1;
3419 /* A callback for expand_symtabs_matching. */
3422 search_symbols_file_matches (const char *filename, void *user_data)
3424 struct search_symbols_data *data = user_data;
3426 return file_matches (filename, data->files, data->nfiles);
3429 /* A callback for expand_symtabs_matching. */
3432 search_symbols_name_matches (const char *symname, void *user_data)
3434 struct search_symbols_data *data = user_data;
3436 return !data->preg_p || regexec (&data->preg, symname, 0, NULL, 0) == 0;
3439 /* Search the symbol table for matches to the regular expression REGEXP,
3440 returning the results in *MATCHES.
3442 Only symbols of KIND are searched:
3443 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3444 and constants (enums)
3445 FUNCTIONS_DOMAIN - search all functions
3446 TYPES_DOMAIN - search all type names
3447 ALL_DOMAIN - an internal error for this function
3449 free_search_symbols should be called when *MATCHES is no longer needed.
3451 The results are sorted locally; each symtab's global and static blocks are
3452 separately alphabetized. */
3455 search_symbols (char *regexp, enum search_domain kind,
3456 int nfiles, char *files[],
3457 struct symbol_search **matches)
3460 struct blockvector *bv;
3463 struct block_iterator iter;
3465 struct objfile *objfile;
3466 struct minimal_symbol *msymbol;
3468 static const enum minimal_symbol_type types[]
3469 = {mst_data, mst_text, mst_abs};
3470 static const enum minimal_symbol_type types2[]
3471 = {mst_bss, mst_file_text, mst_abs};
3472 static const enum minimal_symbol_type types3[]
3473 = {mst_file_data, mst_solib_trampoline, mst_abs};
3474 static const enum minimal_symbol_type types4[]
3475 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
3476 enum minimal_symbol_type ourtype;
3477 enum minimal_symbol_type ourtype2;
3478 enum minimal_symbol_type ourtype3;
3479 enum minimal_symbol_type ourtype4;
3480 struct symbol_search *sr;
3481 struct symbol_search *psr;
3482 struct symbol_search *tail;
3483 struct search_symbols_data datum;
3485 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3486 CLEANUP_CHAIN is freed only in the case of an error. */
3487 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3488 struct cleanup *retval_chain;
3490 gdb_assert (kind <= TYPES_DOMAIN);
3492 ourtype = types[kind];
3493 ourtype2 = types2[kind];
3494 ourtype3 = types3[kind];
3495 ourtype4 = types4[kind];
3497 sr = *matches = NULL;
3503 /* Make sure spacing is right for C++ operators.
3504 This is just a courtesy to make the matching less sensitive
3505 to how many spaces the user leaves between 'operator'
3506 and <TYPENAME> or <OPERATOR>. */
3508 char *opname = operator_chars (regexp, &opend);
3513 int fix = -1; /* -1 means ok; otherwise number of
3516 if (isalpha (*opname) || *opname == '_' || *opname == '$')
3518 /* There should 1 space between 'operator' and 'TYPENAME'. */
3519 if (opname[-1] != ' ' || opname[-2] == ' ')
3524 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3525 if (opname[-1] == ' ')
3528 /* If wrong number of spaces, fix it. */
3531 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
3533 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
3538 errcode = regcomp (&datum.preg, regexp,
3539 REG_NOSUB | (case_sensitivity == case_sensitive_off
3543 char *err = get_regcomp_error (errcode, &datum.preg);
3545 make_cleanup (xfree, err);
3546 error (_("Invalid regexp (%s): %s"), err, regexp);
3549 make_regfree_cleanup (&datum.preg);
3552 /* Search through the partial symtabs *first* for all symbols
3553 matching the regexp. That way we don't have to reproduce all of
3554 the machinery below. */
3556 datum.nfiles = nfiles;
3557 datum.files = files;
3558 ALL_OBJFILES (objfile)
3561 objfile->sf->qf->expand_symtabs_matching (objfile,
3564 : search_symbols_file_matches),
3565 search_symbols_name_matches,
3570 retval_chain = old_chain;
3572 /* Here, we search through the minimal symbol tables for functions
3573 and variables that match, and force their symbols to be read.
3574 This is in particular necessary for demangled variable names,
3575 which are no longer put into the partial symbol tables.
3576 The symbol will then be found during the scan of symtabs below.
3578 For functions, find_pc_symtab should succeed if we have debug info
3579 for the function, for variables we have to call
3580 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3582 If the lookup fails, set found_misc so that we will rescan to print
3583 any matching symbols without debug info.
3584 We only search the objfile the msymbol came from, we no longer search
3585 all objfiles. In large programs (1000s of shared libs) searching all
3586 objfiles is not worth the pain. */
3588 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
3590 ALL_MSYMBOLS (objfile, msymbol)
3594 if (msymbol->created_by_gdb)
3597 if (MSYMBOL_TYPE (msymbol) == ourtype
3598 || MSYMBOL_TYPE (msymbol) == ourtype2
3599 || MSYMBOL_TYPE (msymbol) == ourtype3
3600 || MSYMBOL_TYPE (msymbol) == ourtype4)
3603 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3606 /* Note: An important side-effect of these lookup functions
3607 is to expand the symbol table if msymbol is found, for the
3608 benefit of the next loop on ALL_PRIMARY_SYMTABS. */
3609 if (kind == FUNCTIONS_DOMAIN
3610 ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL
3611 : (lookup_symbol_in_objfile_from_linkage_name
3612 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3620 ALL_PRIMARY_SYMTABS (objfile, s)
3622 bv = BLOCKVECTOR (s);
3623 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3625 struct symbol_search *prevtail = tail;
3628 b = BLOCKVECTOR_BLOCK (bv, i);
3629 ALL_BLOCK_SYMBOLS (b, iter, sym)
3631 struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
3635 if (file_matches (real_symtab->filename, files, nfiles)
3637 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
3639 && ((kind == VARIABLES_DOMAIN
3640 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3641 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
3642 && SYMBOL_CLASS (sym) != LOC_BLOCK
3643 /* LOC_CONST can be used for more than just enums,
3644 e.g., c++ static const members.
3645 We only want to skip enums here. */
3646 && !(SYMBOL_CLASS (sym) == LOC_CONST
3647 && TYPE_CODE (SYMBOL_TYPE (sym))
3649 || (kind == FUNCTIONS_DOMAIN
3650 && SYMBOL_CLASS (sym) == LOC_BLOCK)
3651 || (kind == TYPES_DOMAIN
3652 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
3655 psr = (struct symbol_search *)
3656 xmalloc (sizeof (struct symbol_search));
3658 psr->symtab = real_symtab;
3660 psr->msymbol = NULL;
3672 if (prevtail == NULL)
3674 struct symbol_search dummy;
3677 tail = sort_search_symbols (&dummy, nfound);
3680 make_cleanup_free_search_symbols (sr);
3683 tail = sort_search_symbols (prevtail, nfound);
3688 /* If there are no eyes, avoid all contact. I mean, if there are
3689 no debug symbols, then print directly from the msymbol_vector. */
3691 if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
3693 ALL_MSYMBOLS (objfile, msymbol)
3697 if (msymbol->created_by_gdb)
3700 if (MSYMBOL_TYPE (msymbol) == ourtype
3701 || MSYMBOL_TYPE (msymbol) == ourtype2
3702 || MSYMBOL_TYPE (msymbol) == ourtype3
3703 || MSYMBOL_TYPE (msymbol) == ourtype4)
3706 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3709 /* For functions we can do a quick check of whether the
3710 symbol might be found via find_pc_symtab. */
3711 if (kind != FUNCTIONS_DOMAIN
3712 || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
3714 if (lookup_symbol_in_objfile_from_linkage_name
3715 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3719 psr = (struct symbol_search *)
3720 xmalloc (sizeof (struct symbol_search));
3722 psr->msymbol = msymbol;
3729 make_cleanup_free_search_symbols (sr);
3741 discard_cleanups (retval_chain);
3742 do_cleanups (old_chain);
3746 /* Helper function for symtab_symbol_info, this function uses
3747 the data returned from search_symbols() to print information
3748 regarding the match to gdb_stdout. */
3751 print_symbol_info (enum search_domain kind,
3752 struct symtab *s, struct symbol *sym,
3753 int block, char *last)
3755 if (last == NULL || filename_cmp (last, s->filename) != 0)
3757 fputs_filtered ("\nFile ", gdb_stdout);
3758 fputs_filtered (s->filename, gdb_stdout);
3759 fputs_filtered (":\n", gdb_stdout);
3762 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
3763 printf_filtered ("static ");
3765 /* Typedef that is not a C++ class. */
3766 if (kind == TYPES_DOMAIN
3767 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
3768 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
3769 /* variable, func, or typedef-that-is-c++-class. */
3770 else if (kind < TYPES_DOMAIN
3771 || (kind == TYPES_DOMAIN
3772 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
3774 type_print (SYMBOL_TYPE (sym),
3775 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3776 ? "" : SYMBOL_PRINT_NAME (sym)),
3779 printf_filtered (";\n");
3783 /* This help function for symtab_symbol_info() prints information
3784 for non-debugging symbols to gdb_stdout. */
3787 print_msymbol_info (struct minimal_symbol *msymbol)
3789 struct gdbarch *gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
3792 if (gdbarch_addr_bit (gdbarch) <= 32)
3793 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3794 & (CORE_ADDR) 0xffffffff,
3797 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3799 printf_filtered ("%s %s\n",
3800 tmp, SYMBOL_PRINT_NAME (msymbol));
3803 /* This is the guts of the commands "info functions", "info types", and
3804 "info variables". It calls search_symbols to find all matches and then
3805 print_[m]symbol_info to print out some useful information about the
3809 symtab_symbol_info (char *regexp, enum search_domain kind, int from_tty)
3811 static const char * const classnames[] =
3812 {"variable", "function", "type"};
3813 struct symbol_search *symbols;
3814 struct symbol_search *p;
3815 struct cleanup *old_chain;
3816 char *last_filename = NULL;
3819 gdb_assert (kind <= TYPES_DOMAIN);
3821 /* Must make sure that if we're interrupted, symbols gets freed. */
3822 search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
3823 old_chain = make_cleanup_free_search_symbols (symbols);
3826 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3827 classnames[kind], regexp);
3829 printf_filtered (_("All defined %ss:\n"), classnames[kind]);
3831 for (p = symbols; p != NULL; p = p->next)
3835 if (p->msymbol != NULL)
3839 printf_filtered (_("\nNon-debugging symbols:\n"));
3842 print_msymbol_info (p->msymbol);
3846 print_symbol_info (kind,
3851 last_filename = p->symtab->filename;
3855 do_cleanups (old_chain);
3859 variables_info (char *regexp, int from_tty)
3861 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
3865 functions_info (char *regexp, int from_tty)
3867 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
3872 types_info (char *regexp, int from_tty)
3874 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
3877 /* Breakpoint all functions matching regular expression. */
3880 rbreak_command_wrapper (char *regexp, int from_tty)
3882 rbreak_command (regexp, from_tty);
3885 /* A cleanup function that calls end_rbreak_breakpoints. */
3888 do_end_rbreak_breakpoints (void *ignore)
3890 end_rbreak_breakpoints ();
3894 rbreak_command (char *regexp, int from_tty)
3896 struct symbol_search *ss;
3897 struct symbol_search *p;
3898 struct cleanup *old_chain;
3899 char *string = NULL;
3901 char **files = NULL, *file_name;
3906 char *colon = strchr (regexp, ':');
3908 if (colon && *(colon + 1) != ':')
3912 colon_index = colon - regexp;
3913 file_name = alloca (colon_index + 1);
3914 memcpy (file_name, regexp, colon_index);
3915 file_name[colon_index--] = 0;
3916 while (isspace (file_name[colon_index]))
3917 file_name[colon_index--] = 0;
3921 while (isspace (*regexp)) regexp++;
3925 search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
3926 old_chain = make_cleanup_free_search_symbols (ss);
3927 make_cleanup (free_current_contents, &string);
3929 start_rbreak_breakpoints ();
3930 make_cleanup (do_end_rbreak_breakpoints, NULL);
3931 for (p = ss; p != NULL; p = p->next)
3933 if (p->msymbol == NULL)
3935 int newlen = (strlen (p->symtab->filename)
3936 + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3941 string = xrealloc (string, newlen);
3944 strcpy (string, p->symtab->filename);
3945 strcat (string, ":'");
3946 strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
3947 strcat (string, "'");
3948 break_command (string, from_tty);
3949 print_symbol_info (FUNCTIONS_DOMAIN,
3953 p->symtab->filename);
3957 int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
3961 string = xrealloc (string, newlen);
3964 strcpy (string, "'");
3965 strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol));
3966 strcat (string, "'");
3968 break_command (string, from_tty);
3969 printf_filtered ("<function, no debug info> %s;\n",
3970 SYMBOL_PRINT_NAME (p->msymbol));
3974 do_cleanups (old_chain);
3978 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3980 Either sym_text[sym_text_len] != '(' and then we search for any
3981 symbol starting with SYM_TEXT text.
3983 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3984 be terminated at that point. Partial symbol tables do not have parameters
3988 compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
3990 int (*ncmp) (const char *, const char *, size_t);
3992 ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
3994 if (ncmp (name, sym_text, sym_text_len) != 0)
3997 if (sym_text[sym_text_len] == '(')
3999 /* User searches for `name(someth...'. Require NAME to be terminated.
4000 Normally psymtabs and gdbindex have no parameter types so '\0' will be
4001 present but accept even parameters presence. In this case this
4002 function is in fact strcmp_iw but whitespace skipping is not supported
4003 for tab completion. */
4005 if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
4012 /* Free any memory associated with a completion list. */
4015 free_completion_list (VEC (char_ptr) **list_ptr)
4020 for (i = 0; VEC_iterate (char_ptr, *list_ptr, i, p); ++i)
4022 VEC_free (char_ptr, *list_ptr);
4025 /* Callback for make_cleanup. */
4028 do_free_completion_list (void *list)
4030 free_completion_list (list);
4033 /* Helper routine for make_symbol_completion_list. */
4035 static VEC (char_ptr) *return_val;
4037 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4038 completion_list_add_name \
4039 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4041 /* Test to see if the symbol specified by SYMNAME (which is already
4042 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4043 characters. If so, add it to the current completion list. */
4046 completion_list_add_name (const char *symname,
4047 const char *sym_text, int sym_text_len,
4048 const char *text, const char *word)
4052 /* Clip symbols that cannot match. */
4053 if (!compare_symbol_name (symname, sym_text, sym_text_len))
4056 /* We have a match for a completion, so add SYMNAME to the current list
4057 of matches. Note that the name is moved to freshly malloc'd space. */
4062 if (word == sym_text)
4064 new = xmalloc (strlen (symname) + 5);
4065 strcpy (new, symname);
4067 else if (word > sym_text)
4069 /* Return some portion of symname. */
4070 new = xmalloc (strlen (symname) + 5);
4071 strcpy (new, symname + (word - sym_text));
4075 /* Return some of SYM_TEXT plus symname. */
4076 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
4077 strncpy (new, word, sym_text - word);
4078 new[sym_text - word] = '\0';
4079 strcat (new, symname);
4082 VEC_safe_push (char_ptr, return_val, new);
4086 /* ObjC: In case we are completing on a selector, look as the msymbol
4087 again and feed all the selectors into the mill. */
4090 completion_list_objc_symbol (struct minimal_symbol *msymbol,
4091 const char *sym_text, int sym_text_len,
4092 const char *text, const char *word)
4094 static char *tmp = NULL;
4095 static unsigned int tmplen = 0;
4097 const char *method, *category, *selector;
4100 method = SYMBOL_NATURAL_NAME (msymbol);
4102 /* Is it a method? */
4103 if ((method[0] != '-') && (method[0] != '+'))
4106 if (sym_text[0] == '[')
4107 /* Complete on shortened method method. */
4108 completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
4110 while ((strlen (method) + 1) >= tmplen)
4116 tmp = xrealloc (tmp, tmplen);
4118 selector = strchr (method, ' ');
4119 if (selector != NULL)
4122 category = strchr (method, '(');
4124 if ((category != NULL) && (selector != NULL))
4126 memcpy (tmp, method, (category - method));
4127 tmp[category - method] = ' ';
4128 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4129 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4130 if (sym_text[0] == '[')
4131 completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
4134 if (selector != NULL)
4136 /* Complete on selector only. */
4137 strcpy (tmp, selector);
4138 tmp2 = strchr (tmp, ']');
4142 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4146 /* Break the non-quoted text based on the characters which are in
4147 symbols. FIXME: This should probably be language-specific. */
4150 language_search_unquoted_string (char *text, char *p)
4152 for (; p > text; --p)
4154 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4158 if ((current_language->la_language == language_objc))
4160 if (p[-1] == ':') /* Might be part of a method name. */
4162 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
4163 p -= 2; /* Beginning of a method name. */
4164 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
4165 { /* Might be part of a method name. */
4168 /* Seeing a ' ' or a '(' is not conclusive evidence
4169 that we are in the middle of a method name. However,
4170 finding "-[" or "+[" should be pretty un-ambiguous.
4171 Unfortunately we have to find it now to decide. */
4174 if (isalnum (t[-1]) || t[-1] == '_' ||
4175 t[-1] == ' ' || t[-1] == ':' ||
4176 t[-1] == '(' || t[-1] == ')')
4181 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
4182 p = t - 2; /* Method name detected. */
4183 /* Else we leave with p unchanged. */
4193 completion_list_add_fields (struct symbol *sym, char *sym_text,
4194 int sym_text_len, char *text, char *word)
4196 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4198 struct type *t = SYMBOL_TYPE (sym);
4199 enum type_code c = TYPE_CODE (t);
4202 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4203 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4204 if (TYPE_FIELD_NAME (t, j))
4205 completion_list_add_name (TYPE_FIELD_NAME (t, j),
4206 sym_text, sym_text_len, text, word);
4210 /* Type of the user_data argument passed to add_macro_name or
4211 expand_partial_symbol_name. The contents are simply whatever is
4212 needed by completion_list_add_name. */
4213 struct add_name_data
4221 /* A callback used with macro_for_each and macro_for_each_in_scope.
4222 This adds a macro's name to the current completion list. */
4225 add_macro_name (const char *name, const struct macro_definition *ignore,
4226 struct macro_source_file *ignore2, int ignore3,
4229 struct add_name_data *datum = (struct add_name_data *) user_data;
4231 completion_list_add_name ((char *) name,
4232 datum->sym_text, datum->sym_text_len,
4233 datum->text, datum->word);
4236 /* A callback for expand_partial_symbol_names. */
4239 expand_partial_symbol_name (const char *name, void *user_data)
4241 struct add_name_data *datum = (struct add_name_data *) user_data;
4243 return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
4247 default_make_symbol_completion_list_break_on (char *text, char *word,
4248 const char *break_on,
4249 enum type_code code)
4251 /* Problem: All of the symbols have to be copied because readline
4252 frees them. I'm not going to worry about this; hopefully there
4253 won't be that many. */
4257 struct minimal_symbol *msymbol;
4258 struct objfile *objfile;
4260 const struct block *surrounding_static_block, *surrounding_global_block;
4261 struct block_iterator iter;
4262 /* The symbol we are completing on. Points in same buffer as text. */
4264 /* Length of sym_text. */
4266 struct add_name_data datum;
4267 struct cleanup *back_to;
4269 /* Now look for the symbol we are supposed to complete on. */
4273 char *quote_pos = NULL;
4275 /* First see if this is a quoted string. */
4277 for (p = text; *p != '\0'; ++p)
4279 if (quote_found != '\0')
4281 if (*p == quote_found)
4282 /* Found close quote. */
4284 else if (*p == '\\' && p[1] == quote_found)
4285 /* A backslash followed by the quote character
4286 doesn't end the string. */
4289 else if (*p == '\'' || *p == '"')
4295 if (quote_found == '\'')
4296 /* A string within single quotes can be a symbol, so complete on it. */
4297 sym_text = quote_pos + 1;
4298 else if (quote_found == '"')
4299 /* A double-quoted string is never a symbol, nor does it make sense
4300 to complete it any other way. */
4306 /* It is not a quoted string. Break it based on the characters
4307 which are in symbols. */
4310 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
4311 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
4320 sym_text_len = strlen (sym_text);
4322 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4324 if (current_language->la_language == language_cplus
4325 || current_language->la_language == language_java
4326 || current_language->la_language == language_fortran)
4328 /* These languages may have parameters entered by user but they are never
4329 present in the partial symbol tables. */
4331 const char *cs = memchr (sym_text, '(', sym_text_len);
4334 sym_text_len = cs - sym_text;
4336 gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
4339 back_to = make_cleanup (do_free_completion_list, &return_val);
4341 datum.sym_text = sym_text;
4342 datum.sym_text_len = sym_text_len;
4346 /* Look through the partial symtabs for all symbols which begin
4347 by matching SYM_TEXT. Expand all CUs that you find to the list.
4348 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4349 expand_partial_symbol_names (expand_partial_symbol_name, &datum);
4351 /* At this point scan through the misc symbol vectors and add each
4352 symbol you find to the list. Eventually we want to ignore
4353 anything that isn't a text symbol (everything else will be
4354 handled by the psymtab code above). */
4356 if (code == TYPE_CODE_UNDEF)
4358 ALL_MSYMBOLS (objfile, msymbol)
4361 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
4364 completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text,
4369 /* Search upwards from currently selected frame (so that we can
4370 complete on local vars). Also catch fields of types defined in
4371 this places which match our text string. Only complete on types
4372 visible from current context. */
4374 b = get_selected_block (0);
4375 surrounding_static_block = block_static_block (b);
4376 surrounding_global_block = block_global_block (b);
4377 if (surrounding_static_block != NULL)
4378 while (b != surrounding_static_block)
4382 ALL_BLOCK_SYMBOLS (b, iter, sym)
4384 if (code == TYPE_CODE_UNDEF)
4386 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4388 completion_list_add_fields (sym, sym_text, sym_text_len, text,
4391 else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4392 && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
4393 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4397 /* Stop when we encounter an enclosing function. Do not stop for
4398 non-inlined functions - the locals of the enclosing function
4399 are in scope for a nested function. */
4400 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
4402 b = BLOCK_SUPERBLOCK (b);
4405 /* Add fields from the file's types; symbols will be added below. */
4407 if (code == TYPE_CODE_UNDEF)
4409 if (surrounding_static_block != NULL)
4410 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
4411 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4413 if (surrounding_global_block != NULL)
4414 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
4415 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4418 /* Go through the symtabs and check the externs and statics for
4419 symbols which match. */
4421 ALL_PRIMARY_SYMTABS (objfile, s)
4424 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4425 ALL_BLOCK_SYMBOLS (b, iter, sym)
4427 if (code == TYPE_CODE_UNDEF
4428 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4429 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4430 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4434 ALL_PRIMARY_SYMTABS (objfile, s)
4437 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4438 ALL_BLOCK_SYMBOLS (b, iter, sym)
4440 if (code == TYPE_CODE_UNDEF
4441 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4442 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4443 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4447 /* Skip macros if we are completing a struct tag -- arguable but
4448 usually what is expected. */
4449 if (current_language->la_macro_expansion == macro_expansion_c
4450 && code == TYPE_CODE_UNDEF)
4452 struct macro_scope *scope;
4454 /* Add any macros visible in the default scope. Note that this
4455 may yield the occasional wrong result, because an expression
4456 might be evaluated in a scope other than the default. For
4457 example, if the user types "break file:line if <TAB>", the
4458 resulting expression will be evaluated at "file:line" -- but
4459 at there does not seem to be a way to detect this at
4461 scope = default_macro_scope ();
4464 macro_for_each_in_scope (scope->file, scope->line,
4465 add_macro_name, &datum);
4469 /* User-defined macros are always visible. */
4470 macro_for_each (macro_user_macros, add_macro_name, &datum);
4473 discard_cleanups (back_to);
4474 return (return_val);
4478 default_make_symbol_completion_list (char *text, char *word,
4479 enum type_code code)
4481 return default_make_symbol_completion_list_break_on (text, word, "", code);
4484 /* Return a vector of all symbols (regardless of class) which begin by
4485 matching TEXT. If the answer is no symbols, then the return value
4489 make_symbol_completion_list (char *text, char *word)
4491 return current_language->la_make_symbol_completion_list (text, word,
4495 /* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4496 symbols whose type code is CODE. */
4499 make_symbol_completion_type (char *text, char *word, enum type_code code)
4501 gdb_assert (code == TYPE_CODE_UNION
4502 || code == TYPE_CODE_STRUCT
4503 || code == TYPE_CODE_CLASS
4504 || code == TYPE_CODE_ENUM);
4505 return current_language->la_make_symbol_completion_list (text, word, code);
4508 /* Like make_symbol_completion_list, but suitable for use as a
4509 completion function. */
4512 make_symbol_completion_list_fn (struct cmd_list_element *ignore,
4513 char *text, char *word)
4515 return make_symbol_completion_list (text, word);
4518 /* Like make_symbol_completion_list, but returns a list of symbols
4519 defined in a source file FILE. */
4522 make_file_symbol_completion_list (char *text, char *word, char *srcfile)
4527 struct block_iterator iter;
4528 /* The symbol we are completing on. Points in same buffer as text. */
4530 /* Length of sym_text. */
4533 /* Now look for the symbol we are supposed to complete on.
4534 FIXME: This should be language-specific. */
4538 char *quote_pos = NULL;
4540 /* First see if this is a quoted string. */
4542 for (p = text; *p != '\0'; ++p)
4544 if (quote_found != '\0')
4546 if (*p == quote_found)
4547 /* Found close quote. */
4549 else if (*p == '\\' && p[1] == quote_found)
4550 /* A backslash followed by the quote character
4551 doesn't end the string. */
4554 else if (*p == '\'' || *p == '"')
4560 if (quote_found == '\'')
4561 /* A string within single quotes can be a symbol, so complete on it. */
4562 sym_text = quote_pos + 1;
4563 else if (quote_found == '"')
4564 /* A double-quoted string is never a symbol, nor does it make sense
4565 to complete it any other way. */
4571 /* Not a quoted string. */
4572 sym_text = language_search_unquoted_string (text, p);
4576 sym_text_len = strlen (sym_text);
4580 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4582 s = lookup_symtab (srcfile);
4585 /* Maybe they typed the file with leading directories, while the
4586 symbol tables record only its basename. */
4587 const char *tail = lbasename (srcfile);
4590 s = lookup_symtab (tail);
4593 /* If we have no symtab for that file, return an empty list. */
4595 return (return_val);
4597 /* Go through this symtab and check the externs and statics for
4598 symbols which match. */
4600 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4601 ALL_BLOCK_SYMBOLS (b, iter, sym)
4603 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4606 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4607 ALL_BLOCK_SYMBOLS (b, iter, sym)
4609 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4612 return (return_val);
4615 /* A helper function for make_source_files_completion_list. It adds
4616 another file name to a list of possible completions, growing the
4617 list as necessary. */
4620 add_filename_to_list (const char *fname, char *text, char *word,
4621 VEC (char_ptr) **list)
4624 size_t fnlen = strlen (fname);
4628 /* Return exactly fname. */
4629 new = xmalloc (fnlen + 5);
4630 strcpy (new, fname);
4632 else if (word > text)
4634 /* Return some portion of fname. */
4635 new = xmalloc (fnlen + 5);
4636 strcpy (new, fname + (word - text));
4640 /* Return some of TEXT plus fname. */
4641 new = xmalloc (fnlen + (text - word) + 5);
4642 strncpy (new, word, text - word);
4643 new[text - word] = '\0';
4644 strcat (new, fname);
4646 VEC_safe_push (char_ptr, *list, new);
4650 not_interesting_fname (const char *fname)
4652 static const char *illegal_aliens[] = {
4653 "_globals_", /* inserted by coff_symtab_read */
4658 for (i = 0; illegal_aliens[i]; i++)
4660 if (filename_cmp (fname, illegal_aliens[i]) == 0)
4666 /* An object of this type is passed as the user_data argument to
4667 map_partial_symbol_filenames. */
4668 struct add_partial_filename_data
4670 struct filename_seen_cache *filename_seen_cache;
4674 VEC (char_ptr) **list;
4677 /* A callback for map_partial_symbol_filenames. */
4680 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
4683 struct add_partial_filename_data *data = user_data;
4685 if (not_interesting_fname (filename))
4687 if (!filename_seen (data->filename_seen_cache, filename, 1)
4688 && filename_ncmp (filename, data->text, data->text_len) == 0)
4690 /* This file matches for a completion; add it to the
4691 current list of matches. */
4692 add_filename_to_list (filename, data->text, data->word, data->list);
4696 const char *base_name = lbasename (filename);
4698 if (base_name != filename
4699 && !filename_seen (data->filename_seen_cache, base_name, 1)
4700 && filename_ncmp (base_name, data->text, data->text_len) == 0)
4701 add_filename_to_list (base_name, data->text, data->word, data->list);
4705 /* Return a vector of all source files whose names begin with matching
4706 TEXT. The file names are looked up in the symbol tables of this
4707 program. If the answer is no matchess, then the return value is
4711 make_source_files_completion_list (char *text, char *word)
4714 struct objfile *objfile;
4715 size_t text_len = strlen (text);
4716 VEC (char_ptr) *list = NULL;
4717 const char *base_name;
4718 struct add_partial_filename_data datum;
4719 struct filename_seen_cache *filename_seen_cache;
4720 struct cleanup *back_to, *cache_cleanup;
4722 if (!have_full_symbols () && !have_partial_symbols ())
4725 back_to = make_cleanup (do_free_completion_list, &list);
4727 filename_seen_cache = create_filename_seen_cache ();
4728 cache_cleanup = make_cleanup (delete_filename_seen_cache,
4729 filename_seen_cache);
4731 ALL_SYMTABS (objfile, s)
4733 if (not_interesting_fname (s->filename))
4735 if (!filename_seen (filename_seen_cache, s->filename, 1)
4736 && filename_ncmp (s->filename, text, text_len) == 0)
4738 /* This file matches for a completion; add it to the current
4740 add_filename_to_list (s->filename, text, word, &list);
4744 /* NOTE: We allow the user to type a base name when the
4745 debug info records leading directories, but not the other
4746 way around. This is what subroutines of breakpoint
4747 command do when they parse file names. */
4748 base_name = lbasename (s->filename);
4749 if (base_name != s->filename
4750 && !filename_seen (filename_seen_cache, base_name, 1)
4751 && filename_ncmp (base_name, text, text_len) == 0)
4752 add_filename_to_list (base_name, text, word, &list);
4756 datum.filename_seen_cache = filename_seen_cache;
4759 datum.text_len = text_len;
4761 map_partial_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
4762 0 /*need_fullname*/);
4764 do_cleanups (cache_cleanup);
4765 discard_cleanups (back_to);
4770 /* Determine if PC is in the prologue of a function. The prologue is the area
4771 between the first instruction of a function, and the first executable line.
4772 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4774 If non-zero, func_start is where we think the prologue starts, possibly
4775 by previous examination of symbol table information. */
4778 in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
4780 struct symtab_and_line sal;
4781 CORE_ADDR func_addr, func_end;
4783 /* We have several sources of information we can consult to figure
4785 - Compilers usually emit line number info that marks the prologue
4786 as its own "source line". So the ending address of that "line"
4787 is the end of the prologue. If available, this is the most
4789 - The minimal symbols and partial symbols, which can usually tell
4790 us the starting and ending addresses of a function.
4791 - If we know the function's start address, we can call the
4792 architecture-defined gdbarch_skip_prologue function to analyze the
4793 instruction stream and guess where the prologue ends.
4794 - Our `func_start' argument; if non-zero, this is the caller's
4795 best guess as to the function's entry point. At the time of
4796 this writing, handle_inferior_event doesn't get this right, so
4797 it should be our last resort. */
4799 /* Consult the partial symbol table, to find which function
4801 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4803 CORE_ADDR prologue_end;
4805 /* We don't even have minsym information, so fall back to using
4806 func_start, if given. */
4808 return 1; /* We *might* be in a prologue. */
4810 prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
4812 return func_start <= pc && pc < prologue_end;
4815 /* If we have line number information for the function, that's
4816 usually pretty reliable. */
4817 sal = find_pc_line (func_addr, 0);
4819 /* Now sal describes the source line at the function's entry point,
4820 which (by convention) is the prologue. The end of that "line",
4821 sal.end, is the end of the prologue.
4823 Note that, for functions whose source code is all on a single
4824 line, the line number information doesn't always end up this way.
4825 So we must verify that our purported end-of-prologue address is
4826 *within* the function, not at its start or end. */
4828 || sal.end <= func_addr
4829 || func_end <= sal.end)
4831 /* We don't have any good line number info, so use the minsym
4832 information, together with the architecture-specific prologue
4834 CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
4836 return func_addr <= pc && pc < prologue_end;
4839 /* We have line number info, and it looks good. */
4840 return func_addr <= pc && pc < sal.end;
4843 /* Given PC at the function's start address, attempt to find the
4844 prologue end using SAL information. Return zero if the skip fails.
4846 A non-optimized prologue traditionally has one SAL for the function
4847 and a second for the function body. A single line function has
4848 them both pointing at the same line.
4850 An optimized prologue is similar but the prologue may contain
4851 instructions (SALs) from the instruction body. Need to skip those
4852 while not getting into the function body.
4854 The functions end point and an increasing SAL line are used as
4855 indicators of the prologue's endpoint.
4857 This code is based on the function refine_prologue_limit
4861 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
4863 struct symtab_and_line prologue_sal;
4868 /* Get an initial range for the function. */
4869 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
4870 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
4872 prologue_sal = find_pc_line (start_pc, 0);
4873 if (prologue_sal.line != 0)
4875 /* For languages other than assembly, treat two consecutive line
4876 entries at the same address as a zero-instruction prologue.
4877 The GNU assembler emits separate line notes for each instruction
4878 in a multi-instruction macro, but compilers generally will not
4880 if (prologue_sal.symtab->language != language_asm)
4882 struct linetable *linetable = LINETABLE (prologue_sal.symtab);
4885 /* Skip any earlier lines, and any end-of-sequence marker
4886 from a previous function. */
4887 while (linetable->item[idx].pc != prologue_sal.pc
4888 || linetable->item[idx].line == 0)
4891 if (idx+1 < linetable->nitems
4892 && linetable->item[idx+1].line != 0
4893 && linetable->item[idx+1].pc == start_pc)
4897 /* If there is only one sal that covers the entire function,
4898 then it is probably a single line function, like
4900 if (prologue_sal.end >= end_pc)
4903 while (prologue_sal.end < end_pc)
4905 struct symtab_and_line sal;
4907 sal = find_pc_line (prologue_sal.end, 0);
4910 /* Assume that a consecutive SAL for the same (or larger)
4911 line mark the prologue -> body transition. */
4912 if (sal.line >= prologue_sal.line)
4915 /* The line number is smaller. Check that it's from the
4916 same function, not something inlined. If it's inlined,
4917 then there is no point comparing the line numbers. */
4918 bl = block_for_pc (prologue_sal.end);
4921 if (block_inlined_p (bl))
4923 if (BLOCK_FUNCTION (bl))
4928 bl = BLOCK_SUPERBLOCK (bl);
4933 /* The case in which compiler's optimizer/scheduler has
4934 moved instructions into the prologue. We look ahead in
4935 the function looking for address ranges whose
4936 corresponding line number is less the first one that we
4937 found for the function. This is more conservative then
4938 refine_prologue_limit which scans a large number of SALs
4939 looking for any in the prologue. */
4944 if (prologue_sal.end < end_pc)
4945 /* Return the end of this line, or zero if we could not find a
4947 return prologue_sal.end;
4949 /* Don't return END_PC, which is past the end of the function. */
4950 return prologue_sal.pc;
4954 static char *name_of_main;
4955 enum language language_of_main = language_unknown;
4958 set_main_name (const char *name)
4960 if (name_of_main != NULL)
4962 xfree (name_of_main);
4963 name_of_main = NULL;
4964 language_of_main = language_unknown;
4968 name_of_main = xstrdup (name);
4969 language_of_main = language_unknown;
4973 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4977 find_main_name (void)
4979 const char *new_main_name;
4981 /* Try to see if the main procedure is in Ada. */
4982 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4983 be to add a new method in the language vector, and call this
4984 method for each language until one of them returns a non-empty
4985 name. This would allow us to remove this hard-coded call to
4986 an Ada function. It is not clear that this is a better approach
4987 at this point, because all methods need to be written in a way
4988 such that false positives never be returned. For instance, it is
4989 important that a method does not return a wrong name for the main
4990 procedure if the main procedure is actually written in a different
4991 language. It is easy to guaranty this with Ada, since we use a
4992 special symbol generated only when the main in Ada to find the name
4993 of the main procedure. It is difficult however to see how this can
4994 be guarantied for languages such as C, for instance. This suggests
4995 that order of call for these methods becomes important, which means
4996 a more complicated approach. */
4997 new_main_name = ada_main_name ();
4998 if (new_main_name != NULL)
5000 set_main_name (new_main_name);
5004 new_main_name = go_main_name ();
5005 if (new_main_name != NULL)
5007 set_main_name (new_main_name);
5011 new_main_name = pascal_main_name ();
5012 if (new_main_name != NULL)
5014 set_main_name (new_main_name);
5018 /* The languages above didn't identify the name of the main procedure.
5019 Fallback to "main". */
5020 set_main_name ("main");
5026 if (name_of_main == NULL)
5029 return name_of_main;
5032 /* Handle ``executable_changed'' events for the symtab module. */
5035 symtab_observer_executable_changed (void)
5037 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5038 set_main_name (NULL);
5041 /* Return 1 if the supplied producer string matches the ARM RealView
5042 compiler (armcc). */
5045 producer_is_realview (const char *producer)
5047 static const char *const arm_idents[] = {
5048 "ARM C Compiler, ADS",
5049 "Thumb C Compiler, ADS",
5050 "ARM C++ Compiler, ADS",
5051 "Thumb C++ Compiler, ADS",
5052 "ARM/Thumb C/C++ Compiler, RVCT",
5053 "ARM C/C++ Compiler, RVCT"
5057 if (producer == NULL)
5060 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5061 if (strncmp (producer, arm_idents[i], strlen (arm_idents[i])) == 0)
5068 _initialize_symtab (void)
5070 add_info ("variables", variables_info, _("\
5071 All global and static variable names, or those matching REGEXP."));
5073 add_com ("whereis", class_info, variables_info, _("\
5074 All global and static variable names, or those matching REGEXP."));
5076 add_info ("functions", functions_info,
5077 _("All function names, or those matching REGEXP."));
5079 /* FIXME: This command has at least the following problems:
5080 1. It prints builtin types (in a very strange and confusing fashion).
5081 2. It doesn't print right, e.g. with
5082 typedef struct foo *FOO
5083 type_print prints "FOO" when we want to make it (in this situation)
5084 print "struct foo *".
5085 I also think "ptype" or "whatis" is more likely to be useful (but if
5086 there is much disagreement "info types" can be fixed). */
5087 add_info ("types", types_info,
5088 _("All type names, or those matching REGEXP."));
5090 add_info ("sources", sources_info,
5091 _("Source files in the program."));
5093 add_com ("rbreak", class_breakpoint, rbreak_command,
5094 _("Set a breakpoint for all functions matching REGEXP."));
5098 add_com ("lf", class_info, sources_info,
5099 _("Source files in the program"));
5100 add_com ("lg", class_info, variables_info, _("\
5101 All global and static variable names, or those matching REGEXP."));
5104 add_setshow_enum_cmd ("multiple-symbols", no_class,
5105 multiple_symbols_modes, &multiple_symbols_mode,
5107 Set the debugger behavior when more than one symbol are possible matches\n\
5108 in an expression."), _("\
5109 Show how the debugger handles ambiguities in expressions."), _("\
5110 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5111 NULL, NULL, &setlist, &showlist);
5113 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5114 &basenames_may_differ, _("\
5115 Set whether a source file may have multiple base names."), _("\
5116 Show whether a source file may have multiple base names."), _("\
5117 (A \"base name\" is the name of a file with the directory part removed.\n\
5118 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5119 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5120 before comparing them. Canonicalization is an expensive operation,\n\
5121 but it allows the same file be known by more than one base name.\n\
5122 If not set (the default), all source files are assumed to have just\n\
5123 one base name, and gdb will do file name comparisons more efficiently."),
5125 &setlist, &showlist);
5127 add_setshow_boolean_cmd ("symtab-create", no_class, &symtab_create_debug,
5128 _("Set debugging of symbol table creation."),
5129 _("Show debugging of symbol table creation."), _("\
5130 When enabled, debugging messages are printed when building symbol tables."),
5133 &setdebuglist, &showdebuglist);
5135 observer_attach_executable_changed (symtab_observer_executable_changed);