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 gdb::unique_xmalloc_ptr
<char> fullname_real_path
484 = gdb_realpath (fullname
);
485 fullname
= fullname_real_path
.get ();
486 if (FILENAME_CMP (real_path
, fullname
) == 0)
499 /* Check for a symtab of a specific name; first in symtabs, then in
500 psymtabs. *If* there is no '/' in the name, a match after a '/'
501 in the symtab filename will also work.
503 Calls CALLBACK with each symtab that is found. If CALLBACK returns
504 true, the search stops. */
507 iterate_over_symtabs (const char *name
,
508 gdb::function_view
<bool (symtab
*)> callback
)
510 gdb::unique_xmalloc_ptr
<char> real_path
;
512 /* Here we are interested in canonicalizing an absolute path, not
513 absolutizing a relative path. */
514 if (IS_ABSOLUTE_PATH (name
))
516 real_path
= gdb_realpath (name
);
517 gdb_assert (IS_ABSOLUTE_PATH (real_path
.get ()));
520 for (objfile
*objfile
: current_program_space
->objfiles ())
522 if (iterate_over_some_symtabs (name
, real_path
.get (),
523 objfile
->compunit_symtabs
, NULL
,
528 /* Same search rules as above apply here, but now we look thru the
531 for (objfile
*objfile
: current_program_space
->objfiles ())
534 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
542 /* A wrapper for iterate_over_symtabs that returns the first matching
546 lookup_symtab (const char *name
)
548 struct symtab
*result
= NULL
;
550 iterate_over_symtabs (name
, [&] (symtab
*symtab
)
560 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
561 full method name, which consist of the class name (from T), the unadorned
562 method name from METHOD_ID, and the signature for the specific overload,
563 specified by SIGNATURE_ID. Note that this function is g++ specific. */
566 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
568 int mangled_name_len
;
570 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
571 struct fn_field
*method
= &f
[signature_id
];
572 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
573 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
574 const char *newname
= TYPE_NAME (type
);
576 /* Does the form of physname indicate that it is the full mangled name
577 of a constructor (not just the args)? */
578 int is_full_physname_constructor
;
581 int is_destructor
= is_destructor_name (physname
);
582 /* Need a new type prefix. */
583 const char *const_prefix
= method
->is_const
? "C" : "";
584 const char *volatile_prefix
= method
->is_volatile
? "V" : "";
586 int len
= (newname
== NULL
? 0 : strlen (newname
));
588 /* Nothing to do if physname already contains a fully mangled v3 abi name
589 or an operator name. */
590 if ((physname
[0] == '_' && physname
[1] == 'Z')
591 || is_operator_name (field_name
))
592 return xstrdup (physname
);
594 is_full_physname_constructor
= is_constructor_name (physname
);
596 is_constructor
= is_full_physname_constructor
597 || (newname
&& strcmp (field_name
, newname
) == 0);
600 is_destructor
= (startswith (physname
, "__dt"));
602 if (is_destructor
|| is_full_physname_constructor
)
604 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
605 strcpy (mangled_name
, physname
);
611 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
613 else if (physname
[0] == 't' || physname
[0] == 'Q')
615 /* The physname for template and qualified methods already includes
617 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
623 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
624 volatile_prefix
, len
);
626 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
627 + strlen (buf
) + len
+ strlen (physname
) + 1);
629 mangled_name
= (char *) xmalloc (mangled_name_len
);
631 mangled_name
[0] = '\0';
633 strcpy (mangled_name
, field_name
);
635 strcat (mangled_name
, buf
);
636 /* If the class doesn't have a name, i.e. newname NULL, then we just
637 mangle it using 0 for the length of the class. Thus it gets mangled
638 as something starting with `::' rather than `classname::'. */
640 strcat (mangled_name
, newname
);
642 strcat (mangled_name
, physname
);
643 return (mangled_name
);
646 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
647 correctly allocated. */
650 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
652 struct obstack
*obstack
)
654 if (gsymbol
->language
== language_ada
)
658 gsymbol
->ada_mangled
= 0;
659 gsymbol
->language_specific
.obstack
= obstack
;
663 gsymbol
->ada_mangled
= 1;
664 gsymbol
->language_specific
.demangled_name
= name
;
668 gsymbol
->language_specific
.demangled_name
= name
;
671 /* Return the demangled name of GSYMBOL. */
674 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
676 if (gsymbol
->language
== language_ada
)
678 if (!gsymbol
->ada_mangled
)
683 return gsymbol
->language_specific
.demangled_name
;
687 /* Initialize the language dependent portion of a symbol
688 depending upon the language for the symbol. */
691 symbol_set_language (struct general_symbol_info
*gsymbol
,
692 enum language language
,
693 struct obstack
*obstack
)
695 gsymbol
->language
= language
;
696 if (gsymbol
->language
== language_cplus
697 || gsymbol
->language
== language_d
698 || gsymbol
->language
== language_go
699 || gsymbol
->language
== language_objc
700 || gsymbol
->language
== language_fortran
)
702 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
704 else if (gsymbol
->language
== language_ada
)
706 gdb_assert (gsymbol
->ada_mangled
== 0);
707 gsymbol
->language_specific
.obstack
= obstack
;
711 memset (&gsymbol
->language_specific
, 0,
712 sizeof (gsymbol
->language_specific
));
716 /* Functions to initialize a symbol's mangled name. */
718 /* Objects of this type are stored in the demangled name hash table. */
719 struct demangled_name_entry
721 demangled_name_entry (gdb::string_view mangled_name
)
722 : mangled (mangled_name
) {}
724 gdb::string_view mangled
;
725 enum language language
;
726 gdb::unique_xmalloc_ptr
<char> demangled
;
729 /* Hash function for the demangled name hash. */
732 hash_demangled_name_entry (const void *data
)
734 const struct demangled_name_entry
*e
735 = (const struct demangled_name_entry
*) data
;
737 return fast_hash (e
->mangled
.data (), e
->mangled
.length ());
740 /* Equality function for the demangled name hash. */
743 eq_demangled_name_entry (const void *a
, const void *b
)
745 const struct demangled_name_entry
*da
746 = (const struct demangled_name_entry
*) a
;
747 const struct demangled_name_entry
*db
748 = (const struct demangled_name_entry
*) b
;
750 return da
->mangled
== db
->mangled
;
754 free_demangled_name_entry (void *data
)
756 struct demangled_name_entry
*e
757 = (struct demangled_name_entry
*) data
;
759 e
->~demangled_name_entry();
762 /* Create the hash table used for demangled names. Each hash entry is
763 a pair of strings; one for the mangled name and one for the demangled
764 name. The entry is hashed via just the mangled name. */
767 create_demangled_names_hash (struct objfile_per_bfd_storage
*per_bfd
)
769 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
770 The hash table code will round this up to the next prime number.
771 Choosing a much larger table size wastes memory, and saves only about
772 1% in symbol reading. */
774 per_bfd
->demangled_names_hash
.reset (htab_create_alloc
775 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
776 free_demangled_name_entry
, xcalloc
, xfree
));
779 /* Try to determine the demangled name for a symbol, based on the
780 language of that symbol. If the language is set to language_auto,
781 it will attempt to find any demangling algorithm that works and
782 then set the language appropriately. The returned name is allocated
783 by the demangler and should be xfree'd. */
786 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
789 char *demangled
= NULL
;
792 if (gsymbol
->language
== language_unknown
)
793 gsymbol
->language
= language_auto
;
795 if (gsymbol
->language
!= language_auto
)
797 const struct language_defn
*lang
= language_def (gsymbol
->language
);
799 language_sniff_from_mangled_name (lang
, mangled
, &demangled
);
803 for (i
= language_unknown
; i
< nr_languages
; ++i
)
805 enum language l
= (enum language
) i
;
806 const struct language_defn
*lang
= language_def (l
);
808 if (language_sniff_from_mangled_name (lang
, mangled
, &demangled
))
810 gsymbol
->language
= l
;
818 /* Set both the mangled and demangled (if any) names for GSYMBOL based
819 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
820 objfile's obstack; but if COPY_NAME is 0 and if NAME is
821 NUL-terminated, then this function assumes that NAME is already
822 correctly saved (either permanently or with a lifetime tied to the
823 objfile), and it will not be copied.
825 The hash table corresponding to OBJFILE is used, and the memory
826 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
827 so the pointer can be discarded after calling this function. */
830 symbol_set_names (struct general_symbol_info
*gsymbol
,
831 const char *linkage_name
, int len
, bool copy_name
,
832 struct objfile_per_bfd_storage
*per_bfd
)
834 struct demangled_name_entry
**slot
;
835 /* A 0-terminated copy of the linkage name. */
836 const char *linkage_name_copy
;
838 if (gsymbol
->language
== language_ada
)
840 /* In Ada, we do the symbol lookups using the mangled name, so
841 we can save some space by not storing the demangled name. */
843 gsymbol
->name
= linkage_name
;
846 char *name
= (char *) obstack_alloc (&per_bfd
->storage_obstack
,
849 memcpy (name
, linkage_name
, len
);
851 gsymbol
->name
= name
;
853 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
858 if (per_bfd
->demangled_names_hash
== NULL
)
859 create_demangled_names_hash (per_bfd
);
861 if (linkage_name
[len
] != '\0')
865 alloc_name
= (char *) alloca (len
+ 1);
866 memcpy (alloc_name
, linkage_name
, len
);
867 alloc_name
[len
] = '\0';
869 linkage_name_copy
= alloc_name
;
872 linkage_name_copy
= linkage_name
;
874 struct demangled_name_entry
entry (gdb::string_view (linkage_name_copy
, len
));
875 slot
= ((struct demangled_name_entry
**)
876 htab_find_slot (per_bfd
->demangled_names_hash
.get (),
879 /* If this name is not in the hash table, add it. */
881 /* A C version of the symbol may have already snuck into the table.
882 This happens to, e.g., main.init (__go_init_main). Cope. */
883 || (gsymbol
->language
== language_go
&& (*slot
)->demangled
== nullptr))
885 gdb::unique_xmalloc_ptr
<char> demangled_name_ptr
886 (symbol_find_demangled_name (gsymbol
, linkage_name_copy
));
888 /* Suppose we have demangled_name==NULL, copy_name==0, and
889 linkage_name_copy==linkage_name. In this case, we already have the
890 mangled name saved, and we don't have a demangled name. So,
891 you might think we could save a little space by not recording
892 this in the hash table at all.
894 It turns out that it is actually important to still save such
895 an entry in the hash table, because storing this name gives
896 us better bcache hit rates for partial symbols. */
897 if (!copy_name
&& linkage_name_copy
== linkage_name
)
900 = ((struct demangled_name_entry
*)
901 obstack_alloc (&per_bfd
->storage_obstack
,
902 sizeof (demangled_name_entry
)));
903 new (*slot
) demangled_name_entry
904 (gdb::string_view (linkage_name
, len
));
908 /* If we must copy the mangled name, put it directly after
909 the struct so we can have a single allocation. */
911 = ((struct demangled_name_entry
*)
912 obstack_alloc (&per_bfd
->storage_obstack
,
913 sizeof (demangled_name_entry
) + len
+ 1));
914 char *mangled_ptr
= reinterpret_cast<char *> (*slot
+ 1);
915 strcpy (mangled_ptr
, linkage_name_copy
);
916 new (*slot
) demangled_name_entry
917 (gdb::string_view (mangled_ptr
, len
));
919 (*slot
)->demangled
= std::move (demangled_name_ptr
);
920 (*slot
)->language
= gsymbol
->language
;
922 else if (gsymbol
->language
== language_unknown
923 || gsymbol
->language
== language_auto
)
924 gsymbol
->language
= (*slot
)->language
;
926 gsymbol
->name
= (*slot
)->mangled
.data ();
927 if ((*slot
)->demangled
!= nullptr)
928 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
.get (),
929 &per_bfd
->storage_obstack
);
931 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
934 /* Return the source code name of a symbol. In languages where
935 demangling is necessary, this is the demangled name. */
938 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
940 switch (gsymbol
->language
)
946 case language_fortran
:
947 if (symbol_get_demangled_name (gsymbol
) != NULL
)
948 return symbol_get_demangled_name (gsymbol
);
951 return ada_decode_symbol (gsymbol
);
955 return gsymbol
->name
;
958 /* Return the demangled name for a symbol based on the language for
959 that symbol. If no demangled name exists, return NULL. */
962 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
964 const char *dem_name
= NULL
;
966 switch (gsymbol
->language
)
972 case language_fortran
:
973 dem_name
= symbol_get_demangled_name (gsymbol
);
976 dem_name
= ada_decode_symbol (gsymbol
);
984 /* Return the search name of a symbol---generally the demangled or
985 linkage name of the symbol, depending on how it will be searched for.
986 If there is no distinct demangled name, then returns the same value
987 (same pointer) as SYMBOL_LINKAGE_NAME. */
990 symbol_search_name (const struct general_symbol_info
*gsymbol
)
992 if (gsymbol
->language
== language_ada
)
993 return gsymbol
->name
;
995 return symbol_natural_name (gsymbol
);
1001 symbol_matches_search_name (const struct general_symbol_info
*gsymbol
,
1002 const lookup_name_info
&name
)
1004 symbol_name_matcher_ftype
*name_match
1005 = get_symbol_name_matcher (language_def (gsymbol
->language
), name
);
1006 return name_match (symbol_search_name (gsymbol
), name
, NULL
);
1011 /* Return true if the two sections are the same, or if they could
1012 plausibly be copies of each other, one in an original object
1013 file and another in a separated debug file. */
1016 matching_obj_sections (struct obj_section
*obj_first
,
1017 struct obj_section
*obj_second
)
1019 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
1020 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
1022 /* If they're the same section, then they match. */
1023 if (first
== second
)
1026 /* If either is NULL, give up. */
1027 if (first
== NULL
|| second
== NULL
)
1030 /* This doesn't apply to absolute symbols. */
1031 if (first
->owner
== NULL
|| second
->owner
== NULL
)
1034 /* If they're in the same object file, they must be different sections. */
1035 if (first
->owner
== second
->owner
)
1038 /* Check whether the two sections are potentially corresponding. They must
1039 have the same size, address, and name. We can't compare section indexes,
1040 which would be more reliable, because some sections may have been
1042 if (bfd_section_size (first
) != bfd_section_size (second
))
1045 /* In-memory addresses may start at a different offset, relativize them. */
1046 if (bfd_section_vma (first
) - bfd_get_start_address (first
->owner
)
1047 != bfd_section_vma (second
) - bfd_get_start_address (second
->owner
))
1050 if (bfd_section_name (first
) == NULL
1051 || bfd_section_name (second
) == NULL
1052 || strcmp (bfd_section_name (first
), bfd_section_name (second
)) != 0)
1055 /* Otherwise check that they are in corresponding objfiles. */
1057 struct objfile
*obj
= NULL
;
1058 for (objfile
*objfile
: current_program_space
->objfiles ())
1059 if (objfile
->obfd
== first
->owner
)
1064 gdb_assert (obj
!= NULL
);
1066 if (obj
->separate_debug_objfile
!= NULL
1067 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1069 if (obj
->separate_debug_objfile_backlink
!= NULL
1070 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1079 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1081 struct bound_minimal_symbol msymbol
;
1083 /* If we know that this is not a text address, return failure. This is
1084 necessary because we loop based on texthigh and textlow, which do
1085 not include the data ranges. */
1086 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1087 if (msymbol
.minsym
&& msymbol
.minsym
->data_p ())
1090 for (objfile
*objfile
: current_program_space
->objfiles ())
1092 struct compunit_symtab
*cust
= NULL
;
1095 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1102 /* Hash function for the symbol cache. */
1105 hash_symbol_entry (const struct objfile
*objfile_context
,
1106 const char *name
, domain_enum domain
)
1108 unsigned int hash
= (uintptr_t) objfile_context
;
1111 hash
+= htab_hash_string (name
);
1113 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1114 to map to the same slot. */
1115 if (domain
== STRUCT_DOMAIN
)
1116 hash
+= VAR_DOMAIN
* 7;
1123 /* Equality function for the symbol cache. */
1126 eq_symbol_entry (const struct symbol_cache_slot
*slot
,
1127 const struct objfile
*objfile_context
,
1128 const char *name
, domain_enum domain
)
1130 const char *slot_name
;
1131 domain_enum slot_domain
;
1133 if (slot
->state
== SYMBOL_SLOT_UNUSED
)
1136 if (slot
->objfile_context
!= objfile_context
)
1139 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1141 slot_name
= slot
->value
.not_found
.name
;
1142 slot_domain
= slot
->value
.not_found
.domain
;
1146 slot_name
= SYMBOL_SEARCH_NAME (slot
->value
.found
.symbol
);
1147 slot_domain
= SYMBOL_DOMAIN (slot
->value
.found
.symbol
);
1150 /* NULL names match. */
1151 if (slot_name
== NULL
&& name
== NULL
)
1153 /* But there's no point in calling symbol_matches_domain in the
1154 SYMBOL_SLOT_FOUND case. */
1155 if (slot_domain
!= domain
)
1158 else if (slot_name
!= NULL
&& name
!= NULL
)
1160 /* It's important that we use the same comparison that was done
1161 the first time through. If the slot records a found symbol,
1162 then this means using the symbol name comparison function of
1163 the symbol's language with SYMBOL_SEARCH_NAME. See
1164 dictionary.c. It also means using symbol_matches_domain for
1165 found symbols. See block.c.
1167 If the slot records a not-found symbol, then require a precise match.
1168 We could still be lax with whitespace like strcmp_iw though. */
1170 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1172 if (strcmp (slot_name
, name
) != 0)
1174 if (slot_domain
!= domain
)
1179 struct symbol
*sym
= slot
->value
.found
.symbol
;
1180 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1182 if (!SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
1185 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1186 slot_domain
, domain
))
1192 /* Only one name is NULL. */
1199 /* Given a cache of size SIZE, return the size of the struct (with variable
1200 length array) in bytes. */
1203 symbol_cache_byte_size (unsigned int size
)
1205 return (sizeof (struct block_symbol_cache
)
1206 + ((size
- 1) * sizeof (struct symbol_cache_slot
)));
1212 resize_symbol_cache (struct symbol_cache
*cache
, unsigned int new_size
)
1214 /* If there's no change in size, don't do anything.
1215 All caches have the same size, so we can just compare with the size
1216 of the global symbols cache. */
1217 if ((cache
->global_symbols
!= NULL
1218 && cache
->global_symbols
->size
== new_size
)
1219 || (cache
->global_symbols
== NULL
1223 xfree (cache
->global_symbols
);
1224 xfree (cache
->static_symbols
);
1228 cache
->global_symbols
= NULL
;
1229 cache
->static_symbols
= NULL
;
1233 size_t total_size
= symbol_cache_byte_size (new_size
);
1235 cache
->global_symbols
1236 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1237 cache
->static_symbols
1238 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1239 cache
->global_symbols
->size
= new_size
;
1240 cache
->static_symbols
->size
= new_size
;
1244 /* Return the symbol cache of PSPACE.
1245 Create one if it doesn't exist yet. */
1247 static struct symbol_cache
*
1248 get_symbol_cache (struct program_space
*pspace
)
1250 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1254 cache
= symbol_cache_key
.emplace (pspace
);
1255 resize_symbol_cache (cache
, symbol_cache_size
);
1261 /* Set the size of the symbol cache in all program spaces. */
1264 set_symbol_cache_size (unsigned int new_size
)
1266 struct program_space
*pspace
;
1268 ALL_PSPACES (pspace
)
1270 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1272 /* The pspace could have been created but not have a cache yet. */
1274 resize_symbol_cache (cache
, new_size
);
1278 /* Called when symbol-cache-size is set. */
1281 set_symbol_cache_size_handler (const char *args
, int from_tty
,
1282 struct cmd_list_element
*c
)
1284 if (new_symbol_cache_size
> MAX_SYMBOL_CACHE_SIZE
)
1286 /* Restore the previous value.
1287 This is the value the "show" command prints. */
1288 new_symbol_cache_size
= symbol_cache_size
;
1290 error (_("Symbol cache size is too large, max is %u."),
1291 MAX_SYMBOL_CACHE_SIZE
);
1293 symbol_cache_size
= new_symbol_cache_size
;
1295 set_symbol_cache_size (symbol_cache_size
);
1298 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1299 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1300 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1301 failed (and thus this one will too), or NULL if the symbol is not present
1303 *BSC_PTR and *SLOT_PTR are set to the cache and slot of the symbol, which
1304 can be used to save the result of a full lookup attempt. */
1306 static struct block_symbol
1307 symbol_cache_lookup (struct symbol_cache
*cache
,
1308 struct objfile
*objfile_context
, enum block_enum block
,
1309 const char *name
, domain_enum domain
,
1310 struct block_symbol_cache
**bsc_ptr
,
1311 struct symbol_cache_slot
**slot_ptr
)
1313 struct block_symbol_cache
*bsc
;
1315 struct symbol_cache_slot
*slot
;
1317 if (block
== GLOBAL_BLOCK
)
1318 bsc
= cache
->global_symbols
;
1320 bsc
= cache
->static_symbols
;
1328 hash
= hash_symbol_entry (objfile_context
, name
, domain
);
1329 slot
= bsc
->symbols
+ hash
% bsc
->size
;
1334 if (eq_symbol_entry (slot
, objfile_context
, name
, domain
))
1336 if (symbol_lookup_debug
)
1337 fprintf_unfiltered (gdb_stdlog
,
1338 "%s block symbol cache hit%s for %s, %s\n",
1339 block
== GLOBAL_BLOCK
? "Global" : "Static",
1340 slot
->state
== SYMBOL_SLOT_NOT_FOUND
1341 ? " (not found)" : "",
1342 name
, domain_name (domain
));
1344 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1345 return SYMBOL_LOOKUP_FAILED
;
1346 return slot
->value
.found
;
1349 /* Symbol is not present in the cache. */
1351 if (symbol_lookup_debug
)
1353 fprintf_unfiltered (gdb_stdlog
,
1354 "%s block symbol cache miss for %s, %s\n",
1355 block
== GLOBAL_BLOCK
? "Global" : "Static",
1356 name
, domain_name (domain
));
1362 /* Clear out SLOT. */
1365 symbol_cache_clear_slot (struct symbol_cache_slot
*slot
)
1367 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1368 xfree (slot
->value
.not_found
.name
);
1369 slot
->state
= SYMBOL_SLOT_UNUSED
;
1372 /* Mark SYMBOL as found in SLOT.
1373 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1374 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1375 necessarily the objfile the symbol was found in. */
1378 symbol_cache_mark_found (struct block_symbol_cache
*bsc
,
1379 struct symbol_cache_slot
*slot
,
1380 struct objfile
*objfile_context
,
1381 struct symbol
*symbol
,
1382 const struct block
*block
)
1386 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1389 symbol_cache_clear_slot (slot
);
1391 slot
->state
= SYMBOL_SLOT_FOUND
;
1392 slot
->objfile_context
= objfile_context
;
1393 slot
->value
.found
.symbol
= symbol
;
1394 slot
->value
.found
.block
= block
;
1397 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1398 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1399 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1402 symbol_cache_mark_not_found (struct block_symbol_cache
*bsc
,
1403 struct symbol_cache_slot
*slot
,
1404 struct objfile
*objfile_context
,
1405 const char *name
, domain_enum domain
)
1409 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1412 symbol_cache_clear_slot (slot
);
1414 slot
->state
= SYMBOL_SLOT_NOT_FOUND
;
1415 slot
->objfile_context
= objfile_context
;
1416 slot
->value
.not_found
.name
= xstrdup (name
);
1417 slot
->value
.not_found
.domain
= domain
;
1420 /* Flush the symbol cache of PSPACE. */
1423 symbol_cache_flush (struct program_space
*pspace
)
1425 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1430 if (cache
->global_symbols
== NULL
)
1432 gdb_assert (symbol_cache_size
== 0);
1433 gdb_assert (cache
->static_symbols
== NULL
);
1437 /* If the cache is untouched since the last flush, early exit.
1438 This is important for performance during the startup of a program linked
1439 with 100s (or 1000s) of shared libraries. */
1440 if (cache
->global_symbols
->misses
== 0
1441 && cache
->static_symbols
->misses
== 0)
1444 gdb_assert (cache
->global_symbols
->size
== symbol_cache_size
);
1445 gdb_assert (cache
->static_symbols
->size
== symbol_cache_size
);
1447 for (pass
= 0; pass
< 2; ++pass
)
1449 struct block_symbol_cache
*bsc
1450 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1453 for (i
= 0; i
< bsc
->size
; ++i
)
1454 symbol_cache_clear_slot (&bsc
->symbols
[i
]);
1457 cache
->global_symbols
->hits
= 0;
1458 cache
->global_symbols
->misses
= 0;
1459 cache
->global_symbols
->collisions
= 0;
1460 cache
->static_symbols
->hits
= 0;
1461 cache
->static_symbols
->misses
= 0;
1462 cache
->static_symbols
->collisions
= 0;
1468 symbol_cache_dump (const struct symbol_cache
*cache
)
1472 if (cache
->global_symbols
== NULL
)
1474 printf_filtered (" <disabled>\n");
1478 for (pass
= 0; pass
< 2; ++pass
)
1480 const struct block_symbol_cache
*bsc
1481 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1485 printf_filtered ("Global symbols:\n");
1487 printf_filtered ("Static symbols:\n");
1489 for (i
= 0; i
< bsc
->size
; ++i
)
1491 const struct symbol_cache_slot
*slot
= &bsc
->symbols
[i
];
1495 switch (slot
->state
)
1497 case SYMBOL_SLOT_UNUSED
:
1499 case SYMBOL_SLOT_NOT_FOUND
:
1500 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i
,
1501 host_address_to_string (slot
->objfile_context
),
1502 slot
->value
.not_found
.name
,
1503 domain_name (slot
->value
.not_found
.domain
));
1505 case SYMBOL_SLOT_FOUND
:
1507 struct symbol
*found
= slot
->value
.found
.symbol
;
1508 const struct objfile
*context
= slot
->objfile_context
;
1510 printf_filtered (" [%4u] = %s, %s %s\n", i
,
1511 host_address_to_string (context
),
1512 SYMBOL_PRINT_NAME (found
),
1513 domain_name (SYMBOL_DOMAIN (found
)));
1521 /* The "mt print symbol-cache" command. */
1524 maintenance_print_symbol_cache (const char *args
, int from_tty
)
1526 struct program_space
*pspace
;
1528 ALL_PSPACES (pspace
)
1530 struct symbol_cache
*cache
;
1532 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1534 pspace
->symfile_object_file
!= NULL
1535 ? objfile_name (pspace
->symfile_object_file
)
1536 : "(no object file)");
1538 /* If the cache hasn't been created yet, avoid creating one. */
1539 cache
= symbol_cache_key
.get (pspace
);
1541 printf_filtered (" <empty>\n");
1543 symbol_cache_dump (cache
);
1547 /* The "mt flush-symbol-cache" command. */
1550 maintenance_flush_symbol_cache (const char *args
, int from_tty
)
1552 struct program_space
*pspace
;
1554 ALL_PSPACES (pspace
)
1556 symbol_cache_flush (pspace
);
1560 /* Print usage statistics of CACHE. */
1563 symbol_cache_stats (struct symbol_cache
*cache
)
1567 if (cache
->global_symbols
== NULL
)
1569 printf_filtered (" <disabled>\n");
1573 for (pass
= 0; pass
< 2; ++pass
)
1575 const struct block_symbol_cache
*bsc
1576 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1581 printf_filtered ("Global block cache stats:\n");
1583 printf_filtered ("Static block cache stats:\n");
1585 printf_filtered (" size: %u\n", bsc
->size
);
1586 printf_filtered (" hits: %u\n", bsc
->hits
);
1587 printf_filtered (" misses: %u\n", bsc
->misses
);
1588 printf_filtered (" collisions: %u\n", bsc
->collisions
);
1592 /* The "mt print symbol-cache-statistics" command. */
1595 maintenance_print_symbol_cache_statistics (const char *args
, int from_tty
)
1597 struct program_space
*pspace
;
1599 ALL_PSPACES (pspace
)
1601 struct symbol_cache
*cache
;
1603 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1605 pspace
->symfile_object_file
!= NULL
1606 ? objfile_name (pspace
->symfile_object_file
)
1607 : "(no object file)");
1609 /* If the cache hasn't been created yet, avoid creating one. */
1610 cache
= symbol_cache_key
.get (pspace
);
1612 printf_filtered (" empty, no stats available\n");
1614 symbol_cache_stats (cache
);
1618 /* This module's 'new_objfile' observer. */
1621 symtab_new_objfile_observer (struct objfile
*objfile
)
1623 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1624 symbol_cache_flush (current_program_space
);
1627 /* This module's 'free_objfile' observer. */
1630 symtab_free_objfile_observer (struct objfile
*objfile
)
1632 symbol_cache_flush (objfile
->pspace
);
1635 /* Debug symbols usually don't have section information. We need to dig that
1636 out of the minimal symbols and stash that in the debug symbol. */
1639 fixup_section (struct general_symbol_info
*ginfo
,
1640 CORE_ADDR addr
, struct objfile
*objfile
)
1642 struct minimal_symbol
*msym
;
1644 /* First, check whether a minimal symbol with the same name exists
1645 and points to the same address. The address check is required
1646 e.g. on PowerPC64, where the minimal symbol for a function will
1647 point to the function descriptor, while the debug symbol will
1648 point to the actual function code. */
1649 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1651 ginfo
->section
= MSYMBOL_SECTION (msym
);
1654 /* Static, function-local variables do appear in the linker
1655 (minimal) symbols, but are frequently given names that won't
1656 be found via lookup_minimal_symbol(). E.g., it has been
1657 observed in frv-uclinux (ELF) executables that a static,
1658 function-local variable named "foo" might appear in the
1659 linker symbols as "foo.6" or "foo.3". Thus, there is no
1660 point in attempting to extend the lookup-by-name mechanism to
1661 handle this case due to the fact that there can be multiple
1664 So, instead, search the section table when lookup by name has
1665 failed. The ``addr'' and ``endaddr'' fields may have already
1666 been relocated. If so, the relocation offset (i.e. the
1667 ANOFFSET value) needs to be subtracted from these values when
1668 performing the comparison. We unconditionally subtract it,
1669 because, when no relocation has been performed, the ANOFFSET
1670 value will simply be zero.
1672 The address of the symbol whose section we're fixing up HAS
1673 NOT BEEN adjusted (relocated) yet. It can't have been since
1674 the section isn't yet known and knowing the section is
1675 necessary in order to add the correct relocation value. In
1676 other words, we wouldn't even be in this function (attempting
1677 to compute the section) if it were already known.
1679 Note that it is possible to search the minimal symbols
1680 (subtracting the relocation value if necessary) to find the
1681 matching minimal symbol, but this is overkill and much less
1682 efficient. It is not necessary to find the matching minimal
1683 symbol, only its section.
1685 Note that this technique (of doing a section table search)
1686 can fail when unrelocated section addresses overlap. For
1687 this reason, we still attempt a lookup by name prior to doing
1688 a search of the section table. */
1690 struct obj_section
*s
;
1693 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1695 int idx
= s
- objfile
->sections
;
1696 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1701 if (obj_section_addr (s
) - offset
<= addr
1702 && addr
< obj_section_endaddr (s
) - offset
)
1704 ginfo
->section
= idx
;
1709 /* If we didn't find the section, assume it is in the first
1710 section. If there is no allocated section, then it hardly
1711 matters what we pick, so just pick zero. */
1715 ginfo
->section
= fallback
;
1720 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1727 if (!SYMBOL_OBJFILE_OWNED (sym
))
1730 /* We either have an OBJFILE, or we can get at it from the sym's
1731 symtab. Anything else is a bug. */
1732 gdb_assert (objfile
|| symbol_symtab (sym
));
1734 if (objfile
== NULL
)
1735 objfile
= symbol_objfile (sym
);
1737 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1740 /* We should have an objfile by now. */
1741 gdb_assert (objfile
);
1743 switch (SYMBOL_CLASS (sym
))
1747 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1750 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1754 /* Nothing else will be listed in the minsyms -- no use looking
1759 fixup_section (&sym
->ginfo
, addr
, objfile
);
1766 demangle_for_lookup_info::demangle_for_lookup_info
1767 (const lookup_name_info
&lookup_name
, language lang
)
1769 demangle_result_storage storage
;
1771 if (lookup_name
.ignore_parameters () && lang
== language_cplus
)
1773 gdb::unique_xmalloc_ptr
<char> without_params
1774 = cp_remove_params_if_any (lookup_name
.name ().c_str (),
1775 lookup_name
.completion_mode ());
1777 if (without_params
!= NULL
)
1779 if (lookup_name
.match_type () != symbol_name_match_type::SEARCH_NAME
)
1780 m_demangled_name
= demangle_for_lookup (without_params
.get (),
1786 if (lookup_name
.match_type () == symbol_name_match_type::SEARCH_NAME
)
1787 m_demangled_name
= lookup_name
.name ();
1789 m_demangled_name
= demangle_for_lookup (lookup_name
.name ().c_str (),
1795 const lookup_name_info
&
1796 lookup_name_info::match_any ()
1798 /* Lookup any symbol that "" would complete. I.e., this matches all
1800 static const lookup_name_info
lookup_name ({}, symbol_name_match_type::FULL
,
1806 /* Compute the demangled form of NAME as used by the various symbol
1807 lookup functions. The result can either be the input NAME
1808 directly, or a pointer to a buffer owned by the STORAGE object.
1810 For Ada, this function just returns NAME, unmodified.
1811 Normally, Ada symbol lookups are performed using the encoded name
1812 rather than the demangled name, and so it might seem to make sense
1813 for this function to return an encoded version of NAME.
1814 Unfortunately, we cannot do this, because this function is used in
1815 circumstances where it is not appropriate to try to encode NAME.
1816 For instance, when displaying the frame info, we demangle the name
1817 of each parameter, and then perform a symbol lookup inside our
1818 function using that demangled name. In Ada, certain functions
1819 have internally-generated parameters whose name contain uppercase
1820 characters. Encoding those name would result in those uppercase
1821 characters to become lowercase, and thus cause the symbol lookup
1825 demangle_for_lookup (const char *name
, enum language lang
,
1826 demangle_result_storage
&storage
)
1828 /* If we are using C++, D, or Go, demangle the name before doing a
1829 lookup, so we can always binary search. */
1830 if (lang
== language_cplus
)
1832 char *demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1833 if (demangled_name
!= NULL
)
1834 return storage
.set_malloc_ptr (demangled_name
);
1836 /* If we were given a non-mangled name, canonicalize it
1837 according to the language (so far only for C++). */
1838 std::string canon
= cp_canonicalize_string (name
);
1839 if (!canon
.empty ())
1840 return storage
.swap_string (canon
);
1842 else if (lang
== language_d
)
1844 char *demangled_name
= d_demangle (name
, 0);
1845 if (demangled_name
!= NULL
)
1846 return storage
.set_malloc_ptr (demangled_name
);
1848 else if (lang
== language_go
)
1850 char *demangled_name
= go_demangle (name
, 0);
1851 if (demangled_name
!= NULL
)
1852 return storage
.set_malloc_ptr (demangled_name
);
1861 search_name_hash (enum language language
, const char *search_name
)
1863 return language_def (language
)->la_search_name_hash (search_name
);
1868 This function (or rather its subordinates) have a bunch of loops and
1869 it would seem to be attractive to put in some QUIT's (though I'm not really
1870 sure whether it can run long enough to be really important). But there
1871 are a few calls for which it would appear to be bad news to quit
1872 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1873 that there is C++ code below which can error(), but that probably
1874 doesn't affect these calls since they are looking for a known
1875 variable and thus can probably assume it will never hit the C++
1879 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1880 const domain_enum domain
, enum language lang
,
1881 struct field_of_this_result
*is_a_field_of_this
)
1883 demangle_result_storage storage
;
1884 const char *modified_name
= demangle_for_lookup (name
, lang
, storage
);
1886 return lookup_symbol_aux (modified_name
,
1887 symbol_name_match_type::FULL
,
1888 block
, domain
, lang
,
1889 is_a_field_of_this
);
1895 lookup_symbol (const char *name
, const struct block
*block
,
1897 struct field_of_this_result
*is_a_field_of_this
)
1899 return lookup_symbol_in_language (name
, block
, domain
,
1900 current_language
->la_language
,
1901 is_a_field_of_this
);
1907 lookup_symbol_search_name (const char *search_name
, const struct block
*block
,
1910 return lookup_symbol_aux (search_name
, symbol_name_match_type::SEARCH_NAME
,
1911 block
, domain
, language_asm
, NULL
);
1917 lookup_language_this (const struct language_defn
*lang
,
1918 const struct block
*block
)
1920 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1923 if (symbol_lookup_debug
> 1)
1925 struct objfile
*objfile
= lookup_objfile_from_block (block
);
1927 fprintf_unfiltered (gdb_stdlog
,
1928 "lookup_language_this (%s, %s (objfile %s))",
1929 lang
->la_name
, host_address_to_string (block
),
1930 objfile_debug_name (objfile
));
1937 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
,
1938 symbol_name_match_type::SEARCH_NAME
,
1942 if (symbol_lookup_debug
> 1)
1944 fprintf_unfiltered (gdb_stdlog
, " = %s (%s, block %s)\n",
1945 SYMBOL_PRINT_NAME (sym
),
1946 host_address_to_string (sym
),
1947 host_address_to_string (block
));
1949 return (struct block_symbol
) {sym
, block
};
1951 if (BLOCK_FUNCTION (block
))
1953 block
= BLOCK_SUPERBLOCK (block
);
1956 if (symbol_lookup_debug
> 1)
1957 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1961 /* Given TYPE, a structure/union,
1962 return 1 if the component named NAME from the ultimate target
1963 structure/union is defined, otherwise, return 0. */
1966 check_field (struct type
*type
, const char *name
,
1967 struct field_of_this_result
*is_a_field_of_this
)
1971 /* The type may be a stub. */
1972 type
= check_typedef (type
);
1974 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1976 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1978 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1980 is_a_field_of_this
->type
= type
;
1981 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1986 /* C++: If it was not found as a data field, then try to return it
1987 as a pointer to a method. */
1989 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1991 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1993 is_a_field_of_this
->type
= type
;
1994 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1999 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2000 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
2006 /* Behave like lookup_symbol except that NAME is the natural name
2007 (e.g., demangled name) of the symbol that we're looking for. */
2009 static struct block_symbol
2010 lookup_symbol_aux (const char *name
, symbol_name_match_type match_type
,
2011 const struct block
*block
,
2012 const domain_enum domain
, enum language language
,
2013 struct field_of_this_result
*is_a_field_of_this
)
2015 struct block_symbol result
;
2016 const struct language_defn
*langdef
;
2018 if (symbol_lookup_debug
)
2020 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2022 fprintf_unfiltered (gdb_stdlog
,
2023 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
2024 name
, host_address_to_string (block
),
2026 ? objfile_debug_name (objfile
) : "NULL",
2027 domain_name (domain
), language_str (language
));
2030 /* Make sure we do something sensible with is_a_field_of_this, since
2031 the callers that set this parameter to some non-null value will
2032 certainly use it later. If we don't set it, the contents of
2033 is_a_field_of_this are undefined. */
2034 if (is_a_field_of_this
!= NULL
)
2035 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
2037 /* Search specified block and its superiors. Don't search
2038 STATIC_BLOCK or GLOBAL_BLOCK. */
2040 result
= lookup_local_symbol (name
, match_type
, block
, domain
, language
);
2041 if (result
.symbol
!= NULL
)
2043 if (symbol_lookup_debug
)
2045 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2046 host_address_to_string (result
.symbol
));
2051 /* If requested to do so by the caller and if appropriate for LANGUAGE,
2052 check to see if NAME is a field of `this'. */
2054 langdef
= language_def (language
);
2056 /* Don't do this check if we are searching for a struct. It will
2057 not be found by check_field, but will be found by other
2059 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
2061 result
= lookup_language_this (langdef
, block
);
2065 struct type
*t
= result
.symbol
->type
;
2067 /* I'm not really sure that type of this can ever
2068 be typedefed; just be safe. */
2069 t
= check_typedef (t
);
2070 if (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2071 t
= TYPE_TARGET_TYPE (t
);
2073 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2074 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2075 error (_("Internal error: `%s' is not an aggregate"),
2076 langdef
->la_name_of_this
);
2078 if (check_field (t
, name
, is_a_field_of_this
))
2080 if (symbol_lookup_debug
)
2082 fprintf_unfiltered (gdb_stdlog
,
2083 "lookup_symbol_aux (...) = NULL\n");
2090 /* Now do whatever is appropriate for LANGUAGE to look
2091 up static and global variables. */
2093 result
= langdef
->la_lookup_symbol_nonlocal (langdef
, name
, block
, domain
);
2094 if (result
.symbol
!= NULL
)
2096 if (symbol_lookup_debug
)
2098 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2099 host_address_to_string (result
.symbol
));
2104 /* Now search all static file-level symbols. Not strictly correct,
2105 but more useful than an error. */
2107 result
= lookup_static_symbol (name
, domain
);
2108 if (symbol_lookup_debug
)
2110 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2111 result
.symbol
!= NULL
2112 ? host_address_to_string (result
.symbol
)
2118 /* Check to see if the symbol is defined in BLOCK or its superiors.
2119 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2121 static struct block_symbol
2122 lookup_local_symbol (const char *name
,
2123 symbol_name_match_type match_type
,
2124 const struct block
*block
,
2125 const domain_enum domain
,
2126 enum language language
)
2129 const struct block
*static_block
= block_static_block (block
);
2130 const char *scope
= block_scope (block
);
2132 /* Check if either no block is specified or it's a global block. */
2134 if (static_block
== NULL
)
2137 while (block
!= static_block
)
2139 sym
= lookup_symbol_in_block (name
, match_type
, block
, domain
);
2141 return (struct block_symbol
) {sym
, block
};
2143 if (language
== language_cplus
|| language
== language_fortran
)
2145 struct block_symbol blocksym
2146 = cp_lookup_symbol_imports_or_template (scope
, name
, block
,
2149 if (blocksym
.symbol
!= NULL
)
2153 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
2155 block
= BLOCK_SUPERBLOCK (block
);
2158 /* We've reached the end of the function without finding a result. */
2166 lookup_objfile_from_block (const struct block
*block
)
2171 block
= block_global_block (block
);
2172 /* Look through all blockvectors. */
2173 for (objfile
*obj
: current_program_space
->objfiles ())
2175 for (compunit_symtab
*cust
: obj
->compunits ())
2176 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
2179 if (obj
->separate_debug_objfile_backlink
)
2180 obj
= obj
->separate_debug_objfile_backlink
;
2192 lookup_symbol_in_block (const char *name
, symbol_name_match_type match_type
,
2193 const struct block
*block
,
2194 const domain_enum domain
)
2198 if (symbol_lookup_debug
> 1)
2200 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2202 fprintf_unfiltered (gdb_stdlog
,
2203 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2204 name
, host_address_to_string (block
),
2205 objfile_debug_name (objfile
),
2206 domain_name (domain
));
2209 sym
= block_lookup_symbol (block
, name
, match_type
, domain
);
2212 if (symbol_lookup_debug
> 1)
2214 fprintf_unfiltered (gdb_stdlog
, " = %s\n",
2215 host_address_to_string (sym
));
2217 return fixup_symbol_section (sym
, NULL
);
2220 if (symbol_lookup_debug
> 1)
2221 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2228 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
2229 enum block_enum block_index
,
2231 const domain_enum domain
)
2233 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2235 for (objfile
*objfile
: main_objfile
->separate_debug_objfiles ())
2237 struct block_symbol result
2238 = lookup_symbol_in_objfile (objfile
, block_index
, name
, domain
);
2240 if (result
.symbol
!= nullptr)
2247 /* Check to see if the symbol is defined in one of the OBJFILE's
2248 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2249 depending on whether or not we want to search global symbols or
2252 static struct block_symbol
2253 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
,
2254 enum block_enum block_index
, const char *name
,
2255 const domain_enum domain
)
2257 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2259 if (symbol_lookup_debug
> 1)
2261 fprintf_unfiltered (gdb_stdlog
,
2262 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2263 objfile_debug_name (objfile
),
2264 block_index
== GLOBAL_BLOCK
2265 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2266 name
, domain_name (domain
));
2269 for (compunit_symtab
*cust
: objfile
->compunits ())
2271 const struct blockvector
*bv
;
2272 const struct block
*block
;
2273 struct block_symbol result
;
2275 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2276 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2277 result
.symbol
= block_lookup_symbol_primary (block
, name
, domain
);
2278 result
.block
= block
;
2279 if (result
.symbol
!= NULL
)
2281 if (symbol_lookup_debug
> 1)
2283 fprintf_unfiltered (gdb_stdlog
, " = %s (block %s)\n",
2284 host_address_to_string (result
.symbol
),
2285 host_address_to_string (block
));
2287 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2293 if (symbol_lookup_debug
> 1)
2294 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2298 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2299 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2300 and all associated separate debug objfiles.
2302 Normally we only look in OBJFILE, and not any separate debug objfiles
2303 because the outer loop will cause them to be searched too. This case is
2304 different. Here we're called from search_symbols where it will only
2305 call us for the objfile that contains a matching minsym. */
2307 static struct block_symbol
2308 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
2309 const char *linkage_name
,
2312 enum language lang
= current_language
->la_language
;
2313 struct objfile
*main_objfile
;
2315 demangle_result_storage storage
;
2316 const char *modified_name
= demangle_for_lookup (linkage_name
, lang
, storage
);
2318 if (objfile
->separate_debug_objfile_backlink
)
2319 main_objfile
= objfile
->separate_debug_objfile_backlink
;
2321 main_objfile
= objfile
;
2323 for (::objfile
*cur_objfile
: main_objfile
->separate_debug_objfiles ())
2325 struct block_symbol result
;
2327 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
2328 modified_name
, domain
);
2329 if (result
.symbol
== NULL
)
2330 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
2331 modified_name
, domain
);
2332 if (result
.symbol
!= NULL
)
2339 /* A helper function that throws an exception when a symbol was found
2340 in a psymtab but not in a symtab. */
2342 static void ATTRIBUTE_NORETURN
2343 error_in_psymtab_expansion (enum block_enum block_index
, const char *name
,
2344 struct compunit_symtab
*cust
)
2347 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2348 %s may be an inlined function, or may be a template function\n \
2349 (if a template, try specifying an instantiation: %s<type>)."),
2350 block_index
== GLOBAL_BLOCK
? "global" : "static",
2352 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
2356 /* A helper function for various lookup routines that interfaces with
2357 the "quick" symbol table functions. */
2359 static struct block_symbol
2360 lookup_symbol_via_quick_fns (struct objfile
*objfile
,
2361 enum block_enum block_index
, const char *name
,
2362 const domain_enum domain
)
2364 struct compunit_symtab
*cust
;
2365 const struct blockvector
*bv
;
2366 const struct block
*block
;
2367 struct block_symbol result
;
2372 if (symbol_lookup_debug
> 1)
2374 fprintf_unfiltered (gdb_stdlog
,
2375 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2376 objfile_debug_name (objfile
),
2377 block_index
== GLOBAL_BLOCK
2378 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2379 name
, domain_name (domain
));
2382 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
2385 if (symbol_lookup_debug
> 1)
2387 fprintf_unfiltered (gdb_stdlog
,
2388 "lookup_symbol_via_quick_fns (...) = NULL\n");
2393 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2394 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2395 result
.symbol
= block_lookup_symbol (block
, name
,
2396 symbol_name_match_type::FULL
, domain
);
2397 if (result
.symbol
== NULL
)
2398 error_in_psymtab_expansion (block_index
, name
, cust
);
2400 if (symbol_lookup_debug
> 1)
2402 fprintf_unfiltered (gdb_stdlog
,
2403 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2404 host_address_to_string (result
.symbol
),
2405 host_address_to_string (block
));
2408 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2409 result
.block
= block
;
2416 basic_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2418 const struct block
*block
,
2419 const domain_enum domain
)
2421 struct block_symbol result
;
2423 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2424 the current objfile. Searching the current objfile first is useful
2425 for both matching user expectations as well as performance. */
2427 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2428 if (result
.symbol
!= NULL
)
2431 /* If we didn't find a definition for a builtin type in the static block,
2432 search for it now. This is actually the right thing to do and can be
2433 a massive performance win. E.g., when debugging a program with lots of
2434 shared libraries we could search all of them only to find out the
2435 builtin type isn't defined in any of them. This is common for types
2437 if (domain
== VAR_DOMAIN
)
2439 struct gdbarch
*gdbarch
;
2442 gdbarch
= target_gdbarch ();
2444 gdbarch
= block_gdbarch (block
);
2445 result
.symbol
= language_lookup_primitive_type_as_symbol (langdef
,
2447 result
.block
= NULL
;
2448 if (result
.symbol
!= NULL
)
2452 return lookup_global_symbol (name
, block
, domain
);
2458 lookup_symbol_in_static_block (const char *name
,
2459 const struct block
*block
,
2460 const domain_enum domain
)
2462 const struct block
*static_block
= block_static_block (block
);
2465 if (static_block
== NULL
)
2468 if (symbol_lookup_debug
)
2470 struct objfile
*objfile
= lookup_objfile_from_block (static_block
);
2472 fprintf_unfiltered (gdb_stdlog
,
2473 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2476 host_address_to_string (block
),
2477 objfile_debug_name (objfile
),
2478 domain_name (domain
));
2481 sym
= lookup_symbol_in_block (name
,
2482 symbol_name_match_type::FULL
,
2483 static_block
, domain
);
2484 if (symbol_lookup_debug
)
2486 fprintf_unfiltered (gdb_stdlog
,
2487 "lookup_symbol_in_static_block (...) = %s\n",
2488 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
2490 return (struct block_symbol
) {sym
, static_block
};
2493 /* Perform the standard symbol lookup of NAME in OBJFILE:
2494 1) First search expanded symtabs, and if not found
2495 2) Search the "quick" symtabs (partial or .gdb_index).
2496 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2498 static struct block_symbol
2499 lookup_symbol_in_objfile (struct objfile
*objfile
, enum block_enum block_index
,
2500 const char *name
, const domain_enum domain
)
2502 struct block_symbol result
;
2504 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2506 if (symbol_lookup_debug
)
2508 fprintf_unfiltered (gdb_stdlog
,
2509 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2510 objfile_debug_name (objfile
),
2511 block_index
== GLOBAL_BLOCK
2512 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2513 name
, domain_name (domain
));
2516 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
2518 if (result
.symbol
!= NULL
)
2520 if (symbol_lookup_debug
)
2522 fprintf_unfiltered (gdb_stdlog
,
2523 "lookup_symbol_in_objfile (...) = %s"
2525 host_address_to_string (result
.symbol
));
2530 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
2532 if (symbol_lookup_debug
)
2534 fprintf_unfiltered (gdb_stdlog
,
2535 "lookup_symbol_in_objfile (...) = %s%s\n",
2536 result
.symbol
!= NULL
2537 ? host_address_to_string (result
.symbol
)
2539 result
.symbol
!= NULL
? " (via quick fns)" : "");
2544 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2546 struct global_or_static_sym_lookup_data
2548 /* The name of the symbol we are searching for. */
2551 /* The domain to use for our search. */
2554 /* The block index in which to search. */
2555 enum block_enum block_index
;
2557 /* The field where the callback should store the symbol if found.
2558 It should be initialized to {NULL, NULL} before the search is started. */
2559 struct block_symbol result
;
2562 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2563 It searches by name for a symbol in the block given by BLOCK_INDEX of the
2564 given OBJFILE. The arguments for the search are passed via CB_DATA, which
2565 in reality is a pointer to struct global_or_static_sym_lookup_data. */
2568 lookup_symbol_global_or_static_iterator_cb (struct objfile
*objfile
,
2571 struct global_or_static_sym_lookup_data
*data
=
2572 (struct global_or_static_sym_lookup_data
*) cb_data
;
2574 gdb_assert (data
->result
.symbol
== NULL
2575 && data
->result
.block
== NULL
);
2577 data
->result
= lookup_symbol_in_objfile (objfile
, data
->block_index
,
2578 data
->name
, data
->domain
);
2580 /* If we found a match, tell the iterator to stop. Otherwise,
2582 return (data
->result
.symbol
!= NULL
);
2585 /* This function contains the common code of lookup_{global,static}_symbol.
2586 OBJFILE is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is
2587 the objfile to start the lookup in. */
2589 static struct block_symbol
2590 lookup_global_or_static_symbol (const char *name
,
2591 enum block_enum block_index
,
2592 struct objfile
*objfile
,
2593 const domain_enum domain
)
2595 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2596 struct block_symbol result
;
2597 struct global_or_static_sym_lookup_data lookup_data
;
2598 struct block_symbol_cache
*bsc
;
2599 struct symbol_cache_slot
*slot
;
2601 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2602 gdb_assert (objfile
== nullptr || block_index
== GLOBAL_BLOCK
);
2604 /* First see if we can find the symbol in the cache.
2605 This works because we use the current objfile to qualify the lookup. */
2606 result
= symbol_cache_lookup (cache
, objfile
, block_index
, name
, domain
,
2608 if (result
.symbol
!= NULL
)
2610 if (SYMBOL_LOOKUP_FAILED_P (result
))
2615 /* Do a global search (of global blocks, heh). */
2616 if (result
.symbol
== NULL
)
2618 memset (&lookup_data
, 0, sizeof (lookup_data
));
2619 lookup_data
.name
= name
;
2620 lookup_data
.block_index
= block_index
;
2621 lookup_data
.domain
= domain
;
2622 gdbarch_iterate_over_objfiles_in_search_order
2623 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
2624 lookup_symbol_global_or_static_iterator_cb
, &lookup_data
, objfile
);
2625 result
= lookup_data
.result
;
2628 if (result
.symbol
!= NULL
)
2629 symbol_cache_mark_found (bsc
, slot
, objfile
, result
.symbol
, result
.block
);
2631 symbol_cache_mark_not_found (bsc
, slot
, objfile
, name
, domain
);
2639 lookup_static_symbol (const char *name
, const domain_enum domain
)
2641 return lookup_global_or_static_symbol (name
, STATIC_BLOCK
, nullptr, domain
);
2647 lookup_global_symbol (const char *name
,
2648 const struct block
*block
,
2649 const domain_enum domain
)
2651 /* If a block was passed in, we want to search the corresponding
2652 global block first. This yields "more expected" behavior, and is
2653 needed to support 'FILENAME'::VARIABLE lookups. */
2654 const struct block
*global_block
= block_global_block (block
);
2655 if (global_block
!= nullptr)
2657 symbol
*sym
= lookup_symbol_in_block (name
,
2658 symbol_name_match_type::FULL
,
2659 global_block
, domain
);
2661 return { sym
, global_block
};
2664 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2665 return lookup_global_or_static_symbol (name
, GLOBAL_BLOCK
, objfile
, domain
);
2669 symbol_matches_domain (enum language symbol_language
,
2670 domain_enum symbol_domain
,
2673 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2674 Similarly, any Ada type declaration implicitly defines a typedef. */
2675 if (symbol_language
== language_cplus
2676 || symbol_language
== language_d
2677 || symbol_language
== language_ada
2678 || symbol_language
== language_rust
)
2680 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
2681 && symbol_domain
== STRUCT_DOMAIN
)
2684 /* For all other languages, strict match is required. */
2685 return (symbol_domain
== domain
);
2691 lookup_transparent_type (const char *name
)
2693 return current_language
->la_lookup_transparent_type (name
);
2696 /* A helper for basic_lookup_transparent_type that interfaces with the
2697 "quick" symbol table functions. */
2699 static struct type
*
2700 basic_lookup_transparent_type_quick (struct objfile
*objfile
,
2701 enum block_enum block_index
,
2704 struct compunit_symtab
*cust
;
2705 const struct blockvector
*bv
;
2706 const struct block
*block
;
2711 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
2716 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2717 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2718 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2719 block_find_non_opaque_type
, NULL
);
2721 error_in_psymtab_expansion (block_index
, name
, cust
);
2722 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2723 return SYMBOL_TYPE (sym
);
2726 /* Subroutine of basic_lookup_transparent_type to simplify it.
2727 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2728 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2730 static struct type
*
2731 basic_lookup_transparent_type_1 (struct objfile
*objfile
,
2732 enum block_enum block_index
,
2735 const struct blockvector
*bv
;
2736 const struct block
*block
;
2737 const struct symbol
*sym
;
2739 for (compunit_symtab
*cust
: objfile
->compunits ())
2741 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2742 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2743 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2744 block_find_non_opaque_type
, NULL
);
2747 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2748 return SYMBOL_TYPE (sym
);
2755 /* The standard implementation of lookup_transparent_type. This code
2756 was modeled on lookup_symbol -- the parts not relevant to looking
2757 up types were just left out. In particular it's assumed here that
2758 types are available in STRUCT_DOMAIN and only in file-static or
2762 basic_lookup_transparent_type (const char *name
)
2766 /* Now search all the global symbols. Do the symtab's first, then
2767 check the psymtab's. If a psymtab indicates the existence
2768 of the desired name as a global, then do psymtab-to-symtab
2769 conversion on the fly and return the found symbol. */
2771 for (objfile
*objfile
: current_program_space
->objfiles ())
2773 t
= basic_lookup_transparent_type_1 (objfile
, GLOBAL_BLOCK
, name
);
2778 for (objfile
*objfile
: current_program_space
->objfiles ())
2780 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
2785 /* Now search the static file-level symbols.
2786 Not strictly correct, but more useful than an error.
2787 Do the symtab's first, then
2788 check the psymtab's. If a psymtab indicates the existence
2789 of the desired name as a file-level static, then do psymtab-to-symtab
2790 conversion on the fly and return the found symbol. */
2792 for (objfile
*objfile
: current_program_space
->objfiles ())
2794 t
= basic_lookup_transparent_type_1 (objfile
, STATIC_BLOCK
, name
);
2799 for (objfile
*objfile
: current_program_space
->objfiles ())
2801 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
2806 return (struct type
*) 0;
2812 iterate_over_symbols (const struct block
*block
,
2813 const lookup_name_info
&name
,
2814 const domain_enum domain
,
2815 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2817 struct block_iterator iter
;
2820 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2822 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2823 SYMBOL_DOMAIN (sym
), domain
))
2825 struct block_symbol block_sym
= {sym
, block
};
2827 if (!callback (&block_sym
))
2837 iterate_over_symbols_terminated
2838 (const struct block
*block
,
2839 const lookup_name_info
&name
,
2840 const domain_enum domain
,
2841 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2843 if (!iterate_over_symbols (block
, name
, domain
, callback
))
2845 struct block_symbol block_sym
= {nullptr, block
};
2846 return callback (&block_sym
);
2849 /* Find the compunit symtab associated with PC and SECTION.
2850 This will read in debug info as necessary. */
2852 struct compunit_symtab
*
2853 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2855 struct compunit_symtab
*best_cust
= NULL
;
2856 CORE_ADDR distance
= 0;
2857 struct bound_minimal_symbol msymbol
;
2859 /* If we know that this is not a text address, return failure. This is
2860 necessary because we loop based on the block's high and low code
2861 addresses, which do not include the data ranges, and because
2862 we call find_pc_sect_psymtab which has a similar restriction based
2863 on the partial_symtab's texthigh and textlow. */
2864 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2865 if (msymbol
.minsym
&& msymbol
.minsym
->data_p ())
2868 /* Search all symtabs for the one whose file contains our address, and which
2869 is the smallest of all the ones containing the address. This is designed
2870 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2871 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2872 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2874 This happens for native ecoff format, where code from included files
2875 gets its own symtab. The symtab for the included file should have
2876 been read in already via the dependency mechanism.
2877 It might be swifter to create several symtabs with the same name
2878 like xcoff does (I'm not sure).
2880 It also happens for objfiles that have their functions reordered.
2881 For these, the symtab we are looking for is not necessarily read in. */
2883 for (objfile
*obj_file
: current_program_space
->objfiles ())
2885 for (compunit_symtab
*cust
: obj_file
->compunits ())
2887 const struct block
*b
;
2888 const struct blockvector
*bv
;
2890 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2891 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2893 if (BLOCK_START (b
) <= pc
2894 && BLOCK_END (b
) > pc
2896 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2898 /* For an objfile that has its functions reordered,
2899 find_pc_psymtab will find the proper partial symbol table
2900 and we simply return its corresponding symtab. */
2901 /* In order to better support objfiles that contain both
2902 stabs and coff debugging info, we continue on if a psymtab
2904 if ((obj_file
->flags
& OBJF_REORDERED
) && obj_file
->sf
)
2906 struct compunit_symtab
*result
;
2909 = obj_file
->sf
->qf
->find_pc_sect_compunit_symtab (obj_file
,
2919 struct block_iterator iter
;
2920 struct symbol
*sym
= NULL
;
2922 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2924 fixup_symbol_section (sym
, obj_file
);
2925 if (matching_obj_sections (SYMBOL_OBJ_SECTION (obj_file
,
2931 continue; /* No symbol in this symtab matches
2934 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2940 if (best_cust
!= NULL
)
2943 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2945 for (objfile
*objf
: current_program_space
->objfiles ())
2947 struct compunit_symtab
*result
;
2951 result
= objf
->sf
->qf
->find_pc_sect_compunit_symtab (objf
,
2962 /* Find the compunit symtab associated with PC.
2963 This will read in debug info as necessary.
2964 Backward compatibility, no section. */
2966 struct compunit_symtab
*
2967 find_pc_compunit_symtab (CORE_ADDR pc
)
2969 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2975 find_symbol_at_address (CORE_ADDR address
)
2977 for (objfile
*objfile
: current_program_space
->objfiles ())
2979 if (objfile
->sf
== NULL
2980 || objfile
->sf
->qf
->find_compunit_symtab_by_address
== NULL
)
2983 struct compunit_symtab
*symtab
2984 = objfile
->sf
->qf
->find_compunit_symtab_by_address (objfile
, address
);
2987 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (symtab
);
2989 for (int i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; ++i
)
2991 const struct block
*b
= BLOCKVECTOR_BLOCK (bv
, i
);
2992 struct block_iterator iter
;
2995 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2997 if (SYMBOL_CLASS (sym
) == LOC_STATIC
2998 && SYMBOL_VALUE_ADDRESS (sym
) == address
)
3010 /* Find the source file and line number for a given PC value and SECTION.
3011 Return a structure containing a symtab pointer, a line number,
3012 and a pc range for the entire source line.
3013 The value's .pc field is NOT the specified pc.
3014 NOTCURRENT nonzero means, if specified pc is on a line boundary,
3015 use the line that ends there. Otherwise, in that case, the line
3016 that begins there is used. */
3018 /* The big complication here is that a line may start in one file, and end just
3019 before the start of another file. This usually occurs when you #include
3020 code in the middle of a subroutine. To properly find the end of a line's PC
3021 range, we must search all symtabs associated with this compilation unit, and
3022 find the one whose first PC is closer than that of the next line in this
3025 struct symtab_and_line
3026 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
3028 struct compunit_symtab
*cust
;
3029 struct linetable
*l
;
3031 struct linetable_entry
*item
;
3032 const struct blockvector
*bv
;
3033 struct bound_minimal_symbol msymbol
;
3035 /* Info on best line seen so far, and where it starts, and its file. */
3037 struct linetable_entry
*best
= NULL
;
3038 CORE_ADDR best_end
= 0;
3039 struct symtab
*best_symtab
= 0;
3041 /* Store here the first line number
3042 of a file which contains the line at the smallest pc after PC.
3043 If we don't find a line whose range contains PC,
3044 we will use a line one less than this,
3045 with a range from the start of that file to the first line's pc. */
3046 struct linetable_entry
*alt
= NULL
;
3048 /* Info on best line seen in this file. */
3050 struct linetable_entry
*prev
;
3052 /* If this pc is not from the current frame,
3053 it is the address of the end of a call instruction.
3054 Quite likely that is the start of the following statement.
3055 But what we want is the statement containing the instruction.
3056 Fudge the pc to make sure we get that. */
3058 /* It's tempting to assume that, if we can't find debugging info for
3059 any function enclosing PC, that we shouldn't search for line
3060 number info, either. However, GAS can emit line number info for
3061 assembly files --- very helpful when debugging hand-written
3062 assembly code. In such a case, we'd have no debug info for the
3063 function, but we would have line info. */
3068 /* elz: added this because this function returned the wrong
3069 information if the pc belongs to a stub (import/export)
3070 to call a shlib function. This stub would be anywhere between
3071 two functions in the target, and the line info was erroneously
3072 taken to be the one of the line before the pc. */
3074 /* RT: Further explanation:
3076 * We have stubs (trampolines) inserted between procedures.
3078 * Example: "shr1" exists in a shared library, and a "shr1" stub also
3079 * exists in the main image.
3081 * In the minimal symbol table, we have a bunch of symbols
3082 * sorted by start address. The stubs are marked as "trampoline",
3083 * the others appear as text. E.g.:
3085 * Minimal symbol table for main image
3086 * main: code for main (text symbol)
3087 * shr1: stub (trampoline symbol)
3088 * foo: code for foo (text symbol)
3090 * Minimal symbol table for "shr1" image:
3092 * shr1: code for shr1 (text symbol)
3095 * So the code below is trying to detect if we are in the stub
3096 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3097 * and if found, do the symbolization from the real-code address
3098 * rather than the stub address.
3100 * Assumptions being made about the minimal symbol table:
3101 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3102 * if we're really in the trampoline.s If we're beyond it (say
3103 * we're in "foo" in the above example), it'll have a closer
3104 * symbol (the "foo" text symbol for example) and will not
3105 * return the trampoline.
3106 * 2. lookup_minimal_symbol_text() will find a real text symbol
3107 * corresponding to the trampoline, and whose address will
3108 * be different than the trampoline address. I put in a sanity
3109 * check for the address being the same, to avoid an
3110 * infinite recursion.
3112 msymbol
= lookup_minimal_symbol_by_pc (pc
);
3113 if (msymbol
.minsym
!= NULL
)
3114 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
3116 struct bound_minimal_symbol mfunsym
3117 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
3120 if (mfunsym
.minsym
== NULL
)
3121 /* I eliminated this warning since it is coming out
3122 * in the following situation:
3123 * gdb shmain // test program with shared libraries
3124 * (gdb) break shr1 // function in shared lib
3125 * Warning: In stub for ...
3126 * In the above situation, the shared lib is not loaded yet,
3127 * so of course we can't find the real func/line info,
3128 * but the "break" still works, and the warning is annoying.
3129 * So I commented out the warning. RT */
3130 /* warning ("In stub for %s; unable to find real function/line info",
3131 SYMBOL_LINKAGE_NAME (msymbol)); */
3134 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
3135 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
3136 /* Avoid infinite recursion */
3137 /* See above comment about why warning is commented out. */
3138 /* warning ("In stub for %s; unable to find real function/line info",
3139 SYMBOL_LINKAGE_NAME (msymbol)); */
3143 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
3146 symtab_and_line val
;
3147 val
.pspace
= current_program_space
;
3149 cust
= find_pc_sect_compunit_symtab (pc
, section
);
3152 /* If no symbol information, return previous pc. */
3159 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3161 /* Look at all the symtabs that share this blockvector.
3162 They all have the same apriori range, that we found was right;
3163 but they have different line tables. */
3165 for (symtab
*iter_s
: compunit_filetabs (cust
))
3167 /* Find the best line in this symtab. */
3168 l
= SYMTAB_LINETABLE (iter_s
);
3174 /* I think len can be zero if the symtab lacks line numbers
3175 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3176 I'm not sure which, and maybe it depends on the symbol
3182 item
= l
->item
; /* Get first line info. */
3184 /* Is this file's first line closer than the first lines of other files?
3185 If so, record this file, and its first line, as best alternate. */
3186 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
3189 auto pc_compare
= [](const CORE_ADDR
& comp_pc
,
3190 const struct linetable_entry
& lhs
)->bool
3192 return comp_pc
< lhs
.pc
;
3195 struct linetable_entry
*first
= item
;
3196 struct linetable_entry
*last
= item
+ len
;
3197 item
= std::upper_bound (first
, last
, pc
, pc_compare
);
3199 prev
= item
- 1; /* Found a matching item. */
3201 /* At this point, prev points at the line whose start addr is <= pc, and
3202 item points at the next line. If we ran off the end of the linetable
3203 (pc >= start of the last line), then prev == item. If pc < start of
3204 the first line, prev will not be set. */
3206 /* Is this file's best line closer than the best in the other files?
3207 If so, record this file, and its best line, as best so far. Don't
3208 save prev if it represents the end of a function (i.e. line number
3209 0) instead of a real line. */
3211 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
3214 best_symtab
= iter_s
;
3216 /* Discard BEST_END if it's before the PC of the current BEST. */
3217 if (best_end
<= best
->pc
)
3221 /* If another line (denoted by ITEM) is in the linetable and its
3222 PC is after BEST's PC, but before the current BEST_END, then
3223 use ITEM's PC as the new best_end. */
3224 if (best
&& item
< last
&& item
->pc
> best
->pc
3225 && (best_end
== 0 || best_end
> item
->pc
))
3226 best_end
= item
->pc
;
3231 /* If we didn't find any line number info, just return zeros.
3232 We used to return alt->line - 1 here, but that could be
3233 anywhere; if we don't have line number info for this PC,
3234 don't make some up. */
3237 else if (best
->line
== 0)
3239 /* If our best fit is in a range of PC's for which no line
3240 number info is available (line number is zero) then we didn't
3241 find any valid line information. */
3246 val
.symtab
= best_symtab
;
3247 val
.line
= best
->line
;
3249 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
3254 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3256 val
.section
= section
;
3260 /* Backward compatibility (no section). */
3262 struct symtab_and_line
3263 find_pc_line (CORE_ADDR pc
, int notcurrent
)
3265 struct obj_section
*section
;
3267 section
= find_pc_overlay (pc
);
3268 if (pc_in_unmapped_range (pc
, section
))
3269 pc
= overlay_mapped_address (pc
, section
);
3270 return find_pc_sect_line (pc
, section
, notcurrent
);
3276 find_pc_line_symtab (CORE_ADDR pc
)
3278 struct symtab_and_line sal
;
3280 /* This always passes zero for NOTCURRENT to find_pc_line.
3281 There are currently no callers that ever pass non-zero. */
3282 sal
= find_pc_line (pc
, 0);
3286 /* Find line number LINE in any symtab whose name is the same as
3289 If found, return the symtab that contains the linetable in which it was
3290 found, set *INDEX to the index in the linetable of the best entry
3291 found, and set *EXACT_MATCH to true if the value returned is an
3294 If not found, return NULL. */
3297 find_line_symtab (struct symtab
*sym_tab
, int line
,
3298 int *index
, bool *exact_match
)
3300 int exact
= 0; /* Initialized here to avoid a compiler warning. */
3302 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3306 struct linetable
*best_linetable
;
3307 struct symtab
*best_symtab
;
3309 /* First try looking it up in the given symtab. */
3310 best_linetable
= SYMTAB_LINETABLE (sym_tab
);
3311 best_symtab
= sym_tab
;
3312 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
3313 if (best_index
< 0 || !exact
)
3315 /* Didn't find an exact match. So we better keep looking for
3316 another symtab with the same name. In the case of xcoff,
3317 multiple csects for one source file (produced by IBM's FORTRAN
3318 compiler) produce multiple symtabs (this is unavoidable
3319 assuming csects can be at arbitrary places in memory and that
3320 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3322 /* BEST is the smallest linenumber > LINE so far seen,
3323 or 0 if none has been seen so far.
3324 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3327 if (best_index
>= 0)
3328 best
= best_linetable
->item
[best_index
].line
;
3332 for (objfile
*objfile
: current_program_space
->objfiles ())
3335 objfile
->sf
->qf
->expand_symtabs_with_fullname
3336 (objfile
, symtab_to_fullname (sym_tab
));
3339 for (objfile
*objfile
: current_program_space
->objfiles ())
3341 for (compunit_symtab
*cu
: objfile
->compunits ())
3343 for (symtab
*s
: compunit_filetabs (cu
))
3345 struct linetable
*l
;
3348 if (FILENAME_CMP (sym_tab
->filename
, s
->filename
) != 0)
3350 if (FILENAME_CMP (symtab_to_fullname (sym_tab
),
3351 symtab_to_fullname (s
)) != 0)
3353 l
= SYMTAB_LINETABLE (s
);
3354 ind
= find_line_common (l
, line
, &exact
, 0);
3364 if (best
== 0 || l
->item
[ind
].line
< best
)
3366 best
= l
->item
[ind
].line
;
3381 *index
= best_index
;
3383 *exact_match
= (exact
!= 0);
3388 /* Given SYMTAB, returns all the PCs function in the symtab that
3389 exactly match LINE. Returns an empty vector if there are no exact
3390 matches, but updates BEST_ITEM in this case. */
3392 std::vector
<CORE_ADDR
>
3393 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
3394 struct linetable_entry
**best_item
)
3397 std::vector
<CORE_ADDR
> result
;
3399 /* First, collect all the PCs that are at this line. */
3405 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
3412 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
3414 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
3420 result
.push_back (SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
3428 /* Set the PC value for a given source file and line number and return true.
3429 Returns false for invalid line number (and sets the PC to 0).
3430 The source file is specified with a struct symtab. */
3433 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
3435 struct linetable
*l
;
3442 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
3445 l
= SYMTAB_LINETABLE (symtab
);
3446 *pc
= l
->item
[ind
].pc
;
3453 /* Find the range of pc values in a line.
3454 Store the starting pc of the line into *STARTPTR
3455 and the ending pc (start of next line) into *ENDPTR.
3456 Returns true to indicate success.
3457 Returns false if could not find the specified line. */
3460 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
3463 CORE_ADDR startaddr
;
3464 struct symtab_and_line found_sal
;
3467 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
3470 /* This whole function is based on address. For example, if line 10 has
3471 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3472 "info line *0x123" should say the line goes from 0x100 to 0x200
3473 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3474 This also insures that we never give a range like "starts at 0x134
3475 and ends at 0x12c". */
3477 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
3478 if (found_sal
.line
!= sal
.line
)
3480 /* The specified line (sal) has zero bytes. */
3481 *startptr
= found_sal
.pc
;
3482 *endptr
= found_sal
.pc
;
3486 *startptr
= found_sal
.pc
;
3487 *endptr
= found_sal
.end
;
3492 /* Given a line table and a line number, return the index into the line
3493 table for the pc of the nearest line whose number is >= the specified one.
3494 Return -1 if none is found. The value is >= 0 if it is an index.
3495 START is the index at which to start searching the line table.
3497 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3500 find_line_common (struct linetable
*l
, int lineno
,
3501 int *exact_match
, int start
)
3506 /* BEST is the smallest linenumber > LINENO so far seen,
3507 or 0 if none has been seen so far.
3508 BEST_INDEX identifies the item for it. */
3510 int best_index
= -1;
3521 for (i
= start
; i
< len
; i
++)
3523 struct linetable_entry
*item
= &(l
->item
[i
]);
3525 if (item
->line
== lineno
)
3527 /* Return the first (lowest address) entry which matches. */
3532 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
3539 /* If we got here, we didn't get an exact match. */
3544 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
3546 struct symtab_and_line sal
;
3548 sal
= find_pc_line (pc
, 0);
3551 return sal
.symtab
!= 0;
3554 /* Helper for find_function_start_sal. Does most of the work, except
3555 setting the sal's symbol. */
3557 static symtab_and_line
3558 find_function_start_sal_1 (CORE_ADDR func_addr
, obj_section
*section
,
3561 symtab_and_line sal
= find_pc_sect_line (func_addr
, section
, 0);
3563 if (funfirstline
&& sal
.symtab
!= NULL
3564 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal
.symtab
))
3565 || SYMTAB_LANGUAGE (sal
.symtab
) == language_asm
))
3567 struct gdbarch
*gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
3570 if (gdbarch_skip_entrypoint_p (gdbarch
))
3571 sal
.pc
= gdbarch_skip_entrypoint (gdbarch
, sal
.pc
);
3575 /* We always should have a line for the function start address.
3576 If we don't, something is odd. Create a plain SAL referring
3577 just the PC and hope that skip_prologue_sal (if requested)
3578 can find a line number for after the prologue. */
3579 if (sal
.pc
< func_addr
)
3582 sal
.pspace
= current_program_space
;
3584 sal
.section
= section
;
3588 skip_prologue_sal (&sal
);
3596 find_function_start_sal (CORE_ADDR func_addr
, obj_section
*section
,
3600 = find_function_start_sal_1 (func_addr
, section
, funfirstline
);
3602 /* find_function_start_sal_1 does a linetable search, so it finds
3603 the symtab and linenumber, but not a symbol. Fill in the
3604 function symbol too. */
3605 sal
.symbol
= find_pc_sect_containing_function (sal
.pc
, sal
.section
);
3613 find_function_start_sal (symbol
*sym
, bool funfirstline
)
3615 fixup_symbol_section (sym
, NULL
);
3617 = find_function_start_sal_1 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)),
3618 SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
),
3625 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3626 address for that function that has an entry in SYMTAB's line info
3627 table. If such an entry cannot be found, return FUNC_ADDR
3631 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
3633 CORE_ADDR func_start
, func_end
;
3634 struct linetable
*l
;
3637 /* Give up if this symbol has no lineinfo table. */
3638 l
= SYMTAB_LINETABLE (symtab
);
3642 /* Get the range for the function's PC values, or give up if we
3643 cannot, for some reason. */
3644 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
3647 /* Linetable entries are ordered by PC values, see the commentary in
3648 symtab.h where `struct linetable' is defined. Thus, the first
3649 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3650 address we are looking for. */
3651 for (i
= 0; i
< l
->nitems
; i
++)
3653 struct linetable_entry
*item
= &(l
->item
[i
]);
3655 /* Don't use line numbers of zero, they mark special entries in
3656 the table. See the commentary on symtab.h before the
3657 definition of struct linetable. */
3658 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
3665 /* Adjust SAL to the first instruction past the function prologue.
3666 If the PC was explicitly specified, the SAL is not changed.
3667 If the line number was explicitly specified then the SAL can still be
3668 updated, unless the language for SAL is assembler, in which case the SAL
3669 will be left unchanged.
3670 If SAL is already past the prologue, then do nothing. */
3673 skip_prologue_sal (struct symtab_and_line
*sal
)
3676 struct symtab_and_line start_sal
;
3677 CORE_ADDR pc
, saved_pc
;
3678 struct obj_section
*section
;
3680 struct objfile
*objfile
;
3681 struct gdbarch
*gdbarch
;
3682 const struct block
*b
, *function_block
;
3683 int force_skip
, skip
;
3685 /* Do not change the SAL if PC was specified explicitly. */
3686 if (sal
->explicit_pc
)
3689 /* In assembly code, if the user asks for a specific line then we should
3690 not adjust the SAL. The user already has instruction level
3691 visibility in this case, so selecting a line other than one requested
3692 is likely to be the wrong choice. */
3693 if (sal
->symtab
!= nullptr
3694 && sal
->explicit_line
3695 && SYMTAB_LANGUAGE (sal
->symtab
) == language_asm
)
3698 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3700 switch_to_program_space_and_thread (sal
->pspace
);
3702 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
3705 fixup_symbol_section (sym
, NULL
);
3707 objfile
= symbol_objfile (sym
);
3708 pc
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
3709 section
= SYMBOL_OBJ_SECTION (objfile
, sym
);
3710 name
= SYMBOL_LINKAGE_NAME (sym
);
3714 struct bound_minimal_symbol msymbol
3715 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
3717 if (msymbol
.minsym
== NULL
)
3720 objfile
= msymbol
.objfile
;
3721 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
3722 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
3723 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
3726 gdbarch
= get_objfile_arch (objfile
);
3728 /* Process the prologue in two passes. In the first pass try to skip the
3729 prologue (SKIP is true) and verify there is a real need for it (indicated
3730 by FORCE_SKIP). If no such reason was found run a second pass where the
3731 prologue is not skipped (SKIP is false). */
3736 /* Be conservative - allow direct PC (without skipping prologue) only if we
3737 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3738 have to be set by the caller so we use SYM instead. */
3740 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym
))))
3748 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3749 so that gdbarch_skip_prologue has something unique to work on. */
3750 if (section_is_overlay (section
) && !section_is_mapped (section
))
3751 pc
= overlay_unmapped_address (pc
, section
);
3753 /* Skip "first line" of function (which is actually its prologue). */
3754 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3755 if (gdbarch_skip_entrypoint_p (gdbarch
))
3756 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
3758 pc
= gdbarch_skip_prologue_noexcept (gdbarch
, pc
);
3760 /* For overlays, map pc back into its mapped VMA range. */
3761 pc
= overlay_mapped_address (pc
, section
);
3763 /* Calculate line number. */
3764 start_sal
= find_pc_sect_line (pc
, section
, 0);
3766 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3767 line is still part of the same function. */
3768 if (skip
&& start_sal
.pc
!= pc
3769 && (sym
? (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
3770 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
3771 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
3772 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
3774 /* First pc of next line */
3776 /* Recalculate the line number (might not be N+1). */
3777 start_sal
= find_pc_sect_line (pc
, section
, 0);
3780 /* On targets with executable formats that don't have a concept of
3781 constructors (ELF with .init has, PE doesn't), gcc emits a call
3782 to `__main' in `main' between the prologue and before user
3784 if (gdbarch_skip_main_prologue_p (gdbarch
)
3785 && name
&& strcmp_iw (name
, "main") == 0)
3787 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
3788 /* Recalculate the line number (might not be N+1). */
3789 start_sal
= find_pc_sect_line (pc
, section
, 0);
3793 while (!force_skip
&& skip
--);
3795 /* If we still don't have a valid source line, try to find the first
3796 PC in the lineinfo table that belongs to the same function. This
3797 happens with COFF debug info, which does not seem to have an
3798 entry in lineinfo table for the code after the prologue which has
3799 no direct relation to source. For example, this was found to be
3800 the case with the DJGPP target using "gcc -gcoff" when the
3801 compiler inserted code after the prologue to make sure the stack
3803 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
3805 pc
= skip_prologue_using_lineinfo (pc
, symbol_symtab (sym
));
3806 /* Recalculate the line number. */
3807 start_sal
= find_pc_sect_line (pc
, section
, 0);
3810 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3811 forward SAL to the end of the prologue. */
3816 sal
->section
= section
;
3817 sal
->symtab
= start_sal
.symtab
;
3818 sal
->line
= start_sal
.line
;
3819 sal
->end
= start_sal
.end
;
3821 /* Check if we are now inside an inlined function. If we can,
3822 use the call site of the function instead. */
3823 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
3824 function_block
= NULL
;
3827 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
3829 else if (BLOCK_FUNCTION (b
) != NULL
)
3831 b
= BLOCK_SUPERBLOCK (b
);
3833 if (function_block
!= NULL
3834 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
3836 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
3837 sal
->symtab
= symbol_symtab (BLOCK_FUNCTION (function_block
));
3841 /* Given PC at the function's start address, attempt to find the
3842 prologue end using SAL information. Return zero if the skip fails.
3844 A non-optimized prologue traditionally has one SAL for the function
3845 and a second for the function body. A single line function has
3846 them both pointing at the same line.
3848 An optimized prologue is similar but the prologue may contain
3849 instructions (SALs) from the instruction body. Need to skip those
3850 while not getting into the function body.
3852 The functions end point and an increasing SAL line are used as
3853 indicators of the prologue's endpoint.
3855 This code is based on the function refine_prologue_limit
3859 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
3861 struct symtab_and_line prologue_sal
;
3864 const struct block
*bl
;
3866 /* Get an initial range for the function. */
3867 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
3868 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3870 prologue_sal
= find_pc_line (start_pc
, 0);
3871 if (prologue_sal
.line
!= 0)
3873 /* For languages other than assembly, treat two consecutive line
3874 entries at the same address as a zero-instruction prologue.
3875 The GNU assembler emits separate line notes for each instruction
3876 in a multi-instruction macro, but compilers generally will not
3878 if (prologue_sal
.symtab
->language
!= language_asm
)
3880 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
3883 /* Skip any earlier lines, and any end-of-sequence marker
3884 from a previous function. */
3885 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
3886 || linetable
->item
[idx
].line
== 0)
3889 if (idx
+1 < linetable
->nitems
3890 && linetable
->item
[idx
+1].line
!= 0
3891 && linetable
->item
[idx
+1].pc
== start_pc
)
3895 /* If there is only one sal that covers the entire function,
3896 then it is probably a single line function, like
3898 if (prologue_sal
.end
>= end_pc
)
3901 while (prologue_sal
.end
< end_pc
)
3903 struct symtab_and_line sal
;
3905 sal
= find_pc_line (prologue_sal
.end
, 0);
3908 /* Assume that a consecutive SAL for the same (or larger)
3909 line mark the prologue -> body transition. */
3910 if (sal
.line
>= prologue_sal
.line
)
3912 /* Likewise if we are in a different symtab altogether
3913 (e.g. within a file included via #include). */
3914 if (sal
.symtab
!= prologue_sal
.symtab
)
3917 /* The line number is smaller. Check that it's from the
3918 same function, not something inlined. If it's inlined,
3919 then there is no point comparing the line numbers. */
3920 bl
= block_for_pc (prologue_sal
.end
);
3923 if (block_inlined_p (bl
))
3925 if (BLOCK_FUNCTION (bl
))
3930 bl
= BLOCK_SUPERBLOCK (bl
);
3935 /* The case in which compiler's optimizer/scheduler has
3936 moved instructions into the prologue. We look ahead in
3937 the function looking for address ranges whose
3938 corresponding line number is less the first one that we
3939 found for the function. This is more conservative then
3940 refine_prologue_limit which scans a large number of SALs
3941 looking for any in the prologue. */
3946 if (prologue_sal
.end
< end_pc
)
3947 /* Return the end of this line, or zero if we could not find a
3949 return prologue_sal
.end
;
3951 /* Don't return END_PC, which is past the end of the function. */
3952 return prologue_sal
.pc
;
3958 find_function_alias_target (bound_minimal_symbol msymbol
)
3960 CORE_ADDR func_addr
;
3961 if (!msymbol_is_function (msymbol
.objfile
, msymbol
.minsym
, &func_addr
))
3964 symbol
*sym
= find_pc_function (func_addr
);
3966 && SYMBOL_CLASS (sym
) == LOC_BLOCK
3967 && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) == func_addr
)
3974 /* If P is of the form "operator[ \t]+..." where `...' is
3975 some legitimate operator text, return a pointer to the
3976 beginning of the substring of the operator text.
3977 Otherwise, return "". */
3980 operator_chars (const char *p
, const char **end
)
3983 if (!startswith (p
, CP_OPERATOR_STR
))
3985 p
+= CP_OPERATOR_LEN
;
3987 /* Don't get faked out by `operator' being part of a longer
3989 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
3992 /* Allow some whitespace between `operator' and the operator symbol. */
3993 while (*p
== ' ' || *p
== '\t')
3996 /* Recognize 'operator TYPENAME'. */
3998 if (isalpha (*p
) || *p
== '_' || *p
== '$')
4000 const char *q
= p
+ 1;
4002 while (isalnum (*q
) || *q
== '_' || *q
== '$')
4011 case '\\': /* regexp quoting */
4014 if (p
[2] == '=') /* 'operator\*=' */
4016 else /* 'operator\*' */
4020 else if (p
[1] == '[')
4023 error (_("mismatched quoting on brackets, "
4024 "try 'operator\\[\\]'"));
4025 else if (p
[2] == '\\' && p
[3] == ']')
4027 *end
= p
+ 4; /* 'operator\[\]' */
4031 error (_("nothing is allowed between '[' and ']'"));
4035 /* Gratuitous quote: skip it and move on. */
4057 if (p
[0] == '-' && p
[1] == '>')
4059 /* Struct pointer member operator 'operator->'. */
4062 *end
= p
+ 3; /* 'operator->*' */
4065 else if (p
[2] == '\\')
4067 *end
= p
+ 4; /* Hopefully 'operator->\*' */
4072 *end
= p
+ 2; /* 'operator->' */
4076 if (p
[1] == '=' || p
[1] == p
[0])
4087 error (_("`operator ()' must be specified "
4088 "without whitespace in `()'"));
4093 error (_("`operator ?:' must be specified "
4094 "without whitespace in `?:'"));
4099 error (_("`operator []' must be specified "
4100 "without whitespace in `[]'"));
4104 error (_("`operator %s' not supported"), p
);
4113 /* What part to match in a file name. */
4115 struct filename_partial_match_opts
4117 /* Only match the directory name part. */
4118 bool dirname
= false;
4120 /* Only match the basename part. */
4121 bool basename
= false;
4124 /* Data structure to maintain printing state for output_source_filename. */
4126 struct output_source_filename_data
4128 /* Output only filenames matching REGEXP. */
4130 gdb::optional
<compiled_regex
> c_regexp
;
4131 /* Possibly only match a part of the filename. */
4132 filename_partial_match_opts partial_match
;
4135 /* Cache of what we've seen so far. */
4136 struct filename_seen_cache
*filename_seen_cache
;
4138 /* Flag of whether we're printing the first one. */
4142 /* Slave routine for sources_info. Force line breaks at ,'s.
4143 NAME is the name to print.
4144 DATA contains the state for printing and watching for duplicates. */
4147 output_source_filename (const char *name
,
4148 struct output_source_filename_data
*data
)
4150 /* Since a single source file can result in several partial symbol
4151 tables, we need to avoid printing it more than once. Note: if
4152 some of the psymtabs are read in and some are not, it gets
4153 printed both under "Source files for which symbols have been
4154 read" and "Source files for which symbols will be read in on
4155 demand". I consider this a reasonable way to deal with the
4156 situation. I'm not sure whether this can also happen for
4157 symtabs; it doesn't hurt to check. */
4159 /* Was NAME already seen? */
4160 if (data
->filename_seen_cache
->seen (name
))
4162 /* Yes; don't print it again. */
4166 /* Does it match data->regexp? */
4167 if (data
->c_regexp
.has_value ())
4169 const char *to_match
;
4170 std::string dirname
;
4172 if (data
->partial_match
.dirname
)
4174 dirname
= ldirname (name
);
4175 to_match
= dirname
.c_str ();
4177 else if (data
->partial_match
.basename
)
4178 to_match
= lbasename (name
);
4182 if (data
->c_regexp
->exec (to_match
, 0, NULL
, 0) != 0)
4186 /* Print it and reset *FIRST. */
4188 printf_filtered (", ");
4192 fputs_styled (name
, file_name_style
.style (), gdb_stdout
);
4195 /* A callback for map_partial_symbol_filenames. */
4198 output_partial_symbol_filename (const char *filename
, const char *fullname
,
4201 output_source_filename (fullname
? fullname
: filename
,
4202 (struct output_source_filename_data
*) data
);
4205 using isrc_flag_option_def
4206 = gdb::option::flag_option_def
<filename_partial_match_opts
>;
4208 static const gdb::option::option_def info_sources_option_defs
[] = {
4210 isrc_flag_option_def
{
4212 [] (filename_partial_match_opts
*opts
) { return &opts
->dirname
; },
4213 N_("Show only the files having a dirname matching REGEXP."),
4216 isrc_flag_option_def
{
4218 [] (filename_partial_match_opts
*opts
) { return &opts
->basename
; },
4219 N_("Show only the files having a basename matching REGEXP."),
4224 /* Create an option_def_group for the "info sources" options, with
4225 ISRC_OPTS as context. */
4227 static inline gdb::option::option_def_group
4228 make_info_sources_options_def_group (filename_partial_match_opts
*isrc_opts
)
4230 return {{info_sources_option_defs
}, isrc_opts
};
4233 /* Prints the header message for the source files that will be printed
4234 with the matching info present in DATA. SYMBOL_MSG is a message
4235 that tells what will or has been done with the symbols of the
4236 matching source files. */
4239 print_info_sources_header (const char *symbol_msg
,
4240 const struct output_source_filename_data
*data
)
4242 puts_filtered (symbol_msg
);
4243 if (!data
->regexp
.empty ())
4245 if (data
->partial_match
.dirname
)
4246 printf_filtered (_("(dirname matching regular expression \"%s\")"),
4247 data
->regexp
.c_str ());
4248 else if (data
->partial_match
.basename
)
4249 printf_filtered (_("(basename matching regular expression \"%s\")"),
4250 data
->regexp
.c_str ());
4252 printf_filtered (_("(filename matching regular expression \"%s\")"),
4253 data
->regexp
.c_str ());
4255 puts_filtered ("\n");
4258 /* Completer for "info sources". */
4261 info_sources_command_completer (cmd_list_element
*ignore
,
4262 completion_tracker
&tracker
,
4263 const char *text
, const char *word
)
4265 const auto group
= make_info_sources_options_def_group (nullptr);
4266 if (gdb::option::complete_options
4267 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
4272 info_sources_command (const char *args
, int from_tty
)
4274 struct output_source_filename_data data
;
4276 if (!have_full_symbols () && !have_partial_symbols ())
4278 error (_("No symbol table is loaded. Use the \"file\" command."));
4281 filename_seen_cache filenames_seen
;
4283 auto group
= make_info_sources_options_def_group (&data
.partial_match
);
4285 gdb::option::process_options
4286 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
4288 if (args
!= NULL
&& *args
!= '\000')
4291 data
.filename_seen_cache
= &filenames_seen
;
4294 if (data
.partial_match
.dirname
&& data
.partial_match
.basename
)
4295 error (_("You cannot give both -basename and -dirname to 'info sources'."));
4296 if ((data
.partial_match
.dirname
|| data
.partial_match
.basename
)
4297 && data
.regexp
.empty ())
4298 error (_("Missing REGEXP for 'info sources'."));
4300 if (data
.regexp
.empty ())
4301 data
.c_regexp
.reset ();
4304 int cflags
= REG_NOSUB
;
4305 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
4306 cflags
|= REG_ICASE
;
4308 data
.c_regexp
.emplace (data
.regexp
.c_str (), cflags
,
4309 _("Invalid regexp"));
4312 print_info_sources_header
4313 (_("Source files for which symbols have been read in:\n"), &data
);
4315 for (objfile
*objfile
: current_program_space
->objfiles ())
4317 for (compunit_symtab
*cu
: objfile
->compunits ())
4319 for (symtab
*s
: compunit_filetabs (cu
))
4321 const char *fullname
= symtab_to_fullname (s
);
4323 output_source_filename (fullname
, &data
);
4327 printf_filtered ("\n\n");
4329 print_info_sources_header
4330 (_("Source files for which symbols will be read in on demand:\n"), &data
);
4332 filenames_seen
.clear ();
4334 map_symbol_filenames (output_partial_symbol_filename
, &data
,
4335 1 /*need_fullname*/);
4336 printf_filtered ("\n");
4339 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4340 non-zero compare only lbasename of FILES. */
4343 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
4347 if (file
!= NULL
&& nfiles
!= 0)
4349 for (i
= 0; i
< nfiles
; i
++)
4351 if (compare_filenames_for_search (file
, (basenames
4352 ? lbasename (files
[i
])
4357 else if (nfiles
== 0)
4362 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4363 sort symbols, not minimal symbols. */
4366 symbol_search::compare_search_syms (const symbol_search
&sym_a
,
4367 const symbol_search
&sym_b
)
4371 c
= FILENAME_CMP (symbol_symtab (sym_a
.symbol
)->filename
,
4372 symbol_symtab (sym_b
.symbol
)->filename
);
4376 if (sym_a
.block
!= sym_b
.block
)
4377 return sym_a
.block
- sym_b
.block
;
4379 return strcmp (SYMBOL_PRINT_NAME (sym_a
.symbol
),
4380 SYMBOL_PRINT_NAME (sym_b
.symbol
));
4383 /* Returns true if the type_name of symbol_type of SYM matches TREG.
4384 If SYM has no symbol_type or symbol_name, returns false. */
4387 treg_matches_sym_type_name (const compiled_regex
&treg
,
4388 const struct symbol
*sym
)
4390 struct type
*sym_type
;
4391 std::string printed_sym_type_name
;
4393 if (symbol_lookup_debug
> 1)
4395 fprintf_unfiltered (gdb_stdlog
,
4396 "treg_matches_sym_type_name\n sym %s\n",
4397 SYMBOL_NATURAL_NAME (sym
));
4400 sym_type
= SYMBOL_TYPE (sym
);
4401 if (sym_type
== NULL
)
4405 scoped_switch_to_sym_language_if_auto
l (sym
);
4407 printed_sym_type_name
= type_to_string (sym_type
);
4411 if (symbol_lookup_debug
> 1)
4413 fprintf_unfiltered (gdb_stdlog
,
4414 " sym_type_name %s\n",
4415 printed_sym_type_name
.c_str ());
4419 if (printed_sym_type_name
.empty ())
4422 return treg
.exec (printed_sym_type_name
.c_str (), 0, NULL
, 0) == 0;
4426 /* Sort the symbols in RESULT and remove duplicates. */
4429 sort_search_symbols_remove_dups (std::vector
<symbol_search
> *result
)
4431 std::sort (result
->begin (), result
->end ());
4432 result
->erase (std::unique (result
->begin (), result
->end ()),
4436 /* Search the symbol table for matches to the regular expression REGEXP,
4437 returning the results.
4439 Only symbols of KIND are searched:
4440 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4441 and constants (enums).
4442 if T_REGEXP is not NULL, only returns var that have
4443 a type matching regular expression T_REGEXP.
4444 FUNCTIONS_DOMAIN - search all functions
4445 TYPES_DOMAIN - search all type names
4446 ALL_DOMAIN - an internal error for this function
4448 Within each file the results are sorted locally; each symtab's global and
4449 static blocks are separately alphabetized.
4450 Duplicate entries are removed.
4452 When EXCLUDE_MINSYMS is false then matching minsyms are also returned,
4453 otherwise they are excluded. */
4455 std::vector
<symbol_search
>
4456 search_symbols (const char *regexp
, enum search_domain kind
,
4457 const char *t_regexp
,
4458 int nfiles
, const char *files
[],
4459 bool exclude_minsyms
)
4461 const struct blockvector
*bv
;
4462 const struct block
*b
;
4464 struct block_iterator iter
;
4467 static const enum minimal_symbol_type types
[]
4468 = {mst_data
, mst_text
, mst_unknown
};
4469 static const enum minimal_symbol_type types2
[]
4470 = {mst_bss
, mst_file_text
, mst_unknown
};
4471 static const enum minimal_symbol_type types3
[]
4472 = {mst_file_data
, mst_solib_trampoline
, mst_unknown
};
4473 static const enum minimal_symbol_type types4
[]
4474 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_unknown
};
4475 enum minimal_symbol_type ourtype
;
4476 enum minimal_symbol_type ourtype2
;
4477 enum minimal_symbol_type ourtype3
;
4478 enum minimal_symbol_type ourtype4
;
4479 std::vector
<symbol_search
> result
;
4480 gdb::optional
<compiled_regex
> preg
;
4481 gdb::optional
<compiled_regex
> treg
;
4483 gdb_assert (kind
<= TYPES_DOMAIN
);
4485 ourtype
= types
[kind
];
4486 ourtype2
= types2
[kind
];
4487 ourtype3
= types3
[kind
];
4488 ourtype4
= types4
[kind
];
4492 /* Make sure spacing is right for C++ operators.
4493 This is just a courtesy to make the matching less sensitive
4494 to how many spaces the user leaves between 'operator'
4495 and <TYPENAME> or <OPERATOR>. */
4497 const char *opname
= operator_chars (regexp
, &opend
);
4501 int fix
= -1; /* -1 means ok; otherwise number of
4504 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
4506 /* There should 1 space between 'operator' and 'TYPENAME'. */
4507 if (opname
[-1] != ' ' || opname
[-2] == ' ')
4512 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4513 if (opname
[-1] == ' ')
4516 /* If wrong number of spaces, fix it. */
4519 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
4521 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
4526 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4528 preg
.emplace (regexp
, cflags
, _("Invalid regexp"));
4531 if (t_regexp
!= NULL
)
4533 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4535 treg
.emplace (t_regexp
, cflags
, _("Invalid regexp"));
4538 /* Search through the partial symtabs *first* for all symbols
4539 matching the regexp. That way we don't have to reproduce all of
4540 the machinery below. */
4541 expand_symtabs_matching ([&] (const char *filename
, bool basenames
)
4543 return file_matches (filename
, files
, nfiles
,
4546 lookup_name_info::match_any (),
4547 [&] (const char *symname
)
4549 return (!preg
.has_value ()
4550 || preg
->exec (symname
,
4556 /* Here, we search through the minimal symbol tables for functions
4557 and variables that match, and force their symbols to be read.
4558 This is in particular necessary for demangled variable names,
4559 which are no longer put into the partial symbol tables.
4560 The symbol will then be found during the scan of symtabs below.
4562 For functions, find_pc_symtab should succeed if we have debug info
4563 for the function, for variables we have to call
4564 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4566 If the lookup fails, set found_misc so that we will rescan to print
4567 any matching symbols without debug info.
4568 We only search the objfile the msymbol came from, we no longer search
4569 all objfiles. In large programs (1000s of shared libs) searching all
4570 objfiles is not worth the pain. */
4572 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
4574 for (objfile
*objfile
: current_program_space
->objfiles ())
4576 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
4580 if (msymbol
->created_by_gdb
)
4583 if (MSYMBOL_TYPE (msymbol
) == ourtype
4584 || MSYMBOL_TYPE (msymbol
) == ourtype2
4585 || MSYMBOL_TYPE (msymbol
) == ourtype3
4586 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4588 if (!preg
.has_value ()
4589 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4592 /* Note: An important side-effect of these
4593 lookup functions is to expand the symbol
4594 table if msymbol is found, for the benefit of
4595 the next loop on compunits. */
4596 if (kind
== FUNCTIONS_DOMAIN
4597 ? (find_pc_compunit_symtab
4598 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4600 : (lookup_symbol_in_objfile_from_linkage_name
4601 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4611 for (objfile
*objfile
: current_program_space
->objfiles ())
4613 for (compunit_symtab
*cust
: objfile
->compunits ())
4615 bv
= COMPUNIT_BLOCKVECTOR (cust
);
4616 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
4618 b
= BLOCKVECTOR_BLOCK (bv
, i
);
4619 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4621 struct symtab
*real_symtab
= symbol_symtab (sym
);
4625 /* Check first sole REAL_SYMTAB->FILENAME. It does
4626 not need to be a substring of symtab_to_fullname as
4627 it may contain "./" etc. */
4628 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
4629 || ((basenames_may_differ
4630 || file_matches (lbasename (real_symtab
->filename
),
4632 && file_matches (symtab_to_fullname (real_symtab
),
4634 && ((!preg
.has_value ()
4635 || preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
4637 && ((kind
== VARIABLES_DOMAIN
4638 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
4639 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
4640 && SYMBOL_CLASS (sym
) != LOC_BLOCK
4641 /* LOC_CONST can be used for more than
4642 just enums, e.g., c++ static const
4643 members. We only want to skip enums
4645 && !(SYMBOL_CLASS (sym
) == LOC_CONST
4646 && (TYPE_CODE (SYMBOL_TYPE (sym
))
4648 && (!treg
.has_value ()
4649 || treg_matches_sym_type_name (*treg
, sym
)))
4650 || (kind
== FUNCTIONS_DOMAIN
4651 && SYMBOL_CLASS (sym
) == LOC_BLOCK
4652 && (!treg
.has_value ()
4653 || treg_matches_sym_type_name (*treg
,
4655 || (kind
== TYPES_DOMAIN
4656 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4657 && SYMBOL_DOMAIN (sym
) != MODULE_DOMAIN
))))
4660 result
.emplace_back (i
, sym
);
4667 if (!result
.empty ())
4668 sort_search_symbols_remove_dups (&result
);
4670 /* If there are no eyes, avoid all contact. I mean, if there are
4671 no debug symbols, then add matching minsyms. But if the user wants
4672 to see symbols matching a type regexp, then never give a minimal symbol,
4673 as we assume that a minimal symbol does not have a type. */
4675 if ((found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
4677 && !treg
.has_value ())
4679 for (objfile
*objfile
: current_program_space
->objfiles ())
4681 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
4685 if (msymbol
->created_by_gdb
)
4688 if (MSYMBOL_TYPE (msymbol
) == ourtype
4689 || MSYMBOL_TYPE (msymbol
) == ourtype2
4690 || MSYMBOL_TYPE (msymbol
) == ourtype3
4691 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4693 if (!preg
.has_value ()
4694 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4697 /* For functions we can do a quick check of whether the
4698 symbol might be found via find_pc_symtab. */
4699 if (kind
!= FUNCTIONS_DOMAIN
4700 || (find_pc_compunit_symtab
4701 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4704 if (lookup_symbol_in_objfile_from_linkage_name
4705 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4710 result
.emplace_back (i
, msymbol
, objfile
);
4722 /* Helper function for symtab_symbol_info, this function uses
4723 the data returned from search_symbols() to print information
4724 regarding the match to gdb_stdout. If LAST is not NULL,
4725 print file and line number information for the symbol as
4726 well. Skip printing the filename if it matches LAST. */
4729 print_symbol_info (enum search_domain kind
,
4731 int block
, const char *last
)
4733 scoped_switch_to_sym_language_if_auto
l (sym
);
4734 struct symtab
*s
= symbol_symtab (sym
);
4738 const char *s_filename
= symtab_to_filename_for_display (s
);
4740 if (filename_cmp (last
, s_filename
) != 0)
4742 printf_filtered (_("\nFile %ps:\n"),
4743 styled_string (file_name_style
.style (),
4747 if (SYMBOL_LINE (sym
) != 0)
4748 printf_filtered ("%d:\t", SYMBOL_LINE (sym
));
4750 puts_filtered ("\t");
4753 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
4754 printf_filtered ("static ");
4756 /* Typedef that is not a C++ class. */
4757 if (kind
== TYPES_DOMAIN
4758 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
4760 /* FIXME: For C (and C++) we end up with a difference in output here
4761 between how a typedef is printed, and non-typedefs are printed.
4762 The TYPEDEF_PRINT code places a ";" at the end in an attempt to
4763 appear C-like, while TYPE_PRINT doesn't.
4765 For the struct printing case below, things are worse, we force
4766 printing of the ";" in this function, which is going to be wrong
4767 for languages that don't require a ";" between statements. */
4768 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_TYPEDEF
)
4769 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
4772 type_print (SYMBOL_TYPE (sym
), "", gdb_stdout
, -1);
4773 printf_filtered ("\n");
4776 /* variable, func, or typedef-that-is-c++-class. */
4777 else if (kind
< TYPES_DOMAIN
4778 || (kind
== TYPES_DOMAIN
4779 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
4781 type_print (SYMBOL_TYPE (sym
),
4782 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4783 ? "" : SYMBOL_PRINT_NAME (sym
)),
4786 printf_filtered (";\n");
4790 /* This help function for symtab_symbol_info() prints information
4791 for non-debugging symbols to gdb_stdout. */
4794 print_msymbol_info (struct bound_minimal_symbol msymbol
)
4796 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
4799 if (gdbarch_addr_bit (gdbarch
) <= 32)
4800 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
4801 & (CORE_ADDR
) 0xffffffff,
4804 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
4807 ui_file_style sym_style
= (msymbol
.minsym
->text_p ()
4808 ? function_name_style
.style ()
4809 : ui_file_style ());
4811 printf_filtered (_("%ps %ps\n"),
4812 styled_string (address_style
.style (), tmp
),
4813 styled_string (sym_style
,
4814 MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
4817 /* This is the guts of the commands "info functions", "info types", and
4818 "info variables". It calls search_symbols to find all matches and then
4819 print_[m]symbol_info to print out some useful information about the
4823 symtab_symbol_info (bool quiet
, bool exclude_minsyms
,
4824 const char *regexp
, enum search_domain kind
,
4825 const char *t_regexp
, int from_tty
)
4827 static const char * const classnames
[] =
4828 {"variable", "function", "type"};
4829 const char *last_filename
= "";
4832 gdb_assert (kind
<= TYPES_DOMAIN
);
4834 if (regexp
!= nullptr && *regexp
== '\0')
4837 /* Must make sure that if we're interrupted, symbols gets freed. */
4838 std::vector
<symbol_search
> symbols
= search_symbols (regexp
, kind
,
4846 if (t_regexp
!= NULL
)
4848 (_("All %ss matching regular expression \"%s\""
4849 " with type matching regular expression \"%s\":\n"),
4850 classnames
[kind
], regexp
, t_regexp
);
4852 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4853 classnames
[kind
], regexp
);
4857 if (t_regexp
!= NULL
)
4859 (_("All defined %ss"
4860 " with type matching regular expression \"%s\" :\n"),
4861 classnames
[kind
], t_regexp
);
4863 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
4867 for (const symbol_search
&p
: symbols
)
4871 if (p
.msymbol
.minsym
!= NULL
)
4876 printf_filtered (_("\nNon-debugging symbols:\n"));
4879 print_msymbol_info (p
.msymbol
);
4883 print_symbol_info (kind
,
4888 = symtab_to_filename_for_display (symbol_symtab (p
.symbol
));
4893 /* Structure to hold the values of the options used by the 'info variables'
4894 and 'info functions' commands. These correspond to the -q, -t, and -n
4897 struct info_print_options
4900 bool exclude_minsyms
= false;
4901 char *type_regexp
= nullptr;
4903 ~info_print_options ()
4905 xfree (type_regexp
);
4909 /* The options used by the 'info variables' and 'info functions'
4912 static const gdb::option::option_def info_print_options_defs
[] = {
4913 gdb::option::boolean_option_def
<info_print_options
> {
4915 [] (info_print_options
*opt
) { return &opt
->quiet
; },
4916 nullptr, /* show_cmd_cb */
4917 nullptr /* set_doc */
4920 gdb::option::boolean_option_def
<info_print_options
> {
4922 [] (info_print_options
*opt
) { return &opt
->exclude_minsyms
; },
4923 nullptr, /* show_cmd_cb */
4924 nullptr /* set_doc */
4927 gdb::option::string_option_def
<info_print_options
> {
4929 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
4930 nullptr, /* show_cmd_cb */
4931 nullptr /* set_doc */
4935 /* Returns the option group used by 'info variables' and 'info
4938 static gdb::option::option_def_group
4939 make_info_print_options_def_group (info_print_options
*opts
)
4941 return {{info_print_options_defs
}, opts
};
4944 /* Command completer for 'info variables' and 'info functions'. */
4947 info_print_command_completer (struct cmd_list_element
*ignore
,
4948 completion_tracker
&tracker
,
4949 const char *text
, const char * /* word */)
4952 = make_info_print_options_def_group (nullptr);
4953 if (gdb::option::complete_options
4954 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
4957 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
4958 symbol_completer (ignore
, tracker
, text
, word
);
4961 /* Implement the 'info variables' command. */
4964 info_variables_command (const char *args
, int from_tty
)
4966 info_print_options opts
;
4967 auto grp
= make_info_print_options_def_group (&opts
);
4968 gdb::option::process_options
4969 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
4970 if (args
!= nullptr && *args
== '\0')
4973 symtab_symbol_info (opts
.quiet
, opts
.exclude_minsyms
, args
, VARIABLES_DOMAIN
,
4974 opts
.type_regexp
, from_tty
);
4977 /* Implement the 'info functions' command. */
4980 info_functions_command (const char *args
, int from_tty
)
4982 info_print_options opts
;
4983 auto grp
= make_info_print_options_def_group (&opts
);
4984 gdb::option::process_options
4985 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
4986 if (args
!= nullptr && *args
== '\0')
4989 symtab_symbol_info (opts
.quiet
, opts
.exclude_minsyms
, args
,
4990 FUNCTIONS_DOMAIN
, opts
.type_regexp
, from_tty
);
4993 /* Holds the -q option for the 'info types' command. */
4995 struct info_types_options
5000 /* The options used by the 'info types' command. */
5002 static const gdb::option::option_def info_types_options_defs
[] = {
5003 gdb::option::boolean_option_def
<info_types_options
> {
5005 [] (info_types_options
*opt
) { return &opt
->quiet
; },
5006 nullptr, /* show_cmd_cb */
5007 nullptr /* set_doc */
5011 /* Returns the option group used by 'info types'. */
5013 static gdb::option::option_def_group
5014 make_info_types_options_def_group (info_types_options
*opts
)
5016 return {{info_types_options_defs
}, opts
};
5019 /* Implement the 'info types' command. */
5022 info_types_command (const char *args
, int from_tty
)
5024 info_types_options opts
;
5026 auto grp
= make_info_types_options_def_group (&opts
);
5027 gdb::option::process_options
5028 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
5029 if (args
!= nullptr && *args
== '\0')
5031 symtab_symbol_info (opts
.quiet
, false, args
, TYPES_DOMAIN
, NULL
, from_tty
);
5034 /* Command completer for 'info types' command. */
5037 info_types_command_completer (struct cmd_list_element
*ignore
,
5038 completion_tracker
&tracker
,
5039 const char *text
, const char * /* word */)
5042 = make_info_types_options_def_group (nullptr);
5043 if (gdb::option::complete_options
5044 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
5047 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
5048 symbol_completer (ignore
, tracker
, text
, word
);
5051 /* Breakpoint all functions matching regular expression. */
5054 rbreak_command_wrapper (char *regexp
, int from_tty
)
5056 rbreak_command (regexp
, from_tty
);
5060 rbreak_command (const char *regexp
, int from_tty
)
5063 const char **files
= NULL
;
5064 const char *file_name
;
5069 const char *colon
= strchr (regexp
, ':');
5071 if (colon
&& *(colon
+ 1) != ':')
5076 colon_index
= colon
- regexp
;
5077 local_name
= (char *) alloca (colon_index
+ 1);
5078 memcpy (local_name
, regexp
, colon_index
);
5079 local_name
[colon_index
--] = 0;
5080 while (isspace (local_name
[colon_index
]))
5081 local_name
[colon_index
--] = 0;
5082 file_name
= local_name
;
5085 regexp
= skip_spaces (colon
+ 1);
5089 std::vector
<symbol_search
> symbols
= search_symbols (regexp
,
5095 scoped_rbreak_breakpoints finalize
;
5096 for (const symbol_search
&p
: symbols
)
5098 if (p
.msymbol
.minsym
== NULL
)
5100 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
5101 const char *fullname
= symtab_to_fullname (symtab
);
5103 string
= string_printf ("%s:'%s'", fullname
,
5104 SYMBOL_LINKAGE_NAME (p
.symbol
));
5105 break_command (&string
[0], from_tty
);
5106 print_symbol_info (FUNCTIONS_DOMAIN
, p
.symbol
, p
.block
, NULL
);
5110 string
= string_printf ("'%s'",
5111 MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
));
5113 break_command (&string
[0], from_tty
);
5114 printf_filtered ("<function, no debug info> %s;\n",
5115 MSYMBOL_PRINT_NAME (p
.msymbol
.minsym
));
5121 /* Evaluate if SYMNAME matches LOOKUP_NAME. */
5124 compare_symbol_name (const char *symbol_name
, language symbol_language
,
5125 const lookup_name_info
&lookup_name
,
5126 completion_match_result
&match_res
)
5128 const language_defn
*lang
= language_def (symbol_language
);
5130 symbol_name_matcher_ftype
*name_match
5131 = get_symbol_name_matcher (lang
, lookup_name
);
5133 return name_match (symbol_name
, lookup_name
, &match_res
);
5139 completion_list_add_name (completion_tracker
&tracker
,
5140 language symbol_language
,
5141 const char *symname
,
5142 const lookup_name_info
&lookup_name
,
5143 const char *text
, const char *word
)
5145 completion_match_result
&match_res
5146 = tracker
.reset_completion_match_result ();
5148 /* Clip symbols that cannot match. */
5149 if (!compare_symbol_name (symname
, symbol_language
, lookup_name
, match_res
))
5152 /* Refresh SYMNAME from the match string. It's potentially
5153 different depending on language. (E.g., on Ada, the match may be
5154 the encoded symbol name wrapped in "<>"). */
5155 symname
= match_res
.match
.match ();
5156 gdb_assert (symname
!= NULL
);
5158 /* We have a match for a completion, so add SYMNAME to the current list
5159 of matches. Note that the name is moved to freshly malloc'd space. */
5162 gdb::unique_xmalloc_ptr
<char> completion
5163 = make_completion_match_str (symname
, text
, word
);
5165 /* Here we pass the match-for-lcd object to add_completion. Some
5166 languages match the user text against substrings of symbol
5167 names in some cases. E.g., in C++, "b push_ba" completes to
5168 "std::vector::push_back", "std::string::push_back", etc., and
5169 in this case we want the completion lowest common denominator
5170 to be "push_back" instead of "std::". */
5171 tracker
.add_completion (std::move (completion
),
5172 &match_res
.match_for_lcd
, text
, word
);
5176 /* completion_list_add_name wrapper for struct symbol. */
5179 completion_list_add_symbol (completion_tracker
&tracker
,
5181 const lookup_name_info
&lookup_name
,
5182 const char *text
, const char *word
)
5184 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5185 SYMBOL_NATURAL_NAME (sym
),
5186 lookup_name
, text
, word
);
5189 /* completion_list_add_name wrapper for struct minimal_symbol. */
5192 completion_list_add_msymbol (completion_tracker
&tracker
,
5193 minimal_symbol
*sym
,
5194 const lookup_name_info
&lookup_name
,
5195 const char *text
, const char *word
)
5197 completion_list_add_name (tracker
, MSYMBOL_LANGUAGE (sym
),
5198 MSYMBOL_NATURAL_NAME (sym
),
5199 lookup_name
, text
, word
);
5203 /* ObjC: In case we are completing on a selector, look as the msymbol
5204 again and feed all the selectors into the mill. */
5207 completion_list_objc_symbol (completion_tracker
&tracker
,
5208 struct minimal_symbol
*msymbol
,
5209 const lookup_name_info
&lookup_name
,
5210 const char *text
, const char *word
)
5212 static char *tmp
= NULL
;
5213 static unsigned int tmplen
= 0;
5215 const char *method
, *category
, *selector
;
5218 method
= MSYMBOL_NATURAL_NAME (msymbol
);
5220 /* Is it a method? */
5221 if ((method
[0] != '-') && (method
[0] != '+'))
5225 /* Complete on shortened method method. */
5226 completion_list_add_name (tracker
, language_objc
,
5231 while ((strlen (method
) + 1) >= tmplen
)
5237 tmp
= (char *) xrealloc (tmp
, tmplen
);
5239 selector
= strchr (method
, ' ');
5240 if (selector
!= NULL
)
5243 category
= strchr (method
, '(');
5245 if ((category
!= NULL
) && (selector
!= NULL
))
5247 memcpy (tmp
, method
, (category
- method
));
5248 tmp
[category
- method
] = ' ';
5249 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
5250 completion_list_add_name (tracker
, language_objc
, tmp
,
5251 lookup_name
, text
, word
);
5253 completion_list_add_name (tracker
, language_objc
, tmp
+ 1,
5254 lookup_name
, text
, word
);
5257 if (selector
!= NULL
)
5259 /* Complete on selector only. */
5260 strcpy (tmp
, selector
);
5261 tmp2
= strchr (tmp
, ']');
5265 completion_list_add_name (tracker
, language_objc
, tmp
,
5266 lookup_name
, text
, word
);
5270 /* Break the non-quoted text based on the characters which are in
5271 symbols. FIXME: This should probably be language-specific. */
5274 language_search_unquoted_string (const char *text
, const char *p
)
5276 for (; p
> text
; --p
)
5278 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
5282 if ((current_language
->la_language
== language_objc
))
5284 if (p
[-1] == ':') /* Might be part of a method name. */
5286 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
5287 p
-= 2; /* Beginning of a method name. */
5288 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
5289 { /* Might be part of a method name. */
5292 /* Seeing a ' ' or a '(' is not conclusive evidence
5293 that we are in the middle of a method name. However,
5294 finding "-[" or "+[" should be pretty un-ambiguous.
5295 Unfortunately we have to find it now to decide. */
5298 if (isalnum (t
[-1]) || t
[-1] == '_' ||
5299 t
[-1] == ' ' || t
[-1] == ':' ||
5300 t
[-1] == '(' || t
[-1] == ')')
5305 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
5306 p
= t
- 2; /* Method name detected. */
5307 /* Else we leave with p unchanged. */
5317 completion_list_add_fields (completion_tracker
&tracker
,
5319 const lookup_name_info
&lookup_name
,
5320 const char *text
, const char *word
)
5322 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
5324 struct type
*t
= SYMBOL_TYPE (sym
);
5325 enum type_code c
= TYPE_CODE (t
);
5328 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
5329 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
5330 if (TYPE_FIELD_NAME (t
, j
))
5331 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5332 TYPE_FIELD_NAME (t
, j
),
5333 lookup_name
, text
, word
);
5340 symbol_is_function_or_method (symbol
*sym
)
5342 switch (TYPE_CODE (SYMBOL_TYPE (sym
)))
5344 case TYPE_CODE_FUNC
:
5345 case TYPE_CODE_METHOD
:
5355 symbol_is_function_or_method (minimal_symbol
*msymbol
)
5357 switch (MSYMBOL_TYPE (msymbol
))
5360 case mst_text_gnu_ifunc
:
5361 case mst_solib_trampoline
:
5371 bound_minimal_symbol
5372 find_gnu_ifunc (const symbol
*sym
)
5374 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
5377 lookup_name_info
lookup_name (SYMBOL_SEARCH_NAME (sym
),
5378 symbol_name_match_type::SEARCH_NAME
);
5379 struct objfile
*objfile
= symbol_objfile (sym
);
5381 CORE_ADDR address
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
5382 minimal_symbol
*ifunc
= NULL
;
5384 iterate_over_minimal_symbols (objfile
, lookup_name
,
5385 [&] (minimal_symbol
*minsym
)
5387 if (MSYMBOL_TYPE (minsym
) == mst_text_gnu_ifunc
5388 || MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5390 CORE_ADDR msym_addr
= MSYMBOL_VALUE_ADDRESS (objfile
, minsym
);
5391 if (MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5393 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5395 = gdbarch_convert_from_func_ptr_addr (gdbarch
,
5397 current_top_target ());
5399 if (msym_addr
== address
)
5409 return {ifunc
, objfile
};
5413 /* Add matching symbols from SYMTAB to the current completion list. */
5416 add_symtab_completions (struct compunit_symtab
*cust
,
5417 completion_tracker
&tracker
,
5418 complete_symbol_mode mode
,
5419 const lookup_name_info
&lookup_name
,
5420 const char *text
, const char *word
,
5421 enum type_code code
)
5424 const struct block
*b
;
5425 struct block_iterator iter
;
5431 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
5434 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), i
);
5435 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5437 if (completion_skip_symbol (mode
, sym
))
5440 if (code
== TYPE_CODE_UNDEF
5441 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5442 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
5443 completion_list_add_symbol (tracker
, sym
,
5451 default_collect_symbol_completion_matches_break_on
5452 (completion_tracker
&tracker
, complete_symbol_mode mode
,
5453 symbol_name_match_type name_match_type
,
5454 const char *text
, const char *word
,
5455 const char *break_on
, enum type_code code
)
5457 /* Problem: All of the symbols have to be copied because readline
5458 frees them. I'm not going to worry about this; hopefully there
5459 won't be that many. */
5462 const struct block
*b
;
5463 const struct block
*surrounding_static_block
, *surrounding_global_block
;
5464 struct block_iterator iter
;
5465 /* The symbol we are completing on. Points in same buffer as text. */
5466 const char *sym_text
;
5468 /* Now look for the symbol we are supposed to complete on. */
5469 if (mode
== complete_symbol_mode::LINESPEC
)
5475 const char *quote_pos
= NULL
;
5477 /* First see if this is a quoted string. */
5479 for (p
= text
; *p
!= '\0'; ++p
)
5481 if (quote_found
!= '\0')
5483 if (*p
== quote_found
)
5484 /* Found close quote. */
5486 else if (*p
== '\\' && p
[1] == quote_found
)
5487 /* A backslash followed by the quote character
5488 doesn't end the string. */
5491 else if (*p
== '\'' || *p
== '"')
5497 if (quote_found
== '\'')
5498 /* A string within single quotes can be a symbol, so complete on it. */
5499 sym_text
= quote_pos
+ 1;
5500 else if (quote_found
== '"')
5501 /* A double-quoted string is never a symbol, nor does it make sense
5502 to complete it any other way. */
5508 /* It is not a quoted string. Break it based on the characters
5509 which are in symbols. */
5512 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
5513 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
5522 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5524 /* At this point scan through the misc symbol vectors and add each
5525 symbol you find to the list. Eventually we want to ignore
5526 anything that isn't a text symbol (everything else will be
5527 handled by the psymtab code below). */
5529 if (code
== TYPE_CODE_UNDEF
)
5531 for (objfile
*objfile
: current_program_space
->objfiles ())
5533 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
5537 if (completion_skip_symbol (mode
, msymbol
))
5540 completion_list_add_msymbol (tracker
, msymbol
, lookup_name
,
5543 completion_list_objc_symbol (tracker
, msymbol
, lookup_name
,
5549 /* Add completions for all currently loaded symbol tables. */
5550 for (objfile
*objfile
: current_program_space
->objfiles ())
5552 for (compunit_symtab
*cust
: objfile
->compunits ())
5553 add_symtab_completions (cust
, tracker
, mode
, lookup_name
,
5554 sym_text
, word
, code
);
5557 /* Look through the partial symtabs for all symbols which begin by
5558 matching SYM_TEXT. Expand all CUs that you find to the list. */
5559 expand_symtabs_matching (NULL
,
5562 [&] (compunit_symtab
*symtab
) /* expansion notify */
5564 add_symtab_completions (symtab
,
5565 tracker
, mode
, lookup_name
,
5566 sym_text
, word
, code
);
5570 /* Search upwards from currently selected frame (so that we can
5571 complete on local vars). Also catch fields of types defined in
5572 this places which match our text string. Only complete on types
5573 visible from current context. */
5575 b
= get_selected_block (0);
5576 surrounding_static_block
= block_static_block (b
);
5577 surrounding_global_block
= block_global_block (b
);
5578 if (surrounding_static_block
!= NULL
)
5579 while (b
!= surrounding_static_block
)
5583 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5585 if (code
== TYPE_CODE_UNDEF
)
5587 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5589 completion_list_add_fields (tracker
, sym
, lookup_name
,
5592 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5593 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
5594 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5598 /* Stop when we encounter an enclosing function. Do not stop for
5599 non-inlined functions - the locals of the enclosing function
5600 are in scope for a nested function. */
5601 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
5603 b
= BLOCK_SUPERBLOCK (b
);
5606 /* Add fields from the file's types; symbols will be added below. */
5608 if (code
== TYPE_CODE_UNDEF
)
5610 if (surrounding_static_block
!= NULL
)
5611 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
5612 completion_list_add_fields (tracker
, sym
, lookup_name
,
5615 if (surrounding_global_block
!= NULL
)
5616 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
5617 completion_list_add_fields (tracker
, sym
, lookup_name
,
5621 /* Skip macros if we are completing a struct tag -- arguable but
5622 usually what is expected. */
5623 if (current_language
->la_macro_expansion
== macro_expansion_c
5624 && code
== TYPE_CODE_UNDEF
)
5626 gdb::unique_xmalloc_ptr
<struct macro_scope
> scope
;
5628 /* This adds a macro's name to the current completion list. */
5629 auto add_macro_name
= [&] (const char *macro_name
,
5630 const macro_definition
*,
5631 macro_source_file
*,
5634 completion_list_add_name (tracker
, language_c
, macro_name
,
5635 lookup_name
, sym_text
, word
);
5638 /* Add any macros visible in the default scope. Note that this
5639 may yield the occasional wrong result, because an expression
5640 might be evaluated in a scope other than the default. For
5641 example, if the user types "break file:line if <TAB>", the
5642 resulting expression will be evaluated at "file:line" -- but
5643 at there does not seem to be a way to detect this at
5645 scope
= default_macro_scope ();
5647 macro_for_each_in_scope (scope
->file
, scope
->line
,
5650 /* User-defined macros are always visible. */
5651 macro_for_each (macro_user_macros
, add_macro_name
);
5656 default_collect_symbol_completion_matches (completion_tracker
&tracker
,
5657 complete_symbol_mode mode
,
5658 symbol_name_match_type name_match_type
,
5659 const char *text
, const char *word
,
5660 enum type_code code
)
5662 return default_collect_symbol_completion_matches_break_on (tracker
, mode
,
5668 /* Collect all symbols (regardless of class) which begin by matching
5672 collect_symbol_completion_matches (completion_tracker
&tracker
,
5673 complete_symbol_mode mode
,
5674 symbol_name_match_type name_match_type
,
5675 const char *text
, const char *word
)
5677 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5683 /* Like collect_symbol_completion_matches, but only collect
5684 STRUCT_DOMAIN symbols whose type code is CODE. */
5687 collect_symbol_completion_matches_type (completion_tracker
&tracker
,
5688 const char *text
, const char *word
,
5689 enum type_code code
)
5691 complete_symbol_mode mode
= complete_symbol_mode::EXPRESSION
;
5692 symbol_name_match_type name_match_type
= symbol_name_match_type::EXPRESSION
;
5694 gdb_assert (code
== TYPE_CODE_UNION
5695 || code
== TYPE_CODE_STRUCT
5696 || code
== TYPE_CODE_ENUM
);
5697 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5702 /* Like collect_symbol_completion_matches, but collects a list of
5703 symbols defined in all source files named SRCFILE. */
5706 collect_file_symbol_completion_matches (completion_tracker
&tracker
,
5707 complete_symbol_mode mode
,
5708 symbol_name_match_type name_match_type
,
5709 const char *text
, const char *word
,
5710 const char *srcfile
)
5712 /* The symbol we are completing on. Points in same buffer as text. */
5713 const char *sym_text
;
5715 /* Now look for the symbol we are supposed to complete on.
5716 FIXME: This should be language-specific. */
5717 if (mode
== complete_symbol_mode::LINESPEC
)
5723 const char *quote_pos
= NULL
;
5725 /* First see if this is a quoted string. */
5727 for (p
= text
; *p
!= '\0'; ++p
)
5729 if (quote_found
!= '\0')
5731 if (*p
== quote_found
)
5732 /* Found close quote. */
5734 else if (*p
== '\\' && p
[1] == quote_found
)
5735 /* A backslash followed by the quote character
5736 doesn't end the string. */
5739 else if (*p
== '\'' || *p
== '"')
5745 if (quote_found
== '\'')
5746 /* A string within single quotes can be a symbol, so complete on it. */
5747 sym_text
= quote_pos
+ 1;
5748 else if (quote_found
== '"')
5749 /* A double-quoted string is never a symbol, nor does it make sense
5750 to complete it any other way. */
5756 /* Not a quoted string. */
5757 sym_text
= language_search_unquoted_string (text
, p
);
5761 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5763 /* Go through symtabs for SRCFILE and check the externs and statics
5764 for symbols which match. */
5765 iterate_over_symtabs (srcfile
, [&] (symtab
*s
)
5767 add_symtab_completions (SYMTAB_COMPUNIT (s
),
5768 tracker
, mode
, lookup_name
,
5769 sym_text
, word
, TYPE_CODE_UNDEF
);
5774 /* A helper function for make_source_files_completion_list. It adds
5775 another file name to a list of possible completions, growing the
5776 list as necessary. */
5779 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
5780 completion_list
*list
)
5782 list
->emplace_back (make_completion_match_str (fname
, text
, word
));
5786 not_interesting_fname (const char *fname
)
5788 static const char *illegal_aliens
[] = {
5789 "_globals_", /* inserted by coff_symtab_read */
5794 for (i
= 0; illegal_aliens
[i
]; i
++)
5796 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
5802 /* An object of this type is passed as the user_data argument to
5803 map_partial_symbol_filenames. */
5804 struct add_partial_filename_data
5806 struct filename_seen_cache
*filename_seen_cache
;
5810 completion_list
*list
;
5813 /* A callback for map_partial_symbol_filenames. */
5816 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
5819 struct add_partial_filename_data
*data
5820 = (struct add_partial_filename_data
*) user_data
;
5822 if (not_interesting_fname (filename
))
5824 if (!data
->filename_seen_cache
->seen (filename
)
5825 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
5827 /* This file matches for a completion; add it to the
5828 current list of matches. */
5829 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
5833 const char *base_name
= lbasename (filename
);
5835 if (base_name
!= filename
5836 && !data
->filename_seen_cache
->seen (base_name
)
5837 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
5838 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
5842 /* Return a list of all source files whose names begin with matching
5843 TEXT. The file names are looked up in the symbol tables of this
5847 make_source_files_completion_list (const char *text
, const char *word
)
5849 size_t text_len
= strlen (text
);
5850 completion_list list
;
5851 const char *base_name
;
5852 struct add_partial_filename_data datum
;
5854 if (!have_full_symbols () && !have_partial_symbols ())
5857 filename_seen_cache filenames_seen
;
5859 for (objfile
*objfile
: current_program_space
->objfiles ())
5861 for (compunit_symtab
*cu
: objfile
->compunits ())
5863 for (symtab
*s
: compunit_filetabs (cu
))
5865 if (not_interesting_fname (s
->filename
))
5867 if (!filenames_seen
.seen (s
->filename
)
5868 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
5870 /* This file matches for a completion; add it to the current
5872 add_filename_to_list (s
->filename
, text
, word
, &list
);
5876 /* NOTE: We allow the user to type a base name when the
5877 debug info records leading directories, but not the other
5878 way around. This is what subroutines of breakpoint
5879 command do when they parse file names. */
5880 base_name
= lbasename (s
->filename
);
5881 if (base_name
!= s
->filename
5882 && !filenames_seen
.seen (base_name
)
5883 && filename_ncmp (base_name
, text
, text_len
) == 0)
5884 add_filename_to_list (base_name
, text
, word
, &list
);
5890 datum
.filename_seen_cache
= &filenames_seen
;
5893 datum
.text_len
= text_len
;
5895 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
5896 0 /*need_fullname*/);
5903 /* Return the "main_info" object for the current program space. If
5904 the object has not yet been created, create it and fill in some
5907 static struct main_info
*
5908 get_main_info (void)
5910 struct main_info
*info
= main_progspace_key
.get (current_program_space
);
5914 /* It may seem strange to store the main name in the progspace
5915 and also in whatever objfile happens to see a main name in
5916 its debug info. The reason for this is mainly historical:
5917 gdb returned "main" as the name even if no function named
5918 "main" was defined the program; and this approach lets us
5919 keep compatibility. */
5920 info
= main_progspace_key
.emplace (current_program_space
);
5927 set_main_name (const char *name
, enum language lang
)
5929 struct main_info
*info
= get_main_info ();
5931 if (info
->name_of_main
!= NULL
)
5933 xfree (info
->name_of_main
);
5934 info
->name_of_main
= NULL
;
5935 info
->language_of_main
= language_unknown
;
5939 info
->name_of_main
= xstrdup (name
);
5940 info
->language_of_main
= lang
;
5944 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5948 find_main_name (void)
5950 const char *new_main_name
;
5952 /* First check the objfiles to see whether a debuginfo reader has
5953 picked up the appropriate main name. Historically the main name
5954 was found in a more or less random way; this approach instead
5955 relies on the order of objfile creation -- which still isn't
5956 guaranteed to get the correct answer, but is just probably more
5958 for (objfile
*objfile
: current_program_space
->objfiles ())
5960 if (objfile
->per_bfd
->name_of_main
!= NULL
)
5962 set_main_name (objfile
->per_bfd
->name_of_main
,
5963 objfile
->per_bfd
->language_of_main
);
5968 /* Try to see if the main procedure is in Ada. */
5969 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5970 be to add a new method in the language vector, and call this
5971 method for each language until one of them returns a non-empty
5972 name. This would allow us to remove this hard-coded call to
5973 an Ada function. It is not clear that this is a better approach
5974 at this point, because all methods need to be written in a way
5975 such that false positives never be returned. For instance, it is
5976 important that a method does not return a wrong name for the main
5977 procedure if the main procedure is actually written in a different
5978 language. It is easy to guaranty this with Ada, since we use a
5979 special symbol generated only when the main in Ada to find the name
5980 of the main procedure. It is difficult however to see how this can
5981 be guarantied for languages such as C, for instance. This suggests
5982 that order of call for these methods becomes important, which means
5983 a more complicated approach. */
5984 new_main_name
= ada_main_name ();
5985 if (new_main_name
!= NULL
)
5987 set_main_name (new_main_name
, language_ada
);
5991 new_main_name
= d_main_name ();
5992 if (new_main_name
!= NULL
)
5994 set_main_name (new_main_name
, language_d
);
5998 new_main_name
= go_main_name ();
5999 if (new_main_name
!= NULL
)
6001 set_main_name (new_main_name
, language_go
);
6005 new_main_name
= pascal_main_name ();
6006 if (new_main_name
!= NULL
)
6008 set_main_name (new_main_name
, language_pascal
);
6012 /* The languages above didn't identify the name of the main procedure.
6013 Fallback to "main". */
6014 set_main_name ("main", language_unknown
);
6022 struct main_info
*info
= get_main_info ();
6024 if (info
->name_of_main
== NULL
)
6027 return info
->name_of_main
;
6030 /* Return the language of the main function. If it is not known,
6031 return language_unknown. */
6034 main_language (void)
6036 struct main_info
*info
= get_main_info ();
6038 if (info
->name_of_main
== NULL
)
6041 return info
->language_of_main
;
6044 /* Handle ``executable_changed'' events for the symtab module. */
6047 symtab_observer_executable_changed (void)
6049 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
6050 set_main_name (NULL
, language_unknown
);
6053 /* Return 1 if the supplied producer string matches the ARM RealView
6054 compiler (armcc). */
6057 producer_is_realview (const char *producer
)
6059 static const char *const arm_idents
[] = {
6060 "ARM C Compiler, ADS",
6061 "Thumb C Compiler, ADS",
6062 "ARM C++ Compiler, ADS",
6063 "Thumb C++ Compiler, ADS",
6064 "ARM/Thumb C/C++ Compiler, RVCT",
6065 "ARM C/C++ Compiler, RVCT"
6069 if (producer
== NULL
)
6072 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
6073 if (startswith (producer
, arm_idents
[i
]))
6081 /* The next index to hand out in response to a registration request. */
6083 static int next_aclass_value
= LOC_FINAL_VALUE
;
6085 /* The maximum number of "aclass" registrations we support. This is
6086 constant for convenience. */
6087 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
6089 /* The objects representing the various "aclass" values. The elements
6090 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
6091 elements are those registered at gdb initialization time. */
6093 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
6095 /* The globally visible pointer. This is separate from 'symbol_impl'
6096 so that it can be const. */
6098 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
6100 /* Make sure we saved enough room in struct symbol. */
6102 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
6104 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
6105 is the ops vector associated with this index. This returns the new
6106 index, which should be used as the aclass_index field for symbols
6110 register_symbol_computed_impl (enum address_class aclass
,
6111 const struct symbol_computed_ops
*ops
)
6113 int result
= next_aclass_value
++;
6115 gdb_assert (aclass
== LOC_COMPUTED
);
6116 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6117 symbol_impl
[result
].aclass
= aclass
;
6118 symbol_impl
[result
].ops_computed
= ops
;
6120 /* Sanity check OPS. */
6121 gdb_assert (ops
!= NULL
);
6122 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
6123 gdb_assert (ops
->describe_location
!= NULL
);
6124 gdb_assert (ops
->get_symbol_read_needs
!= NULL
);
6125 gdb_assert (ops
->read_variable
!= NULL
);
6130 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
6131 OPS is the ops vector associated with this index. This returns the
6132 new index, which should be used as the aclass_index field for symbols
6136 register_symbol_block_impl (enum address_class aclass
,
6137 const struct symbol_block_ops
*ops
)
6139 int result
= next_aclass_value
++;
6141 gdb_assert (aclass
== LOC_BLOCK
);
6142 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6143 symbol_impl
[result
].aclass
= aclass
;
6144 symbol_impl
[result
].ops_block
= ops
;
6146 /* Sanity check OPS. */
6147 gdb_assert (ops
!= NULL
);
6148 gdb_assert (ops
->find_frame_base_location
!= NULL
);
6153 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
6154 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
6155 this index. This returns the new index, which should be used as
6156 the aclass_index field for symbols of this type. */
6159 register_symbol_register_impl (enum address_class aclass
,
6160 const struct symbol_register_ops
*ops
)
6162 int result
= next_aclass_value
++;
6164 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
6165 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6166 symbol_impl
[result
].aclass
= aclass
;
6167 symbol_impl
[result
].ops_register
= ops
;
6172 /* Initialize elements of 'symbol_impl' for the constants in enum
6176 initialize_ordinary_address_classes (void)
6180 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
6181 symbol_impl
[i
].aclass
= (enum address_class
) i
;
6186 /* Helper function to initialize the fields of an objfile-owned symbol.
6187 It assumed that *SYM is already all zeroes. */
6190 initialize_objfile_symbol_1 (struct symbol
*sym
)
6192 SYMBOL_OBJFILE_OWNED (sym
) = 1;
6193 SYMBOL_SECTION (sym
) = -1;
6196 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
6199 initialize_objfile_symbol (struct symbol
*sym
)
6201 memset (sym
, 0, sizeof (*sym
));
6202 initialize_objfile_symbol_1 (sym
);
6205 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
6209 allocate_symbol (struct objfile
*objfile
)
6211 struct symbol
*result
;
6213 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
6214 initialize_objfile_symbol_1 (result
);
6219 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
6222 struct template_symbol
*
6223 allocate_template_symbol (struct objfile
*objfile
)
6225 struct template_symbol
*result
;
6227 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
6228 initialize_objfile_symbol_1 (result
);
6236 symbol_objfile (const struct symbol
*symbol
)
6238 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6239 return SYMTAB_OBJFILE (symbol
->owner
.symtab
);
6245 symbol_arch (const struct symbol
*symbol
)
6247 if (!SYMBOL_OBJFILE_OWNED (symbol
))
6248 return symbol
->owner
.arch
;
6249 return get_objfile_arch (SYMTAB_OBJFILE (symbol
->owner
.symtab
));
6255 symbol_symtab (const struct symbol
*symbol
)
6257 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6258 return symbol
->owner
.symtab
;
6264 symbol_set_symtab (struct symbol
*symbol
, struct symtab
*symtab
)
6266 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6267 symbol
->owner
.symtab
= symtab
;
6273 get_symbol_address (const struct symbol
*sym
)
6275 gdb_assert (sym
->maybe_copied
);
6276 gdb_assert (SYMBOL_CLASS (sym
) == LOC_STATIC
);
6278 const char *linkage_name
= SYMBOL_LINKAGE_NAME (sym
);
6280 for (objfile
*objfile
: current_program_space
->objfiles ())
6282 bound_minimal_symbol minsym
6283 = lookup_minimal_symbol_linkage (linkage_name
, objfile
);
6284 if (minsym
.minsym
!= nullptr)
6285 return BMSYMBOL_VALUE_ADDRESS (minsym
);
6287 return sym
->ginfo
.value
.address
;
6293 get_msymbol_address (struct objfile
*objf
, const struct minimal_symbol
*minsym
)
6295 gdb_assert (minsym
->maybe_copied
);
6296 gdb_assert ((objf
->flags
& OBJF_MAINLINE
) == 0);
6298 const char *linkage_name
= MSYMBOL_LINKAGE_NAME (minsym
);
6300 for (objfile
*objfile
: current_program_space
->objfiles ())
6302 if ((objfile
->flags
& OBJF_MAINLINE
) != 0)
6304 bound_minimal_symbol found
6305 = lookup_minimal_symbol_linkage (linkage_name
, objfile
);
6306 if (found
.minsym
!= nullptr)
6307 return BMSYMBOL_VALUE_ADDRESS (found
);
6310 return (minsym
->value
.address
6311 + ANOFFSET (objf
->section_offsets
, minsym
->section
));
6317 _initialize_symtab (void)
6319 cmd_list_element
*c
;
6321 initialize_ordinary_address_classes ();
6323 c
= add_info ("variables", info_variables_command
,
6324 info_print_args_help (_("\
6325 All global and static variable names or those matching REGEXPs.\n\
6326 Usage: info variables [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6327 Prints the global and static variables.\n"),
6328 _("global and static variables"),
6330 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6333 c
= add_com ("whereis", class_info
, info_variables_command
,
6334 info_print_args_help (_("\
6335 All global and static variable names, or those matching REGEXPs.\n\
6336 Usage: whereis [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6337 Prints the global and static variables.\n"),
6338 _("global and static variables"),
6340 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6343 c
= add_info ("functions", info_functions_command
,
6344 info_print_args_help (_("\
6345 All function names or those matching REGEXPs.\n\
6346 Usage: info functions [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6347 Prints the functions.\n"),
6350 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6352 c
= add_info ("types", info_types_command
, _("\
6353 All type names, or those matching REGEXP.\n\
6354 Usage: info types [-q] [REGEXP]\n\
6355 Print information about all types matching REGEXP, or all types if no\n\
6356 REGEXP is given. The optional flag -q disables printing of headers."));
6357 set_cmd_completer_handle_brkchars (c
, info_types_command_completer
);
6359 const auto info_sources_opts
= make_info_sources_options_def_group (nullptr);
6361 static std::string info_sources_help
6362 = gdb::option::build_help (_("\
6363 All source files in the program or those matching REGEXP.\n\
6364 Usage: info sources [OPTION]... [REGEXP]\n\
6365 By default, REGEXP is used to match anywhere in the filename.\n\
6371 c
= add_info ("sources", info_sources_command
, info_sources_help
.c_str ());
6372 set_cmd_completer_handle_brkchars (c
, info_sources_command_completer
);
6374 add_com ("rbreak", class_breakpoint
, rbreak_command
,
6375 _("Set a breakpoint for all functions matching REGEXP."));
6377 add_setshow_enum_cmd ("multiple-symbols", no_class
,
6378 multiple_symbols_modes
, &multiple_symbols_mode
,
6380 Set how the debugger handles ambiguities in expressions."), _("\
6381 Show how the debugger handles ambiguities in expressions."), _("\
6382 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
6383 NULL
, NULL
, &setlist
, &showlist
);
6385 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
6386 &basenames_may_differ
, _("\
6387 Set whether a source file may have multiple base names."), _("\
6388 Show whether a source file may have multiple base names."), _("\
6389 (A \"base name\" is the name of a file with the directory part removed.\n\
6390 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
6391 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
6392 before comparing them. Canonicalization is an expensive operation,\n\
6393 but it allows the same file be known by more than one base name.\n\
6394 If not set (the default), all source files are assumed to have just\n\
6395 one base name, and gdb will do file name comparisons more efficiently."),
6397 &setlist
, &showlist
);
6399 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
6400 _("Set debugging of symbol table creation."),
6401 _("Show debugging of symbol table creation."), _("\
6402 When enabled (non-zero), debugging messages are printed when building\n\
6403 symbol tables. A value of 1 (one) normally provides enough information.\n\
6404 A value greater than 1 provides more verbose information."),
6407 &setdebuglist
, &showdebuglist
);
6409 add_setshow_zuinteger_cmd ("symbol-lookup", no_class
, &symbol_lookup_debug
,
6411 Set debugging of symbol lookup."), _("\
6412 Show debugging of symbol lookup."), _("\
6413 When enabled (non-zero), symbol lookups are logged."),
6415 &setdebuglist
, &showdebuglist
);
6417 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class
,
6418 &new_symbol_cache_size
,
6419 _("Set the size of the symbol cache."),
6420 _("Show the size of the symbol cache."), _("\
6421 The size of the symbol cache.\n\
6422 If zero then the symbol cache is disabled."),
6423 set_symbol_cache_size_handler
, NULL
,
6424 &maintenance_set_cmdlist
,
6425 &maintenance_show_cmdlist
);
6427 add_cmd ("symbol-cache", class_maintenance
, maintenance_print_symbol_cache
,
6428 _("Dump the symbol cache for each program space."),
6429 &maintenanceprintlist
);
6431 add_cmd ("symbol-cache-statistics", class_maintenance
,
6432 maintenance_print_symbol_cache_statistics
,
6433 _("Print symbol cache statistics for each program space."),
6434 &maintenanceprintlist
);
6436 add_cmd ("flush-symbol-cache", class_maintenance
,
6437 maintenance_flush_symbol_cache
,
6438 _("Flush the symbol cache for each program space."),
6441 gdb::observers::executable_changed
.attach (symtab_observer_executable_changed
);
6442 gdb::observers::new_objfile
.attach (symtab_new_objfile_observer
);
6443 gdb::observers::free_objfile
.attach (symtab_free_objfile_observer
);