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"
74 /* Forward declarations for local functions. */
76 static void rbreak_command (const char *, int);
78 static int find_line_common (struct linetable
*, int, int *, int);
80 static struct block_symbol
81 lookup_symbol_aux (const char *name
,
82 symbol_name_match_type match_type
,
83 const struct block
*block
,
84 const domain_enum domain
,
85 enum language language
,
86 struct field_of_this_result
*);
89 struct block_symbol
lookup_local_symbol (const char *name
,
90 symbol_name_match_type match_type
,
91 const struct block
*block
,
92 const domain_enum domain
,
93 enum language language
);
95 static struct block_symbol
96 lookup_symbol_in_objfile (struct objfile
*objfile
,
97 enum block_enum block_index
,
98 const char *name
, const domain_enum domain
);
100 /* Type of the data stored on the program space. */
104 main_info () = default;
108 xfree (name_of_main
);
111 /* Name of "main". */
113 char *name_of_main
= nullptr;
115 /* Language of "main". */
117 enum language language_of_main
= language_unknown
;
120 /* Program space key for finding name and language of "main". */
122 static const program_space_key
<main_info
> main_progspace_key
;
124 /* The default symbol cache size.
125 There is no extra cpu cost for large N (except when flushing the cache,
126 which is rare). The value here is just a first attempt. A better default
127 value may be higher or lower. A prime number can make up for a bad hash
128 computation, so that's why the number is what it is. */
129 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
131 /* The maximum symbol cache size.
132 There's no method to the decision of what value to use here, other than
133 there's no point in allowing a user typo to make gdb consume all memory. */
134 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
136 /* symbol_cache_lookup returns this if a previous lookup failed to find the
137 symbol in any objfile. */
138 #define SYMBOL_LOOKUP_FAILED \
139 ((struct block_symbol) {(struct symbol *) 1, NULL})
140 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
142 /* Recording lookups that don't find the symbol is just as important, if not
143 more so, than recording found symbols. */
145 enum symbol_cache_slot_state
148 SYMBOL_SLOT_NOT_FOUND
,
152 struct symbol_cache_slot
154 enum symbol_cache_slot_state state
;
156 /* The objfile that was current when the symbol was looked up.
157 This is only needed for global blocks, but for simplicity's sake
158 we allocate the space for both. If data shows the extra space used
159 for static blocks is a problem, we can split things up then.
161 Global blocks need cache lookup to include the objfile context because
162 we need to account for gdbarch_iterate_over_objfiles_in_search_order
163 which can traverse objfiles in, effectively, any order, depending on
164 the current objfile, thus affecting which symbol is found. Normally,
165 only the current objfile is searched first, and then the rest are
166 searched in recorded order; but putting cache lookup inside
167 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
168 Instead we just make the current objfile part of the context of
169 cache lookup. This means we can record the same symbol multiple times,
170 each with a different "current objfile" that was in effect when the
171 lookup was saved in the cache, but cache space is pretty cheap. */
172 const struct objfile
*objfile_context
;
176 struct block_symbol found
;
185 /* Symbols don't specify global vs static block.
186 So keep them in separate caches. */
188 struct block_symbol_cache
192 unsigned int collisions
;
194 /* SYMBOLS is a variable length array of this size.
195 One can imagine that in general one cache (global/static) should be a
196 fraction of the size of the other, but there's no data at the moment
197 on which to decide. */
200 struct symbol_cache_slot symbols
[1];
205 Searching for symbols in the static and global blocks over multiple objfiles
206 again and again can be slow, as can searching very big objfiles. This is a
207 simple cache to improve symbol lookup performance, which is critical to
208 overall gdb performance.
210 Symbols are hashed on the name, its domain, and block.
211 They are also hashed on their objfile for objfile-specific lookups. */
215 symbol_cache () = default;
219 xfree (global_symbols
);
220 xfree (static_symbols
);
223 struct block_symbol_cache
*global_symbols
= nullptr;
224 struct block_symbol_cache
*static_symbols
= nullptr;
227 /* Program space key for finding its symbol cache. */
229 static const program_space_key
<symbol_cache
> symbol_cache_key
;
231 /* When non-zero, print debugging messages related to symtab creation. */
232 unsigned int symtab_create_debug
= 0;
234 /* When non-zero, print debugging messages related to symbol lookup. */
235 unsigned int symbol_lookup_debug
= 0;
237 /* The size of the cache is staged here. */
238 static unsigned int new_symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
240 /* The current value of the symbol cache size.
241 This is saved so that if the user enters a value too big we can restore
242 the original value from here. */
243 static unsigned int symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
245 /* True if a file may be known by two different basenames.
246 This is the uncommon case, and significantly slows down gdb.
247 Default set to "off" to not slow down the common case. */
248 bool basenames_may_differ
= false;
250 /* Allow the user to configure the debugger behavior with respect
251 to multiple-choice menus when more than one symbol matches during
254 const char multiple_symbols_ask
[] = "ask";
255 const char multiple_symbols_all
[] = "all";
256 const char multiple_symbols_cancel
[] = "cancel";
257 static const char *const multiple_symbols_modes
[] =
259 multiple_symbols_ask
,
260 multiple_symbols_all
,
261 multiple_symbols_cancel
,
264 static const char *multiple_symbols_mode
= multiple_symbols_all
;
266 /* Read-only accessor to AUTO_SELECT_MODE. */
269 multiple_symbols_select_mode (void)
271 return multiple_symbols_mode
;
274 /* Return the name of a domain_enum. */
277 domain_name (domain_enum e
)
281 case UNDEF_DOMAIN
: return "UNDEF_DOMAIN";
282 case VAR_DOMAIN
: return "VAR_DOMAIN";
283 case STRUCT_DOMAIN
: return "STRUCT_DOMAIN";
284 case MODULE_DOMAIN
: return "MODULE_DOMAIN";
285 case LABEL_DOMAIN
: return "LABEL_DOMAIN";
286 case COMMON_BLOCK_DOMAIN
: return "COMMON_BLOCK_DOMAIN";
287 default: gdb_assert_not_reached ("bad domain_enum");
291 /* Return the name of a search_domain . */
294 search_domain_name (enum search_domain e
)
298 case VARIABLES_DOMAIN
: return "VARIABLES_DOMAIN";
299 case FUNCTIONS_DOMAIN
: return "FUNCTIONS_DOMAIN";
300 case TYPES_DOMAIN
: return "TYPES_DOMAIN";
301 case ALL_DOMAIN
: return "ALL_DOMAIN";
302 default: gdb_assert_not_reached ("bad search_domain");
309 compunit_primary_filetab (const struct compunit_symtab
*cust
)
311 gdb_assert (COMPUNIT_FILETABS (cust
) != NULL
);
313 /* The primary file symtab is the first one in the list. */
314 return COMPUNIT_FILETABS (cust
);
320 compunit_language (const struct compunit_symtab
*cust
)
322 struct symtab
*symtab
= compunit_primary_filetab (cust
);
324 /* The language of the compunit symtab is the language of its primary
326 return SYMTAB_LANGUAGE (symtab
);
332 minimal_symbol::data_p () const
334 return type
== mst_data
337 || type
== mst_file_data
338 || type
== mst_file_bss
;
344 minimal_symbol::text_p () const
346 return type
== mst_text
347 || type
== mst_text_gnu_ifunc
348 || type
== mst_data_gnu_ifunc
349 || type
== mst_slot_got_plt
350 || type
== mst_solib_trampoline
351 || type
== mst_file_text
;
354 /* See whether FILENAME matches SEARCH_NAME using the rule that we
355 advertise to the user. (The manual's description of linespecs
356 describes what we advertise). Returns true if they match, false
360 compare_filenames_for_search (const char *filename
, const char *search_name
)
362 int len
= strlen (filename
);
363 size_t search_len
= strlen (search_name
);
365 if (len
< search_len
)
368 /* The tail of FILENAME must match. */
369 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
372 /* Either the names must completely match, or the character
373 preceding the trailing SEARCH_NAME segment of FILENAME must be a
376 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
377 cannot match FILENAME "/path//dir/file.c" - as user has requested
378 absolute path. The sama applies for "c:\file.c" possibly
379 incorrectly hypothetically matching "d:\dir\c:\file.c".
381 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
382 compatible with SEARCH_NAME "file.c". In such case a compiler had
383 to put the "c:file.c" name into debug info. Such compatibility
384 works only on GDB built for DOS host. */
385 return (len
== search_len
386 || (!IS_ABSOLUTE_PATH (search_name
)
387 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
388 || (HAS_DRIVE_SPEC (filename
)
389 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
392 /* Same as compare_filenames_for_search, but for glob-style patterns.
393 Heads up on the order of the arguments. They match the order of
394 compare_filenames_for_search, but it's the opposite of the order of
395 arguments to gdb_filename_fnmatch. */
398 compare_glob_filenames_for_search (const char *filename
,
399 const char *search_name
)
401 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
402 all /s have to be explicitly specified. */
403 int file_path_elements
= count_path_elements (filename
);
404 int search_path_elements
= count_path_elements (search_name
);
406 if (search_path_elements
> file_path_elements
)
409 if (IS_ABSOLUTE_PATH (search_name
))
411 return (search_path_elements
== file_path_elements
412 && gdb_filename_fnmatch (search_name
, filename
,
413 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0);
417 const char *file_to_compare
418 = strip_leading_path_elements (filename
,
419 file_path_elements
- search_path_elements
);
421 return gdb_filename_fnmatch (search_name
, file_to_compare
,
422 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0;
426 /* Check for a symtab of a specific name by searching some symtabs.
427 This is a helper function for callbacks of iterate_over_symtabs.
429 If NAME is not absolute, then REAL_PATH is NULL
430 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
432 The return value, NAME, REAL_PATH and CALLBACK are identical to the
433 `map_symtabs_matching_filename' method of quick_symbol_functions.
435 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
436 Each symtab within the specified compunit symtab is also searched.
437 AFTER_LAST is one past the last compunit symtab to search; NULL means to
438 search until the end of the list. */
441 iterate_over_some_symtabs (const char *name
,
442 const char *real_path
,
443 struct compunit_symtab
*first
,
444 struct compunit_symtab
*after_last
,
445 gdb::function_view
<bool (symtab
*)> callback
)
447 struct compunit_symtab
*cust
;
448 const char* base_name
= lbasename (name
);
450 for (cust
= first
; cust
!= NULL
&& cust
!= after_last
; cust
= cust
->next
)
452 for (symtab
*s
: compunit_filetabs (cust
))
454 if (compare_filenames_for_search (s
->filename
, name
))
461 /* Before we invoke realpath, which can get expensive when many
462 files are involved, do a quick comparison of the basenames. */
463 if (! basenames_may_differ
464 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
467 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
474 /* If the user gave us an absolute path, try to find the file in
475 this symtab and use its absolute path. */
476 if (real_path
!= NULL
)
478 const char *fullname
= symtab_to_fullname (s
);
480 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
481 gdb_assert (IS_ABSOLUTE_PATH (name
));
482 if (FILENAME_CMP (real_path
, fullname
) == 0)
495 /* Check for a symtab of a specific name; first in symtabs, then in
496 psymtabs. *If* there is no '/' in the name, a match after a '/'
497 in the symtab filename will also work.
499 Calls CALLBACK with each symtab that is found. If CALLBACK returns
500 true, the search stops. */
503 iterate_over_symtabs (const char *name
,
504 gdb::function_view
<bool (symtab
*)> callback
)
506 gdb::unique_xmalloc_ptr
<char> real_path
;
508 /* Here we are interested in canonicalizing an absolute path, not
509 absolutizing a relative path. */
510 if (IS_ABSOLUTE_PATH (name
))
512 real_path
= gdb_realpath (name
);
513 gdb_assert (IS_ABSOLUTE_PATH (real_path
.get ()));
516 for (objfile
*objfile
: current_program_space
->objfiles ())
518 if (iterate_over_some_symtabs (name
, real_path
.get (),
519 objfile
->compunit_symtabs
, NULL
,
524 /* Same search rules as above apply here, but now we look thru the
527 for (objfile
*objfile
: current_program_space
->objfiles ())
530 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
538 /* A wrapper for iterate_over_symtabs that returns the first matching
542 lookup_symtab (const char *name
)
544 struct symtab
*result
= NULL
;
546 iterate_over_symtabs (name
, [&] (symtab
*symtab
)
556 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
557 full method name, which consist of the class name (from T), the unadorned
558 method name from METHOD_ID, and the signature for the specific overload,
559 specified by SIGNATURE_ID. Note that this function is g++ specific. */
562 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
564 int mangled_name_len
;
566 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
567 struct fn_field
*method
= &f
[signature_id
];
568 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
569 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
570 const char *newname
= TYPE_NAME (type
);
572 /* Does the form of physname indicate that it is the full mangled name
573 of a constructor (not just the args)? */
574 int is_full_physname_constructor
;
577 int is_destructor
= is_destructor_name (physname
);
578 /* Need a new type prefix. */
579 const char *const_prefix
= method
->is_const
? "C" : "";
580 const char *volatile_prefix
= method
->is_volatile
? "V" : "";
582 int len
= (newname
== NULL
? 0 : strlen (newname
));
584 /* Nothing to do if physname already contains a fully mangled v3 abi name
585 or an operator name. */
586 if ((physname
[0] == '_' && physname
[1] == 'Z')
587 || is_operator_name (field_name
))
588 return xstrdup (physname
);
590 is_full_physname_constructor
= is_constructor_name (physname
);
592 is_constructor
= is_full_physname_constructor
593 || (newname
&& strcmp (field_name
, newname
) == 0);
596 is_destructor
= (startswith (physname
, "__dt"));
598 if (is_destructor
|| is_full_physname_constructor
)
600 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
601 strcpy (mangled_name
, physname
);
607 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
609 else if (physname
[0] == 't' || physname
[0] == 'Q')
611 /* The physname for template and qualified methods already includes
613 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
619 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
620 volatile_prefix
, len
);
622 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
623 + strlen (buf
) + len
+ strlen (physname
) + 1);
625 mangled_name
= (char *) xmalloc (mangled_name_len
);
627 mangled_name
[0] = '\0';
629 strcpy (mangled_name
, field_name
);
631 strcat (mangled_name
, buf
);
632 /* If the class doesn't have a name, i.e. newname NULL, then we just
633 mangle it using 0 for the length of the class. Thus it gets mangled
634 as something starting with `::' rather than `classname::'. */
636 strcat (mangled_name
, newname
);
638 strcat (mangled_name
, physname
);
639 return (mangled_name
);
642 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
643 correctly allocated. */
646 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
648 struct obstack
*obstack
)
650 if (gsymbol
->language
== language_ada
)
654 gsymbol
->ada_mangled
= 0;
655 gsymbol
->language_specific
.obstack
= obstack
;
659 gsymbol
->ada_mangled
= 1;
660 gsymbol
->language_specific
.demangled_name
= name
;
664 gsymbol
->language_specific
.demangled_name
= name
;
667 /* Return the demangled name of GSYMBOL. */
670 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
672 if (gsymbol
->language
== language_ada
)
674 if (!gsymbol
->ada_mangled
)
679 return gsymbol
->language_specific
.demangled_name
;
683 /* Initialize the language dependent portion of a symbol
684 depending upon the language for the symbol. */
687 symbol_set_language (struct general_symbol_info
*gsymbol
,
688 enum language language
,
689 struct obstack
*obstack
)
691 gsymbol
->language
= language
;
692 if (gsymbol
->language
== language_cplus
693 || gsymbol
->language
== language_d
694 || gsymbol
->language
== language_go
695 || gsymbol
->language
== language_objc
696 || gsymbol
->language
== language_fortran
)
698 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
700 else if (gsymbol
->language
== language_ada
)
702 gdb_assert (gsymbol
->ada_mangled
== 0);
703 gsymbol
->language_specific
.obstack
= obstack
;
707 memset (&gsymbol
->language_specific
, 0,
708 sizeof (gsymbol
->language_specific
));
712 /* Functions to initialize a symbol's mangled name. */
714 /* Objects of this type are stored in the demangled name hash table. */
715 struct demangled_name_entry
717 gdb::string_view mangled
;
718 ENUM_BITFIELD(language
) language
: LANGUAGE_BITS
;
722 /* Hash function for the demangled name hash. */
725 hash_demangled_name_entry (const void *data
)
727 const struct demangled_name_entry
*e
728 = (const struct demangled_name_entry
*) data
;
730 return iterative_hash (e
->mangled
.data (), e
->mangled
.length (), 0);
733 /* Equality function for the demangled name hash. */
736 eq_demangled_name_entry (const void *a
, const void *b
)
738 const struct demangled_name_entry
*da
739 = (const struct demangled_name_entry
*) a
;
740 const struct demangled_name_entry
*db
741 = (const struct demangled_name_entry
*) b
;
743 return da
->mangled
== db
->mangled
;
746 /* Create the hash table used for demangled names. Each hash entry is
747 a pair of strings; one for the mangled name and one for the demangled
748 name. The entry is hashed via just the mangled name. */
751 create_demangled_names_hash (struct objfile_per_bfd_storage
*per_bfd
)
753 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
754 The hash table code will round this up to the next prime number.
755 Choosing a much larger table size wastes memory, and saves only about
756 1% in symbol reading. */
758 per_bfd
->demangled_names_hash
.reset (htab_create_alloc
759 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
760 NULL
, xcalloc
, xfree
));
763 /* Try to determine the demangled name for a symbol, based on the
764 language of that symbol. If the language is set to language_auto,
765 it will attempt to find any demangling algorithm that works and
766 then set the language appropriately. The returned name is allocated
767 by the demangler and should be xfree'd. */
770 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
773 char *demangled
= NULL
;
776 if (gsymbol
->language
== language_unknown
)
777 gsymbol
->language
= language_auto
;
779 if (gsymbol
->language
!= language_auto
)
781 const struct language_defn
*lang
= language_def (gsymbol
->language
);
783 language_sniff_from_mangled_name (lang
, mangled
, &demangled
);
787 for (i
= language_unknown
; i
< nr_languages
; ++i
)
789 enum language l
= (enum language
) i
;
790 const struct language_defn
*lang
= language_def (l
);
792 if (language_sniff_from_mangled_name (lang
, mangled
, &demangled
))
794 gsymbol
->language
= l
;
802 /* Set both the mangled and demangled (if any) names for GSYMBOL based
803 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
804 objfile's obstack; but if COPY_NAME is 0 and if NAME is
805 NUL-terminated, then this function assumes that NAME is already
806 correctly saved (either permanently or with a lifetime tied to the
807 objfile), and it will not be copied.
809 The hash table corresponding to OBJFILE is used, and the memory
810 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
811 so the pointer can be discarded after calling this function. */
814 symbol_set_names (struct general_symbol_info
*gsymbol
,
815 const char *linkage_name
, int len
, bool copy_name
,
816 struct objfile_per_bfd_storage
*per_bfd
)
818 struct demangled_name_entry
**slot
;
819 /* A 0-terminated copy of the linkage name. */
820 const char *linkage_name_copy
;
821 struct demangled_name_entry entry
;
823 if (gsymbol
->language
== language_ada
)
825 /* In Ada, we do the symbol lookups using the mangled name, so
826 we can save some space by not storing the demangled name. */
828 gsymbol
->name
= linkage_name
;
831 char *name
= (char *) obstack_alloc (&per_bfd
->storage_obstack
,
834 memcpy (name
, linkage_name
, len
);
836 gsymbol
->name
= name
;
838 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
843 if (per_bfd
->demangled_names_hash
== NULL
)
844 create_demangled_names_hash (per_bfd
);
846 if (linkage_name
[len
] != '\0')
850 alloc_name
= (char *) alloca (len
+ 1);
851 memcpy (alloc_name
, linkage_name
, len
);
852 alloc_name
[len
] = '\0';
854 linkage_name_copy
= alloc_name
;
857 linkage_name_copy
= linkage_name
;
859 entry
.mangled
= gdb::string_view (linkage_name_copy
, len
);
860 slot
= ((struct demangled_name_entry
**)
861 htab_find_slot (per_bfd
->demangled_names_hash
.get (),
864 /* If this name is not in the hash table, add it. */
866 /* A C version of the symbol may have already snuck into the table.
867 This happens to, e.g., main.init (__go_init_main). Cope. */
868 || (gsymbol
->language
== language_go
869 && (*slot
)->demangled
[0] == '\0'))
871 char *demangled_name_ptr
872 = symbol_find_demangled_name (gsymbol
, linkage_name_copy
);
873 gdb::unique_xmalloc_ptr
<char> demangled_name (demangled_name_ptr
);
874 int demangled_len
= demangled_name
? strlen (demangled_name
.get ()) : 0;
876 /* Suppose we have demangled_name==NULL, copy_name==0, and
877 linkage_name_copy==linkage_name. In this case, we already have the
878 mangled name saved, and we don't have a demangled name. So,
879 you might think we could save a little space by not recording
880 this in the hash table at all.
882 It turns out that it is actually important to still save such
883 an entry in the hash table, because storing this name gives
884 us better bcache hit rates for partial symbols. */
885 if (!copy_name
&& linkage_name_copy
== linkage_name
)
888 = ((struct demangled_name_entry
*)
889 obstack_alloc (&per_bfd
->storage_obstack
,
890 offsetof (struct demangled_name_entry
, demangled
)
891 + demangled_len
+ 1));
892 (*slot
)->mangled
= gdb::string_view (linkage_name
, len
);
898 /* If we must copy the mangled name, put it directly after
899 the demangled name so we can have a single
902 = ((struct demangled_name_entry
*)
903 obstack_alloc (&per_bfd
->storage_obstack
,
904 offsetof (struct demangled_name_entry
, demangled
)
905 + len
+ demangled_len
+ 2));
906 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
907 strcpy (mangled_ptr
, linkage_name_copy
);
908 (*slot
)->mangled
= gdb::string_view (mangled_ptr
, len
);
910 (*slot
)->language
= gsymbol
->language
;
912 if (demangled_name
!= NULL
)
913 strcpy ((*slot
)->demangled
, demangled_name
.get ());
915 (*slot
)->demangled
[0] = '\0';
917 else if (gsymbol
->language
== language_unknown
918 || gsymbol
->language
== language_auto
)
919 gsymbol
->language
= (*slot
)->language
;
921 gsymbol
->name
= (*slot
)->mangled
.data ();
922 if ((*slot
)->demangled
[0] != '\0')
923 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
924 &per_bfd
->storage_obstack
);
926 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
929 /* Return the source code name of a symbol. In languages where
930 demangling is necessary, this is the demangled name. */
933 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
935 switch (gsymbol
->language
)
941 case language_fortran
:
942 if (symbol_get_demangled_name (gsymbol
) != NULL
)
943 return symbol_get_demangled_name (gsymbol
);
946 return ada_decode_symbol (gsymbol
);
950 return gsymbol
->name
;
953 /* Return the demangled name for a symbol based on the language for
954 that symbol. If no demangled name exists, return NULL. */
957 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
959 const char *dem_name
= NULL
;
961 switch (gsymbol
->language
)
967 case language_fortran
:
968 dem_name
= symbol_get_demangled_name (gsymbol
);
971 dem_name
= ada_decode_symbol (gsymbol
);
979 /* Return the search name of a symbol---generally the demangled or
980 linkage name of the symbol, depending on how it will be searched for.
981 If there is no distinct demangled name, then returns the same value
982 (same pointer) as SYMBOL_LINKAGE_NAME. */
985 symbol_search_name (const struct general_symbol_info
*gsymbol
)
987 if (gsymbol
->language
== language_ada
)
988 return gsymbol
->name
;
990 return symbol_natural_name (gsymbol
);
996 symbol_matches_search_name (const struct general_symbol_info
*gsymbol
,
997 const lookup_name_info
&name
)
999 symbol_name_matcher_ftype
*name_match
1000 = get_symbol_name_matcher (language_def (gsymbol
->language
), name
);
1001 return name_match (symbol_search_name (gsymbol
), name
, NULL
);
1006 /* Return true if the two sections are the same, or if they could
1007 plausibly be copies of each other, one in an original object
1008 file and another in a separated debug file. */
1011 matching_obj_sections (struct obj_section
*obj_first
,
1012 struct obj_section
*obj_second
)
1014 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
1015 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
1017 /* If they're the same section, then they match. */
1018 if (first
== second
)
1021 /* If either is NULL, give up. */
1022 if (first
== NULL
|| second
== NULL
)
1025 /* This doesn't apply to absolute symbols. */
1026 if (first
->owner
== NULL
|| second
->owner
== NULL
)
1029 /* If they're in the same object file, they must be different sections. */
1030 if (first
->owner
== second
->owner
)
1033 /* Check whether the two sections are potentially corresponding. They must
1034 have the same size, address, and name. We can't compare section indexes,
1035 which would be more reliable, because some sections may have been
1037 if (bfd_section_size (first
) != bfd_section_size (second
))
1040 /* In-memory addresses may start at a different offset, relativize them. */
1041 if (bfd_section_vma (first
) - bfd_get_start_address (first
->owner
)
1042 != bfd_section_vma (second
) - bfd_get_start_address (second
->owner
))
1045 if (bfd_section_name (first
) == NULL
1046 || bfd_section_name (second
) == NULL
1047 || strcmp (bfd_section_name (first
), bfd_section_name (second
)) != 0)
1050 /* Otherwise check that they are in corresponding objfiles. */
1052 struct objfile
*obj
= NULL
;
1053 for (objfile
*objfile
: current_program_space
->objfiles ())
1054 if (objfile
->obfd
== first
->owner
)
1059 gdb_assert (obj
!= NULL
);
1061 if (obj
->separate_debug_objfile
!= NULL
1062 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1064 if (obj
->separate_debug_objfile_backlink
!= NULL
1065 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1074 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1076 struct bound_minimal_symbol msymbol
;
1078 /* If we know that this is not a text address, return failure. This is
1079 necessary because we loop based on texthigh and textlow, which do
1080 not include the data ranges. */
1081 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1082 if (msymbol
.minsym
&& msymbol
.minsym
->data_p ())
1085 for (objfile
*objfile
: current_program_space
->objfiles ())
1087 struct compunit_symtab
*cust
= NULL
;
1090 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1097 /* Hash function for the symbol cache. */
1100 hash_symbol_entry (const struct objfile
*objfile_context
,
1101 const char *name
, domain_enum domain
)
1103 unsigned int hash
= (uintptr_t) objfile_context
;
1106 hash
+= htab_hash_string (name
);
1108 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1109 to map to the same slot. */
1110 if (domain
== STRUCT_DOMAIN
)
1111 hash
+= VAR_DOMAIN
* 7;
1118 /* Equality function for the symbol cache. */
1121 eq_symbol_entry (const struct symbol_cache_slot
*slot
,
1122 const struct objfile
*objfile_context
,
1123 const char *name
, domain_enum domain
)
1125 const char *slot_name
;
1126 domain_enum slot_domain
;
1128 if (slot
->state
== SYMBOL_SLOT_UNUSED
)
1131 if (slot
->objfile_context
!= objfile_context
)
1134 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1136 slot_name
= slot
->value
.not_found
.name
;
1137 slot_domain
= slot
->value
.not_found
.domain
;
1141 slot_name
= SYMBOL_SEARCH_NAME (slot
->value
.found
.symbol
);
1142 slot_domain
= SYMBOL_DOMAIN (slot
->value
.found
.symbol
);
1145 /* NULL names match. */
1146 if (slot_name
== NULL
&& name
== NULL
)
1148 /* But there's no point in calling symbol_matches_domain in the
1149 SYMBOL_SLOT_FOUND case. */
1150 if (slot_domain
!= domain
)
1153 else if (slot_name
!= NULL
&& name
!= NULL
)
1155 /* It's important that we use the same comparison that was done
1156 the first time through. If the slot records a found symbol,
1157 then this means using the symbol name comparison function of
1158 the symbol's language with SYMBOL_SEARCH_NAME. See
1159 dictionary.c. It also means using symbol_matches_domain for
1160 found symbols. See block.c.
1162 If the slot records a not-found symbol, then require a precise match.
1163 We could still be lax with whitespace like strcmp_iw though. */
1165 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1167 if (strcmp (slot_name
, name
) != 0)
1169 if (slot_domain
!= domain
)
1174 struct symbol
*sym
= slot
->value
.found
.symbol
;
1175 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1177 if (!SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
1180 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1181 slot_domain
, domain
))
1187 /* Only one name is NULL. */
1194 /* Given a cache of size SIZE, return the size of the struct (with variable
1195 length array) in bytes. */
1198 symbol_cache_byte_size (unsigned int size
)
1200 return (sizeof (struct block_symbol_cache
)
1201 + ((size
- 1) * sizeof (struct symbol_cache_slot
)));
1207 resize_symbol_cache (struct symbol_cache
*cache
, unsigned int new_size
)
1209 /* If there's no change in size, don't do anything.
1210 All caches have the same size, so we can just compare with the size
1211 of the global symbols cache. */
1212 if ((cache
->global_symbols
!= NULL
1213 && cache
->global_symbols
->size
== new_size
)
1214 || (cache
->global_symbols
== NULL
1218 xfree (cache
->global_symbols
);
1219 xfree (cache
->static_symbols
);
1223 cache
->global_symbols
= NULL
;
1224 cache
->static_symbols
= NULL
;
1228 size_t total_size
= symbol_cache_byte_size (new_size
);
1230 cache
->global_symbols
1231 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1232 cache
->static_symbols
1233 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1234 cache
->global_symbols
->size
= new_size
;
1235 cache
->static_symbols
->size
= new_size
;
1239 /* Return the symbol cache of PSPACE.
1240 Create one if it doesn't exist yet. */
1242 static struct symbol_cache
*
1243 get_symbol_cache (struct program_space
*pspace
)
1245 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1249 cache
= symbol_cache_key
.emplace (pspace
);
1250 resize_symbol_cache (cache
, symbol_cache_size
);
1256 /* Set the size of the symbol cache in all program spaces. */
1259 set_symbol_cache_size (unsigned int new_size
)
1261 struct program_space
*pspace
;
1263 ALL_PSPACES (pspace
)
1265 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1267 /* The pspace could have been created but not have a cache yet. */
1269 resize_symbol_cache (cache
, new_size
);
1273 /* Called when symbol-cache-size is set. */
1276 set_symbol_cache_size_handler (const char *args
, int from_tty
,
1277 struct cmd_list_element
*c
)
1279 if (new_symbol_cache_size
> MAX_SYMBOL_CACHE_SIZE
)
1281 /* Restore the previous value.
1282 This is the value the "show" command prints. */
1283 new_symbol_cache_size
= symbol_cache_size
;
1285 error (_("Symbol cache size is too large, max is %u."),
1286 MAX_SYMBOL_CACHE_SIZE
);
1288 symbol_cache_size
= new_symbol_cache_size
;
1290 set_symbol_cache_size (symbol_cache_size
);
1293 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1294 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1295 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1296 failed (and thus this one will too), or NULL if the symbol is not present
1298 *BSC_PTR and *SLOT_PTR are set to the cache and slot of the symbol, which
1299 can be used to save the result of a full lookup attempt. */
1301 static struct block_symbol
1302 symbol_cache_lookup (struct symbol_cache
*cache
,
1303 struct objfile
*objfile_context
, enum block_enum block
,
1304 const char *name
, domain_enum domain
,
1305 struct block_symbol_cache
**bsc_ptr
,
1306 struct symbol_cache_slot
**slot_ptr
)
1308 struct block_symbol_cache
*bsc
;
1310 struct symbol_cache_slot
*slot
;
1312 if (block
== GLOBAL_BLOCK
)
1313 bsc
= cache
->global_symbols
;
1315 bsc
= cache
->static_symbols
;
1323 hash
= hash_symbol_entry (objfile_context
, name
, domain
);
1324 slot
= bsc
->symbols
+ hash
% bsc
->size
;
1329 if (eq_symbol_entry (slot
, objfile_context
, name
, domain
))
1331 if (symbol_lookup_debug
)
1332 fprintf_unfiltered (gdb_stdlog
,
1333 "%s block symbol cache hit%s for %s, %s\n",
1334 block
== GLOBAL_BLOCK
? "Global" : "Static",
1335 slot
->state
== SYMBOL_SLOT_NOT_FOUND
1336 ? " (not found)" : "",
1337 name
, domain_name (domain
));
1339 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1340 return SYMBOL_LOOKUP_FAILED
;
1341 return slot
->value
.found
;
1344 /* Symbol is not present in the cache. */
1346 if (symbol_lookup_debug
)
1348 fprintf_unfiltered (gdb_stdlog
,
1349 "%s block symbol cache miss for %s, %s\n",
1350 block
== GLOBAL_BLOCK
? "Global" : "Static",
1351 name
, domain_name (domain
));
1357 /* Clear out SLOT. */
1360 symbol_cache_clear_slot (struct symbol_cache_slot
*slot
)
1362 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1363 xfree (slot
->value
.not_found
.name
);
1364 slot
->state
= SYMBOL_SLOT_UNUSED
;
1367 /* Mark SYMBOL as found in SLOT.
1368 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1369 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1370 necessarily the objfile the symbol was found in. */
1373 symbol_cache_mark_found (struct block_symbol_cache
*bsc
,
1374 struct symbol_cache_slot
*slot
,
1375 struct objfile
*objfile_context
,
1376 struct symbol
*symbol
,
1377 const struct block
*block
)
1381 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1384 symbol_cache_clear_slot (slot
);
1386 slot
->state
= SYMBOL_SLOT_FOUND
;
1387 slot
->objfile_context
= objfile_context
;
1388 slot
->value
.found
.symbol
= symbol
;
1389 slot
->value
.found
.block
= block
;
1392 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1393 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1394 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1397 symbol_cache_mark_not_found (struct block_symbol_cache
*bsc
,
1398 struct symbol_cache_slot
*slot
,
1399 struct objfile
*objfile_context
,
1400 const char *name
, domain_enum domain
)
1404 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1407 symbol_cache_clear_slot (slot
);
1409 slot
->state
= SYMBOL_SLOT_NOT_FOUND
;
1410 slot
->objfile_context
= objfile_context
;
1411 slot
->value
.not_found
.name
= xstrdup (name
);
1412 slot
->value
.not_found
.domain
= domain
;
1415 /* Flush the symbol cache of PSPACE. */
1418 symbol_cache_flush (struct program_space
*pspace
)
1420 struct symbol_cache
*cache
= symbol_cache_key
.get (pspace
);
1425 if (cache
->global_symbols
== NULL
)
1427 gdb_assert (symbol_cache_size
== 0);
1428 gdb_assert (cache
->static_symbols
== NULL
);
1432 /* If the cache is untouched since the last flush, early exit.
1433 This is important for performance during the startup of a program linked
1434 with 100s (or 1000s) of shared libraries. */
1435 if (cache
->global_symbols
->misses
== 0
1436 && cache
->static_symbols
->misses
== 0)
1439 gdb_assert (cache
->global_symbols
->size
== symbol_cache_size
);
1440 gdb_assert (cache
->static_symbols
->size
== symbol_cache_size
);
1442 for (pass
= 0; pass
< 2; ++pass
)
1444 struct block_symbol_cache
*bsc
1445 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1448 for (i
= 0; i
< bsc
->size
; ++i
)
1449 symbol_cache_clear_slot (&bsc
->symbols
[i
]);
1452 cache
->global_symbols
->hits
= 0;
1453 cache
->global_symbols
->misses
= 0;
1454 cache
->global_symbols
->collisions
= 0;
1455 cache
->static_symbols
->hits
= 0;
1456 cache
->static_symbols
->misses
= 0;
1457 cache
->static_symbols
->collisions
= 0;
1463 symbol_cache_dump (const struct symbol_cache
*cache
)
1467 if (cache
->global_symbols
== NULL
)
1469 printf_filtered (" <disabled>\n");
1473 for (pass
= 0; pass
< 2; ++pass
)
1475 const struct block_symbol_cache
*bsc
1476 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1480 printf_filtered ("Global symbols:\n");
1482 printf_filtered ("Static symbols:\n");
1484 for (i
= 0; i
< bsc
->size
; ++i
)
1486 const struct symbol_cache_slot
*slot
= &bsc
->symbols
[i
];
1490 switch (slot
->state
)
1492 case SYMBOL_SLOT_UNUSED
:
1494 case SYMBOL_SLOT_NOT_FOUND
:
1495 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i
,
1496 host_address_to_string (slot
->objfile_context
),
1497 slot
->value
.not_found
.name
,
1498 domain_name (slot
->value
.not_found
.domain
));
1500 case SYMBOL_SLOT_FOUND
:
1502 struct symbol
*found
= slot
->value
.found
.symbol
;
1503 const struct objfile
*context
= slot
->objfile_context
;
1505 printf_filtered (" [%4u] = %s, %s %s\n", i
,
1506 host_address_to_string (context
),
1507 SYMBOL_PRINT_NAME (found
),
1508 domain_name (SYMBOL_DOMAIN (found
)));
1516 /* The "mt print symbol-cache" command. */
1519 maintenance_print_symbol_cache (const char *args
, int from_tty
)
1521 struct program_space
*pspace
;
1523 ALL_PSPACES (pspace
)
1525 struct symbol_cache
*cache
;
1527 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1529 pspace
->symfile_object_file
!= NULL
1530 ? objfile_name (pspace
->symfile_object_file
)
1531 : "(no object file)");
1533 /* If the cache hasn't been created yet, avoid creating one. */
1534 cache
= symbol_cache_key
.get (pspace
);
1536 printf_filtered (" <empty>\n");
1538 symbol_cache_dump (cache
);
1542 /* The "mt flush-symbol-cache" command. */
1545 maintenance_flush_symbol_cache (const char *args
, int from_tty
)
1547 struct program_space
*pspace
;
1549 ALL_PSPACES (pspace
)
1551 symbol_cache_flush (pspace
);
1555 /* Print usage statistics of CACHE. */
1558 symbol_cache_stats (struct symbol_cache
*cache
)
1562 if (cache
->global_symbols
== NULL
)
1564 printf_filtered (" <disabled>\n");
1568 for (pass
= 0; pass
< 2; ++pass
)
1570 const struct block_symbol_cache
*bsc
1571 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1576 printf_filtered ("Global block cache stats:\n");
1578 printf_filtered ("Static block cache stats:\n");
1580 printf_filtered (" size: %u\n", bsc
->size
);
1581 printf_filtered (" hits: %u\n", bsc
->hits
);
1582 printf_filtered (" misses: %u\n", bsc
->misses
);
1583 printf_filtered (" collisions: %u\n", bsc
->collisions
);
1587 /* The "mt print symbol-cache-statistics" command. */
1590 maintenance_print_symbol_cache_statistics (const char *args
, int from_tty
)
1592 struct program_space
*pspace
;
1594 ALL_PSPACES (pspace
)
1596 struct symbol_cache
*cache
;
1598 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1600 pspace
->symfile_object_file
!= NULL
1601 ? objfile_name (pspace
->symfile_object_file
)
1602 : "(no object file)");
1604 /* If the cache hasn't been created yet, avoid creating one. */
1605 cache
= symbol_cache_key
.get (pspace
);
1607 printf_filtered (" empty, no stats available\n");
1609 symbol_cache_stats (cache
);
1613 /* This module's 'new_objfile' observer. */
1616 symtab_new_objfile_observer (struct objfile
*objfile
)
1618 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1619 symbol_cache_flush (current_program_space
);
1622 /* This module's 'free_objfile' observer. */
1625 symtab_free_objfile_observer (struct objfile
*objfile
)
1627 symbol_cache_flush (objfile
->pspace
);
1630 /* Debug symbols usually don't have section information. We need to dig that
1631 out of the minimal symbols and stash that in the debug symbol. */
1634 fixup_section (struct general_symbol_info
*ginfo
,
1635 CORE_ADDR addr
, struct objfile
*objfile
)
1637 struct minimal_symbol
*msym
;
1639 /* First, check whether a minimal symbol with the same name exists
1640 and points to the same address. The address check is required
1641 e.g. on PowerPC64, where the minimal symbol for a function will
1642 point to the function descriptor, while the debug symbol will
1643 point to the actual function code. */
1644 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1646 ginfo
->section
= MSYMBOL_SECTION (msym
);
1649 /* Static, function-local variables do appear in the linker
1650 (minimal) symbols, but are frequently given names that won't
1651 be found via lookup_minimal_symbol(). E.g., it has been
1652 observed in frv-uclinux (ELF) executables that a static,
1653 function-local variable named "foo" might appear in the
1654 linker symbols as "foo.6" or "foo.3". Thus, there is no
1655 point in attempting to extend the lookup-by-name mechanism to
1656 handle this case due to the fact that there can be multiple
1659 So, instead, search the section table when lookup by name has
1660 failed. The ``addr'' and ``endaddr'' fields may have already
1661 been relocated. If so, the relocation offset (i.e. the
1662 ANOFFSET value) needs to be subtracted from these values when
1663 performing the comparison. We unconditionally subtract it,
1664 because, when no relocation has been performed, the ANOFFSET
1665 value will simply be zero.
1667 The address of the symbol whose section we're fixing up HAS
1668 NOT BEEN adjusted (relocated) yet. It can't have been since
1669 the section isn't yet known and knowing the section is
1670 necessary in order to add the correct relocation value. In
1671 other words, we wouldn't even be in this function (attempting
1672 to compute the section) if it were already known.
1674 Note that it is possible to search the minimal symbols
1675 (subtracting the relocation value if necessary) to find the
1676 matching minimal symbol, but this is overkill and much less
1677 efficient. It is not necessary to find the matching minimal
1678 symbol, only its section.
1680 Note that this technique (of doing a section table search)
1681 can fail when unrelocated section addresses overlap. For
1682 this reason, we still attempt a lookup by name prior to doing
1683 a search of the section table. */
1685 struct obj_section
*s
;
1688 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1690 int idx
= s
- objfile
->sections
;
1691 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1696 if (obj_section_addr (s
) - offset
<= addr
1697 && addr
< obj_section_endaddr (s
) - offset
)
1699 ginfo
->section
= idx
;
1704 /* If we didn't find the section, assume it is in the first
1705 section. If there is no allocated section, then it hardly
1706 matters what we pick, so just pick zero. */
1710 ginfo
->section
= fallback
;
1715 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1722 if (!SYMBOL_OBJFILE_OWNED (sym
))
1725 /* We either have an OBJFILE, or we can get at it from the sym's
1726 symtab. Anything else is a bug. */
1727 gdb_assert (objfile
|| symbol_symtab (sym
));
1729 if (objfile
== NULL
)
1730 objfile
= symbol_objfile (sym
);
1732 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1735 /* We should have an objfile by now. */
1736 gdb_assert (objfile
);
1738 switch (SYMBOL_CLASS (sym
))
1742 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1745 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1749 /* Nothing else will be listed in the minsyms -- no use looking
1754 fixup_section (&sym
->ginfo
, addr
, objfile
);
1761 demangle_for_lookup_info::demangle_for_lookup_info
1762 (const lookup_name_info
&lookup_name
, language lang
)
1764 demangle_result_storage storage
;
1766 if (lookup_name
.ignore_parameters () && lang
== language_cplus
)
1768 gdb::unique_xmalloc_ptr
<char> without_params
1769 = cp_remove_params_if_any (lookup_name
.name ().c_str (),
1770 lookup_name
.completion_mode ());
1772 if (without_params
!= NULL
)
1774 if (lookup_name
.match_type () != symbol_name_match_type::SEARCH_NAME
)
1775 m_demangled_name
= demangle_for_lookup (without_params
.get (),
1781 if (lookup_name
.match_type () == symbol_name_match_type::SEARCH_NAME
)
1782 m_demangled_name
= lookup_name
.name ();
1784 m_demangled_name
= demangle_for_lookup (lookup_name
.name ().c_str (),
1790 const lookup_name_info
&
1791 lookup_name_info::match_any ()
1793 /* Lookup any symbol that "" would complete. I.e., this matches all
1795 static const lookup_name_info
lookup_name ({}, symbol_name_match_type::FULL
,
1801 /* Compute the demangled form of NAME as used by the various symbol
1802 lookup functions. The result can either be the input NAME
1803 directly, or a pointer to a buffer owned by the STORAGE object.
1805 For Ada, this function just returns NAME, unmodified.
1806 Normally, Ada symbol lookups are performed using the encoded name
1807 rather than the demangled name, and so it might seem to make sense
1808 for this function to return an encoded version of NAME.
1809 Unfortunately, we cannot do this, because this function is used in
1810 circumstances where it is not appropriate to try to encode NAME.
1811 For instance, when displaying the frame info, we demangle the name
1812 of each parameter, and then perform a symbol lookup inside our
1813 function using that demangled name. In Ada, certain functions
1814 have internally-generated parameters whose name contain uppercase
1815 characters. Encoding those name would result in those uppercase
1816 characters to become lowercase, and thus cause the symbol lookup
1820 demangle_for_lookup (const char *name
, enum language lang
,
1821 demangle_result_storage
&storage
)
1823 /* If we are using C++, D, or Go, demangle the name before doing a
1824 lookup, so we can always binary search. */
1825 if (lang
== language_cplus
)
1827 char *demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1828 if (demangled_name
!= NULL
)
1829 return storage
.set_malloc_ptr (demangled_name
);
1831 /* If we were given a non-mangled name, canonicalize it
1832 according to the language (so far only for C++). */
1833 std::string canon
= cp_canonicalize_string (name
);
1834 if (!canon
.empty ())
1835 return storage
.swap_string (canon
);
1837 else if (lang
== language_d
)
1839 char *demangled_name
= d_demangle (name
, 0);
1840 if (demangled_name
!= NULL
)
1841 return storage
.set_malloc_ptr (demangled_name
);
1843 else if (lang
== language_go
)
1845 char *demangled_name
= go_demangle (name
, 0);
1846 if (demangled_name
!= NULL
)
1847 return storage
.set_malloc_ptr (demangled_name
);
1856 search_name_hash (enum language language
, const char *search_name
)
1858 return language_def (language
)->la_search_name_hash (search_name
);
1863 This function (or rather its subordinates) have a bunch of loops and
1864 it would seem to be attractive to put in some QUIT's (though I'm not really
1865 sure whether it can run long enough to be really important). But there
1866 are a few calls for which it would appear to be bad news to quit
1867 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1868 that there is C++ code below which can error(), but that probably
1869 doesn't affect these calls since they are looking for a known
1870 variable and thus can probably assume it will never hit the C++
1874 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1875 const domain_enum domain
, enum language lang
,
1876 struct field_of_this_result
*is_a_field_of_this
)
1878 demangle_result_storage storage
;
1879 const char *modified_name
= demangle_for_lookup (name
, lang
, storage
);
1881 return lookup_symbol_aux (modified_name
,
1882 symbol_name_match_type::FULL
,
1883 block
, domain
, lang
,
1884 is_a_field_of_this
);
1890 lookup_symbol (const char *name
, const struct block
*block
,
1892 struct field_of_this_result
*is_a_field_of_this
)
1894 return lookup_symbol_in_language (name
, block
, domain
,
1895 current_language
->la_language
,
1896 is_a_field_of_this
);
1902 lookup_symbol_search_name (const char *search_name
, const struct block
*block
,
1905 return lookup_symbol_aux (search_name
, symbol_name_match_type::SEARCH_NAME
,
1906 block
, domain
, language_asm
, NULL
);
1912 lookup_language_this (const struct language_defn
*lang
,
1913 const struct block
*block
)
1915 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1918 if (symbol_lookup_debug
> 1)
1920 struct objfile
*objfile
= lookup_objfile_from_block (block
);
1922 fprintf_unfiltered (gdb_stdlog
,
1923 "lookup_language_this (%s, %s (objfile %s))",
1924 lang
->la_name
, host_address_to_string (block
),
1925 objfile_debug_name (objfile
));
1932 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
,
1933 symbol_name_match_type::SEARCH_NAME
,
1937 if (symbol_lookup_debug
> 1)
1939 fprintf_unfiltered (gdb_stdlog
, " = %s (%s, block %s)\n",
1940 SYMBOL_PRINT_NAME (sym
),
1941 host_address_to_string (sym
),
1942 host_address_to_string (block
));
1944 return (struct block_symbol
) {sym
, block
};
1946 if (BLOCK_FUNCTION (block
))
1948 block
= BLOCK_SUPERBLOCK (block
);
1951 if (symbol_lookup_debug
> 1)
1952 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1956 /* Given TYPE, a structure/union,
1957 return 1 if the component named NAME from the ultimate target
1958 structure/union is defined, otherwise, return 0. */
1961 check_field (struct type
*type
, const char *name
,
1962 struct field_of_this_result
*is_a_field_of_this
)
1966 /* The type may be a stub. */
1967 type
= check_typedef (type
);
1969 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1971 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1973 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1975 is_a_field_of_this
->type
= type
;
1976 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1981 /* C++: If it was not found as a data field, then try to return it
1982 as a pointer to a method. */
1984 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1986 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1988 is_a_field_of_this
->type
= type
;
1989 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1994 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1995 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
2001 /* Behave like lookup_symbol except that NAME is the natural name
2002 (e.g., demangled name) of the symbol that we're looking for. */
2004 static struct block_symbol
2005 lookup_symbol_aux (const char *name
, symbol_name_match_type match_type
,
2006 const struct block
*block
,
2007 const domain_enum domain
, enum language language
,
2008 struct field_of_this_result
*is_a_field_of_this
)
2010 struct block_symbol result
;
2011 const struct language_defn
*langdef
;
2013 if (symbol_lookup_debug
)
2015 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2017 fprintf_unfiltered (gdb_stdlog
,
2018 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
2019 name
, host_address_to_string (block
),
2021 ? objfile_debug_name (objfile
) : "NULL",
2022 domain_name (domain
), language_str (language
));
2025 /* Make sure we do something sensible with is_a_field_of_this, since
2026 the callers that set this parameter to some non-null value will
2027 certainly use it later. If we don't set it, the contents of
2028 is_a_field_of_this are undefined. */
2029 if (is_a_field_of_this
!= NULL
)
2030 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
2032 /* Search specified block and its superiors. Don't search
2033 STATIC_BLOCK or GLOBAL_BLOCK. */
2035 result
= lookup_local_symbol (name
, match_type
, block
, domain
, language
);
2036 if (result
.symbol
!= NULL
)
2038 if (symbol_lookup_debug
)
2040 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2041 host_address_to_string (result
.symbol
));
2046 /* If requested to do so by the caller and if appropriate for LANGUAGE,
2047 check to see if NAME is a field of `this'. */
2049 langdef
= language_def (language
);
2051 /* Don't do this check if we are searching for a struct. It will
2052 not be found by check_field, but will be found by other
2054 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
2056 result
= lookup_language_this (langdef
, block
);
2060 struct type
*t
= result
.symbol
->type
;
2062 /* I'm not really sure that type of this can ever
2063 be typedefed; just be safe. */
2064 t
= check_typedef (t
);
2065 if (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2066 t
= TYPE_TARGET_TYPE (t
);
2068 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2069 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2070 error (_("Internal error: `%s' is not an aggregate"),
2071 langdef
->la_name_of_this
);
2073 if (check_field (t
, name
, is_a_field_of_this
))
2075 if (symbol_lookup_debug
)
2077 fprintf_unfiltered (gdb_stdlog
,
2078 "lookup_symbol_aux (...) = NULL\n");
2085 /* Now do whatever is appropriate for LANGUAGE to look
2086 up static and global variables. */
2088 result
= langdef
->la_lookup_symbol_nonlocal (langdef
, name
, block
, domain
);
2089 if (result
.symbol
!= NULL
)
2091 if (symbol_lookup_debug
)
2093 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2094 host_address_to_string (result
.symbol
));
2099 /* Now search all static file-level symbols. Not strictly correct,
2100 but more useful than an error. */
2102 result
= lookup_static_symbol (name
, domain
);
2103 if (symbol_lookup_debug
)
2105 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2106 result
.symbol
!= NULL
2107 ? host_address_to_string (result
.symbol
)
2113 /* Check to see if the symbol is defined in BLOCK or its superiors.
2114 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2116 static struct block_symbol
2117 lookup_local_symbol (const char *name
,
2118 symbol_name_match_type match_type
,
2119 const struct block
*block
,
2120 const domain_enum domain
,
2121 enum language language
)
2124 const struct block
*static_block
= block_static_block (block
);
2125 const char *scope
= block_scope (block
);
2127 /* Check if either no block is specified or it's a global block. */
2129 if (static_block
== NULL
)
2132 while (block
!= static_block
)
2134 sym
= lookup_symbol_in_block (name
, match_type
, block
, domain
);
2136 return (struct block_symbol
) {sym
, block
};
2138 if (language
== language_cplus
|| language
== language_fortran
)
2140 struct block_symbol blocksym
2141 = cp_lookup_symbol_imports_or_template (scope
, name
, block
,
2144 if (blocksym
.symbol
!= NULL
)
2148 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
2150 block
= BLOCK_SUPERBLOCK (block
);
2153 /* We've reached the end of the function without finding a result. */
2161 lookup_objfile_from_block (const struct block
*block
)
2166 block
= block_global_block (block
);
2167 /* Look through all blockvectors. */
2168 for (objfile
*obj
: current_program_space
->objfiles ())
2170 for (compunit_symtab
*cust
: obj
->compunits ())
2171 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
2174 if (obj
->separate_debug_objfile_backlink
)
2175 obj
= obj
->separate_debug_objfile_backlink
;
2187 lookup_symbol_in_block (const char *name
, symbol_name_match_type match_type
,
2188 const struct block
*block
,
2189 const domain_enum domain
)
2193 if (symbol_lookup_debug
> 1)
2195 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2197 fprintf_unfiltered (gdb_stdlog
,
2198 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2199 name
, host_address_to_string (block
),
2200 objfile_debug_name (objfile
),
2201 domain_name (domain
));
2204 sym
= block_lookup_symbol (block
, name
, match_type
, domain
);
2207 if (symbol_lookup_debug
> 1)
2209 fprintf_unfiltered (gdb_stdlog
, " = %s\n",
2210 host_address_to_string (sym
));
2212 return fixup_symbol_section (sym
, NULL
);
2215 if (symbol_lookup_debug
> 1)
2216 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2223 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
2224 enum block_enum block_index
,
2226 const domain_enum domain
)
2228 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2230 for (objfile
*objfile
: main_objfile
->separate_debug_objfiles ())
2232 struct block_symbol result
2233 = lookup_symbol_in_objfile (objfile
, block_index
, name
, domain
);
2235 if (result
.symbol
!= nullptr)
2242 /* Check to see if the symbol is defined in one of the OBJFILE's
2243 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2244 depending on whether or not we want to search global symbols or
2247 static struct block_symbol
2248 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
,
2249 enum block_enum block_index
, const char *name
,
2250 const domain_enum domain
)
2252 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2254 if (symbol_lookup_debug
> 1)
2256 fprintf_unfiltered (gdb_stdlog
,
2257 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2258 objfile_debug_name (objfile
),
2259 block_index
== GLOBAL_BLOCK
2260 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2261 name
, domain_name (domain
));
2264 for (compunit_symtab
*cust
: objfile
->compunits ())
2266 const struct blockvector
*bv
;
2267 const struct block
*block
;
2268 struct block_symbol result
;
2270 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2271 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2272 result
.symbol
= block_lookup_symbol_primary (block
, name
, domain
);
2273 result
.block
= block
;
2274 if (result
.symbol
!= NULL
)
2276 if (symbol_lookup_debug
> 1)
2278 fprintf_unfiltered (gdb_stdlog
, " = %s (block %s)\n",
2279 host_address_to_string (result
.symbol
),
2280 host_address_to_string (block
));
2282 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2288 if (symbol_lookup_debug
> 1)
2289 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2293 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2294 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2295 and all associated separate debug objfiles.
2297 Normally we only look in OBJFILE, and not any separate debug objfiles
2298 because the outer loop will cause them to be searched too. This case is
2299 different. Here we're called from search_symbols where it will only
2300 call us for the objfile that contains a matching minsym. */
2302 static struct block_symbol
2303 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
2304 const char *linkage_name
,
2307 enum language lang
= current_language
->la_language
;
2308 struct objfile
*main_objfile
;
2310 demangle_result_storage storage
;
2311 const char *modified_name
= demangle_for_lookup (linkage_name
, lang
, storage
);
2313 if (objfile
->separate_debug_objfile_backlink
)
2314 main_objfile
= objfile
->separate_debug_objfile_backlink
;
2316 main_objfile
= objfile
;
2318 for (::objfile
*cur_objfile
: main_objfile
->separate_debug_objfiles ())
2320 struct block_symbol result
;
2322 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
2323 modified_name
, domain
);
2324 if (result
.symbol
== NULL
)
2325 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
2326 modified_name
, domain
);
2327 if (result
.symbol
!= NULL
)
2334 /* A helper function that throws an exception when a symbol was found
2335 in a psymtab but not in a symtab. */
2337 static void ATTRIBUTE_NORETURN
2338 error_in_psymtab_expansion (enum block_enum block_index
, const char *name
,
2339 struct compunit_symtab
*cust
)
2342 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2343 %s may be an inlined function, or may be a template function\n \
2344 (if a template, try specifying an instantiation: %s<type>)."),
2345 block_index
== GLOBAL_BLOCK
? "global" : "static",
2347 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
2351 /* A helper function for various lookup routines that interfaces with
2352 the "quick" symbol table functions. */
2354 static struct block_symbol
2355 lookup_symbol_via_quick_fns (struct objfile
*objfile
,
2356 enum block_enum block_index
, const char *name
,
2357 const domain_enum domain
)
2359 struct compunit_symtab
*cust
;
2360 const struct blockvector
*bv
;
2361 const struct block
*block
;
2362 struct block_symbol result
;
2367 if (symbol_lookup_debug
> 1)
2369 fprintf_unfiltered (gdb_stdlog
,
2370 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2371 objfile_debug_name (objfile
),
2372 block_index
== GLOBAL_BLOCK
2373 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2374 name
, domain_name (domain
));
2377 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
2380 if (symbol_lookup_debug
> 1)
2382 fprintf_unfiltered (gdb_stdlog
,
2383 "lookup_symbol_via_quick_fns (...) = NULL\n");
2388 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2389 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2390 result
.symbol
= block_lookup_symbol (block
, name
,
2391 symbol_name_match_type::FULL
, domain
);
2392 if (result
.symbol
== NULL
)
2393 error_in_psymtab_expansion (block_index
, name
, cust
);
2395 if (symbol_lookup_debug
> 1)
2397 fprintf_unfiltered (gdb_stdlog
,
2398 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2399 host_address_to_string (result
.symbol
),
2400 host_address_to_string (block
));
2403 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2404 result
.block
= block
;
2411 basic_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2413 const struct block
*block
,
2414 const domain_enum domain
)
2416 struct block_symbol result
;
2418 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2419 the current objfile. Searching the current objfile first is useful
2420 for both matching user expectations as well as performance. */
2422 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2423 if (result
.symbol
!= NULL
)
2426 /* If we didn't find a definition for a builtin type in the static block,
2427 search for it now. This is actually the right thing to do and can be
2428 a massive performance win. E.g., when debugging a program with lots of
2429 shared libraries we could search all of them only to find out the
2430 builtin type isn't defined in any of them. This is common for types
2432 if (domain
== VAR_DOMAIN
)
2434 struct gdbarch
*gdbarch
;
2437 gdbarch
= target_gdbarch ();
2439 gdbarch
= block_gdbarch (block
);
2440 result
.symbol
= language_lookup_primitive_type_as_symbol (langdef
,
2442 result
.block
= NULL
;
2443 if (result
.symbol
!= NULL
)
2447 return lookup_global_symbol (name
, block
, domain
);
2453 lookup_symbol_in_static_block (const char *name
,
2454 const struct block
*block
,
2455 const domain_enum domain
)
2457 const struct block
*static_block
= block_static_block (block
);
2460 if (static_block
== NULL
)
2463 if (symbol_lookup_debug
)
2465 struct objfile
*objfile
= lookup_objfile_from_block (static_block
);
2467 fprintf_unfiltered (gdb_stdlog
,
2468 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2471 host_address_to_string (block
),
2472 objfile_debug_name (objfile
),
2473 domain_name (domain
));
2476 sym
= lookup_symbol_in_block (name
,
2477 symbol_name_match_type::FULL
,
2478 static_block
, domain
);
2479 if (symbol_lookup_debug
)
2481 fprintf_unfiltered (gdb_stdlog
,
2482 "lookup_symbol_in_static_block (...) = %s\n",
2483 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
2485 return (struct block_symbol
) {sym
, static_block
};
2488 /* Perform the standard symbol lookup of NAME in OBJFILE:
2489 1) First search expanded symtabs, and if not found
2490 2) Search the "quick" symtabs (partial or .gdb_index).
2491 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2493 static struct block_symbol
2494 lookup_symbol_in_objfile (struct objfile
*objfile
, enum block_enum block_index
,
2495 const char *name
, const domain_enum domain
)
2497 struct block_symbol result
;
2499 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2501 if (symbol_lookup_debug
)
2503 fprintf_unfiltered (gdb_stdlog
,
2504 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2505 objfile_debug_name (objfile
),
2506 block_index
== GLOBAL_BLOCK
2507 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2508 name
, domain_name (domain
));
2511 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
2513 if (result
.symbol
!= NULL
)
2515 if (symbol_lookup_debug
)
2517 fprintf_unfiltered (gdb_stdlog
,
2518 "lookup_symbol_in_objfile (...) = %s"
2520 host_address_to_string (result
.symbol
));
2525 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
2527 if (symbol_lookup_debug
)
2529 fprintf_unfiltered (gdb_stdlog
,
2530 "lookup_symbol_in_objfile (...) = %s%s\n",
2531 result
.symbol
!= NULL
2532 ? host_address_to_string (result
.symbol
)
2534 result
.symbol
!= NULL
? " (via quick fns)" : "");
2539 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2541 struct global_or_static_sym_lookup_data
2543 /* The name of the symbol we are searching for. */
2546 /* The domain to use for our search. */
2549 /* The block index in which to search. */
2550 enum block_enum block_index
;
2552 /* The field where the callback should store the symbol if found.
2553 It should be initialized to {NULL, NULL} before the search is started. */
2554 struct block_symbol result
;
2557 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2558 It searches by name for a symbol in the block given by BLOCK_INDEX of the
2559 given OBJFILE. The arguments for the search are passed via CB_DATA, which
2560 in reality is a pointer to struct global_or_static_sym_lookup_data. */
2563 lookup_symbol_global_or_static_iterator_cb (struct objfile
*objfile
,
2566 struct global_or_static_sym_lookup_data
*data
=
2567 (struct global_or_static_sym_lookup_data
*) cb_data
;
2569 gdb_assert (data
->result
.symbol
== NULL
2570 && data
->result
.block
== NULL
);
2572 data
->result
= lookup_symbol_in_objfile (objfile
, data
->block_index
,
2573 data
->name
, data
->domain
);
2575 /* If we found a match, tell the iterator to stop. Otherwise,
2577 return (data
->result
.symbol
!= NULL
);
2580 /* This function contains the common code of lookup_{global,static}_symbol.
2581 OBJFILE is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is
2582 the objfile to start the lookup in. */
2584 static struct block_symbol
2585 lookup_global_or_static_symbol (const char *name
,
2586 enum block_enum block_index
,
2587 struct objfile
*objfile
,
2588 const domain_enum domain
)
2590 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2591 struct block_symbol result
;
2592 struct global_or_static_sym_lookup_data lookup_data
;
2593 struct block_symbol_cache
*bsc
;
2594 struct symbol_cache_slot
*slot
;
2596 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2597 gdb_assert (objfile
== nullptr || block_index
== GLOBAL_BLOCK
);
2599 /* First see if we can find the symbol in the cache.
2600 This works because we use the current objfile to qualify the lookup. */
2601 result
= symbol_cache_lookup (cache
, objfile
, block_index
, name
, domain
,
2603 if (result
.symbol
!= NULL
)
2605 if (SYMBOL_LOOKUP_FAILED_P (result
))
2610 /* Do a global search (of global blocks, heh). */
2611 if (result
.symbol
== NULL
)
2613 memset (&lookup_data
, 0, sizeof (lookup_data
));
2614 lookup_data
.name
= name
;
2615 lookup_data
.block_index
= block_index
;
2616 lookup_data
.domain
= domain
;
2617 gdbarch_iterate_over_objfiles_in_search_order
2618 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
2619 lookup_symbol_global_or_static_iterator_cb
, &lookup_data
, objfile
);
2620 result
= lookup_data
.result
;
2623 if (result
.symbol
!= NULL
)
2624 symbol_cache_mark_found (bsc
, slot
, objfile
, result
.symbol
, result
.block
);
2626 symbol_cache_mark_not_found (bsc
, slot
, objfile
, name
, domain
);
2634 lookup_static_symbol (const char *name
, const domain_enum domain
)
2636 return lookup_global_or_static_symbol (name
, STATIC_BLOCK
, nullptr, domain
);
2642 lookup_global_symbol (const char *name
,
2643 const struct block
*block
,
2644 const domain_enum domain
)
2646 /* If a block was passed in, we want to search the corresponding
2647 global block first. This yields "more expected" behavior, and is
2648 needed to support 'FILENAME'::VARIABLE lookups. */
2649 const struct block
*global_block
= block_global_block (block
);
2650 if (global_block
!= nullptr)
2652 symbol
*sym
= lookup_symbol_in_block (name
,
2653 symbol_name_match_type::FULL
,
2654 global_block
, domain
);
2656 return { sym
, global_block
};
2659 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2660 return lookup_global_or_static_symbol (name
, GLOBAL_BLOCK
, objfile
, domain
);
2664 symbol_matches_domain (enum language symbol_language
,
2665 domain_enum symbol_domain
,
2668 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2669 Similarly, any Ada type declaration implicitly defines a typedef. */
2670 if (symbol_language
== language_cplus
2671 || symbol_language
== language_d
2672 || symbol_language
== language_ada
2673 || symbol_language
== language_rust
)
2675 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
2676 && symbol_domain
== STRUCT_DOMAIN
)
2679 /* For all other languages, strict match is required. */
2680 return (symbol_domain
== domain
);
2686 lookup_transparent_type (const char *name
)
2688 return current_language
->la_lookup_transparent_type (name
);
2691 /* A helper for basic_lookup_transparent_type that interfaces with the
2692 "quick" symbol table functions. */
2694 static struct type
*
2695 basic_lookup_transparent_type_quick (struct objfile
*objfile
,
2696 enum block_enum block_index
,
2699 struct compunit_symtab
*cust
;
2700 const struct blockvector
*bv
;
2701 const struct block
*block
;
2706 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
2711 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2712 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2713 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2714 block_find_non_opaque_type
, NULL
);
2716 error_in_psymtab_expansion (block_index
, name
, cust
);
2717 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2718 return SYMBOL_TYPE (sym
);
2721 /* Subroutine of basic_lookup_transparent_type to simplify it.
2722 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2723 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2725 static struct type
*
2726 basic_lookup_transparent_type_1 (struct objfile
*objfile
,
2727 enum block_enum block_index
,
2730 const struct blockvector
*bv
;
2731 const struct block
*block
;
2732 const struct symbol
*sym
;
2734 for (compunit_symtab
*cust
: objfile
->compunits ())
2736 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2737 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2738 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2739 block_find_non_opaque_type
, NULL
);
2742 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2743 return SYMBOL_TYPE (sym
);
2750 /* The standard implementation of lookup_transparent_type. This code
2751 was modeled on lookup_symbol -- the parts not relevant to looking
2752 up types were just left out. In particular it's assumed here that
2753 types are available in STRUCT_DOMAIN and only in file-static or
2757 basic_lookup_transparent_type (const char *name
)
2761 /* Now search all the global symbols. Do the symtab's first, then
2762 check the psymtab's. If a psymtab indicates the existence
2763 of the desired name as a global, then do psymtab-to-symtab
2764 conversion on the fly and return the found symbol. */
2766 for (objfile
*objfile
: current_program_space
->objfiles ())
2768 t
= basic_lookup_transparent_type_1 (objfile
, GLOBAL_BLOCK
, name
);
2773 for (objfile
*objfile
: current_program_space
->objfiles ())
2775 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
2780 /* Now search the static file-level symbols.
2781 Not strictly correct, but more useful than an error.
2782 Do the symtab's first, then
2783 check the psymtab's. If a psymtab indicates the existence
2784 of the desired name as a file-level static, then do psymtab-to-symtab
2785 conversion on the fly and return the found symbol. */
2787 for (objfile
*objfile
: current_program_space
->objfiles ())
2789 t
= basic_lookup_transparent_type_1 (objfile
, STATIC_BLOCK
, name
);
2794 for (objfile
*objfile
: current_program_space
->objfiles ())
2796 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
2801 return (struct type
*) 0;
2807 iterate_over_symbols (const struct block
*block
,
2808 const lookup_name_info
&name
,
2809 const domain_enum domain
,
2810 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2812 struct block_iterator iter
;
2815 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2817 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2818 SYMBOL_DOMAIN (sym
), domain
))
2820 struct block_symbol block_sym
= {sym
, block
};
2822 if (!callback (&block_sym
))
2832 iterate_over_symbols_terminated
2833 (const struct block
*block
,
2834 const lookup_name_info
&name
,
2835 const domain_enum domain
,
2836 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2838 if (!iterate_over_symbols (block
, name
, domain
, callback
))
2840 struct block_symbol block_sym
= {nullptr, block
};
2841 return callback (&block_sym
);
2844 /* Find the compunit symtab associated with PC and SECTION.
2845 This will read in debug info as necessary. */
2847 struct compunit_symtab
*
2848 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2850 struct compunit_symtab
*best_cust
= NULL
;
2851 CORE_ADDR distance
= 0;
2852 struct bound_minimal_symbol msymbol
;
2854 /* If we know that this is not a text address, return failure. This is
2855 necessary because we loop based on the block's high and low code
2856 addresses, which do not include the data ranges, and because
2857 we call find_pc_sect_psymtab which has a similar restriction based
2858 on the partial_symtab's texthigh and textlow. */
2859 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2860 if (msymbol
.minsym
&& msymbol
.minsym
->data_p ())
2863 /* Search all symtabs for the one whose file contains our address, and which
2864 is the smallest of all the ones containing the address. This is designed
2865 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2866 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2867 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2869 This happens for native ecoff format, where code from included files
2870 gets its own symtab. The symtab for the included file should have
2871 been read in already via the dependency mechanism.
2872 It might be swifter to create several symtabs with the same name
2873 like xcoff does (I'm not sure).
2875 It also happens for objfiles that have their functions reordered.
2876 For these, the symtab we are looking for is not necessarily read in. */
2878 for (objfile
*obj_file
: current_program_space
->objfiles ())
2880 for (compunit_symtab
*cust
: obj_file
->compunits ())
2882 const struct block
*b
;
2883 const struct blockvector
*bv
;
2885 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2886 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2888 if (BLOCK_START (b
) <= pc
2889 && BLOCK_END (b
) > pc
2891 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2893 /* For an objfile that has its functions reordered,
2894 find_pc_psymtab will find the proper partial symbol table
2895 and we simply return its corresponding symtab. */
2896 /* In order to better support objfiles that contain both
2897 stabs and coff debugging info, we continue on if a psymtab
2899 if ((obj_file
->flags
& OBJF_REORDERED
) && obj_file
->sf
)
2901 struct compunit_symtab
*result
;
2904 = obj_file
->sf
->qf
->find_pc_sect_compunit_symtab (obj_file
,
2914 struct block_iterator iter
;
2915 struct symbol
*sym
= NULL
;
2917 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2919 fixup_symbol_section (sym
, obj_file
);
2920 if (matching_obj_sections (SYMBOL_OBJ_SECTION (obj_file
,
2926 continue; /* No symbol in this symtab matches
2929 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2935 if (best_cust
!= NULL
)
2938 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2940 for (objfile
*objf
: current_program_space
->objfiles ())
2942 struct compunit_symtab
*result
;
2946 result
= objf
->sf
->qf
->find_pc_sect_compunit_symtab (objf
,
2957 /* Find the compunit symtab associated with PC.
2958 This will read in debug info as necessary.
2959 Backward compatibility, no section. */
2961 struct compunit_symtab
*
2962 find_pc_compunit_symtab (CORE_ADDR pc
)
2964 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2970 find_symbol_at_address (CORE_ADDR address
)
2972 for (objfile
*objfile
: current_program_space
->objfiles ())
2974 if (objfile
->sf
== NULL
2975 || objfile
->sf
->qf
->find_compunit_symtab_by_address
== NULL
)
2978 struct compunit_symtab
*symtab
2979 = objfile
->sf
->qf
->find_compunit_symtab_by_address (objfile
, address
);
2982 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (symtab
);
2984 for (int i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; ++i
)
2986 const struct block
*b
= BLOCKVECTOR_BLOCK (bv
, i
);
2987 struct block_iterator iter
;
2990 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2992 if (SYMBOL_CLASS (sym
) == LOC_STATIC
2993 && SYMBOL_VALUE_ADDRESS (sym
) == address
)
3005 /* Find the source file and line number for a given PC value and SECTION.
3006 Return a structure containing a symtab pointer, a line number,
3007 and a pc range for the entire source line.
3008 The value's .pc field is NOT the specified pc.
3009 NOTCURRENT nonzero means, if specified pc is on a line boundary,
3010 use the line that ends there. Otherwise, in that case, the line
3011 that begins there is used. */
3013 /* The big complication here is that a line may start in one file, and end just
3014 before the start of another file. This usually occurs when you #include
3015 code in the middle of a subroutine. To properly find the end of a line's PC
3016 range, we must search all symtabs associated with this compilation unit, and
3017 find the one whose first PC is closer than that of the next line in this
3020 struct symtab_and_line
3021 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
3023 struct compunit_symtab
*cust
;
3024 struct linetable
*l
;
3026 struct linetable_entry
*item
;
3027 const struct blockvector
*bv
;
3028 struct bound_minimal_symbol msymbol
;
3030 /* Info on best line seen so far, and where it starts, and its file. */
3032 struct linetable_entry
*best
= NULL
;
3033 CORE_ADDR best_end
= 0;
3034 struct symtab
*best_symtab
= 0;
3036 /* Store here the first line number
3037 of a file which contains the line at the smallest pc after PC.
3038 If we don't find a line whose range contains PC,
3039 we will use a line one less than this,
3040 with a range from the start of that file to the first line's pc. */
3041 struct linetable_entry
*alt
= NULL
;
3043 /* Info on best line seen in this file. */
3045 struct linetable_entry
*prev
;
3047 /* If this pc is not from the current frame,
3048 it is the address of the end of a call instruction.
3049 Quite likely that is the start of the following statement.
3050 But what we want is the statement containing the instruction.
3051 Fudge the pc to make sure we get that. */
3053 /* It's tempting to assume that, if we can't find debugging info for
3054 any function enclosing PC, that we shouldn't search for line
3055 number info, either. However, GAS can emit line number info for
3056 assembly files --- very helpful when debugging hand-written
3057 assembly code. In such a case, we'd have no debug info for the
3058 function, but we would have line info. */
3063 /* elz: added this because this function returned the wrong
3064 information if the pc belongs to a stub (import/export)
3065 to call a shlib function. This stub would be anywhere between
3066 two functions in the target, and the line info was erroneously
3067 taken to be the one of the line before the pc. */
3069 /* RT: Further explanation:
3071 * We have stubs (trampolines) inserted between procedures.
3073 * Example: "shr1" exists in a shared library, and a "shr1" stub also
3074 * exists in the main image.
3076 * In the minimal symbol table, we have a bunch of symbols
3077 * sorted by start address. The stubs are marked as "trampoline",
3078 * the others appear as text. E.g.:
3080 * Minimal symbol table for main image
3081 * main: code for main (text symbol)
3082 * shr1: stub (trampoline symbol)
3083 * foo: code for foo (text symbol)
3085 * Minimal symbol table for "shr1" image:
3087 * shr1: code for shr1 (text symbol)
3090 * So the code below is trying to detect if we are in the stub
3091 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3092 * and if found, do the symbolization from the real-code address
3093 * rather than the stub address.
3095 * Assumptions being made about the minimal symbol table:
3096 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3097 * if we're really in the trampoline.s If we're beyond it (say
3098 * we're in "foo" in the above example), it'll have a closer
3099 * symbol (the "foo" text symbol for example) and will not
3100 * return the trampoline.
3101 * 2. lookup_minimal_symbol_text() will find a real text symbol
3102 * corresponding to the trampoline, and whose address will
3103 * be different than the trampoline address. I put in a sanity
3104 * check for the address being the same, to avoid an
3105 * infinite recursion.
3107 msymbol
= lookup_minimal_symbol_by_pc (pc
);
3108 if (msymbol
.minsym
!= NULL
)
3109 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
3111 struct bound_minimal_symbol mfunsym
3112 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
3115 if (mfunsym
.minsym
== NULL
)
3116 /* I eliminated this warning since it is coming out
3117 * in the following situation:
3118 * gdb shmain // test program with shared libraries
3119 * (gdb) break shr1 // function in shared lib
3120 * Warning: In stub for ...
3121 * In the above situation, the shared lib is not loaded yet,
3122 * so of course we can't find the real func/line info,
3123 * but the "break" still works, and the warning is annoying.
3124 * So I commented out the warning. RT */
3125 /* warning ("In stub for %s; unable to find real function/line info",
3126 SYMBOL_LINKAGE_NAME (msymbol)); */
3129 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
3130 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
3131 /* Avoid infinite recursion */
3132 /* See above comment about why warning is commented out. */
3133 /* warning ("In stub for %s; unable to find real function/line info",
3134 SYMBOL_LINKAGE_NAME (msymbol)); */
3138 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
3141 symtab_and_line val
;
3142 val
.pspace
= current_program_space
;
3144 cust
= find_pc_sect_compunit_symtab (pc
, section
);
3147 /* If no symbol information, return previous pc. */
3154 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3156 /* Look at all the symtabs that share this blockvector.
3157 They all have the same apriori range, that we found was right;
3158 but they have different line tables. */
3160 for (symtab
*iter_s
: compunit_filetabs (cust
))
3162 /* Find the best line in this symtab. */
3163 l
= SYMTAB_LINETABLE (iter_s
);
3169 /* I think len can be zero if the symtab lacks line numbers
3170 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3171 I'm not sure which, and maybe it depends on the symbol
3177 item
= l
->item
; /* Get first line info. */
3179 /* Is this file's first line closer than the first lines of other files?
3180 If so, record this file, and its first line, as best alternate. */
3181 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
3184 auto pc_compare
= [](const CORE_ADDR
& comp_pc
,
3185 const struct linetable_entry
& lhs
)->bool
3187 return comp_pc
< lhs
.pc
;
3190 struct linetable_entry
*first
= item
;
3191 struct linetable_entry
*last
= item
+ len
;
3192 item
= std::upper_bound (first
, last
, pc
, pc_compare
);
3194 prev
= item
- 1; /* Found a matching item. */
3196 /* At this point, prev points at the line whose start addr is <= pc, and
3197 item points at the next line. If we ran off the end of the linetable
3198 (pc >= start of the last line), then prev == item. If pc < start of
3199 the first line, prev will not be set. */
3201 /* Is this file's best line closer than the best in the other files?
3202 If so, record this file, and its best line, as best so far. Don't
3203 save prev if it represents the end of a function (i.e. line number
3204 0) instead of a real line. */
3206 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
3209 best_symtab
= iter_s
;
3211 /* Discard BEST_END if it's before the PC of the current BEST. */
3212 if (best_end
<= best
->pc
)
3216 /* If another line (denoted by ITEM) is in the linetable and its
3217 PC is after BEST's PC, but before the current BEST_END, then
3218 use ITEM's PC as the new best_end. */
3219 if (best
&& item
< last
&& item
->pc
> best
->pc
3220 && (best_end
== 0 || best_end
> item
->pc
))
3221 best_end
= item
->pc
;
3226 /* If we didn't find any line number info, just return zeros.
3227 We used to return alt->line - 1 here, but that could be
3228 anywhere; if we don't have line number info for this PC,
3229 don't make some up. */
3232 else if (best
->line
== 0)
3234 /* If our best fit is in a range of PC's for which no line
3235 number info is available (line number is zero) then we didn't
3236 find any valid line information. */
3241 val
.symtab
= best_symtab
;
3242 val
.line
= best
->line
;
3244 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
3249 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3251 val
.section
= section
;
3255 /* Backward compatibility (no section). */
3257 struct symtab_and_line
3258 find_pc_line (CORE_ADDR pc
, int notcurrent
)
3260 struct obj_section
*section
;
3262 section
= find_pc_overlay (pc
);
3263 if (pc_in_unmapped_range (pc
, section
))
3264 pc
= overlay_mapped_address (pc
, section
);
3265 return find_pc_sect_line (pc
, section
, notcurrent
);
3271 find_pc_line_symtab (CORE_ADDR pc
)
3273 struct symtab_and_line sal
;
3275 /* This always passes zero for NOTCURRENT to find_pc_line.
3276 There are currently no callers that ever pass non-zero. */
3277 sal
= find_pc_line (pc
, 0);
3281 /* Find line number LINE in any symtab whose name is the same as
3284 If found, return the symtab that contains the linetable in which it was
3285 found, set *INDEX to the index in the linetable of the best entry
3286 found, and set *EXACT_MATCH to true if the value returned is an
3289 If not found, return NULL. */
3292 find_line_symtab (struct symtab
*sym_tab
, int line
,
3293 int *index
, bool *exact_match
)
3295 int exact
= 0; /* Initialized here to avoid a compiler warning. */
3297 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3301 struct linetable
*best_linetable
;
3302 struct symtab
*best_symtab
;
3304 /* First try looking it up in the given symtab. */
3305 best_linetable
= SYMTAB_LINETABLE (sym_tab
);
3306 best_symtab
= sym_tab
;
3307 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
3308 if (best_index
< 0 || !exact
)
3310 /* Didn't find an exact match. So we better keep looking for
3311 another symtab with the same name. In the case of xcoff,
3312 multiple csects for one source file (produced by IBM's FORTRAN
3313 compiler) produce multiple symtabs (this is unavoidable
3314 assuming csects can be at arbitrary places in memory and that
3315 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3317 /* BEST is the smallest linenumber > LINE so far seen,
3318 or 0 if none has been seen so far.
3319 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3322 if (best_index
>= 0)
3323 best
= best_linetable
->item
[best_index
].line
;
3327 for (objfile
*objfile
: current_program_space
->objfiles ())
3330 objfile
->sf
->qf
->expand_symtabs_with_fullname
3331 (objfile
, symtab_to_fullname (sym_tab
));
3334 for (objfile
*objfile
: current_program_space
->objfiles ())
3336 for (compunit_symtab
*cu
: objfile
->compunits ())
3338 for (symtab
*s
: compunit_filetabs (cu
))
3340 struct linetable
*l
;
3343 if (FILENAME_CMP (sym_tab
->filename
, s
->filename
) != 0)
3345 if (FILENAME_CMP (symtab_to_fullname (sym_tab
),
3346 symtab_to_fullname (s
)) != 0)
3348 l
= SYMTAB_LINETABLE (s
);
3349 ind
= find_line_common (l
, line
, &exact
, 0);
3359 if (best
== 0 || l
->item
[ind
].line
< best
)
3361 best
= l
->item
[ind
].line
;
3376 *index
= best_index
;
3378 *exact_match
= (exact
!= 0);
3383 /* Given SYMTAB, returns all the PCs function in the symtab that
3384 exactly match LINE. Returns an empty vector if there are no exact
3385 matches, but updates BEST_ITEM in this case. */
3387 std::vector
<CORE_ADDR
>
3388 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
3389 struct linetable_entry
**best_item
)
3392 std::vector
<CORE_ADDR
> result
;
3394 /* First, collect all the PCs that are at this line. */
3400 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
3407 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
3409 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
3415 result
.push_back (SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
3423 /* Set the PC value for a given source file and line number and return true.
3424 Returns false for invalid line number (and sets the PC to 0).
3425 The source file is specified with a struct symtab. */
3428 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
3430 struct linetable
*l
;
3437 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
3440 l
= SYMTAB_LINETABLE (symtab
);
3441 *pc
= l
->item
[ind
].pc
;
3448 /* Find the range of pc values in a line.
3449 Store the starting pc of the line into *STARTPTR
3450 and the ending pc (start of next line) into *ENDPTR.
3451 Returns true to indicate success.
3452 Returns false if could not find the specified line. */
3455 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
3458 CORE_ADDR startaddr
;
3459 struct symtab_and_line found_sal
;
3462 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
3465 /* This whole function is based on address. For example, if line 10 has
3466 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3467 "info line *0x123" should say the line goes from 0x100 to 0x200
3468 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3469 This also insures that we never give a range like "starts at 0x134
3470 and ends at 0x12c". */
3472 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
3473 if (found_sal
.line
!= sal
.line
)
3475 /* The specified line (sal) has zero bytes. */
3476 *startptr
= found_sal
.pc
;
3477 *endptr
= found_sal
.pc
;
3481 *startptr
= found_sal
.pc
;
3482 *endptr
= found_sal
.end
;
3487 /* Given a line table and a line number, return the index into the line
3488 table for the pc of the nearest line whose number is >= the specified one.
3489 Return -1 if none is found. The value is >= 0 if it is an index.
3490 START is the index at which to start searching the line table.
3492 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3495 find_line_common (struct linetable
*l
, int lineno
,
3496 int *exact_match
, int start
)
3501 /* BEST is the smallest linenumber > LINENO so far seen,
3502 or 0 if none has been seen so far.
3503 BEST_INDEX identifies the item for it. */
3505 int best_index
= -1;
3516 for (i
= start
; i
< len
; i
++)
3518 struct linetable_entry
*item
= &(l
->item
[i
]);
3520 if (item
->line
== lineno
)
3522 /* Return the first (lowest address) entry which matches. */
3527 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
3534 /* If we got here, we didn't get an exact match. */
3539 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
3541 struct symtab_and_line sal
;
3543 sal
= find_pc_line (pc
, 0);
3546 return sal
.symtab
!= 0;
3549 /* Helper for find_function_start_sal. Does most of the work, except
3550 setting the sal's symbol. */
3552 static symtab_and_line
3553 find_function_start_sal_1 (CORE_ADDR func_addr
, obj_section
*section
,
3556 symtab_and_line sal
= find_pc_sect_line (func_addr
, section
, 0);
3558 if (funfirstline
&& sal
.symtab
!= NULL
3559 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal
.symtab
))
3560 || SYMTAB_LANGUAGE (sal
.symtab
) == language_asm
))
3562 struct gdbarch
*gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
3565 if (gdbarch_skip_entrypoint_p (gdbarch
))
3566 sal
.pc
= gdbarch_skip_entrypoint (gdbarch
, sal
.pc
);
3570 /* We always should have a line for the function start address.
3571 If we don't, something is odd. Create a plain SAL referring
3572 just the PC and hope that skip_prologue_sal (if requested)
3573 can find a line number for after the prologue. */
3574 if (sal
.pc
< func_addr
)
3577 sal
.pspace
= current_program_space
;
3579 sal
.section
= section
;
3583 skip_prologue_sal (&sal
);
3591 find_function_start_sal (CORE_ADDR func_addr
, obj_section
*section
,
3595 = find_function_start_sal_1 (func_addr
, section
, funfirstline
);
3597 /* find_function_start_sal_1 does a linetable search, so it finds
3598 the symtab and linenumber, but not a symbol. Fill in the
3599 function symbol too. */
3600 sal
.symbol
= find_pc_sect_containing_function (sal
.pc
, sal
.section
);
3608 find_function_start_sal (symbol
*sym
, bool funfirstline
)
3610 fixup_symbol_section (sym
, NULL
);
3612 = find_function_start_sal_1 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)),
3613 SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
),
3620 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3621 address for that function that has an entry in SYMTAB's line info
3622 table. If such an entry cannot be found, return FUNC_ADDR
3626 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
3628 CORE_ADDR func_start
, func_end
;
3629 struct linetable
*l
;
3632 /* Give up if this symbol has no lineinfo table. */
3633 l
= SYMTAB_LINETABLE (symtab
);
3637 /* Get the range for the function's PC values, or give up if we
3638 cannot, for some reason. */
3639 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
3642 /* Linetable entries are ordered by PC values, see the commentary in
3643 symtab.h where `struct linetable' is defined. Thus, the first
3644 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3645 address we are looking for. */
3646 for (i
= 0; i
< l
->nitems
; i
++)
3648 struct linetable_entry
*item
= &(l
->item
[i
]);
3650 /* Don't use line numbers of zero, they mark special entries in
3651 the table. See the commentary on symtab.h before the
3652 definition of struct linetable. */
3653 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
3660 /* Adjust SAL to the first instruction past the function prologue.
3661 If the PC was explicitly specified, the SAL is not changed.
3662 If the line number was explicitly specified then the SAL can still be
3663 updated, unless the language for SAL is assembler, in which case the SAL
3664 will be left unchanged.
3665 If SAL is already past the prologue, then do nothing. */
3668 skip_prologue_sal (struct symtab_and_line
*sal
)
3671 struct symtab_and_line start_sal
;
3672 CORE_ADDR pc
, saved_pc
;
3673 struct obj_section
*section
;
3675 struct objfile
*objfile
;
3676 struct gdbarch
*gdbarch
;
3677 const struct block
*b
, *function_block
;
3678 int force_skip
, skip
;
3680 /* Do not change the SAL if PC was specified explicitly. */
3681 if (sal
->explicit_pc
)
3684 /* In assembly code, if the user asks for a specific line then we should
3685 not adjust the SAL. The user already has instruction level
3686 visibility in this case, so selecting a line other than one requested
3687 is likely to be the wrong choice. */
3688 if (sal
->symtab
!= nullptr
3689 && sal
->explicit_line
3690 && SYMTAB_LANGUAGE (sal
->symtab
) == language_asm
)
3693 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3695 switch_to_program_space_and_thread (sal
->pspace
);
3697 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
3700 fixup_symbol_section (sym
, NULL
);
3702 objfile
= symbol_objfile (sym
);
3703 pc
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
3704 section
= SYMBOL_OBJ_SECTION (objfile
, sym
);
3705 name
= SYMBOL_LINKAGE_NAME (sym
);
3709 struct bound_minimal_symbol msymbol
3710 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
3712 if (msymbol
.minsym
== NULL
)
3715 objfile
= msymbol
.objfile
;
3716 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
3717 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
3718 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
3721 gdbarch
= get_objfile_arch (objfile
);
3723 /* Process the prologue in two passes. In the first pass try to skip the
3724 prologue (SKIP is true) and verify there is a real need for it (indicated
3725 by FORCE_SKIP). If no such reason was found run a second pass where the
3726 prologue is not skipped (SKIP is false). */
3731 /* Be conservative - allow direct PC (without skipping prologue) only if we
3732 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3733 have to be set by the caller so we use SYM instead. */
3735 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym
))))
3743 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3744 so that gdbarch_skip_prologue has something unique to work on. */
3745 if (section_is_overlay (section
) && !section_is_mapped (section
))
3746 pc
= overlay_unmapped_address (pc
, section
);
3748 /* Skip "first line" of function (which is actually its prologue). */
3749 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3750 if (gdbarch_skip_entrypoint_p (gdbarch
))
3751 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
3753 pc
= gdbarch_skip_prologue_noexcept (gdbarch
, pc
);
3755 /* For overlays, map pc back into its mapped VMA range. */
3756 pc
= overlay_mapped_address (pc
, section
);
3758 /* Calculate line number. */
3759 start_sal
= find_pc_sect_line (pc
, section
, 0);
3761 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3762 line is still part of the same function. */
3763 if (skip
&& start_sal
.pc
!= pc
3764 && (sym
? (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
3765 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
3766 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
3767 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
3769 /* First pc of next line */
3771 /* Recalculate the line number (might not be N+1). */
3772 start_sal
= find_pc_sect_line (pc
, section
, 0);
3775 /* On targets with executable formats that don't have a concept of
3776 constructors (ELF with .init has, PE doesn't), gcc emits a call
3777 to `__main' in `main' between the prologue and before user
3779 if (gdbarch_skip_main_prologue_p (gdbarch
)
3780 && name
&& strcmp_iw (name
, "main") == 0)
3782 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
3783 /* Recalculate the line number (might not be N+1). */
3784 start_sal
= find_pc_sect_line (pc
, section
, 0);
3788 while (!force_skip
&& skip
--);
3790 /* If we still don't have a valid source line, try to find the first
3791 PC in the lineinfo table that belongs to the same function. This
3792 happens with COFF debug info, which does not seem to have an
3793 entry in lineinfo table for the code after the prologue which has
3794 no direct relation to source. For example, this was found to be
3795 the case with the DJGPP target using "gcc -gcoff" when the
3796 compiler inserted code after the prologue to make sure the stack
3798 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
3800 pc
= skip_prologue_using_lineinfo (pc
, symbol_symtab (sym
));
3801 /* Recalculate the line number. */
3802 start_sal
= find_pc_sect_line (pc
, section
, 0);
3805 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3806 forward SAL to the end of the prologue. */
3811 sal
->section
= section
;
3812 sal
->symtab
= start_sal
.symtab
;
3813 sal
->line
= start_sal
.line
;
3814 sal
->end
= start_sal
.end
;
3816 /* Check if we are now inside an inlined function. If we can,
3817 use the call site of the function instead. */
3818 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
3819 function_block
= NULL
;
3822 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
3824 else if (BLOCK_FUNCTION (b
) != NULL
)
3826 b
= BLOCK_SUPERBLOCK (b
);
3828 if (function_block
!= NULL
3829 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
3831 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
3832 sal
->symtab
= symbol_symtab (BLOCK_FUNCTION (function_block
));
3836 /* Given PC at the function's start address, attempt to find the
3837 prologue end using SAL information. Return zero if the skip fails.
3839 A non-optimized prologue traditionally has one SAL for the function
3840 and a second for the function body. A single line function has
3841 them both pointing at the same line.
3843 An optimized prologue is similar but the prologue may contain
3844 instructions (SALs) from the instruction body. Need to skip those
3845 while not getting into the function body.
3847 The functions end point and an increasing SAL line are used as
3848 indicators of the prologue's endpoint.
3850 This code is based on the function refine_prologue_limit
3854 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
3856 struct symtab_and_line prologue_sal
;
3859 const struct block
*bl
;
3861 /* Get an initial range for the function. */
3862 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
3863 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3865 prologue_sal
= find_pc_line (start_pc
, 0);
3866 if (prologue_sal
.line
!= 0)
3868 /* For languages other than assembly, treat two consecutive line
3869 entries at the same address as a zero-instruction prologue.
3870 The GNU assembler emits separate line notes for each instruction
3871 in a multi-instruction macro, but compilers generally will not
3873 if (prologue_sal
.symtab
->language
!= language_asm
)
3875 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
3878 /* Skip any earlier lines, and any end-of-sequence marker
3879 from a previous function. */
3880 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
3881 || linetable
->item
[idx
].line
== 0)
3884 if (idx
+1 < linetable
->nitems
3885 && linetable
->item
[idx
+1].line
!= 0
3886 && linetable
->item
[idx
+1].pc
== start_pc
)
3890 /* If there is only one sal that covers the entire function,
3891 then it is probably a single line function, like
3893 if (prologue_sal
.end
>= end_pc
)
3896 while (prologue_sal
.end
< end_pc
)
3898 struct symtab_and_line sal
;
3900 sal
= find_pc_line (prologue_sal
.end
, 0);
3903 /* Assume that a consecutive SAL for the same (or larger)
3904 line mark the prologue -> body transition. */
3905 if (sal
.line
>= prologue_sal
.line
)
3907 /* Likewise if we are in a different symtab altogether
3908 (e.g. within a file included via #include). */
3909 if (sal
.symtab
!= prologue_sal
.symtab
)
3912 /* The line number is smaller. Check that it's from the
3913 same function, not something inlined. If it's inlined,
3914 then there is no point comparing the line numbers. */
3915 bl
= block_for_pc (prologue_sal
.end
);
3918 if (block_inlined_p (bl
))
3920 if (BLOCK_FUNCTION (bl
))
3925 bl
= BLOCK_SUPERBLOCK (bl
);
3930 /* The case in which compiler's optimizer/scheduler has
3931 moved instructions into the prologue. We look ahead in
3932 the function looking for address ranges whose
3933 corresponding line number is less the first one that we
3934 found for the function. This is more conservative then
3935 refine_prologue_limit which scans a large number of SALs
3936 looking for any in the prologue. */
3941 if (prologue_sal
.end
< end_pc
)
3942 /* Return the end of this line, or zero if we could not find a
3944 return prologue_sal
.end
;
3946 /* Don't return END_PC, which is past the end of the function. */
3947 return prologue_sal
.pc
;
3953 find_function_alias_target (bound_minimal_symbol msymbol
)
3955 CORE_ADDR func_addr
;
3956 if (!msymbol_is_function (msymbol
.objfile
, msymbol
.minsym
, &func_addr
))
3959 symbol
*sym
= find_pc_function (func_addr
);
3961 && SYMBOL_CLASS (sym
) == LOC_BLOCK
3962 && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) == func_addr
)
3969 /* If P is of the form "operator[ \t]+..." where `...' is
3970 some legitimate operator text, return a pointer to the
3971 beginning of the substring of the operator text.
3972 Otherwise, return "". */
3975 operator_chars (const char *p
, const char **end
)
3978 if (!startswith (p
, CP_OPERATOR_STR
))
3980 p
+= CP_OPERATOR_LEN
;
3982 /* Don't get faked out by `operator' being part of a longer
3984 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
3987 /* Allow some whitespace between `operator' and the operator symbol. */
3988 while (*p
== ' ' || *p
== '\t')
3991 /* Recognize 'operator TYPENAME'. */
3993 if (isalpha (*p
) || *p
== '_' || *p
== '$')
3995 const char *q
= p
+ 1;
3997 while (isalnum (*q
) || *q
== '_' || *q
== '$')
4006 case '\\': /* regexp quoting */
4009 if (p
[2] == '=') /* 'operator\*=' */
4011 else /* 'operator\*' */
4015 else if (p
[1] == '[')
4018 error (_("mismatched quoting on brackets, "
4019 "try 'operator\\[\\]'"));
4020 else if (p
[2] == '\\' && p
[3] == ']')
4022 *end
= p
+ 4; /* 'operator\[\]' */
4026 error (_("nothing is allowed between '[' and ']'"));
4030 /* Gratuitous quote: skip it and move on. */
4052 if (p
[0] == '-' && p
[1] == '>')
4054 /* Struct pointer member operator 'operator->'. */
4057 *end
= p
+ 3; /* 'operator->*' */
4060 else if (p
[2] == '\\')
4062 *end
= p
+ 4; /* Hopefully 'operator->\*' */
4067 *end
= p
+ 2; /* 'operator->' */
4071 if (p
[1] == '=' || p
[1] == p
[0])
4082 error (_("`operator ()' must be specified "
4083 "without whitespace in `()'"));
4088 error (_("`operator ?:' must be specified "
4089 "without whitespace in `?:'"));
4094 error (_("`operator []' must be specified "
4095 "without whitespace in `[]'"));
4099 error (_("`operator %s' not supported"), p
);
4108 /* What part to match in a file name. */
4110 struct filename_partial_match_opts
4112 /* Only match the directory name part. */
4113 bool dirname
= false;
4115 /* Only match the basename part. */
4116 bool basename
= false;
4119 /* Data structure to maintain printing state for output_source_filename. */
4121 struct output_source_filename_data
4123 /* Output only filenames matching REGEXP. */
4125 gdb::optional
<compiled_regex
> c_regexp
;
4126 /* Possibly only match a part of the filename. */
4127 filename_partial_match_opts partial_match
;
4130 /* Cache of what we've seen so far. */
4131 struct filename_seen_cache
*filename_seen_cache
;
4133 /* Flag of whether we're printing the first one. */
4137 /* Slave routine for sources_info. Force line breaks at ,'s.
4138 NAME is the name to print.
4139 DATA contains the state for printing and watching for duplicates. */
4142 output_source_filename (const char *name
,
4143 struct output_source_filename_data
*data
)
4145 /* Since a single source file can result in several partial symbol
4146 tables, we need to avoid printing it more than once. Note: if
4147 some of the psymtabs are read in and some are not, it gets
4148 printed both under "Source files for which symbols have been
4149 read" and "Source files for which symbols will be read in on
4150 demand". I consider this a reasonable way to deal with the
4151 situation. I'm not sure whether this can also happen for
4152 symtabs; it doesn't hurt to check. */
4154 /* Was NAME already seen? */
4155 if (data
->filename_seen_cache
->seen (name
))
4157 /* Yes; don't print it again. */
4161 /* Does it match data->regexp? */
4162 if (data
->c_regexp
.has_value ())
4164 const char *to_match
;
4165 std::string dirname
;
4167 if (data
->partial_match
.dirname
)
4169 dirname
= ldirname (name
);
4170 to_match
= dirname
.c_str ();
4172 else if (data
->partial_match
.basename
)
4173 to_match
= lbasename (name
);
4177 if (data
->c_regexp
->exec (to_match
, 0, NULL
, 0) != 0)
4181 /* Print it and reset *FIRST. */
4183 printf_filtered (", ");
4187 fputs_styled (name
, file_name_style
.style (), gdb_stdout
);
4190 /* A callback for map_partial_symbol_filenames. */
4193 output_partial_symbol_filename (const char *filename
, const char *fullname
,
4196 output_source_filename (fullname
? fullname
: filename
,
4197 (struct output_source_filename_data
*) data
);
4200 using isrc_flag_option_def
4201 = gdb::option::flag_option_def
<filename_partial_match_opts
>;
4203 static const gdb::option::option_def info_sources_option_defs
[] = {
4205 isrc_flag_option_def
{
4207 [] (filename_partial_match_opts
*opts
) { return &opts
->dirname
; },
4208 N_("Show only the files having a dirname matching REGEXP."),
4211 isrc_flag_option_def
{
4213 [] (filename_partial_match_opts
*opts
) { return &opts
->basename
; },
4214 N_("Show only the files having a basename matching REGEXP."),
4219 /* Create an option_def_group for the "info sources" options, with
4220 ISRC_OPTS as context. */
4222 static inline gdb::option::option_def_group
4223 make_info_sources_options_def_group (filename_partial_match_opts
*isrc_opts
)
4225 return {{info_sources_option_defs
}, isrc_opts
};
4228 /* Prints the header message for the source files that will be printed
4229 with the matching info present in DATA. SYMBOL_MSG is a message
4230 that tells what will or has been done with the symbols of the
4231 matching source files. */
4234 print_info_sources_header (const char *symbol_msg
,
4235 const struct output_source_filename_data
*data
)
4237 puts_filtered (symbol_msg
);
4238 if (!data
->regexp
.empty ())
4240 if (data
->partial_match
.dirname
)
4241 printf_filtered (_("(dirname matching regular expression \"%s\")"),
4242 data
->regexp
.c_str ());
4243 else if (data
->partial_match
.basename
)
4244 printf_filtered (_("(basename matching regular expression \"%s\")"),
4245 data
->regexp
.c_str ());
4247 printf_filtered (_("(filename matching regular expression \"%s\")"),
4248 data
->regexp
.c_str ());
4250 puts_filtered ("\n");
4253 /* Completer for "info sources". */
4256 info_sources_command_completer (cmd_list_element
*ignore
,
4257 completion_tracker
&tracker
,
4258 const char *text
, const char *word
)
4260 const auto group
= make_info_sources_options_def_group (nullptr);
4261 if (gdb::option::complete_options
4262 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
4267 info_sources_command (const char *args
, int from_tty
)
4269 struct output_source_filename_data data
;
4271 if (!have_full_symbols () && !have_partial_symbols ())
4273 error (_("No symbol table is loaded. Use the \"file\" command."));
4276 filename_seen_cache filenames_seen
;
4278 auto group
= make_info_sources_options_def_group (&data
.partial_match
);
4280 gdb::option::process_options
4281 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
4283 if (args
!= NULL
&& *args
!= '\000')
4286 data
.filename_seen_cache
= &filenames_seen
;
4289 if (data
.partial_match
.dirname
&& data
.partial_match
.basename
)
4290 error (_("You cannot give both -basename and -dirname to 'info sources'."));
4291 if ((data
.partial_match
.dirname
|| data
.partial_match
.basename
)
4292 && data
.regexp
.empty ())
4293 error (_("Missing REGEXP for 'info sources'."));
4295 if (data
.regexp
.empty ())
4296 data
.c_regexp
.reset ();
4299 int cflags
= REG_NOSUB
;
4300 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
4301 cflags
|= REG_ICASE
;
4303 data
.c_regexp
.emplace (data
.regexp
.c_str (), cflags
,
4304 _("Invalid regexp"));
4307 print_info_sources_header
4308 (_("Source files for which symbols have been read in:\n"), &data
);
4310 for (objfile
*objfile
: current_program_space
->objfiles ())
4312 for (compunit_symtab
*cu
: objfile
->compunits ())
4314 for (symtab
*s
: compunit_filetabs (cu
))
4316 const char *fullname
= symtab_to_fullname (s
);
4318 output_source_filename (fullname
, &data
);
4322 printf_filtered ("\n\n");
4324 print_info_sources_header
4325 (_("Source files for which symbols will be read in on demand:\n"), &data
);
4327 filenames_seen
.clear ();
4329 map_symbol_filenames (output_partial_symbol_filename
, &data
,
4330 1 /*need_fullname*/);
4331 printf_filtered ("\n");
4334 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4335 non-zero compare only lbasename of FILES. */
4338 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
4342 if (file
!= NULL
&& nfiles
!= 0)
4344 for (i
= 0; i
< nfiles
; i
++)
4346 if (compare_filenames_for_search (file
, (basenames
4347 ? lbasename (files
[i
])
4352 else if (nfiles
== 0)
4357 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4358 sort symbols, not minimal symbols. */
4361 symbol_search::compare_search_syms (const symbol_search
&sym_a
,
4362 const symbol_search
&sym_b
)
4366 c
= FILENAME_CMP (symbol_symtab (sym_a
.symbol
)->filename
,
4367 symbol_symtab (sym_b
.symbol
)->filename
);
4371 if (sym_a
.block
!= sym_b
.block
)
4372 return sym_a
.block
- sym_b
.block
;
4374 return strcmp (SYMBOL_PRINT_NAME (sym_a
.symbol
),
4375 SYMBOL_PRINT_NAME (sym_b
.symbol
));
4378 /* Returns true if the type_name of symbol_type of SYM matches TREG.
4379 If SYM has no symbol_type or symbol_name, returns false. */
4382 treg_matches_sym_type_name (const compiled_regex
&treg
,
4383 const struct symbol
*sym
)
4385 struct type
*sym_type
;
4386 std::string printed_sym_type_name
;
4388 if (symbol_lookup_debug
> 1)
4390 fprintf_unfiltered (gdb_stdlog
,
4391 "treg_matches_sym_type_name\n sym %s\n",
4392 SYMBOL_NATURAL_NAME (sym
));
4395 sym_type
= SYMBOL_TYPE (sym
);
4396 if (sym_type
== NULL
)
4400 scoped_switch_to_sym_language_if_auto
l (sym
);
4402 printed_sym_type_name
= type_to_string (sym_type
);
4406 if (symbol_lookup_debug
> 1)
4408 fprintf_unfiltered (gdb_stdlog
,
4409 " sym_type_name %s\n",
4410 printed_sym_type_name
.c_str ());
4414 if (printed_sym_type_name
.empty ())
4417 return treg
.exec (printed_sym_type_name
.c_str (), 0, NULL
, 0) == 0;
4421 /* Sort the symbols in RESULT and remove duplicates. */
4424 sort_search_symbols_remove_dups (std::vector
<symbol_search
> *result
)
4426 std::sort (result
->begin (), result
->end ());
4427 result
->erase (std::unique (result
->begin (), result
->end ()),
4431 /* Search the symbol table for matches to the regular expression REGEXP,
4432 returning the results.
4434 Only symbols of KIND are searched:
4435 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4436 and constants (enums).
4437 if T_REGEXP is not NULL, only returns var that have
4438 a type matching regular expression T_REGEXP.
4439 FUNCTIONS_DOMAIN - search all functions
4440 TYPES_DOMAIN - search all type names
4441 ALL_DOMAIN - an internal error for this function
4443 Within each file the results are sorted locally; each symtab's global and
4444 static blocks are separately alphabetized.
4445 Duplicate entries are removed.
4447 When EXCLUDE_MINSYMS is false then matching minsyms are also returned,
4448 otherwise they are excluded. */
4450 std::vector
<symbol_search
>
4451 search_symbols (const char *regexp
, enum search_domain kind
,
4452 const char *t_regexp
,
4453 int nfiles
, const char *files
[],
4454 bool exclude_minsyms
)
4456 const struct blockvector
*bv
;
4457 const struct block
*b
;
4459 struct block_iterator iter
;
4462 static const enum minimal_symbol_type types
[]
4463 = {mst_data
, mst_text
, mst_unknown
};
4464 static const enum minimal_symbol_type types2
[]
4465 = {mst_bss
, mst_file_text
, mst_unknown
};
4466 static const enum minimal_symbol_type types3
[]
4467 = {mst_file_data
, mst_solib_trampoline
, mst_unknown
};
4468 static const enum minimal_symbol_type types4
[]
4469 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_unknown
};
4470 enum minimal_symbol_type ourtype
;
4471 enum minimal_symbol_type ourtype2
;
4472 enum minimal_symbol_type ourtype3
;
4473 enum minimal_symbol_type ourtype4
;
4474 std::vector
<symbol_search
> result
;
4475 gdb::optional
<compiled_regex
> preg
;
4476 gdb::optional
<compiled_regex
> treg
;
4478 gdb_assert (kind
<= TYPES_DOMAIN
);
4480 ourtype
= types
[kind
];
4481 ourtype2
= types2
[kind
];
4482 ourtype3
= types3
[kind
];
4483 ourtype4
= types4
[kind
];
4487 /* Make sure spacing is right for C++ operators.
4488 This is just a courtesy to make the matching less sensitive
4489 to how many spaces the user leaves between 'operator'
4490 and <TYPENAME> or <OPERATOR>. */
4492 const char *opname
= operator_chars (regexp
, &opend
);
4496 int fix
= -1; /* -1 means ok; otherwise number of
4499 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
4501 /* There should 1 space between 'operator' and 'TYPENAME'. */
4502 if (opname
[-1] != ' ' || opname
[-2] == ' ')
4507 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4508 if (opname
[-1] == ' ')
4511 /* If wrong number of spaces, fix it. */
4514 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
4516 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
4521 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4523 preg
.emplace (regexp
, cflags
, _("Invalid regexp"));
4526 if (t_regexp
!= NULL
)
4528 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4530 treg
.emplace (t_regexp
, cflags
, _("Invalid regexp"));
4533 /* Search through the partial symtabs *first* for all symbols
4534 matching the regexp. That way we don't have to reproduce all of
4535 the machinery below. */
4536 expand_symtabs_matching ([&] (const char *filename
, bool basenames
)
4538 return file_matches (filename
, files
, nfiles
,
4541 lookup_name_info::match_any (),
4542 [&] (const char *symname
)
4544 return (!preg
.has_value ()
4545 || preg
->exec (symname
,
4551 /* Here, we search through the minimal symbol tables for functions
4552 and variables that match, and force their symbols to be read.
4553 This is in particular necessary for demangled variable names,
4554 which are no longer put into the partial symbol tables.
4555 The symbol will then be found during the scan of symtabs below.
4557 For functions, find_pc_symtab should succeed if we have debug info
4558 for the function, for variables we have to call
4559 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4561 If the lookup fails, set found_misc so that we will rescan to print
4562 any matching symbols without debug info.
4563 We only search the objfile the msymbol came from, we no longer search
4564 all objfiles. In large programs (1000s of shared libs) searching all
4565 objfiles is not worth the pain. */
4567 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
4569 for (objfile
*objfile
: current_program_space
->objfiles ())
4571 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
4575 if (msymbol
->created_by_gdb
)
4578 if (MSYMBOL_TYPE (msymbol
) == ourtype
4579 || MSYMBOL_TYPE (msymbol
) == ourtype2
4580 || MSYMBOL_TYPE (msymbol
) == ourtype3
4581 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4583 if (!preg
.has_value ()
4584 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4587 /* Note: An important side-effect of these
4588 lookup functions is to expand the symbol
4589 table if msymbol is found, for the benefit of
4590 the next loop on compunits. */
4591 if (kind
== FUNCTIONS_DOMAIN
4592 ? (find_pc_compunit_symtab
4593 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4595 : (lookup_symbol_in_objfile_from_linkage_name
4596 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4606 for (objfile
*objfile
: current_program_space
->objfiles ())
4608 for (compunit_symtab
*cust
: objfile
->compunits ())
4610 bv
= COMPUNIT_BLOCKVECTOR (cust
);
4611 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
4613 b
= BLOCKVECTOR_BLOCK (bv
, i
);
4614 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4616 struct symtab
*real_symtab
= symbol_symtab (sym
);
4620 /* Check first sole REAL_SYMTAB->FILENAME. It does
4621 not need to be a substring of symtab_to_fullname as
4622 it may contain "./" etc. */
4623 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
4624 || ((basenames_may_differ
4625 || file_matches (lbasename (real_symtab
->filename
),
4627 && file_matches (symtab_to_fullname (real_symtab
),
4629 && ((!preg
.has_value ()
4630 || preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
4632 && ((kind
== VARIABLES_DOMAIN
4633 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
4634 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
4635 && SYMBOL_CLASS (sym
) != LOC_BLOCK
4636 /* LOC_CONST can be used for more than
4637 just enums, e.g., c++ static const
4638 members. We only want to skip enums
4640 && !(SYMBOL_CLASS (sym
) == LOC_CONST
4641 && (TYPE_CODE (SYMBOL_TYPE (sym
))
4643 && (!treg
.has_value ()
4644 || treg_matches_sym_type_name (*treg
, sym
)))
4645 || (kind
== FUNCTIONS_DOMAIN
4646 && SYMBOL_CLASS (sym
) == LOC_BLOCK
4647 && (!treg
.has_value ()
4648 || treg_matches_sym_type_name (*treg
,
4650 || (kind
== TYPES_DOMAIN
4651 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4652 && SYMBOL_DOMAIN (sym
) != MODULE_DOMAIN
))))
4655 result
.emplace_back (i
, sym
);
4662 if (!result
.empty ())
4663 sort_search_symbols_remove_dups (&result
);
4665 /* If there are no eyes, avoid all contact. I mean, if there are
4666 no debug symbols, then add matching minsyms. But if the user wants
4667 to see symbols matching a type regexp, then never give a minimal symbol,
4668 as we assume that a minimal symbol does not have a type. */
4670 if ((found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
4672 && !treg
.has_value ())
4674 for (objfile
*objfile
: current_program_space
->objfiles ())
4676 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
4680 if (msymbol
->created_by_gdb
)
4683 if (MSYMBOL_TYPE (msymbol
) == ourtype
4684 || MSYMBOL_TYPE (msymbol
) == ourtype2
4685 || MSYMBOL_TYPE (msymbol
) == ourtype3
4686 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4688 if (!preg
.has_value ()
4689 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4692 /* For functions we can do a quick check of whether the
4693 symbol might be found via find_pc_symtab. */
4694 if (kind
!= FUNCTIONS_DOMAIN
4695 || (find_pc_compunit_symtab
4696 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4699 if (lookup_symbol_in_objfile_from_linkage_name
4700 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4705 result
.emplace_back (i
, msymbol
, objfile
);
4717 /* Helper function for symtab_symbol_info, this function uses
4718 the data returned from search_symbols() to print information
4719 regarding the match to gdb_stdout. If LAST is not NULL,
4720 print file and line number information for the symbol as
4721 well. Skip printing the filename if it matches LAST. */
4724 print_symbol_info (enum search_domain kind
,
4726 int block
, const char *last
)
4728 scoped_switch_to_sym_language_if_auto
l (sym
);
4729 struct symtab
*s
= symbol_symtab (sym
);
4733 const char *s_filename
= symtab_to_filename_for_display (s
);
4735 if (filename_cmp (last
, s_filename
) != 0)
4737 printf_filtered (_("\nFile %ps:\n"),
4738 styled_string (file_name_style
.style (),
4742 if (SYMBOL_LINE (sym
) != 0)
4743 printf_filtered ("%d:\t", SYMBOL_LINE (sym
));
4745 puts_filtered ("\t");
4748 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
4749 printf_filtered ("static ");
4751 /* Typedef that is not a C++ class. */
4752 if (kind
== TYPES_DOMAIN
4753 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
4755 /* FIXME: For C (and C++) we end up with a difference in output here
4756 between how a typedef is printed, and non-typedefs are printed.
4757 The TYPEDEF_PRINT code places a ";" at the end in an attempt to
4758 appear C-like, while TYPE_PRINT doesn't.
4760 For the struct printing case below, things are worse, we force
4761 printing of the ";" in this function, which is going to be wrong
4762 for languages that don't require a ";" between statements. */
4763 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_TYPEDEF
)
4764 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
4767 type_print (SYMBOL_TYPE (sym
), "", gdb_stdout
, -1);
4768 printf_filtered ("\n");
4771 /* variable, func, or typedef-that-is-c++-class. */
4772 else if (kind
< TYPES_DOMAIN
4773 || (kind
== TYPES_DOMAIN
4774 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
4776 type_print (SYMBOL_TYPE (sym
),
4777 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4778 ? "" : SYMBOL_PRINT_NAME (sym
)),
4781 printf_filtered (";\n");
4785 /* This help function for symtab_symbol_info() prints information
4786 for non-debugging symbols to gdb_stdout. */
4789 print_msymbol_info (struct bound_minimal_symbol msymbol
)
4791 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
4794 if (gdbarch_addr_bit (gdbarch
) <= 32)
4795 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
4796 & (CORE_ADDR
) 0xffffffff,
4799 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
4802 ui_file_style sym_style
= (msymbol
.minsym
->text_p ()
4803 ? function_name_style
.style ()
4804 : ui_file_style ());
4806 printf_filtered (_("%ps %ps\n"),
4807 styled_string (address_style
.style (), tmp
),
4808 styled_string (sym_style
,
4809 MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
4812 /* This is the guts of the commands "info functions", "info types", and
4813 "info variables". It calls search_symbols to find all matches and then
4814 print_[m]symbol_info to print out some useful information about the
4818 symtab_symbol_info (bool quiet
, bool exclude_minsyms
,
4819 const char *regexp
, enum search_domain kind
,
4820 const char *t_regexp
, int from_tty
)
4822 static const char * const classnames
[] =
4823 {"variable", "function", "type"};
4824 const char *last_filename
= "";
4827 gdb_assert (kind
<= TYPES_DOMAIN
);
4829 if (regexp
!= nullptr && *regexp
== '\0')
4832 /* Must make sure that if we're interrupted, symbols gets freed. */
4833 std::vector
<symbol_search
> symbols
= search_symbols (regexp
, kind
,
4841 if (t_regexp
!= NULL
)
4843 (_("All %ss matching regular expression \"%s\""
4844 " with type matching regular expression \"%s\":\n"),
4845 classnames
[kind
], regexp
, t_regexp
);
4847 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4848 classnames
[kind
], regexp
);
4852 if (t_regexp
!= NULL
)
4854 (_("All defined %ss"
4855 " with type matching regular expression \"%s\" :\n"),
4856 classnames
[kind
], t_regexp
);
4858 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
4862 for (const symbol_search
&p
: symbols
)
4866 if (p
.msymbol
.minsym
!= NULL
)
4871 printf_filtered (_("\nNon-debugging symbols:\n"));
4874 print_msymbol_info (p
.msymbol
);
4878 print_symbol_info (kind
,
4883 = symtab_to_filename_for_display (symbol_symtab (p
.symbol
));
4888 /* Structure to hold the values of the options used by the 'info variables'
4889 and 'info functions' commands. These correspond to the -q, -t, and -n
4892 struct info_print_options
4895 bool exclude_minsyms
= false;
4896 char *type_regexp
= nullptr;
4898 ~info_print_options ()
4900 xfree (type_regexp
);
4904 /* The options used by the 'info variables' and 'info functions'
4907 static const gdb::option::option_def info_print_options_defs
[] = {
4908 gdb::option::boolean_option_def
<info_print_options
> {
4910 [] (info_print_options
*opt
) { return &opt
->quiet
; },
4911 nullptr, /* show_cmd_cb */
4912 nullptr /* set_doc */
4915 gdb::option::boolean_option_def
<info_print_options
> {
4917 [] (info_print_options
*opt
) { return &opt
->exclude_minsyms
; },
4918 nullptr, /* show_cmd_cb */
4919 nullptr /* set_doc */
4922 gdb::option::string_option_def
<info_print_options
> {
4924 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
4925 nullptr, /* show_cmd_cb */
4926 nullptr /* set_doc */
4930 /* Returns the option group used by 'info variables' and 'info
4933 static gdb::option::option_def_group
4934 make_info_print_options_def_group (info_print_options
*opts
)
4936 return {{info_print_options_defs
}, opts
};
4939 /* Command completer for 'info variables' and 'info functions'. */
4942 info_print_command_completer (struct cmd_list_element
*ignore
,
4943 completion_tracker
&tracker
,
4944 const char *text
, const char * /* word */)
4947 = make_info_print_options_def_group (nullptr);
4948 if (gdb::option::complete_options
4949 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
4952 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
4953 symbol_completer (ignore
, tracker
, text
, word
);
4956 /* Implement the 'info variables' command. */
4959 info_variables_command (const char *args
, int from_tty
)
4961 info_print_options opts
;
4962 auto grp
= make_info_print_options_def_group (&opts
);
4963 gdb::option::process_options
4964 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
4965 if (args
!= nullptr && *args
== '\0')
4968 symtab_symbol_info (opts
.quiet
, opts
.exclude_minsyms
, args
, VARIABLES_DOMAIN
,
4969 opts
.type_regexp
, from_tty
);
4972 /* Implement the 'info functions' command. */
4975 info_functions_command (const char *args
, int from_tty
)
4977 info_print_options opts
;
4978 auto grp
= make_info_print_options_def_group (&opts
);
4979 gdb::option::process_options
4980 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
4981 if (args
!= nullptr && *args
== '\0')
4984 symtab_symbol_info (opts
.quiet
, opts
.exclude_minsyms
, args
,
4985 FUNCTIONS_DOMAIN
, opts
.type_regexp
, from_tty
);
4988 /* Holds the -q option for the 'info types' command. */
4990 struct info_types_options
4995 /* The options used by the 'info types' command. */
4997 static const gdb::option::option_def info_types_options_defs
[] = {
4998 gdb::option::boolean_option_def
<info_types_options
> {
5000 [] (info_types_options
*opt
) { return &opt
->quiet
; },
5001 nullptr, /* show_cmd_cb */
5002 nullptr /* set_doc */
5006 /* Returns the option group used by 'info types'. */
5008 static gdb::option::option_def_group
5009 make_info_types_options_def_group (info_types_options
*opts
)
5011 return {{info_types_options_defs
}, opts
};
5014 /* Implement the 'info types' command. */
5017 info_types_command (const char *args
, int from_tty
)
5019 info_types_options opts
;
5021 auto grp
= make_info_types_options_def_group (&opts
);
5022 gdb::option::process_options
5023 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
5024 if (args
!= nullptr && *args
== '\0')
5026 symtab_symbol_info (opts
.quiet
, false, args
, TYPES_DOMAIN
, NULL
, from_tty
);
5029 /* Command completer for 'info types' command. */
5032 info_types_command_completer (struct cmd_list_element
*ignore
,
5033 completion_tracker
&tracker
,
5034 const char *text
, const char * /* word */)
5037 = make_info_types_options_def_group (nullptr);
5038 if (gdb::option::complete_options
5039 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
5042 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
5043 symbol_completer (ignore
, tracker
, text
, word
);
5046 /* Breakpoint all functions matching regular expression. */
5049 rbreak_command_wrapper (char *regexp
, int from_tty
)
5051 rbreak_command (regexp
, from_tty
);
5055 rbreak_command (const char *regexp
, int from_tty
)
5058 const char **files
= NULL
;
5059 const char *file_name
;
5064 const char *colon
= strchr (regexp
, ':');
5066 if (colon
&& *(colon
+ 1) != ':')
5071 colon_index
= colon
- regexp
;
5072 local_name
= (char *) alloca (colon_index
+ 1);
5073 memcpy (local_name
, regexp
, colon_index
);
5074 local_name
[colon_index
--] = 0;
5075 while (isspace (local_name
[colon_index
]))
5076 local_name
[colon_index
--] = 0;
5077 file_name
= local_name
;
5080 regexp
= skip_spaces (colon
+ 1);
5084 std::vector
<symbol_search
> symbols
= search_symbols (regexp
,
5090 scoped_rbreak_breakpoints finalize
;
5091 for (const symbol_search
&p
: symbols
)
5093 if (p
.msymbol
.minsym
== NULL
)
5095 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
5096 const char *fullname
= symtab_to_fullname (symtab
);
5098 string
= string_printf ("%s:'%s'", fullname
,
5099 SYMBOL_LINKAGE_NAME (p
.symbol
));
5100 break_command (&string
[0], from_tty
);
5101 print_symbol_info (FUNCTIONS_DOMAIN
, p
.symbol
, p
.block
, NULL
);
5105 string
= string_printf ("'%s'",
5106 MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
));
5108 break_command (&string
[0], from_tty
);
5109 printf_filtered ("<function, no debug info> %s;\n",
5110 MSYMBOL_PRINT_NAME (p
.msymbol
.minsym
));
5116 /* Evaluate if SYMNAME matches LOOKUP_NAME. */
5119 compare_symbol_name (const char *symbol_name
, language symbol_language
,
5120 const lookup_name_info
&lookup_name
,
5121 completion_match_result
&match_res
)
5123 const language_defn
*lang
= language_def (symbol_language
);
5125 symbol_name_matcher_ftype
*name_match
5126 = get_symbol_name_matcher (lang
, lookup_name
);
5128 return name_match (symbol_name
, lookup_name
, &match_res
);
5134 completion_list_add_name (completion_tracker
&tracker
,
5135 language symbol_language
,
5136 const char *symname
,
5137 const lookup_name_info
&lookup_name
,
5138 const char *text
, const char *word
)
5140 completion_match_result
&match_res
5141 = tracker
.reset_completion_match_result ();
5143 /* Clip symbols that cannot match. */
5144 if (!compare_symbol_name (symname
, symbol_language
, lookup_name
, match_res
))
5147 /* Refresh SYMNAME from the match string. It's potentially
5148 different depending on language. (E.g., on Ada, the match may be
5149 the encoded symbol name wrapped in "<>"). */
5150 symname
= match_res
.match
.match ();
5151 gdb_assert (symname
!= NULL
);
5153 /* We have a match for a completion, so add SYMNAME to the current list
5154 of matches. Note that the name is moved to freshly malloc'd space. */
5157 gdb::unique_xmalloc_ptr
<char> completion
5158 = make_completion_match_str (symname
, text
, word
);
5160 /* Here we pass the match-for-lcd object to add_completion. Some
5161 languages match the user text against substrings of symbol
5162 names in some cases. E.g., in C++, "b push_ba" completes to
5163 "std::vector::push_back", "std::string::push_back", etc., and
5164 in this case we want the completion lowest common denominator
5165 to be "push_back" instead of "std::". */
5166 tracker
.add_completion (std::move (completion
),
5167 &match_res
.match_for_lcd
, text
, word
);
5171 /* completion_list_add_name wrapper for struct symbol. */
5174 completion_list_add_symbol (completion_tracker
&tracker
,
5176 const lookup_name_info
&lookup_name
,
5177 const char *text
, const char *word
)
5179 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5180 SYMBOL_NATURAL_NAME (sym
),
5181 lookup_name
, text
, word
);
5184 /* completion_list_add_name wrapper for struct minimal_symbol. */
5187 completion_list_add_msymbol (completion_tracker
&tracker
,
5188 minimal_symbol
*sym
,
5189 const lookup_name_info
&lookup_name
,
5190 const char *text
, const char *word
)
5192 completion_list_add_name (tracker
, MSYMBOL_LANGUAGE (sym
),
5193 MSYMBOL_NATURAL_NAME (sym
),
5194 lookup_name
, text
, word
);
5198 /* ObjC: In case we are completing on a selector, look as the msymbol
5199 again and feed all the selectors into the mill. */
5202 completion_list_objc_symbol (completion_tracker
&tracker
,
5203 struct minimal_symbol
*msymbol
,
5204 const lookup_name_info
&lookup_name
,
5205 const char *text
, const char *word
)
5207 static char *tmp
= NULL
;
5208 static unsigned int tmplen
= 0;
5210 const char *method
, *category
, *selector
;
5213 method
= MSYMBOL_NATURAL_NAME (msymbol
);
5215 /* Is it a method? */
5216 if ((method
[0] != '-') && (method
[0] != '+'))
5220 /* Complete on shortened method method. */
5221 completion_list_add_name (tracker
, language_objc
,
5226 while ((strlen (method
) + 1) >= tmplen
)
5232 tmp
= (char *) xrealloc (tmp
, tmplen
);
5234 selector
= strchr (method
, ' ');
5235 if (selector
!= NULL
)
5238 category
= strchr (method
, '(');
5240 if ((category
!= NULL
) && (selector
!= NULL
))
5242 memcpy (tmp
, method
, (category
- method
));
5243 tmp
[category
- method
] = ' ';
5244 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
5245 completion_list_add_name (tracker
, language_objc
, tmp
,
5246 lookup_name
, text
, word
);
5248 completion_list_add_name (tracker
, language_objc
, tmp
+ 1,
5249 lookup_name
, text
, word
);
5252 if (selector
!= NULL
)
5254 /* Complete on selector only. */
5255 strcpy (tmp
, selector
);
5256 tmp2
= strchr (tmp
, ']');
5260 completion_list_add_name (tracker
, language_objc
, tmp
,
5261 lookup_name
, text
, word
);
5265 /* Break the non-quoted text based on the characters which are in
5266 symbols. FIXME: This should probably be language-specific. */
5269 language_search_unquoted_string (const char *text
, const char *p
)
5271 for (; p
> text
; --p
)
5273 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
5277 if ((current_language
->la_language
== language_objc
))
5279 if (p
[-1] == ':') /* Might be part of a method name. */
5281 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
5282 p
-= 2; /* Beginning of a method name. */
5283 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
5284 { /* Might be part of a method name. */
5287 /* Seeing a ' ' or a '(' is not conclusive evidence
5288 that we are in the middle of a method name. However,
5289 finding "-[" or "+[" should be pretty un-ambiguous.
5290 Unfortunately we have to find it now to decide. */
5293 if (isalnum (t
[-1]) || t
[-1] == '_' ||
5294 t
[-1] == ' ' || t
[-1] == ':' ||
5295 t
[-1] == '(' || t
[-1] == ')')
5300 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
5301 p
= t
- 2; /* Method name detected. */
5302 /* Else we leave with p unchanged. */
5312 completion_list_add_fields (completion_tracker
&tracker
,
5314 const lookup_name_info
&lookup_name
,
5315 const char *text
, const char *word
)
5317 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
5319 struct type
*t
= SYMBOL_TYPE (sym
);
5320 enum type_code c
= TYPE_CODE (t
);
5323 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
5324 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
5325 if (TYPE_FIELD_NAME (t
, j
))
5326 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5327 TYPE_FIELD_NAME (t
, j
),
5328 lookup_name
, text
, word
);
5335 symbol_is_function_or_method (symbol
*sym
)
5337 switch (TYPE_CODE (SYMBOL_TYPE (sym
)))
5339 case TYPE_CODE_FUNC
:
5340 case TYPE_CODE_METHOD
:
5350 symbol_is_function_or_method (minimal_symbol
*msymbol
)
5352 switch (MSYMBOL_TYPE (msymbol
))
5355 case mst_text_gnu_ifunc
:
5356 case mst_solib_trampoline
:
5366 bound_minimal_symbol
5367 find_gnu_ifunc (const symbol
*sym
)
5369 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
5372 lookup_name_info
lookup_name (SYMBOL_SEARCH_NAME (sym
),
5373 symbol_name_match_type::SEARCH_NAME
);
5374 struct objfile
*objfile
= symbol_objfile (sym
);
5376 CORE_ADDR address
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
5377 minimal_symbol
*ifunc
= NULL
;
5379 iterate_over_minimal_symbols (objfile
, lookup_name
,
5380 [&] (minimal_symbol
*minsym
)
5382 if (MSYMBOL_TYPE (minsym
) == mst_text_gnu_ifunc
5383 || MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5385 CORE_ADDR msym_addr
= MSYMBOL_VALUE_ADDRESS (objfile
, minsym
);
5386 if (MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5388 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5390 = gdbarch_convert_from_func_ptr_addr (gdbarch
,
5392 current_top_target ());
5394 if (msym_addr
== address
)
5404 return {ifunc
, objfile
};
5408 /* Add matching symbols from SYMTAB to the current completion list. */
5411 add_symtab_completions (struct compunit_symtab
*cust
,
5412 completion_tracker
&tracker
,
5413 complete_symbol_mode mode
,
5414 const lookup_name_info
&lookup_name
,
5415 const char *text
, const char *word
,
5416 enum type_code code
)
5419 const struct block
*b
;
5420 struct block_iterator iter
;
5426 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
5429 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), i
);
5430 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5432 if (completion_skip_symbol (mode
, sym
))
5435 if (code
== TYPE_CODE_UNDEF
5436 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5437 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
5438 completion_list_add_symbol (tracker
, sym
,
5446 default_collect_symbol_completion_matches_break_on
5447 (completion_tracker
&tracker
, complete_symbol_mode mode
,
5448 symbol_name_match_type name_match_type
,
5449 const char *text
, const char *word
,
5450 const char *break_on
, enum type_code code
)
5452 /* Problem: All of the symbols have to be copied because readline
5453 frees them. I'm not going to worry about this; hopefully there
5454 won't be that many. */
5457 const struct block
*b
;
5458 const struct block
*surrounding_static_block
, *surrounding_global_block
;
5459 struct block_iterator iter
;
5460 /* The symbol we are completing on. Points in same buffer as text. */
5461 const char *sym_text
;
5463 /* Now look for the symbol we are supposed to complete on. */
5464 if (mode
== complete_symbol_mode::LINESPEC
)
5470 const char *quote_pos
= NULL
;
5472 /* First see if this is a quoted string. */
5474 for (p
= text
; *p
!= '\0'; ++p
)
5476 if (quote_found
!= '\0')
5478 if (*p
== quote_found
)
5479 /* Found close quote. */
5481 else if (*p
== '\\' && p
[1] == quote_found
)
5482 /* A backslash followed by the quote character
5483 doesn't end the string. */
5486 else if (*p
== '\'' || *p
== '"')
5492 if (quote_found
== '\'')
5493 /* A string within single quotes can be a symbol, so complete on it. */
5494 sym_text
= quote_pos
+ 1;
5495 else if (quote_found
== '"')
5496 /* A double-quoted string is never a symbol, nor does it make sense
5497 to complete it any other way. */
5503 /* It is not a quoted string. Break it based on the characters
5504 which are in symbols. */
5507 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
5508 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
5517 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5519 /* At this point scan through the misc symbol vectors and add each
5520 symbol you find to the list. Eventually we want to ignore
5521 anything that isn't a text symbol (everything else will be
5522 handled by the psymtab code below). */
5524 if (code
== TYPE_CODE_UNDEF
)
5526 for (objfile
*objfile
: current_program_space
->objfiles ())
5528 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
5532 if (completion_skip_symbol (mode
, msymbol
))
5535 completion_list_add_msymbol (tracker
, msymbol
, lookup_name
,
5538 completion_list_objc_symbol (tracker
, msymbol
, lookup_name
,
5544 /* Add completions for all currently loaded symbol tables. */
5545 for (objfile
*objfile
: current_program_space
->objfiles ())
5547 for (compunit_symtab
*cust
: objfile
->compunits ())
5548 add_symtab_completions (cust
, tracker
, mode
, lookup_name
,
5549 sym_text
, word
, code
);
5552 /* Look through the partial symtabs for all symbols which begin by
5553 matching SYM_TEXT. Expand all CUs that you find to the list. */
5554 expand_symtabs_matching (NULL
,
5557 [&] (compunit_symtab
*symtab
) /* expansion notify */
5559 add_symtab_completions (symtab
,
5560 tracker
, mode
, lookup_name
,
5561 sym_text
, word
, code
);
5565 /* Search upwards from currently selected frame (so that we can
5566 complete on local vars). Also catch fields of types defined in
5567 this places which match our text string. Only complete on types
5568 visible from current context. */
5570 b
= get_selected_block (0);
5571 surrounding_static_block
= block_static_block (b
);
5572 surrounding_global_block
= block_global_block (b
);
5573 if (surrounding_static_block
!= NULL
)
5574 while (b
!= surrounding_static_block
)
5578 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5580 if (code
== TYPE_CODE_UNDEF
)
5582 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5584 completion_list_add_fields (tracker
, sym
, lookup_name
,
5587 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5588 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
5589 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5593 /* Stop when we encounter an enclosing function. Do not stop for
5594 non-inlined functions - the locals of the enclosing function
5595 are in scope for a nested function. */
5596 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
5598 b
= BLOCK_SUPERBLOCK (b
);
5601 /* Add fields from the file's types; symbols will be added below. */
5603 if (code
== TYPE_CODE_UNDEF
)
5605 if (surrounding_static_block
!= NULL
)
5606 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
5607 completion_list_add_fields (tracker
, sym
, lookup_name
,
5610 if (surrounding_global_block
!= NULL
)
5611 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
5612 completion_list_add_fields (tracker
, sym
, lookup_name
,
5616 /* Skip macros if we are completing a struct tag -- arguable but
5617 usually what is expected. */
5618 if (current_language
->la_macro_expansion
== macro_expansion_c
5619 && code
== TYPE_CODE_UNDEF
)
5621 gdb::unique_xmalloc_ptr
<struct macro_scope
> scope
;
5623 /* This adds a macro's name to the current completion list. */
5624 auto add_macro_name
= [&] (const char *macro_name
,
5625 const macro_definition
*,
5626 macro_source_file
*,
5629 completion_list_add_name (tracker
, language_c
, macro_name
,
5630 lookup_name
, sym_text
, word
);
5633 /* Add any macros visible in the default scope. Note that this
5634 may yield the occasional wrong result, because an expression
5635 might be evaluated in a scope other than the default. For
5636 example, if the user types "break file:line if <TAB>", the
5637 resulting expression will be evaluated at "file:line" -- but
5638 at there does not seem to be a way to detect this at
5640 scope
= default_macro_scope ();
5642 macro_for_each_in_scope (scope
->file
, scope
->line
,
5645 /* User-defined macros are always visible. */
5646 macro_for_each (macro_user_macros
, add_macro_name
);
5651 default_collect_symbol_completion_matches (completion_tracker
&tracker
,
5652 complete_symbol_mode mode
,
5653 symbol_name_match_type name_match_type
,
5654 const char *text
, const char *word
,
5655 enum type_code code
)
5657 return default_collect_symbol_completion_matches_break_on (tracker
, mode
,
5663 /* Collect all symbols (regardless of class) which begin by matching
5667 collect_symbol_completion_matches (completion_tracker
&tracker
,
5668 complete_symbol_mode mode
,
5669 symbol_name_match_type name_match_type
,
5670 const char *text
, const char *word
)
5672 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5678 /* Like collect_symbol_completion_matches, but only collect
5679 STRUCT_DOMAIN symbols whose type code is CODE. */
5682 collect_symbol_completion_matches_type (completion_tracker
&tracker
,
5683 const char *text
, const char *word
,
5684 enum type_code code
)
5686 complete_symbol_mode mode
= complete_symbol_mode::EXPRESSION
;
5687 symbol_name_match_type name_match_type
= symbol_name_match_type::EXPRESSION
;
5689 gdb_assert (code
== TYPE_CODE_UNION
5690 || code
== TYPE_CODE_STRUCT
5691 || code
== TYPE_CODE_ENUM
);
5692 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5697 /* Like collect_symbol_completion_matches, but collects a list of
5698 symbols defined in all source files named SRCFILE. */
5701 collect_file_symbol_completion_matches (completion_tracker
&tracker
,
5702 complete_symbol_mode mode
,
5703 symbol_name_match_type name_match_type
,
5704 const char *text
, const char *word
,
5705 const char *srcfile
)
5707 /* The symbol we are completing on. Points in same buffer as text. */
5708 const char *sym_text
;
5710 /* Now look for the symbol we are supposed to complete on.
5711 FIXME: This should be language-specific. */
5712 if (mode
== complete_symbol_mode::LINESPEC
)
5718 const char *quote_pos
= NULL
;
5720 /* First see if this is a quoted string. */
5722 for (p
= text
; *p
!= '\0'; ++p
)
5724 if (quote_found
!= '\0')
5726 if (*p
== quote_found
)
5727 /* Found close quote. */
5729 else if (*p
== '\\' && p
[1] == quote_found
)
5730 /* A backslash followed by the quote character
5731 doesn't end the string. */
5734 else if (*p
== '\'' || *p
== '"')
5740 if (quote_found
== '\'')
5741 /* A string within single quotes can be a symbol, so complete on it. */
5742 sym_text
= quote_pos
+ 1;
5743 else if (quote_found
== '"')
5744 /* A double-quoted string is never a symbol, nor does it make sense
5745 to complete it any other way. */
5751 /* Not a quoted string. */
5752 sym_text
= language_search_unquoted_string (text
, p
);
5756 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5758 /* Go through symtabs for SRCFILE and check the externs and statics
5759 for symbols which match. */
5760 iterate_over_symtabs (srcfile
, [&] (symtab
*s
)
5762 add_symtab_completions (SYMTAB_COMPUNIT (s
),
5763 tracker
, mode
, lookup_name
,
5764 sym_text
, word
, TYPE_CODE_UNDEF
);
5769 /* A helper function for make_source_files_completion_list. It adds
5770 another file name to a list of possible completions, growing the
5771 list as necessary. */
5774 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
5775 completion_list
*list
)
5777 list
->emplace_back (make_completion_match_str (fname
, text
, word
));
5781 not_interesting_fname (const char *fname
)
5783 static const char *illegal_aliens
[] = {
5784 "_globals_", /* inserted by coff_symtab_read */
5789 for (i
= 0; illegal_aliens
[i
]; i
++)
5791 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
5797 /* An object of this type is passed as the user_data argument to
5798 map_partial_symbol_filenames. */
5799 struct add_partial_filename_data
5801 struct filename_seen_cache
*filename_seen_cache
;
5805 completion_list
*list
;
5808 /* A callback for map_partial_symbol_filenames. */
5811 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
5814 struct add_partial_filename_data
*data
5815 = (struct add_partial_filename_data
*) user_data
;
5817 if (not_interesting_fname (filename
))
5819 if (!data
->filename_seen_cache
->seen (filename
)
5820 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
5822 /* This file matches for a completion; add it to the
5823 current list of matches. */
5824 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
5828 const char *base_name
= lbasename (filename
);
5830 if (base_name
!= filename
5831 && !data
->filename_seen_cache
->seen (base_name
)
5832 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
5833 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
5837 /* Return a list of all source files whose names begin with matching
5838 TEXT. The file names are looked up in the symbol tables of this
5842 make_source_files_completion_list (const char *text
, const char *word
)
5844 size_t text_len
= strlen (text
);
5845 completion_list list
;
5846 const char *base_name
;
5847 struct add_partial_filename_data datum
;
5849 if (!have_full_symbols () && !have_partial_symbols ())
5852 filename_seen_cache filenames_seen
;
5854 for (objfile
*objfile
: current_program_space
->objfiles ())
5856 for (compunit_symtab
*cu
: objfile
->compunits ())
5858 for (symtab
*s
: compunit_filetabs (cu
))
5860 if (not_interesting_fname (s
->filename
))
5862 if (!filenames_seen
.seen (s
->filename
)
5863 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
5865 /* This file matches for a completion; add it to the current
5867 add_filename_to_list (s
->filename
, text
, word
, &list
);
5871 /* NOTE: We allow the user to type a base name when the
5872 debug info records leading directories, but not the other
5873 way around. This is what subroutines of breakpoint
5874 command do when they parse file names. */
5875 base_name
= lbasename (s
->filename
);
5876 if (base_name
!= s
->filename
5877 && !filenames_seen
.seen (base_name
)
5878 && filename_ncmp (base_name
, text
, text_len
) == 0)
5879 add_filename_to_list (base_name
, text
, word
, &list
);
5885 datum
.filename_seen_cache
= &filenames_seen
;
5888 datum
.text_len
= text_len
;
5890 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
5891 0 /*need_fullname*/);
5898 /* Return the "main_info" object for the current program space. If
5899 the object has not yet been created, create it and fill in some
5902 static struct main_info
*
5903 get_main_info (void)
5905 struct main_info
*info
= main_progspace_key
.get (current_program_space
);
5909 /* It may seem strange to store the main name in the progspace
5910 and also in whatever objfile happens to see a main name in
5911 its debug info. The reason for this is mainly historical:
5912 gdb returned "main" as the name even if no function named
5913 "main" was defined the program; and this approach lets us
5914 keep compatibility. */
5915 info
= main_progspace_key
.emplace (current_program_space
);
5922 set_main_name (const char *name
, enum language lang
)
5924 struct main_info
*info
= get_main_info ();
5926 if (info
->name_of_main
!= NULL
)
5928 xfree (info
->name_of_main
);
5929 info
->name_of_main
= NULL
;
5930 info
->language_of_main
= language_unknown
;
5934 info
->name_of_main
= xstrdup (name
);
5935 info
->language_of_main
= lang
;
5939 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5943 find_main_name (void)
5945 const char *new_main_name
;
5947 /* First check the objfiles to see whether a debuginfo reader has
5948 picked up the appropriate main name. Historically the main name
5949 was found in a more or less random way; this approach instead
5950 relies on the order of objfile creation -- which still isn't
5951 guaranteed to get the correct answer, but is just probably more
5953 for (objfile
*objfile
: current_program_space
->objfiles ())
5955 if (objfile
->per_bfd
->name_of_main
!= NULL
)
5957 set_main_name (objfile
->per_bfd
->name_of_main
,
5958 objfile
->per_bfd
->language_of_main
);
5963 /* Try to see if the main procedure is in Ada. */
5964 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5965 be to add a new method in the language vector, and call this
5966 method for each language until one of them returns a non-empty
5967 name. This would allow us to remove this hard-coded call to
5968 an Ada function. It is not clear that this is a better approach
5969 at this point, because all methods need to be written in a way
5970 such that false positives never be returned. For instance, it is
5971 important that a method does not return a wrong name for the main
5972 procedure if the main procedure is actually written in a different
5973 language. It is easy to guaranty this with Ada, since we use a
5974 special symbol generated only when the main in Ada to find the name
5975 of the main procedure. It is difficult however to see how this can
5976 be guarantied for languages such as C, for instance. This suggests
5977 that order of call for these methods becomes important, which means
5978 a more complicated approach. */
5979 new_main_name
= ada_main_name ();
5980 if (new_main_name
!= NULL
)
5982 set_main_name (new_main_name
, language_ada
);
5986 new_main_name
= d_main_name ();
5987 if (new_main_name
!= NULL
)
5989 set_main_name (new_main_name
, language_d
);
5993 new_main_name
= go_main_name ();
5994 if (new_main_name
!= NULL
)
5996 set_main_name (new_main_name
, language_go
);
6000 new_main_name
= pascal_main_name ();
6001 if (new_main_name
!= NULL
)
6003 set_main_name (new_main_name
, language_pascal
);
6007 /* The languages above didn't identify the name of the main procedure.
6008 Fallback to "main". */
6009 set_main_name ("main", language_unknown
);
6017 struct main_info
*info
= get_main_info ();
6019 if (info
->name_of_main
== NULL
)
6022 return info
->name_of_main
;
6025 /* Return the language of the main function. If it is not known,
6026 return language_unknown. */
6029 main_language (void)
6031 struct main_info
*info
= get_main_info ();
6033 if (info
->name_of_main
== NULL
)
6036 return info
->language_of_main
;
6039 /* Handle ``executable_changed'' events for the symtab module. */
6042 symtab_observer_executable_changed (void)
6044 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
6045 set_main_name (NULL
, language_unknown
);
6048 /* Return 1 if the supplied producer string matches the ARM RealView
6049 compiler (armcc). */
6052 producer_is_realview (const char *producer
)
6054 static const char *const arm_idents
[] = {
6055 "ARM C Compiler, ADS",
6056 "Thumb C Compiler, ADS",
6057 "ARM C++ Compiler, ADS",
6058 "Thumb C++ Compiler, ADS",
6059 "ARM/Thumb C/C++ Compiler, RVCT",
6060 "ARM C/C++ Compiler, RVCT"
6064 if (producer
== NULL
)
6067 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
6068 if (startswith (producer
, arm_idents
[i
]))
6076 /* The next index to hand out in response to a registration request. */
6078 static int next_aclass_value
= LOC_FINAL_VALUE
;
6080 /* The maximum number of "aclass" registrations we support. This is
6081 constant for convenience. */
6082 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
6084 /* The objects representing the various "aclass" values. The elements
6085 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
6086 elements are those registered at gdb initialization time. */
6088 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
6090 /* The globally visible pointer. This is separate from 'symbol_impl'
6091 so that it can be const. */
6093 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
6095 /* Make sure we saved enough room in struct symbol. */
6097 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
6099 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
6100 is the ops vector associated with this index. This returns the new
6101 index, which should be used as the aclass_index field for symbols
6105 register_symbol_computed_impl (enum address_class aclass
,
6106 const struct symbol_computed_ops
*ops
)
6108 int result
= next_aclass_value
++;
6110 gdb_assert (aclass
== LOC_COMPUTED
);
6111 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6112 symbol_impl
[result
].aclass
= aclass
;
6113 symbol_impl
[result
].ops_computed
= ops
;
6115 /* Sanity check OPS. */
6116 gdb_assert (ops
!= NULL
);
6117 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
6118 gdb_assert (ops
->describe_location
!= NULL
);
6119 gdb_assert (ops
->get_symbol_read_needs
!= NULL
);
6120 gdb_assert (ops
->read_variable
!= NULL
);
6125 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
6126 OPS is the ops vector associated with this index. This returns the
6127 new index, which should be used as the aclass_index field for symbols
6131 register_symbol_block_impl (enum address_class aclass
,
6132 const struct symbol_block_ops
*ops
)
6134 int result
= next_aclass_value
++;
6136 gdb_assert (aclass
== LOC_BLOCK
);
6137 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6138 symbol_impl
[result
].aclass
= aclass
;
6139 symbol_impl
[result
].ops_block
= ops
;
6141 /* Sanity check OPS. */
6142 gdb_assert (ops
!= NULL
);
6143 gdb_assert (ops
->find_frame_base_location
!= NULL
);
6148 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
6149 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
6150 this index. This returns the new index, which should be used as
6151 the aclass_index field for symbols of this type. */
6154 register_symbol_register_impl (enum address_class aclass
,
6155 const struct symbol_register_ops
*ops
)
6157 int result
= next_aclass_value
++;
6159 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
6160 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
6161 symbol_impl
[result
].aclass
= aclass
;
6162 symbol_impl
[result
].ops_register
= ops
;
6167 /* Initialize elements of 'symbol_impl' for the constants in enum
6171 initialize_ordinary_address_classes (void)
6175 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
6176 symbol_impl
[i
].aclass
= (enum address_class
) i
;
6181 /* Helper function to initialize the fields of an objfile-owned symbol.
6182 It assumed that *SYM is already all zeroes. */
6185 initialize_objfile_symbol_1 (struct symbol
*sym
)
6187 SYMBOL_OBJFILE_OWNED (sym
) = 1;
6188 SYMBOL_SECTION (sym
) = -1;
6191 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
6194 initialize_objfile_symbol (struct symbol
*sym
)
6196 memset (sym
, 0, sizeof (*sym
));
6197 initialize_objfile_symbol_1 (sym
);
6200 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
6204 allocate_symbol (struct objfile
*objfile
)
6206 struct symbol
*result
;
6208 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
6209 initialize_objfile_symbol_1 (result
);
6214 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
6217 struct template_symbol
*
6218 allocate_template_symbol (struct objfile
*objfile
)
6220 struct template_symbol
*result
;
6222 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
6223 initialize_objfile_symbol_1 (result
);
6231 symbol_objfile (const struct symbol
*symbol
)
6233 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6234 return SYMTAB_OBJFILE (symbol
->owner
.symtab
);
6240 symbol_arch (const struct symbol
*symbol
)
6242 if (!SYMBOL_OBJFILE_OWNED (symbol
))
6243 return symbol
->owner
.arch
;
6244 return get_objfile_arch (SYMTAB_OBJFILE (symbol
->owner
.symtab
));
6250 symbol_symtab (const struct symbol
*symbol
)
6252 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6253 return symbol
->owner
.symtab
;
6259 symbol_set_symtab (struct symbol
*symbol
, struct symtab
*symtab
)
6261 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6262 symbol
->owner
.symtab
= symtab
;
6268 get_symbol_address (const struct symbol
*sym
)
6270 gdb_assert (sym
->maybe_copied
);
6271 gdb_assert (SYMBOL_CLASS (sym
) == LOC_STATIC
);
6273 const char *linkage_name
= SYMBOL_LINKAGE_NAME (sym
);
6275 for (objfile
*objfile
: current_program_space
->objfiles ())
6277 bound_minimal_symbol minsym
6278 = lookup_minimal_symbol_linkage (linkage_name
, objfile
);
6279 if (minsym
.minsym
!= nullptr)
6280 return BMSYMBOL_VALUE_ADDRESS (minsym
);
6282 return sym
->ginfo
.value
.address
;
6288 get_msymbol_address (struct objfile
*objf
, const struct minimal_symbol
*minsym
)
6290 gdb_assert (minsym
->maybe_copied
);
6291 gdb_assert ((objf
->flags
& OBJF_MAINLINE
) == 0);
6293 const char *linkage_name
= MSYMBOL_LINKAGE_NAME (minsym
);
6295 for (objfile
*objfile
: current_program_space
->objfiles ())
6297 if ((objfile
->flags
& OBJF_MAINLINE
) != 0)
6299 bound_minimal_symbol found
6300 = lookup_minimal_symbol_linkage (linkage_name
, objfile
);
6301 if (found
.minsym
!= nullptr)
6302 return BMSYMBOL_VALUE_ADDRESS (found
);
6305 return (minsym
->value
.address
6306 + ANOFFSET (objf
->section_offsets
, minsym
->section
));
6312 _initialize_symtab (void)
6314 cmd_list_element
*c
;
6316 initialize_ordinary_address_classes ();
6318 c
= add_info ("variables", info_variables_command
,
6319 info_print_args_help (_("\
6320 All global and static variable names or those matching REGEXPs.\n\
6321 Usage: info variables [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6322 Prints the global and static variables.\n"),
6323 _("global and static variables"),
6325 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6328 c
= add_com ("whereis", class_info
, info_variables_command
,
6329 info_print_args_help (_("\
6330 All global and static variable names, or those matching REGEXPs.\n\
6331 Usage: whereis [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6332 Prints the global and static variables.\n"),
6333 _("global and static variables"),
6335 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6338 c
= add_info ("functions", info_functions_command
,
6339 info_print_args_help (_("\
6340 All function names or those matching REGEXPs.\n\
6341 Usage: info functions [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6342 Prints the functions.\n"),
6345 set_cmd_completer_handle_brkchars (c
, info_print_command_completer
);
6347 c
= add_info ("types", info_types_command
, _("\
6348 All type names, or those matching REGEXP.\n\
6349 Usage: info types [-q] [REGEXP]\n\
6350 Print information about all types matching REGEXP, or all types if no\n\
6351 REGEXP is given. The optional flag -q disables printing of headers."));
6352 set_cmd_completer_handle_brkchars (c
, info_types_command_completer
);
6354 const auto info_sources_opts
= make_info_sources_options_def_group (nullptr);
6356 static std::string info_sources_help
6357 = gdb::option::build_help (_("\
6358 All source files in the program or those matching REGEXP.\n\
6359 Usage: info sources [OPTION]... [REGEXP]\n\
6360 By default, REGEXP is used to match anywhere in the filename.\n\
6366 c
= add_info ("sources", info_sources_command
, info_sources_help
.c_str ());
6367 set_cmd_completer_handle_brkchars (c
, info_sources_command_completer
);
6369 add_com ("rbreak", class_breakpoint
, rbreak_command
,
6370 _("Set a breakpoint for all functions matching REGEXP."));
6372 add_setshow_enum_cmd ("multiple-symbols", no_class
,
6373 multiple_symbols_modes
, &multiple_symbols_mode
,
6375 Set how the debugger handles ambiguities in expressions."), _("\
6376 Show how the debugger handles ambiguities in expressions."), _("\
6377 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
6378 NULL
, NULL
, &setlist
, &showlist
);
6380 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
6381 &basenames_may_differ
, _("\
6382 Set whether a source file may have multiple base names."), _("\
6383 Show whether a source file may have multiple base names."), _("\
6384 (A \"base name\" is the name of a file with the directory part removed.\n\
6385 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
6386 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
6387 before comparing them. Canonicalization is an expensive operation,\n\
6388 but it allows the same file be known by more than one base name.\n\
6389 If not set (the default), all source files are assumed to have just\n\
6390 one base name, and gdb will do file name comparisons more efficiently."),
6392 &setlist
, &showlist
);
6394 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
6395 _("Set debugging of symbol table creation."),
6396 _("Show debugging of symbol table creation."), _("\
6397 When enabled (non-zero), debugging messages are printed when building\n\
6398 symbol tables. A value of 1 (one) normally provides enough information.\n\
6399 A value greater than 1 provides more verbose information."),
6402 &setdebuglist
, &showdebuglist
);
6404 add_setshow_zuinteger_cmd ("symbol-lookup", no_class
, &symbol_lookup_debug
,
6406 Set debugging of symbol lookup."), _("\
6407 Show debugging of symbol lookup."), _("\
6408 When enabled (non-zero), symbol lookups are logged."),
6410 &setdebuglist
, &showdebuglist
);
6412 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class
,
6413 &new_symbol_cache_size
,
6414 _("Set the size of the symbol cache."),
6415 _("Show the size of the symbol cache."), _("\
6416 The size of the symbol cache.\n\
6417 If zero then the symbol cache is disabled."),
6418 set_symbol_cache_size_handler
, NULL
,
6419 &maintenance_set_cmdlist
,
6420 &maintenance_show_cmdlist
);
6422 add_cmd ("symbol-cache", class_maintenance
, maintenance_print_symbol_cache
,
6423 _("Dump the symbol cache for each program space."),
6424 &maintenanceprintlist
);
6426 add_cmd ("symbol-cache-statistics", class_maintenance
,
6427 maintenance_print_symbol_cache_statistics
,
6428 _("Print symbol cache statistics for each program space."),
6429 &maintenanceprintlist
);
6431 add_cmd ("flush-symbol-cache", class_maintenance
,
6432 maintenance_flush_symbol_cache
,
6433 _("Flush the symbol cache for each program space."),
6436 gdb::observers::executable_changed
.attach (symtab_observer_executable_changed
);
6437 gdb::observers::new_objfile
.attach (symtab_new_objfile_observer
);
6438 gdb::observers::free_objfile
.attach (symtab_free_objfile_observer
);