1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2019 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"
44 #include "cli/cli-style.h"
47 #include "typeprint.h"
49 #include "gdb_obstack.h"
51 #include "dictionary.h"
53 #include <sys/types.h>
58 #include "cp-support.h"
59 #include "observable.h"
62 #include "macroscope.h"
64 #include "parser-defs.h"
65 #include "completer.h"
66 #include "progspace-and-thread.h"
67 #include "gdbsupport/gdb_optional.h"
68 #include "filename-seen-cache.h"
69 #include "arch-utils.h"
71 #include "gdbsupport/gdb_string_view.h"
72 #include "gdbsupport/pathstuff.h"
73 #include "gdbsupport/common-utils.h"
75 /* Forward declarations for local functions. */
77 static void rbreak_command (const char *, int);
79 static int find_line_common (struct linetable
*, int, int *, int);
81 static struct block_symbol
82 lookup_symbol_aux (const char *name
,
83 symbol_name_match_type match_type
,
84 const struct block
*block
,
85 const domain_enum domain
,
86 enum language language
,
87 struct field_of_this_result
*);
90 struct block_symbol
lookup_local_symbol (const char *name
,
91 symbol_name_match_type match_type
,
92 const struct block
*block
,
93 const domain_enum domain
,
94 enum language language
);
96 static struct block_symbol
97 lookup_symbol_in_objfile (struct objfile
*objfile
,
98 enum block_enum block_index
,
99 const char *name
, const domain_enum domain
);
101 /* Type of the data stored on the program space. */
105 main_info () = default;
109 xfree (name_of_main
);
112 /* Name of "main". */
114 char *name_of_main
= nullptr;
116 /* Language of "main". */
118 enum language language_of_main
= language_unknown
;
121 /* Program space key for finding name and language of "main". */
123 static const program_space_key
<main_info
> main_progspace_key
;
125 /* The default symbol cache size.
126 There is no extra cpu cost for large N (except when flushing the cache,
127 which is rare). The value here is just a first attempt. A better default
128 value may be higher or lower. A prime number can make up for a bad hash
129 computation, so that's why the number is what it is. */
130 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
132 /* The maximum symbol cache size.
133 There's no method to the decision of what value to use here, other than
134 there's no point in allowing a user typo to make gdb consume all memory. */
135 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
137 /* symbol_cache_lookup returns this if a previous lookup failed to find the
138 symbol in any objfile. */
139 #define SYMBOL_LOOKUP_FAILED \
140 ((struct block_symbol) {(struct symbol *) 1, NULL})
141 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
143 /* Recording lookups that don't find the symbol is just as important, if not
144 more so, than recording found symbols. */
146 enum symbol_cache_slot_state
149 SYMBOL_SLOT_NOT_FOUND
,
153 struct symbol_cache_slot
155 enum symbol_cache_slot_state state
;
157 /* The objfile that was current when the symbol was looked up.
158 This is only needed for global blocks, but for simplicity's sake
159 we allocate the space for both. If data shows the extra space used
160 for static blocks is a problem, we can split things up then.
162 Global blocks need cache lookup to include the objfile context because
163 we need to account for gdbarch_iterate_over_objfiles_in_search_order
164 which can traverse objfiles in, effectively, any order, depending on
165 the current objfile, thus affecting which symbol is found. Normally,
166 only the current objfile is searched first, and then the rest are
167 searched in recorded order; but putting cache lookup inside
168 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
169 Instead we just make the current objfile part of the context of
170 cache lookup. This means we can record the same symbol multiple times,
171 each with a different "current objfile" that was in effect when the
172 lookup was saved in the cache, but cache space is pretty cheap. */
173 const struct objfile
*objfile_context
;
177 struct block_symbol found
;
186 /* Symbols don't specify global vs static block.
187 So keep them in separate caches. */
189 struct block_symbol_cache
193 unsigned int collisions
;
195 /* SYMBOLS is a variable length array of this size.
196 One can imagine that in general one cache (global/static) should be a
197 fraction of the size of the other, but there's no data at the moment
198 on which to decide. */
201 struct symbol_cache_slot symbols
[1];
206 Searching for symbols in the static and global blocks over multiple objfiles
207 again and again can be slow, as can searching very big objfiles. This is a
208 simple cache to improve symbol lookup performance, which is critical to
209 overall gdb performance.
211 Symbols are hashed on the name, its domain, and block.
212 They are also hashed on their objfile for objfile-specific lookups. */
216 symbol_cache () = default;
220 xfree (global_symbols
);
221 xfree (static_symbols
);
224 struct block_symbol_cache
*global_symbols
= nullptr;
225 struct block_symbol_cache
*static_symbols
= nullptr;
228 /* Program space key for finding its symbol cache. */
230 static const program_space_key
<symbol_cache
> symbol_cache_key
;
232 /* When non-zero, print debugging messages related to symtab creation. */
233 unsigned int symtab_create_debug
= 0;
235 /* When non-zero, print debugging messages related to symbol lookup. */
236 unsigned int symbol_lookup_debug
= 0;
238 /* The size of the cache is staged here. */
239 static unsigned int new_symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
241 /* The current value of the symbol cache size.
242 This is saved so that if the user enters a value too big we can restore
243 the original value from here. */
244 static unsigned int symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
246 /* True if a file may be known by two different basenames.
247 This is the uncommon case, and significantly slows down gdb.
248 Default set to "off" to not slow down the common case. */
249 bool basenames_may_differ
= false;
251 /* Allow the user to configure the debugger behavior with respect
252 to multiple-choice menus when more than one symbol matches during
255 const char multiple_symbols_ask
[] = "ask";
256 const char multiple_symbols_all
[] = "all";
257 const char multiple_symbols_cancel
[] = "cancel";
258 static const char *const multiple_symbols_modes
[] =
260 multiple_symbols_ask
,
261 multiple_symbols_all
,
262 multiple_symbols_cancel
,
265 static const char *multiple_symbols_mode
= multiple_symbols_all
;
267 /* Read-only accessor to AUTO_SELECT_MODE. */
270 multiple_symbols_select_mode (void)
272 return multiple_symbols_mode
;
275 /* Return the name of a domain_enum. */
278 domain_name (domain_enum e
)
282 case UNDEF_DOMAIN
: return "UNDEF_DOMAIN";
283 case VAR_DOMAIN
: return "VAR_DOMAIN";
284 case STRUCT_DOMAIN
: return "STRUCT_DOMAIN";
285 case MODULE_DOMAIN
: return "MODULE_DOMAIN";
286 case LABEL_DOMAIN
: return "LABEL_DOMAIN";
287 case COMMON_BLOCK_DOMAIN
: return "COMMON_BLOCK_DOMAIN";
288 default: gdb_assert_not_reached ("bad domain_enum");
292 /* Return the name of a search_domain . */
295 search_domain_name (enum search_domain e
)
299 case VARIABLES_DOMAIN
: return "VARIABLES_DOMAIN";
300 case FUNCTIONS_DOMAIN
: return "FUNCTIONS_DOMAIN";
301 case TYPES_DOMAIN
: return "TYPES_DOMAIN";
302 case ALL_DOMAIN
: return "ALL_DOMAIN";
303 default: gdb_assert_not_reached ("bad search_domain");
310 compunit_primary_filetab (const struct compunit_symtab
*cust
)
312 gdb_assert (COMPUNIT_FILETABS (cust
) != NULL
);
314 /* The primary file symtab is the first one in the list. */
315 return COMPUNIT_FILETABS (cust
);
321 compunit_language (const struct compunit_symtab
*cust
)
323 struct symtab
*symtab
= compunit_primary_filetab (cust
);
325 /* The language of the compunit symtab is the language of its primary
327 return SYMTAB_LANGUAGE (symtab
);
333 minimal_symbol::data_p () const
335 return type
== mst_data
338 || type
== mst_file_data
339 || type
== mst_file_bss
;
345 minimal_symbol::text_p () const
347 return type
== mst_text
348 || type
== mst_text_gnu_ifunc
349 || type
== mst_data_gnu_ifunc
350 || type
== mst_slot_got_plt
351 || type
== mst_solib_trampoline
352 || type
== mst_file_text
;
355 /* See whether FILENAME matches SEARCH_NAME using the rule that we
356 advertise to the user. (The manual's description of linespecs
357 describes what we advertise). Returns true if they match, false
361 compare_filenames_for_search (const char *filename
, const char *search_name
)
363 int len
= strlen (filename
);
364 size_t search_len
= strlen (search_name
);
366 if (len
< search_len
)
369 /* The tail of FILENAME must match. */
370 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
373 /* Either the names must completely match, or the character
374 preceding the trailing SEARCH_NAME segment of FILENAME must be a
377 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
378 cannot match FILENAME "/path//dir/file.c" - as user has requested
379 absolute path. The sama applies for "c:\file.c" possibly
380 incorrectly hypothetically matching "d:\dir\c:\file.c".
382 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
383 compatible with SEARCH_NAME "file.c". In such case a compiler had
384 to put the "c:file.c" name into debug info. Such compatibility
385 works only on GDB built for DOS host. */
386 return (len
== search_len
387 || (!IS_ABSOLUTE_PATH (search_name
)
388 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
389 || (HAS_DRIVE_SPEC (filename
)
390 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
393 /* Same as compare_filenames_for_search, but for glob-style patterns.
394 Heads up on the order of the arguments. They match the order of
395 compare_filenames_for_search, but it's the opposite of the order of
396 arguments to gdb_filename_fnmatch. */
399 compare_glob_filenames_for_search (const char *filename
,
400 const char *search_name
)
402 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
403 all /s have to be explicitly specified. */
404 int file_path_elements
= count_path_elements (filename
);
405 int search_path_elements
= count_path_elements (search_name
);
407 if (search_path_elements
> file_path_elements
)
410 if (IS_ABSOLUTE_PATH (search_name
))
412 return (search_path_elements
== file_path_elements
413 && gdb_filename_fnmatch (search_name
, filename
,
414 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0);
418 const char *file_to_compare
419 = strip_leading_path_elements (filename
,
420 file_path_elements
- search_path_elements
);
422 return gdb_filename_fnmatch (search_name
, file_to_compare
,
423 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0;
427 /* Check for a symtab of a specific name by searching some symtabs.
428 This is a helper function for callbacks of iterate_over_symtabs.
430 If NAME is not absolute, then REAL_PATH is NULL
431 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
433 The return value, NAME, REAL_PATH and CALLBACK are identical to the
434 `map_symtabs_matching_filename' method of quick_symbol_functions.
436 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
437 Each symtab within the specified compunit symtab is also searched.
438 AFTER_LAST is one past the last compunit symtab to search; NULL means to
439 search until the end of the list. */
442 iterate_over_some_symtabs (const char *name
,
443 const char *real_path
,
444 struct compunit_symtab
*first
,
445 struct compunit_symtab
*after_last
,
446 gdb::function_view
<bool (symtab
*)> callback
)
448 struct compunit_symtab
*cust
;
449 const char* base_name
= lbasename (name
);
451 for (cust
= first
; cust
!= NULL
&& cust
!= after_last
; cust
= cust
->next
)
453 for (symtab
*s
: compunit_filetabs (cust
))
455 if (compare_filenames_for_search (s
->filename
, name
))
462 /* Before we invoke realpath, which can get expensive when many
463 files are involved, do a quick comparison of the basenames. */
464 if (! basenames_may_differ
465 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
468 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
475 /* If the user gave us an absolute path, try to find the file in
476 this symtab and use its absolute path. */
477 if (real_path
!= NULL
)
479 const char *fullname
= symtab_to_fullname (s
);
481 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
482 gdb_assert (IS_ABSOLUTE_PATH (name
));
483 if (FILENAME_CMP (real_path
, fullname
) == 0)
496 /* Check for a symtab of a specific name; first in symtabs, then in
497 psymtabs. *If* there is no '/' in the name, a match after a '/'
498 in the symtab filename will also work.
500 Calls CALLBACK with each symtab that is found. If CALLBACK returns
501 true, the search stops. */
504 iterate_over_symtabs (const char *name
,
505 gdb::function_view
<bool (symtab
*)> callback
)
507 gdb::unique_xmalloc_ptr
<char> real_path
;
509 /* Here we are interested in canonicalizing an absolute path, not
510 absolutizing a relative path. */
511 if (IS_ABSOLUTE_PATH (name
))
513 real_path
= gdb_realpath (name
);
514 gdb_assert (IS_ABSOLUTE_PATH (real_path
.get ()));
517 for (objfile
*objfile
: current_program_space
->objfiles ())
519 if (iterate_over_some_symtabs (name
, real_path
.get (),
520 objfile
->compunit_symtabs
, NULL
,
525 /* Same search rules as above apply here, but now we look thru the
528 for (objfile
*objfile
: current_program_space
->objfiles ())
531 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
539 /* A wrapper for iterate_over_symtabs that returns the first matching
543 lookup_symtab (const char *name
)
545 struct symtab
*result
= NULL
;
547 iterate_over_symtabs (name
, [&] (symtab
*symtab
)
557 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
558 full method name, which consist of the class name (from T), the unadorned
559 method name from METHOD_ID, and the signature for the specific overload,
560 specified by SIGNATURE_ID. Note that this function is g++ specific. */
563 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
565 int mangled_name_len
;
567 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
568 struct fn_field
*method
= &f
[signature_id
];
569 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
570 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
571 const char *newname
= TYPE_NAME (type
);
573 /* Does the form of physname indicate that it is the full mangled name
574 of a constructor (not just the args)? */
575 int is_full_physname_constructor
;
578 int is_destructor
= is_destructor_name (physname
);
579 /* Need a new type prefix. */
580 const char *const_prefix
= method
->is_const
? "C" : "";
581 const char *volatile_prefix
= method
->is_volatile
? "V" : "";
583 int len
= (newname
== NULL
? 0 : strlen (newname
));
585 /* Nothing to do if physname already contains a fully mangled v3 abi name
586 or an operator name. */
587 if ((physname
[0] == '_' && physname
[1] == 'Z')
588 || is_operator_name (field_name
))
589 return xstrdup (physname
);
591 is_full_physname_constructor
= is_constructor_name (physname
);
593 is_constructor
= is_full_physname_constructor
594 || (newname
&& strcmp (field_name
, newname
) == 0);
597 is_destructor
= (startswith (physname
, "__dt"));
599 if (is_destructor
|| is_full_physname_constructor
)
601 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
602 strcpy (mangled_name
, physname
);
608 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
610 else if (physname
[0] == 't' || physname
[0] == 'Q')
612 /* The physname for template and qualified methods already includes
614 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
620 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
621 volatile_prefix
, len
);
623 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
624 + strlen (buf
) + len
+ strlen (physname
) + 1);
626 mangled_name
= (char *) xmalloc (mangled_name_len
);
628 mangled_name
[0] = '\0';
630 strcpy (mangled_name
, field_name
);
632 strcat (mangled_name
, buf
);
633 /* If the class doesn't have a name, i.e. newname NULL, then we just
634 mangle it using 0 for the length of the class. Thus it gets mangled
635 as something starting with `::' rather than `classname::'. */
637 strcat (mangled_name
, newname
);
639 strcat (mangled_name
, physname
);
640 return (mangled_name
);
643 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
644 correctly allocated. */
647 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
649 struct obstack
*obstack
)
651 if (gsymbol
->language
== language_ada
)
655 gsymbol
->ada_mangled
= 0;
656 gsymbol
->language_specific
.obstack
= obstack
;
660 gsymbol
->ada_mangled
= 1;
661 gsymbol
->language_specific
.demangled_name
= name
;
665 gsymbol
->language_specific
.demangled_name
= name
;
668 /* Return the demangled name of GSYMBOL. */
671 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
673 if (gsymbol
->language
== language_ada
)
675 if (!gsymbol
->ada_mangled
)
680 return gsymbol
->language_specific
.demangled_name
;
684 /* Initialize the language dependent portion of a symbol
685 depending upon the language for the symbol. */
688 symbol_set_language (struct general_symbol_info
*gsymbol
,
689 enum language language
,
690 struct obstack
*obstack
)
692 gsymbol
->language
= language
;
693 if (gsymbol
->language
== language_cplus
694 || gsymbol
->language
== language_d
695 || gsymbol
->language
== language_go
696 || gsymbol
->language
== language_objc
697 || gsymbol
->language
== language_fortran
)
699 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
701 else if (gsymbol
->language
== language_ada
)
703 gdb_assert (gsymbol
->ada_mangled
== 0);
704 gsymbol
->language_specific
.obstack
= obstack
;
708 memset (&gsymbol
->language_specific
, 0,
709 sizeof (gsymbol
->language_specific
));
713 /* Functions to initialize a symbol's mangled name. */
715 /* Objects of this type are stored in the demangled name hash table. */
716 struct demangled_name_entry
718 gdb::string_view mangled
;
719 ENUM_BITFIELD(language
) language
: LANGUAGE_BITS
;
723 /* Hash function for the demangled name hash. */
726 hash_demangled_name_entry (const void *data
)
728 const struct demangled_name_entry
*e
729 = (const struct demangled_name_entry
*) data
;
731 return fast_hash (e
->mangled
.data (), e
->mangled
.length ());
734 /* Equality function for the demangled name hash. */
737 eq_demangled_name_entry (const void *a
, const void *b
)
739 const struct demangled_name_entry
*da
740 = (const struct demangled_name_entry
*) a
;
741 const struct demangled_name_entry
*db
742 = (const struct demangled_name_entry
*) b
;
744 return da
->mangled
== db
->mangled
;
747 /* Create the hash table used for demangled names. Each hash entry is
748 a pair of strings; one for the mangled name and one for the demangled
749 name. The entry is hashed via just the mangled name. */
752 create_demangled_names_hash (struct objfile_per_bfd_storage
*per_bfd
)
754 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
755 The hash table code will round this up to the next prime number.
756 Choosing a much larger table size wastes memory, and saves only about
757 1% in symbol reading. */
759 per_bfd
->demangled_names_hash
.reset (htab_create_alloc
760 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
761 NULL
, xcalloc
, xfree
));
764 /* Try to determine the demangled name for a symbol, based on the
765 language of that symbol. If the language is set to language_auto,
766 it will attempt to find any demangling algorithm that works and
767 then set the language appropriately. The returned name is allocated
768 by the demangler and should be xfree'd. */
771 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
774 char *demangled
= NULL
;
777 if (gsymbol
->language
== language_unknown
)
778 gsymbol
->language
= language_auto
;
780 if (gsymbol
->language
!= language_auto
)
782 const struct language_defn
*lang
= language_def (gsymbol
->language
);
784 language_sniff_from_mangled_name (lang
, mangled
, &demangled
);
788 for (i
= language_unknown
; i
< nr_languages
; ++i
)
790 enum language l
= (enum language
) i
;
791 const struct language_defn
*lang
= language_def (l
);
793 if (language_sniff_from_mangled_name (lang
, mangled
, &demangled
))
795 gsymbol
->language
= l
;
803 /* Set both the mangled and demangled (if any) names for GSYMBOL based
804 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
805 objfile's obstack; but if COPY_NAME is 0 and if NAME is
806 NUL-terminated, then this function assumes that NAME is already
807 correctly saved (either permanently or with a lifetime tied to the
808 objfile), and it will not be copied.
810 The hash table corresponding to OBJFILE is used, and the memory
811 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
812 so the pointer can be discarded after calling this function. */
815 symbol_set_names (struct general_symbol_info
*gsymbol
,
816 const char *linkage_name
, int len
, bool copy_name
,
817 struct objfile_per_bfd_storage
*per_bfd
)
819 struct demangled_name_entry
**slot
;
820 /* A 0-terminated copy of the linkage name. */
821 const char *linkage_name_copy
;
822 struct demangled_name_entry entry
;
824 if (gsymbol
->language
== language_ada
)
826 /* In Ada, we do the symbol lookups using the mangled name, so
827 we can save some space by not storing the demangled name. */
829 gsymbol
->name
= linkage_name
;
832 char *name
= (char *) obstack_alloc (&per_bfd
->storage_obstack
,
835 memcpy (name
, linkage_name
, len
);
837 gsymbol
->name
= name
;
839 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
844 if (per_bfd
->demangled_names_hash
== NULL
)
845 create_demangled_names_hash (per_bfd
);
847 if (linkage_name
[len
] != '\0')
851 alloc_name
= (char *) alloca (len
+ 1);
852 memcpy (alloc_name
, linkage_name
, len
);
853 alloc_name
[len
] = '\0';
855 linkage_name_copy
= alloc_name
;
858 linkage_name_copy
= linkage_name
;
860 entry
.mangled
= gdb::string_view (linkage_name_copy
, len
);
861 slot
= ((struct demangled_name_entry
**)
862 htab_find_slot (per_bfd
->demangled_names_hash
.get (),
865 /* If this name is not in the hash table, add it. */
867 /* A C version of the symbol may have already snuck into the table.
868 This happens to, e.g., main.init (__go_init_main). Cope. */
869 || (gsymbol
->language
== language_go
870 && (*slot
)->demangled
[0] == '\0'))
872 char *demangled_name_ptr
873 = symbol_find_demangled_name (gsymbol
, linkage_name_copy
);
874 gdb::unique_xmalloc_ptr
<char> demangled_name (demangled_name_ptr
);
875 int demangled_len
= demangled_name
? strlen (demangled_name
.get ()) : 0;
877 /* Suppose we have demangled_name==NULL, copy_name==0, and
878 linkage_name_copy==linkage_name. In this case, we already have the
879 mangled name saved, and we don't have a demangled name. So,
880 you might think we could save a little space by not recording
881 this in the hash table at all.
883 It turns out that it is actually important to still save such
884 an entry in the hash table, because storing this name gives
885 us better bcache hit rates for partial symbols. */
886 if (!copy_name
&& linkage_name_copy
== linkage_name
)
889 = ((struct demangled_name_entry
*)
890 obstack_alloc (&per_bfd
->storage_obstack
,
891 offsetof (struct demangled_name_entry
, demangled
)
892 + demangled_len
+ 1));
893 (*slot
)->mangled
= gdb::string_view (linkage_name
, len
);
899 /* If we must copy the mangled name, put it directly after
900 the demangled name so we can have a single
903 = ((struct demangled_name_entry
*)
904 obstack_alloc (&per_bfd
->storage_obstack
,
905 offsetof (struct demangled_name_entry
, demangled
)
906 + len
+ demangled_len
+ 2));
907 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
908 strcpy (mangled_ptr
, linkage_name_copy
);
909 (*slot
)->mangled
= gdb::string_view (mangled_ptr
, len
);
911 (*slot
)->language
= gsymbol
->language
;
913 if (demangled_name
!= NULL
)
914 strcpy ((*slot
)->demangled
, demangled_name
.get ());
916 (*slot
)->demangled
[0] = '\0';
918 else if (gsymbol
->language
== language_unknown
919 || gsymbol
->language
== language_auto
)
920 gsymbol
->language
= (*slot
)->language
;
922 gsymbol
->name
= (*slot
)->mangled
.data ();
923 if ((*slot
)->demangled
[0] != '\0')
924 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
925 &per_bfd
->storage_obstack
);
927 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
930 /* Return the source code name of a symbol. In languages where
931 demangling is necessary, this is the demangled name. */
934 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
936 switch (gsymbol
->language
)
942 case language_fortran
:
943 if (symbol_get_demangled_name (gsymbol
) != NULL
)
944 return symbol_get_demangled_name (gsymbol
);
947 return ada_decode_symbol (gsymbol
);
951 return gsymbol
->name
;
954 /* Return the demangled name for a symbol based on the language for
955 that symbol. If no demangled name exists, return NULL. */
958 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
960 const char *dem_name
= NULL
;
962 switch (gsymbol
->language
)
968 case language_fortran
:
969 dem_name
= symbol_get_demangled_name (gsymbol
);
972 dem_name
= ada_decode_symbol (gsymbol
);
980 /* Return the search name of a symbol---generally the demangled or
981 linkage name of the symbol, depending on how it will be searched for.
982 If there is no distinct demangled name, then returns the same value
983 (same pointer) as SYMBOL_LINKAGE_NAME. */
986 symbol_search_name (const struct general_symbol_info
*gsymbol
)
988 if (gsymbol
->language
== language_ada
)
989 return gsymbol
->name
;
991 return symbol_natural_name (gsymbol
);
997 symbol_matches_search_name (const struct general_symbol_info
*gsymbol
,
998 const lookup_name_info
&name
)
1000 symbol_name_matcher_ftype
*name_match
1001 = get_symbol_name_matcher (language_def (gsymbol
->language
), name
);
1002 return name_match (symbol_search_name (gsymbol
), name
, NULL
);
1007 /* Return true if the two sections are the same, or if they could
1008 plausibly be copies of each other, one in an original object
1009 file and another in a separated debug file. */
1012 matching_obj_sections (struct obj_section
*obj_first
,
1013 struct obj_section
*obj_second
)
1015 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
1016 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
1018 /* If they're the same section, then they match. */
1019 if (first
== second
)
1022 /* If either is NULL, give up. */
1023 if (first
== NULL
|| second
== NULL
)
1026 /* This doesn't apply to absolute symbols. */
1027 if (first
->owner
== NULL
|| second
->owner
== NULL
)
1030 /* If they're in the same object file, they must be different sections. */
1031 if (first
->owner
== second
->owner
)
1034 /* Check whether the two sections are potentially corresponding. They must
1035 have the same size, address, and name. We can't compare section indexes,
1036 which would be more reliable, because some sections may have been
1038 if (bfd_section_size (first
) != bfd_section_size (second
))
1041 /* In-memory addresses may start at a different offset, relativize them. */
1042 if (bfd_section_vma (first
) - bfd_get_start_address (first
->owner
)
1043 != bfd_section_vma (second
) - bfd_get_start_address (second
->owner
))
1046 if (bfd_section_name (first
) == NULL
1047 || bfd_section_name (second
) == NULL
1048 || strcmp (bfd_section_name (first
), bfd_section_name (second
)) != 0)
1051 /* Otherwise check that they are in corresponding objfiles. */
1053 struct objfile
*obj
= NULL
;
1054 for (objfile
*objfile
: current_program_space
->objfiles ())
1055 if (objfile
->obfd
== first
->owner
)
1060 gdb_assert (obj
!= NULL
);
1062 if (obj
->separate_debug_objfile
!= NULL
1063 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1065 if (obj
->separate_debug_objfile_backlink
!= NULL
1066 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1075 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1077 struct bound_minimal_symbol msymbol
;
1079 /* If we know that this is not a text address, return failure. This is
1080 necessary because we loop based on texthigh and textlow, which do
1081 not include the data ranges. */
1082 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1083 if (msymbol
.minsym
&& msymbol
.minsym
->data_p ())
1086 for (objfile
*objfile
: current_program_space
->objfiles ())
1088 struct compunit_symtab
*cust
= NULL
;
1091 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1098 /* Hash function for the symbol cache. */
1101 hash_symbol_entry (const struct objfile
*objfile_context
,
1102 const char *name
, domain_enum domain
)
1104 unsigned int hash
= (uintptr_t) objfile_context
;
1107 hash
+= htab_hash_string (name
);
1109 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1110 to map to the same slot. */
1111 if (domain
== STRUCT_DOMAIN
)
1112 hash
+= VAR_DOMAIN
* 7;
1119 /* Equality function for the symbol cache. */
1122 eq_symbol_entry (const struct symbol_cache_slot
*slot
,
1123 const struct objfile
*objfile_context
,
1124 const char *name
, domain_enum domain
)
1126 const char *slot_name
;
1127 domain_enum slot_domain
;
1129 if (slot
->state
== SYMBOL_SLOT_UNUSED
)
1132 if (slot
->objfile_context
!= objfile_context
)
1135 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1137 slot_name
= slot
->value
.not_found
.name
;
1138 slot_domain
= slot
->value
.not_found
.domain
;
1142 slot_name
= SYMBOL_SEARCH_NAME (slot
->value
.found
.symbol
);
1143 slot_domain
= SYMBOL_DOMAIN (slot
->value
.found
.symbol
);
1146 /* NULL names match. */
1147 if (slot_name
== NULL
&& name
== NULL
)
1149 /* But there's no point in calling symbol_matches_domain in the
1150 SYMBOL_SLOT_FOUND case. */
1151 if (slot_domain
!= domain
)
1154 else if (slot_name
!= NULL
&& name
!= NULL
)
1156 /* It's important that we use the same comparison that was done
1157 the first time through. If the slot records a found symbol,
1158 then this means using the symbol name comparison function of
1159 the symbol's language with SYMBOL_SEARCH_NAME. See
1160 dictionary.c. It also means using symbol_matches_domain for
1161 found symbols. See block.c.
1163 If the slot records a not-found symbol, then require a precise match.
1164 We could still be lax with whitespace like strcmp_iw though. */
1166 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1168 if (strcmp (slot_name
, name
) != 0)
1170 if (slot_domain
!= domain
)
1175 struct symbol
*sym
= slot
->value
.found
.symbol
;
1176 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1178 if (!SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
1181 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1182 slot_domain
, domain
))
1188 /* Only one name is NULL. */
1195 /* Given a cache of size SIZE, return the size of the struct (with variable
1196 length array) in bytes. */
1199 symbol_cache_byte_size (unsigned int size
)
1201 return (sizeof (struct block_symbol_cache
)
1202 + ((size
- 1) * sizeof (struct symbol_cache_slot
)));
1208 resize_symbol_cache (struct symbol_cache
*cache
, unsigned int new_size
)
1210 /* If there's no change in size, don't do anything.
1211 All caches have the same size, so we can just compare with the size
1212 of the global symbols cache. */
1213 if ((cache
->global_symbols
!= NULL
1214 && cache
->global_symbols
->size
== new_size
)
1215 || (cache
->global_symbols
== NULL
1219 xfree (cache
->global_symbols
);
1220 xfree (cache
->static_symbols
);
1224 cache
->global_symbols
= NULL
;
1225 cache
->static_symbols
= NULL
;
1229 size_t total_size
= symbol_cache_byte_size (new_size
);
1231 cache
->global_symbols
1232 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1233 cache
->static_symbols
1234 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1235 cache
->global_symbols
->size
= new_size
;
1236 cache
->static_symbols
->size
= new_size
;
1240 /* Return the symbol cache of PSPACE.
1241 Create one if it doesn't exist yet. */
1243 static struct symbol_cache
*
1244 get_symbol_cache (struct program_space
*pspace
)
1246 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1250 cache
= symbol_cache_key
.emplace (pspace
);
1251 resize_symbol_cache (cache
, symbol_cache_size
);
1257 /* Set the size of the symbol cache in all program spaces. */
1260 set_symbol_cache_size (unsigned int new_size
)
1262 struct program_space
*pspace
;
1264 ALL_PSPACES (pspace
)
1266 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1268 /* The pspace could have been created but not have a cache yet. */
1270 resize_symbol_cache (cache
, new_size
);
1274 /* Called when symbol-cache-size is set. */
1277 set_symbol_cache_size_handler (const char *args
, int from_tty
,
1278 struct cmd_list_element
*c
)
1280 if (new_symbol_cache_size
> MAX_SYMBOL_CACHE_SIZE
)
1282 /* Restore the previous value.
1283 This is the value the "show" command prints. */
1284 new_symbol_cache_size
= symbol_cache_size
;
1286 error (_("Symbol cache size is too large, max is %u."),
1287 MAX_SYMBOL_CACHE_SIZE
);
1289 symbol_cache_size
= new_symbol_cache_size
;
1291 set_symbol_cache_size (symbol_cache_size
);
1294 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1295 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1296 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1297 failed (and thus this one will too), or NULL if the symbol is not present
1299 *BSC_PTR and *SLOT_PTR are set to the cache and slot of the symbol, which
1300 can be used to save the result of a full lookup attempt. */
1302 static struct block_symbol
1303 symbol_cache_lookup (struct symbol_cache
*cache
,
1304 struct objfile
*objfile_context
, enum block_enum block
,
1305 const char *name
, domain_enum domain
,
1306 struct block_symbol_cache
**bsc_ptr
,
1307 struct symbol_cache_slot
**slot_ptr
)
1309 struct block_symbol_cache
*bsc
;
1311 struct symbol_cache_slot
*slot
;
1313 if (block
== GLOBAL_BLOCK
)
1314 bsc
= cache
->global_symbols
;
1316 bsc
= cache
->static_symbols
;
1324 hash
= hash_symbol_entry (objfile_context
, name
, domain
);
1325 slot
= bsc
->symbols
+ hash
% bsc
->size
;
1330 if (eq_symbol_entry (slot
, objfile_context
, name
, domain
))
1332 if (symbol_lookup_debug
)
1333 fprintf_unfiltered (gdb_stdlog
,
1334 "%s block symbol cache hit%s for %s, %s\n",
1335 block
== GLOBAL_BLOCK
? "Global" : "Static",
1336 slot
->state
== SYMBOL_SLOT_NOT_FOUND
1337 ? " (not found)" : "",
1338 name
, domain_name (domain
));
1340 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1341 return SYMBOL_LOOKUP_FAILED
;
1342 return slot
->value
.found
;
1345 /* Symbol is not present in the cache. */
1347 if (symbol_lookup_debug
)
1349 fprintf_unfiltered (gdb_stdlog
,
1350 "%s block symbol cache miss for %s, %s\n",
1351 block
== GLOBAL_BLOCK
? "Global" : "Static",
1352 name
, domain_name (domain
));
1358 /* Clear out SLOT. */
1361 symbol_cache_clear_slot (struct symbol_cache_slot
*slot
)
1363 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1364 xfree (slot
->value
.not_found
.name
);
1365 slot
->state
= SYMBOL_SLOT_UNUSED
;
1368 /* Mark SYMBOL as found in SLOT.
1369 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1370 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1371 necessarily the objfile the symbol was found in. */
1374 symbol_cache_mark_found (struct block_symbol_cache
*bsc
,
1375 struct symbol_cache_slot
*slot
,
1376 struct objfile
*objfile_context
,
1377 struct symbol
*symbol
,
1378 const struct block
*block
)
1382 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1385 symbol_cache_clear_slot (slot
);
1387 slot
->state
= SYMBOL_SLOT_FOUND
;
1388 slot
->objfile_context
= objfile_context
;
1389 slot
->value
.found
.symbol
= symbol
;
1390 slot
->value
.found
.block
= block
;
1393 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1394 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1395 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1398 symbol_cache_mark_not_found (struct block_symbol_cache
*bsc
,
1399 struct symbol_cache_slot
*slot
,
1400 struct objfile
*objfile_context
,
1401 const char *name
, domain_enum domain
)
1405 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1408 symbol_cache_clear_slot (slot
);
1410 slot
->state
= SYMBOL_SLOT_NOT_FOUND
;
1411 slot
->objfile_context
= objfile_context
;
1412 slot
->value
.not_found
.name
= xstrdup (name
);
1413 slot
->value
.not_found
.domain
= domain
;
1416 /* Flush the symbol cache of PSPACE. */
1419 symbol_cache_flush (struct program_space
*pspace
)
1421 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1426 if (cache
->global_symbols
== NULL
)
1428 gdb_assert (symbol_cache_size
== 0);
1429 gdb_assert (cache
->static_symbols
== NULL
);
1433 /* If the cache is untouched since the last flush, early exit.
1434 This is important for performance during the startup of a program linked
1435 with 100s (or 1000s) of shared libraries. */
1436 if (cache
->global_symbols
->misses
== 0
1437 && cache
->static_symbols
->misses
== 0)
1440 gdb_assert (cache
->global_symbols
->size
== symbol_cache_size
);
1441 gdb_assert (cache
->static_symbols
->size
== symbol_cache_size
);
1443 for (pass
= 0; pass
< 2; ++pass
)
1445 struct block_symbol_cache
*bsc
1446 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1449 for (i
= 0; i
< bsc
->size
; ++i
)
1450 symbol_cache_clear_slot (&bsc
->symbols
[i
]);
1453 cache
->global_symbols
->hits
= 0;
1454 cache
->global_symbols
->misses
= 0;
1455 cache
->global_symbols
->collisions
= 0;
1456 cache
->static_symbols
->hits
= 0;
1457 cache
->static_symbols
->misses
= 0;
1458 cache
->static_symbols
->collisions
= 0;
1464 symbol_cache_dump (const struct symbol_cache
*cache
)
1468 if (cache
->global_symbols
== NULL
)
1470 printf_filtered (" <disabled>\n");
1474 for (pass
= 0; pass
< 2; ++pass
)
1476 const struct block_symbol_cache
*bsc
1477 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1481 printf_filtered ("Global symbols:\n");
1483 printf_filtered ("Static symbols:\n");
1485 for (i
= 0; i
< bsc
->size
; ++i
)
1487 const struct symbol_cache_slot
*slot
= &bsc
->symbols
[i
];
1491 switch (slot
->state
)
1493 case SYMBOL_SLOT_UNUSED
:
1495 case SYMBOL_SLOT_NOT_FOUND
:
1496 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i
,
1497 host_address_to_string (slot
->objfile_context
),
1498 slot
->value
.not_found
.name
,
1499 domain_name (slot
->value
.not_found
.domain
));
1501 case SYMBOL_SLOT_FOUND
:
1503 struct symbol
*found
= slot
->value
.found
.symbol
;
1504 const struct objfile
*context
= slot
->objfile_context
;
1506 printf_filtered (" [%4u] = %s, %s %s\n", i
,
1507 host_address_to_string (context
),
1508 SYMBOL_PRINT_NAME (found
),
1509 domain_name (SYMBOL_DOMAIN (found
)));
1517 /* The "mt print symbol-cache" command. */
1520 maintenance_print_symbol_cache (const char *args
, int from_tty
)
1522 struct program_space
*pspace
;
1524 ALL_PSPACES (pspace
)
1526 struct symbol_cache
*cache
;
1528 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1530 pspace
->symfile_object_file
!= NULL
1531 ? objfile_name (pspace
->symfile_object_file
)
1532 : "(no object file)");
1534 /* If the cache hasn't been created yet, avoid creating one. */
1535 cache
= symbol_cache_key
.get (pspace
);
1537 printf_filtered (" <empty>\n");
1539 symbol_cache_dump (cache
);
1543 /* The "mt flush-symbol-cache" command. */
1546 maintenance_flush_symbol_cache (const char *args
, int from_tty
)
1548 struct program_space
*pspace
;
1550 ALL_PSPACES (pspace
)
1552 symbol_cache_flush (pspace
);
1556 /* Print usage statistics of CACHE. */
1559 symbol_cache_stats (struct symbol_cache
*cache
)
1563 if (cache
->global_symbols
== NULL
)
1565 printf_filtered (" <disabled>\n");
1569 for (pass
= 0; pass
< 2; ++pass
)
1571 const struct block_symbol_cache
*bsc
1572 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1577 printf_filtered ("Global block cache stats:\n");
1579 printf_filtered ("Static block cache stats:\n");
1581 printf_filtered (" size: %u\n", bsc
->size
);
1582 printf_filtered (" hits: %u\n", bsc
->hits
);
1583 printf_filtered (" misses: %u\n", bsc
->misses
);
1584 printf_filtered (" collisions: %u\n", bsc
->collisions
);
1588 /* The "mt print symbol-cache-statistics" command. */
1591 maintenance_print_symbol_cache_statistics (const char *args
, int from_tty
)
1593 struct program_space
*pspace
;
1595 ALL_PSPACES (pspace
)
1597 struct symbol_cache
*cache
;
1599 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1601 pspace
->symfile_object_file
!= NULL
1602 ? objfile_name (pspace
->symfile_object_file
)
1603 : "(no object file)");
1605 /* If the cache hasn't been created yet, avoid creating one. */
1606 cache
= symbol_cache_key
.get (pspace
);
1608 printf_filtered (" empty, no stats available\n");
1610 symbol_cache_stats (cache
);
1614 /* This module's 'new_objfile' observer. */
1617 symtab_new_objfile_observer (struct objfile
*objfile
)
1619 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1620 symbol_cache_flush (current_program_space
);
1623 /* This module's 'free_objfile' observer. */
1626 symtab_free_objfile_observer (struct objfile
*objfile
)
1628 symbol_cache_flush (objfile
->pspace
);
1631 /* Debug symbols usually don't have section information. We need to dig that
1632 out of the minimal symbols and stash that in the debug symbol. */
1635 fixup_section (struct general_symbol_info
*ginfo
,
1636 CORE_ADDR addr
, struct objfile
*objfile
)
1638 struct minimal_symbol
*msym
;
1640 /* First, check whether a minimal symbol with the same name exists
1641 and points to the same address. The address check is required
1642 e.g. on PowerPC64, where the minimal symbol for a function will
1643 point to the function descriptor, while the debug symbol will
1644 point to the actual function code. */
1645 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1647 ginfo
->section
= MSYMBOL_SECTION (msym
);
1650 /* Static, function-local variables do appear in the linker
1651 (minimal) symbols, but are frequently given names that won't
1652 be found via lookup_minimal_symbol(). E.g., it has been
1653 observed in frv-uclinux (ELF) executables that a static,
1654 function-local variable named "foo" might appear in the
1655 linker symbols as "foo.6" or "foo.3". Thus, there is no
1656 point in attempting to extend the lookup-by-name mechanism to
1657 handle this case due to the fact that there can be multiple
1660 So, instead, search the section table when lookup by name has
1661 failed. The ``addr'' and ``endaddr'' fields may have already
1662 been relocated. If so, the relocation offset (i.e. the
1663 ANOFFSET value) needs to be subtracted from these values when
1664 performing the comparison. We unconditionally subtract it,
1665 because, when no relocation has been performed, the ANOFFSET
1666 value will simply be zero.
1668 The address of the symbol whose section we're fixing up HAS
1669 NOT BEEN adjusted (relocated) yet. It can't have been since
1670 the section isn't yet known and knowing the section is
1671 necessary in order to add the correct relocation value. In
1672 other words, we wouldn't even be in this function (attempting
1673 to compute the section) if it were already known.
1675 Note that it is possible to search the minimal symbols
1676 (subtracting the relocation value if necessary) to find the
1677 matching minimal symbol, but this is overkill and much less
1678 efficient. It is not necessary to find the matching minimal
1679 symbol, only its section.
1681 Note that this technique (of doing a section table search)
1682 can fail when unrelocated section addresses overlap. For
1683 this reason, we still attempt a lookup by name prior to doing
1684 a search of the section table. */
1686 struct obj_section
*s
;
1689 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1691 int idx
= s
- objfile
->sections
;
1692 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1697 if (obj_section_addr (s
) - offset
<= addr
1698 && addr
< obj_section_endaddr (s
) - offset
)
1700 ginfo
->section
= idx
;
1705 /* If we didn't find the section, assume it is in the first
1706 section. If there is no allocated section, then it hardly
1707 matters what we pick, so just pick zero. */
1711 ginfo
->section
= fallback
;
1716 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1723 if (!SYMBOL_OBJFILE_OWNED (sym
))
1726 /* We either have an OBJFILE, or we can get at it from the sym's
1727 symtab. Anything else is a bug. */
1728 gdb_assert (objfile
|| symbol_symtab (sym
));
1730 if (objfile
== NULL
)
1731 objfile
= symbol_objfile (sym
);
1733 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1736 /* We should have an objfile by now. */
1737 gdb_assert (objfile
);
1739 switch (SYMBOL_CLASS (sym
))
1743 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1746 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1750 /* Nothing else will be listed in the minsyms -- no use looking
1755 fixup_section (&sym
->ginfo
, addr
, objfile
);
1762 demangle_for_lookup_info::demangle_for_lookup_info
1763 (const lookup_name_info
&lookup_name
, language lang
)
1765 demangle_result_storage storage
;
1767 if (lookup_name
.ignore_parameters () && lang
== language_cplus
)
1769 gdb::unique_xmalloc_ptr
<char> without_params
1770 = cp_remove_params_if_any (lookup_name
.name ().c_str (),
1771 lookup_name
.completion_mode ());
1773 if (without_params
!= NULL
)
1775 if (lookup_name
.match_type () != symbol_name_match_type::SEARCH_NAME
)
1776 m_demangled_name
= demangle_for_lookup (without_params
.get (),
1782 if (lookup_name
.match_type () == symbol_name_match_type::SEARCH_NAME
)
1783 m_demangled_name
= lookup_name
.name ();
1785 m_demangled_name
= demangle_for_lookup (lookup_name
.name ().c_str (),
1791 const lookup_name_info
&
1792 lookup_name_info::match_any ()
1794 /* Lookup any symbol that "" would complete. I.e., this matches all
1796 static const lookup_name_info
lookup_name ({}, symbol_name_match_type::FULL
,
1802 /* Compute the demangled form of NAME as used by the various symbol
1803 lookup functions. The result can either be the input NAME
1804 directly, or a pointer to a buffer owned by the STORAGE object.
1806 For Ada, this function just returns NAME, unmodified.
1807 Normally, Ada symbol lookups are performed using the encoded name
1808 rather than the demangled name, and so it might seem to make sense
1809 for this function to return an encoded version of NAME.
1810 Unfortunately, we cannot do this, because this function is used in
1811 circumstances where it is not appropriate to try to encode NAME.
1812 For instance, when displaying the frame info, we demangle the name
1813 of each parameter, and then perform a symbol lookup inside our
1814 function using that demangled name. In Ada, certain functions
1815 have internally-generated parameters whose name contain uppercase
1816 characters. Encoding those name would result in those uppercase
1817 characters to become lowercase, and thus cause the symbol lookup
1821 demangle_for_lookup (const char *name
, enum language lang
,
1822 demangle_result_storage
&storage
)
1824 /* If we are using C++, D, or Go, demangle the name before doing a
1825 lookup, so we can always binary search. */
1826 if (lang
== language_cplus
)
1828 char *demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1829 if (demangled_name
!= NULL
)
1830 return storage
.set_malloc_ptr (demangled_name
);
1832 /* If we were given a non-mangled name, canonicalize it
1833 according to the language (so far only for C++). */
1834 std::string canon
= cp_canonicalize_string (name
);
1835 if (!canon
.empty ())
1836 return storage
.swap_string (canon
);
1838 else if (lang
== language_d
)
1840 char *demangled_name
= d_demangle (name
, 0);
1841 if (demangled_name
!= NULL
)
1842 return storage
.set_malloc_ptr (demangled_name
);
1844 else if (lang
== language_go
)
1846 char *demangled_name
= go_demangle (name
, 0);
1847 if (demangled_name
!= NULL
)
1848 return storage
.set_malloc_ptr (demangled_name
);
1857 search_name_hash (enum language language
, const char *search_name
)
1859 return language_def (language
)->la_search_name_hash (search_name
);
1864 This function (or rather its subordinates) have a bunch of loops and
1865 it would seem to be attractive to put in some QUIT's (though I'm not really
1866 sure whether it can run long enough to be really important). But there
1867 are a few calls for which it would appear to be bad news to quit
1868 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1869 that there is C++ code below which can error(), but that probably
1870 doesn't affect these calls since they are looking for a known
1871 variable and thus can probably assume it will never hit the C++
1875 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1876 const domain_enum domain
, enum language lang
,
1877 struct field_of_this_result
*is_a_field_of_this
)
1879 demangle_result_storage storage
;
1880 const char *modified_name
= demangle_for_lookup (name
, lang
, storage
);
1882 return lookup_symbol_aux (modified_name
,
1883 symbol_name_match_type::FULL
,
1884 block
, domain
, lang
,
1885 is_a_field_of_this
);
1891 lookup_symbol (const char *name
, const struct block
*block
,
1893 struct field_of_this_result
*is_a_field_of_this
)
1895 return lookup_symbol_in_language (name
, block
, domain
,
1896 current_language
->la_language
,
1897 is_a_field_of_this
);
1903 lookup_symbol_search_name (const char *search_name
, const struct block
*block
,
1906 return lookup_symbol_aux (search_name
, symbol_name_match_type::SEARCH_NAME
,
1907 block
, domain
, language_asm
, NULL
);
1913 lookup_language_this (const struct language_defn
*lang
,
1914 const struct block
*block
)
1916 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1919 if (symbol_lookup_debug
> 1)
1921 struct objfile
*objfile
= lookup_objfile_from_block (block
);
1923 fprintf_unfiltered (gdb_stdlog
,
1924 "lookup_language_this (%s, %s (objfile %s))",
1925 lang
->la_name
, host_address_to_string (block
),
1926 objfile_debug_name (objfile
));
1933 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
,
1934 symbol_name_match_type::SEARCH_NAME
,
1938 if (symbol_lookup_debug
> 1)
1940 fprintf_unfiltered (gdb_stdlog
, " = %s (%s, block %s)\n",
1941 SYMBOL_PRINT_NAME (sym
),
1942 host_address_to_string (sym
),
1943 host_address_to_string (block
));
1945 return (struct block_symbol
) {sym
, block
};
1947 if (BLOCK_FUNCTION (block
))
1949 block
= BLOCK_SUPERBLOCK (block
);
1952 if (symbol_lookup_debug
> 1)
1953 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1957 /* Given TYPE, a structure/union,
1958 return 1 if the component named NAME from the ultimate target
1959 structure/union is defined, otherwise, return 0. */
1962 check_field (struct type
*type
, const char *name
,
1963 struct field_of_this_result
*is_a_field_of_this
)
1967 /* The type may be a stub. */
1968 type
= check_typedef (type
);
1970 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1972 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1974 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1976 is_a_field_of_this
->type
= type
;
1977 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1982 /* C++: If it was not found as a data field, then try to return it
1983 as a pointer to a method. */
1985 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1987 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1989 is_a_field_of_this
->type
= type
;
1990 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1995 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1996 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
2002 /* Behave like lookup_symbol except that NAME is the natural name
2003 (e.g., demangled name) of the symbol that we're looking for. */
2005 static struct block_symbol
2006 lookup_symbol_aux (const char *name
, symbol_name_match_type match_type
,
2007 const struct block
*block
,
2008 const domain_enum domain
, enum language language
,
2009 struct field_of_this_result
*is_a_field_of_this
)
2011 struct block_symbol result
;
2012 const struct language_defn
*langdef
;
2014 if (symbol_lookup_debug
)
2016 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2018 fprintf_unfiltered (gdb_stdlog
,
2019 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
2020 name
, host_address_to_string (block
),
2022 ? objfile_debug_name (objfile
) : "NULL",
2023 domain_name (domain
), language_str (language
));
2026 /* Make sure we do something sensible with is_a_field_of_this, since
2027 the callers that set this parameter to some non-null value will
2028 certainly use it later. If we don't set it, the contents of
2029 is_a_field_of_this are undefined. */
2030 if (is_a_field_of_this
!= NULL
)
2031 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
2033 /* Search specified block and its superiors. Don't search
2034 STATIC_BLOCK or GLOBAL_BLOCK. */
2036 result
= lookup_local_symbol (name
, match_type
, block
, domain
, language
);
2037 if (result
.symbol
!= NULL
)
2039 if (symbol_lookup_debug
)
2041 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2042 host_address_to_string (result
.symbol
));
2047 /* If requested to do so by the caller and if appropriate for LANGUAGE,
2048 check to see if NAME is a field of `this'. */
2050 langdef
= language_def (language
);
2052 /* Don't do this check if we are searching for a struct. It will
2053 not be found by check_field, but will be found by other
2055 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
2057 result
= lookup_language_this (langdef
, block
);
2061 struct type
*t
= result
.symbol
->type
;
2063 /* I'm not really sure that type of this can ever
2064 be typedefed; just be safe. */
2065 t
= check_typedef (t
);
2066 if (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2067 t
= TYPE_TARGET_TYPE (t
);
2069 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2070 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2071 error (_("Internal error: `%s' is not an aggregate"),
2072 langdef
->la_name_of_this
);
2074 if (check_field (t
, name
, is_a_field_of_this
))
2076 if (symbol_lookup_debug
)
2078 fprintf_unfiltered (gdb_stdlog
,
2079 "lookup_symbol_aux (...) = NULL\n");
2086 /* Now do whatever is appropriate for LANGUAGE to look
2087 up static and global variables. */
2089 result
= langdef
->la_lookup_symbol_nonlocal (langdef
, name
, block
, domain
);
2090 if (result
.symbol
!= NULL
)
2092 if (symbol_lookup_debug
)
2094 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2095 host_address_to_string (result
.symbol
));
2100 /* Now search all static file-level symbols. Not strictly correct,
2101 but more useful than an error. */
2103 result
= lookup_static_symbol (name
, domain
);
2104 if (symbol_lookup_debug
)
2106 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2107 result
.symbol
!= NULL
2108 ? host_address_to_string (result
.symbol
)
2114 /* Check to see if the symbol is defined in BLOCK or its superiors.
2115 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2117 static struct block_symbol
2118 lookup_local_symbol (const char *name
,
2119 symbol_name_match_type match_type
,
2120 const struct block
*block
,
2121 const domain_enum domain
,
2122 enum language language
)
2125 const struct block
*static_block
= block_static_block (block
);
2126 const char *scope
= block_scope (block
);
2128 /* Check if either no block is specified or it's a global block. */
2130 if (static_block
== NULL
)
2133 while (block
!= static_block
)
2135 sym
= lookup_symbol_in_block (name
, match_type
, block
, domain
);
2137 return (struct block_symbol
) {sym
, block
};
2139 if (language
== language_cplus
|| language
== language_fortran
)
2141 struct block_symbol blocksym
2142 = cp_lookup_symbol_imports_or_template (scope
, name
, block
,
2145 if (blocksym
.symbol
!= NULL
)
2149 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
2151 block
= BLOCK_SUPERBLOCK (block
);
2154 /* We've reached the end of the function without finding a result. */
2162 lookup_objfile_from_block (const struct block
*block
)
2167 block
= block_global_block (block
);
2168 /* Look through all blockvectors. */
2169 for (objfile
*obj
: current_program_space
->objfiles ())
2171 for (compunit_symtab
*cust
: obj
->compunits ())
2172 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
2175 if (obj
->separate_debug_objfile_backlink
)
2176 obj
= obj
->separate_debug_objfile_backlink
;
2188 lookup_symbol_in_block (const char *name
, symbol_name_match_type match_type
,
2189 const struct block
*block
,
2190 const domain_enum domain
)
2194 if (symbol_lookup_debug
> 1)
2196 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2198 fprintf_unfiltered (gdb_stdlog
,
2199 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2200 name
, host_address_to_string (block
),
2201 objfile_debug_name (objfile
),
2202 domain_name (domain
));
2205 sym
= block_lookup_symbol (block
, name
, match_type
, domain
);
2208 if (symbol_lookup_debug
> 1)
2210 fprintf_unfiltered (gdb_stdlog
, " = %s\n",
2211 host_address_to_string (sym
));
2213 return fixup_symbol_section (sym
, NULL
);
2216 if (symbol_lookup_debug
> 1)
2217 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2224 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
2225 enum block_enum block_index
,
2227 const domain_enum domain
)
2229 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2231 for (objfile
*objfile
: main_objfile
->separate_debug_objfiles ())
2233 struct block_symbol result
2234 = lookup_symbol_in_objfile (objfile
, block_index
, name
, domain
);
2236 if (result
.symbol
!= nullptr)
2243 /* Check to see if the symbol is defined in one of the OBJFILE's
2244 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2245 depending on whether or not we want to search global symbols or
2248 static struct block_symbol
2249 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
,
2250 enum block_enum block_index
, const char *name
,
2251 const domain_enum domain
)
2253 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2255 if (symbol_lookup_debug
> 1)
2257 fprintf_unfiltered (gdb_stdlog
,
2258 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2259 objfile_debug_name (objfile
),
2260 block_index
== GLOBAL_BLOCK
2261 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2262 name
, domain_name (domain
));
2265 for (compunit_symtab
*cust
: objfile
->compunits ())
2267 const struct blockvector
*bv
;
2268 const struct block
*block
;
2269 struct block_symbol result
;
2271 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2272 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2273 result
.symbol
= block_lookup_symbol_primary (block
, name
, domain
);
2274 result
.block
= block
;
2275 if (result
.symbol
!= NULL
)
2277 if (symbol_lookup_debug
> 1)
2279 fprintf_unfiltered (gdb_stdlog
, " = %s (block %s)\n",
2280 host_address_to_string (result
.symbol
),
2281 host_address_to_string (block
));
2283 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2289 if (symbol_lookup_debug
> 1)
2290 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2294 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2295 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2296 and all associated separate debug objfiles.
2298 Normally we only look in OBJFILE, and not any separate debug objfiles
2299 because the outer loop will cause them to be searched too. This case is
2300 different. Here we're called from search_symbols where it will only
2301 call us for the objfile that contains a matching minsym. */
2303 static struct block_symbol
2304 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
2305 const char *linkage_name
,
2308 enum language lang
= current_language
->la_language
;
2309 struct objfile
*main_objfile
;
2311 demangle_result_storage storage
;
2312 const char *modified_name
= demangle_for_lookup (linkage_name
, lang
, storage
);
2314 if (objfile
->separate_debug_objfile_backlink
)
2315 main_objfile
= objfile
->separate_debug_objfile_backlink
;
2317 main_objfile
= objfile
;
2319 for (::objfile
*cur_objfile
: main_objfile
->separate_debug_objfiles ())
2321 struct block_symbol result
;
2323 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
2324 modified_name
, domain
);
2325 if (result
.symbol
== NULL
)
2326 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
2327 modified_name
, domain
);
2328 if (result
.symbol
!= NULL
)
2335 /* A helper function that throws an exception when a symbol was found
2336 in a psymtab but not in a symtab. */
2338 static void ATTRIBUTE_NORETURN
2339 error_in_psymtab_expansion (enum block_enum block_index
, const char *name
,
2340 struct compunit_symtab
*cust
)
2343 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2344 %s may be an inlined function, or may be a template function\n \
2345 (if a template, try specifying an instantiation: %s<type>)."),
2346 block_index
== GLOBAL_BLOCK
? "global" : "static",
2348 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
2352 /* A helper function for various lookup routines that interfaces with
2353 the "quick" symbol table functions. */
2355 static struct block_symbol
2356 lookup_symbol_via_quick_fns (struct objfile
*objfile
,
2357 enum block_enum block_index
, const char *name
,
2358 const domain_enum domain
)
2360 struct compunit_symtab
*cust
;
2361 const struct blockvector
*bv
;
2362 const struct block
*block
;
2363 struct block_symbol result
;
2368 if (symbol_lookup_debug
> 1)
2370 fprintf_unfiltered (gdb_stdlog
,
2371 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2372 objfile_debug_name (objfile
),
2373 block_index
== GLOBAL_BLOCK
2374 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2375 name
, domain_name (domain
));
2378 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
2381 if (symbol_lookup_debug
> 1)
2383 fprintf_unfiltered (gdb_stdlog
,
2384 "lookup_symbol_via_quick_fns (...) = NULL\n");
2389 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2390 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2391 result
.symbol
= block_lookup_symbol (block
, name
,
2392 symbol_name_match_type::FULL
, domain
);
2393 if (result
.symbol
== NULL
)
2394 error_in_psymtab_expansion (block_index
, name
, cust
);
2396 if (symbol_lookup_debug
> 1)
2398 fprintf_unfiltered (gdb_stdlog
,
2399 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2400 host_address_to_string (result
.symbol
),
2401 host_address_to_string (block
));
2404 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2405 result
.block
= block
;
2412 basic_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2414 const struct block
*block
,
2415 const domain_enum domain
)
2417 struct block_symbol result
;
2419 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2420 the current objfile. Searching the current objfile first is useful
2421 for both matching user expectations as well as performance. */
2423 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2424 if (result
.symbol
!= NULL
)
2427 /* If we didn't find a definition for a builtin type in the static block,
2428 search for it now. This is actually the right thing to do and can be
2429 a massive performance win. E.g., when debugging a program with lots of
2430 shared libraries we could search all of them only to find out the
2431 builtin type isn't defined in any of them. This is common for types
2433 if (domain
== VAR_DOMAIN
)
2435 struct gdbarch
*gdbarch
;
2438 gdbarch
= target_gdbarch ();
2440 gdbarch
= block_gdbarch (block
);
2441 result
.symbol
= language_lookup_primitive_type_as_symbol (langdef
,
2443 result
.block
= NULL
;
2444 if (result
.symbol
!= NULL
)
2448 return lookup_global_symbol (name
, block
, domain
);
2454 lookup_symbol_in_static_block (const char *name
,
2455 const struct block
*block
,
2456 const domain_enum domain
)
2458 const struct block
*static_block
= block_static_block (block
);
2461 if (static_block
== NULL
)
2464 if (symbol_lookup_debug
)
2466 struct objfile
*objfile
= lookup_objfile_from_block (static_block
);
2468 fprintf_unfiltered (gdb_stdlog
,
2469 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2472 host_address_to_string (block
),
2473 objfile_debug_name (objfile
),
2474 domain_name (domain
));
2477 sym
= lookup_symbol_in_block (name
,
2478 symbol_name_match_type::FULL
,
2479 static_block
, domain
);
2480 if (symbol_lookup_debug
)
2482 fprintf_unfiltered (gdb_stdlog
,
2483 "lookup_symbol_in_static_block (...) = %s\n",
2484 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
2486 return (struct block_symbol
) {sym
, static_block
};
2489 /* Perform the standard symbol lookup of NAME in OBJFILE:
2490 1) First search expanded symtabs, and if not found
2491 2) Search the "quick" symtabs (partial or .gdb_index).
2492 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2494 static struct block_symbol
2495 lookup_symbol_in_objfile (struct objfile
*objfile
, enum block_enum block_index
,
2496 const char *name
, const domain_enum domain
)
2498 struct block_symbol result
;
2500 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2502 if (symbol_lookup_debug
)
2504 fprintf_unfiltered (gdb_stdlog
,
2505 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2506 objfile_debug_name (objfile
),
2507 block_index
== GLOBAL_BLOCK
2508 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2509 name
, domain_name (domain
));
2512 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
2514 if (result
.symbol
!= NULL
)
2516 if (symbol_lookup_debug
)
2518 fprintf_unfiltered (gdb_stdlog
,
2519 "lookup_symbol_in_objfile (...) = %s"
2521 host_address_to_string (result
.symbol
));
2526 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
2528 if (symbol_lookup_debug
)
2530 fprintf_unfiltered (gdb_stdlog
,
2531 "lookup_symbol_in_objfile (...) = %s%s\n",
2532 result
.symbol
!= NULL
2533 ? host_address_to_string (result
.symbol
)
2535 result
.symbol
!= NULL
? " (via quick fns)" : "");
2540 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2542 struct global_or_static_sym_lookup_data
2544 /* The name of the symbol we are searching for. */
2547 /* The domain to use for our search. */
2550 /* The block index in which to search. */
2551 enum block_enum block_index
;
2553 /* The field where the callback should store the symbol if found.
2554 It should be initialized to {NULL, NULL} before the search is started. */
2555 struct block_symbol result
;
2558 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2559 It searches by name for a symbol in the block given by BLOCK_INDEX of the
2560 given OBJFILE. The arguments for the search are passed via CB_DATA, which
2561 in reality is a pointer to struct global_or_static_sym_lookup_data. */
2564 lookup_symbol_global_or_static_iterator_cb (struct objfile
*objfile
,
2567 struct global_or_static_sym_lookup_data
*data
=
2568 (struct global_or_static_sym_lookup_data
*) cb_data
;
2570 gdb_assert (data
->result
.symbol
== NULL
2571 && data
->result
.block
== NULL
);
2573 data
->result
= lookup_symbol_in_objfile (objfile
, data
->block_index
,
2574 data
->name
, data
->domain
);
2576 /* If we found a match, tell the iterator to stop. Otherwise,
2578 return (data
->result
.symbol
!= NULL
);
2581 /* This function contains the common code of lookup_{global,static}_symbol.
2582 OBJFILE is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is
2583 the objfile to start the lookup in. */
2585 static struct block_symbol
2586 lookup_global_or_static_symbol (const char *name
,
2587 enum block_enum block_index
,
2588 struct objfile
*objfile
,
2589 const domain_enum domain
)
2591 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2592 struct block_symbol result
;
2593 struct global_or_static_sym_lookup_data lookup_data
;
2594 struct block_symbol_cache
*bsc
;
2595 struct symbol_cache_slot
*slot
;
2597 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2598 gdb_assert (objfile
== nullptr || block_index
== GLOBAL_BLOCK
);
2600 /* First see if we can find the symbol in the cache.
2601 This works because we use the current objfile to qualify the lookup. */
2602 result
= symbol_cache_lookup (cache
, objfile
, block_index
, name
, domain
,
2604 if (result
.symbol
!= NULL
)
2606 if (SYMBOL_LOOKUP_FAILED_P (result
))
2611 /* Do a global search (of global blocks, heh). */
2612 if (result
.symbol
== NULL
)
2614 memset (&lookup_data
, 0, sizeof (lookup_data
));
2615 lookup_data
.name
= name
;
2616 lookup_data
.block_index
= block_index
;
2617 lookup_data
.domain
= domain
;
2618 gdbarch_iterate_over_objfiles_in_search_order
2619 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
2620 lookup_symbol_global_or_static_iterator_cb
, &lookup_data
, objfile
);
2621 result
= lookup_data
.result
;
2624 if (result
.symbol
!= NULL
)
2625 symbol_cache_mark_found (bsc
, slot
, objfile
, result
.symbol
, result
.block
);
2627 symbol_cache_mark_not_found (bsc
, slot
, objfile
, name
, domain
);
2635 lookup_static_symbol (const char *name
, const domain_enum domain
)
2637 return lookup_global_or_static_symbol (name
, STATIC_BLOCK
, nullptr, domain
);
2643 lookup_global_symbol (const char *name
,
2644 const struct block
*block
,
2645 const domain_enum domain
)
2647 /* If a block was passed in, we want to search the corresponding
2648 global block first. This yields "more expected" behavior, and is
2649 needed to support 'FILENAME'::VARIABLE lookups. */
2650 const struct block
*global_block
= block_global_block (block
);
2651 if (global_block
!= nullptr)
2653 symbol
*sym
= lookup_symbol_in_block (name
,
2654 symbol_name_match_type::FULL
,
2655 global_block
, domain
);
2657 return { sym
, global_block
};
2660 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2661 return lookup_global_or_static_symbol (name
, GLOBAL_BLOCK
, objfile
, domain
);
2665 symbol_matches_domain (enum language symbol_language
,
2666 domain_enum symbol_domain
,
2669 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2670 Similarly, any Ada type declaration implicitly defines a typedef. */
2671 if (symbol_language
== language_cplus
2672 || symbol_language
== language_d
2673 || symbol_language
== language_ada
2674 || symbol_language
== language_rust
)
2676 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
2677 && symbol_domain
== STRUCT_DOMAIN
)
2680 /* For all other languages, strict match is required. */
2681 return (symbol_domain
== domain
);
2687 lookup_transparent_type (const char *name
)
2689 return current_language
->la_lookup_transparent_type (name
);
2692 /* A helper for basic_lookup_transparent_type that interfaces with the
2693 "quick" symbol table functions. */
2695 static struct type
*
2696 basic_lookup_transparent_type_quick (struct objfile
*objfile
,
2697 enum block_enum block_index
,
2700 struct compunit_symtab
*cust
;
2701 const struct blockvector
*bv
;
2702 const struct block
*block
;
2707 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
2712 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2713 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2714 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2715 block_find_non_opaque_type
, NULL
);
2717 error_in_psymtab_expansion (block_index
, name
, cust
);
2718 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2719 return SYMBOL_TYPE (sym
);
2722 /* Subroutine of basic_lookup_transparent_type to simplify it.
2723 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2724 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2726 static struct type
*
2727 basic_lookup_transparent_type_1 (struct objfile
*objfile
,
2728 enum block_enum block_index
,
2731 const struct blockvector
*bv
;
2732 const struct block
*block
;
2733 const struct symbol
*sym
;
2735 for (compunit_symtab
*cust
: objfile
->compunits ())
2737 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2738 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2739 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2740 block_find_non_opaque_type
, NULL
);
2743 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2744 return SYMBOL_TYPE (sym
);
2751 /* The standard implementation of lookup_transparent_type. This code
2752 was modeled on lookup_symbol -- the parts not relevant to looking
2753 up types were just left out. In particular it's assumed here that
2754 types are available in STRUCT_DOMAIN and only in file-static or
2758 basic_lookup_transparent_type (const char *name
)
2762 /* Now search all the global symbols. Do the symtab's first, then
2763 check the psymtab's. If a psymtab indicates the existence
2764 of the desired name as a global, then do psymtab-to-symtab
2765 conversion on the fly and return the found symbol. */
2767 for (objfile
*objfile
: current_program_space
->objfiles ())
2769 t
= basic_lookup_transparent_type_1 (objfile
, GLOBAL_BLOCK
, name
);
2774 for (objfile
*objfile
: current_program_space
->objfiles ())
2776 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
2781 /* Now search the static file-level symbols.
2782 Not strictly correct, but more useful than an error.
2783 Do the symtab's first, then
2784 check the psymtab's. If a psymtab indicates the existence
2785 of the desired name as a file-level static, then do psymtab-to-symtab
2786 conversion on the fly and return the found symbol. */
2788 for (objfile
*objfile
: current_program_space
->objfiles ())
2790 t
= basic_lookup_transparent_type_1 (objfile
, STATIC_BLOCK
, name
);
2795 for (objfile
*objfile
: current_program_space
->objfiles ())
2797 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
2802 return (struct type
*) 0;
2808 iterate_over_symbols (const struct block
*block
,
2809 const lookup_name_info
&name
,
2810 const domain_enum domain
,
2811 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2813 struct block_iterator iter
;
2816 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2818 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2819 SYMBOL_DOMAIN (sym
), domain
))
2821 struct block_symbol block_sym
= {sym
, block
};
2823 if (!callback (&block_sym
))
2833 iterate_over_symbols_terminated
2834 (const struct block
*block
,
2835 const lookup_name_info
&name
,
2836 const domain_enum domain
,
2837 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2839 if (!iterate_over_symbols (block
, name
, domain
, callback
))
2841 struct block_symbol block_sym
= {nullptr, block
};
2842 return callback (&block_sym
);
2845 /* Find the compunit symtab associated with PC and SECTION.
2846 This will read in debug info as necessary. */
2848 struct compunit_symtab
*
2849 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2851 struct compunit_symtab
*best_cust
= NULL
;
2852 CORE_ADDR distance
= 0;
2853 struct bound_minimal_symbol msymbol
;
2855 /* If we know that this is not a text address, return failure. This is
2856 necessary because we loop based on the block's high and low code
2857 addresses, which do not include the data ranges, and because
2858 we call find_pc_sect_psymtab which has a similar restriction based
2859 on the partial_symtab's texthigh and textlow. */
2860 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2861 if (msymbol
.minsym
&& msymbol
.minsym
->data_p ())
2864 /* Search all symtabs for the one whose file contains our address, and which
2865 is the smallest of all the ones containing the address. This is designed
2866 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2867 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2868 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2870 This happens for native ecoff format, where code from included files
2871 gets its own symtab. The symtab for the included file should have
2872 been read in already via the dependency mechanism.
2873 It might be swifter to create several symtabs with the same name
2874 like xcoff does (I'm not sure).
2876 It also happens for objfiles that have their functions reordered.
2877 For these, the symtab we are looking for is not necessarily read in. */
2879 for (objfile
*obj_file
: current_program_space
->objfiles ())
2881 for (compunit_symtab
*cust
: obj_file
->compunits ())
2883 const struct block
*b
;
2884 const struct blockvector
*bv
;
2886 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2887 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2889 if (BLOCK_START (b
) <= pc
2890 && BLOCK_END (b
) > pc
2892 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2894 /* For an objfile that has its functions reordered,
2895 find_pc_psymtab will find the proper partial symbol table
2896 and we simply return its corresponding symtab. */
2897 /* In order to better support objfiles that contain both
2898 stabs and coff debugging info, we continue on if a psymtab
2900 if ((obj_file
->flags
& OBJF_REORDERED
) && obj_file
->sf
)
2902 struct compunit_symtab
*result
;
2905 = obj_file
->sf
->qf
->find_pc_sect_compunit_symtab (obj_file
,
2915 struct block_iterator iter
;
2916 struct symbol
*sym
= NULL
;
2918 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2920 fixup_symbol_section (sym
, obj_file
);
2921 if (matching_obj_sections (SYMBOL_OBJ_SECTION (obj_file
,
2927 continue; /* No symbol in this symtab matches
2930 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2936 if (best_cust
!= NULL
)
2939 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2941 for (objfile
*objf
: current_program_space
->objfiles ())
2943 struct compunit_symtab
*result
;
2947 result
= objf
->sf
->qf
->find_pc_sect_compunit_symtab (objf
,
2958 /* Find the compunit symtab associated with PC.
2959 This will read in debug info as necessary.
2960 Backward compatibility, no section. */
2962 struct compunit_symtab
*
2963 find_pc_compunit_symtab (CORE_ADDR pc
)
2965 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2971 find_symbol_at_address (CORE_ADDR address
)
2973 for (objfile
*objfile
: current_program_space
->objfiles ())
2975 if (objfile
->sf
== NULL
2976 || objfile
->sf
->qf
->find_compunit_symtab_by_address
== NULL
)
2979 struct compunit_symtab
*symtab
2980 = objfile
->sf
->qf
->find_compunit_symtab_by_address (objfile
, address
);
2983 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (symtab
);
2985 for (int i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; ++i
)
2987 const struct block
*b
= BLOCKVECTOR_BLOCK (bv
, i
);
2988 struct block_iterator iter
;
2991 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2993 if (SYMBOL_CLASS (sym
) == LOC_STATIC
2994 && SYMBOL_VALUE_ADDRESS (sym
) == address
)
3006 /* Find the source file and line number for a given PC value and SECTION.
3007 Return a structure containing a symtab pointer, a line number,
3008 and a pc range for the entire source line.
3009 The value's .pc field is NOT the specified pc.
3010 NOTCURRENT nonzero means, if specified pc is on a line boundary,
3011 use the line that ends there. Otherwise, in that case, the line
3012 that begins there is used. */
3014 /* The big complication here is that a line may start in one file, and end just
3015 before the start of another file. This usually occurs when you #include
3016 code in the middle of a subroutine. To properly find the end of a line's PC
3017 range, we must search all symtabs associated with this compilation unit, and
3018 find the one whose first PC is closer than that of the next line in this
3021 struct symtab_and_line
3022 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
3024 struct compunit_symtab
*cust
;
3025 struct linetable
*l
;
3027 struct linetable_entry
*item
;
3028 const struct blockvector
*bv
;
3029 struct bound_minimal_symbol msymbol
;
3031 /* Info on best line seen so far, and where it starts, and its file. */
3033 struct linetable_entry
*best
= NULL
;
3034 CORE_ADDR best_end
= 0;
3035 struct symtab
*best_symtab
= 0;
3037 /* Store here the first line number
3038 of a file which contains the line at the smallest pc after PC.
3039 If we don't find a line whose range contains PC,
3040 we will use a line one less than this,
3041 with a range from the start of that file to the first line's pc. */
3042 struct linetable_entry
*alt
= NULL
;
3044 /* Info on best line seen in this file. */
3046 struct linetable_entry
*prev
;
3048 /* If this pc is not from the current frame,
3049 it is the address of the end of a call instruction.
3050 Quite likely that is the start of the following statement.
3051 But what we want is the statement containing the instruction.
3052 Fudge the pc to make sure we get that. */
3054 /* It's tempting to assume that, if we can't find debugging info for
3055 any function enclosing PC, that we shouldn't search for line
3056 number info, either. However, GAS can emit line number info for
3057 assembly files --- very helpful when debugging hand-written
3058 assembly code. In such a case, we'd have no debug info for the
3059 function, but we would have line info. */
3064 /* elz: added this because this function returned the wrong
3065 information if the pc belongs to a stub (import/export)
3066 to call a shlib function. This stub would be anywhere between
3067 two functions in the target, and the line info was erroneously
3068 taken to be the one of the line before the pc. */
3070 /* RT: Further explanation:
3072 * We have stubs (trampolines) inserted between procedures.
3074 * Example: "shr1" exists in a shared library, and a "shr1" stub also
3075 * exists in the main image.
3077 * In the minimal symbol table, we have a bunch of symbols
3078 * sorted by start address. The stubs are marked as "trampoline",
3079 * the others appear as text. E.g.:
3081 * Minimal symbol table for main image
3082 * main: code for main (text symbol)
3083 * shr1: stub (trampoline symbol)
3084 * foo: code for foo (text symbol)
3086 * Minimal symbol table for "shr1" image:
3088 * shr1: code for shr1 (text symbol)
3091 * So the code below is trying to detect if we are in the stub
3092 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3093 * and if found, do the symbolization from the real-code address
3094 * rather than the stub address.
3096 * Assumptions being made about the minimal symbol table:
3097 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3098 * if we're really in the trampoline.s If we're beyond it (say
3099 * we're in "foo" in the above example), it'll have a closer
3100 * symbol (the "foo" text symbol for example) and will not
3101 * return the trampoline.
3102 * 2. lookup_minimal_symbol_text() will find a real text symbol
3103 * corresponding to the trampoline, and whose address will
3104 * be different than the trampoline address. I put in a sanity
3105 * check for the address being the same, to avoid an
3106 * infinite recursion.
3108 msymbol
= lookup_minimal_symbol_by_pc (pc
);
3109 if (msymbol
.minsym
!= NULL
)
3110 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
3112 struct bound_minimal_symbol mfunsym
3113 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
3116 if (mfunsym
.minsym
== NULL
)
3117 /* I eliminated this warning since it is coming out
3118 * in the following situation:
3119 * gdb shmain // test program with shared libraries
3120 * (gdb) break shr1 // function in shared lib
3121 * Warning: In stub for ...
3122 * In the above situation, the shared lib is not loaded yet,
3123 * so of course we can't find the real func/line info,
3124 * but the "break" still works, and the warning is annoying.
3125 * So I commented out the warning. RT */
3126 /* warning ("In stub for %s; unable to find real function/line info",
3127 SYMBOL_LINKAGE_NAME (msymbol)); */
3130 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
3131 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
3132 /* Avoid infinite recursion */
3133 /* See above comment about why warning is commented out. */
3134 /* warning ("In stub for %s; unable to find real function/line info",
3135 SYMBOL_LINKAGE_NAME (msymbol)); */
3139 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
3142 symtab_and_line val
;
3143 val
.pspace
= current_program_space
;
3145 cust
= find_pc_sect_compunit_symtab (pc
, section
);
3148 /* If no symbol information, return previous pc. */
3155 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3157 /* Look at all the symtabs that share this blockvector.
3158 They all have the same apriori range, that we found was right;
3159 but they have different line tables. */
3161 for (symtab
*iter_s
: compunit_filetabs (cust
))
3163 /* Find the best line in this symtab. */
3164 l
= SYMTAB_LINETABLE (iter_s
);
3170 /* I think len can be zero if the symtab lacks line numbers
3171 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3172 I'm not sure which, and maybe it depends on the symbol
3178 item
= l
->item
; /* Get first line info. */
3180 /* Is this file's first line closer than the first lines of other files?
3181 If so, record this file, and its first line, as best alternate. */
3182 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
3185 auto pc_compare
= [](const CORE_ADDR
& comp_pc
,
3186 const struct linetable_entry
& lhs
)->bool
3188 return comp_pc
< lhs
.pc
;
3191 struct linetable_entry
*first
= item
;
3192 struct linetable_entry
*last
= item
+ len
;
3193 item
= std::upper_bound (first
, last
, pc
, pc_compare
);
3195 prev
= item
- 1; /* Found a matching item. */
3197 /* At this point, prev points at the line whose start addr is <= pc, and
3198 item points at the next line. If we ran off the end of the linetable
3199 (pc >= start of the last line), then prev == item. If pc < start of
3200 the first line, prev will not be set. */
3202 /* Is this file's best line closer than the best in the other files?
3203 If so, record this file, and its best line, as best so far. Don't
3204 save prev if it represents the end of a function (i.e. line number
3205 0) instead of a real line. */
3207 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
3210 best_symtab
= iter_s
;
3212 /* Discard BEST_END if it's before the PC of the current BEST. */
3213 if (best_end
<= best
->pc
)
3217 /* If another line (denoted by ITEM) is in the linetable and its
3218 PC is after BEST's PC, but before the current BEST_END, then
3219 use ITEM's PC as the new best_end. */
3220 if (best
&& item
< last
&& item
->pc
> best
->pc
3221 && (best_end
== 0 || best_end
> item
->pc
))
3222 best_end
= item
->pc
;
3227 /* If we didn't find any line number info, just return zeros.
3228 We used to return alt->line - 1 here, but that could be
3229 anywhere; if we don't have line number info for this PC,
3230 don't make some up. */
3233 else if (best
->line
== 0)
3235 /* If our best fit is in a range of PC's for which no line
3236 number info is available (line number is zero) then we didn't
3237 find any valid line information. */
3242 val
.symtab
= best_symtab
;
3243 val
.line
= best
->line
;
3245 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
3250 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3252 val
.section
= section
;
3256 /* Backward compatibility (no section). */
3258 struct symtab_and_line
3259 find_pc_line (CORE_ADDR pc
, int notcurrent
)
3261 struct obj_section
*section
;
3263 section
= find_pc_overlay (pc
);
3264 if (pc_in_unmapped_range (pc
, section
))
3265 pc
= overlay_mapped_address (pc
, section
);
3266 return find_pc_sect_line (pc
, section
, notcurrent
);
3272 find_pc_line_symtab (CORE_ADDR pc
)
3274 struct symtab_and_line sal
;
3276 /* This always passes zero for NOTCURRENT to find_pc_line.
3277 There are currently no callers that ever pass non-zero. */
3278 sal
= find_pc_line (pc
, 0);
3282 /* Find line number LINE in any symtab whose name is the same as
3285 If found, return the symtab that contains the linetable in which it was
3286 found, set *INDEX to the index in the linetable of the best entry
3287 found, and set *EXACT_MATCH to true if the value returned is an
3290 If not found, return NULL. */
3293 find_line_symtab (struct symtab
*sym_tab
, int line
,
3294 int *index
, bool *exact_match
)
3296 int exact
= 0; /* Initialized here to avoid a compiler warning. */
3298 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3302 struct linetable
*best_linetable
;
3303 struct symtab
*best_symtab
;
3305 /* First try looking it up in the given symtab. */
3306 best_linetable
= SYMTAB_LINETABLE (sym_tab
);
3307 best_symtab
= sym_tab
;
3308 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
3309 if (best_index
< 0 || !exact
)
3311 /* Didn't find an exact match. So we better keep looking for
3312 another symtab with the same name. In the case of xcoff,
3313 multiple csects for one source file (produced by IBM's FORTRAN
3314 compiler) produce multiple symtabs (this is unavoidable
3315 assuming csects can be at arbitrary places in memory and that
3316 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3318 /* BEST is the smallest linenumber > LINE so far seen,
3319 or 0 if none has been seen so far.
3320 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3323 if (best_index
>= 0)
3324 best
= best_linetable
->item
[best_index
].line
;
3328 for (objfile
*objfile
: current_program_space
->objfiles ())
3331 objfile
->sf
->qf
->expand_symtabs_with_fullname
3332 (objfile
, symtab_to_fullname (sym_tab
));
3335 for (objfile
*objfile
: current_program_space
->objfiles ())
3337 for (compunit_symtab
*cu
: objfile
->compunits ())
3339 for (symtab
*s
: compunit_filetabs (cu
))
3341 struct linetable
*l
;
3344 if (FILENAME_CMP (sym_tab
->filename
, s
->filename
) != 0)
3346 if (FILENAME_CMP (symtab_to_fullname (sym_tab
),
3347 symtab_to_fullname (s
)) != 0)
3349 l
= SYMTAB_LINETABLE (s
);
3350 ind
= find_line_common (l
, line
, &exact
, 0);
3360 if (best
== 0 || l
->item
[ind
].line
< best
)
3362 best
= l
->item
[ind
].line
;
3377 *index
= best_index
;
3379 *exact_match
= (exact
!= 0);
3384 /* Given SYMTAB, returns all the PCs function in the symtab that
3385 exactly match LINE. Returns an empty vector if there are no exact
3386 matches, but updates BEST_ITEM in this case. */
3388 std::vector
<CORE_ADDR
>
3389 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
3390 struct linetable_entry
**best_item
)
3393 std::vector
<CORE_ADDR
> result
;
3395 /* First, collect all the PCs that are at this line. */
3401 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
3408 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
3410 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
3416 result
.push_back (SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
3424 /* Set the PC value for a given source file and line number and return true.
3425 Returns false for invalid line number (and sets the PC to 0).
3426 The source file is specified with a struct symtab. */
3429 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
3431 struct linetable
*l
;
3438 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
3441 l
= SYMTAB_LINETABLE (symtab
);
3442 *pc
= l
->item
[ind
].pc
;
3449 /* Find the range of pc values in a line.
3450 Store the starting pc of the line into *STARTPTR
3451 and the ending pc (start of next line) into *ENDPTR.
3452 Returns true to indicate success.
3453 Returns false if could not find the specified line. */
3456 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
3459 CORE_ADDR startaddr
;
3460 struct symtab_and_line found_sal
;
3463 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
3466 /* This whole function is based on address. For example, if line 10 has
3467 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3468 "info line *0x123" should say the line goes from 0x100 to 0x200
3469 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3470 This also insures that we never give a range like "starts at 0x134
3471 and ends at 0x12c". */
3473 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
3474 if (found_sal
.line
!= sal
.line
)
3476 /* The specified line (sal) has zero bytes. */
3477 *startptr
= found_sal
.pc
;
3478 *endptr
= found_sal
.pc
;
3482 *startptr
= found_sal
.pc
;
3483 *endptr
= found_sal
.end
;
3488 /* Given a line table and a line number, return the index into the line
3489 table for the pc of the nearest line whose number is >= the specified one.
3490 Return -1 if none is found. The value is >= 0 if it is an index.
3491 START is the index at which to start searching the line table.
3493 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3496 find_line_common (struct linetable
*l
, int lineno
,
3497 int *exact_match
, int start
)
3502 /* BEST is the smallest linenumber > LINENO so far seen,
3503 or 0 if none has been seen so far.
3504 BEST_INDEX identifies the item for it. */
3506 int best_index
= -1;
3517 for (i
= start
; i
< len
; i
++)
3519 struct linetable_entry
*item
= &(l
->item
[i
]);
3521 if (item
->line
== lineno
)
3523 /* Return the first (lowest address) entry which matches. */
3528 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
3535 /* If we got here, we didn't get an exact match. */
3540 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
3542 struct symtab_and_line sal
;
3544 sal
= find_pc_line (pc
, 0);
3547 return sal
.symtab
!= 0;
3550 /* Helper for find_function_start_sal. Does most of the work, except
3551 setting the sal's symbol. */
3553 static symtab_and_line
3554 find_function_start_sal_1 (CORE_ADDR func_addr
, obj_section
*section
,
3557 symtab_and_line sal
= find_pc_sect_line (func_addr
, section
, 0);
3559 if (funfirstline
&& sal
.symtab
!= NULL
3560 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal
.symtab
))
3561 || SYMTAB_LANGUAGE (sal
.symtab
) == language_asm
))
3563 struct gdbarch
*gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
3566 if (gdbarch_skip_entrypoint_p (gdbarch
))
3567 sal
.pc
= gdbarch_skip_entrypoint (gdbarch
, sal
.pc
);
3571 /* We always should have a line for the function start address.
3572 If we don't, something is odd. Create a plain SAL referring
3573 just the PC and hope that skip_prologue_sal (if requested)
3574 can find a line number for after the prologue. */
3575 if (sal
.pc
< func_addr
)
3578 sal
.pspace
= current_program_space
;
3580 sal
.section
= section
;
3584 skip_prologue_sal (&sal
);
3592 find_function_start_sal (CORE_ADDR func_addr
, obj_section
*section
,
3596 = find_function_start_sal_1 (func_addr
, section
, funfirstline
);
3598 /* find_function_start_sal_1 does a linetable search, so it finds
3599 the symtab and linenumber, but not a symbol. Fill in the
3600 function symbol too. */
3601 sal
.symbol
= find_pc_sect_containing_function (sal
.pc
, sal
.section
);
3609 find_function_start_sal (symbol
*sym
, bool funfirstline
)
3611 fixup_symbol_section (sym
, NULL
);
3613 = find_function_start_sal_1 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)),
3614 SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
),
3621 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3622 address for that function that has an entry in SYMTAB's line info
3623 table. If such an entry cannot be found, return FUNC_ADDR
3627 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
3629 CORE_ADDR func_start
, func_end
;
3630 struct linetable
*l
;
3633 /* Give up if this symbol has no lineinfo table. */
3634 l
= SYMTAB_LINETABLE (symtab
);
3638 /* Get the range for the function's PC values, or give up if we
3639 cannot, for some reason. */
3640 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
3643 /* Linetable entries are ordered by PC values, see the commentary in
3644 symtab.h where `struct linetable' is defined. Thus, the first
3645 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3646 address we are looking for. */
3647 for (i
= 0; i
< l
->nitems
; i
++)
3649 struct linetable_entry
*item
= &(l
->item
[i
]);
3651 /* Don't use line numbers of zero, they mark special entries in
3652 the table. See the commentary on symtab.h before the
3653 definition of struct linetable. */
3654 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
3661 /* Adjust SAL to the first instruction past the function prologue.
3662 If the PC was explicitly specified, the SAL is not changed.
3663 If the line number was explicitly specified then the SAL can still be
3664 updated, unless the language for SAL is assembler, in which case the SAL
3665 will be left unchanged.
3666 If SAL is already past the prologue, then do nothing. */
3669 skip_prologue_sal (struct symtab_and_line
*sal
)
3672 struct symtab_and_line start_sal
;
3673 CORE_ADDR pc
, saved_pc
;
3674 struct obj_section
*section
;
3676 struct objfile
*objfile
;
3677 struct gdbarch
*gdbarch
;
3678 const struct block
*b
, *function_block
;
3679 int force_skip
, skip
;
3681 /* Do not change the SAL if PC was specified explicitly. */
3682 if (sal
->explicit_pc
)
3685 /* In assembly code, if the user asks for a specific line then we should
3686 not adjust the SAL. The user already has instruction level
3687 visibility in this case, so selecting a line other than one requested
3688 is likely to be the wrong choice. */
3689 if (sal
->symtab
!= nullptr
3690 && sal
->explicit_line
3691 && SYMTAB_LANGUAGE (sal
->symtab
) == language_asm
)
3694 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3696 switch_to_program_space_and_thread (sal
->pspace
);
3698 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
3701 fixup_symbol_section (sym
, NULL
);
3703 objfile
= symbol_objfile (sym
);
3704 pc
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
3705 section
= SYMBOL_OBJ_SECTION (objfile
, sym
);
3706 name
= SYMBOL_LINKAGE_NAME (sym
);
3710 struct bound_minimal_symbol msymbol
3711 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
3713 if (msymbol
.minsym
== NULL
)
3716 objfile
= msymbol
.objfile
;
3717 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
3718 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
3719 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
3722 gdbarch
= get_objfile_arch (objfile
);
3724 /* Process the prologue in two passes. In the first pass try to skip the
3725 prologue (SKIP is true) and verify there is a real need for it (indicated
3726 by FORCE_SKIP). If no such reason was found run a second pass where the
3727 prologue is not skipped (SKIP is false). */
3732 /* Be conservative - allow direct PC (without skipping prologue) only if we
3733 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3734 have to be set by the caller so we use SYM instead. */
3736 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym
))))
3744 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3745 so that gdbarch_skip_prologue has something unique to work on. */
3746 if (section_is_overlay (section
) && !section_is_mapped (section
))
3747 pc
= overlay_unmapped_address (pc
, section
);
3749 /* Skip "first line" of function (which is actually its prologue). */
3750 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3751 if (gdbarch_skip_entrypoint_p (gdbarch
))
3752 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
3754 pc
= gdbarch_skip_prologue_noexcept (gdbarch
, pc
);
3756 /* For overlays, map pc back into its mapped VMA range. */
3757 pc
= overlay_mapped_address (pc
, section
);
3759 /* Calculate line number. */
3760 start_sal
= find_pc_sect_line (pc
, section
, 0);
3762 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3763 line is still part of the same function. */
3764 if (skip
&& start_sal
.pc
!= pc
3765 && (sym
? (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
3766 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
3767 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
3768 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
3770 /* First pc of next line */
3772 /* Recalculate the line number (might not be N+1). */
3773 start_sal
= find_pc_sect_line (pc
, section
, 0);
3776 /* On targets with executable formats that don't have a concept of
3777 constructors (ELF with .init has, PE doesn't), gcc emits a call
3778 to `__main' in `main' between the prologue and before user
3780 if (gdbarch_skip_main_prologue_p (gdbarch
)
3781 && name
&& strcmp_iw (name
, "main") == 0)
3783 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
3784 /* Recalculate the line number (might not be N+1). */
3785 start_sal
= find_pc_sect_line (pc
, section
, 0);
3789 while (!force_skip
&& skip
--);
3791 /* If we still don't have a valid source line, try to find the first
3792 PC in the lineinfo table that belongs to the same function. This
3793 happens with COFF debug info, which does not seem to have an
3794 entry in lineinfo table for the code after the prologue which has
3795 no direct relation to source. For example, this was found to be
3796 the case with the DJGPP target using "gcc -gcoff" when the
3797 compiler inserted code after the prologue to make sure the stack
3799 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
3801 pc
= skip_prologue_using_lineinfo (pc
, symbol_symtab (sym
));
3802 /* Recalculate the line number. */
3803 start_sal
= find_pc_sect_line (pc
, section
, 0);
3806 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3807 forward SAL to the end of the prologue. */
3812 sal
->section
= section
;
3813 sal
->symtab
= start_sal
.symtab
;
3814 sal
->line
= start_sal
.line
;
3815 sal
->end
= start_sal
.end
;
3817 /* Check if we are now inside an inlined function. If we can,
3818 use the call site of the function instead. */
3819 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
3820 function_block
= NULL
;
3823 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
3825 else if (BLOCK_FUNCTION (b
) != NULL
)
3827 b
= BLOCK_SUPERBLOCK (b
);
3829 if (function_block
!= NULL
3830 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
3832 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
3833 sal
->symtab
= symbol_symtab (BLOCK_FUNCTION (function_block
));
3837 /* Given PC at the function's start address, attempt to find the
3838 prologue end using SAL information. Return zero if the skip fails.
3840 A non-optimized prologue traditionally has one SAL for the function
3841 and a second for the function body. A single line function has
3842 them both pointing at the same line.
3844 An optimized prologue is similar but the prologue may contain
3845 instructions (SALs) from the instruction body. Need to skip those
3846 while not getting into the function body.
3848 The functions end point and an increasing SAL line are used as
3849 indicators of the prologue's endpoint.
3851 This code is based on the function refine_prologue_limit
3855 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
3857 struct symtab_and_line prologue_sal
;
3860 const struct block
*bl
;
3862 /* Get an initial range for the function. */
3863 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
3864 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3866 prologue_sal
= find_pc_line (start_pc
, 0);
3867 if (prologue_sal
.line
!= 0)
3869 /* For languages other than assembly, treat two consecutive line
3870 entries at the same address as a zero-instruction prologue.
3871 The GNU assembler emits separate line notes for each instruction
3872 in a multi-instruction macro, but compilers generally will not
3874 if (prologue_sal
.symtab
->language
!= language_asm
)
3876 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
3879 /* Skip any earlier lines, and any end-of-sequence marker
3880 from a previous function. */
3881 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
3882 || linetable
->item
[idx
].line
== 0)
3885 if (idx
+1 < linetable
->nitems
3886 && linetable
->item
[idx
+1].line
!= 0
3887 && linetable
->item
[idx
+1].pc
== start_pc
)
3891 /* If there is only one sal that covers the entire function,
3892 then it is probably a single line function, like
3894 if (prologue_sal
.end
>= end_pc
)
3897 while (prologue_sal
.end
< end_pc
)
3899 struct symtab_and_line sal
;
3901 sal
= find_pc_line (prologue_sal
.end
, 0);
3904 /* Assume that a consecutive SAL for the same (or larger)
3905 line mark the prologue -> body transition. */
3906 if (sal
.line
>= prologue_sal
.line
)
3908 /* Likewise if we are in a different symtab altogether
3909 (e.g. within a file included via #include). */
3910 if (sal
.symtab
!= prologue_sal
.symtab
)
3913 /* The line number is smaller. Check that it's from the
3914 same function, not something inlined. If it's inlined,
3915 then there is no point comparing the line numbers. */
3916 bl
= block_for_pc (prologue_sal
.end
);
3919 if (block_inlined_p (bl
))
3921 if (BLOCK_FUNCTION (bl
))
3926 bl
= BLOCK_SUPERBLOCK (bl
);
3931 /* The case in which compiler's optimizer/scheduler has
3932 moved instructions into the prologue. We look ahead in
3933 the function looking for address ranges whose
3934 corresponding line number is less the first one that we
3935 found for the function. This is more conservative then
3936 refine_prologue_limit which scans a large number of SALs
3937 looking for any in the prologue. */
3942 if (prologue_sal
.end
< end_pc
)
3943 /* Return the end of this line, or zero if we could not find a
3945 return prologue_sal
.end
;
3947 /* Don't return END_PC, which is past the end of the function. */
3948 return prologue_sal
.pc
;
3954 find_function_alias_target (bound_minimal_symbol msymbol
)
3956 CORE_ADDR func_addr
;
3957 if (!msymbol_is_function (msymbol
.objfile
, msymbol
.minsym
, &func_addr
))
3960 symbol
*sym
= find_pc_function (func_addr
);
3962 && SYMBOL_CLASS (sym
) == LOC_BLOCK
3963 && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) == func_addr
)
3970 /* If P is of the form "operator[ \t]+..." where `...' is
3971 some legitimate operator text, return a pointer to the
3972 beginning of the substring of the operator text.
3973 Otherwise, return "". */
3976 operator_chars (const char *p
, const char **end
)
3979 if (!startswith (p
, CP_OPERATOR_STR
))
3981 p
+= CP_OPERATOR_LEN
;
3983 /* Don't get faked out by `operator' being part of a longer
3985 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
3988 /* Allow some whitespace between `operator' and the operator symbol. */
3989 while (*p
== ' ' || *p
== '\t')
3992 /* Recognize 'operator TYPENAME'. */
3994 if (isalpha (*p
) || *p
== '_' || *p
== '$')
3996 const char *q
= p
+ 1;
3998 while (isalnum (*q
) || *q
== '_' || *q
== '$')
4007 case '\\': /* regexp quoting */
4010 if (p
[2] == '=') /* 'operator\*=' */
4012 else /* 'operator\*' */
4016 else if (p
[1] == '[')
4019 error (_("mismatched quoting on brackets, "
4020 "try 'operator\\[\\]'"));
4021 else if (p
[2] == '\\' && p
[3] == ']')
4023 *end
= p
+ 4; /* 'operator\[\]' */
4027 error (_("nothing is allowed between '[' and ']'"));
4031 /* Gratuitous quote: skip it and move on. */
4053 if (p
[0] == '-' && p
[1] == '>')
4055 /* Struct pointer member operator 'operator->'. */
4058 *end
= p
+ 3; /* 'operator->*' */
4061 else if (p
[2] == '\\')
4063 *end
= p
+ 4; /* Hopefully 'operator->\*' */
4068 *end
= p
+ 2; /* 'operator->' */
4072 if (p
[1] == '=' || p
[1] == p
[0])
4083 error (_("`operator ()' must be specified "
4084 "without whitespace in `()'"));
4089 error (_("`operator ?:' must be specified "
4090 "without whitespace in `?:'"));
4095 error (_("`operator []' must be specified "
4096 "without whitespace in `[]'"));
4100 error (_("`operator %s' not supported"), p
);
4109 /* What part to match in a file name. */
4111 struct filename_partial_match_opts
4113 /* Only match the directory name part. */
4114 bool dirname
= false;
4116 /* Only match the basename part. */
4117 bool basename
= false;
4120 /* Data structure to maintain printing state for output_source_filename. */
4122 struct output_source_filename_data
4124 /* Output only filenames matching REGEXP. */
4126 gdb::optional
<compiled_regex
> c_regexp
;
4127 /* Possibly only match a part of the filename. */
4128 filename_partial_match_opts partial_match
;
4131 /* Cache of what we've seen so far. */
4132 struct filename_seen_cache
*filename_seen_cache
;
4134 /* Flag of whether we're printing the first one. */
4138 /* Slave routine for sources_info. Force line breaks at ,'s.
4139 NAME is the name to print.
4140 DATA contains the state for printing and watching for duplicates. */
4143 output_source_filename (const char *name
,
4144 struct output_source_filename_data
*data
)
4146 /* Since a single source file can result in several partial symbol
4147 tables, we need to avoid printing it more than once. Note: if
4148 some of the psymtabs are read in and some are not, it gets
4149 printed both under "Source files for which symbols have been
4150 read" and "Source files for which symbols will be read in on
4151 demand". I consider this a reasonable way to deal with the
4152 situation. I'm not sure whether this can also happen for
4153 symtabs; it doesn't hurt to check. */
4155 /* Was NAME already seen? */
4156 if (data
->filename_seen_cache
->seen (name
))
4158 /* Yes; don't print it again. */
4162 /* Does it match data->regexp? */
4163 if (data
->c_regexp
.has_value ())
4165 const char *to_match
;
4166 std::string dirname
;
4168 if (data
->partial_match
.dirname
)
4170 dirname
= ldirname (name
);
4171 to_match
= dirname
.c_str ();
4173 else if (data
->partial_match
.basename
)
4174 to_match
= lbasename (name
);
4178 if (data
->c_regexp
->exec (to_match
, 0, NULL
, 0) != 0)
4182 /* Print it and reset *FIRST. */
4184 printf_filtered (", ");
4188 fputs_styled (name
, file_name_style
.style (), gdb_stdout
);
4191 /* A callback for map_partial_symbol_filenames. */
4194 output_partial_symbol_filename (const char *filename
, const char *fullname
,
4197 output_source_filename (fullname
? fullname
: filename
,
4198 (struct output_source_filename_data
*) data
);
4201 using isrc_flag_option_def
4202 = gdb::option::flag_option_def
<filename_partial_match_opts
>;
4204 static const gdb::option::option_def info_sources_option_defs
[] = {
4206 isrc_flag_option_def
{
4208 [] (filename_partial_match_opts
*opts
) { return &opts
->dirname
; },
4209 N_("Show only the files having a dirname matching REGEXP."),
4212 isrc_flag_option_def
{
4214 [] (filename_partial_match_opts
*opts
) { return &opts
->basename
; },
4215 N_("Show only the files having a basename matching REGEXP."),
4220 /* Create an option_def_group for the "info sources" options, with
4221 ISRC_OPTS as context. */
4223 static inline gdb::option::option_def_group
4224 make_info_sources_options_def_group (filename_partial_match_opts
*isrc_opts
)
4226 return {{info_sources_option_defs
}, isrc_opts
};
4229 /* Prints the header message for the source files that will be printed
4230 with the matching info present in DATA. SYMBOL_MSG is a message
4231 that tells what will or has been done with the symbols of the
4232 matching source files. */
4235 print_info_sources_header (const char *symbol_msg
,
4236 const struct output_source_filename_data
*data
)
4238 puts_filtered (symbol_msg
);
4239 if (!data
->regexp
.empty ())
4241 if (data
->partial_match
.dirname
)
4242 printf_filtered (_("(dirname matching regular expression \"%s\")"),
4243 data
->regexp
.c_str ());
4244 else if (data
->partial_match
.basename
)
4245 printf_filtered (_("(basename matching regular expression \"%s\")"),
4246 data
->regexp
.c_str ());
4248 printf_filtered (_("(filename matching regular expression \"%s\")"),
4249 data
->regexp
.c_str ());
4251 puts_filtered ("\n");
4254 /* Completer for "info sources". */
4257 info_sources_command_completer (cmd_list_element
*ignore
,
4258 completion_tracker
&tracker
,
4259 const char *text
, const char *word
)
4261 const auto group
= make_info_sources_options_def_group (nullptr);
4262 if (gdb::option::complete_options
4263 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
4268 info_sources_command (const char *args
, int from_tty
)
4270 struct output_source_filename_data data
;
4272 if (!have_full_symbols () && !have_partial_symbols ())
4274 error (_("No symbol table is loaded. Use the \"file\" command."));
4277 filename_seen_cache filenames_seen
;
4279 auto group
= make_info_sources_options_def_group (&data
.partial_match
);
4281 gdb::option::process_options
4282 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
4284 if (args
!= NULL
&& *args
!= '\000')
4287 data
.filename_seen_cache
= &filenames_seen
;
4290 if (data
.partial_match
.dirname
&& data
.partial_match
.basename
)
4291 error (_("You cannot give both -basename and -dirname to 'info sources'."));
4292 if ((data
.partial_match
.dirname
|| data
.partial_match
.basename
)
4293 && data
.regexp
.empty ())
4294 error (_("Missing REGEXP for 'info sources'."));
4296 if (data
.regexp
.empty ())
4297 data
.c_regexp
.reset ();
4300 int cflags
= REG_NOSUB
;
4301 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
4302 cflags
|= REG_ICASE
;
4304 data
.c_regexp
.emplace (data
.regexp
.c_str (), cflags
,
4305 _("Invalid regexp"));
4308 print_info_sources_header
4309 (_("Source files for which symbols have been read in:\n"), &data
);
4311 for (objfile
*objfile
: current_program_space
->objfiles ())
4313 for (compunit_symtab
*cu
: objfile
->compunits ())
4315 for (symtab
*s
: compunit_filetabs (cu
))
4317 const char *fullname
= symtab_to_fullname (s
);
4319 output_source_filename (fullname
, &data
);
4323 printf_filtered ("\n\n");
4325 print_info_sources_header
4326 (_("Source files for which symbols will be read in on demand:\n"), &data
);
4328 filenames_seen
.clear ();
4330 map_symbol_filenames (output_partial_symbol_filename
, &data
,
4331 1 /*need_fullname*/);
4332 printf_filtered ("\n");
4335 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4336 non-zero compare only lbasename of FILES. */
4339 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
4343 if (file
!= NULL
&& nfiles
!= 0)
4345 for (i
= 0; i
< nfiles
; i
++)
4347 if (compare_filenames_for_search (file
, (basenames
4348 ? lbasename (files
[i
])
4353 else if (nfiles
== 0)
4358 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4359 sort symbols, not minimal symbols. */
4362 symbol_search::compare_search_syms (const symbol_search
&sym_a
,
4363 const symbol_search
&sym_b
)
4367 c
= FILENAME_CMP (symbol_symtab (sym_a
.symbol
)->filename
,
4368 symbol_symtab (sym_b
.symbol
)->filename
);
4372 if (sym_a
.block
!= sym_b
.block
)
4373 return sym_a
.block
- sym_b
.block
;
4375 return strcmp (SYMBOL_PRINT_NAME (sym_a
.symbol
),
4376 SYMBOL_PRINT_NAME (sym_b
.symbol
));
4379 /* Returns true if the type_name of symbol_type of SYM matches TREG.
4380 If SYM has no symbol_type or symbol_name, returns false. */
4383 treg_matches_sym_type_name (const compiled_regex
&treg
,
4384 const struct symbol
*sym
)
4386 struct type
*sym_type
;
4387 std::string printed_sym_type_name
;
4389 if (symbol_lookup_debug
> 1)
4391 fprintf_unfiltered (gdb_stdlog
,
4392 "treg_matches_sym_type_name\n sym %s\n",
4393 SYMBOL_NATURAL_NAME (sym
));
4396 sym_type
= SYMBOL_TYPE (sym
);
4397 if (sym_type
== NULL
)
4401 scoped_switch_to_sym_language_if_auto
l (sym
);
4403 printed_sym_type_name
= type_to_string (sym_type
);
4407 if (symbol_lookup_debug
> 1)
4409 fprintf_unfiltered (gdb_stdlog
,
4410 " sym_type_name %s\n",
4411 printed_sym_type_name
.c_str ());
4415 if (printed_sym_type_name
.empty ())
4418 return treg
.exec (printed_sym_type_name
.c_str (), 0, NULL
, 0) == 0;
4422 /* Sort the symbols in RESULT and remove duplicates. */
4425 sort_search_symbols_remove_dups (std::vector
<symbol_search
> *result
)
4427 std::sort (result
->begin (), result
->end ());
4428 result
->erase (std::unique (result
->begin (), result
->end ()),
4432 /* Search the symbol table for matches to the regular expression REGEXP,
4433 returning the results.
4435 Only symbols of KIND are searched:
4436 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4437 and constants (enums).
4438 if T_REGEXP is not NULL, only returns var that have
4439 a type matching regular expression T_REGEXP.
4440 FUNCTIONS_DOMAIN - search all functions
4441 TYPES_DOMAIN - search all type names
4442 ALL_DOMAIN - an internal error for this function
4444 Within each file the results are sorted locally; each symtab's global and
4445 static blocks are separately alphabetized.
4446 Duplicate entries are removed.
4448 When EXCLUDE_MINSYMS is false then matching minsyms are also returned,
4449 otherwise they are excluded. */
4451 std::vector
<symbol_search
>
4452 search_symbols (const char *regexp
, enum search_domain kind
,
4453 const char *t_regexp
,
4454 int nfiles
, const char *files
[],
4455 bool exclude_minsyms
)
4457 const struct blockvector
*bv
;
4458 const struct block
*b
;
4460 struct block_iterator iter
;
4463 static const enum minimal_symbol_type types
[]
4464 = {mst_data
, mst_text
, mst_unknown
};
4465 static const enum minimal_symbol_type types2
[]
4466 = {mst_bss
, mst_file_text
, mst_unknown
};
4467 static const enum minimal_symbol_type types3
[]
4468 = {mst_file_data
, mst_solib_trampoline
, mst_unknown
};
4469 static const enum minimal_symbol_type types4
[]
4470 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_unknown
};
4471 enum minimal_symbol_type ourtype
;
4472 enum minimal_symbol_type ourtype2
;
4473 enum minimal_symbol_type ourtype3
;
4474 enum minimal_symbol_type ourtype4
;
4475 std::vector
<symbol_search
> result
;
4476 gdb::optional
<compiled_regex
> preg
;
4477 gdb::optional
<compiled_regex
> treg
;
4479 gdb_assert (kind
<= TYPES_DOMAIN
);
4481 ourtype
= types
[kind
];
4482 ourtype2
= types2
[kind
];
4483 ourtype3
= types3
[kind
];
4484 ourtype4
= types4
[kind
];
4488 /* Make sure spacing is right for C++ operators.
4489 This is just a courtesy to make the matching less sensitive
4490 to how many spaces the user leaves between 'operator'
4491 and <TYPENAME> or <OPERATOR>. */
4493 const char *opname
= operator_chars (regexp
, &opend
);
4497 int fix
= -1; /* -1 means ok; otherwise number of
4500 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
4502 /* There should 1 space between 'operator' and 'TYPENAME'. */
4503 if (opname
[-1] != ' ' || opname
[-2] == ' ')
4508 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4509 if (opname
[-1] == ' ')
4512 /* If wrong number of spaces, fix it. */
4515 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
4517 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
4522 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4524 preg
.emplace (regexp
, cflags
, _("Invalid regexp"));
4527 if (t_regexp
!= NULL
)
4529 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4531 treg
.emplace (t_regexp
, cflags
, _("Invalid regexp"));
4534 /* Search through the partial symtabs *first* for all symbols
4535 matching the regexp. That way we don't have to reproduce all of
4536 the machinery below. */
4537 expand_symtabs_matching ([&] (const char *filename
, bool basenames
)
4539 return file_matches (filename
, files
, nfiles
,
4542 lookup_name_info::match_any (),
4543 [&] (const char *symname
)
4545 return (!preg
.has_value ()
4546 || preg
->exec (symname
,
4552 /* Here, we search through the minimal symbol tables for functions
4553 and variables that match, and force their symbols to be read.
4554 This is in particular necessary for demangled variable names,
4555 which are no longer put into the partial symbol tables.
4556 The symbol will then be found during the scan of symtabs below.
4558 For functions, find_pc_symtab should succeed if we have debug info
4559 for the function, for variables we have to call
4560 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4562 If the lookup fails, set found_misc so that we will rescan to print
4563 any matching symbols without debug info.
4564 We only search the objfile the msymbol came from, we no longer search
4565 all objfiles. In large programs (1000s of shared libs) searching all
4566 objfiles is not worth the pain. */
4568 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
4570 for (objfile
*objfile
: current_program_space
->objfiles ())
4572 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
4576 if (msymbol
->created_by_gdb
)
4579 if (MSYMBOL_TYPE (msymbol
) == ourtype
4580 || MSYMBOL_TYPE (msymbol
) == ourtype2
4581 || MSYMBOL_TYPE (msymbol
) == ourtype3
4582 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4584 if (!preg
.has_value ()
4585 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4588 /* Note: An important side-effect of these
4589 lookup functions is to expand the symbol
4590 table if msymbol is found, for the benefit of
4591 the next loop on compunits. */
4592 if (kind
== FUNCTIONS_DOMAIN
4593 ? (find_pc_compunit_symtab
4594 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4596 : (lookup_symbol_in_objfile_from_linkage_name
4597 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4607 for (objfile
*objfile
: current_program_space
->objfiles ())
4609 for (compunit_symtab
*cust
: objfile
->compunits ())
4611 bv
= COMPUNIT_BLOCKVECTOR (cust
);
4612 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
4614 b
= BLOCKVECTOR_BLOCK (bv
, i
);
4615 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4617 struct symtab
*real_symtab
= symbol_symtab (sym
);
4621 /* Check first sole REAL_SYMTAB->FILENAME. It does
4622 not need to be a substring of symtab_to_fullname as
4623 it may contain "./" etc. */
4624 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
4625 || ((basenames_may_differ
4626 || file_matches (lbasename (real_symtab
->filename
),
4628 && file_matches (symtab_to_fullname (real_symtab
),
4630 && ((!preg
.has_value ()
4631 || preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
4633 && ((kind
== VARIABLES_DOMAIN
4634 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
4635 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
4636 && SYMBOL_CLASS (sym
) != LOC_BLOCK
4637 /* LOC_CONST can be used for more than
4638 just enums, e.g., c++ static const
4639 members. We only want to skip enums
4641 && !(SYMBOL_CLASS (sym
) == LOC_CONST
4642 && (TYPE_CODE (SYMBOL_TYPE (sym
))
4644 && (!treg
.has_value ()
4645 || treg_matches_sym_type_name (*treg
, sym
)))
4646 || (kind
== FUNCTIONS_DOMAIN
4647 && SYMBOL_CLASS (sym
) == LOC_BLOCK
4648 && (!treg
.has_value ()
4649 || treg_matches_sym_type_name (*treg
,
4651 || (kind
== TYPES_DOMAIN
4652 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4653 && SYMBOL_DOMAIN (sym
) != MODULE_DOMAIN
))))
4656 result
.emplace_back (i
, sym
);
4663 if (!result
.empty ())
4664 sort_search_symbols_remove_dups (&result
);
4666 /* If there are no eyes, avoid all contact. I mean, if there are
4667 no debug symbols, then add matching minsyms. But if the user wants
4668 to see symbols matching a type regexp, then never give a minimal symbol,
4669 as we assume that a minimal symbol does not have a type. */
4671 if ((found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
4673 && !treg
.has_value ())
4675 for (objfile
*objfile
: current_program_space
->objfiles ())
4677 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
4681 if (msymbol
->created_by_gdb
)
4684 if (MSYMBOL_TYPE (msymbol
) == ourtype
4685 || MSYMBOL_TYPE (msymbol
) == ourtype2
4686 || MSYMBOL_TYPE (msymbol
) == ourtype3
4687 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4689 if (!preg
.has_value ()
4690 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4693 /* For functions we can do a quick check of whether the
4694 symbol might be found via find_pc_symtab. */
4695 if (kind
!= FUNCTIONS_DOMAIN
4696 || (find_pc_compunit_symtab
4697 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4700 if (lookup_symbol_in_objfile_from_linkage_name
4701 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4706 result
.emplace_back (i
, msymbol
, objfile
);
4718 /* Helper function for symtab_symbol_info, this function uses
4719 the data returned from search_symbols() to print information
4720 regarding the match to gdb_stdout. If LAST is not NULL,
4721 print file and line number information for the symbol as
4722 well. Skip printing the filename if it matches LAST. */
4725 print_symbol_info (enum search_domain kind
,
4727 int block
, const char *last
)
4729 scoped_switch_to_sym_language_if_auto
l (sym
);
4730 struct symtab
*s
= symbol_symtab (sym
);
4734 const char *s_filename
= symtab_to_filename_for_display (s
);
4736 if (filename_cmp (last
, s_filename
) != 0)
4738 printf_filtered (_("\nFile %ps:\n"),
4739 styled_string (file_name_style
.style (),
4743 if (SYMBOL_LINE (sym
) != 0)
4744 printf_filtered ("%d:\t", SYMBOL_LINE (sym
));
4746 puts_filtered ("\t");
4749 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
4750 printf_filtered ("static ");
4752 /* Typedef that is not a C++ class. */
4753 if (kind
== TYPES_DOMAIN
4754 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
4756 /* FIXME: For C (and C++) we end up with a difference in output here
4757 between how a typedef is printed, and non-typedefs are printed.
4758 The TYPEDEF_PRINT code places a ";" at the end in an attempt to
4759 appear C-like, while TYPE_PRINT doesn't.
4761 For the struct printing case below, things are worse, we force
4762 printing of the ";" in this function, which is going to be wrong
4763 for languages that don't require a ";" between statements. */
4764 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_TYPEDEF
)
4765 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
4768 type_print (SYMBOL_TYPE (sym
), "", gdb_stdout
, -1);
4769 printf_filtered ("\n");
4772 /* variable, func, or typedef-that-is-c++-class. */
4773 else if (kind
< TYPES_DOMAIN
4774 || (kind
== TYPES_DOMAIN
4775 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
4777 type_print (SYMBOL_TYPE (sym
),
4778 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4779 ? "" : SYMBOL_PRINT_NAME (sym
)),
4782 printf_filtered (";\n");
4786 /* This help function for symtab_symbol_info() prints information
4787 for non-debugging symbols to gdb_stdout. */
4790 print_msymbol_info (struct bound_minimal_symbol msymbol
)
4792 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
4795 if (gdbarch_addr_bit (gdbarch
) <= 32)
4796 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
4797 & (CORE_ADDR
) 0xffffffff,
4800 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
4803 ui_file_style sym_style
= (msymbol
.minsym
->text_p ()
4804 ? function_name_style
.style ()
4805 : ui_file_style ());
4807 printf_filtered (_("%ps %ps\n"),
4808 styled_string (address_style
.style (), tmp
),
4809 styled_string (sym_style
,
4810 MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
4813 /* This is the guts of the commands "info functions", "info types", and
4814 "info variables". It calls search_symbols to find all matches and then
4815 print_[m]symbol_info to print out some useful information about the
4819 symtab_symbol_info (bool quiet
, bool exclude_minsyms
,
4820 const char *regexp
, enum search_domain kind
,
4821 const char *t_regexp
, int from_tty
)
4823 static const char * const classnames
[] =
4824 {"variable", "function", "type"};
4825 const char *last_filename
= "";
4828 gdb_assert (kind
<= TYPES_DOMAIN
);
4830 if (regexp
!= nullptr && *regexp
== '\0')
4833 /* Must make sure that if we're interrupted, symbols gets freed. */
4834 std::vector
<symbol_search
> symbols
= search_symbols (regexp
, kind
,
4842 if (t_regexp
!= NULL
)
4844 (_("All %ss matching regular expression \"%s\""
4845 " with type matching regular expression \"%s\":\n"),
4846 classnames
[kind
], regexp
, t_regexp
);
4848 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4849 classnames
[kind
], regexp
);
4853 if (t_regexp
!= NULL
)
4855 (_("All defined %ss"
4856 " with type matching regular expression \"%s\" :\n"),
4857 classnames
[kind
], t_regexp
);
4859 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
4863 for (const symbol_search
&p
: symbols
)
4867 if (p
.msymbol
.minsym
!= NULL
)
4872 printf_filtered (_("\nNon-debugging symbols:\n"));
4875 print_msymbol_info (p
.msymbol
);
4879 print_symbol_info (kind
,
4884 = symtab_to_filename_for_display (symbol_symtab (p
.symbol
));
4889 /* Structure to hold the values of the options used by the 'info variables'
4890 and 'info functions' commands. These correspond to the -q, -t, and -n
4893 struct info_print_options
4896 bool exclude_minsyms
= false;
4897 char *type_regexp
= nullptr;
4899 ~info_print_options ()
4901 xfree (type_regexp
);
4905 /* The options used by the 'info variables' and 'info functions'
4908 static const gdb::option::option_def info_print_options_defs
[] = {
4909 gdb::option::boolean_option_def
<info_print_options
> {
4911 [] (info_print_options
*opt
) { return &opt
->quiet
; },
4912 nullptr, /* show_cmd_cb */
4913 nullptr /* set_doc */
4916 gdb::option::boolean_option_def
<info_print_options
> {
4918 [] (info_print_options
*opt
) { return &opt
->exclude_minsyms
; },
4919 nullptr, /* show_cmd_cb */
4920 nullptr /* set_doc */
4923 gdb::option::string_option_def
<info_print_options
> {
4925 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
4926 nullptr, /* show_cmd_cb */
4927 nullptr /* set_doc */
4931 /* Returns the option group used by 'info variables' and 'info
4934 static gdb::option::option_def_group
4935 make_info_print_options_def_group (info_print_options
*opts
)
4937 return {{info_print_options_defs
}, opts
};
4940 /* Command completer for 'info variables' and 'info functions'. */
4943 info_print_command_completer (struct cmd_list_element
*ignore
,
4944 completion_tracker
&tracker
,
4945 const char *text
, const char * /* word */)
4948 = make_info_print_options_def_group (nullptr);
4949 if (gdb::option::complete_options
4950 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
4953 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
4954 symbol_completer (ignore
, tracker
, text
, word
);
4957 /* Implement the 'info variables' command. */
4960 info_variables_command (const char *args
, int from_tty
)
4962 info_print_options opts
;
4963 auto grp
= make_info_print_options_def_group (&opts
);
4964 gdb::option::process_options
4965 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
4966 if (args
!= nullptr && *args
== '\0')
4969 symtab_symbol_info (opts
.quiet
, opts
.exclude_minsyms
, args
, VARIABLES_DOMAIN
,
4970 opts
.type_regexp
, from_tty
);
4973 /* Implement the 'info functions' command. */
4976 info_functions_command (const char *args
, int from_tty
)
4978 info_print_options opts
;
4979 auto grp
= make_info_print_options_def_group (&opts
);
4980 gdb::option::process_options
4981 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
4982 if (args
!= nullptr && *args
== '\0')
4985 symtab_symbol_info (opts
.quiet
, opts
.exclude_minsyms
, args
,
4986 FUNCTIONS_DOMAIN
, opts
.type_regexp
, from_tty
);
4989 /* Holds the -q option for the 'info types' command. */
4991 struct info_types_options
4996 /* The options used by the 'info types' command. */
4998 static const gdb::option::option_def info_types_options_defs
[] = {
4999 gdb::option::boolean_option_def
<info_types_options
> {
5001 [] (info_types_options
*opt
) { return &opt
->quiet
; },
5002 nullptr, /* show_cmd_cb */
5003 nullptr /* set_doc */
5007 /* Returns the option group used by 'info types'. */
5009 static gdb::option::option_def_group
5010 make_info_types_options_def_group (info_types_options
*opts
)
5012 return {{info_types_options_defs
}, opts
};
5015 /* Implement the 'info types' command. */
5018 info_types_command (const char *args
, int from_tty
)
5020 info_types_options opts
;
5022 auto grp
= make_info_types_options_def_group (&opts
);
5023 gdb::option::process_options
5024 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
5025 if (args
!= nullptr && *args
== '\0')
5027 symtab_symbol_info (opts
.quiet
, false, args
, TYPES_DOMAIN
, NULL
, from_tty
);
5030 /* Command completer for 'info types' command. */
5033 info_types_command_completer (struct cmd_list_element
*ignore
,
5034 completion_tracker
&tracker
,
5035 const char *text
, const char * /* word */)
5038 = make_info_types_options_def_group (nullptr);
5039 if (gdb::option::complete_options
5040 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
5043 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
5044 symbol_completer (ignore
, tracker
, text
, word
);
5047 /* Breakpoint all functions matching regular expression. */
5050 rbreak_command_wrapper (char *regexp
, int from_tty
)
5052 rbreak_command (regexp
, from_tty
);
5056 rbreak_command (const char *regexp
, int from_tty
)
5059 const char **files
= NULL
;
5060 const char *file_name
;
5065 const char *colon
= strchr (regexp
, ':');
5067 if (colon
&& *(colon
+ 1) != ':')
5072 colon_index
= colon
- regexp
;
5073 local_name
= (char *) alloca (colon_index
+ 1);
5074 memcpy (local_name
, regexp
, colon_index
);
5075 local_name
[colon_index
--] = 0;
5076 while (isspace (local_name
[colon_index
]))
5077 local_name
[colon_index
--] = 0;
5078 file_name
= local_name
;
5081 regexp
= skip_spaces (colon
+ 1);
5085 std::vector
<symbol_search
> symbols
= search_symbols (regexp
,
5091 scoped_rbreak_breakpoints finalize
;
5092 for (const symbol_search
&p
: symbols
)
5094 if (p
.msymbol
.minsym
== NULL
)
5096 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
5097 const char *fullname
= symtab_to_fullname (symtab
);
5099 string
= string_printf ("%s:'%s'", fullname
,
5100 SYMBOL_LINKAGE_NAME (p
.symbol
));
5101 break_command (&string
[0], from_tty
);
5102 print_symbol_info (FUNCTIONS_DOMAIN
, p
.symbol
, p
.block
, NULL
);
5106 string
= string_printf ("'%s'",
5107 MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
));
5109 break_command (&string
[0], from_tty
);
5110 printf_filtered ("<function, no debug info> %s;\n",
5111 MSYMBOL_PRINT_NAME (p
.msymbol
.minsym
));
5117 /* Evaluate if SYMNAME matches LOOKUP_NAME. */
5120 compare_symbol_name (const char *symbol_name
, language symbol_language
,
5121 const lookup_name_info
&lookup_name
,
5122 completion_match_result
&match_res
)
5124 const language_defn
*lang
= language_def (symbol_language
);
5126 symbol_name_matcher_ftype
*name_match
5127 = get_symbol_name_matcher (lang
, lookup_name
);
5129 return name_match (symbol_name
, lookup_name
, &match_res
);
5135 completion_list_add_name (completion_tracker
&tracker
,
5136 language symbol_language
,
5137 const char *symname
,
5138 const lookup_name_info
&lookup_name
,
5139 const char *text
, const char *word
)
5141 completion_match_result
&match_res
5142 = tracker
.reset_completion_match_result ();
5144 /* Clip symbols that cannot match. */
5145 if (!compare_symbol_name (symname
, symbol_language
, lookup_name
, match_res
))
5148 /* Refresh SYMNAME from the match string. It's potentially
5149 different depending on language. (E.g., on Ada, the match may be
5150 the encoded symbol name wrapped in "<>"). */
5151 symname
= match_res
.match
.match ();
5152 gdb_assert (symname
!= NULL
);
5154 /* We have a match for a completion, so add SYMNAME to the current list
5155 of matches. Note that the name is moved to freshly malloc'd space. */
5158 gdb::unique_xmalloc_ptr
<char> completion
5159 = make_completion_match_str (symname
, text
, word
);
5161 /* Here we pass the match-for-lcd object to add_completion. Some
5162 languages match the user text against substrings of symbol
5163 names in some cases. E.g., in C++, "b push_ba" completes to
5164 "std::vector::push_back", "std::string::push_back", etc., and
5165 in this case we want the completion lowest common denominator
5166 to be "push_back" instead of "std::". */
5167 tracker
.add_completion (std::move (completion
),
5168 &match_res
.match_for_lcd
, text
, word
);
5172 /* completion_list_add_name wrapper for struct symbol. */
5175 completion_list_add_symbol (completion_tracker
&tracker
,
5177 const lookup_name_info
&lookup_name
,
5178 const char *text
, const char *word
)
5180 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5181 SYMBOL_NATURAL_NAME (sym
),
5182 lookup_name
, text
, word
);
5185 /* completion_list_add_name wrapper for struct minimal_symbol. */
5188 completion_list_add_msymbol (completion_tracker
&tracker
,
5189 minimal_symbol
*sym
,
5190 const lookup_name_info
&lookup_name
,
5191 const char *text
, const char *word
)
5193 completion_list_add_name (tracker
, MSYMBOL_LANGUAGE (sym
),
5194 MSYMBOL_NATURAL_NAME (sym
),
5195 lookup_name
, text
, word
);
5199 /* ObjC: In case we are completing on a selector, look as the msymbol
5200 again and feed all the selectors into the mill. */
5203 completion_list_objc_symbol (completion_tracker
&tracker
,
5204 struct minimal_symbol
*msymbol
,
5205 const lookup_name_info
&lookup_name
,
5206 const char *text
, const char *word
)
5208 static char *tmp
= NULL
;
5209 static unsigned int tmplen
= 0;
5211 const char *method
, *category
, *selector
;
5214 method
= MSYMBOL_NATURAL_NAME (msymbol
);
5216 /* Is it a method? */
5217 if ((method
[0] != '-') && (method
[0] != '+'))
5221 /* Complete on shortened method method. */
5222 completion_list_add_name (tracker
, language_objc
,
5227 while ((strlen (method
) + 1) >= tmplen
)
5233 tmp
= (char *) xrealloc (tmp
, tmplen
);
5235 selector
= strchr (method
, ' ');
5236 if (selector
!= NULL
)
5239 category
= strchr (method
, '(');
5241 if ((category
!= NULL
) && (selector
!= NULL
))
5243 memcpy (tmp
, method
, (category
- method
));
5244 tmp
[category
- method
] = ' ';
5245 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
5246 completion_list_add_name (tracker
, language_objc
, tmp
,
5247 lookup_name
, text
, word
);
5249 completion_list_add_name (tracker
, language_objc
, tmp
+ 1,
5250 lookup_name
, text
, word
);
5253 if (selector
!= NULL
)
5255 /* Complete on selector only. */
5256 strcpy (tmp
, selector
);
5257 tmp2
= strchr (tmp
, ']');
5261 completion_list_add_name (tracker
, language_objc
, tmp
,
5262 lookup_name
, text
, word
);
5266 /* Break the non-quoted text based on the characters which are in
5267 symbols. FIXME: This should probably be language-specific. */
5270 language_search_unquoted_string (const char *text
, const char *p
)
5272 for (; p
> text
; --p
)
5274 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
5278 if ((current_language
->la_language
== language_objc
))
5280 if (p
[-1] == ':') /* Might be part of a method name. */
5282 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
5283 p
-= 2; /* Beginning of a method name. */
5284 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
5285 { /* Might be part of a method name. */
5288 /* Seeing a ' ' or a '(' is not conclusive evidence
5289 that we are in the middle of a method name. However,
5290 finding "-[" or "+[" should be pretty un-ambiguous.
5291 Unfortunately we have to find it now to decide. */
5294 if (isalnum (t
[-1]) || t
[-1] == '_' ||
5295 t
[-1] == ' ' || t
[-1] == ':' ||
5296 t
[-1] == '(' || t
[-1] == ')')
5301 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
5302 p
= t
- 2; /* Method name detected. */
5303 /* Else we leave with p unchanged. */
5313 completion_list_add_fields (completion_tracker
&tracker
,
5315 const lookup_name_info
&lookup_name
,
5316 const char *text
, const char *word
)
5318 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
5320 struct type
*t
= SYMBOL_TYPE (sym
);
5321 enum type_code c
= TYPE_CODE (t
);
5324 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
5325 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
5326 if (TYPE_FIELD_NAME (t
, j
))
5327 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5328 TYPE_FIELD_NAME (t
, j
),
5329 lookup_name
, text
, word
);
5336 symbol_is_function_or_method (symbol
*sym
)
5338 switch (TYPE_CODE (SYMBOL_TYPE (sym
)))
5340 case TYPE_CODE_FUNC
:
5341 case TYPE_CODE_METHOD
:
5351 symbol_is_function_or_method (minimal_symbol
*msymbol
)
5353 switch (MSYMBOL_TYPE (msymbol
))
5356 case mst_text_gnu_ifunc
:
5357 case mst_solib_trampoline
:
5367 bound_minimal_symbol
5368 find_gnu_ifunc (const symbol
*sym
)
5370 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
5373 lookup_name_info
lookup_name (SYMBOL_SEARCH_NAME (sym
),
5374 symbol_name_match_type::SEARCH_NAME
);
5375 struct objfile
*objfile
= symbol_objfile (sym
);
5377 CORE_ADDR address
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
5378 minimal_symbol
*ifunc
= NULL
;
5380 iterate_over_minimal_symbols (objfile
, lookup_name
,
5381 [&] (minimal_symbol
*minsym
)
5383 if (MSYMBOL_TYPE (minsym
) == mst_text_gnu_ifunc
5384 || MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5386 CORE_ADDR msym_addr
= MSYMBOL_VALUE_ADDRESS (objfile
, minsym
);
5387 if (MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5389 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5391 = gdbarch_convert_from_func_ptr_addr (gdbarch
,
5393 current_top_target ());
5395 if (msym_addr
== address
)
5405 return {ifunc
, objfile
};
5409 /* Add matching symbols from SYMTAB to the current completion list. */
5412 add_symtab_completions (struct compunit_symtab
*cust
,
5413 completion_tracker
&tracker
,
5414 complete_symbol_mode mode
,
5415 const lookup_name_info
&lookup_name
,
5416 const char *text
, const char *word
,
5417 enum type_code code
)
5420 const struct block
*b
;
5421 struct block_iterator iter
;
5427 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
5430 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), i
);
5431 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5433 if (completion_skip_symbol (mode
, sym
))
5436 if (code
== TYPE_CODE_UNDEF
5437 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5438 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
5439 completion_list_add_symbol (tracker
, sym
,
5447 default_collect_symbol_completion_matches_break_on
5448 (completion_tracker
&tracker
, complete_symbol_mode mode
,
5449 symbol_name_match_type name_match_type
,
5450 const char *text
, const char *word
,
5451 const char *break_on
, enum type_code code
)
5453 /* Problem: All of the symbols have to be copied because readline
5454 frees them. I'm not going to worry about this; hopefully there
5455 won't be that many. */
5458 const struct block
*b
;
5459 const struct block
*surrounding_static_block
, *surrounding_global_block
;
5460 struct block_iterator iter
;
5461 /* The symbol we are completing on. Points in same buffer as text. */
5462 const char *sym_text
;
5464 /* Now look for the symbol we are supposed to complete on. */
5465 if (mode
== complete_symbol_mode::LINESPEC
)
5471 const char *quote_pos
= NULL
;
5473 /* First see if this is a quoted string. */
5475 for (p
= text
; *p
!= '\0'; ++p
)
5477 if (quote_found
!= '\0')
5479 if (*p
== quote_found
)
5480 /* Found close quote. */
5482 else if (*p
== '\\' && p
[1] == quote_found
)
5483 /* A backslash followed by the quote character
5484 doesn't end the string. */
5487 else if (*p
== '\'' || *p
== '"')
5493 if (quote_found
== '\'')
5494 /* A string within single quotes can be a symbol, so complete on it. */
5495 sym_text
= quote_pos
+ 1;
5496 else if (quote_found
== '"')
5497 /* A double-quoted string is never a symbol, nor does it make sense
5498 to complete it any other way. */
5504 /* It is not a quoted string. Break it based on the characters
5505 which are in symbols. */
5508 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
5509 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
5518 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5520 /* At this point scan through the misc symbol vectors and add each
5521 symbol you find to the list. Eventually we want to ignore
5522 anything that isn't a text symbol (everything else will be
5523 handled by the psymtab code below). */
5525 if (code
== TYPE_CODE_UNDEF
)
5527 for (objfile
*objfile
: current_program_space
->objfiles ())
5529 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
5533 if (completion_skip_symbol (mode
, msymbol
))
5536 completion_list_add_msymbol (tracker
, msymbol
, lookup_name
,
5539 completion_list_objc_symbol (tracker
, msymbol
, lookup_name
,
5545 /* Add completions for all currently loaded symbol tables. */
5546 for (objfile
*objfile
: current_program_space
->objfiles ())
5548 for (compunit_symtab
*cust
: objfile
->compunits ())
5549 add_symtab_completions (cust
, tracker
, mode
, lookup_name
,
5550 sym_text
, word
, code
);
5553 /* Look through the partial symtabs for all symbols which begin by
5554 matching SYM_TEXT. Expand all CUs that you find to the list. */
5555 expand_symtabs_matching (NULL
,
5558 [&] (compunit_symtab
*symtab
) /* expansion notify */
5560 add_symtab_completions (symtab
,
5561 tracker
, mode
, lookup_name
,
5562 sym_text
, word
, code
);
5566 /* Search upwards from currently selected frame (so that we can
5567 complete on local vars). Also catch fields of types defined in
5568 this places which match our text string. Only complete on types
5569 visible from current context. */
5571 b
= get_selected_block (0);
5572 surrounding_static_block
= block_static_block (b
);
5573 surrounding_global_block
= block_global_block (b
);
5574 if (surrounding_static_block
!= NULL
)
5575 while (b
!= surrounding_static_block
)
5579 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5581 if (code
== TYPE_CODE_UNDEF
)
5583 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5585 completion_list_add_fields (tracker
, sym
, lookup_name
,
5588 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5589 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
5590 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5594 /* Stop when we encounter an enclosing function. Do not stop for
5595 non-inlined functions - the locals of the enclosing function
5596 are in scope for a nested function. */
5597 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
5599 b
= BLOCK_SUPERBLOCK (b
);
5602 /* Add fields from the file's types; symbols will be added below. */
5604 if (code
== TYPE_CODE_UNDEF
)
5606 if (surrounding_static_block
!= NULL
)
5607 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
5608 completion_list_add_fields (tracker
, sym
, lookup_name
,
5611 if (surrounding_global_block
!= NULL
)
5612 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
5613 completion_list_add_fields (tracker
, sym
, lookup_name
,
5617 /* Skip macros if we are completing a struct tag -- arguable but
5618 usually what is expected. */
5619 if (current_language
->la_macro_expansion
== macro_expansion_c
5620 && code
== TYPE_CODE_UNDEF
)
5622 gdb::unique_xmalloc_ptr
<struct macro_scope
> scope
;
5624 /* This adds a macro's name to the current completion list. */
5625 auto add_macro_name
= [&] (const char *macro_name
,
5626 const macro_definition
*,
5627 macro_source_file
*,
5630 completion_list_add_name (tracker
, language_c
, macro_name
,
5631 lookup_name
, sym_text
, word
);
5634 /* Add any macros visible in the default scope. Note that this
5635 may yield the occasional wrong result, because an expression
5636 might be evaluated in a scope other than the default. For
5637 example, if the user types "break file:line if <TAB>", the
5638 resulting expression will be evaluated at "file:line" -- but
5639 at there does not seem to be a way to detect this at
5641 scope
= default_macro_scope ();
5643 macro_for_each_in_scope (scope
->file
, scope
->line
,
5646 /* User-defined macros are always visible. */
5647 macro_for_each (macro_user_macros
, add_macro_name
);
5652 default_collect_symbol_completion_matches (completion_tracker
&tracker
,
5653 complete_symbol_mode mode
,
5654 symbol_name_match_type name_match_type
,
5655 const char *text
, const char *word
,
5656 enum type_code code
)
5658 return default_collect_symbol_completion_matches_break_on (tracker
, mode
,
5664 /* Collect all symbols (regardless of class) which begin by matching
5668 collect_symbol_completion_matches (completion_tracker
&tracker
,
5669 complete_symbol_mode mode
,
5670 symbol_name_match_type name_match_type
,
5671 const char *text
, const char *word
)
5673 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5679 /* Like collect_symbol_completion_matches, but only collect
5680 STRUCT_DOMAIN symbols whose type code is CODE. */
5683 collect_symbol_completion_matches_type (completion_tracker
&tracker
,
5684 const char *text
, const char *word
,
5685 enum type_code code
)
5687 complete_symbol_mode mode
= complete_symbol_mode::EXPRESSION
;
5688 symbol_name_match_type name_match_type
= symbol_name_match_type::EXPRESSION
;
5690 gdb_assert (code
== TYPE_CODE_UNION
5691 || code
== TYPE_CODE_STRUCT
5692 || code
== TYPE_CODE_ENUM
);
5693 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5698 /* Like collect_symbol_completion_matches, but collects a list of
5699 symbols defined in all source files named SRCFILE. */
5702 collect_file_symbol_completion_matches (completion_tracker
&tracker
,
5703 complete_symbol_mode mode
,
5704 symbol_name_match_type name_match_type
,
5705 const char *text
, const char *word
,
5706 const char *srcfile
)
5708 /* The symbol we are completing on. Points in same buffer as text. */
5709 const char *sym_text
;
5711 /* Now look for the symbol we are supposed to complete on.
5712 FIXME: This should be language-specific. */
5713 if (mode
== complete_symbol_mode::LINESPEC
)
5719 const char *quote_pos
= NULL
;
5721 /* First see if this is a quoted string. */
5723 for (p
= text
; *p
!= '\0'; ++p
)
5725 if (quote_found
!= '\0')
5727 if (*p
== quote_found
)
5728 /* Found close quote. */
5730 else if (*p
== '\\' && p
[1] == quote_found
)
5731 /* A backslash followed by the quote character
5732 doesn't end the string. */
5735 else if (*p
== '\'' || *p
== '"')
5741 if (quote_found
== '\'')
5742 /* A string within single quotes can be a symbol, so complete on it. */
5743 sym_text
= quote_pos
+ 1;
5744 else if (quote_found
== '"')
5745 /* A double-quoted string is never a symbol, nor does it make sense
5746 to complete it any other way. */
5752 /* Not a quoted string. */
5753 sym_text
= language_search_unquoted_string (text
, p
);
5757 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5759 /* Go through symtabs for SRCFILE and check the externs and statics
5760 for symbols which match. */
5761 iterate_over_symtabs (srcfile
, [&] (symtab
*s
)
5763 add_symtab_completions (SYMTAB_COMPUNIT (s
),
5764 tracker
, mode
, lookup_name
,
5765 sym_text
, word
, TYPE_CODE_UNDEF
);
5770 /* A helper function for make_source_files_completion_list. It adds
5771 another file name to a list of possible completions, growing the
5772 list as necessary. */
5775 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
5776 completion_list
*list
)
5778 list
->emplace_back (make_completion_match_str (fname
, text
, word
));
5782 not_interesting_fname (const char *fname
)
5784 static const char *illegal_aliens
[] = {
5785 "_globals_", /* inserted by coff_symtab_read */
5790 for (i
= 0; illegal_aliens
[i
]; i
++)
5792 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
5798 /* An object of this type is passed as the user_data argument to
5799 map_partial_symbol_filenames. */
5800 struct add_partial_filename_data
5802 struct filename_seen_cache
*filename_seen_cache
;
5806 completion_list
*list
;
5809 /* A callback for map_partial_symbol_filenames. */
5812 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
5815 struct add_partial_filename_data
*data
5816 = (struct add_partial_filename_data
*) user_data
;
5818 if (not_interesting_fname (filename
))
5820 if (!data
->filename_seen_cache
->seen (filename
)
5821 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
5823 /* This file matches for a completion; add it to the
5824 current list of matches. */
5825 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
5829 const char *base_name
= lbasename (filename
);
5831 if (base_name
!= filename
5832 && !data
->filename_seen_cache
->seen (base_name
)
5833 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
5834 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
5838 /* Return a list of all source files whose names begin with matching
5839 TEXT. The file names are looked up in the symbol tables of this
5843 make_source_files_completion_list (const char *text
, const char *word
)
5845 size_t text_len
= strlen (text
);
5846 completion_list list
;
5847 const char *base_name
;
5848 struct add_partial_filename_data datum
;
5850 if (!have_full_symbols () && !have_partial_symbols ())
5853 filename_seen_cache filenames_seen
;
5855 for (objfile
*objfile
: current_program_space
->objfiles ())
5857 for (compunit_symtab
*cu
: objfile
->compunits ())
5859 for (symtab
*s
: compunit_filetabs (cu
))
5861 if (not_interesting_fname (s
->filename
))
5863 if (!filenames_seen
.seen (s
->filename
)
5864 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
5866 /* This file matches for a completion; add it to the current
5868 add_filename_to_list (s
->filename
, text
, word
, &list
);
5872 /* NOTE: We allow the user to type a base name when the
5873 debug info records leading directories, but not the other
5874 way around. This is what subroutines of breakpoint
5875 command do when they parse file names. */
5876 base_name
= lbasename (s
->filename
);
5877 if (base_name
!= s
->filename
5878 && !filenames_seen
.seen (base_name
)
5879 && filename_ncmp (base_name
, text
, text_len
) == 0)
5880 add_filename_to_list (base_name
, text
, word
, &list
);
5886 datum
.filename_seen_cache
= &filenames_seen
;
5889 datum
.text_len
= text_len
;
5891 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
5892 0 /*need_fullname*/);
5899 /* Return the "main_info" object for the current program space. If
5900 the object has not yet been created, create it and fill in some
5903 static struct main_info
*
5904 get_main_info (void)
5906 struct main_info
*info
= main_progspace_key
.get (current_program_space
);
5910 /* It may seem strange to store the main name in the progspace
5911 and also in whatever objfile happens to see a main name in
5912 its debug info. The reason for this is mainly historical:
5913 gdb returned "main" as the name even if no function named
5914 "main" was defined the program; and this approach lets us
5915 keep compatibility. */
5916 info
= main_progspace_key
.emplace (current_program_space
);
5923 set_main_name (const char *name
, enum language lang
)
5925 struct main_info
*info
= get_main_info ();
5927 if (info
->name_of_main
!= NULL
)
5929 xfree (info
->name_of_main
);
5930 info
->name_of_main
= NULL
;
5931 info
->language_of_main
= language_unknown
;
5935 info
->name_of_main
= xstrdup (name
);
5936 info
->language_of_main
= lang
;
5940 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5944 find_main_name (void)
5946 const char *new_main_name
;
5948 /* First check the objfiles to see whether a debuginfo reader has
5949 picked up the appropriate main name. Historically the main name
5950 was found in a more or less random way; this approach instead
5951 relies on the order of objfile creation -- which still isn't
5952 guaranteed to get the correct answer, but is just probably more
5954 for (objfile
*objfile
: current_program_space
->objfiles ())
5956 if (objfile
->per_bfd
->name_of_main
!= NULL
)
5958 set_main_name (objfile
->per_bfd
->name_of_main
,
5959 objfile
->per_bfd
->language_of_main
);
5964 /* Try to see if the main procedure is in Ada. */
5965 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5966 be to add a new method in the language vector, and call this
5967 method for each language until one of them returns a non-empty
5968 name. This would allow us to remove this hard-coded call to
5969 an Ada function. It is not clear that this is a better approach
5970 at this point, because all methods need to be written in a way
5971 such that false positives never be returned. For instance, it is
5972 important that a method does not return a wrong name for the main
5973 procedure if the main procedure is actually written in a different
5974 language. It is easy to guaranty this with Ada, since we use a
5975 special symbol generated only when the main in Ada to find the name
5976 of the main procedure. It is difficult however to see how this can
5977 be guarantied for languages such as C, for instance. This suggests
5978 that order of call for these methods becomes important, which means
5979 a more complicated approach. */
5980 new_main_name
= ada_main_name ();
5981 if (new_main_name
!= NULL
)
5983 set_main_name (new_main_name
, language_ada
);
5987 new_main_name
= d_main_name ();
5988 if (new_main_name
!= NULL
)
5990 set_main_name (new_main_name
, language_d
);
5994 new_main_name
= go_main_name ();
5995 if (new_main_name
!= NULL
)
5997 set_main_name (new_main_name
, language_go
);
6001 new_main_name
= pascal_main_name ();
6002 if (new_main_name
!= NULL
)
6004 set_main_name (new_main_name
, language_pascal
);
6008 /* The languages above didn't identify the name of the main procedure.
6009 Fallback to "main". */
6010 set_main_name ("main", language_unknown
);
6018 struct main_info
*info
= get_main_info ();
6020 if (info
->name_of_main
== NULL
)
6023 return info
->name_of_main
;
6026 /* Return the language of the main function. If it is not known,
6027 return language_unknown. */
6030 main_language (void)
6032 struct main_info
*info
= get_main_info ();
6034 if (info
->name_of_main
== NULL
)
6037 return info
->language_of_main
;
6040 /* Handle ``executable_changed'' events for the symtab module. */
6043 symtab_observer_executable_changed (void)
6045 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
6046 set_main_name (NULL
, language_unknown
);
6049 /* Return 1 if the supplied producer string matches the ARM RealView
6050 compiler (armcc). */
6053 producer_is_realview (const char *producer
)
6055 static const char *const arm_idents
[] = {
6056 "ARM C Compiler, ADS",
6057 "Thumb C Compiler, ADS",
6058 "ARM C++ Compiler, ADS",
6059 "Thumb C++ Compiler, ADS",
6060 "ARM/Thumb C/C++ Compiler, RVCT",
6061 "ARM C/C++ Compiler, RVCT"
6065 if (producer
== NULL
)
6068 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
6069 if (startswith (producer
, arm_idents
[i
]))
6077 /* The next index to hand out in response to a registration request. */
6079 static int next_aclass_value
= LOC_FINAL_VALUE
;
6081 /* The maximum number of "aclass" registrations we support. This is
6082 constant for convenience. */
6083 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
6085 /* The objects representing the various "aclass" values. The elements
6086 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
6087 elements are those registered at gdb initialization time. */
6089 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
6091 /* The globally visible pointer. This is separate from 'symbol_impl'
6092 so that it can be const. */
6094 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
6096 /* Make sure we saved enough room in struct symbol. */
6098 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
6100 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
6101 is the ops vector associated with this index. This returns the new
6102 index, which should be used as the aclass_index field for symbols
6106 register_symbol_computed_impl (enum address_class aclass
,
6107 const struct symbol_computed_ops
*ops
)
6109 int result
= next_aclass_value
++;
6111 gdb_assert (aclass
== LOC_COMPUTED
);
6112 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6113 symbol_impl
[result
].aclass
= aclass
;
6114 symbol_impl
[result
].ops_computed
= ops
;
6116 /* Sanity check OPS. */
6117 gdb_assert (ops
!= NULL
);
6118 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
6119 gdb_assert (ops
->describe_location
!= NULL
);
6120 gdb_assert (ops
->get_symbol_read_needs
!= NULL
);
6121 gdb_assert (ops
->read_variable
!= NULL
);
6126 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
6127 OPS is the ops vector associated with this index. This returns the
6128 new index, which should be used as the aclass_index field for symbols
6132 register_symbol_block_impl (enum address_class aclass
,
6133 const struct symbol_block_ops
*ops
)
6135 int result
= next_aclass_value
++;
6137 gdb_assert (aclass
== LOC_BLOCK
);
6138 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6139 symbol_impl
[result
].aclass
= aclass
;
6140 symbol_impl
[result
].ops_block
= ops
;
6142 /* Sanity check OPS. */
6143 gdb_assert (ops
!= NULL
);
6144 gdb_assert (ops
->find_frame_base_location
!= NULL
);
6149 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
6150 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
6151 this index. This returns the new index, which should be used as
6152 the aclass_index field for symbols of this type. */
6155 register_symbol_register_impl (enum address_class aclass
,
6156 const struct symbol_register_ops
*ops
)
6158 int result
= next_aclass_value
++;
6160 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
6161 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6162 symbol_impl
[result
].aclass
= aclass
;
6163 symbol_impl
[result
].ops_register
= ops
;
6168 /* Initialize elements of 'symbol_impl' for the constants in enum
6172 initialize_ordinary_address_classes (void)
6176 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
6177 symbol_impl
[i
].aclass
= (enum address_class
) i
;
6182 /* Helper function to initialize the fields of an objfile-owned symbol.
6183 It assumed that *SYM is already all zeroes. */
6186 initialize_objfile_symbol_1 (struct symbol
*sym
)
6188 SYMBOL_OBJFILE_OWNED (sym
) = 1;
6189 SYMBOL_SECTION (sym
) = -1;
6192 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
6195 initialize_objfile_symbol (struct symbol
*sym
)
6197 memset (sym
, 0, sizeof (*sym
));
6198 initialize_objfile_symbol_1 (sym
);
6201 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
6205 allocate_symbol (struct objfile
*objfile
)
6207 struct symbol
*result
;
6209 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
6210 initialize_objfile_symbol_1 (result
);
6215 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
6218 struct template_symbol
*
6219 allocate_template_symbol (struct objfile
*objfile
)
6221 struct template_symbol
*result
;
6223 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
6224 initialize_objfile_symbol_1 (result
);
6232 symbol_objfile (const struct symbol
*symbol
)
6234 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6235 return SYMTAB_OBJFILE (symbol
->owner
.symtab
);
6241 symbol_arch (const struct symbol
*symbol
)
6243 if (!SYMBOL_OBJFILE_OWNED (symbol
))
6244 return symbol
->owner
.arch
;
6245 return get_objfile_arch (SYMTAB_OBJFILE (symbol
->owner
.symtab
));
6251 symbol_symtab (const struct symbol
*symbol
)
6253 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6254 return symbol
->owner
.symtab
;
6260 symbol_set_symtab (struct symbol
*symbol
, struct symtab
*symtab
)
6262 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6263 symbol
->owner
.symtab
= symtab
;
6269 get_symbol_address (const struct symbol
*sym
)
6271 gdb_assert (sym
->maybe_copied
);
6272 gdb_assert (SYMBOL_CLASS (sym
) == LOC_STATIC
);
6274 const char *linkage_name
= SYMBOL_LINKAGE_NAME (sym
);
6276 for (objfile
*objfile
: current_program_space
->objfiles ())
6278 bound_minimal_symbol minsym
6279 = lookup_minimal_symbol_linkage (linkage_name
, objfile
);
6280 if (minsym
.minsym
!= nullptr)
6281 return BMSYMBOL_VALUE_ADDRESS (minsym
);
6283 return sym
->ginfo
.value
.address
;
6289 get_msymbol_address (struct objfile
*objf
, const struct minimal_symbol
*minsym
)
6291 gdb_assert (minsym
->maybe_copied
);
6292 gdb_assert ((objf
->flags
& OBJF_MAINLINE
) == 0);
6294 const char *linkage_name
= MSYMBOL_LINKAGE_NAME (minsym
);
6296 for (objfile
*objfile
: current_program_space
->objfiles ())
6298 if ((objfile
->flags
& OBJF_MAINLINE
) != 0)
6300 bound_minimal_symbol found
6301 = lookup_minimal_symbol_linkage (linkage_name
, objfile
);
6302 if (found
.minsym
!= nullptr)
6303 return BMSYMBOL_VALUE_ADDRESS (found
);
6306 return (minsym
->value
.address
6307 + ANOFFSET (objf
->section_offsets
, minsym
->section
));
6313 _initialize_symtab (void)
6315 cmd_list_element
*c
;
6317 initialize_ordinary_address_classes ();
6319 c
= add_info ("variables", info_variables_command
,
6320 info_print_args_help (_("\
6321 All global and static variable names or those matching REGEXPs.\n\
6322 Usage: info variables [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6323 Prints the global and static variables.\n"),
6324 _("global and static variables"),
6326 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6329 c
= add_com ("whereis", class_info
, info_variables_command
,
6330 info_print_args_help (_("\
6331 All global and static variable names, or those matching REGEXPs.\n\
6332 Usage: whereis [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6333 Prints the global and static variables.\n"),
6334 _("global and static variables"),
6336 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6339 c
= add_info ("functions", info_functions_command
,
6340 info_print_args_help (_("\
6341 All function names or those matching REGEXPs.\n\
6342 Usage: info functions [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6343 Prints the functions.\n"),
6346 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6348 c
= add_info ("types", info_types_command
, _("\
6349 All type names, or those matching REGEXP.\n\
6350 Usage: info types [-q] [REGEXP]\n\
6351 Print information about all types matching REGEXP, or all types if no\n\
6352 REGEXP is given. The optional flag -q disables printing of headers."));
6353 set_cmd_completer_handle_brkchars (c
, info_types_command_completer
);
6355 const auto info_sources_opts
= make_info_sources_options_def_group (nullptr);
6357 static std::string info_sources_help
6358 = gdb::option::build_help (_("\
6359 All source files in the program or those matching REGEXP.\n\
6360 Usage: info sources [OPTION]... [REGEXP]\n\
6361 By default, REGEXP is used to match anywhere in the filename.\n\
6367 c
= add_info ("sources", info_sources_command
, info_sources_help
.c_str ());
6368 set_cmd_completer_handle_brkchars (c
, info_sources_command_completer
);
6370 add_com ("rbreak", class_breakpoint
, rbreak_command
,
6371 _("Set a breakpoint for all functions matching REGEXP."));
6373 add_setshow_enum_cmd ("multiple-symbols", no_class
,
6374 multiple_symbols_modes
, &multiple_symbols_mode
,
6376 Set how the debugger handles ambiguities in expressions."), _("\
6377 Show how the debugger handles ambiguities in expressions."), _("\
6378 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
6379 NULL
, NULL
, &setlist
, &showlist
);
6381 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
6382 &basenames_may_differ
, _("\
6383 Set whether a source file may have multiple base names."), _("\
6384 Show whether a source file may have multiple base names."), _("\
6385 (A \"base name\" is the name of a file with the directory part removed.\n\
6386 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
6387 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
6388 before comparing them. Canonicalization is an expensive operation,\n\
6389 but it allows the same file be known by more than one base name.\n\
6390 If not set (the default), all source files are assumed to have just\n\
6391 one base name, and gdb will do file name comparisons more efficiently."),
6393 &setlist
, &showlist
);
6395 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
6396 _("Set debugging of symbol table creation."),
6397 _("Show debugging of symbol table creation."), _("\
6398 When enabled (non-zero), debugging messages are printed when building\n\
6399 symbol tables. A value of 1 (one) normally provides enough information.\n\
6400 A value greater than 1 provides more verbose information."),
6403 &setdebuglist
, &showdebuglist
);
6405 add_setshow_zuinteger_cmd ("symbol-lookup", no_class
, &symbol_lookup_debug
,
6407 Set debugging of symbol lookup."), _("\
6408 Show debugging of symbol lookup."), _("\
6409 When enabled (non-zero), symbol lookups are logged."),
6411 &setdebuglist
, &showdebuglist
);
6413 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class
,
6414 &new_symbol_cache_size
,
6415 _("Set the size of the symbol cache."),
6416 _("Show the size of the symbol cache."), _("\
6417 The size of the symbol cache.\n\
6418 If zero then the symbol cache is disabled."),
6419 set_symbol_cache_size_handler
, NULL
,
6420 &maintenance_set_cmdlist
,
6421 &maintenance_show_cmdlist
);
6423 add_cmd ("symbol-cache", class_maintenance
, maintenance_print_symbol_cache
,
6424 _("Dump the symbol cache for each program space."),
6425 &maintenanceprintlist
);
6427 add_cmd ("symbol-cache-statistics", class_maintenance
,
6428 maintenance_print_symbol_cache_statistics
,
6429 _("Print symbol cache statistics for each program space."),
6430 &maintenanceprintlist
);
6432 add_cmd ("flush-symbol-cache", class_maintenance
,
6433 maintenance_flush_symbol_cache
,
6434 _("Flush the symbol cache for each program space."),
6437 gdb::observers::executable_changed
.attach (symtab_observer_executable_changed
);
6438 gdb::observers::new_objfile
.attach (symtab_new_objfile_observer
);
6439 gdb::observers::free_objfile
.attach (symtab_free_objfile_observer
);