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 "call-cmds.h"
31 #include "gdb_regex.h"
32 #include "expression.h"
38 #include "filenames.h" /* for FILENAME_CMP */
39 #include "objc-lang.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
53 #include "gdb_string.h"
57 #include "cp-support.h"
59 #include "gdb_assert.h"
62 #include "macroscope.h"
66 /* Prototypes for local functions */
68 static void completion_list_add_name (char *, char *, int, char *, char *);
70 static void rbreak_command (char *, int);
72 static void types_info (char *, int);
74 static void functions_info (char *, int);
76 static void variables_info (char *, int);
78 static void sources_info (char *, int);
80 static void output_source_filename (const char *, int *);
82 static int find_line_common (struct linetable *, int, int *, int);
84 static struct symbol *lookup_symbol_aux (const char *name,
85 const struct block *block,
86 const domain_enum domain,
87 enum language language,
88 int *is_a_field_of_this);
91 struct symbol *lookup_symbol_aux_local (const char *name,
92 const struct block *block,
93 const domain_enum domain,
94 enum language language);
97 struct symbol *lookup_symbol_aux_symtabs (int block_index,
99 const domain_enum domain);
102 struct symbol *lookup_symbol_aux_quick (struct objfile *objfile,
105 const domain_enum domain);
107 static void print_msymbol_info (struct minimal_symbol *);
109 void _initialize_symtab (void);
113 /* Non-zero if a file may be known by two different basenames.
114 This is the uncommon case, and significantly slows down gdb.
115 Default set to "off" to not slow down the common case. */
116 int basenames_may_differ = 0;
118 /* Allow the user to configure the debugger behavior with respect
119 to multiple-choice menus when more than one symbol matches during
122 const char multiple_symbols_ask[] = "ask";
123 const char multiple_symbols_all[] = "all";
124 const char multiple_symbols_cancel[] = "cancel";
125 static const char *multiple_symbols_modes[] =
127 multiple_symbols_ask,
128 multiple_symbols_all,
129 multiple_symbols_cancel,
132 static const char *multiple_symbols_mode = multiple_symbols_all;
134 /* Read-only accessor to AUTO_SELECT_MODE. */
137 multiple_symbols_select_mode (void)
139 return multiple_symbols_mode;
142 /* Block in which the most recently searched-for symbol was found.
143 Might be better to make this a parameter to lookup_symbol and
146 const struct block *block_found;
148 /* See whether FILENAME matches SEARCH_NAME using the rule that we
149 advertise to the user. (The manual's description of linespecs
150 describes what we advertise). SEARCH_LEN is the length of
151 SEARCH_NAME. We assume that SEARCH_NAME is a relative path.
152 Returns true if they match, false otherwise. */
155 compare_filenames_for_search (const char *filename, const char *search_name,
158 int len = strlen (filename);
161 if (len < search_len)
164 /* The tail of FILENAME must match. */
165 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
168 /* Either the names must completely match, or the character
169 preceding the trailing SEARCH_NAME segment of FILENAME must be a
170 directory separator. */
171 return (len == search_len
172 || IS_DIR_SEPARATOR (filename[len - search_len - 1])
173 || (HAS_DRIVE_SPEC (filename)
174 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
177 /* Check for a symtab of a specific name by searching some symtabs.
178 This is a helper function for callbacks of iterate_over_symtabs.
180 The return value, NAME, FULL_PATH, REAL_PATH, CALLBACK, and DATA
181 are identical to the `map_symtabs_matching_filename' method of
182 quick_symbol_functions.
184 FIRST and AFTER_LAST indicate the range of symtabs to search.
185 AFTER_LAST is one past the last symtab to search; NULL means to
186 search until the end of the list. */
189 iterate_over_some_symtabs (const char *name,
190 const char *full_path,
191 const char *real_path,
192 int (*callback) (struct symtab *symtab,
195 struct symtab *first,
196 struct symtab *after_last)
198 struct symtab *s = NULL;
199 struct cleanup *cleanup;
200 const char* base_name = lbasename (name);
201 int name_len = strlen (name);
202 int is_abs = IS_ABSOLUTE_PATH (name);
204 for (s = first; s != NULL && s != after_last; s = s->next)
206 /* Exact match is always ok. */
207 if (FILENAME_CMP (name, s->filename) == 0)
209 if (callback (s, data))
213 if (!is_abs && compare_filenames_for_search (s->filename, name, name_len))
215 if (callback (s, data))
219 /* Before we invoke realpath, which can get expensive when many
220 files are involved, do a quick comparison of the basenames. */
221 if (! basenames_may_differ
222 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
225 /* If the user gave us an absolute path, try to find the file in
226 this symtab and use its absolute path. */
228 if (full_path != NULL)
230 const char *fp = symtab_to_fullname (s);
232 if (fp != NULL && FILENAME_CMP (full_path, fp) == 0)
234 if (callback (s, data))
238 if (fp != NULL && !is_abs && compare_filenames_for_search (fp, name,
241 if (callback (s, data))
246 if (real_path != NULL)
248 char *fullname = symtab_to_fullname (s);
250 if (fullname != NULL)
252 char *rp = gdb_realpath (fullname);
254 make_cleanup (xfree, rp);
255 if (FILENAME_CMP (real_path, rp) == 0)
257 if (callback (s, data))
261 if (!is_abs && compare_filenames_for_search (rp, name, name_len))
263 if (callback (s, data))
273 /* Check for a symtab of a specific name; first in symtabs, then in
274 psymtabs. *If* there is no '/' in the name, a match after a '/'
275 in the symtab filename will also work.
277 Calls CALLBACK with each symtab that is found and with the supplied
278 DATA. If CALLBACK returns true, the search stops. */
281 iterate_over_symtabs (const char *name,
282 int (*callback) (struct symtab *symtab,
286 struct symtab *s = NULL;
287 struct objfile *objfile;
288 char *real_path = NULL;
289 char *full_path = NULL;
290 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
292 /* Here we are interested in canonicalizing an absolute path, not
293 absolutizing a relative path. */
294 if (IS_ABSOLUTE_PATH (name))
296 full_path = xfullpath (name);
297 make_cleanup (xfree, full_path);
298 real_path = gdb_realpath (name);
299 make_cleanup (xfree, real_path);
302 ALL_OBJFILES (objfile)
304 if (iterate_over_some_symtabs (name, full_path, real_path, callback, data,
305 objfile->symtabs, NULL))
307 do_cleanups (cleanups);
312 /* Same search rules as above apply here, but now we look thru the
315 ALL_OBJFILES (objfile)
318 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
325 do_cleanups (cleanups);
330 do_cleanups (cleanups);
333 /* The callback function used by lookup_symtab. */
336 lookup_symtab_callback (struct symtab *symtab, void *data)
338 struct symtab **result_ptr = data;
340 *result_ptr = symtab;
344 /* A wrapper for iterate_over_symtabs that returns the first matching
348 lookup_symtab (const char *name)
350 struct symtab *result = NULL;
352 iterate_over_symtabs (name, lookup_symtab_callback, &result);
357 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
358 full method name, which consist of the class name (from T), the unadorned
359 method name from METHOD_ID, and the signature for the specific overload,
360 specified by SIGNATURE_ID. Note that this function is g++ specific. */
363 gdb_mangle_name (struct type *type, int method_id, int signature_id)
365 int mangled_name_len;
367 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
368 struct fn_field *method = &f[signature_id];
369 char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
370 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
371 char *newname = type_name_no_tag (type);
373 /* Does the form of physname indicate that it is the full mangled name
374 of a constructor (not just the args)? */
375 int is_full_physname_constructor;
378 int is_destructor = is_destructor_name (physname);
379 /* Need a new type prefix. */
380 char *const_prefix = method->is_const ? "C" : "";
381 char *volatile_prefix = method->is_volatile ? "V" : "";
383 int len = (newname == NULL ? 0 : strlen (newname));
385 /* Nothing to do if physname already contains a fully mangled v3 abi name
386 or an operator name. */
387 if ((physname[0] == '_' && physname[1] == 'Z')
388 || is_operator_name (field_name))
389 return xstrdup (physname);
391 is_full_physname_constructor = is_constructor_name (physname);
393 is_constructor = is_full_physname_constructor
394 || (newname && strcmp (field_name, newname) == 0);
397 is_destructor = (strncmp (physname, "__dt", 4) == 0);
399 if (is_destructor || is_full_physname_constructor)
401 mangled_name = (char *) xmalloc (strlen (physname) + 1);
402 strcpy (mangled_name, physname);
408 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
410 else if (physname[0] == 't' || physname[0] == 'Q')
412 /* The physname for template and qualified methods already includes
414 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
420 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
422 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
423 + strlen (buf) + len + strlen (physname) + 1);
425 mangled_name = (char *) xmalloc (mangled_name_len);
427 mangled_name[0] = '\0';
429 strcpy (mangled_name, field_name);
431 strcat (mangled_name, buf);
432 /* If the class doesn't have a name, i.e. newname NULL, then we just
433 mangle it using 0 for the length of the class. Thus it gets mangled
434 as something starting with `::' rather than `classname::'. */
436 strcat (mangled_name, newname);
438 strcat (mangled_name, physname);
439 return (mangled_name);
442 /* Initialize the cplus_specific structure. 'cplus_specific' should
443 only be allocated for use with cplus symbols. */
446 symbol_init_cplus_specific (struct general_symbol_info *gsymbol,
447 struct objfile *objfile)
449 /* A language_specific structure should not have been previously
451 gdb_assert (gsymbol->language_specific.cplus_specific == NULL);
452 gdb_assert (objfile != NULL);
454 gsymbol->language_specific.cplus_specific =
455 OBSTACK_ZALLOC (&objfile->objfile_obstack, struct cplus_specific);
458 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
459 correctly allocated. For C++ symbols a cplus_specific struct is
460 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
461 OBJFILE can be NULL. */
463 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
465 struct objfile *objfile)
467 if (gsymbol->language == language_cplus)
469 if (gsymbol->language_specific.cplus_specific == NULL)
470 symbol_init_cplus_specific (gsymbol, objfile);
472 gsymbol->language_specific.cplus_specific->demangled_name = name;
475 gsymbol->language_specific.mangled_lang.demangled_name = name;
478 /* Return the demangled name of GSYMBOL. */
480 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
482 if (gsymbol->language == language_cplus)
484 if (gsymbol->language_specific.cplus_specific != NULL)
485 return gsymbol->language_specific.cplus_specific->demangled_name;
490 return gsymbol->language_specific.mangled_lang.demangled_name;
494 /* Initialize the language dependent portion of a symbol
495 depending upon the language for the symbol. */
497 symbol_set_language (struct general_symbol_info *gsymbol,
498 enum language language)
500 gsymbol->language = language;
501 if (gsymbol->language == language_d
502 || gsymbol->language == language_java
503 || gsymbol->language == language_objc
504 || gsymbol->language == language_fortran)
506 symbol_set_demangled_name (gsymbol, NULL, NULL);
508 else if (gsymbol->language == language_cplus)
509 gsymbol->language_specific.cplus_specific = NULL;
512 memset (&gsymbol->language_specific, 0,
513 sizeof (gsymbol->language_specific));
517 /* Functions to initialize a symbol's mangled name. */
519 /* Objects of this type are stored in the demangled name hash table. */
520 struct demangled_name_entry
526 /* 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. */
537 eq_demangled_name_entry (const void *a, const void *b)
539 const struct demangled_name_entry *da = a;
540 const struct demangled_name_entry *db = b;
542 return strcmp (da->mangled, db->mangled) == 0;
545 /* Create the hash table used for demangled names. Each hash entry is
546 a pair of strings; one for the mangled name and one for the demangled
547 name. The entry is hashed via just the mangled name. */
550 create_demangled_names_hash (struct objfile *objfile)
552 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
553 The hash table code will round this up to the next prime number.
554 Choosing a much larger table size wastes memory, and saves only about
555 1% in symbol reading. */
557 objfile->demangled_names_hash = htab_create_alloc
558 (256, hash_demangled_name_entry, eq_demangled_name_entry,
559 NULL, xcalloc, xfree);
562 /* Try to determine the demangled name for a symbol, based on the
563 language of that symbol. If the language is set to language_auto,
564 it will attempt to find any demangling algorithm that works and
565 then set the language appropriately. The returned name is allocated
566 by the demangler and should be xfree'd. */
569 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
572 char *demangled = NULL;
574 if (gsymbol->language == language_unknown)
575 gsymbol->language = language_auto;
577 if (gsymbol->language == language_objc
578 || gsymbol->language == language_auto)
581 objc_demangle (mangled, 0);
582 if (demangled != NULL)
584 gsymbol->language = language_objc;
588 if (gsymbol->language == language_cplus
589 || gsymbol->language == language_auto)
592 cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
593 if (demangled != NULL)
595 gsymbol->language = language_cplus;
599 if (gsymbol->language == language_java)
602 cplus_demangle (mangled,
603 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
604 if (demangled != NULL)
606 gsymbol->language = language_java;
610 if (gsymbol->language == language_d
611 || gsymbol->language == language_auto)
613 demangled = d_demangle(mangled, 0);
614 if (demangled != NULL)
616 gsymbol->language = language_d;
620 /* We could support `gsymbol->language == language_fortran' here to provide
621 module namespaces also for inferiors with only minimal symbol table (ELF
622 symbols). Just the mangling standard is not standardized across compilers
623 and there is no DW_AT_producer available for inferiors with only the ELF
624 symbols to check the mangling kind. */
628 /* Set both the mangled and demangled (if any) names for GSYMBOL based
629 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
630 objfile's obstack; but if COPY_NAME is 0 and if NAME is
631 NUL-terminated, then this function assumes that NAME is already
632 correctly saved (either permanently or with a lifetime tied to the
633 objfile), and it will not be copied.
635 The hash table corresponding to OBJFILE is used, and the memory
636 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
637 so the pointer can be discarded after calling this function. */
639 /* We have to be careful when dealing with Java names: when we run
640 into a Java minimal symbol, we don't know it's a Java symbol, so it
641 gets demangled as a C++ name. This is unfortunate, but there's not
642 much we can do about it: but when demangling partial symbols and
643 regular symbols, we'd better not reuse the wrong demangled name.
644 (See PR gdb/1039.) We solve this by putting a distinctive prefix
645 on Java names when storing them in the hash table. */
647 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
648 don't mind the Java prefix so much: different languages have
649 different demangling requirements, so it's only natural that we
650 need to keep language data around in our demangling cache. But
651 it's not good that the minimal symbol has the wrong demangled name.
652 Unfortunately, I can't think of any easy solution to that
655 #define JAVA_PREFIX "##JAVA$$"
656 #define JAVA_PREFIX_LEN 8
659 symbol_set_names (struct general_symbol_info *gsymbol,
660 const char *linkage_name, int len, int copy_name,
661 struct objfile *objfile)
663 struct demangled_name_entry **slot;
664 /* A 0-terminated copy of the linkage name. */
665 const char *linkage_name_copy;
666 /* A copy of the linkage name that might have a special Java prefix
667 added to it, for use when looking names up in the hash table. */
668 const char *lookup_name;
669 /* The length of lookup_name. */
671 struct demangled_name_entry entry;
673 if (gsymbol->language == language_ada)
675 /* In Ada, we do the symbol lookups using the mangled name, so
676 we can save some space by not storing the demangled name.
678 As a side note, we have also observed some overlap between
679 the C++ mangling and Ada mangling, similarly to what has
680 been observed with Java. Because we don't store the demangled
681 name with the symbol, we don't need to use the same trick
684 gsymbol->name = (char *) linkage_name;
687 gsymbol->name = obstack_alloc (&objfile->objfile_obstack, len + 1);
688 memcpy (gsymbol->name, linkage_name, len);
689 gsymbol->name[len] = '\0';
691 symbol_set_demangled_name (gsymbol, NULL, NULL);
696 if (objfile->demangled_names_hash == NULL)
697 create_demangled_names_hash (objfile);
699 /* The stabs reader generally provides names that are not
700 NUL-terminated; most of the other readers don't do this, so we
701 can just use the given copy, unless we're in the Java case. */
702 if (gsymbol->language == language_java)
706 lookup_len = len + JAVA_PREFIX_LEN;
707 alloc_name = alloca (lookup_len + 1);
708 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
709 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
710 alloc_name[lookup_len] = '\0';
712 lookup_name = alloc_name;
713 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
715 else if (linkage_name[len] != '\0')
720 alloc_name = alloca (lookup_len + 1);
721 memcpy (alloc_name, linkage_name, len);
722 alloc_name[lookup_len] = '\0';
724 lookup_name = alloc_name;
725 linkage_name_copy = alloc_name;
730 lookup_name = linkage_name;
731 linkage_name_copy = linkage_name;
734 entry.mangled = (char *) lookup_name;
735 slot = ((struct demangled_name_entry **)
736 htab_find_slot (objfile->demangled_names_hash,
739 /* If this name is not in the hash table, add it. */
742 char *demangled_name = symbol_find_demangled_name (gsymbol,
744 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
746 /* Suppose we have demangled_name==NULL, copy_name==0, and
747 lookup_name==linkage_name. In this case, we already have the
748 mangled name saved, and we don't have a demangled name. So,
749 you might think we could save a little space by not recording
750 this in the hash table at all.
752 It turns out that it is actually important to still save such
753 an entry in the hash table, because storing this name gives
754 us better bcache hit rates for partial symbols. */
755 if (!copy_name && lookup_name == linkage_name)
757 *slot = obstack_alloc (&objfile->objfile_obstack,
758 offsetof (struct demangled_name_entry,
760 + demangled_len + 1);
761 (*slot)->mangled = (char *) lookup_name;
765 /* If we must copy the mangled name, put it directly after
766 the demangled name so we can have a single
768 *slot = obstack_alloc (&objfile->objfile_obstack,
769 offsetof (struct demangled_name_entry,
771 + lookup_len + demangled_len + 2);
772 (*slot)->mangled = &((*slot)->demangled[demangled_len + 1]);
773 strcpy ((*slot)->mangled, lookup_name);
776 if (demangled_name != NULL)
778 strcpy ((*slot)->demangled, demangled_name);
779 xfree (demangled_name);
782 (*slot)->demangled[0] = '\0';
785 gsymbol->name = (*slot)->mangled + lookup_len - len;
786 if ((*slot)->demangled[0] != '\0')
787 symbol_set_demangled_name (gsymbol, (*slot)->demangled, objfile);
789 symbol_set_demangled_name (gsymbol, NULL, objfile);
792 /* Return the source code name of a symbol. In languages where
793 demangling is necessary, this is the demangled name. */
796 symbol_natural_name (const struct general_symbol_info *gsymbol)
798 switch (gsymbol->language)
804 case language_fortran:
805 if (symbol_get_demangled_name (gsymbol) != NULL)
806 return symbol_get_demangled_name (gsymbol);
809 if (symbol_get_demangled_name (gsymbol) != NULL)
810 return symbol_get_demangled_name (gsymbol);
812 return ada_decode_symbol (gsymbol);
817 return gsymbol->name;
820 /* Return the demangled name for a symbol based on the language for
821 that symbol. If no demangled name exists, return NULL. */
823 symbol_demangled_name (const struct general_symbol_info *gsymbol)
825 switch (gsymbol->language)
831 case language_fortran:
832 if (symbol_get_demangled_name (gsymbol) != NULL)
833 return symbol_get_demangled_name (gsymbol);
836 if (symbol_get_demangled_name (gsymbol) != NULL)
837 return symbol_get_demangled_name (gsymbol);
839 return ada_decode_symbol (gsymbol);
847 /* Return the search name of a symbol---generally the demangled or
848 linkage name of the symbol, depending on how it will be searched for.
849 If there is no distinct demangled name, then returns the same value
850 (same pointer) as SYMBOL_LINKAGE_NAME. */
852 symbol_search_name (const struct general_symbol_info *gsymbol)
854 if (gsymbol->language == language_ada)
855 return gsymbol->name;
857 return symbol_natural_name (gsymbol);
860 /* Initialize the structure fields to zero values. */
862 init_sal (struct symtab_and_line *sal)
870 sal->explicit_pc = 0;
871 sal->explicit_line = 0;
875 /* Return 1 if the two sections are the same, or if they could
876 plausibly be copies of each other, one in an original object
877 file and another in a separated debug file. */
880 matching_obj_sections (struct obj_section *obj_first,
881 struct obj_section *obj_second)
883 asection *first = obj_first? obj_first->the_bfd_section : NULL;
884 asection *second = obj_second? obj_second->the_bfd_section : NULL;
887 /* If they're the same section, then they match. */
891 /* If either is NULL, give up. */
892 if (first == NULL || second == NULL)
895 /* This doesn't apply to absolute symbols. */
896 if (first->owner == NULL || second->owner == NULL)
899 /* If they're in the same object file, they must be different sections. */
900 if (first->owner == second->owner)
903 /* Check whether the two sections are potentially corresponding. They must
904 have the same size, address, and name. We can't compare section indexes,
905 which would be more reliable, because some sections may have been
907 if (bfd_get_section_size (first) != bfd_get_section_size (second))
910 /* In-memory addresses may start at a different offset, relativize them. */
911 if (bfd_get_section_vma (first->owner, first)
912 - bfd_get_start_address (first->owner)
913 != bfd_get_section_vma (second->owner, second)
914 - bfd_get_start_address (second->owner))
917 if (bfd_get_section_name (first->owner, first) == NULL
918 || bfd_get_section_name (second->owner, second) == NULL
919 || strcmp (bfd_get_section_name (first->owner, first),
920 bfd_get_section_name (second->owner, second)) != 0)
923 /* Otherwise check that they are in corresponding objfiles. */
926 if (obj->obfd == first->owner)
928 gdb_assert (obj != NULL);
930 if (obj->separate_debug_objfile != NULL
931 && obj->separate_debug_objfile->obfd == second->owner)
933 if (obj->separate_debug_objfile_backlink != NULL
934 && obj->separate_debug_objfile_backlink->obfd == second->owner)
941 find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
943 struct objfile *objfile;
944 struct minimal_symbol *msymbol;
946 /* If we know that this is not a text address, return failure. This is
947 necessary because we loop based on texthigh and textlow, which do
948 not include the data ranges. */
949 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
951 && (MSYMBOL_TYPE (msymbol) == mst_data
952 || MSYMBOL_TYPE (msymbol) == mst_bss
953 || MSYMBOL_TYPE (msymbol) == mst_abs
954 || MSYMBOL_TYPE (msymbol) == mst_file_data
955 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
958 ALL_OBJFILES (objfile)
960 struct symtab *result = NULL;
963 result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
972 /* Debug symbols usually don't have section information. We need to dig that
973 out of the minimal symbols and stash that in the debug symbol. */
976 fixup_section (struct general_symbol_info *ginfo,
977 CORE_ADDR addr, struct objfile *objfile)
979 struct minimal_symbol *msym;
981 /* First, check whether a minimal symbol with the same name exists
982 and points to the same address. The address check is required
983 e.g. on PowerPC64, where the minimal symbol for a function will
984 point to the function descriptor, while the debug symbol will
985 point to the actual function code. */
986 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
989 ginfo->obj_section = SYMBOL_OBJ_SECTION (msym);
990 ginfo->section = SYMBOL_SECTION (msym);
994 /* Static, function-local variables do appear in the linker
995 (minimal) symbols, but are frequently given names that won't
996 be found via lookup_minimal_symbol(). E.g., it has been
997 observed in frv-uclinux (ELF) executables that a static,
998 function-local variable named "foo" might appear in the
999 linker symbols as "foo.6" or "foo.3". Thus, there is no
1000 point in attempting to extend the lookup-by-name mechanism to
1001 handle this case due to the fact that there can be multiple
1004 So, instead, search the section table when lookup by name has
1005 failed. The ``addr'' and ``endaddr'' fields may have already
1006 been relocated. If so, the relocation offset (i.e. the
1007 ANOFFSET value) needs to be subtracted from these values when
1008 performing the comparison. We unconditionally subtract it,
1009 because, when no relocation has been performed, the ANOFFSET
1010 value will simply be zero.
1012 The address of the symbol whose section we're fixing up HAS
1013 NOT BEEN adjusted (relocated) yet. It can't have been since
1014 the section isn't yet known and knowing the section is
1015 necessary in order to add the correct relocation value. In
1016 other words, we wouldn't even be in this function (attempting
1017 to compute the section) if it were already known.
1019 Note that it is possible to search the minimal symbols
1020 (subtracting the relocation value if necessary) to find the
1021 matching minimal symbol, but this is overkill and much less
1022 efficient. It is not necessary to find the matching minimal
1023 symbol, only its section.
1025 Note that this technique (of doing a section table search)
1026 can fail when unrelocated section addresses overlap. For
1027 this reason, we still attempt a lookup by name prior to doing
1028 a search of the section table. */
1030 struct obj_section *s;
1032 ALL_OBJFILE_OSECTIONS (objfile, s)
1034 int idx = s->the_bfd_section->index;
1035 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1037 if (obj_section_addr (s) - offset <= addr
1038 && addr < obj_section_endaddr (s) - offset)
1040 ginfo->obj_section = s;
1041 ginfo->section = idx;
1049 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1056 if (SYMBOL_OBJ_SECTION (sym))
1059 /* We either have an OBJFILE, or we can get at it from the sym's
1060 symtab. Anything else is a bug. */
1061 gdb_assert (objfile || SYMBOL_SYMTAB (sym));
1063 if (objfile == NULL)
1064 objfile = SYMBOL_SYMTAB (sym)->objfile;
1066 /* We should have an objfile by now. */
1067 gdb_assert (objfile);
1069 switch (SYMBOL_CLASS (sym))
1073 addr = SYMBOL_VALUE_ADDRESS (sym);
1076 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1080 /* Nothing else will be listed in the minsyms -- no use looking
1085 fixup_section (&sym->ginfo, addr, objfile);
1090 /* Compute the demangled form of NAME as used by the various symbol
1091 lookup functions. The result is stored in *RESULT_NAME. Returns a
1092 cleanup which can be used to clean up the result.
1094 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1095 Normally, Ada symbol lookups are performed using the encoded name
1096 rather than the demangled name, and so it might seem to make sense
1097 for this function to return an encoded version of NAME.
1098 Unfortunately, we cannot do this, because this function is used in
1099 circumstances where it is not appropriate to try to encode NAME.
1100 For instance, when displaying the frame info, we demangle the name
1101 of each parameter, and then perform a symbol lookup inside our
1102 function using that demangled name. In Ada, certain functions
1103 have internally-generated parameters whose name contain uppercase
1104 characters. Encoding those name would result in those uppercase
1105 characters to become lowercase, and thus cause the symbol lookup
1109 demangle_for_lookup (const char *name, enum language lang,
1110 const char **result_name)
1112 char *demangled_name = NULL;
1113 const char *modified_name = NULL;
1114 struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
1116 modified_name = name;
1118 /* If we are using C++, D, or Java, demangle the name before doing a
1119 lookup, so we can always binary search. */
1120 if (lang == language_cplus)
1122 demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1125 modified_name = demangled_name;
1126 make_cleanup (xfree, demangled_name);
1130 /* If we were given a non-mangled name, canonicalize it
1131 according to the language (so far only for C++). */
1132 demangled_name = cp_canonicalize_string (name);
1135 modified_name = demangled_name;
1136 make_cleanup (xfree, demangled_name);
1140 else if (lang == language_java)
1142 demangled_name = cplus_demangle (name,
1143 DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1146 modified_name = demangled_name;
1147 make_cleanup (xfree, demangled_name);
1150 else if (lang == language_d)
1152 demangled_name = d_demangle (name, 0);
1155 modified_name = demangled_name;
1156 make_cleanup (xfree, demangled_name);
1160 *result_name = modified_name;
1164 /* Find the definition for a specified symbol name NAME
1165 in domain DOMAIN, visible from lexical block BLOCK.
1166 Returns the struct symbol pointer, or zero if no symbol is found.
1167 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1168 NAME is a field of the current implied argument `this'. If so set
1169 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1170 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1171 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1173 /* This function (or rather its subordinates) have a bunch of loops and
1174 it would seem to be attractive to put in some QUIT's (though I'm not really
1175 sure whether it can run long enough to be really important). But there
1176 are a few calls for which it would appear to be bad news to quit
1177 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1178 that there is C++ code below which can error(), but that probably
1179 doesn't affect these calls since they are looking for a known
1180 variable and thus can probably assume it will never hit the C++
1184 lookup_symbol_in_language (const char *name, const struct block *block,
1185 const domain_enum domain, enum language lang,
1186 int *is_a_field_of_this)
1188 const char *modified_name;
1189 struct symbol *returnval;
1190 struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
1192 returnval = lookup_symbol_aux (modified_name, block, domain, lang,
1193 is_a_field_of_this);
1194 do_cleanups (cleanup);
1199 /* Behave like lookup_symbol_in_language, but performed with the
1200 current language. */
1203 lookup_symbol (const char *name, const struct block *block,
1204 domain_enum domain, int *is_a_field_of_this)
1206 return lookup_symbol_in_language (name, block, domain,
1207 current_language->la_language,
1208 is_a_field_of_this);
1211 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1212 found, or NULL if not found. */
1215 lookup_language_this (const struct language_defn *lang,
1216 const struct block *block)
1218 if (lang->la_name_of_this == NULL || block == NULL)
1225 sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1228 if (BLOCK_FUNCTION (block))
1230 block = BLOCK_SUPERBLOCK (block);
1236 /* Behave like lookup_symbol except that NAME is the natural name
1237 (e.g., demangled name) of the symbol that we're looking for. */
1239 static struct symbol *
1240 lookup_symbol_aux (const char *name, const struct block *block,
1241 const domain_enum domain, enum language language,
1242 int *is_a_field_of_this)
1245 const struct language_defn *langdef;
1247 /* Make sure we do something sensible with is_a_field_of_this, since
1248 the callers that set this parameter to some non-null value will
1249 certainly use it later and expect it to be either 0 or 1.
1250 If we don't set it, the contents of is_a_field_of_this are
1252 if (is_a_field_of_this != NULL)
1253 *is_a_field_of_this = 0;
1255 /* Search specified block and its superiors. Don't search
1256 STATIC_BLOCK or GLOBAL_BLOCK. */
1258 sym = lookup_symbol_aux_local (name, block, domain, language);
1262 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1263 check to see if NAME is a field of `this'. */
1265 langdef = language_def (language);
1267 if (is_a_field_of_this != NULL)
1269 struct symbol *sym = lookup_language_this (langdef, block);
1273 struct type *t = sym->type;
1275 /* I'm not really sure that type of this can ever
1276 be typedefed; just be safe. */
1278 if (TYPE_CODE (t) == TYPE_CODE_PTR
1279 || TYPE_CODE (t) == TYPE_CODE_REF)
1280 t = TYPE_TARGET_TYPE (t);
1282 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1283 && TYPE_CODE (t) != TYPE_CODE_UNION)
1284 error (_("Internal error: `%s' is not an aggregate"),
1285 langdef->la_name_of_this);
1287 if (check_field (t, name))
1289 *is_a_field_of_this = 1;
1295 /* Now do whatever is appropriate for LANGUAGE to look
1296 up static and global variables. */
1298 sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
1302 /* Now search all static file-level symbols. Not strictly correct,
1303 but more useful than an error. */
1305 return lookup_static_symbol_aux (name, domain);
1308 /* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1309 first, then check the psymtabs. If a psymtab indicates the existence of the
1310 desired name as a file-level static, then do psymtab-to-symtab conversion on
1311 the fly and return the found symbol. */
1314 lookup_static_symbol_aux (const char *name, const domain_enum domain)
1316 struct objfile *objfile;
1319 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
1323 ALL_OBJFILES (objfile)
1325 sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
1333 /* Check to see if the symbol is defined in BLOCK or its superiors.
1334 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1336 static struct symbol *
1337 lookup_symbol_aux_local (const char *name, const struct block *block,
1338 const domain_enum domain,
1339 enum language language)
1342 const struct block *static_block = block_static_block (block);
1343 const char *scope = block_scope (block);
1345 /* Check if either no block is specified or it's a global block. */
1347 if (static_block == NULL)
1350 while (block != static_block)
1352 sym = lookup_symbol_aux_block (name, block, domain);
1356 if (language == language_cplus || language == language_fortran)
1358 sym = cp_lookup_symbol_imports_or_template (scope, name, block,
1364 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
1366 block = BLOCK_SUPERBLOCK (block);
1369 /* We've reached the edge of the function without finding a result. */
1374 /* Look up OBJFILE to BLOCK. */
1377 lookup_objfile_from_block (const struct block *block)
1379 struct objfile *obj;
1385 block = block_global_block (block);
1386 /* Go through SYMTABS. */
1387 ALL_SYMTABS (obj, s)
1388 if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
1390 if (obj->separate_debug_objfile_backlink)
1391 obj = obj->separate_debug_objfile_backlink;
1399 /* Look up a symbol in a block; if found, fixup the symbol, and set
1400 block_found appropriately. */
1403 lookup_symbol_aux_block (const char *name, const struct block *block,
1404 const domain_enum domain)
1408 sym = lookup_block_symbol (block, name, domain);
1411 block_found = block;
1412 return fixup_symbol_section (sym, NULL);
1418 /* Check all global symbols in OBJFILE in symtabs and
1422 lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
1424 const domain_enum domain)
1426 const struct objfile *objfile;
1428 struct blockvector *bv;
1429 const struct block *block;
1432 for (objfile = main_objfile;
1434 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
1436 /* Go through symtabs. */
1437 ALL_OBJFILE_SYMTABS (objfile, s)
1439 bv = BLOCKVECTOR (s);
1440 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1441 sym = lookup_block_symbol (block, name, domain);
1444 block_found = block;
1445 return fixup_symbol_section (sym, (struct objfile *)objfile);
1449 sym = lookup_symbol_aux_quick ((struct objfile *) objfile, GLOBAL_BLOCK,
1458 /* Check to see if the symbol is defined in one of the symtabs.
1459 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1460 depending on whether or not we want to search global symbols or
1463 static struct symbol *
1464 lookup_symbol_aux_symtabs (int block_index, const char *name,
1465 const domain_enum domain)
1468 struct objfile *objfile;
1469 struct blockvector *bv;
1470 const struct block *block;
1473 ALL_OBJFILES (objfile)
1476 objfile->sf->qf->pre_expand_symtabs_matching (objfile,
1480 ALL_OBJFILE_SYMTABS (objfile, s)
1483 bv = BLOCKVECTOR (s);
1484 block = BLOCKVECTOR_BLOCK (bv, block_index);
1485 sym = lookup_block_symbol (block, name, domain);
1488 block_found = block;
1489 return fixup_symbol_section (sym, objfile);
1497 /* A helper function for lookup_symbol_aux that interfaces with the
1498 "quick" symbol table functions. */
1500 static struct symbol *
1501 lookup_symbol_aux_quick (struct objfile *objfile, int kind,
1502 const char *name, const domain_enum domain)
1504 struct symtab *symtab;
1505 struct blockvector *bv;
1506 const struct block *block;
1511 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, domain);
1515 bv = BLOCKVECTOR (symtab);
1516 block = BLOCKVECTOR_BLOCK (bv, kind);
1517 sym = lookup_block_symbol (block, name, domain);
1520 /* This shouldn't be necessary, but as a last resort try
1521 looking in the statics even though the psymtab claimed
1522 the symbol was global, or vice-versa. It's possible
1523 that the psymtab gets it wrong in some cases. */
1525 /* FIXME: carlton/2002-09-30: Should we really do that?
1526 If that happens, isn't it likely to be a GDB error, in
1527 which case we should fix the GDB error rather than
1528 silently dealing with it here? So I'd vote for
1529 removing the check for the symbol in the other
1531 block = BLOCKVECTOR_BLOCK (bv,
1532 kind == GLOBAL_BLOCK ?
1533 STATIC_BLOCK : GLOBAL_BLOCK);
1534 sym = lookup_block_symbol (block, name, domain);
1537 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1538 %s may be an inlined function, or may be a template function\n\
1539 (if a template, try specifying an instantiation: %s<type>)."),
1540 kind == GLOBAL_BLOCK ? "global" : "static",
1541 name, symtab->filename, name, name);
1543 return fixup_symbol_section (sym, objfile);
1546 /* A default version of lookup_symbol_nonlocal for use by languages
1547 that can't think of anything better to do. This implements the C
1551 basic_lookup_symbol_nonlocal (const char *name,
1552 const struct block *block,
1553 const domain_enum domain)
1557 /* NOTE: carlton/2003-05-19: The comments below were written when
1558 this (or what turned into this) was part of lookup_symbol_aux;
1559 I'm much less worried about these questions now, since these
1560 decisions have turned out well, but I leave these comments here
1563 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1564 not it would be appropriate to search the current global block
1565 here as well. (That's what this code used to do before the
1566 is_a_field_of_this check was moved up.) On the one hand, it's
1567 redundant with the lookup_symbol_aux_symtabs search that happens
1568 next. On the other hand, if decode_line_1 is passed an argument
1569 like filename:var, then the user presumably wants 'var' to be
1570 searched for in filename. On the third hand, there shouldn't be
1571 multiple global variables all of which are named 'var', and it's
1572 not like decode_line_1 has ever restricted its search to only
1573 global variables in a single filename. All in all, only
1574 searching the static block here seems best: it's correct and it's
1577 /* NOTE: carlton/2002-12-05: There's also a possible performance
1578 issue here: if you usually search for global symbols in the
1579 current file, then it would be slightly better to search the
1580 current global block before searching all the symtabs. But there
1581 are other factors that have a much greater effect on performance
1582 than that one, so I don't think we should worry about that for
1585 sym = lookup_symbol_static (name, block, domain);
1589 return lookup_symbol_global (name, block, domain);
1592 /* Lookup a symbol in the static block associated to BLOCK, if there
1593 is one; do nothing if BLOCK is NULL or a global block. */
1596 lookup_symbol_static (const char *name,
1597 const struct block *block,
1598 const domain_enum domain)
1600 const struct block *static_block = block_static_block (block);
1602 if (static_block != NULL)
1603 return lookup_symbol_aux_block (name, static_block, domain);
1608 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1612 lookup_symbol_global (const char *name,
1613 const struct block *block,
1614 const domain_enum domain)
1616 struct symbol *sym = NULL;
1617 struct objfile *objfile = NULL;
1619 /* Call library-specific lookup procedure. */
1620 objfile = lookup_objfile_from_block (block);
1621 if (objfile != NULL)
1622 sym = solib_global_lookup (objfile, name, domain);
1626 sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, domain);
1630 ALL_OBJFILES (objfile)
1632 sym = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK, name, domain);
1641 symbol_matches_domain (enum language symbol_language,
1642 domain_enum symbol_domain,
1645 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1646 A Java class declaration also defines a typedef for the class.
1647 Similarly, any Ada type declaration implicitly defines a typedef. */
1648 if (symbol_language == language_cplus
1649 || symbol_language == language_d
1650 || symbol_language == language_java
1651 || symbol_language == language_ada)
1653 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
1654 && symbol_domain == STRUCT_DOMAIN)
1657 /* For all other languages, strict match is required. */
1658 return (symbol_domain == domain);
1661 /* Look up a type named NAME in the struct_domain. The type returned
1662 must not be opaque -- i.e., must have at least one field
1666 lookup_transparent_type (const char *name)
1668 return current_language->la_lookup_transparent_type (name);
1671 /* A helper for basic_lookup_transparent_type that interfaces with the
1672 "quick" symbol table functions. */
1674 static struct type *
1675 basic_lookup_transparent_type_quick (struct objfile *objfile, int kind,
1678 struct symtab *symtab;
1679 struct blockvector *bv;
1680 struct block *block;
1685 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, STRUCT_DOMAIN);
1689 bv = BLOCKVECTOR (symtab);
1690 block = BLOCKVECTOR_BLOCK (bv, kind);
1691 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1694 int other_kind = kind == GLOBAL_BLOCK ? STATIC_BLOCK : GLOBAL_BLOCK;
1696 /* This shouldn't be necessary, but as a last resort
1697 * try looking in the 'other kind' even though the psymtab
1698 * claimed the symbol was one thing. It's possible that
1699 * the psymtab gets it wrong in some cases.
1701 block = BLOCKVECTOR_BLOCK (bv, other_kind);
1702 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1704 /* FIXME; error is wrong in one case. */
1706 Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1707 %s may be an inlined function, or may be a template function\n\
1708 (if a template, try specifying an instantiation: %s<type>)."),
1709 name, symtab->filename, name, name);
1711 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1712 return SYMBOL_TYPE (sym);
1717 /* The standard implementation of lookup_transparent_type. This code
1718 was modeled on lookup_symbol -- the parts not relevant to looking
1719 up types were just left out. In particular it's assumed here that
1720 types are available in struct_domain and only at file-static or
1724 basic_lookup_transparent_type (const char *name)
1727 struct symtab *s = NULL;
1728 struct blockvector *bv;
1729 struct objfile *objfile;
1730 struct block *block;
1733 /* Now search all the global symbols. Do the symtab's first, then
1734 check the psymtab's. If a psymtab indicates the existence
1735 of the desired name as a global, then do psymtab-to-symtab
1736 conversion on the fly and return the found symbol. */
1738 ALL_OBJFILES (objfile)
1741 objfile->sf->qf->pre_expand_symtabs_matching (objfile,
1743 name, STRUCT_DOMAIN);
1745 ALL_OBJFILE_SYMTABS (objfile, s)
1748 bv = BLOCKVECTOR (s);
1749 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1750 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1751 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1753 return SYMBOL_TYPE (sym);
1758 ALL_OBJFILES (objfile)
1760 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
1765 /* Now search the static file-level symbols.
1766 Not strictly correct, but more useful than an error.
1767 Do the symtab's first, then
1768 check the psymtab's. If a psymtab indicates the existence
1769 of the desired name as a file-level static, then do psymtab-to-symtab
1770 conversion on the fly and return the found symbol. */
1772 ALL_OBJFILES (objfile)
1775 objfile->sf->qf->pre_expand_symtabs_matching (objfile, STATIC_BLOCK,
1776 name, STRUCT_DOMAIN);
1778 ALL_OBJFILE_SYMTABS (objfile, s)
1780 bv = BLOCKVECTOR (s);
1781 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1782 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1783 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1785 return SYMBOL_TYPE (sym);
1790 ALL_OBJFILES (objfile)
1792 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
1797 return (struct type *) 0;
1801 /* Find the name of the file containing main(). */
1802 /* FIXME: What about languages without main() or specially linked
1803 executables that have no main() ? */
1806 find_main_filename (void)
1808 struct objfile *objfile;
1809 char *name = main_name ();
1811 ALL_OBJFILES (objfile)
1817 result = objfile->sf->qf->find_symbol_file (objfile, name);
1824 /* Search BLOCK for symbol NAME in DOMAIN.
1826 Note that if NAME is the demangled form of a C++ symbol, we will fail
1827 to find a match during the binary search of the non-encoded names, but
1828 for now we don't worry about the slight inefficiency of looking for
1829 a match we'll never find, since it will go pretty quick. Once the
1830 binary search terminates, we drop through and do a straight linear
1831 search on the symbols. Each symbol which is marked as being a ObjC/C++
1832 symbol (language_cplus or language_objc set) has both the encoded and
1833 non-encoded names tested for a match. */
1836 lookup_block_symbol (const struct block *block, const char *name,
1837 const domain_enum domain)
1839 struct dict_iterator iter;
1842 if (!BLOCK_FUNCTION (block))
1844 for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1846 sym = dict_iter_name_next (name, &iter))
1848 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1849 SYMBOL_DOMAIN (sym), domain))
1856 /* Note that parameter symbols do not always show up last in the
1857 list; this loop makes sure to take anything else other than
1858 parameter symbols first; it only uses parameter symbols as a
1859 last resort. Note that this only takes up extra computation
1862 struct symbol *sym_found = NULL;
1864 for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1866 sym = dict_iter_name_next (name, &iter))
1868 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1869 SYMBOL_DOMAIN (sym), domain))
1872 if (!SYMBOL_IS_ARGUMENT (sym))
1878 return (sym_found); /* Will be NULL if not found. */
1882 /* Iterate over the symbols named NAME, matching DOMAIN, starting with
1885 For each symbol that matches, CALLBACK is called. The symbol and
1886 DATA are passed to the callback.
1888 If CALLBACK returns zero, the iteration ends. Otherwise, the
1889 search continues. This function iterates upward through blocks.
1890 When the outermost block has been finished, the function
1894 iterate_over_symbols (const struct block *block, const char *name,
1895 const domain_enum domain,
1896 int (*callback) (struct symbol *, void *),
1901 struct dict_iterator iter;
1904 for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter);
1906 sym = dict_iter_name_next (name, &iter))
1908 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1909 SYMBOL_DOMAIN (sym), domain))
1911 if (!callback (sym, data))
1916 block = BLOCK_SUPERBLOCK (block);
1920 /* Find the symtab associated with PC and SECTION. Look through the
1921 psymtabs and read in another symtab if necessary. */
1924 find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
1927 struct blockvector *bv;
1928 struct symtab *s = NULL;
1929 struct symtab *best_s = NULL;
1930 struct objfile *objfile;
1931 struct program_space *pspace;
1932 CORE_ADDR distance = 0;
1933 struct minimal_symbol *msymbol;
1935 pspace = current_program_space;
1937 /* If we know that this is not a text address, return failure. This is
1938 necessary because we loop based on the block's high and low code
1939 addresses, which do not include the data ranges, and because
1940 we call find_pc_sect_psymtab which has a similar restriction based
1941 on the partial_symtab's texthigh and textlow. */
1942 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1944 && (MSYMBOL_TYPE (msymbol) == mst_data
1945 || MSYMBOL_TYPE (msymbol) == mst_bss
1946 || MSYMBOL_TYPE (msymbol) == mst_abs
1947 || MSYMBOL_TYPE (msymbol) == mst_file_data
1948 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
1951 /* Search all symtabs for the one whose file contains our address, and which
1952 is the smallest of all the ones containing the address. This is designed
1953 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1954 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1955 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1957 This happens for native ecoff format, where code from included files
1958 gets its own symtab. The symtab for the included file should have
1959 been read in already via the dependency mechanism.
1960 It might be swifter to create several symtabs with the same name
1961 like xcoff does (I'm not sure).
1963 It also happens for objfiles that have their functions reordered.
1964 For these, the symtab we are looking for is not necessarily read in. */
1966 ALL_PRIMARY_SYMTABS (objfile, s)
1968 bv = BLOCKVECTOR (s);
1969 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1971 if (BLOCK_START (b) <= pc
1972 && BLOCK_END (b) > pc
1974 || BLOCK_END (b) - BLOCK_START (b) < distance))
1976 /* For an objfile that has its functions reordered,
1977 find_pc_psymtab will find the proper partial symbol table
1978 and we simply return its corresponding symtab. */
1979 /* In order to better support objfiles that contain both
1980 stabs and coff debugging info, we continue on if a psymtab
1982 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
1984 struct symtab *result;
1987 = objfile->sf->qf->find_pc_sect_symtab (objfile,
1996 struct dict_iterator iter;
1997 struct symbol *sym = NULL;
1999 ALL_BLOCK_SYMBOLS (b, iter, sym)
2001 fixup_symbol_section (sym, objfile);
2002 if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym), section))
2006 continue; /* No symbol in this symtab matches
2009 distance = BLOCK_END (b) - BLOCK_START (b);
2017 ALL_OBJFILES (objfile)
2019 struct symtab *result;
2023 result = objfile->sf->qf->find_pc_sect_symtab (objfile,
2034 /* Find the symtab associated with PC. Look through the psymtabs and read
2035 in another symtab if necessary. Backward compatibility, no section. */
2038 find_pc_symtab (CORE_ADDR pc)
2040 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
2044 /* Find the source file and line number for a given PC value and SECTION.
2045 Return a structure containing a symtab pointer, a line number,
2046 and a pc range for the entire source line.
2047 The value's .pc field is NOT the specified pc.
2048 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2049 use the line that ends there. Otherwise, in that case, the line
2050 that begins there is used. */
2052 /* The big complication here is that a line may start in one file, and end just
2053 before the start of another file. This usually occurs when you #include
2054 code in the middle of a subroutine. To properly find the end of a line's PC
2055 range, we must search all symtabs associated with this compilation unit, and
2056 find the one whose first PC is closer than that of the next line in this
2059 /* If it's worth the effort, we could be using a binary search. */
2061 struct symtab_and_line
2062 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
2065 struct linetable *l;
2068 struct linetable_entry *item;
2069 struct symtab_and_line val;
2070 struct blockvector *bv;
2071 struct minimal_symbol *msymbol;
2072 struct minimal_symbol *mfunsym;
2073 struct objfile *objfile;
2075 /* Info on best line seen so far, and where it starts, and its file. */
2077 struct linetable_entry *best = NULL;
2078 CORE_ADDR best_end = 0;
2079 struct symtab *best_symtab = 0;
2081 /* Store here the first line number
2082 of a file which contains the line at the smallest pc after PC.
2083 If we don't find a line whose range contains PC,
2084 we will use a line one less than this,
2085 with a range from the start of that file to the first line's pc. */
2086 struct linetable_entry *alt = NULL;
2087 struct symtab *alt_symtab = 0;
2089 /* Info on best line seen in this file. */
2091 struct linetable_entry *prev;
2093 /* If this pc is not from the current frame,
2094 it is the address of the end of a call instruction.
2095 Quite likely that is the start of the following statement.
2096 But what we want is the statement containing the instruction.
2097 Fudge the pc to make sure we get that. */
2099 init_sal (&val); /* initialize to zeroes */
2101 val.pspace = current_program_space;
2103 /* It's tempting to assume that, if we can't find debugging info for
2104 any function enclosing PC, that we shouldn't search for line
2105 number info, either. However, GAS can emit line number info for
2106 assembly files --- very helpful when debugging hand-written
2107 assembly code. In such a case, we'd have no debug info for the
2108 function, but we would have line info. */
2113 /* elz: added this because this function returned the wrong
2114 information if the pc belongs to a stub (import/export)
2115 to call a shlib function. This stub would be anywhere between
2116 two functions in the target, and the line info was erroneously
2117 taken to be the one of the line before the pc. */
2119 /* RT: Further explanation:
2121 * We have stubs (trampolines) inserted between procedures.
2123 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2124 * exists in the main image.
2126 * In the minimal symbol table, we have a bunch of symbols
2127 * sorted by start address. The stubs are marked as "trampoline",
2128 * the others appear as text. E.g.:
2130 * Minimal symbol table for main image
2131 * main: code for main (text symbol)
2132 * shr1: stub (trampoline symbol)
2133 * foo: code for foo (text symbol)
2135 * Minimal symbol table for "shr1" image:
2137 * shr1: code for shr1 (text symbol)
2140 * So the code below is trying to detect if we are in the stub
2141 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2142 * and if found, do the symbolization from the real-code address
2143 * rather than the stub address.
2145 * Assumptions being made about the minimal symbol table:
2146 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2147 * if we're really in the trampoline.s If we're beyond it (say
2148 * we're in "foo" in the above example), it'll have a closer
2149 * symbol (the "foo" text symbol for example) and will not
2150 * return the trampoline.
2151 * 2. lookup_minimal_symbol_text() will find a real text symbol
2152 * corresponding to the trampoline, and whose address will
2153 * be different than the trampoline address. I put in a sanity
2154 * check for the address being the same, to avoid an
2155 * infinite recursion.
2157 msymbol = lookup_minimal_symbol_by_pc (pc);
2158 if (msymbol != NULL)
2159 if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
2161 mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
2163 if (mfunsym == NULL)
2164 /* I eliminated this warning since it is coming out
2165 * in the following situation:
2166 * gdb shmain // test program with shared libraries
2167 * (gdb) break shr1 // function in shared lib
2168 * Warning: In stub for ...
2169 * In the above situation, the shared lib is not loaded yet,
2170 * so of course we can't find the real func/line info,
2171 * but the "break" still works, and the warning is annoying.
2172 * So I commented out the warning. RT */
2173 /* warning ("In stub for %s; unable to find real function/line info",
2174 SYMBOL_LINKAGE_NAME (msymbol)); */
2177 else if (SYMBOL_VALUE_ADDRESS (mfunsym)
2178 == SYMBOL_VALUE_ADDRESS (msymbol))
2179 /* Avoid infinite recursion */
2180 /* See above comment about why warning is commented out. */
2181 /* warning ("In stub for %s; unable to find real function/line info",
2182 SYMBOL_LINKAGE_NAME (msymbol)); */
2186 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
2190 s = find_pc_sect_symtab (pc, section);
2193 /* If no symbol information, return previous pc. */
2200 bv = BLOCKVECTOR (s);
2201 objfile = s->objfile;
2203 /* Look at all the symtabs that share this blockvector.
2204 They all have the same apriori range, that we found was right;
2205 but they have different line tables. */
2207 ALL_OBJFILE_SYMTABS (objfile, s)
2209 if (BLOCKVECTOR (s) != bv)
2212 /* Find the best line in this symtab. */
2219 /* I think len can be zero if the symtab lacks line numbers
2220 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2221 I'm not sure which, and maybe it depends on the symbol
2227 item = l->item; /* Get first line info. */
2229 /* Is this file's first line closer than the first lines of other files?
2230 If so, record this file, and its first line, as best alternate. */
2231 if (item->pc > pc && (!alt || item->pc < alt->pc))
2237 for (i = 0; i < len; i++, item++)
2239 /* Leave prev pointing to the linetable entry for the last line
2240 that started at or before PC. */
2247 /* At this point, prev points at the line whose start addr is <= pc, and
2248 item points at the next line. If we ran off the end of the linetable
2249 (pc >= start of the last line), then prev == item. If pc < start of
2250 the first line, prev will not be set. */
2252 /* Is this file's best line closer than the best in the other files?
2253 If so, record this file, and its best line, as best so far. Don't
2254 save prev if it represents the end of a function (i.e. line number
2255 0) instead of a real line. */
2257 if (prev && prev->line && (!best || prev->pc > best->pc))
2262 /* Discard BEST_END if it's before the PC of the current BEST. */
2263 if (best_end <= best->pc)
2267 /* If another line (denoted by ITEM) is in the linetable and its
2268 PC is after BEST's PC, but before the current BEST_END, then
2269 use ITEM's PC as the new best_end. */
2270 if (best && i < len && item->pc > best->pc
2271 && (best_end == 0 || best_end > item->pc))
2272 best_end = item->pc;
2277 /* If we didn't find any line number info, just return zeros.
2278 We used to return alt->line - 1 here, but that could be
2279 anywhere; if we don't have line number info for this PC,
2280 don't make some up. */
2283 else if (best->line == 0)
2285 /* If our best fit is in a range of PC's for which no line
2286 number info is available (line number is zero) then we didn't
2287 find any valid line information. */
2292 val.symtab = best_symtab;
2293 val.line = best->line;
2295 if (best_end && (!alt || best_end < alt->pc))
2300 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2302 val.section = section;
2306 /* Backward compatibility (no section). */
2308 struct symtab_and_line
2309 find_pc_line (CORE_ADDR pc, int notcurrent)
2311 struct obj_section *section;
2313 section = find_pc_overlay (pc);
2314 if (pc_in_unmapped_range (pc, section))
2315 pc = overlay_mapped_address (pc, section);
2316 return find_pc_sect_line (pc, section, notcurrent);
2319 /* Find line number LINE in any symtab whose name is the same as
2322 If found, return the symtab that contains the linetable in which it was
2323 found, set *INDEX to the index in the linetable of the best entry
2324 found, and set *EXACT_MATCH nonzero if the value returned is an
2327 If not found, return NULL. */
2330 find_line_symtab (struct symtab *symtab, int line,
2331 int *index, int *exact_match)
2333 int exact = 0; /* Initialized here to avoid a compiler warning. */
2335 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2339 struct linetable *best_linetable;
2340 struct symtab *best_symtab;
2342 /* First try looking it up in the given symtab. */
2343 best_linetable = LINETABLE (symtab);
2344 best_symtab = symtab;
2345 best_index = find_line_common (best_linetable, line, &exact, 0);
2346 if (best_index < 0 || !exact)
2348 /* Didn't find an exact match. So we better keep looking for
2349 another symtab with the same name. In the case of xcoff,
2350 multiple csects for one source file (produced by IBM's FORTRAN
2351 compiler) produce multiple symtabs (this is unavoidable
2352 assuming csects can be at arbitrary places in memory and that
2353 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2355 /* BEST is the smallest linenumber > LINE so far seen,
2356 or 0 if none has been seen so far.
2357 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2360 struct objfile *objfile;
2363 if (best_index >= 0)
2364 best = best_linetable->item[best_index].line;
2368 ALL_OBJFILES (objfile)
2371 objfile->sf->qf->expand_symtabs_with_filename (objfile,
2375 /* Get symbol full file name if possible. */
2376 symtab_to_fullname (symtab);
2378 ALL_SYMTABS (objfile, s)
2380 struct linetable *l;
2383 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
2385 if (symtab->fullname != NULL
2386 && symtab_to_fullname (s) != NULL
2387 && FILENAME_CMP (symtab->fullname, s->fullname) != 0)
2390 ind = find_line_common (l, line, &exact, 0);
2400 if (best == 0 || l->item[ind].line < best)
2402 best = l->item[ind].line;
2415 *index = best_index;
2417 *exact_match = exact;
2422 /* Given SYMTAB, returns all the PCs function in the symtab that
2423 exactly match LINE. Returns NULL if there are no exact matches,
2424 but updates BEST_ITEM in this case. */
2427 find_pcs_for_symtab_line (struct symtab *symtab, int line,
2428 struct linetable_entry **best_item)
2431 struct symbol *previous_function = NULL;
2432 VEC (CORE_ADDR) *result = NULL;
2434 /* First, collect all the PCs that are at this line. */
2440 idx = find_line_common (LINETABLE (symtab), line, &was_exact, start);
2446 struct linetable_entry *item = &LINETABLE (symtab)->item[idx];
2448 if (*best_item == NULL || item->line < (*best_item)->line)
2454 VEC_safe_push (CORE_ADDR, result, LINETABLE (symtab)->item[idx].pc);
2462 /* Set the PC value for a given source file and line number and return true.
2463 Returns zero for invalid line number (and sets the PC to 0).
2464 The source file is specified with a struct symtab. */
2467 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
2469 struct linetable *l;
2476 symtab = find_line_symtab (symtab, line, &ind, NULL);
2479 l = LINETABLE (symtab);
2480 *pc = l->item[ind].pc;
2487 /* Find the range of pc values in a line.
2488 Store the starting pc of the line into *STARTPTR
2489 and the ending pc (start of next line) into *ENDPTR.
2490 Returns 1 to indicate success.
2491 Returns 0 if could not find the specified line. */
2494 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2497 CORE_ADDR startaddr;
2498 struct symtab_and_line found_sal;
2501 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
2504 /* This whole function is based on address. For example, if line 10 has
2505 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2506 "info line *0x123" should say the line goes from 0x100 to 0x200
2507 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2508 This also insures that we never give a range like "starts at 0x134
2509 and ends at 0x12c". */
2511 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2512 if (found_sal.line != sal.line)
2514 /* The specified line (sal) has zero bytes. */
2515 *startptr = found_sal.pc;
2516 *endptr = found_sal.pc;
2520 *startptr = found_sal.pc;
2521 *endptr = found_sal.end;
2526 /* Given a line table and a line number, return the index into the line
2527 table for the pc of the nearest line whose number is >= the specified one.
2528 Return -1 if none is found. The value is >= 0 if it is an index.
2529 START is the index at which to start searching the line table.
2531 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2534 find_line_common (struct linetable *l, int lineno,
2535 int *exact_match, int start)
2540 /* BEST is the smallest linenumber > LINENO so far seen,
2541 or 0 if none has been seen so far.
2542 BEST_INDEX identifies the item for it. */
2544 int best_index = -1;
2555 for (i = start; i < len; i++)
2557 struct linetable_entry *item = &(l->item[i]);
2559 if (item->line == lineno)
2561 /* Return the first (lowest address) entry which matches. */
2566 if (item->line > lineno && (best == 0 || item->line < best))
2573 /* If we got here, we didn't get an exact match. */
2578 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
2580 struct symtab_and_line sal;
2582 sal = find_pc_line (pc, 0);
2585 return sal.symtab != 0;
2588 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2589 address for that function that has an entry in SYMTAB's line info
2590 table. If such an entry cannot be found, return FUNC_ADDR
2593 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
2595 CORE_ADDR func_start, func_end;
2596 struct linetable *l;
2599 /* Give up if this symbol has no lineinfo table. */
2600 l = LINETABLE (symtab);
2604 /* Get the range for the function's PC values, or give up if we
2605 cannot, for some reason. */
2606 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
2609 /* Linetable entries are ordered by PC values, see the commentary in
2610 symtab.h where `struct linetable' is defined. Thus, the first
2611 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2612 address we are looking for. */
2613 for (i = 0; i < l->nitems; i++)
2615 struct linetable_entry *item = &(l->item[i]);
2617 /* Don't use line numbers of zero, they mark special entries in
2618 the table. See the commentary on symtab.h before the
2619 definition of struct linetable. */
2620 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
2627 /* Given a function symbol SYM, find the symtab and line for the start
2629 If the argument FUNFIRSTLINE is nonzero, we want the first line
2630 of real code inside the function. */
2632 struct symtab_and_line
2633 find_function_start_sal (struct symbol *sym, int funfirstline)
2635 struct symtab_and_line sal;
2637 fixup_symbol_section (sym, NULL);
2638 sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
2639 SYMBOL_OBJ_SECTION (sym), 0);
2641 /* We always should have a line for the function start address.
2642 If we don't, something is odd. Create a plain SAL refering
2643 just the PC and hope that skip_prologue_sal (if requested)
2644 can find a line number for after the prologue. */
2645 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
2648 sal.pspace = current_program_space;
2649 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2650 sal.section = SYMBOL_OBJ_SECTION (sym);
2654 skip_prologue_sal (&sal);
2659 /* Adjust SAL to the first instruction past the function prologue.
2660 If the PC was explicitly specified, the SAL is not changed.
2661 If the line number was explicitly specified, at most the SAL's PC
2662 is updated. If SAL is already past the prologue, then do nothing. */
2664 skip_prologue_sal (struct symtab_and_line *sal)
2667 struct symtab_and_line start_sal;
2668 struct cleanup *old_chain;
2669 CORE_ADDR pc, saved_pc;
2670 struct obj_section *section;
2672 struct objfile *objfile;
2673 struct gdbarch *gdbarch;
2674 struct block *b, *function_block;
2675 int force_skip, skip;
2677 /* Do not change the SAL is PC was specified explicitly. */
2678 if (sal->explicit_pc)
2681 old_chain = save_current_space_and_thread ();
2682 switch_to_program_space_and_thread (sal->pspace);
2684 sym = find_pc_sect_function (sal->pc, sal->section);
2687 fixup_symbol_section (sym, NULL);
2689 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2690 section = SYMBOL_OBJ_SECTION (sym);
2691 name = SYMBOL_LINKAGE_NAME (sym);
2692 objfile = SYMBOL_SYMTAB (sym)->objfile;
2696 struct minimal_symbol *msymbol
2697 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
2699 if (msymbol == NULL)
2701 do_cleanups (old_chain);
2705 pc = SYMBOL_VALUE_ADDRESS (msymbol);
2706 section = SYMBOL_OBJ_SECTION (msymbol);
2707 name = SYMBOL_LINKAGE_NAME (msymbol);
2708 objfile = msymbol_objfile (msymbol);
2711 gdbarch = get_objfile_arch (objfile);
2713 /* Process the prologue in two passes. In the first pass try to skip the
2714 prologue (SKIP is true) and verify there is a real need for it (indicated
2715 by FORCE_SKIP). If no such reason was found run a second pass where the
2716 prologue is not skipped (SKIP is false). */
2721 /* Be conservative - allow direct PC (without skipping prologue) only if we
2722 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2723 have to be set by the caller so we use SYM instead. */
2724 if (sym && SYMBOL_SYMTAB (sym)->locations_valid)
2732 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2733 so that gdbarch_skip_prologue has something unique to work on. */
2734 if (section_is_overlay (section) && !section_is_mapped (section))
2735 pc = overlay_unmapped_address (pc, section);
2737 /* Skip "first line" of function (which is actually its prologue). */
2738 pc += gdbarch_deprecated_function_start_offset (gdbarch);
2740 pc = gdbarch_skip_prologue (gdbarch, pc);
2742 /* For overlays, map pc back into its mapped VMA range. */
2743 pc = overlay_mapped_address (pc, section);
2745 /* Calculate line number. */
2746 start_sal = find_pc_sect_line (pc, section, 0);
2748 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2749 line is still part of the same function. */
2750 if (skip && start_sal.pc != pc
2751 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
2752 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2753 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section)
2754 == lookup_minimal_symbol_by_pc_section (pc, section))))
2756 /* First pc of next line */
2758 /* Recalculate the line number (might not be N+1). */
2759 start_sal = find_pc_sect_line (pc, section, 0);
2762 /* On targets with executable formats that don't have a concept of
2763 constructors (ELF with .init has, PE doesn't), gcc emits a call
2764 to `__main' in `main' between the prologue and before user
2766 if (gdbarch_skip_main_prologue_p (gdbarch)
2767 && name && strcmp (name, "main") == 0)
2769 pc = gdbarch_skip_main_prologue (gdbarch, pc);
2770 /* Recalculate the line number (might not be N+1). */
2771 start_sal = find_pc_sect_line (pc, section, 0);
2775 while (!force_skip && skip--);
2777 /* If we still don't have a valid source line, try to find the first
2778 PC in the lineinfo table that belongs to the same function. This
2779 happens with COFF debug info, which does not seem to have an
2780 entry in lineinfo table for the code after the prologue which has
2781 no direct relation to source. For example, this was found to be
2782 the case with the DJGPP target using "gcc -gcoff" when the
2783 compiler inserted code after the prologue to make sure the stack
2785 if (!force_skip && sym && start_sal.symtab == NULL)
2787 pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
2788 /* Recalculate the line number. */
2789 start_sal = find_pc_sect_line (pc, section, 0);
2792 do_cleanups (old_chain);
2794 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2795 forward SAL to the end of the prologue. */
2800 sal->section = section;
2802 /* Unless the explicit_line flag was set, update the SAL line
2803 and symtab to correspond to the modified PC location. */
2804 if (sal->explicit_line)
2807 sal->symtab = start_sal.symtab;
2808 sal->line = start_sal.line;
2809 sal->end = start_sal.end;
2811 /* Check if we are now inside an inlined function. If we can,
2812 use the call site of the function instead. */
2813 b = block_for_pc_sect (sal->pc, sal->section);
2814 function_block = NULL;
2817 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
2819 else if (BLOCK_FUNCTION (b) != NULL)
2821 b = BLOCK_SUPERBLOCK (b);
2823 if (function_block != NULL
2824 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
2826 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
2827 sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
2831 /* If P is of the form "operator[ \t]+..." where `...' is
2832 some legitimate operator text, return a pointer to the
2833 beginning of the substring of the operator text.
2834 Otherwise, return "". */
2836 operator_chars (char *p, char **end)
2839 if (strncmp (p, "operator", 8))
2843 /* Don't get faked out by `operator' being part of a longer
2845 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
2848 /* Allow some whitespace between `operator' and the operator symbol. */
2849 while (*p == ' ' || *p == '\t')
2852 /* Recognize 'operator TYPENAME'. */
2854 if (isalpha (*p) || *p == '_' || *p == '$')
2858 while (isalnum (*q) || *q == '_' || *q == '$')
2867 case '\\': /* regexp quoting */
2870 if (p[2] == '=') /* 'operator\*=' */
2872 else /* 'operator\*' */
2876 else if (p[1] == '[')
2879 error (_("mismatched quoting on brackets, "
2880 "try 'operator\\[\\]'"));
2881 else if (p[2] == '\\' && p[3] == ']')
2883 *end = p + 4; /* 'operator\[\]' */
2887 error (_("nothing is allowed between '[' and ']'"));
2891 /* Gratuitous qoute: skip it and move on. */
2913 if (p[0] == '-' && p[1] == '>')
2915 /* Struct pointer member operator 'operator->'. */
2918 *end = p + 3; /* 'operator->*' */
2921 else if (p[2] == '\\')
2923 *end = p + 4; /* Hopefully 'operator->\*' */
2928 *end = p + 2; /* 'operator->' */
2932 if (p[1] == '=' || p[1] == p[0])
2943 error (_("`operator ()' must be specified "
2944 "without whitespace in `()'"));
2949 error (_("`operator ?:' must be specified "
2950 "without whitespace in `?:'"));
2955 error (_("`operator []' must be specified "
2956 "without whitespace in `[]'"));
2960 error (_("`operator %s' not supported"), p);
2969 /* If FILE is not already in the table of files, return zero;
2970 otherwise return non-zero. Optionally add FILE to the table if ADD
2971 is non-zero. If *FIRST is non-zero, forget the old table
2974 filename_seen (const char *file, int add, int *first)
2976 /* Table of files seen so far. */
2977 static const char **tab = NULL;
2978 /* Allocated size of tab in elements.
2979 Start with one 256-byte block (when using GNU malloc.c).
2980 24 is the malloc overhead when range checking is in effect. */
2981 static int tab_alloc_size = (256 - 24) / sizeof (char *);
2982 /* Current size of tab in elements. */
2983 static int tab_cur_size;
2989 tab = (const char **) xmalloc (tab_alloc_size * sizeof (*tab));
2993 /* Is FILE in tab? */
2994 for (p = tab; p < tab + tab_cur_size; p++)
2995 if (filename_cmp (*p, file) == 0)
2998 /* No; maybe add it to tab. */
3001 if (tab_cur_size == tab_alloc_size)
3003 tab_alloc_size *= 2;
3004 tab = (const char **) xrealloc ((char *) tab,
3005 tab_alloc_size * sizeof (*tab));
3007 tab[tab_cur_size++] = file;
3013 /* Slave routine for sources_info. Force line breaks at ,'s.
3014 NAME is the name to print and *FIRST is nonzero if this is the first
3015 name printed. Set *FIRST to zero. */
3017 output_source_filename (const char *name, int *first)
3019 /* Since a single source file can result in several partial symbol
3020 tables, we need to avoid printing it more than once. Note: if
3021 some of the psymtabs are read in and some are not, it gets
3022 printed both under "Source files for which symbols have been
3023 read" and "Source files for which symbols will be read in on
3024 demand". I consider this a reasonable way to deal with the
3025 situation. I'm not sure whether this can also happen for
3026 symtabs; it doesn't hurt to check. */
3028 /* Was NAME already seen? */
3029 if (filename_seen (name, 1, first))
3031 /* Yes; don't print it again. */
3034 /* No; print it and reset *FIRST. */
3041 printf_filtered (", ");
3045 fputs_filtered (name, gdb_stdout);
3048 /* A callback for map_partial_symbol_filenames. */
3050 output_partial_symbol_filename (const char *filename, const char *fullname,
3053 output_source_filename (fullname ? fullname : filename, data);
3057 sources_info (char *ignore, int from_tty)
3060 struct objfile *objfile;
3063 if (!have_full_symbols () && !have_partial_symbols ())
3065 error (_("No symbol table is loaded. Use the \"file\" command."));
3068 printf_filtered ("Source files for which symbols have been read in:\n\n");
3071 ALL_SYMTABS (objfile, s)
3073 const char *fullname = symtab_to_fullname (s);
3075 output_source_filename (fullname ? fullname : s->filename, &first);
3077 printf_filtered ("\n\n");
3079 printf_filtered ("Source files for which symbols "
3080 "will be read in on demand:\n\n");
3083 map_partial_symbol_filenames (output_partial_symbol_filename, &first,
3084 1 /*need_fullname*/);
3085 printf_filtered ("\n");
3089 file_matches (const char *file, char *files[], int nfiles)
3093 if (file != NULL && nfiles != 0)
3095 for (i = 0; i < nfiles; i++)
3097 if (filename_cmp (files[i], lbasename (file)) == 0)
3101 else if (nfiles == 0)
3106 /* Free any memory associated with a search. */
3108 free_search_symbols (struct symbol_search *symbols)
3110 struct symbol_search *p;
3111 struct symbol_search *next;
3113 for (p = symbols; p != NULL; p = next)
3121 do_free_search_symbols_cleanup (void *symbols)
3123 free_search_symbols (symbols);
3127 make_cleanup_free_search_symbols (struct symbol_search *symbols)
3129 return make_cleanup (do_free_search_symbols_cleanup, symbols);
3132 /* Helper function for sort_search_symbols and qsort. Can only
3133 sort symbols, not minimal symbols. */
3135 compare_search_syms (const void *sa, const void *sb)
3137 struct symbol_search **sym_a = (struct symbol_search **) sa;
3138 struct symbol_search **sym_b = (struct symbol_search **) sb;
3140 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
3141 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
3144 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
3145 prevtail where it is, but update its next pointer to point to
3146 the first of the sorted symbols. */
3147 static struct symbol_search *
3148 sort_search_symbols (struct symbol_search *prevtail, int nfound)
3150 struct symbol_search **symbols, *symp, *old_next;
3153 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
3155 symp = prevtail->next;
3156 for (i = 0; i < nfound; i++)
3161 /* Generally NULL. */
3164 qsort (symbols, nfound, sizeof (struct symbol_search *),
3165 compare_search_syms);
3168 for (i = 0; i < nfound; i++)
3170 symp->next = symbols[i];
3173 symp->next = old_next;
3179 /* An object of this type is passed as the user_data to the
3180 expand_symtabs_matching method. */
3181 struct search_symbols_data
3186 /* It is true if PREG contains valid data, false otherwise. */
3187 unsigned preg_p : 1;
3191 /* A callback for expand_symtabs_matching. */
3193 search_symbols_file_matches (const char *filename, void *user_data)
3195 struct search_symbols_data *data = user_data;
3197 return file_matches (filename, data->files, data->nfiles);
3200 /* A callback for expand_symtabs_matching. */
3202 search_symbols_name_matches (const char *symname, void *user_data)
3204 struct search_symbols_data *data = user_data;
3206 return !data->preg_p || regexec (&data->preg, symname, 0, NULL, 0) == 0;
3209 /* Search the symbol table for matches to the regular expression REGEXP,
3210 returning the results in *MATCHES.
3212 Only symbols of KIND are searched:
3213 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3214 and constants (enums)
3215 FUNCTIONS_DOMAIN - search all functions
3216 TYPES_DOMAIN - search all type names
3217 ALL_DOMAIN - an internal error for this function
3219 free_search_symbols should be called when *MATCHES is no longer needed.
3221 The results are sorted locally; each symtab's global and static blocks are
3222 separately alphabetized. */
3225 search_symbols (char *regexp, enum search_domain kind,
3226 int nfiles, char *files[],
3227 struct symbol_search **matches)
3230 struct blockvector *bv;
3233 struct dict_iterator iter;
3235 struct objfile *objfile;
3236 struct minimal_symbol *msymbol;
3239 static const enum minimal_symbol_type types[]
3240 = {mst_data, mst_text, mst_abs};
3241 static const enum minimal_symbol_type types2[]
3242 = {mst_bss, mst_file_text, mst_abs};
3243 static const enum minimal_symbol_type types3[]
3244 = {mst_file_data, mst_solib_trampoline, mst_abs};
3245 static const enum minimal_symbol_type types4[]
3246 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
3247 enum minimal_symbol_type ourtype;
3248 enum minimal_symbol_type ourtype2;
3249 enum minimal_symbol_type ourtype3;
3250 enum minimal_symbol_type ourtype4;
3251 struct symbol_search *sr;
3252 struct symbol_search *psr;
3253 struct symbol_search *tail;
3254 struct search_symbols_data datum;
3256 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3257 CLEANUP_CHAIN is freed only in the case of an error. */
3258 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3259 struct cleanup *retval_chain;
3261 gdb_assert (kind <= TYPES_DOMAIN);
3263 ourtype = types[kind];
3264 ourtype2 = types2[kind];
3265 ourtype3 = types3[kind];
3266 ourtype4 = types4[kind];
3268 sr = *matches = NULL;
3274 /* Make sure spacing is right for C++ operators.
3275 This is just a courtesy to make the matching less sensitive
3276 to how many spaces the user leaves between 'operator'
3277 and <TYPENAME> or <OPERATOR>. */
3279 char *opname = operator_chars (regexp, &opend);
3284 int fix = -1; /* -1 means ok; otherwise number of
3287 if (isalpha (*opname) || *opname == '_' || *opname == '$')
3289 /* There should 1 space between 'operator' and 'TYPENAME'. */
3290 if (opname[-1] != ' ' || opname[-2] == ' ')
3295 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3296 if (opname[-1] == ' ')
3299 /* If wrong number of spaces, fix it. */
3302 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
3304 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
3309 errcode = regcomp (&datum.preg, regexp,
3310 REG_NOSUB | (case_sensitivity == case_sensitive_off
3314 char *err = get_regcomp_error (errcode, &datum.preg);
3316 make_cleanup (xfree, err);
3317 error (_("Invalid regexp (%s): %s"), err, regexp);
3320 make_regfree_cleanup (&datum.preg);
3323 /* Search through the partial symtabs *first* for all symbols
3324 matching the regexp. That way we don't have to reproduce all of
3325 the machinery below. */
3327 datum.nfiles = nfiles;
3328 datum.files = files;
3329 ALL_OBJFILES (objfile)
3332 objfile->sf->qf->expand_symtabs_matching (objfile,
3333 search_symbols_file_matches,
3334 search_symbols_name_matches,
3339 retval_chain = old_chain;
3341 /* Here, we search through the minimal symbol tables for functions
3342 and variables that match, and force their symbols to be read.
3343 This is in particular necessary for demangled variable names,
3344 which are no longer put into the partial symbol tables.
3345 The symbol will then be found during the scan of symtabs below.
3347 For functions, find_pc_symtab should succeed if we have debug info
3348 for the function, for variables we have to call lookup_symbol
3349 to determine if the variable has debug info.
3350 If the lookup fails, set found_misc so that we will rescan to print
3351 any matching symbols without debug info. */
3353 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
3355 ALL_MSYMBOLS (objfile, msymbol)
3359 if (MSYMBOL_TYPE (msymbol) == ourtype ||
3360 MSYMBOL_TYPE (msymbol) == ourtype2 ||
3361 MSYMBOL_TYPE (msymbol) == ourtype3 ||
3362 MSYMBOL_TYPE (msymbol) == ourtype4)
3365 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3368 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
3370 /* FIXME: carlton/2003-02-04: Given that the
3371 semantics of lookup_symbol keeps on changing
3372 slightly, it would be a nice idea if we had a
3373 function lookup_symbol_minsym that found the
3374 symbol associated to a given minimal symbol (if
3376 if (kind == FUNCTIONS_DOMAIN
3377 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
3378 (struct block *) NULL,
3388 ALL_PRIMARY_SYMTABS (objfile, s)
3390 bv = BLOCKVECTOR (s);
3391 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3393 struct symbol_search *prevtail = tail;
3396 b = BLOCKVECTOR_BLOCK (bv, i);
3397 ALL_BLOCK_SYMBOLS (b, iter, sym)
3399 struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
3403 if (file_matches (real_symtab->filename, files, nfiles)
3405 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
3407 && ((kind == VARIABLES_DOMAIN
3408 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3409 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
3410 && SYMBOL_CLASS (sym) != LOC_BLOCK
3411 /* LOC_CONST can be used for more than just enums,
3412 e.g., c++ static const members.
3413 We only want to skip enums here. */
3414 && !(SYMBOL_CLASS (sym) == LOC_CONST
3415 && TYPE_CODE (SYMBOL_TYPE (sym))
3417 || (kind == FUNCTIONS_DOMAIN
3418 && SYMBOL_CLASS (sym) == LOC_BLOCK)
3419 || (kind == TYPES_DOMAIN
3420 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
3423 psr = (struct symbol_search *)
3424 xmalloc (sizeof (struct symbol_search));
3426 psr->symtab = real_symtab;
3428 psr->msymbol = NULL;
3440 if (prevtail == NULL)
3442 struct symbol_search dummy;
3445 tail = sort_search_symbols (&dummy, nfound);
3448 make_cleanup_free_search_symbols (sr);
3451 tail = sort_search_symbols (prevtail, nfound);
3456 /* If there are no eyes, avoid all contact. I mean, if there are
3457 no debug symbols, then print directly from the msymbol_vector. */
3459 if (found_misc || kind != FUNCTIONS_DOMAIN)
3461 ALL_MSYMBOLS (objfile, msymbol)
3465 if (MSYMBOL_TYPE (msymbol) == ourtype ||
3466 MSYMBOL_TYPE (msymbol) == ourtype2 ||
3467 MSYMBOL_TYPE (msymbol) == ourtype3 ||
3468 MSYMBOL_TYPE (msymbol) == ourtype4)
3471 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3474 /* Functions: Look up by address. */
3475 if (kind != FUNCTIONS_DOMAIN ||
3476 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
3478 /* Variables/Absolutes: Look up by name. */
3479 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
3480 (struct block *) NULL, VAR_DOMAIN, 0)
3484 psr = (struct symbol_search *)
3485 xmalloc (sizeof (struct symbol_search));
3487 psr->msymbol = msymbol;
3494 make_cleanup_free_search_symbols (sr);
3506 discard_cleanups (retval_chain);
3507 do_cleanups (old_chain);
3511 /* Helper function for symtab_symbol_info, this function uses
3512 the data returned from search_symbols() to print information
3513 regarding the match to gdb_stdout. */
3516 print_symbol_info (enum search_domain kind,
3517 struct symtab *s, struct symbol *sym,
3518 int block, char *last)
3520 if (last == NULL || filename_cmp (last, s->filename) != 0)
3522 fputs_filtered ("\nFile ", gdb_stdout);
3523 fputs_filtered (s->filename, gdb_stdout);
3524 fputs_filtered (":\n", gdb_stdout);
3527 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
3528 printf_filtered ("static ");
3530 /* Typedef that is not a C++ class. */
3531 if (kind == TYPES_DOMAIN
3532 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
3533 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
3534 /* variable, func, or typedef-that-is-c++-class. */
3535 else if (kind < TYPES_DOMAIN ||
3536 (kind == TYPES_DOMAIN &&
3537 SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
3539 type_print (SYMBOL_TYPE (sym),
3540 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
3541 ? "" : SYMBOL_PRINT_NAME (sym)),
3544 printf_filtered (";\n");
3548 /* This help function for symtab_symbol_info() prints information
3549 for non-debugging symbols to gdb_stdout. */
3552 print_msymbol_info (struct minimal_symbol *msymbol)
3554 struct gdbarch *gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
3557 if (gdbarch_addr_bit (gdbarch) <= 32)
3558 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3559 & (CORE_ADDR) 0xffffffff,
3562 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3564 printf_filtered ("%s %s\n",
3565 tmp, SYMBOL_PRINT_NAME (msymbol));
3568 /* This is the guts of the commands "info functions", "info types", and
3569 "info variables". It calls search_symbols to find all matches and then
3570 print_[m]symbol_info to print out some useful information about the
3574 symtab_symbol_info (char *regexp, enum search_domain kind, int from_tty)
3576 static const char * const classnames[] =
3577 {"variable", "function", "type"};
3578 struct symbol_search *symbols;
3579 struct symbol_search *p;
3580 struct cleanup *old_chain;
3581 char *last_filename = NULL;
3584 gdb_assert (kind <= TYPES_DOMAIN);
3586 /* Must make sure that if we're interrupted, symbols gets freed. */
3587 search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
3588 old_chain = make_cleanup_free_search_symbols (symbols);
3590 printf_filtered (regexp
3591 ? "All %ss matching regular expression \"%s\":\n"
3592 : "All defined %ss:\n",
3593 classnames[kind], regexp);
3595 for (p = symbols; p != NULL; p = p->next)
3599 if (p->msymbol != NULL)
3603 printf_filtered ("\nNon-debugging symbols:\n");
3606 print_msymbol_info (p->msymbol);
3610 print_symbol_info (kind,
3615 last_filename = p->symtab->filename;
3619 do_cleanups (old_chain);
3623 variables_info (char *regexp, int from_tty)
3625 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
3629 functions_info (char *regexp, int from_tty)
3631 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
3636 types_info (char *regexp, int from_tty)
3638 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
3641 /* Breakpoint all functions matching regular expression. */
3644 rbreak_command_wrapper (char *regexp, int from_tty)
3646 rbreak_command (regexp, from_tty);
3649 /* A cleanup function that calls end_rbreak_breakpoints. */
3652 do_end_rbreak_breakpoints (void *ignore)
3654 end_rbreak_breakpoints ();
3658 rbreak_command (char *regexp, int from_tty)
3660 struct symbol_search *ss;
3661 struct symbol_search *p;
3662 struct cleanup *old_chain;
3663 char *string = NULL;
3665 char **files = NULL, *file_name;
3670 char *colon = strchr (regexp, ':');
3672 if (colon && *(colon + 1) != ':')
3676 colon_index = colon - regexp;
3677 file_name = alloca (colon_index + 1);
3678 memcpy (file_name, regexp, colon_index);
3679 file_name[colon_index--] = 0;
3680 while (isspace (file_name[colon_index]))
3681 file_name[colon_index--] = 0;
3685 while (isspace (*regexp)) regexp++;
3689 search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
3690 old_chain = make_cleanup_free_search_symbols (ss);
3691 make_cleanup (free_current_contents, &string);
3693 start_rbreak_breakpoints ();
3694 make_cleanup (do_end_rbreak_breakpoints, NULL);
3695 for (p = ss; p != NULL; p = p->next)
3697 if (p->msymbol == NULL)
3699 int newlen = (strlen (p->symtab->filename)
3700 + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3705 string = xrealloc (string, newlen);
3708 strcpy (string, p->symtab->filename);
3709 strcat (string, ":'");
3710 strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
3711 strcat (string, "'");
3712 break_command (string, from_tty);
3713 print_symbol_info (FUNCTIONS_DOMAIN,
3717 p->symtab->filename);
3721 int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
3725 string = xrealloc (string, newlen);
3728 strcpy (string, "'");
3729 strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol));
3730 strcat (string, "'");
3732 break_command (string, from_tty);
3733 printf_filtered ("<function, no debug info> %s;\n",
3734 SYMBOL_PRINT_NAME (p->msymbol));
3738 do_cleanups (old_chain);
3742 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3744 Either sym_text[sym_text_len] != '(' and then we search for any
3745 symbol starting with SYM_TEXT text.
3747 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3748 be terminated at that point. Partial symbol tables do not have parameters
3752 compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
3754 int (*ncmp) (const char *, const char *, size_t);
3756 ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
3758 if (ncmp (name, sym_text, sym_text_len) != 0)
3761 if (sym_text[sym_text_len] == '(')
3763 /* User searches for `name(someth...'. Require NAME to be terminated.
3764 Normally psymtabs and gdbindex have no parameter types so '\0' will be
3765 present but accept even parameters presence. In this case this
3766 function is in fact strcmp_iw but whitespace skipping is not supported
3767 for tab completion. */
3769 if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
3776 /* Free any memory associated with a completion list. */
3779 free_completion_list (char ***list_ptr)
3782 char **list = *list_ptr;
3784 while (list[i] != NULL)
3792 /* Callback for make_cleanup. */
3795 do_free_completion_list (void *list)
3797 free_completion_list (list);
3800 /* Helper routine for make_symbol_completion_list. */
3802 static int return_val_size;
3803 static int return_val_index;
3804 static char **return_val;
3806 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3807 completion_list_add_name \
3808 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3810 /* Test to see if the symbol specified by SYMNAME (which is already
3811 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3812 characters. If so, add it to the current completion list. */
3815 completion_list_add_name (char *symname, char *sym_text, int sym_text_len,
3816 char *text, char *word)
3820 /* Clip symbols that cannot match. */
3821 if (!compare_symbol_name (symname, sym_text, sym_text_len))
3824 /* We have a match for a completion, so add SYMNAME to the current list
3825 of matches. Note that the name is moved to freshly malloc'd space. */
3830 if (word == sym_text)
3832 new = xmalloc (strlen (symname) + 5);
3833 strcpy (new, symname);
3835 else if (word > sym_text)
3837 /* Return some portion of symname. */
3838 new = xmalloc (strlen (symname) + 5);
3839 strcpy (new, symname + (word - sym_text));
3843 /* Return some of SYM_TEXT plus symname. */
3844 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
3845 strncpy (new, word, sym_text - word);
3846 new[sym_text - word] = '\0';
3847 strcat (new, symname);
3850 if (return_val_index + 3 > return_val_size)
3852 newsize = (return_val_size *= 2) * sizeof (char *);
3853 return_val = (char **) xrealloc ((char *) return_val, newsize);
3855 return_val[return_val_index++] = new;
3856 return_val[return_val_index] = NULL;
3860 /* ObjC: In case we are completing on a selector, look as the msymbol
3861 again and feed all the selectors into the mill. */
3864 completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text,
3865 int sym_text_len, char *text, char *word)
3867 static char *tmp = NULL;
3868 static unsigned int tmplen = 0;
3870 char *method, *category, *selector;
3873 method = SYMBOL_NATURAL_NAME (msymbol);
3875 /* Is it a method? */
3876 if ((method[0] != '-') && (method[0] != '+'))
3879 if (sym_text[0] == '[')
3880 /* Complete on shortened method method. */
3881 completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
3883 while ((strlen (method) + 1) >= tmplen)
3889 tmp = xrealloc (tmp, tmplen);
3891 selector = strchr (method, ' ');
3892 if (selector != NULL)
3895 category = strchr (method, '(');
3897 if ((category != NULL) && (selector != NULL))
3899 memcpy (tmp, method, (category - method));
3900 tmp[category - method] = ' ';
3901 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
3902 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
3903 if (sym_text[0] == '[')
3904 completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
3907 if (selector != NULL)
3909 /* Complete on selector only. */
3910 strcpy (tmp, selector);
3911 tmp2 = strchr (tmp, ']');
3915 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
3919 /* Break the non-quoted text based on the characters which are in
3920 symbols. FIXME: This should probably be language-specific. */
3923 language_search_unquoted_string (char *text, char *p)
3925 for (; p > text; --p)
3927 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3931 if ((current_language->la_language == language_objc))
3933 if (p[-1] == ':') /* Might be part of a method name. */
3935 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
3936 p -= 2; /* Beginning of a method name. */
3937 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
3938 { /* Might be part of a method name. */
3941 /* Seeing a ' ' or a '(' is not conclusive evidence
3942 that we are in the middle of a method name. However,
3943 finding "-[" or "+[" should be pretty un-ambiguous.
3944 Unfortunately we have to find it now to decide. */
3947 if (isalnum (t[-1]) || t[-1] == '_' ||
3948 t[-1] == ' ' || t[-1] == ':' ||
3949 t[-1] == '(' || t[-1] == ')')
3954 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
3955 p = t - 2; /* Method name detected. */
3956 /* Else we leave with p unchanged. */
3966 completion_list_add_fields (struct symbol *sym, char *sym_text,
3967 int sym_text_len, char *text, char *word)
3969 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3971 struct type *t = SYMBOL_TYPE (sym);
3972 enum type_code c = TYPE_CODE (t);
3975 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
3976 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
3977 if (TYPE_FIELD_NAME (t, j))
3978 completion_list_add_name (TYPE_FIELD_NAME (t, j),
3979 sym_text, sym_text_len, text, word);
3983 /* Type of the user_data argument passed to add_macro_name or
3984 expand_partial_symbol_name. The contents are simply whatever is
3985 needed by completion_list_add_name. */
3986 struct add_name_data
3994 /* A callback used with macro_for_each and macro_for_each_in_scope.
3995 This adds a macro's name to the current completion list. */
3997 add_macro_name (const char *name, const struct macro_definition *ignore,
3998 struct macro_source_file *ignore2, int ignore3,
4001 struct add_name_data *datum = (struct add_name_data *) user_data;
4003 completion_list_add_name ((char *) name,
4004 datum->sym_text, datum->sym_text_len,
4005 datum->text, datum->word);
4008 /* A callback for expand_partial_symbol_names. */
4010 expand_partial_symbol_name (const char *name, void *user_data)
4012 struct add_name_data *datum = (struct add_name_data *) user_data;
4014 return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
4018 default_make_symbol_completion_list_break_on (char *text, char *word,
4019 const char *break_on)
4021 /* Problem: All of the symbols have to be copied because readline
4022 frees them. I'm not going to worry about this; hopefully there
4023 won't be that many. */
4027 struct minimal_symbol *msymbol;
4028 struct objfile *objfile;
4030 const struct block *surrounding_static_block, *surrounding_global_block;
4031 struct dict_iterator iter;
4032 /* The symbol we are completing on. Points in same buffer as text. */
4034 /* Length of sym_text. */
4036 struct add_name_data datum;
4037 struct cleanup *back_to;
4039 /* Now look for the symbol we are supposed to complete on. */
4043 char *quote_pos = NULL;
4045 /* First see if this is a quoted string. */
4047 for (p = text; *p != '\0'; ++p)
4049 if (quote_found != '\0')
4051 if (*p == quote_found)
4052 /* Found close quote. */
4054 else if (*p == '\\' && p[1] == quote_found)
4055 /* A backslash followed by the quote character
4056 doesn't end the string. */
4059 else if (*p == '\'' || *p == '"')
4065 if (quote_found == '\'')
4066 /* A string within single quotes can be a symbol, so complete on it. */
4067 sym_text = quote_pos + 1;
4068 else if (quote_found == '"')
4069 /* A double-quoted string is never a symbol, nor does it make sense
4070 to complete it any other way. */
4072 return_val = (char **) xmalloc (sizeof (char *));
4073 return_val[0] = NULL;
4078 /* It is not a quoted string. Break it based on the characters
4079 which are in symbols. */
4082 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
4083 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
4092 sym_text_len = strlen (sym_text);
4094 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4096 if (current_language->la_language == language_cplus
4097 || current_language->la_language == language_java
4098 || current_language->la_language == language_fortran)
4100 /* These languages may have parameters entered by user but they are never
4101 present in the partial symbol tables. */
4103 const char *cs = memchr (sym_text, '(', sym_text_len);
4106 sym_text_len = cs - sym_text;
4108 gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
4110 return_val_size = 100;
4111 return_val_index = 0;
4112 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
4113 return_val[0] = NULL;
4114 back_to = make_cleanup (do_free_completion_list, &return_val);
4116 datum.sym_text = sym_text;
4117 datum.sym_text_len = sym_text_len;
4121 /* Look through the partial symtabs for all symbols which begin
4122 by matching SYM_TEXT. Expand all CUs that you find to the list.
4123 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4124 expand_partial_symbol_names (expand_partial_symbol_name, &datum);
4126 /* At this point scan through the misc symbol vectors and add each
4127 symbol you find to the list. Eventually we want to ignore
4128 anything that isn't a text symbol (everything else will be
4129 handled by the psymtab code above). */
4131 ALL_MSYMBOLS (objfile, msymbol)
4134 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
4136 completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text, word);
4139 /* Search upwards from currently selected frame (so that we can
4140 complete on local vars). Also catch fields of types defined in
4141 this places which match our text string. Only complete on types
4142 visible from current context. */
4144 b = get_selected_block (0);
4145 surrounding_static_block = block_static_block (b);
4146 surrounding_global_block = block_global_block (b);
4147 if (surrounding_static_block != NULL)
4148 while (b != surrounding_static_block)
4152 ALL_BLOCK_SYMBOLS (b, iter, sym)
4154 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4156 completion_list_add_fields (sym, sym_text, sym_text_len, text,
4160 /* Stop when we encounter an enclosing function. Do not stop for
4161 non-inlined functions - the locals of the enclosing function
4162 are in scope for a nested function. */
4163 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
4165 b = BLOCK_SUPERBLOCK (b);
4168 /* Add fields from the file's types; symbols will be added below. */
4170 if (surrounding_static_block != NULL)
4171 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
4172 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4174 if (surrounding_global_block != NULL)
4175 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
4176 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4178 /* Go through the symtabs and check the externs and statics for
4179 symbols which match. */
4181 ALL_PRIMARY_SYMTABS (objfile, s)
4184 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4185 ALL_BLOCK_SYMBOLS (b, iter, sym)
4187 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4191 ALL_PRIMARY_SYMTABS (objfile, s)
4194 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4195 ALL_BLOCK_SYMBOLS (b, iter, sym)
4197 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4201 if (current_language->la_macro_expansion == macro_expansion_c)
4203 struct macro_scope *scope;
4205 /* Add any macros visible in the default scope. Note that this
4206 may yield the occasional wrong result, because an expression
4207 might be evaluated in a scope other than the default. For
4208 example, if the user types "break file:line if <TAB>", the
4209 resulting expression will be evaluated at "file:line" -- but
4210 at there does not seem to be a way to detect this at
4212 scope = default_macro_scope ();
4215 macro_for_each_in_scope (scope->file, scope->line,
4216 add_macro_name, &datum);
4220 /* User-defined macros are always visible. */
4221 macro_for_each (macro_user_macros, add_macro_name, &datum);
4224 discard_cleanups (back_to);
4225 return (return_val);
4229 default_make_symbol_completion_list (char *text, char *word)
4231 return default_make_symbol_completion_list_break_on (text, word, "");
4234 /* Return a NULL terminated array of all symbols (regardless of class)
4235 which begin by matching TEXT. If the answer is no symbols, then
4236 the return value is an array which contains only a NULL pointer. */
4239 make_symbol_completion_list (char *text, char *word)
4241 return current_language->la_make_symbol_completion_list (text, word);
4244 /* Like make_symbol_completion_list, but suitable for use as a
4245 completion function. */
4248 make_symbol_completion_list_fn (struct cmd_list_element *ignore,
4249 char *text, char *word)
4251 return make_symbol_completion_list (text, word);
4254 /* Like make_symbol_completion_list, but returns a list of symbols
4255 defined in a source file FILE. */
4258 make_file_symbol_completion_list (char *text, char *word, char *srcfile)
4263 struct dict_iterator iter;
4264 /* The symbol we are completing on. Points in same buffer as text. */
4266 /* Length of sym_text. */
4269 /* Now look for the symbol we are supposed to complete on.
4270 FIXME: This should be language-specific. */
4274 char *quote_pos = NULL;
4276 /* First see if this is a quoted string. */
4278 for (p = text; *p != '\0'; ++p)
4280 if (quote_found != '\0')
4282 if (*p == quote_found)
4283 /* Found close quote. */
4285 else if (*p == '\\' && p[1] == quote_found)
4286 /* A backslash followed by the quote character
4287 doesn't end the string. */
4290 else if (*p == '\'' || *p == '"')
4296 if (quote_found == '\'')
4297 /* A string within single quotes can be a symbol, so complete on it. */
4298 sym_text = quote_pos + 1;
4299 else if (quote_found == '"')
4300 /* A double-quoted string is never a symbol, nor does it make sense
4301 to complete it any other way. */
4303 return_val = (char **) xmalloc (sizeof (char *));
4304 return_val[0] = NULL;
4309 /* Not a quoted string. */
4310 sym_text = language_search_unquoted_string (text, p);
4314 sym_text_len = strlen (sym_text);
4316 return_val_size = 10;
4317 return_val_index = 0;
4318 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
4319 return_val[0] = NULL;
4321 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4323 s = lookup_symtab (srcfile);
4326 /* Maybe they typed the file with leading directories, while the
4327 symbol tables record only its basename. */
4328 const char *tail = lbasename (srcfile);
4331 s = lookup_symtab (tail);
4334 /* If we have no symtab for that file, return an empty list. */
4336 return (return_val);
4338 /* Go through this symtab and check the externs and statics for
4339 symbols which match. */
4341 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4342 ALL_BLOCK_SYMBOLS (b, iter, sym)
4344 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4347 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4348 ALL_BLOCK_SYMBOLS (b, iter, sym)
4350 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4353 return (return_val);
4356 /* A helper function for make_source_files_completion_list. It adds
4357 another file name to a list of possible completions, growing the
4358 list as necessary. */
4361 add_filename_to_list (const char *fname, char *text, char *word,
4362 char ***list, int *list_used, int *list_alloced)
4365 size_t fnlen = strlen (fname);
4367 if (*list_used + 1 >= *list_alloced)
4370 *list = (char **) xrealloc ((char *) *list,
4371 *list_alloced * sizeof (char *));
4376 /* Return exactly fname. */
4377 new = xmalloc (fnlen + 5);
4378 strcpy (new, fname);
4380 else if (word > text)
4382 /* Return some portion of fname. */
4383 new = xmalloc (fnlen + 5);
4384 strcpy (new, fname + (word - text));
4388 /* Return some of TEXT plus fname. */
4389 new = xmalloc (fnlen + (text - word) + 5);
4390 strncpy (new, word, text - word);
4391 new[text - word] = '\0';
4392 strcat (new, fname);
4394 (*list)[*list_used] = new;
4395 (*list)[++*list_used] = NULL;
4399 not_interesting_fname (const char *fname)
4401 static const char *illegal_aliens[] = {
4402 "_globals_", /* inserted by coff_symtab_read */
4407 for (i = 0; illegal_aliens[i]; i++)
4409 if (filename_cmp (fname, illegal_aliens[i]) == 0)
4415 /* An object of this type is passed as the user_data argument to
4416 map_partial_symbol_filenames. */
4417 struct add_partial_filename_data
4428 /* A callback for map_partial_symbol_filenames. */
4430 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
4433 struct add_partial_filename_data *data = user_data;
4435 if (not_interesting_fname (filename))
4437 if (!filename_seen (filename, 1, data->first)
4438 && filename_ncmp (filename, data->text, data->text_len) == 0)
4440 /* This file matches for a completion; add it to the
4441 current list of matches. */
4442 add_filename_to_list (filename, data->text, data->word,
4443 data->list, data->list_used, data->list_alloced);
4447 const char *base_name = lbasename (filename);
4449 if (base_name != filename
4450 && !filename_seen (base_name, 1, data->first)
4451 && filename_ncmp (base_name, data->text, data->text_len) == 0)
4452 add_filename_to_list (base_name, data->text, data->word,
4453 data->list, data->list_used, data->list_alloced);
4457 /* Return a NULL terminated array of all source files whose names
4458 begin with matching TEXT. The file names are looked up in the
4459 symbol tables of this program. If the answer is no matchess, then
4460 the return value is an array which contains only a NULL pointer. */
4463 make_source_files_completion_list (char *text, char *word)
4466 struct objfile *objfile;
4468 int list_alloced = 1;
4470 size_t text_len = strlen (text);
4471 char **list = (char **) xmalloc (list_alloced * sizeof (char *));
4472 const char *base_name;
4473 struct add_partial_filename_data datum;
4474 struct cleanup *back_to;
4478 if (!have_full_symbols () && !have_partial_symbols ())
4481 back_to = make_cleanup (do_free_completion_list, &list);
4483 ALL_SYMTABS (objfile, s)
4485 if (not_interesting_fname (s->filename))
4487 if (!filename_seen (s->filename, 1, &first)
4488 && filename_ncmp (s->filename, text, text_len) == 0)
4490 /* This file matches for a completion; add it to the current
4492 add_filename_to_list (s->filename, text, word,
4493 &list, &list_used, &list_alloced);
4497 /* NOTE: We allow the user to type a base name when the
4498 debug info records leading directories, but not the other
4499 way around. This is what subroutines of breakpoint
4500 command do when they parse file names. */
4501 base_name = lbasename (s->filename);
4502 if (base_name != s->filename
4503 && !filename_seen (base_name, 1, &first)
4504 && filename_ncmp (base_name, text, text_len) == 0)
4505 add_filename_to_list (base_name, text, word,
4506 &list, &list_used, &list_alloced);
4510 datum.first = &first;
4513 datum.text_len = text_len;
4515 datum.list_used = &list_used;
4516 datum.list_alloced = &list_alloced;
4517 map_partial_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
4518 0 /*need_fullname*/);
4519 discard_cleanups (back_to);
4524 /* Determine if PC is in the prologue of a function. The prologue is the area
4525 between the first instruction of a function, and the first executable line.
4526 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4528 If non-zero, func_start is where we think the prologue starts, possibly
4529 by previous examination of symbol table information. */
4532 in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
4534 struct symtab_and_line sal;
4535 CORE_ADDR func_addr, func_end;
4537 /* We have several sources of information we can consult to figure
4539 - Compilers usually emit line number info that marks the prologue
4540 as its own "source line". So the ending address of that "line"
4541 is the end of the prologue. If available, this is the most
4543 - The minimal symbols and partial symbols, which can usually tell
4544 us the starting and ending addresses of a function.
4545 - If we know the function's start address, we can call the
4546 architecture-defined gdbarch_skip_prologue function to analyze the
4547 instruction stream and guess where the prologue ends.
4548 - Our `func_start' argument; if non-zero, this is the caller's
4549 best guess as to the function's entry point. At the time of
4550 this writing, handle_inferior_event doesn't get this right, so
4551 it should be our last resort. */
4553 /* Consult the partial symbol table, to find which function
4555 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4557 CORE_ADDR prologue_end;
4559 /* We don't even have minsym information, so fall back to using
4560 func_start, if given. */
4562 return 1; /* We *might* be in a prologue. */
4564 prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
4566 return func_start <= pc && pc < prologue_end;
4569 /* If we have line number information for the function, that's
4570 usually pretty reliable. */
4571 sal = find_pc_line (func_addr, 0);
4573 /* Now sal describes the source line at the function's entry point,
4574 which (by convention) is the prologue. The end of that "line",
4575 sal.end, is the end of the prologue.
4577 Note that, for functions whose source code is all on a single
4578 line, the line number information doesn't always end up this way.
4579 So we must verify that our purported end-of-prologue address is
4580 *within* the function, not at its start or end. */
4582 || sal.end <= func_addr
4583 || func_end <= sal.end)
4585 /* We don't have any good line number info, so use the minsym
4586 information, together with the architecture-specific prologue
4588 CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
4590 return func_addr <= pc && pc < prologue_end;
4593 /* We have line number info, and it looks good. */
4594 return func_addr <= pc && pc < sal.end;
4597 /* Given PC at the function's start address, attempt to find the
4598 prologue end using SAL information. Return zero if the skip fails.
4600 A non-optimized prologue traditionally has one SAL for the function
4601 and a second for the function body. A single line function has
4602 them both pointing at the same line.
4604 An optimized prologue is similar but the prologue may contain
4605 instructions (SALs) from the instruction body. Need to skip those
4606 while not getting into the function body.
4608 The functions end point and an increasing SAL line are used as
4609 indicators of the prologue's endpoint.
4611 This code is based on the function refine_prologue_limit
4615 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
4617 struct symtab_and_line prologue_sal;
4622 /* Get an initial range for the function. */
4623 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
4624 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
4626 prologue_sal = find_pc_line (start_pc, 0);
4627 if (prologue_sal.line != 0)
4629 /* For languages other than assembly, treat two consecutive line
4630 entries at the same address as a zero-instruction prologue.
4631 The GNU assembler emits separate line notes for each instruction
4632 in a multi-instruction macro, but compilers generally will not
4634 if (prologue_sal.symtab->language != language_asm)
4636 struct linetable *linetable = LINETABLE (prologue_sal.symtab);
4639 /* Skip any earlier lines, and any end-of-sequence marker
4640 from a previous function. */
4641 while (linetable->item[idx].pc != prologue_sal.pc
4642 || linetable->item[idx].line == 0)
4645 if (idx+1 < linetable->nitems
4646 && linetable->item[idx+1].line != 0
4647 && linetable->item[idx+1].pc == start_pc)
4651 /* If there is only one sal that covers the entire function,
4652 then it is probably a single line function, like
4654 if (prologue_sal.end >= end_pc)
4657 while (prologue_sal.end < end_pc)
4659 struct symtab_and_line sal;
4661 sal = find_pc_line (prologue_sal.end, 0);
4664 /* Assume that a consecutive SAL for the same (or larger)
4665 line mark the prologue -> body transition. */
4666 if (sal.line >= prologue_sal.line)
4669 /* The line number is smaller. Check that it's from the
4670 same function, not something inlined. If it's inlined,
4671 then there is no point comparing the line numbers. */
4672 bl = block_for_pc (prologue_sal.end);
4675 if (block_inlined_p (bl))
4677 if (BLOCK_FUNCTION (bl))
4682 bl = BLOCK_SUPERBLOCK (bl);
4687 /* The case in which compiler's optimizer/scheduler has
4688 moved instructions into the prologue. We look ahead in
4689 the function looking for address ranges whose
4690 corresponding line number is less the first one that we
4691 found for the function. This is more conservative then
4692 refine_prologue_limit which scans a large number of SALs
4693 looking for any in the prologue. */
4698 if (prologue_sal.end < end_pc)
4699 /* Return the end of this line, or zero if we could not find a
4701 return prologue_sal.end;
4703 /* Don't return END_PC, which is past the end of the function. */
4704 return prologue_sal.pc;
4707 struct symtabs_and_lines
4708 decode_line_spec (char *string, int flags)
4710 struct symtabs_and_lines sals;
4711 struct symtab_and_line cursal;
4714 error (_("Empty line specification."));
4716 /* We use whatever is set as the current source line. We do not try
4717 and get a default or it will recursively call us! */
4718 cursal = get_current_source_symtab_and_line ();
4720 sals = decode_line_1 (&string, flags,
4721 cursal.symtab, cursal.line);
4724 error (_("Junk at end of line specification: %s"), string);
4729 static char *name_of_main;
4730 enum language language_of_main = language_unknown;
4733 set_main_name (const char *name)
4735 if (name_of_main != NULL)
4737 xfree (name_of_main);
4738 name_of_main = NULL;
4739 language_of_main = language_unknown;
4743 name_of_main = xstrdup (name);
4744 language_of_main = language_unknown;
4748 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4752 find_main_name (void)
4754 const char *new_main_name;
4756 /* Try to see if the main procedure is in Ada. */
4757 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4758 be to add a new method in the language vector, and call this
4759 method for each language until one of them returns a non-empty
4760 name. This would allow us to remove this hard-coded call to
4761 an Ada function. It is not clear that this is a better approach
4762 at this point, because all methods need to be written in a way
4763 such that false positives never be returned. For instance, it is
4764 important that a method does not return a wrong name for the main
4765 procedure if the main procedure is actually written in a different
4766 language. It is easy to guaranty this with Ada, since we use a
4767 special symbol generated only when the main in Ada to find the name
4768 of the main procedure. It is difficult however to see how this can
4769 be guarantied for languages such as C, for instance. This suggests
4770 that order of call for these methods becomes important, which means
4771 a more complicated approach. */
4772 new_main_name = ada_main_name ();
4773 if (new_main_name != NULL)
4775 set_main_name (new_main_name);
4779 new_main_name = pascal_main_name ();
4780 if (new_main_name != NULL)
4782 set_main_name (new_main_name);
4786 /* The languages above didn't identify the name of the main procedure.
4787 Fallback to "main". */
4788 set_main_name ("main");
4794 if (name_of_main == NULL)
4797 return name_of_main;
4800 /* Handle ``executable_changed'' events for the symtab module. */
4803 symtab_observer_executable_changed (void)
4805 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
4806 set_main_name (NULL);
4809 /* Return 1 if the supplied producer string matches the ARM RealView
4810 compiler (armcc). */
4813 producer_is_realview (const char *producer)
4815 static const char *const arm_idents[] = {
4816 "ARM C Compiler, ADS",
4817 "Thumb C Compiler, ADS",
4818 "ARM C++ Compiler, ADS",
4819 "Thumb C++ Compiler, ADS",
4820 "ARM/Thumb C/C++ Compiler, RVCT",
4821 "ARM C/C++ Compiler, RVCT"
4825 if (producer == NULL)
4828 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
4829 if (strncmp (producer, arm_idents[i], strlen (arm_idents[i])) == 0)
4836 _initialize_symtab (void)
4838 add_info ("variables", variables_info, _("\
4839 All global and static variable names, or those matching REGEXP."));
4841 add_com ("whereis", class_info, variables_info, _("\
4842 All global and static variable names, or those matching REGEXP."));
4844 add_info ("functions", functions_info,
4845 _("All function names, or those matching REGEXP."));
4847 /* FIXME: This command has at least the following problems:
4848 1. It prints builtin types (in a very strange and confusing fashion).
4849 2. It doesn't print right, e.g. with
4850 typedef struct foo *FOO
4851 type_print prints "FOO" when we want to make it (in this situation)
4852 print "struct foo *".
4853 I also think "ptype" or "whatis" is more likely to be useful (but if
4854 there is much disagreement "info types" can be fixed). */
4855 add_info ("types", types_info,
4856 _("All type names, or those matching REGEXP."));
4858 add_info ("sources", sources_info,
4859 _("Source files in the program."));
4861 add_com ("rbreak", class_breakpoint, rbreak_command,
4862 _("Set a breakpoint for all functions matching REGEXP."));
4866 add_com ("lf", class_info, sources_info,
4867 _("Source files in the program"));
4868 add_com ("lg", class_info, variables_info, _("\
4869 All global and static variable names, or those matching REGEXP."));
4872 add_setshow_enum_cmd ("multiple-symbols", no_class,
4873 multiple_symbols_modes, &multiple_symbols_mode,
4875 Set the debugger behavior when more than one symbol are possible matches\n\
4876 in an expression."), _("\
4877 Show how the debugger handles ambiguities in expressions."), _("\
4878 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
4879 NULL, NULL, &setlist, &showlist);
4881 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
4882 &basenames_may_differ, _("\
4883 Set whether a source file may have multiple base names."), _("\
4884 Show whether a source file may have multiple base names."), _("\
4885 (A \"base name\" is the name of a file with the directory part removed.\n\
4886 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
4887 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
4888 before comparing them. Canonicalization is an expensive operation,\n\
4889 but it allows the same file be known by more than one base name.\n\
4890 If not set (the default), all source files are assumed to have just\n\
4891 one base name, and gdb will do file name comparisons more efficiently."),
4893 &setlist, &showlist);
4895 observer_attach_executable_changed (symtab_observer_executable_changed);