1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdb_regex.h"
31 #include "expression.h"
36 #include "filenames.h" /* for FILENAME_CMP */
37 #include "objc-lang.h"
43 #include "cli/cli-utils.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
56 #include "cp-support.h"
60 #include "macroscope.h"
62 #include "parser-defs.h"
64 /* Forward declarations for local functions. */
66 static void rbreak_command (char *, int);
68 static int find_line_common (struct linetable
*, int, int *, int);
70 static struct symbol
*lookup_symbol_aux (const char *name
,
71 const struct block
*block
,
72 const domain_enum domain
,
73 enum language language
,
74 struct field_of_this_result
*);
77 struct symbol
*lookup_local_symbol (const char *name
,
78 const struct block
*block
,
79 const domain_enum domain
,
80 enum language language
);
82 static struct symbol
*
83 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
,
84 int block_index
, const char *name
,
85 const domain_enum domain
);
88 struct symbol
*lookup_symbol_via_quick_fns (struct objfile
*objfile
,
91 const domain_enum domain
);
93 extern initialize_file_ftype _initialize_symtab
;
95 /* Program space key for finding name and language of "main". */
97 static const struct program_space_data
*main_progspace_key
;
99 /* Type of the data stored on the program space. */
103 /* Name of "main". */
107 /* Language of "main". */
109 enum language language_of_main
;
112 /* When non-zero, print debugging messages related to symtab creation. */
113 unsigned int symtab_create_debug
= 0;
115 /* Non-zero if a file may be known by two different basenames.
116 This is the uncommon case, and significantly slows down gdb.
117 Default set to "off" to not slow down the common case. */
118 int basenames_may_differ
= 0;
120 /* Allow the user to configure the debugger behavior with respect
121 to multiple-choice menus when more than one symbol matches during
124 const char multiple_symbols_ask
[] = "ask";
125 const char multiple_symbols_all
[] = "all";
126 const char multiple_symbols_cancel
[] = "cancel";
127 static const char *const multiple_symbols_modes
[] =
129 multiple_symbols_ask
,
130 multiple_symbols_all
,
131 multiple_symbols_cancel
,
134 static const char *multiple_symbols_mode
= multiple_symbols_all
;
136 /* Read-only accessor to AUTO_SELECT_MODE. */
139 multiple_symbols_select_mode (void)
141 return multiple_symbols_mode
;
144 /* Block in which the most recently searched-for symbol was found.
145 Might be better to make this a parameter to lookup_symbol and
148 const struct block
*block_found
;
150 /* Return the name of a domain_enum. */
153 domain_name (domain_enum e
)
157 case UNDEF_DOMAIN
: return "UNDEF_DOMAIN";
158 case VAR_DOMAIN
: return "VAR_DOMAIN";
159 case STRUCT_DOMAIN
: return "STRUCT_DOMAIN";
160 case LABEL_DOMAIN
: return "LABEL_DOMAIN";
161 case COMMON_BLOCK_DOMAIN
: return "COMMON_BLOCK_DOMAIN";
162 default: gdb_assert_not_reached ("bad domain_enum");
166 /* Return the name of a search_domain . */
169 search_domain_name (enum search_domain e
)
173 case VARIABLES_DOMAIN
: return "VARIABLES_DOMAIN";
174 case FUNCTIONS_DOMAIN
: return "FUNCTIONS_DOMAIN";
175 case TYPES_DOMAIN
: return "TYPES_DOMAIN";
176 case ALL_DOMAIN
: return "ALL_DOMAIN";
177 default: gdb_assert_not_reached ("bad search_domain");
184 compunit_primary_filetab (const struct compunit_symtab
*cust
)
186 gdb_assert (COMPUNIT_FILETABS (cust
) != NULL
);
188 /* The primary file symtab is the first one in the list. */
189 return COMPUNIT_FILETABS (cust
);
195 compunit_language (const struct compunit_symtab
*cust
)
197 struct symtab
*symtab
= compunit_primary_filetab (cust
);
199 /* The language of the compunit symtab is the language of its primary
201 return SYMTAB_LANGUAGE (symtab
);
204 /* See whether FILENAME matches SEARCH_NAME using the rule that we
205 advertise to the user. (The manual's description of linespecs
206 describes what we advertise). Returns true if they match, false
210 compare_filenames_for_search (const char *filename
, const char *search_name
)
212 int len
= strlen (filename
);
213 size_t search_len
= strlen (search_name
);
215 if (len
< search_len
)
218 /* The tail of FILENAME must match. */
219 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
222 /* Either the names must completely match, or the character
223 preceding the trailing SEARCH_NAME segment of FILENAME must be a
226 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
227 cannot match FILENAME "/path//dir/file.c" - as user has requested
228 absolute path. The sama applies for "c:\file.c" possibly
229 incorrectly hypothetically matching "d:\dir\c:\file.c".
231 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
232 compatible with SEARCH_NAME "file.c". In such case a compiler had
233 to put the "c:file.c" name into debug info. Such compatibility
234 works only on GDB built for DOS host. */
235 return (len
== search_len
236 || (!IS_ABSOLUTE_PATH (search_name
)
237 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
238 || (HAS_DRIVE_SPEC (filename
)
239 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
242 /* Check for a symtab of a specific name by searching some symtabs.
243 This is a helper function for callbacks of iterate_over_symtabs.
245 If NAME is not absolute, then REAL_PATH is NULL
246 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
248 The return value, NAME, REAL_PATH, CALLBACK, and DATA
249 are identical to the `map_symtabs_matching_filename' method of
250 quick_symbol_functions.
252 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
253 Each symtab within the specified compunit symtab is also searched.
254 AFTER_LAST is one past the last compunit symtab to search; NULL means to
255 search until the end of the list. */
258 iterate_over_some_symtabs (const char *name
,
259 const char *real_path
,
260 int (*callback
) (struct symtab
*symtab
,
263 struct compunit_symtab
*first
,
264 struct compunit_symtab
*after_last
)
266 struct compunit_symtab
*cust
;
268 const char* base_name
= lbasename (name
);
270 for (cust
= first
; cust
!= NULL
&& cust
!= after_last
; cust
= cust
->next
)
272 ALL_COMPUNIT_FILETABS (cust
, s
)
274 if (compare_filenames_for_search (s
->filename
, name
))
276 if (callback (s
, data
))
281 /* Before we invoke realpath, which can get expensive when many
282 files are involved, do a quick comparison of the basenames. */
283 if (! basenames_may_differ
284 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
287 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
289 if (callback (s
, data
))
294 /* If the user gave us an absolute path, try to find the file in
295 this symtab and use its absolute path. */
296 if (real_path
!= NULL
)
298 const char *fullname
= symtab_to_fullname (s
);
300 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
301 gdb_assert (IS_ABSOLUTE_PATH (name
));
302 if (FILENAME_CMP (real_path
, fullname
) == 0)
304 if (callback (s
, data
))
315 /* Check for a symtab of a specific name; first in symtabs, then in
316 psymtabs. *If* there is no '/' in the name, a match after a '/'
317 in the symtab filename will also work.
319 Calls CALLBACK with each symtab that is found and with the supplied
320 DATA. If CALLBACK returns true, the search stops. */
323 iterate_over_symtabs (const char *name
,
324 int (*callback
) (struct symtab
*symtab
,
328 struct objfile
*objfile
;
329 char *real_path
= NULL
;
330 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
332 /* Here we are interested in canonicalizing an absolute path, not
333 absolutizing a relative path. */
334 if (IS_ABSOLUTE_PATH (name
))
336 real_path
= gdb_realpath (name
);
337 make_cleanup (xfree
, real_path
);
338 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
341 ALL_OBJFILES (objfile
)
343 if (iterate_over_some_symtabs (name
, real_path
, callback
, data
,
344 objfile
->compunit_symtabs
, NULL
))
346 do_cleanups (cleanups
);
351 /* Same search rules as above apply here, but now we look thru the
354 ALL_OBJFILES (objfile
)
357 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
363 do_cleanups (cleanups
);
368 do_cleanups (cleanups
);
371 /* The callback function used by lookup_symtab. */
374 lookup_symtab_callback (struct symtab
*symtab
, void *data
)
376 struct symtab
**result_ptr
= data
;
378 *result_ptr
= symtab
;
382 /* A wrapper for iterate_over_symtabs that returns the first matching
386 lookup_symtab (const char *name
)
388 struct symtab
*result
= NULL
;
390 iterate_over_symtabs (name
, lookup_symtab_callback
, &result
);
395 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
396 full method name, which consist of the class name (from T), the unadorned
397 method name from METHOD_ID, and the signature for the specific overload,
398 specified by SIGNATURE_ID. Note that this function is g++ specific. */
401 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
403 int mangled_name_len
;
405 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
406 struct fn_field
*method
= &f
[signature_id
];
407 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
408 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
409 const char *newname
= type_name_no_tag (type
);
411 /* Does the form of physname indicate that it is the full mangled name
412 of a constructor (not just the args)? */
413 int is_full_physname_constructor
;
416 int is_destructor
= is_destructor_name (physname
);
417 /* Need a new type prefix. */
418 char *const_prefix
= method
->is_const
? "C" : "";
419 char *volatile_prefix
= method
->is_volatile
? "V" : "";
421 int len
= (newname
== NULL
? 0 : strlen (newname
));
423 /* Nothing to do if physname already contains a fully mangled v3 abi name
424 or an operator name. */
425 if ((physname
[0] == '_' && physname
[1] == 'Z')
426 || is_operator_name (field_name
))
427 return xstrdup (physname
);
429 is_full_physname_constructor
= is_constructor_name (physname
);
431 is_constructor
= is_full_physname_constructor
432 || (newname
&& strcmp (field_name
, newname
) == 0);
435 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
437 if (is_destructor
|| is_full_physname_constructor
)
439 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
440 strcpy (mangled_name
, physname
);
446 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
448 else if (physname
[0] == 't' || physname
[0] == 'Q')
450 /* The physname for template and qualified methods already includes
452 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
458 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
459 volatile_prefix
, len
);
461 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
462 + strlen (buf
) + len
+ strlen (physname
) + 1);
464 mangled_name
= (char *) xmalloc (mangled_name_len
);
466 mangled_name
[0] = '\0';
468 strcpy (mangled_name
, field_name
);
470 strcat (mangled_name
, buf
);
471 /* If the class doesn't have a name, i.e. newname NULL, then we just
472 mangle it using 0 for the length of the class. Thus it gets mangled
473 as something starting with `::' rather than `classname::'. */
475 strcat (mangled_name
, newname
);
477 strcat (mangled_name
, physname
);
478 return (mangled_name
);
481 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
482 correctly allocated. */
485 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
487 struct obstack
*obstack
)
489 if (gsymbol
->language
== language_ada
)
493 gsymbol
->ada_mangled
= 0;
494 gsymbol
->language_specific
.obstack
= obstack
;
498 gsymbol
->ada_mangled
= 1;
499 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
503 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
506 /* Return the demangled name of GSYMBOL. */
509 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
511 if (gsymbol
->language
== language_ada
)
513 if (!gsymbol
->ada_mangled
)
518 return gsymbol
->language_specific
.mangled_lang
.demangled_name
;
522 /* Initialize the language dependent portion of a symbol
523 depending upon the language for the symbol. */
526 symbol_set_language (struct general_symbol_info
*gsymbol
,
527 enum language language
,
528 struct obstack
*obstack
)
530 gsymbol
->language
= language
;
531 if (gsymbol
->language
== language_cplus
532 || gsymbol
->language
== language_d
533 || gsymbol
->language
== language_go
534 || gsymbol
->language
== language_java
535 || gsymbol
->language
== language_objc
536 || gsymbol
->language
== language_fortran
)
538 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
540 else if (gsymbol
->language
== language_ada
)
542 gdb_assert (gsymbol
->ada_mangled
== 0);
543 gsymbol
->language_specific
.obstack
= obstack
;
547 memset (&gsymbol
->language_specific
, 0,
548 sizeof (gsymbol
->language_specific
));
552 /* Functions to initialize a symbol's mangled name. */
554 /* Objects of this type are stored in the demangled name hash table. */
555 struct demangled_name_entry
561 /* Hash function for the demangled name hash. */
564 hash_demangled_name_entry (const void *data
)
566 const struct demangled_name_entry
*e
= data
;
568 return htab_hash_string (e
->mangled
);
571 /* Equality function for the demangled name hash. */
574 eq_demangled_name_entry (const void *a
, const void *b
)
576 const struct demangled_name_entry
*da
= a
;
577 const struct demangled_name_entry
*db
= b
;
579 return strcmp (da
->mangled
, db
->mangled
) == 0;
582 /* Create the hash table used for demangled names. Each hash entry is
583 a pair of strings; one for the mangled name and one for the demangled
584 name. The entry is hashed via just the mangled name. */
587 create_demangled_names_hash (struct objfile
*objfile
)
589 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
590 The hash table code will round this up to the next prime number.
591 Choosing a much larger table size wastes memory, and saves only about
592 1% in symbol reading. */
594 objfile
->per_bfd
->demangled_names_hash
= htab_create_alloc
595 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
596 NULL
, xcalloc
, xfree
);
599 /* Try to determine the demangled name for a symbol, based on the
600 language of that symbol. If the language is set to language_auto,
601 it will attempt to find any demangling algorithm that works and
602 then set the language appropriately. The returned name is allocated
603 by the demangler and should be xfree'd. */
606 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
609 char *demangled
= NULL
;
611 if (gsymbol
->language
== language_unknown
)
612 gsymbol
->language
= language_auto
;
614 if (gsymbol
->language
== language_objc
615 || gsymbol
->language
== language_auto
)
618 objc_demangle (mangled
, 0);
619 if (demangled
!= NULL
)
621 gsymbol
->language
= language_objc
;
625 if (gsymbol
->language
== language_cplus
626 || gsymbol
->language
== language_auto
)
629 gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
630 if (demangled
!= NULL
)
632 gsymbol
->language
= language_cplus
;
636 if (gsymbol
->language
== language_java
)
639 gdb_demangle (mangled
,
640 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
641 if (demangled
!= NULL
)
643 gsymbol
->language
= language_java
;
647 if (gsymbol
->language
== language_d
648 || gsymbol
->language
== language_auto
)
650 demangled
= d_demangle(mangled
, 0);
651 if (demangled
!= NULL
)
653 gsymbol
->language
= language_d
;
657 /* FIXME(dje): Continually adding languages here is clumsy.
658 Better to just call la_demangle if !auto, and if auto then call
659 a utility routine that tries successive languages in turn and reports
660 which one it finds. I realize the la_demangle options may be different
661 for different languages but there's already a FIXME for that. */
662 if (gsymbol
->language
== language_go
663 || gsymbol
->language
== language_auto
)
665 demangled
= go_demangle (mangled
, 0);
666 if (demangled
!= NULL
)
668 gsymbol
->language
= language_go
;
673 /* We could support `gsymbol->language == language_fortran' here to provide
674 module namespaces also for inferiors with only minimal symbol table (ELF
675 symbols). Just the mangling standard is not standardized across compilers
676 and there is no DW_AT_producer available for inferiors with only the ELF
677 symbols to check the mangling kind. */
679 /* Check for Ada symbols last. See comment below explaining why. */
681 if (gsymbol
->language
== language_auto
)
683 const char *demangled
= ada_decode (mangled
);
685 if (demangled
!= mangled
&& demangled
!= NULL
&& demangled
[0] != '<')
687 /* Set the gsymbol language to Ada, but still return NULL.
688 Two reasons for that:
690 1. For Ada, we prefer computing the symbol's decoded name
691 on the fly rather than pre-compute it, in order to save
692 memory (Ada projects are typically very large).
694 2. There are some areas in the definition of the GNAT
695 encoding where, with a bit of bad luck, we might be able
696 to decode a non-Ada symbol, generating an incorrect
697 demangled name (Eg: names ending with "TB" for instance
698 are identified as task bodies and so stripped from
699 the decoded name returned).
701 Returning NULL, here, helps us get a little bit of
702 the best of both worlds. Because we're last, we should
703 not affect any of the other languages that were able to
704 demangle the symbol before us; we get to correctly tag
705 Ada symbols as such; and even if we incorrectly tagged
706 a non-Ada symbol, which should be rare, any routing
707 through the Ada language should be transparent (Ada
708 tries to behave much like C/C++ with non-Ada symbols). */
709 gsymbol
->language
= language_ada
;
717 /* Set both the mangled and demangled (if any) names for GSYMBOL based
718 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
719 objfile's obstack; but if COPY_NAME is 0 and if NAME is
720 NUL-terminated, then this function assumes that NAME is already
721 correctly saved (either permanently or with a lifetime tied to the
722 objfile), and it will not be copied.
724 The hash table corresponding to OBJFILE is used, and the memory
725 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
726 so the pointer can be discarded after calling this function. */
728 /* We have to be careful when dealing with Java names: when we run
729 into a Java minimal symbol, we don't know it's a Java symbol, so it
730 gets demangled as a C++ name. This is unfortunate, but there's not
731 much we can do about it: but when demangling partial symbols and
732 regular symbols, we'd better not reuse the wrong demangled name.
733 (See PR gdb/1039.) We solve this by putting a distinctive prefix
734 on Java names when storing them in the hash table. */
736 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
737 don't mind the Java prefix so much: different languages have
738 different demangling requirements, so it's only natural that we
739 need to keep language data around in our demangling cache. But
740 it's not good that the minimal symbol has the wrong demangled name.
741 Unfortunately, I can't think of any easy solution to that
744 #define JAVA_PREFIX "##JAVA$$"
745 #define JAVA_PREFIX_LEN 8
748 symbol_set_names (struct general_symbol_info
*gsymbol
,
749 const char *linkage_name
, int len
, int copy_name
,
750 struct objfile
*objfile
)
752 struct demangled_name_entry
**slot
;
753 /* A 0-terminated copy of the linkage name. */
754 const char *linkage_name_copy
;
755 /* A copy of the linkage name that might have a special Java prefix
756 added to it, for use when looking names up in the hash table. */
757 const char *lookup_name
;
758 /* The length of lookup_name. */
760 struct demangled_name_entry entry
;
761 struct objfile_per_bfd_storage
*per_bfd
= objfile
->per_bfd
;
763 if (gsymbol
->language
== language_ada
)
765 /* In Ada, we do the symbol lookups using the mangled name, so
766 we can save some space by not storing the demangled name.
768 As a side note, we have also observed some overlap between
769 the C++ mangling and Ada mangling, similarly to what has
770 been observed with Java. Because we don't store the demangled
771 name with the symbol, we don't need to use the same trick
774 gsymbol
->name
= linkage_name
;
777 char *name
= obstack_alloc (&per_bfd
->storage_obstack
, len
+ 1);
779 memcpy (name
, linkage_name
, len
);
781 gsymbol
->name
= name
;
783 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
788 if (per_bfd
->demangled_names_hash
== NULL
)
789 create_demangled_names_hash (objfile
);
791 /* The stabs reader generally provides names that are not
792 NUL-terminated; most of the other readers don't do this, so we
793 can just use the given copy, unless we're in the Java case. */
794 if (gsymbol
->language
== language_java
)
798 lookup_len
= len
+ JAVA_PREFIX_LEN
;
799 alloc_name
= alloca (lookup_len
+ 1);
800 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
801 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
802 alloc_name
[lookup_len
] = '\0';
804 lookup_name
= alloc_name
;
805 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
807 else if (linkage_name
[len
] != '\0')
812 alloc_name
= alloca (lookup_len
+ 1);
813 memcpy (alloc_name
, linkage_name
, len
);
814 alloc_name
[lookup_len
] = '\0';
816 lookup_name
= alloc_name
;
817 linkage_name_copy
= alloc_name
;
822 lookup_name
= linkage_name
;
823 linkage_name_copy
= linkage_name
;
826 entry
.mangled
= lookup_name
;
827 slot
= ((struct demangled_name_entry
**)
828 htab_find_slot (per_bfd
->demangled_names_hash
,
831 /* If this name is not in the hash table, add it. */
833 /* A C version of the symbol may have already snuck into the table.
834 This happens to, e.g., main.init (__go_init_main). Cope. */
835 || (gsymbol
->language
== language_go
836 && (*slot
)->demangled
[0] == '\0'))
838 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
840 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
842 /* Suppose we have demangled_name==NULL, copy_name==0, and
843 lookup_name==linkage_name. In this case, we already have the
844 mangled name saved, and we don't have a demangled name. So,
845 you might think we could save a little space by not recording
846 this in the hash table at all.
848 It turns out that it is actually important to still save such
849 an entry in the hash table, because storing this name gives
850 us better bcache hit rates for partial symbols. */
851 if (!copy_name
&& lookup_name
== linkage_name
)
853 *slot
= obstack_alloc (&per_bfd
->storage_obstack
,
854 offsetof (struct demangled_name_entry
,
856 + demangled_len
+ 1);
857 (*slot
)->mangled
= lookup_name
;
863 /* If we must copy the mangled name, put it directly after
864 the demangled name so we can have a single
866 *slot
= obstack_alloc (&per_bfd
->storage_obstack
,
867 offsetof (struct demangled_name_entry
,
869 + lookup_len
+ demangled_len
+ 2);
870 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
871 strcpy (mangled_ptr
, lookup_name
);
872 (*slot
)->mangled
= mangled_ptr
;
875 if (demangled_name
!= NULL
)
877 strcpy ((*slot
)->demangled
, demangled_name
);
878 xfree (demangled_name
);
881 (*slot
)->demangled
[0] = '\0';
884 gsymbol
->name
= (*slot
)->mangled
+ lookup_len
- len
;
885 if ((*slot
)->demangled
[0] != '\0')
886 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
887 &per_bfd
->storage_obstack
);
889 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
892 /* Return the source code name of a symbol. In languages where
893 demangling is necessary, this is the demangled name. */
896 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
898 switch (gsymbol
->language
)
905 case language_fortran
:
906 if (symbol_get_demangled_name (gsymbol
) != NULL
)
907 return symbol_get_demangled_name (gsymbol
);
910 return ada_decode_symbol (gsymbol
);
914 return gsymbol
->name
;
917 /* Return the demangled name for a symbol based on the language for
918 that symbol. If no demangled name exists, return NULL. */
921 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
923 const char *dem_name
= NULL
;
925 switch (gsymbol
->language
)
932 case language_fortran
:
933 dem_name
= symbol_get_demangled_name (gsymbol
);
936 dem_name
= ada_decode_symbol (gsymbol
);
944 /* Return the search name of a symbol---generally the demangled or
945 linkage name of the symbol, depending on how it will be searched for.
946 If there is no distinct demangled name, then returns the same value
947 (same pointer) as SYMBOL_LINKAGE_NAME. */
950 symbol_search_name (const struct general_symbol_info
*gsymbol
)
952 if (gsymbol
->language
== language_ada
)
953 return gsymbol
->name
;
955 return symbol_natural_name (gsymbol
);
958 /* Initialize the structure fields to zero values. */
961 init_sal (struct symtab_and_line
*sal
)
963 memset (sal
, 0, sizeof (*sal
));
967 /* Return 1 if the two sections are the same, or if they could
968 plausibly be copies of each other, one in an original object
969 file and another in a separated debug file. */
972 matching_obj_sections (struct obj_section
*obj_first
,
973 struct obj_section
*obj_second
)
975 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
976 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
979 /* If they're the same section, then they match. */
983 /* If either is NULL, give up. */
984 if (first
== NULL
|| second
== NULL
)
987 /* This doesn't apply to absolute symbols. */
988 if (first
->owner
== NULL
|| second
->owner
== NULL
)
991 /* If they're in the same object file, they must be different sections. */
992 if (first
->owner
== second
->owner
)
995 /* Check whether the two sections are potentially corresponding. They must
996 have the same size, address, and name. We can't compare section indexes,
997 which would be more reliable, because some sections may have been
999 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
1002 /* In-memory addresses may start at a different offset, relativize them. */
1003 if (bfd_get_section_vma (first
->owner
, first
)
1004 - bfd_get_start_address (first
->owner
)
1005 != bfd_get_section_vma (second
->owner
, second
)
1006 - bfd_get_start_address (second
->owner
))
1009 if (bfd_get_section_name (first
->owner
, first
) == NULL
1010 || bfd_get_section_name (second
->owner
, second
) == NULL
1011 || strcmp (bfd_get_section_name (first
->owner
, first
),
1012 bfd_get_section_name (second
->owner
, second
)) != 0)
1015 /* Otherwise check that they are in corresponding objfiles. */
1018 if (obj
->obfd
== first
->owner
)
1020 gdb_assert (obj
!= NULL
);
1022 if (obj
->separate_debug_objfile
!= NULL
1023 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1025 if (obj
->separate_debug_objfile_backlink
!= NULL
1026 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1035 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1037 struct objfile
*objfile
;
1038 struct bound_minimal_symbol msymbol
;
1040 /* If we know that this is not a text address, return failure. This is
1041 necessary because we loop based on texthigh and textlow, which do
1042 not include the data ranges. */
1043 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1045 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
1046 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
1047 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
1048 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
1049 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
1052 ALL_OBJFILES (objfile
)
1054 struct compunit_symtab
*cust
= NULL
;
1057 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1064 /* Debug symbols usually don't have section information. We need to dig that
1065 out of the minimal symbols and stash that in the debug symbol. */
1068 fixup_section (struct general_symbol_info
*ginfo
,
1069 CORE_ADDR addr
, struct objfile
*objfile
)
1071 struct minimal_symbol
*msym
;
1073 /* First, check whether a minimal symbol with the same name exists
1074 and points to the same address. The address check is required
1075 e.g. on PowerPC64, where the minimal symbol for a function will
1076 point to the function descriptor, while the debug symbol will
1077 point to the actual function code. */
1078 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1080 ginfo
->section
= MSYMBOL_SECTION (msym
);
1083 /* Static, function-local variables do appear in the linker
1084 (minimal) symbols, but are frequently given names that won't
1085 be found via lookup_minimal_symbol(). E.g., it has been
1086 observed in frv-uclinux (ELF) executables that a static,
1087 function-local variable named "foo" might appear in the
1088 linker symbols as "foo.6" or "foo.3". Thus, there is no
1089 point in attempting to extend the lookup-by-name mechanism to
1090 handle this case due to the fact that there can be multiple
1093 So, instead, search the section table when lookup by name has
1094 failed. The ``addr'' and ``endaddr'' fields may have already
1095 been relocated. If so, the relocation offset (i.e. the
1096 ANOFFSET value) needs to be subtracted from these values when
1097 performing the comparison. We unconditionally subtract it,
1098 because, when no relocation has been performed, the ANOFFSET
1099 value will simply be zero.
1101 The address of the symbol whose section we're fixing up HAS
1102 NOT BEEN adjusted (relocated) yet. It can't have been since
1103 the section isn't yet known and knowing the section is
1104 necessary in order to add the correct relocation value. In
1105 other words, we wouldn't even be in this function (attempting
1106 to compute the section) if it were already known.
1108 Note that it is possible to search the minimal symbols
1109 (subtracting the relocation value if necessary) to find the
1110 matching minimal symbol, but this is overkill and much less
1111 efficient. It is not necessary to find the matching minimal
1112 symbol, only its section.
1114 Note that this technique (of doing a section table search)
1115 can fail when unrelocated section addresses overlap. For
1116 this reason, we still attempt a lookup by name prior to doing
1117 a search of the section table. */
1119 struct obj_section
*s
;
1122 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1124 int idx
= s
- objfile
->sections
;
1125 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1130 if (obj_section_addr (s
) - offset
<= addr
1131 && addr
< obj_section_endaddr (s
) - offset
)
1133 ginfo
->section
= idx
;
1138 /* If we didn't find the section, assume it is in the first
1139 section. If there is no allocated section, then it hardly
1140 matters what we pick, so just pick zero. */
1144 ginfo
->section
= fallback
;
1149 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1156 /* We either have an OBJFILE, or we can get at it from the sym's
1157 symtab. Anything else is a bug. */
1158 gdb_assert (objfile
|| SYMBOL_SYMTAB (sym
));
1160 if (objfile
== NULL
)
1161 objfile
= SYMBOL_OBJFILE (sym
);
1163 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1166 /* We should have an objfile by now. */
1167 gdb_assert (objfile
);
1169 switch (SYMBOL_CLASS (sym
))
1173 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1176 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1180 /* Nothing else will be listed in the minsyms -- no use looking
1185 fixup_section (&sym
->ginfo
, addr
, objfile
);
1190 /* Compute the demangled form of NAME as used by the various symbol
1191 lookup functions. The result is stored in *RESULT_NAME. Returns a
1192 cleanup which can be used to clean up the result.
1194 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1195 Normally, Ada symbol lookups are performed using the encoded name
1196 rather than the demangled name, and so it might seem to make sense
1197 for this function to return an encoded version of NAME.
1198 Unfortunately, we cannot do this, because this function is used in
1199 circumstances where it is not appropriate to try to encode NAME.
1200 For instance, when displaying the frame info, we demangle the name
1201 of each parameter, and then perform a symbol lookup inside our
1202 function using that demangled name. In Ada, certain functions
1203 have internally-generated parameters whose name contain uppercase
1204 characters. Encoding those name would result in those uppercase
1205 characters to become lowercase, and thus cause the symbol lookup
1209 demangle_for_lookup (const char *name
, enum language lang
,
1210 const char **result_name
)
1212 char *demangled_name
= NULL
;
1213 const char *modified_name
= NULL
;
1214 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, 0);
1216 modified_name
= name
;
1218 /* If we are using C++, D, Go, or Java, demangle the name before doing a
1219 lookup, so we can always binary search. */
1220 if (lang
== language_cplus
)
1222 demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1225 modified_name
= demangled_name
;
1226 make_cleanup (xfree
, demangled_name
);
1230 /* If we were given a non-mangled name, canonicalize it
1231 according to the language (so far only for C++). */
1232 demangled_name
= cp_canonicalize_string (name
);
1235 modified_name
= demangled_name
;
1236 make_cleanup (xfree
, demangled_name
);
1240 else if (lang
== language_java
)
1242 demangled_name
= gdb_demangle (name
,
1243 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1246 modified_name
= demangled_name
;
1247 make_cleanup (xfree
, demangled_name
);
1250 else if (lang
== language_d
)
1252 demangled_name
= d_demangle (name
, 0);
1255 modified_name
= demangled_name
;
1256 make_cleanup (xfree
, demangled_name
);
1259 else if (lang
== language_go
)
1261 demangled_name
= go_demangle (name
, 0);
1264 modified_name
= demangled_name
;
1265 make_cleanup (xfree
, demangled_name
);
1269 *result_name
= modified_name
;
1275 This function (or rather its subordinates) have a bunch of loops and
1276 it would seem to be attractive to put in some QUIT's (though I'm not really
1277 sure whether it can run long enough to be really important). But there
1278 are a few calls for which it would appear to be bad news to quit
1279 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1280 that there is C++ code below which can error(), but that probably
1281 doesn't affect these calls since they are looking for a known
1282 variable and thus can probably assume it will never hit the C++
1286 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1287 const domain_enum domain
, enum language lang
,
1288 struct field_of_this_result
*is_a_field_of_this
)
1290 const char *modified_name
;
1291 struct symbol
*returnval
;
1292 struct cleanup
*cleanup
= demangle_for_lookup (name
, lang
, &modified_name
);
1294 returnval
= lookup_symbol_aux (modified_name
, block
, domain
, lang
,
1295 is_a_field_of_this
);
1296 do_cleanups (cleanup
);
1304 lookup_symbol (const char *name
, const struct block
*block
,
1306 struct field_of_this_result
*is_a_field_of_this
)
1308 return lookup_symbol_in_language (name
, block
, domain
,
1309 current_language
->la_language
,
1310 is_a_field_of_this
);
1316 lookup_language_this (const struct language_defn
*lang
,
1317 const struct block
*block
)
1319 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1326 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
, VAR_DOMAIN
);
1329 block_found
= block
;
1332 if (BLOCK_FUNCTION (block
))
1334 block
= BLOCK_SUPERBLOCK (block
);
1340 /* Given TYPE, a structure/union,
1341 return 1 if the component named NAME from the ultimate target
1342 structure/union is defined, otherwise, return 0. */
1345 check_field (struct type
*type
, const char *name
,
1346 struct field_of_this_result
*is_a_field_of_this
)
1350 /* The type may be a stub. */
1351 CHECK_TYPEDEF (type
);
1353 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1355 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1357 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1359 is_a_field_of_this
->type
= type
;
1360 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1365 /* C++: If it was not found as a data field, then try to return it
1366 as a pointer to a method. */
1368 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1370 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1372 is_a_field_of_this
->type
= type
;
1373 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1378 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1379 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
1385 /* Behave like lookup_symbol except that NAME is the natural name
1386 (e.g., demangled name) of the symbol that we're looking for. */
1388 static struct symbol
*
1389 lookup_symbol_aux (const char *name
, const struct block
*block
,
1390 const domain_enum domain
, enum language language
,
1391 struct field_of_this_result
*is_a_field_of_this
)
1394 const struct language_defn
*langdef
;
1396 /* Make sure we do something sensible with is_a_field_of_this, since
1397 the callers that set this parameter to some non-null value will
1398 certainly use it later. If we don't set it, the contents of
1399 is_a_field_of_this are undefined. */
1400 if (is_a_field_of_this
!= NULL
)
1401 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
1403 /* Search specified block and its superiors. Don't search
1404 STATIC_BLOCK or GLOBAL_BLOCK. */
1406 sym
= lookup_local_symbol (name
, block
, domain
, language
);
1410 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1411 check to see if NAME is a field of `this'. */
1413 langdef
= language_def (language
);
1415 /* Don't do this check if we are searching for a struct. It will
1416 not be found by check_field, but will be found by other
1418 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
1420 struct symbol
*sym
= lookup_language_this (langdef
, block
);
1424 struct type
*t
= sym
->type
;
1426 /* I'm not really sure that type of this can ever
1427 be typedefed; just be safe. */
1429 if (TYPE_CODE (t
) == TYPE_CODE_PTR
1430 || TYPE_CODE (t
) == TYPE_CODE_REF
)
1431 t
= TYPE_TARGET_TYPE (t
);
1433 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1434 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1435 error (_("Internal error: `%s' is not an aggregate"),
1436 langdef
->la_name_of_this
);
1438 if (check_field (t
, name
, is_a_field_of_this
))
1443 /* Now do whatever is appropriate for LANGUAGE to look
1444 up static and global variables. */
1446 sym
= langdef
->la_lookup_symbol_nonlocal (name
, block
, domain
);
1450 /* Now search all static file-level symbols. Not strictly correct,
1451 but more useful than an error. */
1453 return lookup_static_symbol (name
, domain
);
1456 /* Check to see if the symbol is defined in BLOCK or its superiors.
1457 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1459 static struct symbol
*
1460 lookup_local_symbol (const char *name
, const struct block
*block
,
1461 const domain_enum domain
,
1462 enum language language
)
1465 const struct block
*static_block
= block_static_block (block
);
1466 const char *scope
= block_scope (block
);
1468 /* Check if either no block is specified or it's a global block. */
1470 if (static_block
== NULL
)
1473 while (block
!= static_block
)
1475 sym
= lookup_symbol_in_block (name
, block
, domain
);
1479 if (language
== language_cplus
|| language
== language_fortran
)
1481 sym
= cp_lookup_symbol_imports_or_template (scope
, name
, block
,
1487 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
1489 block
= BLOCK_SUPERBLOCK (block
);
1492 /* We've reached the end of the function without finding a result. */
1500 lookup_objfile_from_block (const struct block
*block
)
1502 struct objfile
*obj
;
1503 struct compunit_symtab
*cust
;
1508 block
= block_global_block (block
);
1509 /* Look through all blockvectors. */
1510 ALL_COMPUNITS (obj
, cust
)
1511 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
1514 if (obj
->separate_debug_objfile_backlink
)
1515 obj
= obj
->separate_debug_objfile_backlink
;
1526 lookup_symbol_in_block (const char *name
, const struct block
*block
,
1527 const domain_enum domain
)
1531 sym
= block_lookup_symbol (block
, name
, domain
);
1534 block_found
= block
;
1535 return fixup_symbol_section (sym
, NULL
);
1544 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
1546 const domain_enum domain
)
1548 struct objfile
*objfile
;
1550 for (objfile
= main_objfile
;
1552 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
1556 sym
= lookup_symbol_in_objfile_symtabs (objfile
, GLOBAL_BLOCK
, name
,
1561 sym
= lookup_symbol_via_quick_fns (objfile
, GLOBAL_BLOCK
, name
, domain
);
1569 /* Check to see if the symbol is defined in one of the OBJFILE's
1570 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1571 depending on whether or not we want to search global symbols or
1574 static struct symbol
*
1575 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
, int block_index
,
1576 const char *name
, const domain_enum domain
)
1578 struct compunit_symtab
*cust
;
1580 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
1582 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
1584 const struct blockvector
*bv
;
1585 const struct block
*block
;
1588 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1589 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1590 sym
= block_lookup_symbol_primary (block
, name
, domain
);
1593 block_found
= block
;
1594 return fixup_symbol_section (sym
, objfile
);
1601 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
1602 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1603 and all associated separate debug objfiles.
1605 Normally we only look in OBJFILE, and not any separate debug objfiles
1606 because the outer loop will cause them to be searched too. This case is
1607 different. Here we're called from search_symbols where it will only
1608 call us for the the objfile that contains a matching minsym. */
1610 static struct symbol
*
1611 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
1612 const char *linkage_name
,
1615 enum language lang
= current_language
->la_language
;
1616 const char *modified_name
;
1617 struct cleanup
*cleanup
= demangle_for_lookup (linkage_name
, lang
,
1619 struct objfile
*main_objfile
, *cur_objfile
;
1621 if (objfile
->separate_debug_objfile_backlink
)
1622 main_objfile
= objfile
->separate_debug_objfile_backlink
;
1624 main_objfile
= objfile
;
1626 for (cur_objfile
= main_objfile
;
1628 cur_objfile
= objfile_separate_debug_iterate (main_objfile
, cur_objfile
))
1632 sym
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
1633 modified_name
, domain
);
1635 sym
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
1636 modified_name
, domain
);
1639 do_cleanups (cleanup
);
1644 do_cleanups (cleanup
);
1648 /* A helper function that throws an exception when a symbol was found
1649 in a psymtab but not in a symtab. */
1651 static void ATTRIBUTE_NORETURN
1652 error_in_psymtab_expansion (int block_index
, const char *name
,
1653 struct compunit_symtab
*cust
)
1656 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1657 %s may be an inlined function, or may be a template function\n \
1658 (if a template, try specifying an instantiation: %s<type>)."),
1659 block_index
== GLOBAL_BLOCK
? "global" : "static",
1661 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
1665 /* A helper function for various lookup routines that interfaces with
1666 the "quick" symbol table functions. */
1668 static struct symbol
*
1669 lookup_symbol_via_quick_fns (struct objfile
*objfile
, int block_index
,
1670 const char *name
, const domain_enum domain
)
1672 struct compunit_symtab
*cust
;
1673 const struct blockvector
*bv
;
1674 const struct block
*block
;
1679 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
1683 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1684 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1685 sym
= block_lookup_symbol (block
, name
, domain
);
1687 error_in_psymtab_expansion (block_index
, name
, cust
);
1688 block_found
= block
;
1689 return fixup_symbol_section (sym
, objfile
);
1695 basic_lookup_symbol_nonlocal (const char *name
,
1696 const struct block
*block
,
1697 const domain_enum domain
)
1701 /* NOTE: carlton/2003-05-19: The comments below were written when
1702 this (or what turned into this) was part of lookup_symbol_aux;
1703 I'm much less worried about these questions now, since these
1704 decisions have turned out well, but I leave these comments here
1707 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1708 not it would be appropriate to search the current global block
1709 here as well. (That's what this code used to do before the
1710 is_a_field_of_this check was moved up.) On the one hand, it's
1711 redundant with the lookup in all objfiles search that happens
1712 next. On the other hand, if decode_line_1 is passed an argument
1713 like filename:var, then the user presumably wants 'var' to be
1714 searched for in filename. On the third hand, there shouldn't be
1715 multiple global variables all of which are named 'var', and it's
1716 not like decode_line_1 has ever restricted its search to only
1717 global variables in a single filename. All in all, only
1718 searching the static block here seems best: it's correct and it's
1721 /* NOTE: carlton/2002-12-05: There's also a possible performance
1722 issue here: if you usually search for global symbols in the
1723 current file, then it would be slightly better to search the
1724 current global block before searching all the symtabs. But there
1725 are other factors that have a much greater effect on performance
1726 than that one, so I don't think we should worry about that for
1729 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
1730 the current objfile. Searching the current objfile first is useful
1731 for both matching user expectations as well as performance. */
1733 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
1737 return lookup_global_symbol (name
, block
, domain
);
1743 lookup_symbol_in_static_block (const char *name
,
1744 const struct block
*block
,
1745 const domain_enum domain
)
1747 const struct block
*static_block
= block_static_block (block
);
1749 if (static_block
!= NULL
)
1750 return lookup_symbol_in_block (name
, static_block
, domain
);
1755 /* Perform the standard symbol lookup of NAME in OBJFILE:
1756 1) First search expanded symtabs, and if not found
1757 2) Search the "quick" symtabs (partial or .gdb_index).
1758 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
1760 static struct symbol
*
1761 lookup_symbol_in_objfile (struct objfile
*objfile
, int block_index
,
1762 const char *name
, const domain_enum domain
)
1764 struct symbol
*result
;
1766 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
1770 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
1780 lookup_static_symbol (const char *name
, const domain_enum domain
)
1782 struct objfile
*objfile
;
1783 struct symbol
*result
;
1785 ALL_OBJFILES (objfile
)
1787 result
= lookup_symbol_in_objfile (objfile
, STATIC_BLOCK
, name
, domain
);
1795 /* Private data to be used with lookup_symbol_global_iterator_cb. */
1797 struct global_sym_lookup_data
1799 /* The name of the symbol we are searching for. */
1802 /* The domain to use for our search. */
1805 /* The field where the callback should store the symbol if found.
1806 It should be initialized to NULL before the search is started. */
1807 struct symbol
*result
;
1810 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1811 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1812 OBJFILE. The arguments for the search are passed via CB_DATA,
1813 which in reality is a pointer to struct global_sym_lookup_data. */
1816 lookup_symbol_global_iterator_cb (struct objfile
*objfile
,
1819 struct global_sym_lookup_data
*data
=
1820 (struct global_sym_lookup_data
*) cb_data
;
1822 gdb_assert (data
->result
== NULL
);
1824 data
->result
= lookup_symbol_in_objfile (objfile
, GLOBAL_BLOCK
,
1825 data
->name
, data
->domain
);
1827 /* If we found a match, tell the iterator to stop. Otherwise,
1829 return (data
->result
!= NULL
);
1835 lookup_global_symbol (const char *name
,
1836 const struct block
*block
,
1837 const domain_enum domain
)
1839 struct symbol
*sym
= NULL
;
1840 struct objfile
*objfile
= NULL
;
1841 struct global_sym_lookup_data lookup_data
;
1843 /* Call library-specific lookup procedure. */
1844 objfile
= lookup_objfile_from_block (block
);
1845 if (objfile
!= NULL
)
1846 sym
= solib_global_lookup (objfile
, name
, domain
);
1850 memset (&lookup_data
, 0, sizeof (lookup_data
));
1851 lookup_data
.name
= name
;
1852 lookup_data
.domain
= domain
;
1853 gdbarch_iterate_over_objfiles_in_search_order
1854 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
1855 lookup_symbol_global_iterator_cb
, &lookup_data
, objfile
);
1857 return lookup_data
.result
;
1861 symbol_matches_domain (enum language symbol_language
,
1862 domain_enum symbol_domain
,
1865 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1866 A Java class declaration also defines a typedef for the class.
1867 Similarly, any Ada type declaration implicitly defines a typedef. */
1868 if (symbol_language
== language_cplus
1869 || symbol_language
== language_d
1870 || symbol_language
== language_java
1871 || symbol_language
== language_ada
)
1873 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
1874 && symbol_domain
== STRUCT_DOMAIN
)
1877 /* For all other languages, strict match is required. */
1878 return (symbol_domain
== domain
);
1884 lookup_transparent_type (const char *name
)
1886 return current_language
->la_lookup_transparent_type (name
);
1889 /* A helper for basic_lookup_transparent_type that interfaces with the
1890 "quick" symbol table functions. */
1892 static struct type
*
1893 basic_lookup_transparent_type_quick (struct objfile
*objfile
, int block_index
,
1896 struct compunit_symtab
*cust
;
1897 const struct blockvector
*bv
;
1898 struct block
*block
;
1903 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
1908 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1909 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1910 sym
= block_lookup_symbol (block
, name
, STRUCT_DOMAIN
);
1912 error_in_psymtab_expansion (block_index
, name
, cust
);
1914 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1915 return SYMBOL_TYPE (sym
);
1920 /* The standard implementation of lookup_transparent_type. This code
1921 was modeled on lookup_symbol -- the parts not relevant to looking
1922 up types were just left out. In particular it's assumed here that
1923 types are available in STRUCT_DOMAIN and only in file-static or
1927 basic_lookup_transparent_type (const char *name
)
1930 struct compunit_symtab
*cust
;
1931 const struct blockvector
*bv
;
1932 struct objfile
*objfile
;
1933 struct block
*block
;
1936 /* Now search all the global symbols. Do the symtab's first, then
1937 check the psymtab's. If a psymtab indicates the existence
1938 of the desired name as a global, then do psymtab-to-symtab
1939 conversion on the fly and return the found symbol. */
1941 ALL_OBJFILES (objfile
)
1943 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
1945 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1946 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1947 sym
= block_lookup_symbol (block
, name
, STRUCT_DOMAIN
);
1948 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1950 return SYMBOL_TYPE (sym
);
1955 ALL_OBJFILES (objfile
)
1957 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
1962 /* Now search the static file-level symbols.
1963 Not strictly correct, but more useful than an error.
1964 Do the symtab's first, then
1965 check the psymtab's. If a psymtab indicates the existence
1966 of the desired name as a file-level static, then do psymtab-to-symtab
1967 conversion on the fly and return the found symbol. */
1969 ALL_OBJFILES (objfile
)
1971 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
1973 bv
= COMPUNIT_BLOCKVECTOR (cust
);
1974 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1975 sym
= block_lookup_symbol (block
, name
, STRUCT_DOMAIN
);
1976 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1978 return SYMBOL_TYPE (sym
);
1983 ALL_OBJFILES (objfile
)
1985 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
1990 return (struct type
*) 0;
1993 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
1995 For each symbol that matches, CALLBACK is called. The symbol and
1996 DATA are passed to the callback.
1998 If CALLBACK returns zero, the iteration ends. Otherwise, the
1999 search continues. */
2002 iterate_over_symbols (const struct block
*block
, const char *name
,
2003 const domain_enum domain
,
2004 symbol_found_callback_ftype
*callback
,
2007 struct block_iterator iter
;
2010 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2012 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2013 SYMBOL_DOMAIN (sym
), domain
))
2015 if (!callback (sym
, data
))
2021 /* Find the compunit symtab associated with PC and SECTION.
2022 This will read in debug info as necessary. */
2024 struct compunit_symtab
*
2025 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2027 struct compunit_symtab
*cust
;
2028 struct compunit_symtab
*best_cust
= NULL
;
2029 struct objfile
*objfile
;
2030 CORE_ADDR distance
= 0;
2031 struct bound_minimal_symbol msymbol
;
2033 /* If we know that this is not a text address, return failure. This is
2034 necessary because we loop based on the block's high and low code
2035 addresses, which do not include the data ranges, and because
2036 we call find_pc_sect_psymtab which has a similar restriction based
2037 on the partial_symtab's texthigh and textlow. */
2038 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2040 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
2041 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
2042 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
2043 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
2044 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
2047 /* Search all symtabs for the one whose file contains our address, and which
2048 is the smallest of all the ones containing the address. This is designed
2049 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2050 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2051 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2053 This happens for native ecoff format, where code from included files
2054 gets its own symtab. The symtab for the included file should have
2055 been read in already via the dependency mechanism.
2056 It might be swifter to create several symtabs with the same name
2057 like xcoff does (I'm not sure).
2059 It also happens for objfiles that have their functions reordered.
2060 For these, the symtab we are looking for is not necessarily read in. */
2062 ALL_COMPUNITS (objfile
, cust
)
2065 const struct blockvector
*bv
;
2067 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2068 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2070 if (BLOCK_START (b
) <= pc
2071 && BLOCK_END (b
) > pc
2073 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2075 /* For an objfile that has its functions reordered,
2076 find_pc_psymtab will find the proper partial symbol table
2077 and we simply return its corresponding symtab. */
2078 /* In order to better support objfiles that contain both
2079 stabs and coff debugging info, we continue on if a psymtab
2081 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->sf
)
2083 struct compunit_symtab
*result
;
2086 = objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
,
2095 struct block_iterator iter
;
2096 struct symbol
*sym
= NULL
;
2098 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2100 fixup_symbol_section (sym
, objfile
);
2101 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, sym
),
2106 continue; /* No symbol in this symtab matches
2109 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2114 if (best_cust
!= NULL
)
2117 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2119 ALL_OBJFILES (objfile
)
2121 struct compunit_symtab
*result
;
2125 result
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
,
2136 /* Find the compunit symtab associated with PC.
2137 This will read in debug info as necessary.
2138 Backward compatibility, no section. */
2140 struct compunit_symtab
*
2141 find_pc_compunit_symtab (CORE_ADDR pc
)
2143 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2147 /* Find the source file and line number for a given PC value and SECTION.
2148 Return a structure containing a symtab pointer, a line number,
2149 and a pc range for the entire source line.
2150 The value's .pc field is NOT the specified pc.
2151 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2152 use the line that ends there. Otherwise, in that case, the line
2153 that begins there is used. */
2155 /* The big complication here is that a line may start in one file, and end just
2156 before the start of another file. This usually occurs when you #include
2157 code in the middle of a subroutine. To properly find the end of a line's PC
2158 range, we must search all symtabs associated with this compilation unit, and
2159 find the one whose first PC is closer than that of the next line in this
2162 /* If it's worth the effort, we could be using a binary search. */
2164 struct symtab_and_line
2165 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
2167 struct compunit_symtab
*cust
;
2168 struct symtab
*iter_s
;
2169 struct linetable
*l
;
2172 struct linetable_entry
*item
;
2173 struct symtab_and_line val
;
2174 const struct blockvector
*bv
;
2175 struct bound_minimal_symbol msymbol
;
2177 /* Info on best line seen so far, and where it starts, and its file. */
2179 struct linetable_entry
*best
= NULL
;
2180 CORE_ADDR best_end
= 0;
2181 struct symtab
*best_symtab
= 0;
2183 /* Store here the first line number
2184 of a file which contains the line at the smallest pc after PC.
2185 If we don't find a line whose range contains PC,
2186 we will use a line one less than this,
2187 with a range from the start of that file to the first line's pc. */
2188 struct linetable_entry
*alt
= NULL
;
2190 /* Info on best line seen in this file. */
2192 struct linetable_entry
*prev
;
2194 /* If this pc is not from the current frame,
2195 it is the address of the end of a call instruction.
2196 Quite likely that is the start of the following statement.
2197 But what we want is the statement containing the instruction.
2198 Fudge the pc to make sure we get that. */
2200 init_sal (&val
); /* initialize to zeroes */
2202 val
.pspace
= current_program_space
;
2204 /* It's tempting to assume that, if we can't find debugging info for
2205 any function enclosing PC, that we shouldn't search for line
2206 number info, either. However, GAS can emit line number info for
2207 assembly files --- very helpful when debugging hand-written
2208 assembly code. In such a case, we'd have no debug info for the
2209 function, but we would have line info. */
2214 /* elz: added this because this function returned the wrong
2215 information if the pc belongs to a stub (import/export)
2216 to call a shlib function. This stub would be anywhere between
2217 two functions in the target, and the line info was erroneously
2218 taken to be the one of the line before the pc. */
2220 /* RT: Further explanation:
2222 * We have stubs (trampolines) inserted between procedures.
2224 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2225 * exists in the main image.
2227 * In the minimal symbol table, we have a bunch of symbols
2228 * sorted by start address. The stubs are marked as "trampoline",
2229 * the others appear as text. E.g.:
2231 * Minimal symbol table for main image
2232 * main: code for main (text symbol)
2233 * shr1: stub (trampoline symbol)
2234 * foo: code for foo (text symbol)
2236 * Minimal symbol table for "shr1" image:
2238 * shr1: code for shr1 (text symbol)
2241 * So the code below is trying to detect if we are in the stub
2242 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2243 * and if found, do the symbolization from the real-code address
2244 * rather than the stub address.
2246 * Assumptions being made about the minimal symbol table:
2247 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2248 * if we're really in the trampoline.s If we're beyond it (say
2249 * we're in "foo" in the above example), it'll have a closer
2250 * symbol (the "foo" text symbol for example) and will not
2251 * return the trampoline.
2252 * 2. lookup_minimal_symbol_text() will find a real text symbol
2253 * corresponding to the trampoline, and whose address will
2254 * be different than the trampoline address. I put in a sanity
2255 * check for the address being the same, to avoid an
2256 * infinite recursion.
2258 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2259 if (msymbol
.minsym
!= NULL
)
2260 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
2262 struct bound_minimal_symbol mfunsym
2263 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
2266 if (mfunsym
.minsym
== NULL
)
2267 /* I eliminated this warning since it is coming out
2268 * in the following situation:
2269 * gdb shmain // test program with shared libraries
2270 * (gdb) break shr1 // function in shared lib
2271 * Warning: In stub for ...
2272 * In the above situation, the shared lib is not loaded yet,
2273 * so of course we can't find the real func/line info,
2274 * but the "break" still works, and the warning is annoying.
2275 * So I commented out the warning. RT */
2276 /* warning ("In stub for %s; unable to find real function/line info",
2277 SYMBOL_LINKAGE_NAME (msymbol)); */
2280 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
2281 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
2282 /* Avoid infinite recursion */
2283 /* See above comment about why warning is commented out. */
2284 /* warning ("In stub for %s; unable to find real function/line info",
2285 SYMBOL_LINKAGE_NAME (msymbol)); */
2289 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
2293 cust
= find_pc_sect_compunit_symtab (pc
, section
);
2296 /* If no symbol information, return previous pc. */
2303 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2305 /* Look at all the symtabs that share this blockvector.
2306 They all have the same apriori range, that we found was right;
2307 but they have different line tables. */
2309 ALL_COMPUNIT_FILETABS (cust
, iter_s
)
2311 /* Find the best line in this symtab. */
2312 l
= SYMTAB_LINETABLE (iter_s
);
2318 /* I think len can be zero if the symtab lacks line numbers
2319 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2320 I'm not sure which, and maybe it depends on the symbol
2326 item
= l
->item
; /* Get first line info. */
2328 /* Is this file's first line closer than the first lines of other files?
2329 If so, record this file, and its first line, as best alternate. */
2330 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2333 for (i
= 0; i
< len
; i
++, item
++)
2335 /* Leave prev pointing to the linetable entry for the last line
2336 that started at or before PC. */
2343 /* At this point, prev points at the line whose start addr is <= pc, and
2344 item points at the next line. If we ran off the end of the linetable
2345 (pc >= start of the last line), then prev == item. If pc < start of
2346 the first line, prev will not be set. */
2348 /* Is this file's best line closer than the best in the other files?
2349 If so, record this file, and its best line, as best so far. Don't
2350 save prev if it represents the end of a function (i.e. line number
2351 0) instead of a real line. */
2353 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2356 best_symtab
= iter_s
;
2358 /* Discard BEST_END if it's before the PC of the current BEST. */
2359 if (best_end
<= best
->pc
)
2363 /* If another line (denoted by ITEM) is in the linetable and its
2364 PC is after BEST's PC, but before the current BEST_END, then
2365 use ITEM's PC as the new best_end. */
2366 if (best
&& i
< len
&& item
->pc
> best
->pc
2367 && (best_end
== 0 || best_end
> item
->pc
))
2368 best_end
= item
->pc
;
2373 /* If we didn't find any line number info, just return zeros.
2374 We used to return alt->line - 1 here, but that could be
2375 anywhere; if we don't have line number info for this PC,
2376 don't make some up. */
2379 else if (best
->line
== 0)
2381 /* If our best fit is in a range of PC's for which no line
2382 number info is available (line number is zero) then we didn't
2383 find any valid line information. */
2388 val
.symtab
= best_symtab
;
2389 val
.line
= best
->line
;
2391 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2396 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2398 val
.section
= section
;
2402 /* Backward compatibility (no section). */
2404 struct symtab_and_line
2405 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2407 struct obj_section
*section
;
2409 section
= find_pc_overlay (pc
);
2410 if (pc_in_unmapped_range (pc
, section
))
2411 pc
= overlay_mapped_address (pc
, section
);
2412 return find_pc_sect_line (pc
, section
, notcurrent
);
2418 find_pc_line_symtab (CORE_ADDR pc
)
2420 struct symtab_and_line sal
;
2422 /* This always passes zero for NOTCURRENT to find_pc_line.
2423 There are currently no callers that ever pass non-zero. */
2424 sal
= find_pc_line (pc
, 0);
2428 /* Find line number LINE in any symtab whose name is the same as
2431 If found, return the symtab that contains the linetable in which it was
2432 found, set *INDEX to the index in the linetable of the best entry
2433 found, and set *EXACT_MATCH nonzero if the value returned is an
2436 If not found, return NULL. */
2439 find_line_symtab (struct symtab
*symtab
, int line
,
2440 int *index
, int *exact_match
)
2442 int exact
= 0; /* Initialized here to avoid a compiler warning. */
2444 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2448 struct linetable
*best_linetable
;
2449 struct symtab
*best_symtab
;
2451 /* First try looking it up in the given symtab. */
2452 best_linetable
= SYMTAB_LINETABLE (symtab
);
2453 best_symtab
= symtab
;
2454 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
2455 if (best_index
< 0 || !exact
)
2457 /* Didn't find an exact match. So we better keep looking for
2458 another symtab with the same name. In the case of xcoff,
2459 multiple csects for one source file (produced by IBM's FORTRAN
2460 compiler) produce multiple symtabs (this is unavoidable
2461 assuming csects can be at arbitrary places in memory and that
2462 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2464 /* BEST is the smallest linenumber > LINE so far seen,
2465 or 0 if none has been seen so far.
2466 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2469 struct objfile
*objfile
;
2470 struct compunit_symtab
*cu
;
2473 if (best_index
>= 0)
2474 best
= best_linetable
->item
[best_index
].line
;
2478 ALL_OBJFILES (objfile
)
2481 objfile
->sf
->qf
->expand_symtabs_with_fullname (objfile
,
2482 symtab_to_fullname (symtab
));
2485 ALL_FILETABS (objfile
, cu
, s
)
2487 struct linetable
*l
;
2490 if (FILENAME_CMP (symtab
->filename
, s
->filename
) != 0)
2492 if (FILENAME_CMP (symtab_to_fullname (symtab
),
2493 symtab_to_fullname (s
)) != 0)
2495 l
= SYMTAB_LINETABLE (s
);
2496 ind
= find_line_common (l
, line
, &exact
, 0);
2506 if (best
== 0 || l
->item
[ind
].line
< best
)
2508 best
= l
->item
[ind
].line
;
2521 *index
= best_index
;
2523 *exact_match
= exact
;
2528 /* Given SYMTAB, returns all the PCs function in the symtab that
2529 exactly match LINE. Returns NULL if there are no exact matches,
2530 but updates BEST_ITEM in this case. */
2533 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
2534 struct linetable_entry
**best_item
)
2537 VEC (CORE_ADDR
) *result
= NULL
;
2539 /* First, collect all the PCs that are at this line. */
2545 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
2552 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
2554 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
2560 VEC_safe_push (CORE_ADDR
, result
,
2561 SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
2569 /* Set the PC value for a given source file and line number and return true.
2570 Returns zero for invalid line number (and sets the PC to 0).
2571 The source file is specified with a struct symtab. */
2574 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2576 struct linetable
*l
;
2583 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2586 l
= SYMTAB_LINETABLE (symtab
);
2587 *pc
= l
->item
[ind
].pc
;
2594 /* Find the range of pc values in a line.
2595 Store the starting pc of the line into *STARTPTR
2596 and the ending pc (start of next line) into *ENDPTR.
2597 Returns 1 to indicate success.
2598 Returns 0 if could not find the specified line. */
2601 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2604 CORE_ADDR startaddr
;
2605 struct symtab_and_line found_sal
;
2608 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2611 /* This whole function is based on address. For example, if line 10 has
2612 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2613 "info line *0x123" should say the line goes from 0x100 to 0x200
2614 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2615 This also insures that we never give a range like "starts at 0x134
2616 and ends at 0x12c". */
2618 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2619 if (found_sal
.line
!= sal
.line
)
2621 /* The specified line (sal) has zero bytes. */
2622 *startptr
= found_sal
.pc
;
2623 *endptr
= found_sal
.pc
;
2627 *startptr
= found_sal
.pc
;
2628 *endptr
= found_sal
.end
;
2633 /* Given a line table and a line number, return the index into the line
2634 table for the pc of the nearest line whose number is >= the specified one.
2635 Return -1 if none is found. The value is >= 0 if it is an index.
2636 START is the index at which to start searching the line table.
2638 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2641 find_line_common (struct linetable
*l
, int lineno
,
2642 int *exact_match
, int start
)
2647 /* BEST is the smallest linenumber > LINENO so far seen,
2648 or 0 if none has been seen so far.
2649 BEST_INDEX identifies the item for it. */
2651 int best_index
= -1;
2662 for (i
= start
; i
< len
; i
++)
2664 struct linetable_entry
*item
= &(l
->item
[i
]);
2666 if (item
->line
== lineno
)
2668 /* Return the first (lowest address) entry which matches. */
2673 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2680 /* If we got here, we didn't get an exact match. */
2685 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2687 struct symtab_and_line sal
;
2689 sal
= find_pc_line (pc
, 0);
2692 return sal
.symtab
!= 0;
2695 /* Given a function symbol SYM, find the symtab and line for the start
2697 If the argument FUNFIRSTLINE is nonzero, we want the first line
2698 of real code inside the function. */
2700 struct symtab_and_line
2701 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2703 struct symtab_and_line sal
;
2705 fixup_symbol_section (sym
, NULL
);
2706 sal
= find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2707 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
), 0);
2709 /* We always should have a line for the function start address.
2710 If we don't, something is odd. Create a plain SAL refering
2711 just the PC and hope that skip_prologue_sal (if requested)
2712 can find a line number for after the prologue. */
2713 if (sal
.pc
< BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)))
2716 sal
.pspace
= current_program_space
;
2717 sal
.pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2718 sal
.section
= SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
);
2722 skip_prologue_sal (&sal
);
2727 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2728 address for that function that has an entry in SYMTAB's line info
2729 table. If such an entry cannot be found, return FUNC_ADDR
2733 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
2735 CORE_ADDR func_start
, func_end
;
2736 struct linetable
*l
;
2739 /* Give up if this symbol has no lineinfo table. */
2740 l
= SYMTAB_LINETABLE (symtab
);
2744 /* Get the range for the function's PC values, or give up if we
2745 cannot, for some reason. */
2746 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
2749 /* Linetable entries are ordered by PC values, see the commentary in
2750 symtab.h where `struct linetable' is defined. Thus, the first
2751 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2752 address we are looking for. */
2753 for (i
= 0; i
< l
->nitems
; i
++)
2755 struct linetable_entry
*item
= &(l
->item
[i
]);
2757 /* Don't use line numbers of zero, they mark special entries in
2758 the table. See the commentary on symtab.h before the
2759 definition of struct linetable. */
2760 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
2767 /* Adjust SAL to the first instruction past the function prologue.
2768 If the PC was explicitly specified, the SAL is not changed.
2769 If the line number was explicitly specified, at most the SAL's PC
2770 is updated. If SAL is already past the prologue, then do nothing. */
2773 skip_prologue_sal (struct symtab_and_line
*sal
)
2776 struct symtab_and_line start_sal
;
2777 struct cleanup
*old_chain
;
2778 CORE_ADDR pc
, saved_pc
;
2779 struct obj_section
*section
;
2781 struct objfile
*objfile
;
2782 struct gdbarch
*gdbarch
;
2783 const struct block
*b
, *function_block
;
2784 int force_skip
, skip
;
2786 /* Do not change the SAL if PC was specified explicitly. */
2787 if (sal
->explicit_pc
)
2790 old_chain
= save_current_space_and_thread ();
2791 switch_to_program_space_and_thread (sal
->pspace
);
2793 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
2796 fixup_symbol_section (sym
, NULL
);
2798 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2799 section
= SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
);
2800 name
= SYMBOL_LINKAGE_NAME (sym
);
2801 objfile
= SYMBOL_OBJFILE (sym
);
2805 struct bound_minimal_symbol msymbol
2806 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
2808 if (msymbol
.minsym
== NULL
)
2810 do_cleanups (old_chain
);
2814 objfile
= msymbol
.objfile
;
2815 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2816 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
2817 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
2820 gdbarch
= get_objfile_arch (objfile
);
2822 /* Process the prologue in two passes. In the first pass try to skip the
2823 prologue (SKIP is true) and verify there is a real need for it (indicated
2824 by FORCE_SKIP). If no such reason was found run a second pass where the
2825 prologue is not skipped (SKIP is false). */
2830 /* Be conservative - allow direct PC (without skipping prologue) only if we
2831 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2832 have to be set by the caller so we use SYM instead. */
2833 if (sym
&& COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (SYMBOL_SYMTAB (sym
))))
2841 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2842 so that gdbarch_skip_prologue has something unique to work on. */
2843 if (section_is_overlay (section
) && !section_is_mapped (section
))
2844 pc
= overlay_unmapped_address (pc
, section
);
2846 /* Skip "first line" of function (which is actually its prologue). */
2847 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2848 if (gdbarch_skip_entrypoint_p (gdbarch
))
2849 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
2851 pc
= gdbarch_skip_prologue (gdbarch
, pc
);
2853 /* For overlays, map pc back into its mapped VMA range. */
2854 pc
= overlay_mapped_address (pc
, section
);
2856 /* Calculate line number. */
2857 start_sal
= find_pc_sect_line (pc
, section
, 0);
2859 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2860 line is still part of the same function. */
2861 if (skip
&& start_sal
.pc
!= pc
2862 && (sym
? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
2863 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2864 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
2865 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
2867 /* First pc of next line */
2869 /* Recalculate the line number (might not be N+1). */
2870 start_sal
= find_pc_sect_line (pc
, section
, 0);
2873 /* On targets with executable formats that don't have a concept of
2874 constructors (ELF with .init has, PE doesn't), gcc emits a call
2875 to `__main' in `main' between the prologue and before user
2877 if (gdbarch_skip_main_prologue_p (gdbarch
)
2878 && name
&& strcmp_iw (name
, "main") == 0)
2880 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
2881 /* Recalculate the line number (might not be N+1). */
2882 start_sal
= find_pc_sect_line (pc
, section
, 0);
2886 while (!force_skip
&& skip
--);
2888 /* If we still don't have a valid source line, try to find the first
2889 PC in the lineinfo table that belongs to the same function. This
2890 happens with COFF debug info, which does not seem to have an
2891 entry in lineinfo table for the code after the prologue which has
2892 no direct relation to source. For example, this was found to be
2893 the case with the DJGPP target using "gcc -gcoff" when the
2894 compiler inserted code after the prologue to make sure the stack
2896 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
2898 pc
= skip_prologue_using_lineinfo (pc
, SYMBOL_SYMTAB (sym
));
2899 /* Recalculate the line number. */
2900 start_sal
= find_pc_sect_line (pc
, section
, 0);
2903 do_cleanups (old_chain
);
2905 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2906 forward SAL to the end of the prologue. */
2911 sal
->section
= section
;
2913 /* Unless the explicit_line flag was set, update the SAL line
2914 and symtab to correspond to the modified PC location. */
2915 if (sal
->explicit_line
)
2918 sal
->symtab
= start_sal
.symtab
;
2919 sal
->line
= start_sal
.line
;
2920 sal
->end
= start_sal
.end
;
2922 /* Check if we are now inside an inlined function. If we can,
2923 use the call site of the function instead. */
2924 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
2925 function_block
= NULL
;
2928 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
2930 else if (BLOCK_FUNCTION (b
) != NULL
)
2932 b
= BLOCK_SUPERBLOCK (b
);
2934 if (function_block
!= NULL
2935 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
2937 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
2938 sal
->symtab
= SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block
));
2942 /* Given PC at the function's start address, attempt to find the
2943 prologue end using SAL information. Return zero if the skip fails.
2945 A non-optimized prologue traditionally has one SAL for the function
2946 and a second for the function body. A single line function has
2947 them both pointing at the same line.
2949 An optimized prologue is similar but the prologue may contain
2950 instructions (SALs) from the instruction body. Need to skip those
2951 while not getting into the function body.
2953 The functions end point and an increasing SAL line are used as
2954 indicators of the prologue's endpoint.
2956 This code is based on the function refine_prologue_limit
2960 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
2962 struct symtab_and_line prologue_sal
;
2965 const struct block
*bl
;
2967 /* Get an initial range for the function. */
2968 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
2969 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2971 prologue_sal
= find_pc_line (start_pc
, 0);
2972 if (prologue_sal
.line
!= 0)
2974 /* For languages other than assembly, treat two consecutive line
2975 entries at the same address as a zero-instruction prologue.
2976 The GNU assembler emits separate line notes for each instruction
2977 in a multi-instruction macro, but compilers generally will not
2979 if (prologue_sal
.symtab
->language
!= language_asm
)
2981 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
2984 /* Skip any earlier lines, and any end-of-sequence marker
2985 from a previous function. */
2986 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
2987 || linetable
->item
[idx
].line
== 0)
2990 if (idx
+1 < linetable
->nitems
2991 && linetable
->item
[idx
+1].line
!= 0
2992 && linetable
->item
[idx
+1].pc
== start_pc
)
2996 /* If there is only one sal that covers the entire function,
2997 then it is probably a single line function, like
2999 if (prologue_sal
.end
>= end_pc
)
3002 while (prologue_sal
.end
< end_pc
)
3004 struct symtab_and_line sal
;
3006 sal
= find_pc_line (prologue_sal
.end
, 0);
3009 /* Assume that a consecutive SAL for the same (or larger)
3010 line mark the prologue -> body transition. */
3011 if (sal
.line
>= prologue_sal
.line
)
3013 /* Likewise if we are in a different symtab altogether
3014 (e.g. within a file included via #include). */
3015 if (sal
.symtab
!= prologue_sal
.symtab
)
3018 /* The line number is smaller. Check that it's from the
3019 same function, not something inlined. If it's inlined,
3020 then there is no point comparing the line numbers. */
3021 bl
= block_for_pc (prologue_sal
.end
);
3024 if (block_inlined_p (bl
))
3026 if (BLOCK_FUNCTION (bl
))
3031 bl
= BLOCK_SUPERBLOCK (bl
);
3036 /* The case in which compiler's optimizer/scheduler has
3037 moved instructions into the prologue. We look ahead in
3038 the function looking for address ranges whose
3039 corresponding line number is less the first one that we
3040 found for the function. This is more conservative then
3041 refine_prologue_limit which scans a large number of SALs
3042 looking for any in the prologue. */
3047 if (prologue_sal
.end
< end_pc
)
3048 /* Return the end of this line, or zero if we could not find a
3050 return prologue_sal
.end
;
3052 /* Don't return END_PC, which is past the end of the function. */
3053 return prologue_sal
.pc
;
3056 /* If P is of the form "operator[ \t]+..." where `...' is
3057 some legitimate operator text, return a pointer to the
3058 beginning of the substring of the operator text.
3059 Otherwise, return "". */
3062 operator_chars (const char *p
, const char **end
)
3065 if (strncmp (p
, "operator", 8))
3069 /* Don't get faked out by `operator' being part of a longer
3071 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
3074 /* Allow some whitespace between `operator' and the operator symbol. */
3075 while (*p
== ' ' || *p
== '\t')
3078 /* Recognize 'operator TYPENAME'. */
3080 if (isalpha (*p
) || *p
== '_' || *p
== '$')
3082 const char *q
= p
+ 1;
3084 while (isalnum (*q
) || *q
== '_' || *q
== '$')
3093 case '\\': /* regexp quoting */
3096 if (p
[2] == '=') /* 'operator\*=' */
3098 else /* 'operator\*' */
3102 else if (p
[1] == '[')
3105 error (_("mismatched quoting on brackets, "
3106 "try 'operator\\[\\]'"));
3107 else if (p
[2] == '\\' && p
[3] == ']')
3109 *end
= p
+ 4; /* 'operator\[\]' */
3113 error (_("nothing is allowed between '[' and ']'"));
3117 /* Gratuitous qoute: skip it and move on. */
3139 if (p
[0] == '-' && p
[1] == '>')
3141 /* Struct pointer member operator 'operator->'. */
3144 *end
= p
+ 3; /* 'operator->*' */
3147 else if (p
[2] == '\\')
3149 *end
= p
+ 4; /* Hopefully 'operator->\*' */
3154 *end
= p
+ 2; /* 'operator->' */
3158 if (p
[1] == '=' || p
[1] == p
[0])
3169 error (_("`operator ()' must be specified "
3170 "without whitespace in `()'"));
3175 error (_("`operator ?:' must be specified "
3176 "without whitespace in `?:'"));
3181 error (_("`operator []' must be specified "
3182 "without whitespace in `[]'"));
3186 error (_("`operator %s' not supported"), p
);
3195 /* Cache to watch for file names already seen by filename_seen. */
3197 struct filename_seen_cache
3199 /* Table of files seen so far. */
3201 /* Initial size of the table. It automagically grows from here. */
3202 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
3205 /* filename_seen_cache constructor. */
3207 static struct filename_seen_cache
*
3208 create_filename_seen_cache (void)
3210 struct filename_seen_cache
*cache
;
3212 cache
= XNEW (struct filename_seen_cache
);
3213 cache
->tab
= htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE
,
3214 filename_hash
, filename_eq
,
3215 NULL
, xcalloc
, xfree
);
3220 /* Empty the cache, but do not delete it. */
3223 clear_filename_seen_cache (struct filename_seen_cache
*cache
)
3225 htab_empty (cache
->tab
);
3228 /* filename_seen_cache destructor.
3229 This takes a void * argument as it is generally used as a cleanup. */
3232 delete_filename_seen_cache (void *ptr
)
3234 struct filename_seen_cache
*cache
= ptr
;
3236 htab_delete (cache
->tab
);
3240 /* If FILE is not already in the table of files in CACHE, return zero;
3241 otherwise return non-zero. Optionally add FILE to the table if ADD
3244 NOTE: We don't manage space for FILE, we assume FILE lives as long
3245 as the caller needs. */
3248 filename_seen (struct filename_seen_cache
*cache
, const char *file
, int add
)
3252 /* Is FILE in tab? */
3253 slot
= htab_find_slot (cache
->tab
, file
, add
? INSERT
: NO_INSERT
);
3257 /* No; maybe add it to tab. */
3259 *slot
= (char *) file
;
3264 /* Data structure to maintain printing state for output_source_filename. */
3266 struct output_source_filename_data
3268 /* Cache of what we've seen so far. */
3269 struct filename_seen_cache
*filename_seen_cache
;
3271 /* Flag of whether we're printing the first one. */
3275 /* Slave routine for sources_info. Force line breaks at ,'s.
3276 NAME is the name to print.
3277 DATA contains the state for printing and watching for duplicates. */
3280 output_source_filename (const char *name
,
3281 struct output_source_filename_data
*data
)
3283 /* Since a single source file can result in several partial symbol
3284 tables, we need to avoid printing it more than once. Note: if
3285 some of the psymtabs are read in and some are not, it gets
3286 printed both under "Source files for which symbols have been
3287 read" and "Source files for which symbols will be read in on
3288 demand". I consider this a reasonable way to deal with the
3289 situation. I'm not sure whether this can also happen for
3290 symtabs; it doesn't hurt to check. */
3292 /* Was NAME already seen? */
3293 if (filename_seen (data
->filename_seen_cache
, name
, 1))
3295 /* Yes; don't print it again. */
3299 /* No; print it and reset *FIRST. */
3301 printf_filtered (", ");
3305 fputs_filtered (name
, gdb_stdout
);
3308 /* A callback for map_partial_symbol_filenames. */
3311 output_partial_symbol_filename (const char *filename
, const char *fullname
,
3314 output_source_filename (fullname
? fullname
: filename
, data
);
3318 sources_info (char *ignore
, int from_tty
)
3320 struct compunit_symtab
*cu
;
3322 struct objfile
*objfile
;
3323 struct output_source_filename_data data
;
3324 struct cleanup
*cleanups
;
3326 if (!have_full_symbols () && !have_partial_symbols ())
3328 error (_("No symbol table is loaded. Use the \"file\" command."));
3331 data
.filename_seen_cache
= create_filename_seen_cache ();
3332 cleanups
= make_cleanup (delete_filename_seen_cache
,
3333 data
.filename_seen_cache
);
3335 printf_filtered ("Source files for which symbols have been read in:\n\n");
3338 ALL_FILETABS (objfile
, cu
, s
)
3340 const char *fullname
= symtab_to_fullname (s
);
3342 output_source_filename (fullname
, &data
);
3344 printf_filtered ("\n\n");
3346 printf_filtered ("Source files for which symbols "
3347 "will be read in on demand:\n\n");
3349 clear_filename_seen_cache (data
.filename_seen_cache
);
3351 map_symbol_filenames (output_partial_symbol_filename
, &data
,
3352 1 /*need_fullname*/);
3353 printf_filtered ("\n");
3355 do_cleanups (cleanups
);
3358 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
3359 non-zero compare only lbasename of FILES. */
3362 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
3366 if (file
!= NULL
&& nfiles
!= 0)
3368 for (i
= 0; i
< nfiles
; i
++)
3370 if (compare_filenames_for_search (file
, (basenames
3371 ? lbasename (files
[i
])
3376 else if (nfiles
== 0)
3381 /* Free any memory associated with a search. */
3384 free_search_symbols (struct symbol_search
*symbols
)
3386 struct symbol_search
*p
;
3387 struct symbol_search
*next
;
3389 for (p
= symbols
; p
!= NULL
; p
= next
)
3397 do_free_search_symbols_cleanup (void *symbolsp
)
3399 struct symbol_search
*symbols
= *(struct symbol_search
**) symbolsp
;
3401 free_search_symbols (symbols
);
3405 make_cleanup_free_search_symbols (struct symbol_search
**symbolsp
)
3407 return make_cleanup (do_free_search_symbols_cleanup
, symbolsp
);
3410 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
3411 sort symbols, not minimal symbols. */
3414 compare_search_syms (const void *sa
, const void *sb
)
3416 struct symbol_search
*sym_a
= *(struct symbol_search
**) sa
;
3417 struct symbol_search
*sym_b
= *(struct symbol_search
**) sb
;
3420 c
= FILENAME_CMP (sym_a
->symtab
->filename
, sym_b
->symtab
->filename
);
3424 if (sym_a
->block
!= sym_b
->block
)
3425 return sym_a
->block
- sym_b
->block
;
3427 return strcmp (SYMBOL_PRINT_NAME (sym_a
->symbol
),
3428 SYMBOL_PRINT_NAME (sym_b
->symbol
));
3431 /* Sort the NFOUND symbols in list FOUND and remove duplicates.
3432 The duplicates are freed, and the new list is returned in
3433 *NEW_HEAD, *NEW_TAIL. */
3436 sort_search_symbols_remove_dups (struct symbol_search
*found
, int nfound
,
3437 struct symbol_search
**new_head
,
3438 struct symbol_search
**new_tail
)
3440 struct symbol_search
**symbols
, *symp
, *old_next
;
3443 gdb_assert (found
!= NULL
&& nfound
> 0);
3445 /* Build an array out of the list so we can easily sort them. */
3446 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
3449 for (i
= 0; i
< nfound
; i
++)
3451 gdb_assert (symp
!= NULL
);
3452 gdb_assert (symp
->block
>= 0 && symp
->block
<= 1);
3456 gdb_assert (symp
== NULL
);
3458 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
3459 compare_search_syms
);
3461 /* Collapse out the dups. */
3462 for (i
= 1, j
= 1; i
< nfound
; ++i
)
3464 if (compare_search_syms (&symbols
[j
- 1], &symbols
[i
]) != 0)
3465 symbols
[j
++] = symbols
[i
];
3470 symbols
[j
- 1]->next
= NULL
;
3472 /* Rebuild the linked list. */
3473 for (i
= 0; i
< nunique
- 1; i
++)
3474 symbols
[i
]->next
= symbols
[i
+ 1];
3475 symbols
[nunique
- 1]->next
= NULL
;
3477 *new_head
= symbols
[0];
3478 *new_tail
= symbols
[nunique
- 1];
3482 /* An object of this type is passed as the user_data to the
3483 expand_symtabs_matching method. */
3484 struct search_symbols_data
3489 /* It is true if PREG contains valid data, false otherwise. */
3490 unsigned preg_p
: 1;
3494 /* A callback for expand_symtabs_matching. */
3497 search_symbols_file_matches (const char *filename
, void *user_data
,
3500 struct search_symbols_data
*data
= user_data
;
3502 return file_matches (filename
, data
->files
, data
->nfiles
, basenames
);
3505 /* A callback for expand_symtabs_matching. */
3508 search_symbols_name_matches (const char *symname
, void *user_data
)
3510 struct search_symbols_data
*data
= user_data
;
3512 return !data
->preg_p
|| regexec (&data
->preg
, symname
, 0, NULL
, 0) == 0;
3515 /* Search the symbol table for matches to the regular expression REGEXP,
3516 returning the results in *MATCHES.
3518 Only symbols of KIND are searched:
3519 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3520 and constants (enums)
3521 FUNCTIONS_DOMAIN - search all functions
3522 TYPES_DOMAIN - search all type names
3523 ALL_DOMAIN - an internal error for this function
3525 free_search_symbols should be called when *MATCHES is no longer needed.
3527 Within each file the results are sorted locally; each symtab's global and
3528 static blocks are separately alphabetized.
3529 Duplicate entries are removed. */
3532 search_symbols (const char *regexp
, enum search_domain kind
,
3533 int nfiles
, const char *files
[],
3534 struct symbol_search
**matches
)
3536 struct compunit_symtab
*cust
;
3537 const struct blockvector
*bv
;
3540 struct block_iterator iter
;
3542 struct objfile
*objfile
;
3543 struct minimal_symbol
*msymbol
;
3545 static const enum minimal_symbol_type types
[]
3546 = {mst_data
, mst_text
, mst_abs
};
3547 static const enum minimal_symbol_type types2
[]
3548 = {mst_bss
, mst_file_text
, mst_abs
};
3549 static const enum minimal_symbol_type types3
[]
3550 = {mst_file_data
, mst_solib_trampoline
, mst_abs
};
3551 static const enum minimal_symbol_type types4
[]
3552 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_abs
};
3553 enum minimal_symbol_type ourtype
;
3554 enum minimal_symbol_type ourtype2
;
3555 enum minimal_symbol_type ourtype3
;
3556 enum minimal_symbol_type ourtype4
;
3557 struct symbol_search
*found
;
3558 struct symbol_search
*tail
;
3559 struct search_symbols_data datum
;
3562 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3563 CLEANUP_CHAIN is freed only in the case of an error. */
3564 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3565 struct cleanup
*retval_chain
;
3567 gdb_assert (kind
<= TYPES_DOMAIN
);
3569 ourtype
= types
[kind
];
3570 ourtype2
= types2
[kind
];
3571 ourtype3
= types3
[kind
];
3572 ourtype4
= types4
[kind
];
3579 /* Make sure spacing is right for C++ operators.
3580 This is just a courtesy to make the matching less sensitive
3581 to how many spaces the user leaves between 'operator'
3582 and <TYPENAME> or <OPERATOR>. */
3584 const char *opname
= operator_chars (regexp
, &opend
);
3589 int fix
= -1; /* -1 means ok; otherwise number of
3592 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
3594 /* There should 1 space between 'operator' and 'TYPENAME'. */
3595 if (opname
[-1] != ' ' || opname
[-2] == ' ')
3600 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3601 if (opname
[-1] == ' ')
3604 /* If wrong number of spaces, fix it. */
3607 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
3609 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3614 errcode
= regcomp (&datum
.preg
, regexp
,
3615 REG_NOSUB
| (case_sensitivity
== case_sensitive_off
3619 char *err
= get_regcomp_error (errcode
, &datum
.preg
);
3621 make_cleanup (xfree
, err
);
3622 error (_("Invalid regexp (%s): %s"), err
, regexp
);
3625 make_regfree_cleanup (&datum
.preg
);
3628 /* Search through the partial symtabs *first* for all symbols
3629 matching the regexp. That way we don't have to reproduce all of
3630 the machinery below. */
3632 datum
.nfiles
= nfiles
;
3633 datum
.files
= files
;
3634 expand_symtabs_matching ((nfiles
== 0
3636 : search_symbols_file_matches
),
3637 search_symbols_name_matches
,
3640 /* Here, we search through the minimal symbol tables for functions
3641 and variables that match, and force their symbols to be read.
3642 This is in particular necessary for demangled variable names,
3643 which are no longer put into the partial symbol tables.
3644 The symbol will then be found during the scan of symtabs below.
3646 For functions, find_pc_symtab should succeed if we have debug info
3647 for the function, for variables we have to call
3648 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3650 If the lookup fails, set found_misc so that we will rescan to print
3651 any matching symbols without debug info.
3652 We only search the objfile the msymbol came from, we no longer search
3653 all objfiles. In large programs (1000s of shared libs) searching all
3654 objfiles is not worth the pain. */
3656 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3658 ALL_MSYMBOLS (objfile
, msymbol
)
3662 if (msymbol
->created_by_gdb
)
3665 if (MSYMBOL_TYPE (msymbol
) == ourtype
3666 || MSYMBOL_TYPE (msymbol
) == ourtype2
3667 || MSYMBOL_TYPE (msymbol
) == ourtype3
3668 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
3671 || regexec (&datum
.preg
, MSYMBOL_NATURAL_NAME (msymbol
), 0,
3674 /* Note: An important side-effect of these lookup functions
3675 is to expand the symbol table if msymbol is found, for the
3676 benefit of the next loop on ALL_COMPUNITS. */
3677 if (kind
== FUNCTIONS_DOMAIN
3678 ? (find_pc_compunit_symtab
3679 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
)) == NULL
)
3680 : (lookup_symbol_in_objfile_from_linkage_name
3681 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
3692 retval_chain
= make_cleanup_free_search_symbols (&found
);
3694 ALL_COMPUNITS (objfile
, cust
)
3696 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3697 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3699 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3700 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3702 struct symtab
*real_symtab
= SYMBOL_SYMTAB (sym
);
3706 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
3707 a substring of symtab_to_fullname as it may contain "./" etc. */
3708 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
3709 || ((basenames_may_differ
3710 || file_matches (lbasename (real_symtab
->filename
),
3712 && file_matches (symtab_to_fullname (real_symtab
),
3715 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (sym
), 0,
3717 && ((kind
== VARIABLES_DOMAIN
3718 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3719 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
3720 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3721 /* LOC_CONST can be used for more than just enums,
3722 e.g., c++ static const members.
3723 We only want to skip enums here. */
3724 && !(SYMBOL_CLASS (sym
) == LOC_CONST
3725 && (TYPE_CODE (SYMBOL_TYPE (sym
))
3726 == TYPE_CODE_ENUM
)))
3727 || (kind
== FUNCTIONS_DOMAIN
3728 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3729 || (kind
== TYPES_DOMAIN
3730 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
3733 struct symbol_search
*psr
= (struct symbol_search
*)
3734 xmalloc (sizeof (struct symbol_search
));
3736 psr
->symtab
= real_symtab
;
3738 memset (&psr
->msymbol
, 0, sizeof (psr
->msymbol
));
3753 sort_search_symbols_remove_dups (found
, nfound
, &found
, &tail
);
3754 /* Note: nfound is no longer useful beyond this point. */
3757 /* If there are no eyes, avoid all contact. I mean, if there are
3758 no debug symbols, then add matching minsyms. */
3760 if (found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
3762 ALL_MSYMBOLS (objfile
, msymbol
)
3766 if (msymbol
->created_by_gdb
)
3769 if (MSYMBOL_TYPE (msymbol
) == ourtype
3770 || MSYMBOL_TYPE (msymbol
) == ourtype2
3771 || MSYMBOL_TYPE (msymbol
) == ourtype3
3772 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
3775 || regexec (&datum
.preg
, MSYMBOL_NATURAL_NAME (msymbol
), 0,
3778 /* For functions we can do a quick check of whether the
3779 symbol might be found via find_pc_symtab. */
3780 if (kind
!= FUNCTIONS_DOMAIN
3781 || (find_pc_compunit_symtab
3782 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
)) == NULL
))
3784 if (lookup_symbol_in_objfile_from_linkage_name
3785 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
3789 struct symbol_search
*psr
= (struct symbol_search
*)
3790 xmalloc (sizeof (struct symbol_search
));
3792 psr
->msymbol
.minsym
= msymbol
;
3793 psr
->msymbol
.objfile
= objfile
;
3809 discard_cleanups (retval_chain
);
3810 do_cleanups (old_chain
);
3814 /* Helper function for symtab_symbol_info, this function uses
3815 the data returned from search_symbols() to print information
3816 regarding the match to gdb_stdout. */
3819 print_symbol_info (enum search_domain kind
,
3820 struct symtab
*s
, struct symbol
*sym
,
3821 int block
, const char *last
)
3823 const char *s_filename
= symtab_to_filename_for_display (s
);
3825 if (last
== NULL
|| filename_cmp (last
, s_filename
) != 0)
3827 fputs_filtered ("\nFile ", gdb_stdout
);
3828 fputs_filtered (s_filename
, gdb_stdout
);
3829 fputs_filtered (":\n", gdb_stdout
);
3832 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3833 printf_filtered ("static ");
3835 /* Typedef that is not a C++ class. */
3836 if (kind
== TYPES_DOMAIN
3837 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3838 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3839 /* variable, func, or typedef-that-is-c++-class. */
3840 else if (kind
< TYPES_DOMAIN
3841 || (kind
== TYPES_DOMAIN
3842 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3844 type_print (SYMBOL_TYPE (sym
),
3845 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3846 ? "" : SYMBOL_PRINT_NAME (sym
)),
3849 printf_filtered (";\n");
3853 /* This help function for symtab_symbol_info() prints information
3854 for non-debugging symbols to gdb_stdout. */
3857 print_msymbol_info (struct bound_minimal_symbol msymbol
)
3859 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
3862 if (gdbarch_addr_bit (gdbarch
) <= 32)
3863 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
3864 & (CORE_ADDR
) 0xffffffff,
3867 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
3869 printf_filtered ("%s %s\n",
3870 tmp
, MSYMBOL_PRINT_NAME (msymbol
.minsym
));
3873 /* This is the guts of the commands "info functions", "info types", and
3874 "info variables". It calls search_symbols to find all matches and then
3875 print_[m]symbol_info to print out some useful information about the
3879 symtab_symbol_info (char *regexp
, enum search_domain kind
, int from_tty
)
3881 static const char * const classnames
[] =
3882 {"variable", "function", "type"};
3883 struct symbol_search
*symbols
;
3884 struct symbol_search
*p
;
3885 struct cleanup
*old_chain
;
3886 const char *last_filename
= NULL
;
3889 gdb_assert (kind
<= TYPES_DOMAIN
);
3891 /* Must make sure that if we're interrupted, symbols gets freed. */
3892 search_symbols (regexp
, kind
, 0, NULL
, &symbols
);
3893 old_chain
= make_cleanup_free_search_symbols (&symbols
);
3896 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3897 classnames
[kind
], regexp
);
3899 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
3901 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3905 if (p
->msymbol
.minsym
!= NULL
)
3909 printf_filtered (_("\nNon-debugging symbols:\n"));
3912 print_msymbol_info (p
->msymbol
);
3916 print_symbol_info (kind
,
3921 last_filename
= symtab_to_filename_for_display (p
->symtab
);
3925 do_cleanups (old_chain
);
3929 variables_info (char *regexp
, int from_tty
)
3931 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3935 functions_info (char *regexp
, int from_tty
)
3937 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3942 types_info (char *regexp
, int from_tty
)
3944 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3947 /* Breakpoint all functions matching regular expression. */
3950 rbreak_command_wrapper (char *regexp
, int from_tty
)
3952 rbreak_command (regexp
, from_tty
);
3955 /* A cleanup function that calls end_rbreak_breakpoints. */
3958 do_end_rbreak_breakpoints (void *ignore
)
3960 end_rbreak_breakpoints ();
3964 rbreak_command (char *regexp
, int from_tty
)
3966 struct symbol_search
*ss
;
3967 struct symbol_search
*p
;
3968 struct cleanup
*old_chain
;
3969 char *string
= NULL
;
3971 const char **files
= NULL
;
3972 const char *file_name
;
3977 char *colon
= strchr (regexp
, ':');
3979 if (colon
&& *(colon
+ 1) != ':')
3984 colon_index
= colon
- regexp
;
3985 local_name
= alloca (colon_index
+ 1);
3986 memcpy (local_name
, regexp
, colon_index
);
3987 local_name
[colon_index
--] = 0;
3988 while (isspace (local_name
[colon_index
]))
3989 local_name
[colon_index
--] = 0;
3990 file_name
= local_name
;
3993 regexp
= skip_spaces (colon
+ 1);
3997 search_symbols (regexp
, FUNCTIONS_DOMAIN
, nfiles
, files
, &ss
);
3998 old_chain
= make_cleanup_free_search_symbols (&ss
);
3999 make_cleanup (free_current_contents
, &string
);
4001 start_rbreak_breakpoints ();
4002 make_cleanup (do_end_rbreak_breakpoints
, NULL
);
4003 for (p
= ss
; p
!= NULL
; p
= p
->next
)
4005 if (p
->msymbol
.minsym
== NULL
)
4007 const char *fullname
= symtab_to_fullname (p
->symtab
);
4009 int newlen
= (strlen (fullname
)
4010 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
4015 string
= xrealloc (string
, newlen
);
4018 strcpy (string
, fullname
);
4019 strcat (string
, ":'");
4020 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
4021 strcat (string
, "'");
4022 break_command (string
, from_tty
);
4023 print_symbol_info (FUNCTIONS_DOMAIN
,
4027 symtab_to_filename_for_display (p
->symtab
));
4031 int newlen
= (strlen (MSYMBOL_LINKAGE_NAME (p
->msymbol
.minsym
)) + 3);
4035 string
= xrealloc (string
, newlen
);
4038 strcpy (string
, "'");
4039 strcat (string
, MSYMBOL_LINKAGE_NAME (p
->msymbol
.minsym
));
4040 strcat (string
, "'");
4042 break_command (string
, from_tty
);
4043 printf_filtered ("<function, no debug info> %s;\n",
4044 MSYMBOL_PRINT_NAME (p
->msymbol
.minsym
));
4048 do_cleanups (old_chain
);
4052 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
4054 Either sym_text[sym_text_len] != '(' and then we search for any
4055 symbol starting with SYM_TEXT text.
4057 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
4058 be terminated at that point. Partial symbol tables do not have parameters
4062 compare_symbol_name (const char *name
, const char *sym_text
, int sym_text_len
)
4064 int (*ncmp
) (const char *, const char *, size_t);
4066 ncmp
= (case_sensitivity
== case_sensitive_on
? strncmp
: strncasecmp
);
4068 if (ncmp (name
, sym_text
, sym_text_len
) != 0)
4071 if (sym_text
[sym_text_len
] == '(')
4073 /* User searches for `name(someth...'. Require NAME to be terminated.
4074 Normally psymtabs and gdbindex have no parameter types so '\0' will be
4075 present but accept even parameters presence. In this case this
4076 function is in fact strcmp_iw but whitespace skipping is not supported
4077 for tab completion. */
4079 if (name
[sym_text_len
] != '\0' && name
[sym_text_len
] != '(')
4086 /* Free any memory associated with a completion list. */
4089 free_completion_list (VEC (char_ptr
) **list_ptr
)
4094 for (i
= 0; VEC_iterate (char_ptr
, *list_ptr
, i
, p
); ++i
)
4096 VEC_free (char_ptr
, *list_ptr
);
4099 /* Callback for make_cleanup. */
4102 do_free_completion_list (void *list
)
4104 free_completion_list (list
);
4107 /* Helper routine for make_symbol_completion_list. */
4109 static VEC (char_ptr
) *return_val
;
4111 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4112 completion_list_add_name \
4113 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4115 #define MCOMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4116 completion_list_add_name \
4117 (MSYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4119 /* Test to see if the symbol specified by SYMNAME (which is already
4120 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4121 characters. If so, add it to the current completion list. */
4124 completion_list_add_name (const char *symname
,
4125 const char *sym_text
, int sym_text_len
,
4126 const char *text
, const char *word
)
4128 /* Clip symbols that cannot match. */
4129 if (!compare_symbol_name (symname
, sym_text
, sym_text_len
))
4132 /* We have a match for a completion, so add SYMNAME to the current list
4133 of matches. Note that the name is moved to freshly malloc'd space. */
4138 if (word
== sym_text
)
4140 new = xmalloc (strlen (symname
) + 5);
4141 strcpy (new, symname
);
4143 else if (word
> sym_text
)
4145 /* Return some portion of symname. */
4146 new = xmalloc (strlen (symname
) + 5);
4147 strcpy (new, symname
+ (word
- sym_text
));
4151 /* Return some of SYM_TEXT plus symname. */
4152 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
4153 strncpy (new, word
, sym_text
- word
);
4154 new[sym_text
- word
] = '\0';
4155 strcat (new, symname
);
4158 VEC_safe_push (char_ptr
, return_val
, new);
4162 /* ObjC: In case we are completing on a selector, look as the msymbol
4163 again and feed all the selectors into the mill. */
4166 completion_list_objc_symbol (struct minimal_symbol
*msymbol
,
4167 const char *sym_text
, int sym_text_len
,
4168 const char *text
, const char *word
)
4170 static char *tmp
= NULL
;
4171 static unsigned int tmplen
= 0;
4173 const char *method
, *category
, *selector
;
4176 method
= MSYMBOL_NATURAL_NAME (msymbol
);
4178 /* Is it a method? */
4179 if ((method
[0] != '-') && (method
[0] != '+'))
4182 if (sym_text
[0] == '[')
4183 /* Complete on shortened method method. */
4184 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
4186 while ((strlen (method
) + 1) >= tmplen
)
4192 tmp
= xrealloc (tmp
, tmplen
);
4194 selector
= strchr (method
, ' ');
4195 if (selector
!= NULL
)
4198 category
= strchr (method
, '(');
4200 if ((category
!= NULL
) && (selector
!= NULL
))
4202 memcpy (tmp
, method
, (category
- method
));
4203 tmp
[category
- method
] = ' ';
4204 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
4205 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
4206 if (sym_text
[0] == '[')
4207 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
4210 if (selector
!= NULL
)
4212 /* Complete on selector only. */
4213 strcpy (tmp
, selector
);
4214 tmp2
= strchr (tmp
, ']');
4218 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
4222 /* Break the non-quoted text based on the characters which are in
4223 symbols. FIXME: This should probably be language-specific. */
4226 language_search_unquoted_string (const char *text
, const char *p
)
4228 for (; p
> text
; --p
)
4230 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
4234 if ((current_language
->la_language
== language_objc
))
4236 if (p
[-1] == ':') /* Might be part of a method name. */
4238 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
4239 p
-= 2; /* Beginning of a method name. */
4240 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
4241 { /* Might be part of a method name. */
4244 /* Seeing a ' ' or a '(' is not conclusive evidence
4245 that we are in the middle of a method name. However,
4246 finding "-[" or "+[" should be pretty un-ambiguous.
4247 Unfortunately we have to find it now to decide. */
4250 if (isalnum (t
[-1]) || t
[-1] == '_' ||
4251 t
[-1] == ' ' || t
[-1] == ':' ||
4252 t
[-1] == '(' || t
[-1] == ')')
4257 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
4258 p
= t
- 2; /* Method name detected. */
4259 /* Else we leave with p unchanged. */
4269 completion_list_add_fields (struct symbol
*sym
, const char *sym_text
,
4270 int sym_text_len
, const char *text
,
4273 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
4275 struct type
*t
= SYMBOL_TYPE (sym
);
4276 enum type_code c
= TYPE_CODE (t
);
4279 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
4280 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
4281 if (TYPE_FIELD_NAME (t
, j
))
4282 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
4283 sym_text
, sym_text_len
, text
, word
);
4287 /* Type of the user_data argument passed to add_macro_name or
4288 symbol_completion_matcher. The contents are simply whatever is
4289 needed by completion_list_add_name. */
4290 struct add_name_data
4292 const char *sym_text
;
4298 /* A callback used with macro_for_each and macro_for_each_in_scope.
4299 This adds a macro's name to the current completion list. */
4302 add_macro_name (const char *name
, const struct macro_definition
*ignore
,
4303 struct macro_source_file
*ignore2
, int ignore3
,
4306 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
4308 completion_list_add_name (name
,
4309 datum
->sym_text
, datum
->sym_text_len
,
4310 datum
->text
, datum
->word
);
4313 /* A callback for expand_symtabs_matching. */
4316 symbol_completion_matcher (const char *name
, void *user_data
)
4318 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
4320 return compare_symbol_name (name
, datum
->sym_text
, datum
->sym_text_len
);
4324 default_make_symbol_completion_list_break_on (const char *text
,
4326 const char *break_on
,
4327 enum type_code code
)
4329 /* Problem: All of the symbols have to be copied because readline
4330 frees them. I'm not going to worry about this; hopefully there
4331 won't be that many. */
4334 struct compunit_symtab
*cust
;
4335 struct minimal_symbol
*msymbol
;
4336 struct objfile
*objfile
;
4337 const struct block
*b
;
4338 const struct block
*surrounding_static_block
, *surrounding_global_block
;
4339 struct block_iterator iter
;
4340 /* The symbol we are completing on. Points in same buffer as text. */
4341 const char *sym_text
;
4342 /* Length of sym_text. */
4344 struct add_name_data datum
;
4345 struct cleanup
*back_to
;
4347 /* Now look for the symbol we are supposed to complete on. */
4351 const char *quote_pos
= NULL
;
4353 /* First see if this is a quoted string. */
4355 for (p
= text
; *p
!= '\0'; ++p
)
4357 if (quote_found
!= '\0')
4359 if (*p
== quote_found
)
4360 /* Found close quote. */
4362 else if (*p
== '\\' && p
[1] == quote_found
)
4363 /* A backslash followed by the quote character
4364 doesn't end the string. */
4367 else if (*p
== '\'' || *p
== '"')
4373 if (quote_found
== '\'')
4374 /* A string within single quotes can be a symbol, so complete on it. */
4375 sym_text
= quote_pos
+ 1;
4376 else if (quote_found
== '"')
4377 /* A double-quoted string is never a symbol, nor does it make sense
4378 to complete it any other way. */
4384 /* It is not a quoted string. Break it based on the characters
4385 which are in symbols. */
4388 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
4389 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
4398 sym_text_len
= strlen (sym_text
);
4400 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4402 if (current_language
->la_language
== language_cplus
4403 || current_language
->la_language
== language_java
4404 || current_language
->la_language
== language_fortran
)
4406 /* These languages may have parameters entered by user but they are never
4407 present in the partial symbol tables. */
4409 const char *cs
= memchr (sym_text
, '(', sym_text_len
);
4412 sym_text_len
= cs
- sym_text
;
4414 gdb_assert (sym_text
[sym_text_len
] == '\0' || sym_text
[sym_text_len
] == '(');
4417 back_to
= make_cleanup (do_free_completion_list
, &return_val
);
4419 datum
.sym_text
= sym_text
;
4420 datum
.sym_text_len
= sym_text_len
;
4424 /* Look through the partial symtabs for all symbols which begin
4425 by matching SYM_TEXT. Expand all CUs that you find to the list.
4426 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4427 expand_symtabs_matching (NULL
, symbol_completion_matcher
, ALL_DOMAIN
,
4430 /* At this point scan through the misc symbol vectors and add each
4431 symbol you find to the list. Eventually we want to ignore
4432 anything that isn't a text symbol (everything else will be
4433 handled by the psymtab code above). */
4435 if (code
== TYPE_CODE_UNDEF
)
4437 ALL_MSYMBOLS (objfile
, msymbol
)
4440 MCOMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
,
4443 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
,
4448 /* Search upwards from currently selected frame (so that we can
4449 complete on local vars). Also catch fields of types defined in
4450 this places which match our text string. Only complete on types
4451 visible from current context. */
4453 b
= get_selected_block (0);
4454 surrounding_static_block
= block_static_block (b
);
4455 surrounding_global_block
= block_global_block (b
);
4456 if (surrounding_static_block
!= NULL
)
4457 while (b
!= surrounding_static_block
)
4461 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4463 if (code
== TYPE_CODE_UNDEF
)
4465 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4467 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
,
4470 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4471 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
4472 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4476 /* Stop when we encounter an enclosing function. Do not stop for
4477 non-inlined functions - the locals of the enclosing function
4478 are in scope for a nested function. */
4479 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
4481 b
= BLOCK_SUPERBLOCK (b
);
4484 /* Add fields from the file's types; symbols will be added below. */
4486 if (code
== TYPE_CODE_UNDEF
)
4488 if (surrounding_static_block
!= NULL
)
4489 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
4490 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4492 if (surrounding_global_block
!= NULL
)
4493 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
4494 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4497 /* Go through the symtabs and check the externs and statics for
4498 symbols which match. */
4500 ALL_COMPUNITS (objfile
, cust
)
4503 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), GLOBAL_BLOCK
);
4504 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4506 if (code
== TYPE_CODE_UNDEF
4507 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4508 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4509 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4513 ALL_COMPUNITS (objfile
, cust
)
4516 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), STATIC_BLOCK
);
4517 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4519 if (code
== TYPE_CODE_UNDEF
4520 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4521 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4522 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4526 /* Skip macros if we are completing a struct tag -- arguable but
4527 usually what is expected. */
4528 if (current_language
->la_macro_expansion
== macro_expansion_c
4529 && code
== TYPE_CODE_UNDEF
)
4531 struct macro_scope
*scope
;
4533 /* Add any macros visible in the default scope. Note that this
4534 may yield the occasional wrong result, because an expression
4535 might be evaluated in a scope other than the default. For
4536 example, if the user types "break file:line if <TAB>", the
4537 resulting expression will be evaluated at "file:line" -- but
4538 at there does not seem to be a way to detect this at
4540 scope
= default_macro_scope ();
4543 macro_for_each_in_scope (scope
->file
, scope
->line
,
4544 add_macro_name
, &datum
);
4548 /* User-defined macros are always visible. */
4549 macro_for_each (macro_user_macros
, add_macro_name
, &datum
);
4552 discard_cleanups (back_to
);
4553 return (return_val
);
4557 default_make_symbol_completion_list (const char *text
, const char *word
,
4558 enum type_code code
)
4560 return default_make_symbol_completion_list_break_on (text
, word
, "", code
);
4563 /* Return a vector of all symbols (regardless of class) which begin by
4564 matching TEXT. If the answer is no symbols, then the return value
4568 make_symbol_completion_list (const char *text
, const char *word
)
4570 return current_language
->la_make_symbol_completion_list (text
, word
,
4574 /* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4575 symbols whose type code is CODE. */
4578 make_symbol_completion_type (const char *text
, const char *word
,
4579 enum type_code code
)
4581 gdb_assert (code
== TYPE_CODE_UNION
4582 || code
== TYPE_CODE_STRUCT
4583 || code
== TYPE_CODE_ENUM
);
4584 return current_language
->la_make_symbol_completion_list (text
, word
, code
);
4587 /* Like make_symbol_completion_list, but suitable for use as a
4588 completion function. */
4591 make_symbol_completion_list_fn (struct cmd_list_element
*ignore
,
4592 const char *text
, const char *word
)
4594 return make_symbol_completion_list (text
, word
);
4597 /* Like make_symbol_completion_list, but returns a list of symbols
4598 defined in a source file FILE. */
4601 make_file_symbol_completion_list (const char *text
, const char *word
,
4602 const char *srcfile
)
4607 struct block_iterator iter
;
4608 /* The symbol we are completing on. Points in same buffer as text. */
4609 const char *sym_text
;
4610 /* Length of sym_text. */
4613 /* Now look for the symbol we are supposed to complete on.
4614 FIXME: This should be language-specific. */
4618 const char *quote_pos
= NULL
;
4620 /* First see if this is a quoted string. */
4622 for (p
= text
; *p
!= '\0'; ++p
)
4624 if (quote_found
!= '\0')
4626 if (*p
== quote_found
)
4627 /* Found close quote. */
4629 else if (*p
== '\\' && p
[1] == quote_found
)
4630 /* A backslash followed by the quote character
4631 doesn't end the string. */
4634 else if (*p
== '\'' || *p
== '"')
4640 if (quote_found
== '\'')
4641 /* A string within single quotes can be a symbol, so complete on it. */
4642 sym_text
= quote_pos
+ 1;
4643 else if (quote_found
== '"')
4644 /* A double-quoted string is never a symbol, nor does it make sense
4645 to complete it any other way. */
4651 /* Not a quoted string. */
4652 sym_text
= language_search_unquoted_string (text
, p
);
4656 sym_text_len
= strlen (sym_text
);
4660 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4662 s
= lookup_symtab (srcfile
);
4665 /* Maybe they typed the file with leading directories, while the
4666 symbol tables record only its basename. */
4667 const char *tail
= lbasename (srcfile
);
4670 s
= lookup_symtab (tail
);
4673 /* If we have no symtab for that file, return an empty list. */
4675 return (return_val
);
4677 /* Go through this symtab and check the externs and statics for
4678 symbols which match. */
4680 b
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4681 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4683 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4686 b
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (s
), STATIC_BLOCK
);
4687 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4689 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4692 return (return_val
);
4695 /* A helper function for make_source_files_completion_list. It adds
4696 another file name to a list of possible completions, growing the
4697 list as necessary. */
4700 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
4701 VEC (char_ptr
) **list
)
4704 size_t fnlen
= strlen (fname
);
4708 /* Return exactly fname. */
4709 new = xmalloc (fnlen
+ 5);
4710 strcpy (new, fname
);
4712 else if (word
> text
)
4714 /* Return some portion of fname. */
4715 new = xmalloc (fnlen
+ 5);
4716 strcpy (new, fname
+ (word
- text
));
4720 /* Return some of TEXT plus fname. */
4721 new = xmalloc (fnlen
+ (text
- word
) + 5);
4722 strncpy (new, word
, text
- word
);
4723 new[text
- word
] = '\0';
4724 strcat (new, fname
);
4726 VEC_safe_push (char_ptr
, *list
, new);
4730 not_interesting_fname (const char *fname
)
4732 static const char *illegal_aliens
[] = {
4733 "_globals_", /* inserted by coff_symtab_read */
4738 for (i
= 0; illegal_aliens
[i
]; i
++)
4740 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
4746 /* An object of this type is passed as the user_data argument to
4747 map_partial_symbol_filenames. */
4748 struct add_partial_filename_data
4750 struct filename_seen_cache
*filename_seen_cache
;
4754 VEC (char_ptr
) **list
;
4757 /* A callback for map_partial_symbol_filenames. */
4760 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
4763 struct add_partial_filename_data
*data
= user_data
;
4765 if (not_interesting_fname (filename
))
4767 if (!filename_seen (data
->filename_seen_cache
, filename
, 1)
4768 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
4770 /* This file matches for a completion; add it to the
4771 current list of matches. */
4772 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
4776 const char *base_name
= lbasename (filename
);
4778 if (base_name
!= filename
4779 && !filename_seen (data
->filename_seen_cache
, base_name
, 1)
4780 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
4781 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
4785 /* Return a vector of all source files whose names begin with matching
4786 TEXT. The file names are looked up in the symbol tables of this
4787 program. If the answer is no matchess, then the return value is
4791 make_source_files_completion_list (const char *text
, const char *word
)
4793 struct compunit_symtab
*cu
;
4795 struct objfile
*objfile
;
4796 size_t text_len
= strlen (text
);
4797 VEC (char_ptr
) *list
= NULL
;
4798 const char *base_name
;
4799 struct add_partial_filename_data datum
;
4800 struct filename_seen_cache
*filename_seen_cache
;
4801 struct cleanup
*back_to
, *cache_cleanup
;
4803 if (!have_full_symbols () && !have_partial_symbols ())
4806 back_to
= make_cleanup (do_free_completion_list
, &list
);
4808 filename_seen_cache
= create_filename_seen_cache ();
4809 cache_cleanup
= make_cleanup (delete_filename_seen_cache
,
4810 filename_seen_cache
);
4812 ALL_FILETABS (objfile
, cu
, s
)
4814 if (not_interesting_fname (s
->filename
))
4816 if (!filename_seen (filename_seen_cache
, s
->filename
, 1)
4817 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
4819 /* This file matches for a completion; add it to the current
4821 add_filename_to_list (s
->filename
, text
, word
, &list
);
4825 /* NOTE: We allow the user to type a base name when the
4826 debug info records leading directories, but not the other
4827 way around. This is what subroutines of breakpoint
4828 command do when they parse file names. */
4829 base_name
= lbasename (s
->filename
);
4830 if (base_name
!= s
->filename
4831 && !filename_seen (filename_seen_cache
, base_name
, 1)
4832 && filename_ncmp (base_name
, text
, text_len
) == 0)
4833 add_filename_to_list (base_name
, text
, word
, &list
);
4837 datum
.filename_seen_cache
= filename_seen_cache
;
4840 datum
.text_len
= text_len
;
4842 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
4843 0 /*need_fullname*/);
4845 do_cleanups (cache_cleanup
);
4846 discard_cleanups (back_to
);
4853 /* Return the "main_info" object for the current program space. If
4854 the object has not yet been created, create it and fill in some
4857 static struct main_info
*
4858 get_main_info (void)
4860 struct main_info
*info
= program_space_data (current_program_space
,
4861 main_progspace_key
);
4865 /* It may seem strange to store the main name in the progspace
4866 and also in whatever objfile happens to see a main name in
4867 its debug info. The reason for this is mainly historical:
4868 gdb returned "main" as the name even if no function named
4869 "main" was defined the program; and this approach lets us
4870 keep compatibility. */
4871 info
= XCNEW (struct main_info
);
4872 info
->language_of_main
= language_unknown
;
4873 set_program_space_data (current_program_space
, main_progspace_key
,
4880 /* A cleanup to destroy a struct main_info when a progspace is
4884 main_info_cleanup (struct program_space
*pspace
, void *data
)
4886 struct main_info
*info
= data
;
4889 xfree (info
->name_of_main
);
4894 set_main_name (const char *name
, enum language lang
)
4896 struct main_info
*info
= get_main_info ();
4898 if (info
->name_of_main
!= NULL
)
4900 xfree (info
->name_of_main
);
4901 info
->name_of_main
= NULL
;
4902 info
->language_of_main
= language_unknown
;
4906 info
->name_of_main
= xstrdup (name
);
4907 info
->language_of_main
= lang
;
4911 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4915 find_main_name (void)
4917 const char *new_main_name
;
4918 struct objfile
*objfile
;
4920 /* First check the objfiles to see whether a debuginfo reader has
4921 picked up the appropriate main name. Historically the main name
4922 was found in a more or less random way; this approach instead
4923 relies on the order of objfile creation -- which still isn't
4924 guaranteed to get the correct answer, but is just probably more
4926 ALL_OBJFILES (objfile
)
4928 if (objfile
->per_bfd
->name_of_main
!= NULL
)
4930 set_main_name (objfile
->per_bfd
->name_of_main
,
4931 objfile
->per_bfd
->language_of_main
);
4936 /* Try to see if the main procedure is in Ada. */
4937 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4938 be to add a new method in the language vector, and call this
4939 method for each language until one of them returns a non-empty
4940 name. This would allow us to remove this hard-coded call to
4941 an Ada function. It is not clear that this is a better approach
4942 at this point, because all methods need to be written in a way
4943 such that false positives never be returned. For instance, it is
4944 important that a method does not return a wrong name for the main
4945 procedure if the main procedure is actually written in a different
4946 language. It is easy to guaranty this with Ada, since we use a
4947 special symbol generated only when the main in Ada to find the name
4948 of the main procedure. It is difficult however to see how this can
4949 be guarantied for languages such as C, for instance. This suggests
4950 that order of call for these methods becomes important, which means
4951 a more complicated approach. */
4952 new_main_name
= ada_main_name ();
4953 if (new_main_name
!= NULL
)
4955 set_main_name (new_main_name
, language_ada
);
4959 new_main_name
= d_main_name ();
4960 if (new_main_name
!= NULL
)
4962 set_main_name (new_main_name
, language_d
);
4966 new_main_name
= go_main_name ();
4967 if (new_main_name
!= NULL
)
4969 set_main_name (new_main_name
, language_go
);
4973 new_main_name
= pascal_main_name ();
4974 if (new_main_name
!= NULL
)
4976 set_main_name (new_main_name
, language_pascal
);
4980 /* The languages above didn't identify the name of the main procedure.
4981 Fallback to "main". */
4982 set_main_name ("main", language_unknown
);
4988 struct main_info
*info
= get_main_info ();
4990 if (info
->name_of_main
== NULL
)
4993 return info
->name_of_main
;
4996 /* Return the language of the main function. If it is not known,
4997 return language_unknown. */
5000 main_language (void)
5002 struct main_info
*info
= get_main_info ();
5004 if (info
->name_of_main
== NULL
)
5007 return info
->language_of_main
;
5010 /* Handle ``executable_changed'' events for the symtab module. */
5013 symtab_observer_executable_changed (void)
5015 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5016 set_main_name (NULL
, language_unknown
);
5019 /* Return 1 if the supplied producer string matches the ARM RealView
5020 compiler (armcc). */
5023 producer_is_realview (const char *producer
)
5025 static const char *const arm_idents
[] = {
5026 "ARM C Compiler, ADS",
5027 "Thumb C Compiler, ADS",
5028 "ARM C++ Compiler, ADS",
5029 "Thumb C++ Compiler, ADS",
5030 "ARM/Thumb C/C++ Compiler, RVCT",
5031 "ARM C/C++ Compiler, RVCT"
5035 if (producer
== NULL
)
5038 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
5039 if (strncmp (producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
5047 /* The next index to hand out in response to a registration request. */
5049 static int next_aclass_value
= LOC_FINAL_VALUE
;
5051 /* The maximum number of "aclass" registrations we support. This is
5052 constant for convenience. */
5053 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5055 /* The objects representing the various "aclass" values. The elements
5056 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5057 elements are those registered at gdb initialization time. */
5059 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
5061 /* The globally visible pointer. This is separate from 'symbol_impl'
5062 so that it can be const. */
5064 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
5066 /* Make sure we saved enough room in struct symbol. */
5068 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
5070 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5071 is the ops vector associated with this index. This returns the new
5072 index, which should be used as the aclass_index field for symbols
5076 register_symbol_computed_impl (enum address_class aclass
,
5077 const struct symbol_computed_ops
*ops
)
5079 int result
= next_aclass_value
++;
5081 gdb_assert (aclass
== LOC_COMPUTED
);
5082 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5083 symbol_impl
[result
].aclass
= aclass
;
5084 symbol_impl
[result
].ops_computed
= ops
;
5086 /* Sanity check OPS. */
5087 gdb_assert (ops
!= NULL
);
5088 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
5089 gdb_assert (ops
->describe_location
!= NULL
);
5090 gdb_assert (ops
->read_needs_frame
!= NULL
);
5091 gdb_assert (ops
->read_variable
!= NULL
);
5096 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5097 OPS is the ops vector associated with this index. This returns the
5098 new index, which should be used as the aclass_index field for symbols
5102 register_symbol_block_impl (enum address_class aclass
,
5103 const struct symbol_block_ops
*ops
)
5105 int result
= next_aclass_value
++;
5107 gdb_assert (aclass
== LOC_BLOCK
);
5108 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5109 symbol_impl
[result
].aclass
= aclass
;
5110 symbol_impl
[result
].ops_block
= ops
;
5112 /* Sanity check OPS. */
5113 gdb_assert (ops
!= NULL
);
5114 gdb_assert (ops
->find_frame_base_location
!= NULL
);
5119 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5120 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5121 this index. This returns the new index, which should be used as
5122 the aclass_index field for symbols of this type. */
5125 register_symbol_register_impl (enum address_class aclass
,
5126 const struct symbol_register_ops
*ops
)
5128 int result
= next_aclass_value
++;
5130 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
5131 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5132 symbol_impl
[result
].aclass
= aclass
;
5133 symbol_impl
[result
].ops_register
= ops
;
5138 /* Initialize elements of 'symbol_impl' for the constants in enum
5142 initialize_ordinary_address_classes (void)
5146 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
5147 symbol_impl
[i
].aclass
= i
;
5152 /* Initialize the symbol SYM. */
5155 initialize_symbol (struct symbol
*sym
)
5157 memset (sym
, 0, sizeof (*sym
));
5158 SYMBOL_SECTION (sym
) = -1;
5161 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5165 allocate_symbol (struct objfile
*objfile
)
5167 struct symbol
*result
;
5169 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
5170 SYMBOL_SECTION (result
) = -1;
5175 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5178 struct template_symbol
*
5179 allocate_template_symbol (struct objfile
*objfile
)
5181 struct template_symbol
*result
;
5183 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
5184 SYMBOL_SECTION (&result
->base
) = -1;
5192 _initialize_symtab (void)
5194 initialize_ordinary_address_classes ();
5197 = register_program_space_data_with_cleanup (NULL
, main_info_cleanup
);
5199 add_info ("variables", variables_info
, _("\
5200 All global and static variable names, or those matching REGEXP."));
5202 add_com ("whereis", class_info
, variables_info
, _("\
5203 All global and static variable names, or those matching REGEXP."));
5205 add_info ("functions", functions_info
,
5206 _("All function names, or those matching REGEXP."));
5208 /* FIXME: This command has at least the following problems:
5209 1. It prints builtin types (in a very strange and confusing fashion).
5210 2. It doesn't print right, e.g. with
5211 typedef struct foo *FOO
5212 type_print prints "FOO" when we want to make it (in this situation)
5213 print "struct foo *".
5214 I also think "ptype" or "whatis" is more likely to be useful (but if
5215 there is much disagreement "info types" can be fixed). */
5216 add_info ("types", types_info
,
5217 _("All type names, or those matching REGEXP."));
5219 add_info ("sources", sources_info
,
5220 _("Source files in the program."));
5222 add_com ("rbreak", class_breakpoint
, rbreak_command
,
5223 _("Set a breakpoint for all functions matching REGEXP."));
5227 add_com ("lf", class_info
, sources_info
,
5228 _("Source files in the program"));
5229 add_com ("lg", class_info
, variables_info
, _("\
5230 All global and static variable names, or those matching REGEXP."));
5233 add_setshow_enum_cmd ("multiple-symbols", no_class
,
5234 multiple_symbols_modes
, &multiple_symbols_mode
,
5236 Set the debugger behavior when more than one symbol are possible matches\n\
5237 in an expression."), _("\
5238 Show how the debugger handles ambiguities in expressions."), _("\
5239 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5240 NULL
, NULL
, &setlist
, &showlist
);
5242 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
5243 &basenames_may_differ
, _("\
5244 Set whether a source file may have multiple base names."), _("\
5245 Show whether a source file may have multiple base names."), _("\
5246 (A \"base name\" is the name of a file with the directory part removed.\n\
5247 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5248 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5249 before comparing them. Canonicalization is an expensive operation,\n\
5250 but it allows the same file be known by more than one base name.\n\
5251 If not set (the default), all source files are assumed to have just\n\
5252 one base name, and gdb will do file name comparisons more efficiently."),
5254 &setlist
, &showlist
);
5256 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
5257 _("Set debugging of symbol table creation."),
5258 _("Show debugging of symbol table creation."), _("\
5259 When enabled (non-zero), debugging messages are printed when building\n\
5260 symbol tables. A value of 1 (one) normally provides enough information.\n\
5261 A value greater than 1 provides more verbose information."),
5264 &setdebuglist
, &showdebuglist
);
5266 observer_attach_executable_changed (symtab_observer_executable_changed
);