GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/symtab.c
Go to the documentation of this file.
1/* Symbol table lookup for the GNU debugger, GDB.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "symtab.h"
22#include "gdbtypes.h"
23#include "gdbcore.h"
24#include "frame.h"
25#include "target.h"
26#include "value.h"
27#include "symfile.h"
28#include "objfiles.h"
29#include "gdbcmd.h"
30#include "gdbsupport/gdb_regex.h"
31#include "expression.h"
32#include "language.h"
33#include "demangle.h"
34#include "inferior.h"
35#include "source.h"
36#include "filenames.h" /* for FILENAME_CMP */
37#include "objc-lang.h"
38#include "d-lang.h"
39#include "ada-lang.h"
40#include "go-lang.h"
41#include "p-lang.h"
42#include "addrmap.h"
43#include "cli/cli-utils.h"
44#include "cli/cli-style.h"
45#include "cli/cli-cmds.h"
46#include "fnmatch.h"
47#include "hashtab.h"
48#include "typeprint.h"
49
50#include "gdbsupport/gdb_obstack.h"
51#include "block.h"
52#include "dictionary.h"
53
54#include <sys/types.h>
55#include <fcntl.h>
56#include <sys/stat.h>
57#include <ctype.h>
58#include "cp-abi.h"
59#include "cp-support.h"
60#include "observable.h"
61#include "solist.h"
62#include "macrotab.h"
63#include "macroscope.h"
64
65#include "parser-defs.h"
66#include "completer.h"
68#include "gdbsupport/gdb_optional.h"
69#include "filename-seen-cache.h"
70#include "arch-utils.h"
71#include <algorithm>
72#include "gdbsupport/gdb_string_view.h"
73#include "gdbsupport/pathstuff.h"
74#include "gdbsupport/common-utils.h"
75
76/* Forward declarations for local functions. */
77
78static void rbreak_command (const char *, int);
79
80static int find_line_common (struct linetable *, int, int *, int);
81
82static struct block_symbol
83 lookup_symbol_aux (const char *name,
84 symbol_name_match_type match_type,
85 const struct block *block,
86 const domain_enum domain,
87 enum language language,
88 struct field_of_this_result *);
89
90static
92 symbol_name_match_type match_type,
93 const struct block *block,
94 const domain_enum domain,
95 enum language language);
96
97static struct block_symbol
99 enum block_enum block_index,
100 const char *name, const domain_enum domain);
101
102/* Type of the data stored on the program space. */
103
105{
106 main_info () = default;
107
109 {
111 }
112
113 /* Name of "main". */
114
115 char *name_of_main = nullptr;
116
117 /* Language of "main". */
118
120};
121
122/* Program space key for finding name and language of "main". */
123
125
126/* The default symbol cache size.
127 There is no extra cpu cost for large N (except when flushing the cache,
128 which is rare). The value here is just a first attempt. A better default
129 value may be higher or lower. A prime number can make up for a bad hash
130 computation, so that's why the number is what it is. */
131#define DEFAULT_SYMBOL_CACHE_SIZE 1021
132
133/* The maximum symbol cache size.
134 There's no method to the decision of what value to use here, other than
135 there's no point in allowing a user typo to make gdb consume all memory. */
136#define MAX_SYMBOL_CACHE_SIZE (1024*1024)
137
138/* symbol_cache_lookup returns this if a previous lookup failed to find the
139 symbol in any objfile. */
140#define SYMBOL_LOOKUP_FAILED \
141 ((struct block_symbol) {(struct symbol *) 1, NULL})
142#define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
143
144/* Recording lookups that don't find the symbol is just as important, if not
145 more so, than recording found symbols. */
146
148{
153
155{
157
158 /* The objfile that was current when the symbol was looked up.
159 This is only needed for global blocks, but for simplicity's sake
160 we allocate the space for both. If data shows the extra space used
161 for static blocks is a problem, we can split things up then.
162
163 Global blocks need cache lookup to include the objfile context because
164 we need to account for gdbarch_iterate_over_objfiles_in_search_order
165 which can traverse objfiles in, effectively, any order, depending on
166 the current objfile, thus affecting which symbol is found. Normally,
167 only the current objfile is searched first, and then the rest are
168 searched in recorded order; but putting cache lookup inside
169 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
170 Instead we just make the current objfile part of the context of
171 cache lookup. This means we can record the same symbol multiple times,
172 each with a different "current objfile" that was in effect when the
173 lookup was saved in the cache, but cache space is pretty cheap. */
175
176 union
177 {
179 struct
180 {
181 char *name;
185};
186
187/* Clear out SLOT. */
188
189static void
191{
192 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
193 xfree (slot->value.not_found.name);
195}
196
197/* Symbols don't specify global vs static block.
198 So keep them in separate caches. */
199
201{
202 unsigned int hits;
203 unsigned int misses;
204 unsigned int collisions;
205
206 /* SYMBOLS is a variable length array of this size.
207 One can imagine that in general one cache (global/static) should be a
208 fraction of the size of the other, but there's no data at the moment
209 on which to decide. */
210 unsigned int size;
211
213};
214
215/* Clear all slots of BSC and free BSC. */
216
217static void
219{
220 if (bsc != nullptr)
221 {
222 for (unsigned int i = 0; i < bsc->size; i++)
224 xfree (bsc);
225 }
226}
227
228/* The symbol cache.
229
230 Searching for symbols in the static and global blocks over multiple objfiles
231 again and again can be slow, as can searching very big objfiles. This is a
232 simple cache to improve symbol lookup performance, which is critical to
233 overall gdb performance.
234
235 Symbols are hashed on the name, its domain, and block.
236 They are also hashed on their objfile for objfile-specific lookups. */
237
239{
240 symbol_cache () = default;
241
243 {
246 }
247
250};
251
252/* Program space key for finding its symbol cache. */
253
255
256/* When non-zero, print debugging messages related to symtab creation. */
257unsigned int symtab_create_debug = 0;
258
259/* When non-zero, print debugging messages related to symbol lookup. */
260unsigned int symbol_lookup_debug = 0;
261
262/* The size of the cache is staged here. */
264
265/* The current value of the symbol cache size.
266 This is saved so that if the user enters a value too big we can restore
267 the original value from here. */
269
270/* True if a file may be known by two different basenames.
271 This is the uncommon case, and significantly slows down gdb.
272 Default set to "off" to not slow down the common case. */
274
275/* Allow the user to configure the debugger behavior with respect
276 to multiple-choice menus when more than one symbol matches during
277 a symbol lookup. */
278
279const char multiple_symbols_ask[] = "ask";
280const char multiple_symbols_all[] = "all";
281const char multiple_symbols_cancel[] = "cancel";
282static const char *const multiple_symbols_modes[] =
283{
287 NULL
288};
290
291/* When TRUE, ignore the prologue-end flag in linetable_entry when searching
292 for the SAL past a function prologue. */
293static bool ignore_prologue_end_flag = false;
294
295/* Read-only accessor to AUTO_SELECT_MODE. */
296
297const char *
299{
301}
302
303/* Return the name of a domain_enum. */
304
305const char *
307{
308 switch (e)
309 {
310 case UNDEF_DOMAIN: return "UNDEF_DOMAIN";
311 case VAR_DOMAIN: return "VAR_DOMAIN";
312 case STRUCT_DOMAIN: return "STRUCT_DOMAIN";
313 case MODULE_DOMAIN: return "MODULE_DOMAIN";
314 case LABEL_DOMAIN: return "LABEL_DOMAIN";
315 case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN";
316 default: gdb_assert_not_reached ("bad domain_enum");
317 }
318}
319
320/* Return the name of a search_domain . */
321
322const char *
324{
325 switch (e)
326 {
327 case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN";
328 case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN";
329 case TYPES_DOMAIN: return "TYPES_DOMAIN";
330 case MODULES_DOMAIN: return "MODULES_DOMAIN";
331 case ALL_DOMAIN: return "ALL_DOMAIN";
332 default: gdb_assert_not_reached ("bad search_domain");
333 }
334}
335
336/* See symtab.h. */
337
338call_site *
340{
341 if (m_call_site_htab == nullptr)
342 return nullptr;
343
344 CORE_ADDR delta
345 = this->objfile ()->section_offsets[this->block_line_section ()];
346 CORE_ADDR unrelocated_pc = pc - delta;
347
348 struct call_site call_site_local (unrelocated_pc, nullptr, nullptr);
349 void **slot
350 = htab_find_slot (m_call_site_htab, &call_site_local, NO_INSERT);
351 if (slot == nullptr)
352 return nullptr;
353
354 return (call_site *) *slot;
355}
356
357/* See symtab.h. */
358
359void
361{
362 gdb_assert (m_call_site_htab == nullptr);
363 m_call_site_htab = call_site_htab;
364}
365
366/* See symtab.h. */
367
368void
370{
371 symtab *prev_filetab = nullptr;
372
373 /* Move PRIMARY_FILETAB to the head of the filetab list. */
374 for (symtab *filetab : this->filetabs ())
375 {
376 if (filetab == primary_filetab)
377 {
378 if (prev_filetab != nullptr)
379 {
380 prev_filetab->next = primary_filetab->next;
383 }
384
385 break;
386 }
387
388 prev_filetab = filetab;
389 }
390
391 gdb_assert (primary_filetab == m_filetabs);
392}
393
394/* See symtab.h. */
395
396struct symtab *
398{
399 gdb_assert (m_filetabs != nullptr);
400
401 /* The primary file symtab is the first one in the list. */
402 return m_filetabs;
403}
404
405/* See symtab.h. */
406
407enum language
409{
410 struct symtab *symtab = primary_filetab ();
411
412 /* The language of the compunit symtab is the language of its
413 primary source file. */
414 return symtab->language ();
415}
416
417/* The relocated address of the minimal symbol, using the section
418 offsets from OBJFILE. */
419
420CORE_ADDR
422{
423 if (this->maybe_copied)
424 return get_msymbol_address (objfile, this);
425 else
426 return (this->value_raw_address ()
427 + objfile->section_offsets[this->section_index ()]);
428}
429
430/* See symtab.h. */
431
432bool
434{
435 return m_type == mst_data
436 || m_type == mst_bss
437 || m_type == mst_abs
439 || m_type == mst_file_bss;
440}
441
442/* See symtab.h. */
443
444bool
446{
447 return m_type == mst_text
452 || m_type == mst_file_text;
453}
454
455/* See whether FILENAME matches SEARCH_NAME using the rule that we
456 advertise to the user. (The manual's description of linespecs
457 describes what we advertise). Returns true if they match, false
458 otherwise. */
459
460bool
461compare_filenames_for_search (const char *filename, const char *search_name)
462{
463 int len = strlen (filename);
464 size_t search_len = strlen (search_name);
465
466 if (len < search_len)
467 return false;
468
469 /* The tail of FILENAME must match. */
470 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
471 return false;
472
473 /* Either the names must completely match, or the character
474 preceding the trailing SEARCH_NAME segment of FILENAME must be a
475 directory separator.
476
477 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
478 cannot match FILENAME "/path//dir/file.c" - as user has requested
479 absolute path. The sama applies for "c:\file.c" possibly
480 incorrectly hypothetically matching "d:\dir\c:\file.c".
481
482 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
483 compatible with SEARCH_NAME "file.c". In such case a compiler had
484 to put the "c:file.c" name into debug info. Such compatibility
485 works only on GDB built for DOS host. */
486 return (len == search_len
487 || (!IS_ABSOLUTE_PATH (search_name)
488 && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
489 || (HAS_DRIVE_SPEC (filename)
490 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
491}
492
493/* Same as compare_filenames_for_search, but for glob-style patterns.
494 Heads up on the order of the arguments. They match the order of
495 compare_filenames_for_search, but it's the opposite of the order of
496 arguments to gdb_filename_fnmatch. */
497
498bool
500 const char *search_name)
501{
502 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
503 all /s have to be explicitly specified. */
504 int file_path_elements = count_path_elements (filename);
505 int search_path_elements = count_path_elements (search_name);
506
507 if (search_path_elements > file_path_elements)
508 return false;
509
510 if (IS_ABSOLUTE_PATH (search_name))
511 {
512 return (search_path_elements == file_path_elements
513 && gdb_filename_fnmatch (search_name, filename,
514 FNM_FILE_NAME | FNM_NOESCAPE) == 0);
515 }
516
517 {
518 const char *file_to_compare
520 file_path_elements - search_path_elements);
521
522 return gdb_filename_fnmatch (search_name, file_to_compare,
523 FNM_FILE_NAME | FNM_NOESCAPE) == 0;
524 }
525}
526
527/* Check for a symtab of a specific name by searching some symtabs.
528 This is a helper function for callbacks of iterate_over_symtabs.
529
530 If NAME is not absolute, then REAL_PATH is NULL
531 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
532
533 The return value, NAME, REAL_PATH and CALLBACK are identical to the
534 `map_symtabs_matching_filename' method of quick_symbol_functions.
535
536 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
537 Each symtab within the specified compunit symtab is also searched.
538 AFTER_LAST is one past the last compunit symtab to search; NULL means to
539 search until the end of the list. */
540
541bool
543 const char *real_path,
544 struct compunit_symtab *first,
545 struct compunit_symtab *after_last,
546 gdb::function_view<bool (symtab *)> callback)
547{
548 struct compunit_symtab *cust;
549 const char* base_name = lbasename (name);
550
551 for (cust = first; cust != NULL && cust != after_last; cust = cust->next)
552 {
553 for (symtab *s : cust->filetabs ())
554 {
555 if (compare_filenames_for_search (s->filename, name))
556 {
557 if (callback (s))
558 return true;
559 continue;
560 }
561
562 /* Before we invoke realpath, which can get expensive when many
563 files are involved, do a quick comparison of the basenames. */
565 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
566 continue;
567
569 {
570 if (callback (s))
571 return true;
572 continue;
573 }
574
575 /* If the user gave us an absolute path, try to find the file in
576 this symtab and use its absolute path. */
577 if (real_path != NULL)
578 {
579 const char *fullname = symtab_to_fullname (s);
580
581 gdb_assert (IS_ABSOLUTE_PATH (real_path));
582 gdb_assert (IS_ABSOLUTE_PATH (name));
583 gdb::unique_xmalloc_ptr<char> fullname_real_path
584 = gdb_realpath (fullname);
585 fullname = fullname_real_path.get ();
586 if (FILENAME_CMP (real_path, fullname) == 0)
587 {
588 if (callback (s))
589 return true;
590 continue;
591 }
592 }
593 }
594 }
595
596 return false;
597}
598
599/* Check for a symtab of a specific name; first in symtabs, then in
600 psymtabs. *If* there is no '/' in the name, a match after a '/'
601 in the symtab filename will also work.
602
603 Calls CALLBACK with each symtab that is found. If CALLBACK returns
604 true, the search stops. */
605
606void
608 gdb::function_view<bool (symtab *)> callback)
609{
610 gdb::unique_xmalloc_ptr<char> real_path;
611
612 /* Here we are interested in canonicalizing an absolute path, not
613 absolutizing a relative path. */
614 if (IS_ABSOLUTE_PATH (name))
615 {
616 real_path = gdb_realpath (name);
617 gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
618 }
619
621 {
622 if (iterate_over_some_symtabs (name, real_path.get (),
624 callback))
625 return;
626 }
627
628 /* Same search rules as above apply here, but now we look thru the
629 psymtabs. */
630
632 {
633 if (objfile->map_symtabs_matching_filename (name, real_path.get (),
634 callback))
635 return;
636 }
637}
638
639/* A wrapper for iterate_over_symtabs that returns the first matching
640 symtab, or NULL. */
641
642struct symtab *
643lookup_symtab (const char *name)
644{
645 struct symtab *result = NULL;
646
648 {
649 result = symtab;
650 return true;
651 });
652
653 return result;
654}
655
656
657/* Mangle a GDB method stub type. This actually reassembles the pieces of the
658 full method name, which consist of the class name (from T), the unadorned
659 method name from METHOD_ID, and the signature for the specific overload,
660 specified by SIGNATURE_ID. Note that this function is g++ specific. */
661
662char *
663gdb_mangle_name (struct type *type, int method_id, int signature_id)
664{
665 int mangled_name_len;
666 char *mangled_name;
667 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
668 struct fn_field *method = &f[signature_id];
669 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
670 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
671 const char *newname = type->name ();
672
673 /* Does the form of physname indicate that it is the full mangled name
674 of a constructor (not just the args)? */
675 int is_full_physname_constructor;
676
677 int is_constructor;
678 int is_destructor = is_destructor_name (physname);
679 /* Need a new type prefix. */
680 const char *const_prefix = method->is_const ? "C" : "";
681 const char *volatile_prefix = method->is_volatile ? "V" : "";
682 char buf[20];
683 int len = (newname == NULL ? 0 : strlen (newname));
684
685 /* Nothing to do if physname already contains a fully mangled v3 abi name
686 or an operator name. */
687 if ((physname[0] == '_' && physname[1] == 'Z')
689 return xstrdup (physname);
690
691 is_full_physname_constructor = is_constructor_name (physname);
692
693 is_constructor = is_full_physname_constructor
694 || (newname && strcmp (field_name, newname) == 0);
695
696 if (!is_destructor)
697 is_destructor = (startswith (physname, "__dt"));
698
699 if (is_destructor || is_full_physname_constructor)
700 {
701 mangled_name = (char *) xmalloc (strlen (physname) + 1);
702 strcpy (mangled_name, physname);
703 return mangled_name;
704 }
705
706 if (len == 0)
707 {
708 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
709 }
710 else if (physname[0] == 't' || physname[0] == 'Q')
711 {
712 /* The physname for template and qualified methods already includes
713 the class name. */
714 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
715 newname = NULL;
716 len = 0;
717 }
718 else
719 {
720 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
721 volatile_prefix, len);
722 }
723 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
724 + strlen (buf) + len + strlen (physname) + 1);
725
726 mangled_name = (char *) xmalloc (mangled_name_len);
727 if (is_constructor)
728 mangled_name[0] = '\0';
729 else
730 strcpy (mangled_name, field_name);
731
732 strcat (mangled_name, buf);
733 /* If the class doesn't have a name, i.e. newname NULL, then we just
734 mangle it using 0 for the length of the class. Thus it gets mangled
735 as something starting with `::' rather than `classname::'. */
736 if (newname != NULL)
737 strcat (mangled_name, newname);
738
739 strcat (mangled_name, physname);
740 return (mangled_name);
741}
742
743/* See symtab.h. */
744
745void
747 struct obstack *obstack)
748{
749 if (language () == language_ada)
750 {
751 if (name == NULL)
752 {
753 ada_mangled = 0;
754 language_specific.obstack = obstack;
755 }
756 else
757 {
758 ada_mangled = 1;
759 language_specific.demangled_name = name;
760 }
761 }
762 else
763 language_specific.demangled_name = name;
764}
765
766
767/* Initialize the language dependent portion of a symbol
768 depending upon the language for the symbol. */
769
770void
772 struct obstack *obstack)
773{
776 || language == language_d
780 {
782 }
783 else if (language == language_ada)
784 {
785 gdb_assert (ada_mangled == 0);
786 language_specific.obstack = obstack;
787 }
788 else
789 {
790 memset (&language_specific, 0, sizeof (language_specific));
791 }
792}
793
794/* Functions to initialize a symbol's mangled name. */
795
796/* Objects of this type are stored in the demangled name hash table. */
798{
799 demangled_name_entry (gdb::string_view mangled_name)
800 : mangled (mangled_name) {}
801
802 gdb::string_view mangled;
804 gdb::unique_xmalloc_ptr<char> demangled;
805};
806
807/* Hash function for the demangled name hash. */
808
809static hashval_t
811{
812 const struct demangled_name_entry *e
813 = (const struct demangled_name_entry *) data;
814
815 return fast_hash (e->mangled.data (), e->mangled.length ());
816}
817
818/* Equality function for the demangled name hash. */
819
820static int
821eq_demangled_name_entry (const void *a, const void *b)
822{
823 const struct demangled_name_entry *da
824 = (const struct demangled_name_entry *) a;
825 const struct demangled_name_entry *db
826 = (const struct demangled_name_entry *) b;
827
828 return da->mangled == db->mangled;
829}
830
831static void
833{
834 struct demangled_name_entry *e
835 = (struct demangled_name_entry *) data;
836
837 e->~demangled_name_entry();
838}
839
840/* Create the hash table used for demangled names. Each hash entry is
841 a pair of strings; one for the mangled name and one for the demangled
842 name. The entry is hashed via just the mangled name. */
843
844static void
846{
847 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
848 The hash table code will round this up to the next prime number.
849 Choosing a much larger table size wastes memory, and saves only about
850 1% in symbol reading. However, if the minsym count is already
851 initialized (e.g. because symbol name setting was deferred to
852 a background thread) we can initialize the hashtable with a count
853 based on that, because we will almost certainly have at least that
854 many entries. If we have a nonzero number but less than 256,
855 we still stay with 256 to have some space for psymbols, etc. */
856
857 /* htab will expand the table when it is 3/4th full, so we account for that
858 here. +2 to round up. */
859 int minsym_based_count = (per_bfd->minimal_symbol_count + 2) / 3 * 4;
860 int count = std::max (per_bfd->minimal_symbol_count, minsym_based_count);
861
862 per_bfd->demangled_names_hash.reset (htab_create_alloc
865}
866
867/* See symtab.h */
868
869gdb::unique_xmalloc_ptr<char>
871 const char *mangled)
872{
873 gdb::unique_xmalloc_ptr<char> demangled;
874 int i;
875
876 if (gsymbol->language () == language_unknown)
877 gsymbol->m_language = language_auto;
878
879 if (gsymbol->language () != language_auto)
880 {
881 const struct language_defn *lang = language_def (gsymbol->language ());
882
883 lang->sniff_from_mangled_name (mangled, &demangled);
884 return demangled;
885 }
886
887 for (i = language_unknown; i < nr_languages; ++i)
888 {
889 enum language l = (enum language) i;
890 const struct language_defn *lang = language_def (l);
891
892 if (lang->sniff_from_mangled_name (mangled, &demangled))
893 {
894 gsymbol->m_language = l;
895 return demangled;
896 }
897 }
898
899 return NULL;
900}
901
902/* Set both the mangled and demangled (if any) names for GSYMBOL based
903 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
904 objfile's obstack; but if COPY_NAME is 0 and if NAME is
905 NUL-terminated, then this function assumes that NAME is already
906 correctly saved (either permanently or with a lifetime tied to the
907 objfile), and it will not be copied.
908
909 The hash table corresponding to OBJFILE is used, and the memory
910 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
911 so the pointer can be discarded after calling this function. */
912
913void
914general_symbol_info::compute_and_set_names (gdb::string_view linkage_name,
915 bool copy_name,
917 gdb::optional<hashval_t> hash)
918{
919 struct demangled_name_entry **slot;
920
921 if (language () == language_ada)
922 {
923 /* In Ada, we do the symbol lookups using the mangled name, so
924 we can save some space by not storing the demangled name. */
925 if (!copy_name)
926 m_name = linkage_name.data ();
927 else
928 m_name = obstack_strndup (&per_bfd->storage_obstack,
929 linkage_name.data (),
930 linkage_name.length ());
931 set_demangled_name (NULL, &per_bfd->storage_obstack);
932
933 return;
934 }
935
936 if (per_bfd->demangled_names_hash == NULL)
938
939 struct demangled_name_entry entry (linkage_name);
940 if (!hash.has_value ())
941 hash = hash_demangled_name_entry (&entry);
942 slot = ((struct demangled_name_entry **)
943 htab_find_slot_with_hash (per_bfd->demangled_names_hash.get (),
944 &entry, *hash, INSERT));
945
946 /* The const_cast is safe because the only reason it is already
947 initialized is if we purposefully set it from a background
948 thread to avoid doing the work here. However, it is still
949 allocated from the heap and needs to be freed by us, just
950 like if we called symbol_find_demangled_name here. If this is
951 nullptr, we call symbol_find_demangled_name below, but we put
952 this smart pointer here to be sure that we don't leak this name. */
953 gdb::unique_xmalloc_ptr<char> demangled_name
954 (const_cast<char *> (language_specific.demangled_name));
955
956 /* If this name is not in the hash table, add it. */
957 if (*slot == NULL
958 /* A C version of the symbol may have already snuck into the table.
959 This happens to, e.g., main.init (__go_init_main). Cope. */
960 || (language () == language_go && (*slot)->demangled == nullptr))
961 {
962 /* A 0-terminated copy of the linkage name. Callers must set COPY_NAME
963 to true if the string might not be nullterminated. We have to make
964 this copy because demangling needs a nullterminated string. */
965 gdb::string_view linkage_name_copy;
966 if (copy_name)
967 {
968 char *alloc_name = (char *) alloca (linkage_name.length () + 1);
969 memcpy (alloc_name, linkage_name.data (), linkage_name.length ());
970 alloc_name[linkage_name.length ()] = '\0';
971
972 linkage_name_copy = gdb::string_view (alloc_name,
973 linkage_name.length ());
974 }
975 else
976 linkage_name_copy = linkage_name;
977
978 if (demangled_name.get () == nullptr)
980 = symbol_find_demangled_name (this, linkage_name_copy.data ());
981
982 /* Suppose we have demangled_name==NULL, copy_name==0, and
983 linkage_name_copy==linkage_name. In this case, we already have the
984 mangled name saved, and we don't have a demangled name. So,
985 you might think we could save a little space by not recording
986 this in the hash table at all.
987
988 It turns out that it is actually important to still save such
989 an entry in the hash table, because storing this name gives
990 us better bcache hit rates for partial symbols. */
991 if (!copy_name)
992 {
993 *slot
994 = ((struct demangled_name_entry *)
995 obstack_alloc (&per_bfd->storage_obstack,
996 sizeof (demangled_name_entry)));
998 }
999 else
1000 {
1001 /* If we must copy the mangled name, put it directly after
1002 the struct so we can have a single allocation. */
1003 *slot
1004 = ((struct demangled_name_entry *)
1005 obstack_alloc (&per_bfd->storage_obstack,
1006 sizeof (demangled_name_entry)
1007 + linkage_name.length () + 1));
1008 char *mangled_ptr = reinterpret_cast<char *> (*slot + 1);
1009 memcpy (mangled_ptr, linkage_name.data (), linkage_name.length ());
1010 mangled_ptr [linkage_name.length ()] = '\0';
1011 new (*slot) demangled_name_entry
1012 (gdb::string_view (mangled_ptr, linkage_name.length ()));
1013 }
1014 (*slot)->demangled = std::move (demangled_name);
1015 (*slot)->language = language ();
1016 }
1017 else if (language () == language_unknown || language () == language_auto)
1018 m_language = (*slot)->language;
1019
1020 m_name = (*slot)->mangled.data ();
1021 set_demangled_name ((*slot)->demangled.get (), &per_bfd->storage_obstack);
1022}
1023
1024/* See symtab.h. */
1025
1026const char *
1028{
1029 switch (language ())
1030 {
1031 case language_cplus:
1032 case language_d:
1033 case language_go:
1034 case language_objc:
1035 case language_fortran:
1036 case language_rust:
1037 if (language_specific.demangled_name != nullptr)
1038 return language_specific.demangled_name;
1039 break;
1040 case language_ada:
1041 return ada_decode_symbol (this);
1042 default:
1043 break;
1044 }
1045 return linkage_name ();
1046}
1047
1048/* See symtab.h. */
1049
1050const char *
1052{
1053 const char *dem_name = NULL;
1054
1055 switch (language ())
1056 {
1057 case language_cplus:
1058 case language_d:
1059 case language_go:
1060 case language_objc:
1061 case language_fortran:
1062 case language_rust:
1063 dem_name = language_specific.demangled_name;
1064 break;
1065 case language_ada:
1066 dem_name = ada_decode_symbol (this);
1067 break;
1068 default:
1069 break;
1070 }
1071 return dem_name;
1072}
1073
1074/* See symtab.h. */
1075
1076const char *
1078{
1079 if (language () == language_ada)
1080 return linkage_name ();
1081 else
1082 return natural_name ();
1083}
1084
1085/* See symtab.h. */
1086
1087struct obj_section *
1089{
1090 if (section_index () >= 0)
1091 return &objfile->sections[section_index ()];
1092 return nullptr;
1093}
1094
1095/* See symtab.h. */
1096
1097bool
1099 const lookup_name_info &name)
1100{
1101 symbol_name_matcher_ftype *name_match
1103 return name_match (gsymbol->search_name (), name, NULL);
1104}
1105
1106
1107
1108/* Return true if the two sections are the same, or if they could
1109 plausibly be copies of each other, one in an original object
1110 file and another in a separated debug file. */
1111
1112bool
1114 struct obj_section *obj_second)
1115{
1116 asection *first = obj_first? obj_first->the_bfd_section : NULL;
1117 asection *second = obj_second? obj_second->the_bfd_section : NULL;
1118
1119 /* If they're the same section, then they match. */
1120 if (first == second)
1121 return true;
1122
1123 /* If either is NULL, give up. */
1124 if (first == NULL || second == NULL)
1125 return false;
1126
1127 /* This doesn't apply to absolute symbols. */
1128 if (first->owner == NULL || second->owner == NULL)
1129 return false;
1130
1131 /* If they're in the same object file, they must be different sections. */
1132 if (first->owner == second->owner)
1133 return false;
1134
1135 /* Check whether the two sections are potentially corresponding. They must
1136 have the same size, address, and name. We can't compare section indexes,
1137 which would be more reliable, because some sections may have been
1138 stripped. */
1139 if (bfd_section_size (first) != bfd_section_size (second))
1140 return false;
1141
1142 /* In-memory addresses may start at a different offset, relativize them. */
1143 if (bfd_section_vma (first) - bfd_get_start_address (first->owner)
1144 != bfd_section_vma (second) - bfd_get_start_address (second->owner))
1145 return false;
1146
1147 if (bfd_section_name (first) == NULL
1148 || bfd_section_name (second) == NULL
1149 || strcmp (bfd_section_name (first), bfd_section_name (second)) != 0)
1150 return false;
1151
1152 /* Otherwise check that they are in corresponding objfiles. */
1153
1154 struct objfile *obj = NULL;
1156 if (objfile->obfd == first->owner)
1157 {
1158 obj = objfile;
1159 break;
1160 }
1161 gdb_assert (obj != NULL);
1162
1163 if (obj->separate_debug_objfile != NULL
1164 && obj->separate_debug_objfile->obfd == second->owner)
1165 return true;
1166 if (obj->separate_debug_objfile_backlink != NULL
1167 && obj->separate_debug_objfile_backlink->obfd == second->owner)
1168 return true;
1169
1170 return false;
1171}
1172
1173/* See symtab.h. */
1174
1175void
1176expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
1177{
1178 struct bound_minimal_symbol msymbol;
1179
1180 /* If we know that this is not a text address, return failure. This is
1181 necessary because we loop based on texthigh and textlow, which do
1182 not include the data ranges. */
1183 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1184 if (msymbol.minsym && msymbol.minsym->data_p ())
1185 return;
1186
1188 {
1189 struct compunit_symtab *cust
1190 = objfile->find_pc_sect_compunit_symtab (msymbol, pc, section, 0);
1191 if (cust)
1192 return;
1193 }
1194}
1195
1196/* Hash function for the symbol cache. */
1197
1198static unsigned int
1199hash_symbol_entry (const struct objfile *objfile_context,
1200 const char *name, domain_enum domain)
1201{
1202 unsigned int hash = (uintptr_t) objfile_context;
1203
1204 if (name != NULL)
1205 hash += htab_hash_string (name);
1206
1207 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1208 to map to the same slot. */
1209 if (domain == STRUCT_DOMAIN)
1210 hash += VAR_DOMAIN * 7;
1211 else
1212 hash += domain * 7;
1213
1214 return hash;
1215}
1216
1217/* Equality function for the symbol cache. */
1218
1219static int
1221 const struct objfile *objfile_context,
1222 const char *name, domain_enum domain)
1223{
1224 const char *slot_name;
1225 domain_enum slot_domain;
1226
1227 if (slot->state == SYMBOL_SLOT_UNUSED)
1228 return 0;
1229
1230 if (slot->objfile_context != objfile_context)
1231 return 0;
1232
1233 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1234 {
1235 slot_name = slot->value.not_found.name;
1236 slot_domain = slot->value.not_found.domain;
1237 }
1238 else
1239 {
1240 slot_name = slot->value.found.symbol->search_name ();
1241 slot_domain = slot->value.found.symbol->domain ();
1242 }
1243
1244 /* NULL names match. */
1245 if (slot_name == NULL && name == NULL)
1246 {
1247 /* But there's no point in calling symbol_matches_domain in the
1248 SYMBOL_SLOT_FOUND case. */
1249 if (slot_domain != domain)
1250 return 0;
1251 }
1252 else if (slot_name != NULL && name != NULL)
1253 {
1254 /* It's important that we use the same comparison that was done
1255 the first time through. If the slot records a found symbol,
1256 then this means using the symbol name comparison function of
1257 the symbol's language with symbol->search_name (). See
1258 dictionary.c. It also means using symbol_matches_domain for
1259 found symbols. See block.c.
1260
1261 If the slot records a not-found symbol, then require a precise match.
1262 We could still be lax with whitespace like strcmp_iw though. */
1263
1264 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1265 {
1266 if (strcmp (slot_name, name) != 0)
1267 return 0;
1268 if (slot_domain != domain)
1269 return 0;
1270 }
1271 else
1272 {
1273 struct symbol *sym = slot->value.found.symbol;
1275
1276 if (!symbol_matches_search_name (sym, lookup_name))
1277 return 0;
1278
1279 if (!symbol_matches_domain (sym->language (), slot_domain, domain))
1280 return 0;
1281 }
1282 }
1283 else
1284 {
1285 /* Only one name is NULL. */
1286 return 0;
1287 }
1288
1289 return 1;
1290}
1291
1292/* Given a cache of size SIZE, return the size of the struct (with variable
1293 length array) in bytes. */
1294
1295static size_t
1297{
1298 return (sizeof (struct block_symbol_cache)
1299 + ((size - 1) * sizeof (struct symbol_cache_slot)));
1300}
1301
1302/* Resize CACHE. */
1303
1304static void
1305resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size)
1306{
1307 /* If there's no change in size, don't do anything.
1308 All caches have the same size, so we can just compare with the size
1309 of the global symbols cache. */
1310 if ((cache->global_symbols != NULL
1311 && cache->global_symbols->size == new_size)
1312 || (cache->global_symbols == NULL
1313 && new_size == 0))
1314 return;
1315
1318
1319 if (new_size == 0)
1320 {
1321 cache->global_symbols = NULL;
1322 cache->static_symbols = NULL;
1323 }
1324 else
1325 {
1326 size_t total_size = symbol_cache_byte_size (new_size);
1327
1328 cache->global_symbols
1329 = (struct block_symbol_cache *) xcalloc (1, total_size);
1330 cache->static_symbols
1331 = (struct block_symbol_cache *) xcalloc (1, total_size);
1332 cache->global_symbols->size = new_size;
1333 cache->static_symbols->size = new_size;
1334 }
1335}
1336
1337/* Return the symbol cache of PSPACE.
1338 Create one if it doesn't exist yet. */
1339
1340static struct symbol_cache *
1342{
1343 struct symbol_cache *cache = symbol_cache_key.get (pspace);
1344
1345 if (cache == NULL)
1346 {
1347 cache = symbol_cache_key.emplace (pspace);
1349 }
1350
1351 return cache;
1352}
1353
1354/* Set the size of the symbol cache in all program spaces. */
1355
1356static void
1357set_symbol_cache_size (unsigned int new_size)
1358{
1359 for (struct program_space *pspace : program_spaces)
1360 {
1361 struct symbol_cache *cache = symbol_cache_key.get (pspace);
1362
1363 /* The pspace could have been created but not have a cache yet. */
1364 if (cache != NULL)
1365 resize_symbol_cache (cache, new_size);
1366 }
1367}
1368
1369/* Called when symbol-cache-size is set. */
1370
1371static void
1372set_symbol_cache_size_handler (const char *args, int from_tty,
1373 struct cmd_list_element *c)
1374{
1376 {
1377 /* Restore the previous value.
1378 This is the value the "show" command prints. */
1380
1381 error (_("Symbol cache size is too large, max is %u."),
1383 }
1385
1387}
1388
1389/* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1390 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1391 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1392 failed (and thus this one will too), or NULL if the symbol is not present
1393 in the cache.
1394 *BSC_PTR and *SLOT_PTR are set to the cache and slot of the symbol, which
1395 can be used to save the result of a full lookup attempt. */
1396
1397static struct block_symbol
1399 struct objfile *objfile_context, enum block_enum block,
1400 const char *name, domain_enum domain,
1401 struct block_symbol_cache **bsc_ptr,
1402 struct symbol_cache_slot **slot_ptr)
1403{
1404 struct block_symbol_cache *bsc;
1405 unsigned int hash;
1406 struct symbol_cache_slot *slot;
1407
1408 if (block == GLOBAL_BLOCK)
1409 bsc = cache->global_symbols;
1410 else
1411 bsc = cache->static_symbols;
1412 if (bsc == NULL)
1413 {
1414 *bsc_ptr = NULL;
1415 *slot_ptr = NULL;
1416 return {};
1417 }
1418
1420 slot = bsc->symbols + hash % bsc->size;
1421
1422 *bsc_ptr = bsc;
1423 *slot_ptr = slot;
1424
1426 {
1427 symbol_lookup_debug_printf ("%s block symbol cache hit%s for %s, %s",
1428 block == GLOBAL_BLOCK ? "Global" : "Static",
1430 ? " (not found)" : "", name,
1432 ++bsc->hits;
1433 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1434 return SYMBOL_LOOKUP_FAILED;
1435 return slot->value.found;
1436 }
1437
1438 /* Symbol is not present in the cache. */
1439
1440 symbol_lookup_debug_printf ("%s block symbol cache miss for %s, %s",
1441 block == GLOBAL_BLOCK ? "Global" : "Static",
1443 ++bsc->misses;
1444 return {};
1445}
1446
1447/* Mark SYMBOL as found in SLOT.
1448 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1449 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1450 necessarily the objfile the symbol was found in. */
1451
1452static void
1454 struct symbol_cache_slot *slot,
1455 struct objfile *objfile_context,
1456 struct symbol *symbol,
1457 const struct block *block)
1458{
1459 if (bsc == NULL)
1460 return;
1461 if (slot->state != SYMBOL_SLOT_UNUSED)
1462 {
1463 ++bsc->collisions;
1465 }
1466 slot->state = SYMBOL_SLOT_FOUND;
1468 slot->value.found.symbol = symbol;
1469 slot->value.found.block = block;
1470}
1471
1472/* Mark symbol NAME, DOMAIN as not found in SLOT.
1473 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1474 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1475
1476static void
1478 struct symbol_cache_slot *slot,
1479 struct objfile *objfile_context,
1480 const char *name, domain_enum domain)
1481{
1482 if (bsc == NULL)
1483 return;
1484 if (slot->state != SYMBOL_SLOT_UNUSED)
1485 {
1486 ++bsc->collisions;
1488 }
1491 slot->value.not_found.name = xstrdup (name);
1492 slot->value.not_found.domain = domain;
1493}
1494
1495/* Flush the symbol cache of PSPACE. */
1496
1497static void
1499{
1500 struct symbol_cache *cache = symbol_cache_key.get (pspace);
1501 int pass;
1502
1503 if (cache == NULL)
1504 return;
1505 if (cache->global_symbols == NULL)
1506 {
1507 gdb_assert (symbol_cache_size == 0);
1508 gdb_assert (cache->static_symbols == NULL);
1509 return;
1510 }
1511
1512 /* If the cache is untouched since the last flush, early exit.
1513 This is important for performance during the startup of a program linked
1514 with 100s (or 1000s) of shared libraries. */
1515 if (cache->global_symbols->misses == 0
1516 && cache->static_symbols->misses == 0)
1517 return;
1518
1519 gdb_assert (cache->global_symbols->size == symbol_cache_size);
1520 gdb_assert (cache->static_symbols->size == symbol_cache_size);
1521
1522 for (pass = 0; pass < 2; ++pass)
1523 {
1524 struct block_symbol_cache *bsc
1525 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1526 unsigned int i;
1527
1528 for (i = 0; i < bsc->size; ++i)
1530 }
1531
1532 cache->global_symbols->hits = 0;
1533 cache->global_symbols->misses = 0;
1534 cache->global_symbols->collisions = 0;
1535 cache->static_symbols->hits = 0;
1536 cache->static_symbols->misses = 0;
1537 cache->static_symbols->collisions = 0;
1538}
1539
1540/* Dump CACHE. */
1541
1542static void
1543symbol_cache_dump (const struct symbol_cache *cache)
1544{
1545 int pass;
1546
1547 if (cache->global_symbols == NULL)
1548 {
1549 gdb_printf (" <disabled>\n");
1550 return;
1551 }
1552
1553 for (pass = 0; pass < 2; ++pass)
1554 {
1555 const struct block_symbol_cache *bsc
1556 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1557 unsigned int i;
1558
1559 if (pass == 0)
1560 gdb_printf ("Global symbols:\n");
1561 else
1562 gdb_printf ("Static symbols:\n");
1563
1564 for (i = 0; i < bsc->size; ++i)
1565 {
1566 const struct symbol_cache_slot *slot = &bsc->symbols[i];
1567
1568 QUIT;
1569
1570 switch (slot->state)
1571 {
1572 case SYMBOL_SLOT_UNUSED:
1573 break;
1575 gdb_printf (" [%4u] = %s, %s %s (not found)\n", i,
1576 host_address_to_string (slot->objfile_context),
1577 slot->value.not_found.name,
1579 break;
1580 case SYMBOL_SLOT_FOUND:
1581 {
1582 struct symbol *found = slot->value.found.symbol;
1583 const struct objfile *context = slot->objfile_context;
1584
1585 gdb_printf (" [%4u] = %s, %s %s\n", i,
1586 host_address_to_string (context),
1587 found->print_name (),
1588 domain_name (found->domain ()));
1589 break;
1590 }
1591 }
1592 }
1593 }
1594}
1595
1596/* The "mt print symbol-cache" command. */
1597
1598static void
1599maintenance_print_symbol_cache (const char *args, int from_tty)
1600{
1601 for (struct program_space *pspace : program_spaces)
1602 {
1603 struct symbol_cache *cache;
1604
1605 gdb_printf (_("Symbol cache for pspace %d\n%s:\n"),
1606 pspace->num,
1607 pspace->symfile_object_file != NULL
1608 ? objfile_name (pspace->symfile_object_file)
1609 : "(no object file)");
1610
1611 /* If the cache hasn't been created yet, avoid creating one. */
1612 cache = symbol_cache_key.get (pspace);
1613 if (cache == NULL)
1614 gdb_printf (" <empty>\n");
1615 else
1616 symbol_cache_dump (cache);
1617 }
1618}
1619
1620/* The "mt flush-symbol-cache" command. */
1621
1622static void
1623maintenance_flush_symbol_cache (const char *args, int from_tty)
1624{
1625 for (struct program_space *pspace : program_spaces)
1626 {
1627 symbol_cache_flush (pspace);
1628 }
1629}
1630
1631/* Print usage statistics of CACHE. */
1632
1633static void
1635{
1636 int pass;
1637
1638 if (cache->global_symbols == NULL)
1639 {
1640 gdb_printf (" <disabled>\n");
1641 return;
1642 }
1643
1644 for (pass = 0; pass < 2; ++pass)
1645 {
1646 const struct block_symbol_cache *bsc
1647 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1648
1649 QUIT;
1650
1651 if (pass == 0)
1652 gdb_printf ("Global block cache stats:\n");
1653 else
1654 gdb_printf ("Static block cache stats:\n");
1655
1656 gdb_printf (" size: %u\n", bsc->size);
1657 gdb_printf (" hits: %u\n", bsc->hits);
1658 gdb_printf (" misses: %u\n", bsc->misses);
1659 gdb_printf (" collisions: %u\n", bsc->collisions);
1660 }
1661}
1662
1663/* The "mt print symbol-cache-statistics" command. */
1664
1665static void
1666maintenance_print_symbol_cache_statistics (const char *args, int from_tty)
1667{
1668 for (struct program_space *pspace : program_spaces)
1669 {
1670 struct symbol_cache *cache;
1671
1672 gdb_printf (_("Symbol cache statistics for pspace %d\n%s:\n"),
1673 pspace->num,
1674 pspace->symfile_object_file != NULL
1675 ? objfile_name (pspace->symfile_object_file)
1676 : "(no object file)");
1677
1678 /* If the cache hasn't been created yet, avoid creating one. */
1679 cache = symbol_cache_key.get (pspace);
1680 if (cache == NULL)
1681 gdb_printf (" empty, no stats available\n");
1682 else
1683 symbol_cache_stats (cache);
1684 }
1685}
1686
1687/* This module's 'new_objfile' observer. */
1688
1689static void
1691{
1692 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1694}
1695
1696/* This module's 'free_objfile' observer. */
1697
1698static void
1700{
1702}
1703
1704/* Debug symbols usually don't have section information. We need to dig that
1705 out of the minimal symbols and stash that in the debug symbol. */
1706
1707void
1709 CORE_ADDR addr, struct objfile *objfile)
1710{
1711 struct minimal_symbol *msym;
1712
1713 /* First, check whether a minimal symbol with the same name exists
1714 and points to the same address. The address check is required
1715 e.g. on PowerPC64, where the minimal symbol for a function will
1716 point to the function descriptor, while the debug symbol will
1717 point to the actual function code. */
1718 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->linkage_name (),
1719 objfile);
1720 if (msym)
1721 ginfo->set_section_index (msym->section_index ());
1722 else
1723 {
1724 /* Static, function-local variables do appear in the linker
1725 (minimal) symbols, but are frequently given names that won't
1726 be found via lookup_minimal_symbol(). E.g., it has been
1727 observed in frv-uclinux (ELF) executables that a static,
1728 function-local variable named "foo" might appear in the
1729 linker symbols as "foo.6" or "foo.3". Thus, there is no
1730 point in attempting to extend the lookup-by-name mechanism to
1731 handle this case due to the fact that there can be multiple
1732 names.
1733
1734 So, instead, search the section table when lookup by name has
1735 failed. The ``addr'' and ``endaddr'' fields may have already
1736 been relocated. If so, the relocation offset needs to be
1737 subtracted from these values when performing the comparison.
1738 We unconditionally subtract it, because, when no relocation
1739 has been performed, the value will simply be zero.
1740
1741 The address of the symbol whose section we're fixing up HAS
1742 NOT BEEN adjusted (relocated) yet. It can't have been since
1743 the section isn't yet known and knowing the section is
1744 necessary in order to add the correct relocation value. In
1745 other words, we wouldn't even be in this function (attempting
1746 to compute the section) if it were already known.
1747
1748 Note that it is possible to search the minimal symbols
1749 (subtracting the relocation value if necessary) to find the
1750 matching minimal symbol, but this is overkill and much less
1751 efficient. It is not necessary to find the matching minimal
1752 symbol, only its section.
1753
1754 Note that this technique (of doing a section table search)
1755 can fail when unrelocated section addresses overlap. For
1756 this reason, we still attempt a lookup by name prior to doing
1757 a search of the section table. */
1758
1759 struct obj_section *s;
1760 int fallback = -1;
1761
1763 {
1764 int idx = s - objfile->sections;
1765 CORE_ADDR offset = objfile->section_offsets[idx];
1766
1767 if (fallback == -1)
1768 fallback = idx;
1769
1770 if (s->addr () - offset <= addr && addr < s->endaddr () - offset)
1771 {
1772 ginfo->set_section_index (idx);
1773 return;
1774 }
1775 }
1776
1777 /* If we didn't find the section, assume it is in the first
1778 section. If there is no allocated section, then it hardly
1779 matters what we pick, so just pick zero. */
1780 if (fallback == -1)
1781 ginfo->set_section_index (0);
1782 else
1783 ginfo->set_section_index (fallback);
1784 }
1785}
1786
1787struct symbol *
1789{
1790 CORE_ADDR addr;
1791
1792 if (!sym)
1793 return NULL;
1794
1795 if (!sym->is_objfile_owned ())
1796 return sym;
1797
1798 /* We either have an OBJFILE, or we can get at it from the sym's
1799 symtab. Anything else is a bug. */
1800 gdb_assert (objfile || sym->symtab ());
1801
1802 if (objfile == NULL)
1803 objfile = sym->objfile ();
1804
1805 if (sym->obj_section (objfile) != nullptr)
1806 return sym;
1807
1808 /* We should have an objfile by now. */
1809 gdb_assert (objfile);
1810
1811 switch (sym->aclass ())
1812 {
1813 case LOC_STATIC:
1814 case LOC_LABEL:
1815 addr = sym->value_address ();
1816 break;
1817 case LOC_BLOCK:
1818 addr = sym->value_block ()->entry_pc ();
1819 break;
1820
1821 default:
1822 /* Nothing else will be listed in the minsyms -- no use looking
1823 it up. */
1824 return sym;
1825 }
1826
1827 fixup_section (sym, addr, objfile);
1828
1829 return sym;
1830}
1831
1832/* See symtab.h. */
1833
1835 (const lookup_name_info &lookup_name, language lang)
1836{
1838
1839 if (lookup_name.ignore_parameters () && lang == language_cplus)
1840 {
1841 gdb::unique_xmalloc_ptr<char> without_params
1843 lookup_name.completion_mode ());
1844
1845 if (without_params != NULL)
1846 {
1847 if (lookup_name.match_type () != symbol_name_match_type::SEARCH_NAME)
1848 m_demangled_name = demangle_for_lookup (without_params.get (),
1849 lang, storage);
1850 return;
1851 }
1852 }
1853
1854 if (lookup_name.match_type () == symbol_name_match_type::SEARCH_NAME)
1855 m_demangled_name = lookup_name.c_str ();
1856 else
1858 lang, storage);
1859}
1860
1861/* See symtab.h. */
1862
1863const lookup_name_info &
1865{
1866 /* Lookup any symbol that "" would complete. I.e., this matches all
1867 symbol names. */
1868 static const lookup_name_info lookup_name ("", symbol_name_match_type::FULL,
1869 true);
1870
1871 return lookup_name;
1872}
1873
1874/* Compute the demangled form of NAME as used by the various symbol
1875 lookup functions. The result can either be the input NAME
1876 directly, or a pointer to a buffer owned by the STORAGE object.
1877
1878 For Ada, this function just returns NAME, unmodified.
1879 Normally, Ada symbol lookups are performed using the encoded name
1880 rather than the demangled name, and so it might seem to make sense
1881 for this function to return an encoded version of NAME.
1882 Unfortunately, we cannot do this, because this function is used in
1883 circumstances where it is not appropriate to try to encode NAME.
1884 For instance, when displaying the frame info, we demangle the name
1885 of each parameter, and then perform a symbol lookup inside our
1886 function using that demangled name. In Ada, certain functions
1887 have internally-generated parameters whose name contain uppercase
1888 characters. Encoding those name would result in those uppercase
1889 characters to become lowercase, and thus cause the symbol lookup
1890 to fail. */
1891
1892const char *
1893demangle_for_lookup (const char *name, enum language lang,
1894 demangle_result_storage &storage)
1895{
1896 /* If we are using C++, D, or Go, demangle the name before doing a
1897 lookup, so we can always binary search. */
1898 if (lang == language_cplus)
1899 {
1900 gdb::unique_xmalloc_ptr<char> demangled_name
1901 = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1902 if (demangled_name != NULL)
1903 return storage.set_malloc_ptr (std::move (demangled_name));
1904
1905 /* If we were given a non-mangled name, canonicalize it
1906 according to the language (so far only for C++). */
1907 gdb::unique_xmalloc_ptr<char> canon = cp_canonicalize_string (name);
1908 if (canon != nullptr)
1909 return storage.set_malloc_ptr (std::move (canon));
1910 }
1911 else if (lang == language_d)
1912 {
1913 gdb::unique_xmalloc_ptr<char> demangled_name = d_demangle (name, 0);
1914 if (demangled_name != NULL)
1915 return storage.set_malloc_ptr (std::move (demangled_name));
1916 }
1917 else if (lang == language_go)
1918 {
1919 gdb::unique_xmalloc_ptr<char> demangled_name
1921 if (demangled_name != NULL)
1922 return storage.set_malloc_ptr (std::move (demangled_name));
1923 }
1924
1925 return name;
1926}
1927
1928/* See symtab.h. */
1929
1930unsigned int
1932{
1934}
1935
1936/* See symtab.h.
1937
1938 This function (or rather its subordinates) have a bunch of loops and
1939 it would seem to be attractive to put in some QUIT's (though I'm not really
1940 sure whether it can run long enough to be really important). But there
1941 are a few calls for which it would appear to be bad news to quit
1942 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1943 that there is C++ code below which can error(), but that probably
1944 doesn't affect these calls since they are looking for a known
1945 variable and thus can probably assume it will never hit the C++
1946 code). */
1947
1948struct block_symbol
1949lookup_symbol_in_language (const char *name, const struct block *block,
1950 const domain_enum domain, enum language lang,
1951 struct field_of_this_result *is_a_field_of_this)
1952{
1954
1956 const char *modified_name = demangle_for_lookup (name, lang, storage);
1957
1958 return lookup_symbol_aux (modified_name,
1960 block, domain, lang,
1961 is_a_field_of_this);
1962}
1963
1964/* See symtab.h. */
1965
1966struct block_symbol
1967lookup_symbol (const char *name, const struct block *block,
1968 domain_enum domain,
1969 struct field_of_this_result *is_a_field_of_this)
1970{
1971 return lookup_symbol_in_language (name, block, domain,
1973 is_a_field_of_this);
1974}
1975
1976/* See symtab.h. */
1977
1978struct block_symbol
1979lookup_symbol_search_name (const char *search_name, const struct block *block,
1980 domain_enum domain)
1981{
1983 block, domain, language_asm, NULL);
1984}
1985
1986/* See symtab.h. */
1987
1988struct block_symbol
1990 const struct block *block)
1991{
1992 if (lang->name_of_this () == NULL || block == NULL)
1993 return {};
1994
1995 symbol_lookup_debug_printf_v ("lookup_language_this (%s, %s (objfile %s))",
1996 lang->name (), host_address_to_string (block),
1998
1999 while (block)
2000 {
2001 struct symbol *sym;
2002
2003 sym = block_lookup_symbol (block, lang->name_of_this (),
2005 VAR_DOMAIN);
2006 if (sym != NULL)
2007 {
2009 ("lookup_language_this (...) = %s (%s, block %s)",
2010 sym->print_name (), host_address_to_string (sym),
2011 host_address_to_string (block));
2012 return (struct block_symbol) {sym, block};
2013 }
2014 if (block->function ())
2015 break;
2016 block = block->superblock ();
2017 }
2018
2019 symbol_lookup_debug_printf_v ("lookup_language_this (...) = NULL");
2020 return {};
2021}
2022
2023/* Given TYPE, a structure/union,
2024 return 1 if the component named NAME from the ultimate target
2025 structure/union is defined, otherwise, return 0. */
2026
2027static int
2028check_field (struct type *type, const char *name,
2029 struct field_of_this_result *is_a_field_of_this)
2030{
2031 int i;
2032
2033 /* The type may be a stub. */
2035
2036 for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--)
2037 {
2038 const char *t_field_name = type->field (i).name ();
2039
2040 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2041 {
2042 is_a_field_of_this->type = type;
2043 is_a_field_of_this->field = &type->field (i);
2044 return 1;
2045 }
2046 }
2047
2048 /* C++: If it was not found as a data field, then try to return it
2049 as a pointer to a method. */
2050
2051 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2052 {
2053 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2054 {
2055 is_a_field_of_this->type = type;
2056 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
2057 return 1;
2058 }
2059 }
2060
2061 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2062 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
2063 return 1;
2064
2065 return 0;
2066}
2067
2068/* Behave like lookup_symbol except that NAME is the natural name
2069 (e.g., demangled name) of the symbol that we're looking for. */
2070
2071static struct block_symbol
2073 const struct block *block,
2074 const domain_enum domain, enum language language,
2075 struct field_of_this_result *is_a_field_of_this)
2076{
2078
2079 struct block_symbol result;
2080 const struct language_defn *langdef;
2081
2083 {
2084 struct objfile *objfile = (block == nullptr
2085 ? nullptr : block_objfile (block));
2086
2088 ("demangled symbol name = \"%s\", block @ %s (objfile %s)",
2089 name, host_address_to_string (block),
2090 objfile != NULL ? objfile_debug_name (objfile) : "NULL");
2092 ("domain name = \"%s\", language = \"%s\")",
2093 domain_name (domain), language_str (language));
2094 }
2095
2096 /* Make sure we do something sensible with is_a_field_of_this, since
2097 the callers that set this parameter to some non-null value will
2098 certainly use it later. If we don't set it, the contents of
2099 is_a_field_of_this are undefined. */
2100 if (is_a_field_of_this != NULL)
2101 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
2102
2103 /* Search specified block and its superiors. Don't search
2104 STATIC_BLOCK or GLOBAL_BLOCK. */
2105
2106 result = lookup_local_symbol (name, match_type, block, domain, language);
2107 if (result.symbol != NULL)
2108 {
2110 ("found symbol @ %s (using lookup_local_symbol)",
2111 host_address_to_string (result.symbol));
2112 return result;
2113 }
2114
2115 /* If requested to do so by the caller and if appropriate for LANGUAGE,
2116 check to see if NAME is a field of `this'. */
2117
2118 langdef = language_def (language);
2119
2120 /* Don't do this check if we are searching for a struct. It will
2121 not be found by check_field, but will be found by other
2122 means. */
2123 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
2124 {
2125 result = lookup_language_this (langdef, block);
2126
2127 if (result.symbol)
2128 {
2129 struct type *t = result.symbol->type ();
2130
2131 /* I'm not really sure that type of this can ever
2132 be typedefed; just be safe. */
2133 t = check_typedef (t);
2134 if (t->is_pointer_or_reference ())
2135 t = t->target_type ();
2136
2137 if (t->code () != TYPE_CODE_STRUCT
2138 && t->code () != TYPE_CODE_UNION)
2139 error (_("Internal error: `%s' is not an aggregate"),
2140 langdef->name_of_this ());
2141
2142 if (check_field (t, name, is_a_field_of_this))
2143 {
2144 symbol_lookup_debug_printf ("no symbol found");
2145 return {};
2146 }
2147 }
2148 }
2149
2150 /* Now do whatever is appropriate for LANGUAGE to look
2151 up static and global variables. */
2152
2153 result = langdef->lookup_symbol_nonlocal (name, block, domain);
2154 if (result.symbol != NULL)
2155 {
2157 ("found symbol @ %s (using language lookup_symbol_nonlocal)",
2158 host_address_to_string (result.symbol));
2159 return result;
2160 }
2161
2162 /* Now search all static file-level symbols. Not strictly correct,
2163 but more useful than an error. */
2164
2165 result = lookup_static_symbol (name, domain);
2167 ("found symbol @ %s (using lookup_static_symbol)",
2168 result.symbol != NULL ? host_address_to_string (result.symbol) : "NULL");
2169 return result;
2170}
2171
2172/* Check to see if the symbol is defined in BLOCK or its superiors.
2173 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2174
2175static struct block_symbol
2177 symbol_name_match_type match_type,
2178 const struct block *block,
2179 const domain_enum domain,
2180 enum language language)
2181{
2182 struct symbol *sym;
2183 const struct block *static_block = block_static_block (block);
2184 const char *scope = block_scope (block);
2185
2186 /* Check if either no block is specified or it's a global block. */
2187
2188 if (static_block == NULL)
2189 return {};
2190
2191 while (block != static_block)
2192 {
2193 sym = lookup_symbol_in_block (name, match_type, block, domain);
2194 if (sym != NULL)
2195 return (struct block_symbol) {sym, block};
2196
2198 {
2199 struct block_symbol blocksym
2201 domain);
2202
2203 if (blocksym.symbol != NULL)
2204 return blocksym;
2205 }
2206
2207 if (block->function () != NULL && block_inlined_p (block))
2208 break;
2209 block = block->superblock ();
2210 }
2211
2212 /* We've reached the end of the function without finding a result. */
2213
2214 return {};
2215}
2216
2217/* See symtab.h. */
2218
2219struct symbol *
2221 const struct block *block,
2222 const domain_enum domain)
2223{
2224 struct symbol *sym;
2225
2227 {
2228 struct objfile *objfile
2229 = block == nullptr ? nullptr : block_objfile (block);
2230
2232 ("lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2233 name, host_address_to_string (block),
2234 objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
2235 domain_name (domain));
2236 }
2237
2238 sym = block_lookup_symbol (block, name, match_type, domain);
2239 if (sym)
2240 {
2241 symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = %s",
2242 host_address_to_string (sym));
2243 return fixup_symbol_section (sym, NULL);
2244 }
2245
2246 symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = NULL");
2247 return NULL;
2248}
2249
2250/* See symtab.h. */
2251
2252struct block_symbol
2254 enum block_enum block_index,
2255 const char *name,
2256 const domain_enum domain)
2257{
2258 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2259
2260 for (objfile *objfile : main_objfile->separate_debug_objfiles ())
2261 {
2262 struct block_symbol result
2263 = lookup_symbol_in_objfile (objfile, block_index, name, domain);
2264
2265 if (result.symbol != nullptr)
2266 return result;
2267 }
2268
2269 return {};
2270}
2271
2272/* Check to see if the symbol is defined in one of the OBJFILE's
2273 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2274 depending on whether or not we want to search global symbols or
2275 static symbols. */
2276
2277static struct block_symbol
2279 enum block_enum block_index, const char *name,
2280 const domain_enum domain)
2281{
2282 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2283
2285 ("lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2287 block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2288 name, domain_name (domain));
2289
2290 struct block_symbol other;
2291 other.symbol = NULL;
2292 for (compunit_symtab *cust : objfile->compunits ())
2293 {
2294 const struct blockvector *bv;
2295 const struct block *block;
2296 struct block_symbol result;
2297
2298 bv = cust->blockvector ();
2299 block = bv->block (block_index);
2300 result.symbol = block_lookup_symbol_primary (block, name, domain);
2301 result.block = block;
2302 if (result.symbol == NULL)
2303 continue;
2304 if (best_symbol (result.symbol, domain))
2305 {
2306 other = result;
2307 break;
2308 }
2309 if (symbol_matches_domain (result.symbol->language (),
2310 result.symbol->domain (), domain))
2311 {
2312 struct symbol *better
2313 = better_symbol (other.symbol, result.symbol, domain);
2314 if (better != other.symbol)
2315 {
2316 other.symbol = better;
2317 other.block = block;
2318 }
2319 }
2320 }
2321
2322 if (other.symbol != NULL)
2323 {
2325 ("lookup_symbol_in_objfile_symtabs (...) = %s (block %s)",
2326 host_address_to_string (other.symbol),
2327 host_address_to_string (other.block));
2328 other.symbol = fixup_symbol_section (other.symbol, objfile);
2329 return other;
2330 }
2331
2333 ("lookup_symbol_in_objfile_symtabs (...) = NULL");
2334 return {};
2335}
2336
2337/* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2338 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2339 and all associated separate debug objfiles.
2340
2341 Normally we only look in OBJFILE, and not any separate debug objfiles
2342 because the outer loop will cause them to be searched too. This case is
2343 different. Here we're called from search_symbols where it will only
2344 call us for the objfile that contains a matching minsym. */
2345
2346static struct block_symbol
2348 const char *linkage_name,
2349 domain_enum domain)
2350{
2352 struct objfile *main_objfile;
2353
2355 const char *modified_name = demangle_for_lookup (linkage_name, lang, storage);
2356
2359 else
2360 main_objfile = objfile;
2361
2362 for (::objfile *cur_objfile : main_objfile->separate_debug_objfiles ())
2363 {
2364 struct block_symbol result;
2365
2366 result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
2367 modified_name, domain);
2368 if (result.symbol == NULL)
2369 result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
2370 modified_name, domain);
2371 if (result.symbol != NULL)
2372 return result;
2373 }
2374
2375 return {};
2376}
2377
2378/* A helper function that throws an exception when a symbol was found
2379 in a psymtab but not in a symtab. */
2380
2381static void ATTRIBUTE_NORETURN
2382error_in_psymtab_expansion (enum block_enum block_index, const char *name,
2383 struct compunit_symtab *cust)
2384{
2385 error (_("\
2386Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2387%s may be an inlined function, or may be a template function\n \
2388(if a template, try specifying an instantiation: %s<type>)."),
2389 block_index == GLOBAL_BLOCK ? "global" : "static",
2390 name,
2392 name, name);
2393}
2394
2395/* A helper function for various lookup routines that interfaces with
2396 the "quick" symbol table functions. */
2397
2398static struct block_symbol
2400 enum block_enum block_index, const char *name,
2401 const domain_enum domain)
2402{
2403 struct compunit_symtab *cust;
2404 const struct blockvector *bv;
2405 const struct block *block;
2406 struct block_symbol result;
2407
2409 ("lookup_symbol_via_quick_fns (%s, %s, %s, %s)",
2411 block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2412 name, domain_name (domain));
2413
2414 cust = objfile->lookup_symbol (block_index, name, domain);
2415 if (cust == NULL)
2416 {
2418 ("lookup_symbol_via_quick_fns (...) = NULL");
2419 return {};
2420 }
2421
2422 bv = cust->blockvector ();
2423 block = bv->block (block_index);
2426 if (result.symbol == NULL)
2427 error_in_psymtab_expansion (block_index, name, cust);
2428
2430 ("lookup_symbol_via_quick_fns (...) = %s (block %s)",
2431 host_address_to_string (result.symbol),
2432 host_address_to_string (block));
2433
2434 result.symbol = fixup_symbol_section (result.symbol, objfile);
2435 result.block = block;
2436 return result;
2437}
2438
2439/* See language.h. */
2440
2441struct block_symbol
2442language_defn::lookup_symbol_nonlocal (const char *name,
2443 const struct block *block,
2444 const domain_enum domain) const
2445{
2446 struct block_symbol result;
2447
2448 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2449 the current objfile. Searching the current objfile first is useful
2450 for both matching user expectations as well as performance. */
2451
2452 result = lookup_symbol_in_static_block (name, block, domain);
2453 if (result.symbol != NULL)
2454 return result;
2455
2456 /* If we didn't find a definition for a builtin type in the static block,
2457 search for it now. This is actually the right thing to do and can be
2458 a massive performance win. E.g., when debugging a program with lots of
2459 shared libraries we could search all of them only to find out the
2460 builtin type isn't defined in any of them. This is common for types
2461 like "void". */
2462 if (domain == VAR_DOMAIN)
2463 {
2464 struct gdbarch *gdbarch;
2465
2466 if (block == NULL)
2468 else
2471 gdbarch, name);
2472 result.block = NULL;
2473 if (result.symbol != NULL)
2474 return result;
2475 }
2476
2477 return lookup_global_symbol (name, block, domain);
2478}
2479
2480/* See symtab.h. */
2481
2482struct block_symbol
2484 const struct block *block,
2485 const domain_enum domain)
2486{
2487 const struct block *static_block = block_static_block (block);
2488 struct symbol *sym;
2489
2490 if (static_block == NULL)
2491 return {};
2492
2494 {
2495 struct objfile *objfile = (block == nullptr
2496 ? nullptr : block_objfile (block));
2497
2499 ("lookup_symbol_in_static_block (%s, %s (objfile %s), %s)",
2500 name, host_address_to_string (block),
2501 objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
2502 domain_name (domain));
2503 }
2504
2507 static_block, domain);
2508 symbol_lookup_debug_printf ("lookup_symbol_in_static_block (...) = %s",
2509 sym != NULL
2510 ? host_address_to_string (sym) : "NULL");
2511 return (struct block_symbol) {sym, static_block};
2512}
2513
2514/* Perform the standard symbol lookup of NAME in OBJFILE:
2515 1) First search expanded symtabs, and if not found
2516 2) Search the "quick" symtabs (partial or .gdb_index).
2517 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2518
2519static struct block_symbol
2521 const char *name, const domain_enum domain)
2522{
2523 struct block_symbol result;
2524
2525 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2526
2527 symbol_lookup_debug_printf ("lookup_symbol_in_objfile (%s, %s, %s, %s)",
2529 block_index == GLOBAL_BLOCK
2530 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2531 name, domain_name (domain));
2532
2533 result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
2534 name, domain);
2535 if (result.symbol != NULL)
2536 {
2538 ("lookup_symbol_in_objfile (...) = %s (in symtabs)",
2539 host_address_to_string (result.symbol));
2540 return result;
2541 }
2542
2543 result = lookup_symbol_via_quick_fns (objfile, block_index,
2544 name, domain);
2545 symbol_lookup_debug_printf ("lookup_symbol_in_objfile (...) = %s%s",
2546 result.symbol != NULL
2547 ? host_address_to_string (result.symbol)
2548 : "NULL",
2549 result.symbol != NULL ? " (via quick fns)"
2550 : "");
2551 return result;
2552}
2553
2554/* This function contains the common code of lookup_{global,static}_symbol.
2555 OBJFILE is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is
2556 the objfile to start the lookup in. */
2557
2558static struct block_symbol
2560 enum block_enum block_index,
2561 struct objfile *objfile,
2562 const domain_enum domain)
2563{
2565 struct block_symbol result;
2566 struct block_symbol_cache *bsc;
2567 struct symbol_cache_slot *slot;
2568
2569 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2570 gdb_assert (objfile == nullptr || block_index == GLOBAL_BLOCK);
2571
2572 /* First see if we can find the symbol in the cache.
2573 This works because we use the current objfile to qualify the lookup. */
2574 result = symbol_cache_lookup (cache, objfile, block_index, name, domain,
2575 &bsc, &slot);
2576 if (result.symbol != NULL)
2577 {
2578 if (SYMBOL_LOOKUP_FAILED_P (result))
2579 return {};
2580 return result;
2581 }
2582
2583 /* Do a global search (of global blocks, heh). */
2584 if (result.symbol == NULL)
2586 (objfile != NULL ? objfile->arch () : target_gdbarch (),
2587 [&result, block_index, name, domain] (struct objfile *objfile_iter)
2588 {
2589 result = lookup_symbol_in_objfile (objfile_iter, block_index,
2590 name, domain);
2591 return result.symbol != nullptr;
2592 },
2593 objfile);
2594
2595 if (result.symbol != NULL)
2596 symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
2597 else
2599
2600 return result;
2601}
2602
2603/* See symtab.h. */
2604
2605struct block_symbol
2606lookup_static_symbol (const char *name, const domain_enum domain)
2607{
2608 return lookup_global_or_static_symbol (name, STATIC_BLOCK, nullptr, domain);
2609}
2610
2611/* See symtab.h. */
2612
2613struct block_symbol
2615 const struct block *block,
2616 const domain_enum domain)
2617{
2618 /* If a block was passed in, we want to search the corresponding
2619 global block first. This yields "more expected" behavior, and is
2620 needed to support 'FILENAME'::VARIABLE lookups. */
2621 const struct block *global_block = block_global_block (block);
2622 symbol *sym = NULL;
2623 if (global_block != nullptr)
2624 {
2627 global_block, domain);
2628 if (sym != NULL && best_symbol (sym, domain))
2629 return { sym, global_block };
2630 }
2631
2632 struct objfile *objfile = nullptr;
2633 if (block != nullptr)
2634 {
2638 }
2639
2640 block_symbol bs
2642 if (better_symbol (sym, bs.symbol, domain) == sym)
2643 return { sym, global_block };
2644 else
2645 return bs;
2646}
2647
2648bool
2649symbol_matches_domain (enum language symbol_language,
2650 domain_enum symbol_domain,
2651 domain_enum domain)
2652{
2653 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2654 Similarly, any Ada type declaration implicitly defines a typedef. */
2655 if (symbol_language == language_cplus
2656 || symbol_language == language_d
2657 || symbol_language == language_ada
2658 || symbol_language == language_rust)
2659 {
2660 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
2661 && symbol_domain == STRUCT_DOMAIN)
2662 return true;
2663 }
2664 /* For all other languages, strict match is required. */
2665 return (symbol_domain == domain);
2666}
2667
2668/* See symtab.h. */
2669
2670struct type *
2672{
2674}
2675
2676/* A helper for basic_lookup_transparent_type that interfaces with the
2677 "quick" symbol table functions. */
2678
2679static struct type *
2681 enum block_enum block_index,
2682 const char *name)
2683{
2684 struct compunit_symtab *cust;
2685 const struct blockvector *bv;
2686 const struct block *block;
2687 struct symbol *sym;
2688
2689 cust = objfile->lookup_symbol (block_index, name, STRUCT_DOMAIN);
2690 if (cust == NULL)
2691 return NULL;
2692
2693 bv = cust->blockvector ();
2694 block = bv->block (block_index);
2697 if (sym == NULL)
2698 error_in_psymtab_expansion (block_index, name, cust);
2699 gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
2700 return sym->type ();
2701}
2702
2703/* Subroutine of basic_lookup_transparent_type to simplify it.
2704 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2705 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2706
2707static struct type *
2709 enum block_enum block_index,
2710 const char *name)
2711{
2712 const struct blockvector *bv;
2713 const struct block *block;
2714 const struct symbol *sym;
2715
2716 for (compunit_symtab *cust : objfile->compunits ())
2717 {
2718 bv = cust->blockvector ();
2719 block = bv->block (block_index);
2722 if (sym != NULL)
2723 {
2724 gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
2725 return sym->type ();
2726 }
2727 }
2728
2729 return NULL;
2730}
2731
2732/* The standard implementation of lookup_transparent_type. This code
2733 was modeled on lookup_symbol -- the parts not relevant to looking
2734 up types were just left out. In particular it's assumed here that
2735 types are available in STRUCT_DOMAIN and only in file-static or
2736 global blocks. */
2737
2738struct type *
2740{
2741 struct type *t;
2742
2743 /* Now search all the global symbols. Do the symtab's first, then
2744 check the psymtab's. If a psymtab indicates the existence
2745 of the desired name as a global, then do psymtab-to-symtab
2746 conversion on the fly and return the found symbol. */
2747
2749 {
2751 if (t)
2752 return t;
2753 }
2754
2756 {
2758 if (t)
2759 return t;
2760 }
2761
2762 /* Now search the static file-level symbols.
2763 Not strictly correct, but more useful than an error.
2764 Do the symtab's first, then
2765 check the psymtab's. If a psymtab indicates the existence
2766 of the desired name as a file-level static, then do psymtab-to-symtab
2767 conversion on the fly and return the found symbol. */
2768
2770 {
2772 if (t)
2773 return t;
2774 }
2775
2777 {
2779 if (t)
2780 return t;
2781 }
2782
2783 return (struct type *) 0;
2784}
2785
2786/* See symtab.h. */
2787
2788bool
2790 const lookup_name_info &name,
2791 const domain_enum domain,
2792 gdb::function_view<symbol_found_callback_ftype> callback)
2793{
2794 struct block_iterator iter;
2795 struct symbol *sym;
2796
2798 {
2799 if (symbol_matches_domain (sym->language (), sym->domain (), domain))
2800 {
2801 struct block_symbol block_sym = {sym, block};
2802
2803 if (!callback (&block_sym))
2804 return false;
2805 }
2806 }
2807 return true;
2808}
2809
2810/* See symtab.h. */
2811
2812bool
2814 (const struct block *block,
2815 const lookup_name_info &name,
2816 const domain_enum domain,
2817 gdb::function_view<symbol_found_callback_ftype> callback)
2818{
2819 if (!iterate_over_symbols (block, name, domain, callback))
2820 return false;
2821 struct block_symbol block_sym = {nullptr, block};
2822 return callback (&block_sym);
2823}
2824
2825/* Find the compunit symtab associated with PC and SECTION.
2826 This will read in debug info as necessary. */
2827
2828struct compunit_symtab *
2829find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
2830{
2831 struct compunit_symtab *best_cust = NULL;
2832 CORE_ADDR best_cust_range = 0;
2833 struct bound_minimal_symbol msymbol;
2834
2835 /* If we know that this is not a text address, return failure. This is
2836 necessary because we loop based on the block's high and low code
2837 addresses, which do not include the data ranges, and because
2838 we call find_pc_sect_psymtab which has a similar restriction based
2839 on the partial_symtab's texthigh and textlow. */
2840 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2841 if (msymbol.minsym && msymbol.minsym->data_p ())
2842 return NULL;
2843
2844 /* Search all symtabs for the one whose file contains our address, and which
2845 is the smallest of all the ones containing the address. This is designed
2846 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2847 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2848 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2849
2850 This happens for native ecoff format, where code from included files
2851 gets its own symtab. The symtab for the included file should have
2852 been read in already via the dependency mechanism.
2853 It might be swifter to create several symtabs with the same name
2854 like xcoff does (I'm not sure).
2855
2856 It also happens for objfiles that have their functions reordered.
2857 For these, the symtab we are looking for is not necessarily read in. */
2858
2859 for (objfile *obj_file : current_program_space->objfiles ())
2860 {
2861 for (compunit_symtab *cust : obj_file->compunits ())
2862 {
2863 const struct blockvector *bv = cust->blockvector ();
2864 const struct block *global_block = bv->global_block ();
2865 CORE_ADDR start = global_block->start ();
2866 CORE_ADDR end = global_block->end ();
2867 bool in_range_p = start <= pc && pc < end;
2868 if (!in_range_p)
2869 continue;
2870
2871 if (bv->map () != nullptr)
2872 {
2873 if (bv->map ()->find (pc) == nullptr)
2874 continue;
2875
2876 return cust;
2877 }
2878
2879 CORE_ADDR range = end - start;
2880 if (best_cust != nullptr
2881 && range >= best_cust_range)
2882 /* Cust doesn't have a smaller range than best_cust, skip it. */
2883 continue;
2884
2885 /* For an objfile that has its functions reordered,
2886 find_pc_psymtab will find the proper partial symbol table
2887 and we simply return its corresponding symtab. */
2888 /* In order to better support objfiles that contain both
2889 stabs and coff debugging info, we continue on if a psymtab
2890 can't be found. */
2891 if ((obj_file->flags & OBJF_REORDERED) != 0)
2892 {
2893 struct compunit_symtab *result;
2894
2895 result
2896 = obj_file->find_pc_sect_compunit_symtab (msymbol,
2897 pc,
2898 section,
2899 0);
2900 if (result != NULL)
2901 return result;
2902 }
2903
2904 if (section != 0)
2905 {
2906 struct symbol *sym = NULL;
2907 struct block_iterator iter;
2908
2909 for (int b_index = GLOBAL_BLOCK;
2910 b_index <= STATIC_BLOCK && sym == NULL;
2911 ++b_index)
2912 {
2913 const struct block *b = bv->block (b_index);
2914 ALL_BLOCK_SYMBOLS (b, iter, sym)
2915 {
2916 fixup_symbol_section (sym, obj_file);
2917 if (matching_obj_sections (sym->obj_section (obj_file),
2918 section))
2919 break;
2920 }
2921 }
2922 if (sym == NULL)
2923 continue; /* No symbol in this symtab matches
2924 section. */
2925 }
2926
2927 /* Cust is best found sofar, save it. */
2928 best_cust = cust;
2929 best_cust_range = range;
2930 }
2931 }
2932
2933 if (best_cust != NULL)
2934 return best_cust;
2935
2936 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2937
2938 for (objfile *objf : current_program_space->objfiles ())
2939 {
2940 struct compunit_symtab *result
2941 = objf->find_pc_sect_compunit_symtab (msymbol, pc, section, 1);
2942 if (result != NULL)
2943 return result;
2944 }
2945
2946 return NULL;
2947}
2948
2949/* Find the compunit symtab associated with PC.
2950 This will read in debug info as necessary.
2951 Backward compatibility, no section. */
2952
2953struct compunit_symtab *
2955{
2957}
2958
2959/* See symtab.h. */
2960
2961struct symbol *
2963{
2964 /* A helper function to search a given symtab for a symbol matching
2965 ADDR. */
2966 auto search_symtab = [] (compunit_symtab *symtab, CORE_ADDR addr) -> symbol *
2967 {
2968 const struct blockvector *bv = symtab->blockvector ();
2969
2970 for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
2971 {
2972 const struct block *b = bv->block (i);
2973 struct block_iterator iter;
2974 struct symbol *sym;
2975
2976 ALL_BLOCK_SYMBOLS (b, iter, sym)
2977 {
2978 if (sym->aclass () == LOC_STATIC
2979 && sym->value_address () == addr)
2980 return sym;
2981 }
2982 }
2983 return nullptr;
2984 };
2985
2987 {
2988 /* If this objfile was read with -readnow, then we need to
2989 search the symtabs directly. */
2990 if ((objfile->flags & OBJF_READNOW) != 0)
2991 {
2993 {
2994 struct symbol *sym = search_symtab (symtab, address);
2995 if (sym != nullptr)
2996 return sym;
2997 }
2998 }
2999 else
3000 {
3001 struct compunit_symtab *symtab
3003 if (symtab != NULL)
3004 {
3005 struct symbol *sym = search_symtab (symtab, address);
3006 if (sym != nullptr)
3007 return sym;
3008 }
3009 }
3010 }
3011
3012 return NULL;
3013}
3014
3015
3016
3017/* Find the source file and line number for a given PC value and SECTION.
3018 Return a structure containing a symtab pointer, a line number,
3019 and a pc range for the entire source line.
3020 The value's .pc field is NOT the specified pc.
3021 NOTCURRENT nonzero means, if specified pc is on a line boundary,
3022 use the line that ends there. Otherwise, in that case, the line
3023 that begins there is used. */
3024
3025/* The big complication here is that a line may start in one file, and end just
3026 before the start of another file. This usually occurs when you #include
3027 code in the middle of a subroutine. To properly find the end of a line's PC
3028 range, we must search all symtabs associated with this compilation unit, and
3029 find the one whose first PC is closer than that of the next line in this
3030 symtab. */
3031
3032struct symtab_and_line
3033find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
3034{
3035 struct compunit_symtab *cust;
3036 struct linetable *l;
3037 int len;
3038 struct linetable_entry *item;
3039 const struct blockvector *bv;
3040 struct bound_minimal_symbol msymbol;
3041
3042 /* Info on best line seen so far, and where it starts, and its file. */
3043
3044 struct linetable_entry *best = NULL;
3045 CORE_ADDR best_end = 0;
3046 struct symtab *best_symtab = 0;
3047
3048 /* Store here the first line number
3049 of a file which contains the line at the smallest pc after PC.
3050 If we don't find a line whose range contains PC,
3051 we will use a line one less than this,
3052 with a range from the start of that file to the first line's pc. */
3053 struct linetable_entry *alt = NULL;
3054
3055 /* Info on best line seen in this file. */
3056
3057 struct linetable_entry *prev;
3058
3059 /* If this pc is not from the current frame,
3060 it is the address of the end of a call instruction.
3061 Quite likely that is the start of the following statement.
3062 But what we want is the statement containing the instruction.
3063 Fudge the pc to make sure we get that. */
3064
3065 /* It's tempting to assume that, if we can't find debugging info for
3066 any function enclosing PC, that we shouldn't search for line
3067 number info, either. However, GAS can emit line number info for
3068 assembly files --- very helpful when debugging hand-written
3069 assembly code. In such a case, we'd have no debug info for the
3070 function, but we would have line info. */
3071
3072 if (notcurrent)
3073 pc -= 1;
3074
3075 /* elz: added this because this function returned the wrong
3076 information if the pc belongs to a stub (import/export)
3077 to call a shlib function. This stub would be anywhere between
3078 two functions in the target, and the line info was erroneously
3079 taken to be the one of the line before the pc. */
3080
3081 /* RT: Further explanation:
3082
3083 * We have stubs (trampolines) inserted between procedures.
3084 *
3085 * Example: "shr1" exists in a shared library, and a "shr1" stub also
3086 * exists in the main image.
3087 *
3088 * In the minimal symbol table, we have a bunch of symbols
3089 * sorted by start address. The stubs are marked as "trampoline",
3090 * the others appear as text. E.g.:
3091 *
3092 * Minimal symbol table for main image
3093 * main: code for main (text symbol)
3094 * shr1: stub (trampoline symbol)
3095 * foo: code for foo (text symbol)
3096 * ...
3097 * Minimal symbol table for "shr1" image:
3098 * ...
3099 * shr1: code for shr1 (text symbol)
3100 * ...
3101 *
3102 * So the code below is trying to detect if we are in the stub
3103 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3104 * and if found, do the symbolization from the real-code address
3105 * rather than the stub address.
3106 *
3107 * Assumptions being made about the minimal symbol table:
3108 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3109 * if we're really in the trampoline.s If we're beyond it (say
3110 * we're in "foo" in the above example), it'll have a closer
3111 * symbol (the "foo" text symbol for example) and will not
3112 * return the trampoline.
3113 * 2. lookup_minimal_symbol_text() will find a real text symbol
3114 * corresponding to the trampoline, and whose address will
3115 * be different than the trampoline address. I put in a sanity
3116 * check for the address being the same, to avoid an
3117 * infinite recursion.
3118 */
3119 msymbol = lookup_minimal_symbol_by_pc (pc);
3120 if (msymbol.minsym != NULL)
3121 if (msymbol.minsym->type () == mst_solib_trampoline)
3122 {
3123 struct bound_minimal_symbol mfunsym
3125 NULL);
3126
3127 if (mfunsym.minsym == NULL)
3128 /* I eliminated this warning since it is coming out
3129 * in the following situation:
3130 * gdb shmain // test program with shared libraries
3131 * (gdb) break shr1 // function in shared lib
3132 * Warning: In stub for ...
3133 * In the above situation, the shared lib is not loaded yet,
3134 * so of course we can't find the real func/line info,
3135 * but the "break" still works, and the warning is annoying.
3136 * So I commented out the warning. RT */
3137 /* warning ("In stub for %s; unable to find real function/line info",
3138 msymbol->linkage_name ()); */
3139 ;
3140 /* fall through */
3141 else if (mfunsym.value_address ()
3142 == msymbol.value_address ())
3143 /* Avoid infinite recursion */
3144 /* See above comment about why warning is commented out. */
3145 /* warning ("In stub for %s; unable to find real function/line info",
3146 msymbol->linkage_name ()); */
3147 ;
3148 /* fall through */
3149 else
3150 {
3151 /* Detect an obvious case of infinite recursion. If this
3152 should occur, we'd like to know about it, so error out,
3153 fatally. */
3154 if (mfunsym.value_address () == pc)
3155 internal_error (_("Infinite recursion detected in find_pc_sect_line;"
3156 "please file a bug report"));
3157
3158 return find_pc_line (mfunsym.value_address (), 0);
3159 }
3160 }
3161
3162 symtab_and_line val;
3164
3165 cust = find_pc_sect_compunit_symtab (pc, section);
3166 if (cust == NULL)
3167 {
3168 /* If no symbol information, return previous pc. */
3169 if (notcurrent)
3170 pc++;
3171 val.pc = pc;
3172 return val;
3173 }
3174
3175 bv = cust->blockvector ();
3176
3177 /* Look at all the symtabs that share this blockvector.
3178 They all have the same apriori range, that we found was right;
3179 but they have different line tables. */
3180
3181 for (symtab *iter_s : cust->filetabs ())
3182 {
3183 /* Find the best line in this symtab. */
3184 l = iter_s->linetable ();
3185 if (!l)
3186 continue;
3187 len = l->nitems;
3188 if (len <= 0)
3189 {
3190 /* I think len can be zero if the symtab lacks line numbers
3191 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3192 I'm not sure which, and maybe it depends on the symbol
3193 reader). */
3194 continue;
3195 }
3196
3197 prev = NULL;
3198 item = l->item; /* Get first line info. */
3199
3200 /* Is this file's first line closer than the first lines of other files?
3201 If so, record this file, and its first line, as best alternate. */
3202 if (item->pc > pc && (!alt || item->pc < alt->pc))
3203 alt = item;
3204
3205 auto pc_compare = [](const CORE_ADDR & comp_pc,
3206 const struct linetable_entry & lhs)->bool
3207 {
3208 return comp_pc < lhs.pc;
3209 };
3210
3211 struct linetable_entry *first = item;
3212 struct linetable_entry *last = item + len;
3213 item = std::upper_bound (first, last, pc, pc_compare);
3214 if (item != first)
3215 prev = item - 1; /* Found a matching item. */
3216
3217 /* At this point, prev points at the line whose start addr is <= pc, and
3218 item points at the next line. If we ran off the end of the linetable
3219 (pc >= start of the last line), then prev == item. If pc < start of
3220 the first line, prev will not be set. */
3221
3222 /* Is this file's best line closer than the best in the other files?
3223 If so, record this file, and its best line, as best so far. Don't
3224 save prev if it represents the end of a function (i.e. line number
3225 0) instead of a real line. */
3226
3227 if (prev && prev->line && (!best || prev->pc > best->pc))
3228 {
3229 best = prev;
3230 best_symtab = iter_s;
3231
3232 /* If during the binary search we land on a non-statement entry,
3233 scan backward through entries at the same address to see if
3234 there is an entry marked as is-statement. In theory this
3235 duplication should have been removed from the line table
3236 during construction, this is just a double check. If the line
3237 table has had the duplication removed then this should be
3238 pretty cheap. */
3239 if (!best->is_stmt)
3240 {
3241 struct linetable_entry *tmp = best;
3242 while (tmp > first && (tmp - 1)->pc == tmp->pc
3243 && (tmp - 1)->line != 0 && !tmp->is_stmt)
3244 --tmp;
3245 if (tmp->is_stmt)
3246 best = tmp;
3247 }
3248
3249 /* Discard BEST_END if it's before the PC of the current BEST. */
3250 if (best_end <= best->pc)
3251 best_end = 0;
3252 }
3253
3254 /* If another line (denoted by ITEM) is in the linetable and its
3255 PC is after BEST's PC, but before the current BEST_END, then
3256 use ITEM's PC as the new best_end. */
3257 if (best && item < last && item->pc > best->pc
3258 && (best_end == 0 || best_end > item->pc))
3259 best_end = item->pc;
3260 }
3261
3262 if (!best_symtab)
3263 {
3264 /* If we didn't find any line number info, just return zeros.
3265 We used to return alt->line - 1 here, but that could be
3266 anywhere; if we don't have line number info for this PC,
3267 don't make some up. */
3268 val.pc = pc;
3269 }
3270 else if (best->line == 0)
3271 {
3272 /* If our best fit is in a range of PC's for which no line
3273 number info is available (line number is zero) then we didn't
3274 find any valid line information. */
3275 val.pc = pc;
3276 }
3277 else
3278 {
3279 val.is_stmt = best->is_stmt;
3280 val.symtab = best_symtab;
3281 val.line = best->line;
3282 val.pc = best->pc;
3283 if (best_end && (!alt || best_end < alt->pc))
3284 val.end = best_end;
3285 else if (alt)
3286 val.end = alt->pc;
3287 else
3288 val.end = bv->global_block ()->end ();
3289 }
3290 val.section = section;
3291 return val;
3292}
3293
3294/* Backward compatibility (no section). */
3295
3296struct symtab_and_line
3297find_pc_line (CORE_ADDR pc, int notcurrent)
3298{
3299 struct obj_section *section;
3300
3303 return find_pc_sect_line (pc, section, notcurrent);
3304
3305 /* If the original PC was an unmapped address then we translate this to a
3306 mapped address in order to lookup the sal. However, as the user
3307 passed us an unmapped address it makes more sense to return a result
3308 that has the pc and end fields translated to unmapped addresses. */
3310 symtab_and_line sal = find_pc_sect_line (pc, section, notcurrent);
3313 return sal;
3314}
3315
3316/* See symtab.h. */
3317
3318struct symtab *
3320{
3321 struct symtab_and_line sal;
3322
3323 /* This always passes zero for NOTCURRENT to find_pc_line.
3324 There are currently no callers that ever pass non-zero. */
3325 sal = find_pc_line (pc, 0);
3326 return sal.symtab;
3327}
3328
3329/* Find line number LINE in any symtab whose name is the same as
3330 SYMTAB.
3331
3332 If found, return the symtab that contains the linetable in which it was
3333 found, set *INDEX to the index in the linetable of the best entry
3334 found, and set *EXACT_MATCH to true if the value returned is an
3335 exact match.
3336
3337 If not found, return NULL. */
3338
3339struct symtab *
3340find_line_symtab (struct symtab *sym_tab, int line,
3341 int *index, bool *exact_match)
3342{
3343 int exact = 0; /* Initialized here to avoid a compiler warning. */
3344
3345 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3346 so far seen. */
3347
3348 int best_index;
3349 struct linetable *best_linetable;
3350 struct symtab *best_symtab;
3351
3352 /* First try looking it up in the given symtab. */
3353 best_linetable = sym_tab->linetable ();
3354 best_symtab = sym_tab;
3355 best_index = find_line_common (best_linetable, line, &exact, 0);
3356 if (best_index < 0 || !exact)
3357 {
3358 /* Didn't find an exact match. So we better keep looking for
3359 another symtab with the same name. In the case of xcoff,
3360 multiple csects for one source file (produced by IBM's FORTRAN
3361 compiler) produce multiple symtabs (this is unavoidable
3362 assuming csects can be at arbitrary places in memory and that
3363 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3364
3365 /* BEST is the smallest linenumber > LINE so far seen,
3366 or 0 if none has been seen so far.
3367 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3368 int best;
3369
3370 if (best_index >= 0)
3371 best = best_linetable->item[best_index].line;
3372 else
3373 best = 0;
3374
3377
3379 {
3380 for (compunit_symtab *cu : objfile->compunits ())
3381 {
3382 for (symtab *s : cu->filetabs ())
3383 {
3384 struct linetable *l;
3385 int ind;
3386
3387 if (FILENAME_CMP (sym_tab->filename, s->filename) != 0)
3388 continue;
3389 if (FILENAME_CMP (symtab_to_fullname (sym_tab),
3390 symtab_to_fullname (s)) != 0)
3391 continue;
3392 l = s->linetable ();
3393 ind = find_line_common (l, line, &exact, 0);
3394 if (ind >= 0)
3395 {
3396 if (exact)
3397 {
3398 best_index = ind;
3399 best_linetable = l;
3400 best_symtab = s;
3401 goto done;
3402 }
3403 if (best == 0 || l->item[ind].line < best)
3404 {
3405 best = l->item[ind].line;
3406 best_index = ind;
3407 best_linetable = l;
3408 best_symtab = s;
3409 }
3410 }
3411 }
3412 }
3413 }
3414 }
3415done:
3416 if (best_index < 0)
3417 return NULL;
3418
3419 if (index)
3420 *index = best_index;
3421 if (exact_match)
3422 *exact_match = (exact != 0);
3423
3424 return best_symtab;
3425}
3426
3427/* Given SYMTAB, returns all the PCs function in the symtab that
3428 exactly match LINE. Returns an empty vector if there are no exact
3429 matches, but updates BEST_ITEM in this case. */
3430
3431std::vector<CORE_ADDR>
3433 struct linetable_entry **best_item)
3434{
3435 int start = 0;
3436 std::vector<CORE_ADDR> result;
3437
3438 /* First, collect all the PCs that are at this line. */
3439 while (1)
3440 {
3441 int was_exact;
3442 int idx;
3443
3444 idx = find_line_common (symtab->linetable (), line, &was_exact,
3445 start);
3446 if (idx < 0)
3447 break;
3448
3449 if (!was_exact)
3450 {
3451 struct linetable_entry *item = &symtab->linetable ()->item[idx];
3452
3453 if (*best_item == NULL
3454 || (item->line < (*best_item)->line && item->is_stmt))
3455 *best_item = item;
3456
3457 break;
3458 }
3459
3460 result.push_back (symtab->linetable ()->item[idx].pc);
3461 start = idx + 1;
3462 }
3463
3464 return result;
3465}
3466
3467
3468/* Set the PC value for a given source file and line number and return true.
3469 Returns false for invalid line number (and sets the PC to 0).
3470 The source file is specified with a struct symtab. */
3471
3472bool
3473find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
3474{
3475 struct linetable *l;
3476 int ind;
3477
3478 *pc = 0;
3479 if (symtab == 0)
3480 return false;
3481
3482 symtab = find_line_symtab (symtab, line, &ind, NULL);
3483 if (symtab != NULL)
3484 {
3485 l = symtab->linetable ();
3486 *pc = l->item[ind].pc;
3487 return true;
3488 }
3489 else
3490 return false;
3491}
3492
3493/* Find the range of pc values in a line.
3494 Store the starting pc of the line into *STARTPTR
3495 and the ending pc (start of next line) into *ENDPTR.
3496 Returns true to indicate success.
3497 Returns false if could not find the specified line. */
3498
3499bool
3500find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
3501 CORE_ADDR *endptr)
3502{
3503 CORE_ADDR startaddr;
3504 struct symtab_and_line found_sal;
3505
3506 startaddr = sal.pc;
3507 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
3508 return false;
3509
3510 /* This whole function is based on address. For example, if line 10 has
3511 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3512 "info line *0x123" should say the line goes from 0x100 to 0x200
3513 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3514 This also insures that we never give a range like "starts at 0x134
3515 and ends at 0x12c". */
3516
3517 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
3518 if (found_sal.line != sal.line)
3519 {
3520 /* The specified line (sal) has zero bytes. */
3521 *startptr = found_sal.pc;
3522 *endptr = found_sal.pc;
3523 }
3524 else
3525 {
3526 *startptr = found_sal.pc;
3527 *endptr = found_sal.end;
3528 }
3529 return true;
3530}
3531
3532/* Given a line table and a line number, return the index into the line
3533 table for the pc of the nearest line whose number is >= the specified one.
3534 Return -1 if none is found. The value is >= 0 if it is an index.
3535 START is the index at which to start searching the line table.
3536
3537 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3538
3539static int
3540find_line_common (struct linetable *l, int lineno,
3541 int *exact_match, int start)
3542{
3543 int i;
3544 int len;
3545
3546 /* BEST is the smallest linenumber > LINENO so far seen,
3547 or 0 if none has been seen so far.
3548 BEST_INDEX identifies the item for it. */
3549
3550 int best_index = -1;
3551 int best = 0;
3552
3553 *exact_match = 0;
3554
3555 if (lineno <= 0)
3556 return -1;
3557 if (l == 0)
3558 return -1;
3559
3560 len = l->nitems;
3561 for (i = start; i < len; i++)
3562 {
3563 struct linetable_entry *item = &(l->item[i]);
3564
3565 /* Ignore non-statements. */
3566 if (!item->is_stmt)
3567 continue;
3568
3569 if (item->line == lineno)
3570 {
3571 /* Return the first (lowest address) entry which matches. */
3572 *exact_match = 1;
3573 return i;
3574 }
3575
3576 if (item->line > lineno && (best == 0 || item->line < best))
3577 {
3578 best = item->line;
3579 best_index = i;
3580 }
3581 }
3582
3583 /* If we got here, we didn't get an exact match. */
3584 return best_index;
3585}
3586
3587bool
3588find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
3589{
3590 struct symtab_and_line sal;
3591
3592 sal = find_pc_line (pc, 0);
3593 *startptr = sal.pc;
3594 *endptr = sal.end;
3595 return sal.symtab != 0;
3596}
3597
3598/* Helper for find_function_start_sal. Does most of the work, except
3599 setting the sal's symbol. */
3600
3601static symtab_and_line
3603 bool funfirstline)
3604{
3605 symtab_and_line sal = find_pc_sect_line (func_addr, section, 0);
3606
3607 if (funfirstline && sal.symtab != NULL
3608 && (sal.symtab->compunit ()->locations_valid ()
3609 || sal.symtab->language () == language_asm))
3610 {
3611 struct gdbarch *gdbarch = sal.symtab->compunit ()->objfile ()->arch ();
3612
3613 sal.pc = func_addr;
3615 sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
3616 return sal;
3617 }
3618
3619 /* We always should have a line for the function start address.
3620 If we don't, something is odd. Create a plain SAL referring
3621 just the PC and hope that skip_prologue_sal (if requested)
3622 can find a line number for after the prologue. */
3623 if (sal.pc < func_addr)
3624 {
3625 sal = {};
3627 sal.pc = func_addr;
3628 sal.section = section;
3629 }
3630
3631 if (funfirstline)
3632 skip_prologue_sal (&sal);
3633
3634 return sal;
3635}
3636
3637/* See symtab.h. */
3638
3640find_function_start_sal (CORE_ADDR func_addr, obj_section *section,
3641 bool funfirstline)
3642{
3643 symtab_and_line sal
3644 = find_function_start_sal_1 (func_addr, section, funfirstline);
3645
3646 /* find_function_start_sal_1 does a linetable search, so it finds
3647 the symtab and linenumber, but not a symbol. Fill in the
3648 function symbol too. */
3650
3651 return sal;
3652}
3653
3654/* See symtab.h. */
3655
3657find_function_start_sal (symbol *sym, bool funfirstline)
3658{
3659 fixup_symbol_section (sym, NULL);
3660 symtab_and_line sal
3662 sym->obj_section (sym->objfile ()),
3663 funfirstline);
3664 sal.symbol = sym;
3665 return sal;
3666}
3667
3668
3669/* Given a function start address FUNC_ADDR and SYMTAB, find the first
3670 address for that function that has an entry in SYMTAB's line info
3671 table. If such an entry cannot be found, return FUNC_ADDR
3672 unaltered. */
3673
3674static CORE_ADDR
3675skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
3676{
3677 CORE_ADDR func_start, func_end;
3678 struct linetable *l;
3679 int i;
3680
3681 /* Give up if this symbol has no lineinfo table. */
3682 l = symtab->linetable ();
3683 if (l == NULL)
3684 return func_addr;
3685
3686 /* Get the range for the function's PC values, or give up if we
3687 cannot, for some reason. */
3688 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
3689 return func_addr;
3690
3691 /* Linetable entries are ordered by PC values, see the commentary in
3692 symtab.h where `struct linetable' is defined. Thus, the first
3693 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3694 address we are looking for. */
3695 for (i = 0; i < l->nitems; i++)
3696 {
3697 struct linetable_entry *item = &(l->item[i]);
3698
3699 /* Don't use line numbers of zero, they mark special entries in
3700 the table. See the commentary on symtab.h before the
3701 definition of struct linetable. */
3702 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
3703 return item->pc;
3704 }
3705
3706 return func_addr;
3707}
3708
3709/* Try to locate the address where a breakpoint should be placed past the
3710 prologue of function starting at FUNC_ADDR using the line table.
3711
3712 Return the address associated with the first entry in the line-table for
3713 the function starting at FUNC_ADDR which has prologue_end set to true if
3714 such entry exist, otherwise return an empty optional. */
3715
3716static gdb::optional<CORE_ADDR>
3718{
3719 CORE_ADDR start_pc, end_pc;
3720
3721 if (!find_pc_partial_function (func_addr, nullptr, &start_pc, &end_pc))
3722 return {};
3723
3724 const struct symtab_and_line prologue_sal = find_pc_line (start_pc, 0);
3725 if (prologue_sal.symtab != nullptr
3726 && prologue_sal.symtab->language () != language_asm)
3727 {
3728 struct linetable *linetable = prologue_sal.symtab->linetable ();
3729
3730 auto it = std::lower_bound
3731 (linetable->item, linetable->item + linetable->nitems, start_pc,
3732 [] (const linetable_entry &lte, CORE_ADDR pc) -> bool
3733 {
3734 return lte.pc < pc;
3735 });
3736
3737 for (;
3738 it < linetable->item + linetable->nitems && it->pc <= end_pc;
3739 it++)
3740 if (it->prologue_end)
3741 return {it->pc};
3742 }
3743
3744 return {};
3745}
3746
3747/* Adjust SAL to the first instruction past the function prologue.
3748 If the PC was explicitly specified, the SAL is not changed.
3749 If the line number was explicitly specified then the SAL can still be
3750 updated, unless the language for SAL is assembler, in which case the SAL
3751 will be left unchanged.
3752 If SAL is already past the prologue, then do nothing. */
3753
3754void
3756{
3757 struct symbol *sym;
3758 struct symtab_and_line start_sal;
3759 CORE_ADDR pc, saved_pc;
3760 struct obj_section *section;
3761 const char *name;
3762 struct objfile *objfile;
3763 struct gdbarch *gdbarch;
3764 const struct block *b, *function_block;
3765 int force_skip, skip;
3766
3767 /* Do not change the SAL if PC was specified explicitly. */
3768 if (sal->explicit_pc)
3769 return;
3770
3771 /* In assembly code, if the user asks for a specific line then we should
3772 not adjust the SAL. The user already has instruction level
3773 visibility in this case, so selecting a line other than one requested
3774 is likely to be the wrong choice. */
3775 if (sal->symtab != nullptr
3776 && sal->explicit_line
3777 && sal->symtab->language () == language_asm)
3778 return;
3779
3780 scoped_restore_current_pspace_and_thread restore_pspace_thread;
3781
3783
3784 sym = find_pc_sect_function (sal->pc, sal->section);
3785 if (sym != NULL)
3786 {
3787 fixup_symbol_section (sym, NULL);
3788
3789 objfile = sym->objfile ();
3790 pc = sym->value_block ()->entry_pc ();
3791 section = sym->obj_section (objfile);
3792 name = sym->linkage_name ();
3793 }
3794 else
3795 {
3796 struct bound_minimal_symbol msymbol
3798
3799 if (msymbol.minsym == NULL)
3800 return;
3801
3802 objfile = msymbol.objfile;
3803 pc = msymbol.value_address ();
3804 section = msymbol.minsym->obj_section (objfile);
3805 name = msymbol.minsym->linkage_name ();
3806 }
3807
3808 gdbarch = objfile->arch ();
3809
3810 /* Process the prologue in two passes. In the first pass try to skip the
3811 prologue (SKIP is true) and verify there is a real need for it (indicated
3812 by FORCE_SKIP). If no such reason was found run a second pass where the
3813 prologue is not skipped (SKIP is false). */
3814
3815 skip = 1;
3816 force_skip = 1;
3817
3818 /* Be conservative - allow direct PC (without skipping prologue) only if we
3819 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3820 have to be set by the caller so we use SYM instead. */
3821 if (sym != NULL
3822 && sym->symtab ()->compunit ()->locations_valid ())
3823 force_skip = 0;
3824
3825 saved_pc = pc;
3826 do
3827 {
3828 pc = saved_pc;
3829
3830 /* Check if the compiler explicitly indicated where a breakpoint should
3831 be placed to skip the prologue. */
3832 if (!ignore_prologue_end_flag && skip)
3833 {
3834 gdb::optional<CORE_ADDR> linetable_pc
3836 if (linetable_pc)
3837 {
3838 pc = *linetable_pc;
3839 start_sal = find_pc_sect_line (pc, section, 0);
3840 force_skip = 1;
3841 continue;
3842 }
3843 }
3844
3845 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3846 so that gdbarch_skip_prologue has something unique to work on. */
3847 if (section_is_overlay (section) && !section_is_mapped (section))
3848 pc = overlay_unmapped_address (pc, section);
3849
3850 /* Skip "first line" of function (which is actually its prologue). */
3854 if (skip)
3856
3857 /* For overlays, map pc back into its mapped VMA range. */
3858 pc = overlay_mapped_address (pc, section);
3859
3860 /* Calculate line number. */
3861 start_sal = find_pc_sect_line (pc, section, 0);
3862
3863 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3864 line is still part of the same function. */
3865 if (skip && start_sal.pc != pc
3866 && (sym ? (sym->value_block ()->entry_pc () <= start_sal.end
3867 && start_sal.end < sym->value_block()->end ())
3868 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
3870 {
3871 /* First pc of next line */
3872 pc = start_sal.end;
3873 /* Recalculate the line number (might not be N+1). */
3874 start_sal = find_pc_sect_line (pc, section, 0);
3875 }
3876
3877 /* On targets with executable formats that don't have a concept of
3878 constructors (ELF with .init has, PE doesn't), gcc emits a call
3879 to `__main' in `main' between the prologue and before user
3880 code. */
3882 && name && strcmp_iw (name, "main") == 0)
3883 {
3885 /* Recalculate the line number (might not be N+1). */
3886 start_sal = find_pc_sect_line (pc, section, 0);
3887 force_skip = 1;
3888 }
3889 }
3890 while (!force_skip && skip--);
3891
3892 /* If we still don't have a valid source line, try to find the first
3893 PC in the lineinfo table that belongs to the same function. This
3894 happens with COFF debug info, which does not seem to have an
3895 entry in lineinfo table for the code after the prologue which has
3896 no direct relation to source. For example, this was found to be
3897 the case with the DJGPP target using "gcc -gcoff" when the
3898 compiler inserted code after the prologue to make sure the stack
3899 is aligned. */
3900 if (!force_skip && sym && start_sal.symtab == NULL)
3901 {
3902 pc = skip_prologue_using_lineinfo (pc, sym->symtab ());
3903 /* Recalculate the line number. */
3904 start_sal = find_pc_sect_line (pc, section, 0);
3905 }
3906
3907 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3908 forward SAL to the end of the prologue. */
3909 if (sal->pc >= pc)
3910 return;
3911
3912 sal->pc = pc;
3913 sal->section = section;
3914 sal->symtab = start_sal.symtab;
3915 sal->line = start_sal.line;
3916 sal->end = start_sal.end;
3917
3918 /* Check if we are now inside an inlined function. If we can,
3919 use the call site of the function instead. */
3920 b = block_for_pc_sect (sal->pc, sal->section);
3921 function_block = NULL;
3922 while (b != NULL)
3923 {
3924 if (b->function () != NULL && block_inlined_p (b))
3925 function_block = b;
3926 else if (b->function () != NULL)
3927 break;
3928 b = b->superblock ();
3929 }
3930 if (function_block != NULL
3931 && function_block->function ()->line () != 0)
3932 {
3933 sal->line = function_block->function ()->line ();
3934 sal->symtab = function_block->function ()->symtab ();
3935 }
3936}
3937
3938/* Given PC at the function's start address, attempt to find the
3939 prologue end using SAL information. Return zero if the skip fails.
3940
3941 A non-optimized prologue traditionally has one SAL for the function
3942 and a second for the function body. A single line function has
3943 them both pointing at the same line.
3944
3945 An optimized prologue is similar but the prologue may contain
3946 instructions (SALs) from the instruction body. Need to skip those
3947 while not getting into the function body.
3948
3949 The functions end point and an increasing SAL line are used as
3950 indicators of the prologue's endpoint.
3951
3952 This code is based on the function refine_prologue_limit
3953 (found in ia64). */
3954
3955CORE_ADDR
3956skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
3957{
3958 struct symtab_and_line prologue_sal;
3959 CORE_ADDR start_pc;
3960 CORE_ADDR end_pc;
3961 const struct block *bl;
3962
3963 /* Get an initial range for the function. */
3964 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
3966
3967 prologue_sal = find_pc_line (start_pc, 0);
3968 if (prologue_sal.line != 0)
3969 {
3970 /* For languages other than assembly, treat two consecutive line
3971 entries at the same address as a zero-instruction prologue.
3972 The GNU assembler emits separate line notes for each instruction
3973 in a multi-instruction macro, but compilers generally will not
3974 do this. */
3975 if (prologue_sal.symtab->language () != language_asm)
3976 {
3977 struct linetable *linetable = prologue_sal.symtab->linetable ();
3978 int idx = 0;
3979
3980 /* Skip any earlier lines, and any end-of-sequence marker
3981 from a previous function. */
3982 while (linetable->item[idx].pc != prologue_sal.pc
3983 || linetable->item[idx].line == 0)
3984 idx++;
3985
3986 if (idx+1 < linetable->nitems
3987 && linetable->item[idx+1].line != 0
3988 && linetable->item[idx+1].pc == start_pc)
3989 return start_pc;
3990 }
3991
3992 /* If there is only one sal that covers the entire function,
3993 then it is probably a single line function, like
3994 "foo(){}". */
3995 if (prologue_sal.end >= end_pc)
3996 return 0;
3997
3998 while (prologue_sal.end < end_pc)
3999 {
4000 struct symtab_and_line sal;
4001
4002 sal = find_pc_line (prologue_sal.end, 0);
4003 if (sal.line == 0)
4004 break;
4005 /* Assume that a consecutive SAL for the same (or larger)
4006 line mark the prologue -> body transition. */
4007 if (sal.line >= prologue_sal.line)
4008 break;
4009 /* Likewise if we are in a different symtab altogether
4010 (e.g. within a file included via #include).  */
4011 if (sal.symtab != prologue_sal.symtab)
4012 break;
4013
4014 /* The line number is smaller. Check that it's from the
4015 same function, not something inlined. If it's inlined,
4016 then there is no point comparing the line numbers. */
4017 bl = block_for_pc (prologue_sal.end);
4018 while (bl)
4019 {
4020 if (block_inlined_p (bl))
4021 break;
4022 if (bl->function ())
4023 {
4024 bl = NULL;
4025 break;
4026 }
4027 bl = bl->superblock ();
4028 }
4029 if (bl != NULL)
4030 break;
4031
4032 /* The case in which compiler's optimizer/scheduler has
4033 moved instructions into the prologue. We look ahead in
4034 the function looking for address ranges whose
4035 corresponding line number is less the first one that we
4036 found for the function. This is more conservative then
4037 refine_prologue_limit which scans a large number of SALs
4038 looking for any in the prologue. */
4039 prologue_sal = sal;
4040 }
4041 }
4042
4043 if (prologue_sal.end < end_pc)
4044 /* Return the end of this line, or zero if we could not find a
4045 line. */
4046 return prologue_sal.end;
4047 else
4048 /* Don't return END_PC, which is past the end of the function. */
4049 return prologue_sal.pc;
4050}
4051
4052/* See symtab.h. */
4053
4054symbol *
4056{
4057 CORE_ADDR func_addr;
4058 if (!msymbol_is_function (msymbol.objfile, msymbol.minsym, &func_addr))
4059 return NULL;
4060
4061 symbol *sym = find_pc_function (func_addr);
4062 if (sym != NULL
4063 && sym->aclass () == LOC_BLOCK
4064 && sym->value_block ()->entry_pc () == func_addr)
4065 return sym;
4066
4067 return NULL;
4068}
4069
4070
4071/* If P is of the form "operator[ \t]+..." where `...' is
4072 some legitimate operator text, return a pointer to the
4073 beginning of the substring of the operator text.
4074 Otherwise, return "". */
4075
4076static const char *
4077operator_chars (const char *p, const char **end)
4078{
4079 *end = "";
4080 if (!startswith (p, CP_OPERATOR_STR))
4081 return *end;
4082 p += CP_OPERATOR_LEN;
4083
4084 /* Don't get faked out by `operator' being part of a longer
4085 identifier. */
4086 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
4087 return *end;
4088
4089 /* Allow some whitespace between `operator' and the operator symbol. */
4090 while (*p == ' ' || *p == '\t')
4091 p++;
4092
4093 /* Recognize 'operator TYPENAME'. */
4094
4095 if (isalpha (*p) || *p == '_' || *p == '$')
4096 {
4097 const char *q = p + 1;
4098
4099 while (isalnum (*q) || *q == '_' || *q == '$')
4100 q++;
4101 *end = q;
4102 return p;
4103 }
4104
4105 while (*p)
4106 switch (*p)
4107 {
4108 case '\\': /* regexp quoting */
4109 if (p[1] == '*')
4110 {
4111 if (p[2] == '=') /* 'operator\*=' */
4112 *end = p + 3;
4113 else /* 'operator\*' */
4114 *end = p + 2;
4115 return p;
4116 }
4117 else if (p[1] == '[')
4118 {
4119 if (p[2] == ']')
4120 error (_("mismatched quoting on brackets, "
4121 "try 'operator\\[\\]'"));
4122 else if (p[2] == '\\' && p[3] == ']')
4123 {
4124 *end = p + 4; /* 'operator\[\]' */
4125 return p;
4126 }
4127 else
4128 error (_("nothing is allowed between '[' and ']'"));
4129 }
4130 else
4131 {
4132 /* Gratuitous quote: skip it and move on. */
4133 p++;
4134 continue;
4135 }
4136 break;
4137 case '!':
4138 case '=':
4139 case '*':
4140 case '/':
4141 case '%':
4142 case '^':
4143 if (p[1] == '=')
4144 *end = p + 2;
4145 else
4146 *end = p + 1;
4147 return p;
4148 case '<':
4149 case '>':
4150 case '+':
4151 case '-':
4152 case '&':
4153 case '|':
4154 if (p[0] == '-' && p[1] == '>')
4155 {
4156 /* Struct pointer member operator 'operator->'. */
4157 if (p[2] == '*')
4158 {
4159 *end = p + 3; /* 'operator->*' */
4160 return p;
4161 }
4162 else if (p[2] == '\\')
4163 {
4164 *end = p + 4; /* Hopefully 'operator->\*' */
4165 return p;
4166 }
4167 else
4168 {
4169 *end = p + 2; /* 'operator->' */
4170 return p;
4171 }
4172 }
4173 if (p[1] == '=' || p[1] == p[0])
4174 *end = p + 2;
4175 else
4176 *end = p + 1;
4177 return p;
4178 case '~':
4179 case ',':
4180 *end = p + 1;
4181 return p;
4182 case '(':
4183 if (p[1] != ')')
4184 error (_("`operator ()' must be specified "
4185 "without whitespace in `()'"));
4186 *end = p + 2;
4187 return p;
4188 case '?':
4189 if (p[1] != ':')
4190 error (_("`operator ?:' must be specified "
4191 "without whitespace in `?:'"));
4192 *end = p + 2;
4193 return p;
4194 case '[':
4195 if (p[1] != ']')
4196 error (_("`operator []' must be specified "
4197 "without whitespace in `[]'"));
4198 *end = p + 2;
4199 return p;
4200 default:
4201 error (_("`operator %s' not supported"), p);
4202 break;
4203 }
4204
4205 *end = "";
4206 return *end;
4207}
4208
4209
4210/* See class declaration. */
4211
4213 const char *regexp)
4214 : m_match_type (match_type),
4215 m_regexp (regexp)
4216{
4217 /* Setup the compiled regular expression M_C_REGEXP based on M_REGEXP. */
4218 if (m_regexp != nullptr && *m_regexp != '\0')
4219 {
4220 gdb_assert (m_regexp != nullptr);
4221
4222 int cflags = REG_NOSUB;
4223#ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
4224 cflags |= REG_ICASE;
4225#endif
4226 m_c_regexp.emplace (m_regexp, cflags, _("Invalid regexp"));
4227 }
4228}
4229
4230/* See class declaration. */
4231
4232bool
4233info_sources_filter::matches (const char *fullname) const
4234{
4235 /* Does it match regexp? */
4236 if (m_c_regexp.has_value ())
4237 {
4238 const char *to_match;
4239 std::string dirname;
4240
4241 switch (m_match_type)
4242 {
4243 case match_on::DIRNAME:
4244 dirname = ldirname (fullname);
4245 to_match = dirname.c_str ();
4246 break;
4247 case match_on::BASENAME:
4248 to_match = lbasename (fullname);
4249 break;
4250 case match_on::FULLNAME:
4251 to_match = fullname;
4252 break;
4253 default:
4254 gdb_assert_not_reached ("bad m_match_type");
4255 }
4256
4257 if (m_c_regexp->exec (to_match, 0, NULL, 0) != 0)
4258 return false;
4259 }
4260
4261 return true;
4262}
4263
4264/* Data structure to maintain the state used for printing the results of
4265 the 'info sources' command. */
4266
4268{
4269 /* Create an object for displaying the results of the 'info sources'
4270 command to UIOUT. FILTER must remain valid and unchanged for the
4271 lifetime of this object as this object retains a reference to FILTER. */
4273 const info_sources_filter &filter)
4274 : m_filter (filter),
4275 m_uiout (uiout)
4276 { /* Nothing. */ }
4277
4279
4280 /* Reset enough state of this object so we can match against a new set of
4281 files. The existing regular expression is retained though. */
4283 {
4284 m_first = true;
4286 }
4287
4288 /* Worker for sources_info, outputs the file name formatted for either
4289 cli or mi (based on the current_uiout). In cli mode displays
4290 FULLNAME with a comma separating this name from any previously
4291 printed name (line breaks are added at the comma). In MI mode
4292 outputs a tuple containing DISP_NAME (the files display name),
4293 FULLNAME, and EXPANDED_P (true when this file is from a fully
4294 expanded symtab, otherwise false). */
4295 void output (const char *disp_name, const char *fullname, bool expanded_p);
4296
4297 /* An overload suitable for use as a callback to
4298 quick_symbol_functions::map_symbol_filenames. */
4299 void operator() (const char *filename, const char *fullname)
4300 {
4301 /* The false here indicates that this file is from an unexpanded
4302 symtab. */
4303 output (filename, fullname, false);
4304 }
4305
4306 /* Return true if at least one filename has been printed (after a call to
4307 output) since either this object was created, or the last call to
4308 reset_output. */
4310 {
4311 return !m_first;
4312 }
4313
4314private:
4315
4316 /* Flag of whether we're printing the first one. */
4317 bool m_first = true;
4318
4319 /* Cache of what we've seen so far. */
4321
4322 /* How source filename should be filtered. */
4324
4325 /* The object to which output is sent. */
4327};
4328
4329/* See comment in class declaration above. */
4330
4331void
4333 const char *fullname,
4334 bool expanded_p)
4335{
4336 /* Since a single source file can result in several partial symbol
4337 tables, we need to avoid printing it more than once. Note: if
4338 some of the psymtabs are read in and some are not, it gets
4339 printed both under "Source files for which symbols have been
4340 read" and "Source files for which symbols will be read in on
4341 demand". I consider this a reasonable way to deal with the
4342 situation. I'm not sure whether this can also happen for
4343 symtabs; it doesn't hurt to check. */
4344
4345 /* Was NAME already seen? If so, then don't print it again. */
4346 if (m_filename_seen_cache.seen (fullname))
4347 return;
4348
4349 /* If the filter rejects this file then don't print it. */
4350 if (!m_filter.matches (fullname))
4351 return;
4352
4353 ui_out_emit_tuple ui_emitter (m_uiout, nullptr);
4354
4355 /* Print it and reset *FIRST. */
4356 if (!m_first)
4357 m_uiout->text (", ");
4358 m_first = false;
4359
4360 m_uiout->wrap_hint (0);
4361 if (m_uiout->is_mi_like_p ())
4362 {
4363 m_uiout->field_string ("file", disp_name, file_name_style.style ());
4364 if (fullname != nullptr)
4365 m_uiout->field_string ("fullname", fullname,
4367 m_uiout->field_string ("debug-fully-read",
4368 (expanded_p ? "true" : "false"));
4369 }
4370 else
4371 {
4372 if (fullname == nullptr)
4373 fullname = disp_name;
4374 m_uiout->field_string ("fullname", fullname,
4376 }
4377}
4378
4379/* For the 'info sources' command, what part of the file names should we be
4380 matching the user supplied regular expression against? */
4381
4383{
4384 /* Only match the directory name part. */
4385 bool dirname = false;
4386
4387 /* Only match the basename part. */
4388 bool basename = false;
4389};
4390
4393
4395
4397 "dirname",
4398 [] (filename_partial_match_opts *opts) { return &opts->dirname; },
4399 N_("Show only the files having a dirname matching REGEXP."),
4400 },
4401
4403 "basename",
4404 [] (filename_partial_match_opts *opts) { return &opts->basename; },
4405 N_("Show only the files having a basename matching REGEXP."),
4406 },
4407
4408};
4409
4410/* Create an option_def_group for the "info sources" options, with
4411 ISRC_OPTS as context. */
4412
4415{
4416 return {{info_sources_option_defs}, isrc_opts};
4417}
4418
4419/* Completer for "info sources". */
4420
4421static void
4423 completion_tracker &tracker,
4424 const char *text, const char *word)
4425{
4426 const auto group = make_info_sources_options_def_group (nullptr);
4428 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
4429 return;
4430}
4431
4432/* See symtab.h. */
4433
4434void
4436 bool group_by_objfile,
4437 const info_sources_filter &filter)
4438{
4439 output_source_filename_data data (uiout, filter);
4440
4441 ui_out_emit_list results_emitter (uiout, "files");
4442 gdb::optional<ui_out_emit_tuple> output_tuple;
4443 gdb::optional<ui_out_emit_list> sources_list;
4444
4445 gdb_assert (group_by_objfile || uiout->is_mi_like_p ());
4446
4448 {
4449 if (group_by_objfile)
4450 {
4451 output_tuple.emplace (uiout, nullptr);
4452 uiout->field_string ("filename", objfile_name (objfile),
4454 uiout->text (":\n");
4455 bool debug_fully_readin = !objfile->has_unexpanded_symtabs ();
4456 if (uiout->is_mi_like_p ())
4457 {
4458 const char *debug_info_state;
4460 {
4461 if (debug_fully_readin)
4462 debug_info_state = "fully-read";
4463 else
4464 debug_info_state = "partially-read";
4465 }
4466 else
4467 debug_info_state = "none";
4468 current_uiout->field_string ("debug-info", debug_info_state);
4469 }
4470 else
4471 {
4472 if (!debug_fully_readin)
4473 uiout->text ("(Full debug information has not yet been read "
4474 "for this file.)\n");
4476 uiout->text ("(Objfile has no debug information.)\n");
4477 uiout->text ("\n");
4478 }
4479 sources_list.emplace (uiout, "sources");
4480 }
4481
4482 for (compunit_symtab *cu : objfile->compunits ())
4483 {
4484 for (symtab *s : cu->filetabs ())
4485 {
4486 const char *file = symtab_to_filename_for_display (s);
4487 const char *fullname = symtab_to_fullname (s);
4488 data.output (file, fullname, true);
4489 }
4490 }
4491
4492 if (group_by_objfile)
4493 {
4494 objfile->map_symbol_filenames (data, true /* need_fullname */);
4495 if (data.printed_filename_p ())
4496 uiout->text ("\n\n");
4497 data.reset_output ();
4498 sources_list.reset ();
4499 output_tuple.reset ();
4500 }
4501 }
4502
4503 if (!group_by_objfile)
4504 {
4505 data.reset_output ();
4506 map_symbol_filenames (data, true /*need_fullname*/);
4507 }
4508}
4509
4510/* Implement the 'info sources' command. */
4511
4512static void
4513info_sources_command (const char *args, int from_tty)
4514{
4516 error (_("No symbol table is loaded. Use the \"file\" command."));
4517
4518 filename_partial_match_opts match_opts;
4519 auto group = make_info_sources_options_def_group (&match_opts);
4522
4523 if (match_opts.dirname && match_opts.basename)
4524 error (_("You cannot give both -basename and -dirname to 'info sources'."));
4525
4526 const char *regex = nullptr;
4527 if (args != NULL && *args != '\000')
4528 regex = args;
4529
4530 if ((match_opts.dirname || match_opts.basename) && regex == nullptr)
4531 error (_("Missing REGEXP for 'info sources'."));
4532
4534 if (match_opts.dirname)
4536 else if (match_opts.basename)
4538 else
4540
4541 info_sources_filter filter (match_type, regex);
4542 info_sources_worker (current_uiout, true, filter);
4543}
4544
4545/* Compare FILE against all the entries of FILENAMES. If BASENAMES is
4546 true compare only lbasename of FILENAMES. */
4547
4548static bool
4549file_matches (const char *file, const std::vector<const char *> &filenames,
4550 bool basenames)
4551{
4552 if (filenames.empty ())
4553 return true;
4554
4555 for (const char *name : filenames)
4556 {
4557 name = (basenames ? lbasename (name) : name);
4559 return true;
4560 }
4561
4562 return false;
4563}
4564
4565/* Helper function for std::sort on symbol_search objects. Can only sort
4566 symbols, not minimal symbols. */
4567
4568int
4570 const symbol_search &sym_b)
4571{
4572 int c;
4573
4574 c = FILENAME_CMP (sym_a.symbol->symtab ()->filename,
4575 sym_b.symbol->symtab ()->filename);
4576 if (c != 0)
4577 return c;
4578
4579 if (sym_a.block != sym_b.block)
4580 return sym_a.block - sym_b.block;
4581
4582 return strcmp (sym_a.symbol->print_name (), sym_b.symbol->print_name ());
4583}
4584
4585/* Returns true if the type_name of symbol_type of SYM matches TREG.
4586 If SYM has no symbol_type or symbol_name, returns false. */
4587
4588bool
4589treg_matches_sym_type_name (const compiled_regex &treg,
4590 const struct symbol *sym)
4591{
4592 struct type *sym_type;
4593 std::string printed_sym_type_name;
4594
4595 symbol_lookup_debug_printf_v ("treg_matches_sym_type_name, sym %s",
4596 sym->natural_name ());
4597
4598 sym_type = sym->type ();
4599 if (sym_type == NULL)
4600 return false;
4601
4602 {
4604
4605 printed_sym_type_name = type_to_string (sym_type);
4606 }
4607
4608 symbol_lookup_debug_printf_v ("sym_type_name %s",
4609 printed_sym_type_name.c_str ());
4610
4611 if (printed_sym_type_name.empty ())
4612 return false;
4613
4614 return treg.exec (printed_sym_type_name.c_str (), 0, NULL, 0) == 0;
4615}
4616
4617/* See symtab.h. */
4618
4619bool
4621 (const enum search_domain kind, const minimal_symbol *msymbol)
4622{
4623 switch (msymbol->type ())
4624 {
4625 case mst_data:
4626 case mst_bss:
4627 case mst_file_data:
4628 case mst_file_bss:
4629 return kind == VARIABLES_DOMAIN;
4630 case mst_text:
4631 case mst_file_text:
4633 case mst_text_gnu_ifunc:
4634 return kind == FUNCTIONS_DOMAIN;
4635 default:
4636 return false;
4637 }
4638}
4639
4640/* See symtab.h. */
4641
4642bool
4644 (objfile *objfile, const gdb::optional<compiled_regex> &preg) const
4645{
4646 enum search_domain kind = m_kind;
4647 bool found_msymbol = false;
4648
4649 auto do_file_match = [&] (const char *filename, bool basenames)
4650 {
4651 return file_matches (filename, filenames, basenames);
4652 };
4653 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher = nullptr;
4654 if (!filenames.empty ())
4655 file_matcher = do_file_match;
4656
4658 (file_matcher,
4660 [&] (const char *symname)
4661 {
4662 return (!preg.has_value ()
4663 || preg->exec (symname, 0, NULL, 0) == 0);
4664 },
4665 NULL,
4668 kind);
4669
4670 /* Here, we search through the minimal symbol tables for functions and
4671 variables that match, and force their symbols to be read. This is in
4672 particular necessary for demangled variable names, which are no longer
4673 put into the partial symbol tables. The symbol will then be found
4674 during the scan of symtabs later.
4675
4676 For functions, find_pc_symtab should succeed if we have debug info for
4677 the function, for variables we have to call
4678 lookup_symbol_in_objfile_from_linkage_name to determine if the
4679 variable has debug info. If the lookup fails, set found_msymbol so
4680 that we will rescan to print any matching symbols without debug info.
4681 We only search the objfile the msymbol came from, we no longer search
4682 all objfiles. In large programs (1000s of shared libs) searching all
4683 objfiles is not worth the pain. */
4684 if (filenames.empty ()
4685 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
4686 {
4687 for (minimal_symbol *msymbol : objfile->msymbols ())
4688 {
4689 QUIT;
4690
4691 if (msymbol->created_by_gdb)
4692 continue;
4693
4694 if (is_suitable_msymbol (kind, msymbol))
4695 {
4696 if (!preg.has_value ()
4697 || preg->exec (msymbol->natural_name (), 0,
4698 NULL, 0) == 0)
4699 {
4700 /* An important side-effect of these lookup functions is
4701 to expand the symbol table if msymbol is found, later
4702 in the process we will add matching symbols or
4703 msymbols to the results list, and that requires that
4704 the symbols tables are expanded. */
4705 if (kind == FUNCTIONS_DOMAIN
4707 (msymbol->value_address (objfile)) == NULL)
4709 (objfile, msymbol->linkage_name (),
4710 VAR_DOMAIN)
4711 .symbol == NULL))
4712 found_msymbol = true;
4713 }
4714 }
4715 }
4716 }
4717
4718 return found_msymbol;
4719}
4720
4721/* See symtab.h. */
4722
4723bool
4725 (objfile *objfile,
4726 const gdb::optional<compiled_regex> &preg,
4727 const gdb::optional<compiled_regex> &treg,
4728 std::set<symbol_search> *result_set) const
4729{
4730 enum search_domain kind = m_kind;
4731
4732 /* Add matching symbols (if not already present). */
4733 for (compunit_symtab *cust : objfile->compunits ())
4734 {
4735 const struct blockvector *bv = cust->blockvector ();
4736
4738 {
4739 struct block_iterator iter;
4740 struct symbol *sym;
4741 const struct block *b = bv->block (block);
4742
4743 ALL_BLOCK_SYMBOLS (b, iter, sym)
4744 {
4745 struct symtab *real_symtab = sym->symtab ();
4746
4747 QUIT;
4748
4749 /* Check first sole REAL_SYMTAB->FILENAME. It does
4750 not need to be a substring of symtab_to_fullname as
4751 it may contain "./" etc. */
4752 if ((file_matches (real_symtab->filename, filenames, false)
4754 || file_matches (lbasename (real_symtab->filename),
4755 filenames, true))
4756 && file_matches (symtab_to_fullname (real_symtab),
4757 filenames, false)))
4758 && ((!preg.has_value ()
4759 || preg->exec (sym->natural_name (), 0,
4760 NULL, 0) == 0)
4761 && ((kind == VARIABLES_DOMAIN
4762 && sym->aclass () != LOC_TYPEDEF
4763 && sym->aclass () != LOC_UNRESOLVED
4764 && sym->aclass () != LOC_BLOCK
4765 /* LOC_CONST can be used for more than
4766 just enums, e.g., c++ static const
4767 members. We only want to skip enums
4768 here. */
4769 && !(sym->aclass () == LOC_CONST
4770 && (sym->type ()->code ()
4771 == TYPE_CODE_ENUM))
4772 && (!treg.has_value ()
4773 || treg_matches_sym_type_name (*treg, sym)))
4774 || (kind == FUNCTIONS_DOMAIN
4775 && sym->aclass () == LOC_BLOCK
4776 && (!treg.has_value ()
4778 sym)))
4779 || (kind == TYPES_DOMAIN
4780 && sym->aclass () == LOC_TYPEDEF
4781 && sym->domain () != MODULE_DOMAIN)
4782 || (kind == MODULES_DOMAIN
4783 && sym->domain () == MODULE_DOMAIN
4784 && sym->line () != 0))))
4785 {
4786 if (result_set->size () < m_max_search_results)
4787 {
4788 /* Match, insert if not already in the results. */
4789 symbol_search ss (block, sym);
4790 if (result_set->find (ss) == result_set->end ())
4791 result_set->insert (ss);
4792 }
4793 else
4794 return false;
4795 }
4796 }
4797 }
4798 }
4799
4800 return true;
4801}
4802
4803/* See symtab.h. */
4804
4805bool
4807 (objfile *objfile, const gdb::optional<compiled_regex> &preg,
4808 std::vector<symbol_search> *results) const
4809{
4810 enum search_domain kind = m_kind;
4811
4812 for (minimal_symbol *msymbol : objfile->msymbols ())
4813 {
4814 QUIT;
4815
4816 if (msymbol->created_by_gdb)
4817 continue;
4818
4819 if (is_suitable_msymbol (kind, msymbol))
4820 {
4821 if (!preg.has_value ()
4822 || preg->exec (msymbol->natural_name (), 0,
4823 NULL, 0) == 0)
4824 {
4825 /* For functions we can do a quick check of whether the
4826 symbol might be found via find_pc_symtab. */
4827 if (kind != FUNCTIONS_DOMAIN
4829 (msymbol->value_address (objfile)) == NULL))
4830 {
4832 (objfile, msymbol->linkage_name (),
4833 VAR_DOMAIN).symbol == NULL)
4834 {
4835 /* Matching msymbol, add it to the results list. */
4836 if (results->size () < m_max_search_results)
4837 results->emplace_back (GLOBAL_BLOCK, msymbol, objfile);
4838 else
4839 return false;
4840 }
4841 }
4842 }
4843 }
4844 }
4845
4846 return true;
4847}
4848
4849/* See symtab.h. */
4850
4851std::vector<symbol_search>
4853{
4854 gdb::optional<compiled_regex> preg;
4855 gdb::optional<compiled_regex> treg;
4856
4857 gdb_assert (m_kind != ALL_DOMAIN);
4858
4859 if (m_symbol_name_regexp != NULL)
4860 {
4861 const char *symbol_name_regexp = m_symbol_name_regexp;
4862 std::string symbol_name_regexp_holder;
4863
4864 /* Make sure spacing is right for C++ operators.
4865 This is just a courtesy to make the matching less sensitive
4866 to how many spaces the user leaves between 'operator'
4867 and <TYPENAME> or <OPERATOR>. */
4868 const char *opend;
4869 const char *opname = operator_chars (symbol_name_regexp, &opend);
4870
4871 if (*opname)
4872 {
4873 int fix = -1; /* -1 means ok; otherwise number of
4874 spaces needed. */
4875
4876 if (isalpha (*opname) || *opname == '_' || *opname == '$')
4877 {
4878 /* There should 1 space between 'operator' and 'TYPENAME'. */
4879 if (opname[-1] != ' ' || opname[-2] == ' ')
4880 fix = 1;
4881 }
4882 else
4883 {
4884 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4885 if (opname[-1] == ' ')
4886 fix = 0;
4887 }
4888 /* If wrong number of spaces, fix it. */
4889 if (fix >= 0)
4890 {
4891 symbol_name_regexp_holder
4892 = string_printf ("operator%.*s%s", fix, " ", opname);
4893 symbol_name_regexp = symbol_name_regexp_holder.c_str ();
4894 }
4895 }
4896
4897 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
4898 ? REG_ICASE : 0);
4899 preg.emplace (symbol_name_regexp, cflags,
4900 _("Invalid regexp"));
4901 }
4902
4903 if (m_symbol_type_regexp != NULL)
4904 {
4905 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
4906 ? REG_ICASE : 0);
4907 treg.emplace (m_symbol_type_regexp, cflags,
4908 _("Invalid regexp"));
4909 }
4910
4911 bool found_msymbol = false;
4912 std::set<symbol_search> result_set;
4914 {
4915 /* Expand symtabs within objfile that possibly contain matching
4916 symbols. */
4917 found_msymbol |= expand_symtabs (objfile, preg);
4918
4919 /* Find matching symbols within OBJFILE and add them in to the
4920 RESULT_SET set. Use a set here so that we can easily detect
4921 duplicates as we go, and can therefore track how many unique
4922 matches we have found so far. */
4923 if (!add_matching_symbols (objfile, preg, treg, &result_set))
4924 break;
4925 }
4926
4927 /* Convert the result set into a sorted result list, as std::set is
4928 defined to be sorted then no explicit call to std::sort is needed. */
4929 std::vector<symbol_search> result (result_set.begin (), result_set.end ());
4930
4931 /* If there are no debug symbols, then add matching minsyms. But if the
4932 user wants to see symbols matching a type regexp, then never give a
4933 minimal symbol, as we assume that a minimal symbol does not have a
4934 type. */
4935 if ((found_msymbol || (filenames.empty () && m_kind == VARIABLES_DOMAIN))
4937 && !treg.has_value ())
4938 {
4939 gdb_assert (m_kind == VARIABLES_DOMAIN || m_kind == FUNCTIONS_DOMAIN);
4941 if (!add_matching_msymbols (objfile, preg, &result))
4942 break;
4943 }
4944
4945 return result;
4946}
4947
4948/* See symtab.h. */
4949
4950std::string
4952 enum search_domain kind)
4953{
4954 std::string str;
4955
4956 gdb_assert (block == GLOBAL_BLOCK || block == STATIC_BLOCK);
4957
4958 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
4959 str += "static ";
4960
4961 /* Typedef that is not a C++ class. */
4962 if (kind == TYPES_DOMAIN
4963 && sym->domain () != STRUCT_DOMAIN)
4964 {
4965 string_file tmp_stream;
4966
4967 /* FIXME: For C (and C++) we end up with a difference in output here
4968 between how a typedef is printed, and non-typedefs are printed.
4969 The TYPEDEF_PRINT code places a ";" at the end in an attempt to
4970 appear C-like, while TYPE_PRINT doesn't.
4971
4972 For the struct printing case below, things are worse, we force
4973 printing of the ";" in this function, which is going to be wrong
4974 for languages that don't require a ";" between statements. */
4975 if (sym->type ()->code () == TYPE_CODE_TYPEDEF)
4976 typedef_print (sym->type (), sym, &tmp_stream);
4977 else
4978 type_print (sym->type (), "", &tmp_stream, -1);
4979 str += tmp_stream.string ();
4980 }
4981 /* variable, func, or typedef-that-is-c++-class. */
4982 else if (kind < TYPES_DOMAIN
4983 || (kind == TYPES_DOMAIN
4984 && sym->domain () == STRUCT_DOMAIN))
4985 {
4986 string_file tmp_stream;
4987
4988 type_print (sym->type (),
4989 (sym->aclass () == LOC_TYPEDEF
4990 ? "" : sym->print_name ()),
4991 &tmp_stream, 0);
4992
4993 str += tmp_stream.string ();
4994 str += ";";
4995 }
4996 /* Printing of modules is currently done here, maybe at some future
4997 point we might want a language specific method to print the module
4998 symbol so that we can customise the output more. */
4999 else if (kind == MODULES_DOMAIN)
5000 str += sym->print_name ();
5001
5002 return str;
5003}
5004
5005/* Helper function for symbol info commands, for example 'info functions',
5006 'info variables', etc. KIND is the kind of symbol we searched for, and
5007 BLOCK is the type of block the symbols was found in, either GLOBAL_BLOCK
5008 or STATIC_BLOCK. SYM is the symbol we found. If LAST is not NULL,
5009 print file and line number information for the symbol as well. Skip
5010 printing the filename if it matches LAST. */
5011
5012static void
5014 struct symbol *sym,
5015 int block, const char *last)
5016{
5018 struct symtab *s = sym->symtab ();
5019
5020 if (last != NULL)
5021 {
5022 const char *s_filename = symtab_to_filename_for_display (s);
5023
5024 if (filename_cmp (last, s_filename) != 0)
5025 {
5026 gdb_printf (_("\nFile %ps:\n"),
5028 s_filename));
5029 }
5030
5031 if (sym->line () != 0)
5032 gdb_printf ("%d:\t", sym->line ());
5033 else
5034 gdb_puts ("\t");
5035 }
5036
5037 std::string str = symbol_to_info_string (sym, block, kind);
5038 gdb_printf ("%s\n", str.c_str ());
5039}
5040
5041/* This help function for symtab_symbol_info() prints information
5042 for non-debugging symbols to gdb_stdout. */
5043
5044static void
5046{
5047 struct gdbarch *gdbarch = msymbol.objfile->arch ();
5048 char *tmp;
5049
5050 if (gdbarch_addr_bit (gdbarch) <= 32)
5051 tmp = hex_string_custom (msymbol.value_address ()
5052 & (CORE_ADDR) 0xffffffff,
5053 8);
5054 else
5055 tmp = hex_string_custom (msymbol.value_address (),
5056 16);
5057
5058 ui_file_style sym_style = (msymbol.minsym->text_p ()
5060 : ui_file_style ());
5061
5062 gdb_printf (_("%ps %ps\n"),
5064 styled_string (sym_style, msymbol.minsym->print_name ()));
5065}
5066
5067/* This is the guts of the commands "info functions", "info types", and
5068 "info variables". It calls search_symbols to find all matches and then
5069 print_[m]symbol_info to print out some useful information about the
5070 matches. */
5071
5072static void
5073symtab_symbol_info (bool quiet, bool exclude_minsyms,
5074 const char *regexp, enum search_domain kind,
5075 const char *t_regexp, int from_tty)
5076{
5077 static const char * const classnames[] =
5078 {"variable", "function", "type", "module"};
5079 const char *last_filename = "";
5080 int first = 1;
5081
5082 gdb_assert (kind != ALL_DOMAIN);
5083
5084 if (regexp != nullptr && *regexp == '\0')
5085 regexp = nullptr;
5086
5087 global_symbol_searcher spec (kind, regexp);
5088 spec.set_symbol_type_regexp (t_regexp);
5089 spec.set_exclude_minsyms (exclude_minsyms);
5090 std::vector<symbol_search> symbols = spec.search ();
5091
5092 if (!quiet)
5093 {
5094 if (regexp != NULL)
5095 {
5096 if (t_regexp != NULL)
5098 (_("All %ss matching regular expression \"%s\""
5099 " with type matching regular expression \"%s\":\n"),
5100 classnames[kind], regexp, t_regexp);
5101 else
5102 gdb_printf (_("All %ss matching regular expression \"%s\":\n"),
5103 classnames[kind], regexp);
5104 }
5105 else
5106 {
5107 if (t_regexp != NULL)
5109 (_("All defined %ss"
5110 " with type matching regular expression \"%s\" :\n"),
5111 classnames[kind], t_regexp);
5112 else
5113 gdb_printf (_("All defined %ss:\n"), classnames[kind]);
5114 }
5115 }
5116
5117 for (const symbol_search &p : symbols)
5118 {
5119 QUIT;
5120
5121 if (p.msymbol.minsym != NULL)
5122 {
5123 if (first)
5124 {
5125 if (!quiet)
5126 gdb_printf (_("\nNon-debugging symbols:\n"));
5127 first = 0;
5128 }
5129 print_msymbol_info (p.msymbol);
5130 }
5131 else
5132 {
5133 print_symbol_info (kind,
5134 p.symbol,
5135 p.block,
5136 last_filename);
5137 last_filename
5138 = symtab_to_filename_for_display (p.symbol->symtab ());
5139 }
5140 }
5141}
5142
5143/* Structure to hold the values of the options used by the 'info variables'
5144 and 'info functions' commands. These correspond to the -q, -t, and -n
5145 options. */
5146
5148{
5149 bool quiet = false;
5150 bool exclude_minsyms = false;
5151 std::string type_regexp;
5152};
5153
5154/* The options used by the 'info variables' and 'info functions'
5155 commands. */
5156
5159 "q",
5160 [] (info_vars_funcs_options *opt) { return &opt->quiet; },
5161 nullptr, /* show_cmd_cb */
5162 nullptr /* set_doc */
5163 },
5164
5166 "n",
5167 [] (info_vars_funcs_options *opt) { return &opt->exclude_minsyms; },
5168 nullptr, /* show_cmd_cb */
5169 nullptr /* set_doc */
5170 },
5171
5173 "t",
5174 [] (info_vars_funcs_options *opt) { return &opt->type_regexp; },
5175 nullptr, /* show_cmd_cb */
5176 nullptr /* set_doc */
5177 }
5178};
5179
5180/* Returns the option group used by 'info variables' and 'info
5181 functions'. */
5182
5185{
5186 return {{info_vars_funcs_options_defs}, opts};
5187}
5188
5189/* Command completer for 'info variables' and 'info functions'. */
5190
5191static void
5193 completion_tracker &tracker,
5194 const char *text, const char * /* word */)
5195{
5196 const auto group
5199 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
5200 return;
5201
5202 const char *word = advance_to_expression_complete_word_point (tracker, text);
5203 symbol_completer (ignore, tracker, text, word);
5204}
5205
5206/* Implement the 'info variables' command. */
5207
5208static void
5209info_variables_command (const char *args, int from_tty)
5210{
5212 auto grp = make_info_vars_funcs_options_def_group (&opts);
5215 if (args != nullptr && *args == '\0')
5216 args = nullptr;
5217
5219 (opts.quiet, opts.exclude_minsyms, args, VARIABLES_DOMAIN,
5220 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
5221 from_tty);
5222}
5223
5224/* Implement the 'info functions' command. */
5225
5226static void
5227info_functions_command (const char *args, int from_tty)
5228{
5230
5231 auto grp = make_info_vars_funcs_options_def_group (&opts);
5234 if (args != nullptr && *args == '\0')
5235 args = nullptr;
5236
5238 (opts.quiet, opts.exclude_minsyms, args, FUNCTIONS_DOMAIN,
5239 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
5240 from_tty);
5241}
5242
5243/* Holds the -q option for the 'info types' command. */
5244
5246{
5247 bool quiet = false;
5248};
5249
5250/* The options used by the 'info types' command. */
5251
5254 "q",
5255 [] (info_types_options *opt) { return &opt->quiet; },
5256 nullptr, /* show_cmd_cb */
5257 nullptr /* set_doc */
5258 }
5259};
5260
5261/* Returns the option group used by 'info types'. */
5262
5265{
5266 return {{info_types_options_defs}, opts};
5267}
5268
5269/* Implement the 'info types' command. */
5270
5271static void
5272info_types_command (const char *args, int from_tty)
5273{
5274 info_types_options opts;
5275
5276 auto grp = make_info_types_options_def_group (&opts);
5279 if (args != nullptr && *args == '\0')
5280 args = nullptr;
5281 symtab_symbol_info (opts.quiet, false, args, TYPES_DOMAIN, NULL, from_tty);
5282}
5283
5284/* Command completer for 'info types' command. */
5285
5286static void
5288 completion_tracker &tracker,
5289 const char *text, const char * /* word */)
5290{
5291 const auto group
5294 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
5295 return;
5296
5297 const char *word = advance_to_expression_complete_word_point (tracker, text);
5298 symbol_completer (ignore, tracker, text, word);
5299}
5300
5301/* Implement the 'info modules' command. */
5302
5303static void
5304info_modules_command (const char *args, int from_tty)
5305{
5306 info_types_options opts;
5307
5308 auto grp = make_info_types_options_def_group (&opts);
5311 if (args != nullptr && *args == '\0')
5312 args = nullptr;
5313 symtab_symbol_info (opts.quiet, true, args, MODULES_DOMAIN, NULL,
5314 from_tty);
5315}
5316
5317static void
5318rbreak_command (const char *regexp, int from_tty)
5319{
5320 std::string string;
5321 const char *file_name = nullptr;
5322
5323 if (regexp != nullptr)
5324 {
5325 const char *colon = strchr (regexp, ':');
5326
5327 /* Ignore the colon if it is part of a Windows drive. */
5328 if (HAS_DRIVE_SPEC (regexp)
5329 && (regexp[2] == '/' || regexp[2] == '\\'))
5330 colon = strchr (STRIP_DRIVE_SPEC (regexp), ':');
5331
5332 if (colon && *(colon + 1) != ':')
5333 {
5334 int colon_index;
5335 char *local_name;
5336
5337 colon_index = colon - regexp;
5338 local_name = (char *) alloca (colon_index + 1);
5339 memcpy (local_name, regexp, colon_index);
5340 local_name[colon_index--] = 0;
5341 while (isspace (local_name[colon_index]))
5342 local_name[colon_index--] = 0;
5343 file_name = local_name;
5344 regexp = skip_spaces (colon + 1);
5345 }
5346 }
5347
5349 if (file_name != nullptr)
5350 spec.filenames.push_back (file_name);
5351 std::vector<symbol_search> symbols = spec.search ();
5352
5354 for (const symbol_search &p : symbols)
5355 {
5356 if (p.msymbol.minsym == NULL)
5357 {
5358 struct symtab *symtab = p.symbol->symtab ();
5359 const char *fullname = symtab_to_fullname (symtab);
5360
5361 string = string_printf ("%s:'%s'", fullname,
5362 p.symbol->linkage_name ());
5363 break_command (&string[0], from_tty);
5364 print_symbol_info (FUNCTIONS_DOMAIN, p.symbol, p.block, NULL);
5365 }
5366 else
5367 {
5368 string = string_printf ("'%s'",
5369 p.msymbol.minsym->linkage_name ());
5370
5371 break_command (&string[0], from_tty);
5372 gdb_printf ("<function, no debug info> %s;\n",
5373 p.msymbol.minsym->print_name ());
5374 }
5375 }
5376}
5377
5378
5379/* Evaluate if SYMNAME matches LOOKUP_NAME. */
5380
5381static int
5382compare_symbol_name (const char *symbol_name, language symbol_language,
5383 const lookup_name_info &lookup_name,
5384 completion_match_result &match_res)
5385{
5386 const language_defn *lang = language_def (symbol_language);
5387
5388 symbol_name_matcher_ftype *name_match
5389 = lang->get_symbol_name_matcher (lookup_name);
5390
5391 return name_match (symbol_name, lookup_name, &match_res);
5392}
5393
5394/* See symtab.h. */
5395
5396bool
5398 language symbol_language,
5399 const char *symname,
5400 const lookup_name_info &lookup_name,
5401 const char *text, const char *word)
5402{
5403 completion_match_result &match_res
5404 = tracker.reset_completion_match_result ();
5405
5406 /* Clip symbols that cannot match. */
5407 if (!compare_symbol_name (symname, symbol_language, lookup_name, match_res))
5408 return false;
5409
5410 /* Refresh SYMNAME from the match string. It's potentially
5411 different depending on language. (E.g., on Ada, the match may be
5412 the encoded symbol name wrapped in "<>"). */
5413 symname = match_res.match.match ();
5414 gdb_assert (symname != NULL);
5415
5416 /* We have a match for a completion, so add SYMNAME to the current list
5417 of matches. Note that the name is moved to freshly malloc'd space. */
5418
5419 {
5420 gdb::unique_xmalloc_ptr<char> completion
5421 = make_completion_match_str (symname, text, word);
5422
5423 /* Here we pass the match-for-lcd object to add_completion. Some
5424 languages match the user text against substrings of symbol
5425 names in some cases. E.g., in C++, "b push_ba" completes to
5426 "std::vector::push_back", "std::string::push_back", etc., and
5427 in this case we want the completion lowest common denominator
5428 to be "push_back" instead of "std::". */
5429 tracker.add_completion (std::move (completion),
5430 &match_res.match_for_lcd, text, word);
5431 }
5432
5433 return true;
5434}
5435
5436/* completion_list_add_name wrapper for struct symbol. */
5437
5438static void
5440 symbol *sym,
5441 const lookup_name_info &lookup_name,
5442 const char *text, const char *word)
5443{
5444 if (!completion_list_add_name (tracker, sym->language (),
5445 sym->natural_name (),
5446 lookup_name, text, word))
5447 return;
5448
5449 /* C++ function symbols include the parameters within both the msymbol
5450 name and the symbol name. The problem is that the msymbol name will
5451 describe the parameters in the most basic way, with typedefs stripped
5452 out, while the symbol name will represent the types as they appear in
5453 the program. This means we will see duplicate entries in the
5454 completion tracker. The following converts the symbol name back to
5455 the msymbol name and removes the msymbol name from the completion
5456 tracker. */
5457 if (sym->language () == language_cplus
5458 && sym->domain () == VAR_DOMAIN
5459 && sym->aclass () == LOC_BLOCK)
5460 {
5461 /* The call to canonicalize returns the empty string if the input
5462 string is already in canonical form, thanks to this we don't
5463 remove the symbol we just added above. */
5464 gdb::unique_xmalloc_ptr<char> str
5466 if (str != nullptr)
5467 tracker.remove_completion (str.get ());
5468 }
5469}
5470
5471/* completion_list_add_name wrapper for struct minimal_symbol. */
5472
5473static void
5475 minimal_symbol *sym,
5476 const lookup_name_info &lookup_name,
5477 const char *text, const char *word)
5478{
5479 completion_list_add_name (tracker, sym->language (),
5480 sym->natural_name (),
5481 lookup_name, text, word);
5482}
5483
5484
5485/* ObjC: In case we are completing on a selector, look as the msymbol
5486 again and feed all the selectors into the mill. */
5487
5488static void
5490 struct minimal_symbol *msymbol,
5491 const lookup_name_info &lookup_name,
5492 const char *text, const char *word)
5493{
5494 static char *tmp = NULL;
5495 static unsigned int tmplen = 0;
5496
5497 const char *method, *category, *selector;
5498 char *tmp2 = NULL;
5499
5500 method = msymbol->natural_name ();
5501
5502 /* Is it a method? */
5503 if ((method[0] != '-') && (method[0] != '+'))
5504 return;
5505
5506 if (text[0] == '[')
5507 /* Complete on shortened method method. */
5509 method + 1,
5510 lookup_name,
5511 text, word);
5512
5513 while ((strlen (method) + 1) >= tmplen)
5514 {
5515 if (tmplen == 0)
5516 tmplen = 1024;
5517 else
5518 tmplen *= 2;
5519 tmp = (char *) xrealloc (tmp, tmplen);
5520 }
5521 selector = strchr (method, ' ');
5522 if (selector != NULL)
5523 selector++;
5524
5525 category = strchr (method, '(');
5526
5527 if ((category != NULL) && (selector != NULL))
5528 {
5529 memcpy (tmp, method, (category - method));
5530 tmp[category - method] = ' ';
5531 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
5533 lookup_name, text, word);
5534 if (text[0] == '[')
5535 completion_list_add_name (tracker, language_objc, tmp + 1,
5536 lookup_name, text, word);
5537 }
5538
5539 if (selector != NULL)
5540 {
5541 /* Complete on selector only. */
5542 strcpy (tmp, selector);
5543 tmp2 = strchr (tmp, ']');
5544 if (tmp2 != NULL)
5545 *tmp2 = '\0';
5546
5548 lookup_name, text, word);
5549 }
5550}
5551
5552/* Break the non-quoted text based on the characters which are in
5553 symbols. FIXME: This should probably be language-specific. */
5554
5555static const char *
5556language_search_unquoted_string (const char *text, const char *p)
5557{
5558 for (; p > text; --p)
5559 {
5560 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
5561 continue;
5562 else
5563 {
5565 {
5566 if (p[-1] == ':') /* Might be part of a method name. */
5567 continue;
5568 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
5569 p -= 2; /* Beginning of a method name. */
5570 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
5571 { /* Might be part of a method name. */
5572 const char *t = p;
5573
5574 /* Seeing a ' ' or a '(' is not conclusive evidence
5575 that we are in the middle of a method name. However,
5576 finding "-[" or "+[" should be pretty un-ambiguous.
5577 Unfortunately we have to find it now to decide. */
5578
5579 while (t > text)
5580 if (isalnum (t[-1]) || t[-1] == '_' ||
5581 t[-1] == ' ' || t[-1] == ':' ||
5582 t[-1] == '(' || t[-1] == ')')
5583 --t;
5584 else
5585 break;
5586
5587 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
5588 p = t - 2; /* Method name detected. */
5589 /* Else we leave with p unchanged. */
5590 }
5591 }
5592 break;
5593 }
5594 }
5595 return p;
5596}
5597
5598static void
5600 struct symbol *sym,
5601 const lookup_name_info &lookup_name,
5602 const char *text, const char *word)
5603{
5604 if (sym->aclass () == LOC_TYPEDEF)
5605 {
5606 struct type *t = sym->type ();
5607 enum type_code c = t->code ();
5608 int j;
5609
5610 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
5611 for (j = TYPE_N_BASECLASSES (t); j < t->num_fields (); j++)
5612 if (t->field (j).name ())
5613 completion_list_add_name (tracker, sym->language (),
5614 t->field (j).name (),
5615 lookup_name, text, word);
5616 }
5617}
5618
5619/* See symtab.h. */
5620
5621bool
5623{
5624 switch (sym->type ()->code ())
5625 {
5626 case TYPE_CODE_FUNC:
5627 case TYPE_CODE_METHOD:
5628 return true;
5629 default:
5630 return false;
5631 }
5632}
5633
5634/* See symtab.h. */
5635
5636bool
5638{
5639 switch (msymbol->type ())
5640 {
5641 case mst_text:
5642 case mst_text_gnu_ifunc:
5644 case mst_file_text:
5645 return true;
5646 default:
5647 return false;
5648 }
5649}
5650
5651/* See symtab.h. */
5652
5655{
5656 if (sym->aclass () != LOC_BLOCK)
5657 return {};
5658
5659 lookup_name_info lookup_name (sym->search_name (),
5661 struct objfile *objfile = sym->objfile ();
5662
5663 CORE_ADDR address = sym->value_block ()->entry_pc ();
5664 minimal_symbol *ifunc = NULL;
5665
5667 [&] (minimal_symbol *minsym)
5668 {
5669 if (minsym->type () == mst_text_gnu_ifunc
5670 || minsym->type () == mst_data_gnu_ifunc)
5671 {
5672 CORE_ADDR msym_addr = minsym->value_address (objfile);
5673 if (minsym->type () == mst_data_gnu_ifunc)
5674 {
5675 struct gdbarch *gdbarch = objfile->arch ();
5676 msym_addr = gdbarch_convert_from_func_ptr_addr
5677 (gdbarch, msym_addr, current_inferior ()->top_target ());
5678 }
5679 if (msym_addr == address)
5680 {
5681 ifunc = minsym;
5682 return true;
5683 }
5684 }
5685 return false;
5686 });
5687
5688 if (ifunc != NULL)
5689 return {ifunc, objfile};
5690 return {};
5691}
5692
5693/* Add matching symbols from SYMTAB to the current completion list. */
5694
5695static void
5697 completion_tracker &tracker,
5699 const lookup_name_info &lookup_name,
5700 const char *text, const char *word,
5701 enum type_code code)
5702{
5703 struct symbol *sym;
5704 struct block_iterator iter;
5705 int i;
5706
5707 if (cust == NULL)
5708 return;
5709
5710 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
5711 {
5712 QUIT;
5713
5714 const struct block *b = cust->blockvector ()->block (i);
5715 ALL_BLOCK_SYMBOLS (b, iter, sym)
5716 {
5717 if (completion_skip_symbol (mode, sym))
5718 continue;
5719
5720 if (code == TYPE_CODE_UNDEF
5721 || (sym->domain () == STRUCT_DOMAIN
5722 && sym->type ()->code () == code))
5723 completion_list_add_symbol (tracker, sym,
5724 lookup_name,
5725 text, word);
5726 }
5727 }
5728}
5729
5730void
5733 symbol_name_match_type name_match_type,
5734 const char *text, const char *word,
5735 const char *break_on, enum type_code code)
5736{
5737 /* Problem: All of the symbols have to be copied because readline
5738 frees them. I'm not going to worry about this; hopefully there
5739 won't be that many. */
5740
5741 struct symbol *sym;
5742 const struct block *b;
5743 const struct block *surrounding_static_block, *surrounding_global_block;
5744 struct block_iterator iter;
5745 /* The symbol we are completing on. Points in same buffer as text. */
5746 const char *sym_text;
5747
5748 /* Now look for the symbol we are supposed to complete on. */
5750 sym_text = text;
5751 else
5752 {
5753 const char *p;
5754 char quote_found;
5755 const char *quote_pos = NULL;
5756
5757 /* First see if this is a quoted string. */
5758 quote_found = '\0';
5759 for (p = text; *p != '\0'; ++p)
5760 {
5761 if (quote_found != '\0')
5762 {
5763 if (*p == quote_found)
5764 /* Found close quote. */
5765 quote_found = '\0';
5766 else if (*p == '\\' && p[1] == quote_found)
5767 /* A backslash followed by the quote character
5768 doesn't end the string. */
5769 ++p;
5770 }
5771 else if (*p == '\'' || *p == '"')
5772 {
5773 quote_found = *p;
5774 quote_pos = p;
5775 }
5776 }
5777 if (quote_found == '\'')
5778 /* A string within single quotes can be a symbol, so complete on it. */
5779 sym_text = quote_pos + 1;
5780 else if (quote_found == '"')
5781 /* A double-quoted string is never a symbol, nor does it make sense
5782 to complete it any other way. */
5783 {
5784 return;
5785 }
5786 else
5787 {
5788 /* It is not a quoted string. Break it based on the characters
5789 which are in symbols. */
5790 while (p > text)
5791 {
5792 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
5793 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
5794 --p;
5795 else
5796 break;
5797 }
5798 sym_text = p;
5799 }
5800 }
5801
5802 lookup_name_info lookup_name (sym_text, name_match_type, true);
5803
5804 /* At this point scan through the misc symbol vectors and add each
5805 symbol you find to the list. Eventually we want to ignore
5806 anything that isn't a text symbol (everything else will be
5807 handled by the psymtab code below). */
5808
5809 if (code == TYPE_CODE_UNDEF)
5810 {
5812 {
5813 for (minimal_symbol *msymbol : objfile->msymbols ())
5814 {
5815 QUIT;
5816
5817 if (completion_skip_symbol (mode, msymbol))
5818 continue;
5819
5820 completion_list_add_msymbol (tracker, msymbol, lookup_name,
5821 sym_text, word);
5822
5823 completion_list_objc_symbol (tracker, msymbol, lookup_name,
5824 sym_text, word);
5825 }
5826 }
5827 }
5828
5829 /* Add completions for all currently loaded symbol tables. */
5831 {
5832 for (compunit_symtab *cust : objfile->compunits ())
5833 add_symtab_completions (cust, tracker, mode, lookup_name,
5834 sym_text, word, code);
5835 }
5836
5837 /* Look through the partial symtabs for all symbols which begin by
5838 matching SYM_TEXT. Expand all CUs that you find to the list. */
5840 lookup_name,
5841 NULL,
5842 [&] (compunit_symtab *symtab) /* expansion notify */
5843 {
5845 tracker, mode, lookup_name,
5846 sym_text, word, code);
5847 return true;
5848 },
5850 ALL_DOMAIN);
5851
5852 /* Search upwards from currently selected frame (so that we can
5853 complete on local vars). Also catch fields of types defined in
5854 this places which match our text string. Only complete on types
5855 visible from current context. */
5856
5857 b = get_selected_block (0);
5858 surrounding_static_block = block_static_block (b);
5859 surrounding_global_block = block_global_block (b);
5860 if (surrounding_static_block != NULL)
5861 while (b != surrounding_static_block)
5862 {
5863 QUIT;
5864
5865 ALL_BLOCK_SYMBOLS (b, iter, sym)
5866 {
5867 if (code == TYPE_CODE_UNDEF)
5868 {
5869 completion_list_add_symbol (tracker, sym, lookup_name,
5870 sym_text, word);
5871 completion_list_add_fields (tracker, sym, lookup_name,
5872 sym_text, word);
5873 }
5874 else if (sym->domain () == STRUCT_DOMAIN
5875 && sym->type ()->code () == code)
5876 completion_list_add_symbol (tracker, sym, lookup_name,
5877 sym_text, word);
5878 }
5879
5880 /* Stop when we encounter an enclosing function. Do not stop for
5881 non-inlined functions - the locals of the enclosing function
5882 are in scope for a nested function. */
5883 if (b->function () != NULL && block_inlined_p (b))
5884 break;
5885 b = b->superblock ();
5886 }
5887
5888 /* Add fields from the file's types; symbols will be added below. */
5889
5890 if (code == TYPE_CODE_UNDEF)
5891 {
5892 if (surrounding_static_block != NULL)
5893 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
5894 completion_list_add_fields (tracker, sym, lookup_name,
5895 sym_text, word);
5896
5897 if (surrounding_global_block != NULL)
5898 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
5899 completion_list_add_fields (tracker, sym, lookup_name,
5900 sym_text, word);
5901 }
5902
5903 /* Skip macros if we are completing a struct tag -- arguable but
5904 usually what is expected. */
5906 && code == TYPE_CODE_UNDEF)
5907 {
5908 gdb::unique_xmalloc_ptr<struct macro_scope> scope;
5909
5910 /* This adds a macro's name to the current completion list. */
5911 auto add_macro_name = [&] (const char *macro_name,
5912 const macro_definition *,
5914 int)
5915 {
5916 completion_list_add_name (tracker, language_c, macro_name,
5917 lookup_name, sym_text, word);
5918 };
5919
5920 /* Add any macros visible in the default scope. Note that this
5921 may yield the occasional wrong result, because an expression
5922 might be evaluated in a scope other than the default. For
5923 example, if the user types "break file:line if <TAB>", the
5924 resulting expression will be evaluated at "file:line" -- but
5925 at there does not seem to be a way to detect this at
5926 completion time. */
5927 scope = default_macro_scope ();
5928 if (scope)
5929 macro_for_each_in_scope (scope->file, scope->line,
5930 add_macro_name);
5931
5932 /* User-defined macros are always visible. */
5933 macro_for_each (macro_user_macros, add_macro_name);
5934 }
5935}
5936
5937/* Collect all symbols (regardless of class) which begin by matching
5938 TEXT. */
5939
5940void
5943 symbol_name_match_type name_match_type,
5944 const char *text, const char *word)
5945{
5947 name_match_type,
5948 text, word,
5950}
5951
5952/* Like collect_symbol_completion_matches, but only collect
5953 STRUCT_DOMAIN symbols whose type code is CODE. */
5954
5955void
5957 const char *text, const char *word,
5958 enum type_code code)
5959{
5962
5963 gdb_assert (code == TYPE_CODE_UNION
5964 || code == TYPE_CODE_STRUCT
5965 || code == TYPE_CODE_ENUM);
5967 name_match_type,
5968 text, word, code);
5969}
5970
5971/* Like collect_symbol_completion_matches, but collects a list of
5972 symbols defined in all source files named SRCFILE. */
5973
5974void
5977 symbol_name_match_type name_match_type,
5978 const char *text, const char *word,
5979 const char *srcfile)
5980{
5981 /* The symbol we are completing on. Points in same buffer as text. */
5982 const char *sym_text;
5983
5984 /* Now look for the symbol we are supposed to complete on.
5985 FIXME: This should be language-specific. */
5987 sym_text = text;
5988 else
5989 {
5990 const char *p;
5991 char quote_found;
5992 const char *quote_pos = NULL;
5993
5994 /* First see if this is a quoted string. */
5995 quote_found = '\0';
5996 for (p = text; *p != '\0'; ++p)
5997 {
5998 if (quote_found != '\0')
5999 {
6000 if (*p == quote_found)
6001 /* Found close quote. */
6002 quote_found = '\0';
6003 else if (*p == '\\' && p[1] == quote_found)
6004 /* A backslash followed by the quote character
6005 doesn't end the string. */
6006 ++p;
6007 }
6008 else if (*p == '\'' || *p == '"')
6009 {
6010 quote_found = *p;
6011 quote_pos = p;
6012 }
6013 }
6014 if (quote_found == '\'')
6015 /* A string within single quotes can be a symbol, so complete on it. */
6016 sym_text = quote_pos + 1;
6017 else if (quote_found == '"')
6018 /* A double-quoted string is never a symbol, nor does it make sense
6019 to complete it any other way. */
6020 {
6021 return;
6022 }
6023 else
6024 {
6025 /* Not a quoted string. */
6026 sym_text = language_search_unquoted_string (text, p);
6027 }
6028 }
6029
6030 lookup_name_info lookup_name (sym_text, name_match_type, true);
6031
6032 /* Go through symtabs for SRCFILE and check the externs and statics
6033 for symbols which match. */
6034 iterate_over_symtabs (srcfile, [&] (symtab *s)
6035 {
6037 tracker, mode, lookup_name,
6038 sym_text, word, TYPE_CODE_UNDEF);
6039 return false;
6040 });
6041}
6042
6043/* A helper function for make_source_files_completion_list. It adds
6044 another file name to a list of possible completions, growing the
6045 list as necessary. */
6046
6047static void
6048add_filename_to_list (const char *fname, const char *text, const char *word,
6049 completion_list *list)
6050{
6051 list->emplace_back (make_completion_match_str (fname, text, word));
6052}
6053
6054static int
6055not_interesting_fname (const char *fname)
6056{
6057 static const char *illegal_aliens[] = {
6058 "_globals_", /* inserted by coff_symtab_read */
6059 NULL
6060 };
6061 int i;
6062
6063 for (i = 0; illegal_aliens[i]; i++)
6064 {
6065 if (filename_cmp (fname, illegal_aliens[i]) == 0)
6066 return 1;
6067 }
6068 return 0;
6069}
6070
6071/* An object of this type is passed as the callback argument to
6072 map_partial_symbol_filenames. */
6074{
6076 const char *text;
6077 const char *word;
6080
6081 void operator() (const char *filename, const char *fullname);
6082};
6083
6084/* A callback for map_partial_symbol_filenames. */
6085
6086void
6088 const char *fullname)
6089{
6090 if (not_interesting_fname (filename))
6091 return;
6092 if (!filename_seen_cache->seen (filename)
6093 && filename_ncmp (filename, text, text_len) == 0)
6094 {
6095 /* This file matches for a completion; add it to the
6096 current list of matches. */
6097 add_filename_to_list (filename, text, word, list);
6098 }
6099 else
6100 {
6101 const char *base_name = lbasename (filename);
6102
6103 if (base_name != filename
6104 && !filename_seen_cache->seen (base_name)
6105 && filename_ncmp (base_name, text, text_len) == 0)
6106 add_filename_to_list (base_name, text, word, list);
6107 }
6108}
6109
6110/* Return a list of all source files whose names begin with matching
6111 TEXT. The file names are looked up in the symbol tables of this
6112 program. */
6113
6115make_source_files_completion_list (const char *text, const char *word)
6116{
6117 size_t text_len = strlen (text);
6118 completion_list list;
6119 const char *base_name;
6120 struct add_partial_filename_data datum;
6121
6123 return list;
6124
6125 filename_seen_cache filenames_seen;
6126
6128 {
6129 for (compunit_symtab *cu : objfile->compunits ())
6130 {
6131 for (symtab *s : cu->filetabs ())
6132 {
6133 if (not_interesting_fname (s->filename))
6134 continue;
6135 if (!filenames_seen.seen (s->filename)
6136 && filename_ncmp (s->filename, text, text_len) == 0)
6137 {
6138 /* This file matches for a completion; add it to the current
6139 list of matches. */
6140 add_filename_to_list (s->filename, text, word, &list);
6141 }
6142 else
6143 {
6144 /* NOTE: We allow the user to type a base name when the
6145 debug info records leading directories, but not the other
6146 way around. This is what subroutines of breakpoint
6147 command do when they parse file names. */
6148 base_name = lbasename (s->filename);
6149 if (base_name != s->filename
6150 && !filenames_seen.seen (base_name)
6151 && filename_ncmp (base_name, text, text_len) == 0)
6152 add_filename_to_list (base_name, text, word, &list);
6153 }
6154 }
6155 }
6156 }
6157
6158 datum.filename_seen_cache = &filenames_seen;
6159 datum.text = text;
6160 datum.word = word;
6161 datum.text_len = text_len;
6162 datum.list = &list;
6163 map_symbol_filenames (datum, false /*need_fullname*/);
6164
6165 return list;
6166}
6167
6168/* Track MAIN */
6169
6170/* Return the "main_info" object for the current program space. If
6171 the object has not yet been created, create it and fill in some
6172 default values. */
6173
6174static struct main_info *
6176{
6178
6179 if (info == NULL)
6180 {
6181 /* It may seem strange to store the main name in the progspace
6182 and also in whatever objfile happens to see a main name in
6183 its debug info. The reason for this is mainly historical:
6184 gdb returned "main" as the name even if no function named
6185 "main" was defined the program; and this approach lets us
6186 keep compatibility. */
6188 }
6189
6190 return info;
6191}
6192
6193static void
6194set_main_name (const char *name, enum language lang)
6195{
6196 struct main_info *info = get_main_info ();
6197
6198 if (info->name_of_main != NULL)
6199 {
6200 xfree (info->name_of_main);
6201 info->name_of_main = NULL;
6202 info->language_of_main = language_unknown;
6203 }
6204 if (name != NULL)
6205 {
6206 info->name_of_main = xstrdup (name);
6207 info->language_of_main = lang;
6208 }
6209}
6210
6211/* Deduce the name of the main procedure, and set NAME_OF_MAIN
6212 accordingly. */
6213
6214static void
6216{
6217 const char *new_main_name;
6218
6219 /* First check the objfiles to see whether a debuginfo reader has
6220 picked up the appropriate main name. Historically the main name
6221 was found in a more or less random way; this approach instead
6222 relies on the order of objfile creation -- which still isn't
6223 guaranteed to get the correct answer, but is just probably more
6224 accurate. */
6226 {
6227 if (objfile->per_bfd->name_of_main != NULL)
6228 {
6231 return;
6232 }
6233 }
6234
6235 /* Try to see if the main procedure is in Ada. */
6236 /* FIXME: brobecker/2005-03-07: Another way of doing this would
6237 be to add a new method in the language vector, and call this
6238 method for each language until one of them returns a non-empty
6239 name. This would allow us to remove this hard-coded call to
6240 an Ada function. It is not clear that this is a better approach
6241 at this point, because all methods need to be written in a way
6242 such that false positives never be returned. For instance, it is
6243 important that a method does not return a wrong name for the main
6244 procedure if the main procedure is actually written in a different
6245 language. It is easy to guaranty this with Ada, since we use a
6246 special symbol generated only when the main in Ada to find the name
6247 of the main procedure. It is difficult however to see how this can
6248 be guarantied for languages such as C, for instance. This suggests
6249 that order of call for these methods becomes important, which means
6250 a more complicated approach. */
6251 new_main_name = ada_main_name ();
6252 if (new_main_name != NULL)
6253 {
6254 set_main_name (new_main_name, language_ada);
6255 return;
6256 }
6257
6258 new_main_name = d_main_name ();
6259 if (new_main_name != NULL)
6260 {
6261 set_main_name (new_main_name, language_d);
6262 return;
6263 }
6264
6265 new_main_name = go_main_name ();
6266 if (new_main_name != NULL)
6267 {
6268 set_main_name (new_main_name, language_go);
6269 return;
6270 }
6271
6272 new_main_name = pascal_main_name ();
6273 if (new_main_name != NULL)
6274 {
6275 set_main_name (new_main_name, language_pascal);
6276 return;
6277 }
6278
6279 /* The languages above didn't identify the name of the main procedure.
6280 Fallback to "main". */
6281
6282 /* Try to find language for main in psymtabs. */
6283 bool symbol_found_p = false;
6285 (target_gdbarch (),
6286 [&symbol_found_p] (objfile *obj)
6287 {
6288 language lang
6290 &symbol_found_p);
6291 if (symbol_found_p)
6292 {
6293 set_main_name ("main", lang);
6294 return 1;
6295 }
6296
6297 return 0;
6298 }, nullptr);
6299
6300 if (symbol_found_p)
6301 return;
6302
6304}
6305
6306/* See symtab.h. */
6307
6308const char *
6310{
6311 struct main_info *info = get_main_info ();
6312
6313 if (info->name_of_main == NULL)
6314 find_main_name ();
6315
6316 return info->name_of_main;
6317}
6318
6319/* Return the language of the main function. If it is not known,
6320 return language_unknown. */
6321
6322enum language
6324{
6325 struct main_info *info = get_main_info ();
6326
6327 if (info->name_of_main == NULL)
6328 find_main_name ();
6329
6330 return info->language_of_main;
6331}
6332
6333/* Handle ``executable_changed'' events for the symtab module. */
6334
6335static void
6337{
6338 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
6340}
6341
6342/* Return 1 if the supplied producer string matches the ARM RealView
6343 compiler (armcc). */
6344
6345bool
6346producer_is_realview (const char *producer)
6347{
6348 static const char *const arm_idents[] = {
6349 "ARM C Compiler, ADS",
6350 "Thumb C Compiler, ADS",
6351 "ARM C++ Compiler, ADS",
6352 "Thumb C++ Compiler, ADS",
6353 "ARM/Thumb C/C++ Compiler, RVCT",
6354 "ARM C/C++ Compiler, RVCT"
6355 };
6356
6357 if (producer == NULL)
6358 return false;
6359
6360 for (const char *ident : arm_idents)
6361 if (startswith (producer, ident))
6362 return true;
6363
6364 return false;
6365}
6366
6367
6368
6369/* The next index to hand out in response to a registration request. */
6370
6372
6373/* The maximum number of "aclass" registrations we support. This is
6374 constant for convenience. */
6375#define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
6376
6377/* The objects representing the various "aclass" values. The elements
6378 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
6379 elements are those registered at gdb initialization time. */
6380
6382
6383/* The globally visible pointer. This is separate from 'symbol_impl'
6384 so that it can be const. */
6385
6386gdb::array_view<const struct symbol_impl> symbol_impls (symbol_impl);
6387
6388/* Make sure we saved enough room in struct symbol. */
6389
6391
6392/* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
6393 is the ops vector associated with this index. This returns the new
6394 index, which should be used as the aclass_index field for symbols
6395 of this type. */
6396
6397int
6399 const struct symbol_computed_ops *ops)
6400{
6401 int result = next_aclass_value++;
6402
6403 gdb_assert (aclass == LOC_COMPUTED);
6404 gdb_assert (result < MAX_SYMBOL_IMPLS);
6405 symbol_impl[result].aclass = aclass;
6406 symbol_impl[result].ops_computed = ops;
6407
6408 /* Sanity check OPS. */
6409 gdb_assert (ops != NULL);
6410 gdb_assert (ops->tracepoint_var_ref != NULL);
6411 gdb_assert (ops->describe_location != NULL);
6412 gdb_assert (ops->get_symbol_read_needs != NULL);
6413 gdb_assert (ops->read_variable != NULL);
6414
6415 return result;
6416}
6417
6418/* Register a function with frame base type. ACLASS must be LOC_BLOCK.
6419 OPS is the ops vector associated with this index. This returns the
6420 new index, which should be used as the aclass_index field for symbols
6421 of this type. */
6422
6423int
6425 const struct symbol_block_ops *ops)
6426{
6427 int result = next_aclass_value++;
6428
6429 gdb_assert (aclass == LOC_BLOCK);
6430 gdb_assert (result < MAX_SYMBOL_IMPLS);
6431 symbol_impl[result].aclass = aclass;
6432 symbol_impl[result].ops_block = ops;
6433
6434 /* Sanity check OPS. */
6435 gdb_assert (ops != NULL);
6436 gdb_assert (ops->find_frame_base_location != NULL);
6437
6438 return result;
6439}
6440
6441/* Register a register symbol type. ACLASS must be LOC_REGISTER or
6442 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
6443 this index. This returns the new index, which should be used as
6444 the aclass_index field for symbols of this type. */
6445
6446int
6448 const struct symbol_register_ops *ops)
6449{
6450 int result = next_aclass_value++;
6451
6452 gdb_assert (aclass == LOC_REGISTER || aclass == LOC_REGPARM_ADDR);
6453 gdb_assert (result < MAX_SYMBOL_IMPLS);
6454 symbol_impl[result].aclass = aclass;
6455 symbol_impl[result].ops_register = ops;
6456
6457 return result;
6458}
6459
6460/* Initialize elements of 'symbol_impl' for the constants in enum
6461 address_class. */
6462
6463static void
6465{
6466 int i;
6467
6468 for (i = 0; i < LOC_FINAL_VALUE; ++i)
6469 symbol_impl[i].aclass = (enum address_class) i;
6470}
6471
6472
6473
6474/* See symtab.h. */
6475
6476struct objfile *
6478{
6479 gdb_assert (is_objfile_owned ());
6480 return owner.symtab->compunit ()->objfile ();
6481}
6482
6483/* See symtab.h. */
6484
6485struct gdbarch *
6486symbol::arch () const
6487{
6488 if (!is_objfile_owned ())
6489 return owner.arch;
6490 return owner.symtab->compunit ()->objfile ()->arch ();
6491}
6492
6493/* See symtab.h. */
6494
6495struct symtab *
6496symbol::symtab () const
6497{
6498 gdb_assert (is_objfile_owned ());
6499 return owner.symtab;
6500}
6501
6502/* See symtab.h. */
6503
6504void
6506{
6507 gdb_assert (is_objfile_owned ());
6508 owner.symtab = symtab;
6509}
6510
6511/* See symtab.h. */
6512
6513CORE_ADDR
6514get_symbol_address (const struct symbol *sym)
6515{
6516 gdb_assert (sym->maybe_copied);
6517 gdb_assert (sym->aclass () == LOC_STATIC);
6518
6519 const char *linkage_name = sym->linkage_name ();
6520
6522 {
6524 continue;
6525
6527 = lookup_minimal_symbol_linkage (linkage_name, objfile);
6528 if (minsym.minsym != nullptr)
6529 return minsym.value_address ();
6530 }
6531 return sym->m_value.address;
6532}
6533
6534/* See symtab.h. */
6535
6536CORE_ADDR
6537get_msymbol_address (struct objfile *objf, const struct minimal_symbol *minsym)
6538{
6539 gdb_assert (minsym->maybe_copied);
6540 gdb_assert ((objf->flags & OBJF_MAINLINE) == 0);
6541
6542 const char *linkage_name = minsym->linkage_name ();
6543
6545 {
6547 && (objfile->flags & OBJF_MAINLINE) != 0)
6548 {
6550 = lookup_minimal_symbol_linkage (linkage_name, objfile);
6551 if (found.minsym != nullptr)
6552 return found.value_address ();
6553 }
6554 }
6555 return (minsym->m_value.address
6556 + objf->section_offsets[minsym->section_index ()]);
6557}
6558
6559
6560
6561/* Hold the sub-commands of 'info module'. */
6562
6564
6565/* See symtab.h. */
6566
6567std::vector<module_symbol_search>
6568search_module_symbols (const char *module_regexp, const char *regexp,
6569 const char *type_regexp, search_domain kind)
6570{
6571 std::vector<module_symbol_search> results;
6572
6573 /* Search for all modules matching MODULE_REGEXP. */
6574 global_symbol_searcher spec1 (MODULES_DOMAIN, module_regexp);
6575 spec1.set_exclude_minsyms (true);
6576 std::vector<symbol_search> modules = spec1.search ();
6577
6578 /* Now search for all symbols of the required KIND matching the required
6579 regular expressions. We figure out which ones are in which modules
6580 below. */
6581 global_symbol_searcher spec2 (kind, regexp);
6582 spec2.set_symbol_type_regexp (type_regexp);
6583 spec2.set_exclude_minsyms (true);
6584 std::vector<symbol_search> symbols = spec2.search ();
6585
6586 /* Now iterate over all MODULES, checking to see which items from
6587 SYMBOLS are in each module. */
6588 for (const symbol_search &p : modules)
6589 {
6590 QUIT;
6591
6592 /* This is a module. */
6593 gdb_assert (p.symbol != nullptr);
6594
6595 std::string prefix = p.symbol->print_name ();
6596 prefix += "::";
6597
6598 for (const symbol_search &q : symbols)
6599 {
6600 if (q.symbol == nullptr)
6601 continue;
6602
6603 if (strncmp (q.symbol->print_name (), prefix.c_str (),
6604 prefix.size ()) != 0)
6605 continue;
6606
6607 results.push_back ({p, q});
6608 }
6609 }
6610
6611 return results;
6612}
6613
6614/* Implement the core of both 'info module functions' and 'info module
6615 variables'. */
6616
6617static void
6618info_module_subcommand (bool quiet, const char *module_regexp,
6619 const char *regexp, const char *type_regexp,
6620 search_domain kind)
6621{
6622 /* Print a header line. Don't build the header line bit by bit as this
6623 prevents internationalisation. */
6624 if (!quiet)
6625 {
6626 if (module_regexp == nullptr)
6627 {
6628 if (type_regexp == nullptr)
6629 {
6630 if (regexp == nullptr)
6632 ? _("All variables in all modules:")
6633 : _("All functions in all modules:")));
6634 else
6636 ((kind == VARIABLES_DOMAIN
6637 ? _("All variables matching regular expression"
6638 " \"%s\" in all modules:")
6639 : _("All functions matching regular expression"
6640 " \"%s\" in all modules:")),
6641 regexp);
6642 }
6643 else
6644 {
6645 if (regexp == nullptr)
6647 ((kind == VARIABLES_DOMAIN
6648 ? _("All variables with type matching regular "
6649 "expression \"%s\" in all modules:")
6650 : _("All functions with type matching regular "
6651 "expression \"%s\" in all modules:")),
6652 type_regexp);
6653 else
6655 ((kind == VARIABLES_DOMAIN
6656 ? _("All variables matching regular expression "
6657 "\"%s\",\n\twith type matching regular "
6658 "expression \"%s\" in all modules:")
6659 : _("All functions matching regular expression "
6660 "\"%s\",\n\twith type matching regular "
6661 "expression \"%s\" in all modules:")),
6662 regexp, type_regexp);
6663 }
6664 }
6665 else
6666 {
6667 if (type_regexp == nullptr)
6668 {
6669 if (regexp == nullptr)
6671 ((kind == VARIABLES_DOMAIN
6672 ? _("All variables in all modules matching regular "
6673 "expression \"%s\":")
6674 : _("All functions in all modules matching regular "
6675 "expression \"%s\":")),
6676 module_regexp);
6677 else
6679 ((kind == VARIABLES_DOMAIN
6680 ? _("All variables matching regular expression "
6681 "\"%s\",\n\tin all modules matching regular "
6682 "expression \"%s\":")
6683 : _("All functions matching regular expression "
6684 "\"%s\",\n\tin all modules matching regular "
6685 "expression \"%s\":")),
6686 regexp, module_regexp);
6687 }
6688 else
6689 {
6690 if (regexp == nullptr)
6692 ((kind == VARIABLES_DOMAIN
6693 ? _("All variables with type matching regular "
6694 "expression \"%s\"\n\tin all modules matching "
6695 "regular expression \"%s\":")
6696 : _("All functions with type matching regular "
6697 "expression \"%s\"\n\tin all modules matching "
6698 "regular expression \"%s\":")),
6699 type_regexp, module_regexp);
6700 else
6702 ((kind == VARIABLES_DOMAIN
6703 ? _("All variables matching regular expression "
6704 "\"%s\",\n\twith type matching regular expression "
6705 "\"%s\",\n\tin all modules matching regular "
6706 "expression \"%s\":")
6707 : _("All functions matching regular expression "
6708 "\"%s\",\n\twith type matching regular expression "
6709 "\"%s\",\n\tin all modules matching regular "
6710 "expression \"%s\":")),
6711 regexp, type_regexp, module_regexp);
6712 }
6713 }
6714 gdb_printf ("\n");
6715 }
6716
6717 /* Find all symbols of type KIND matching the given regular expressions
6718 along with the symbols for the modules in which those symbols
6719 reside. */
6720 std::vector<module_symbol_search> module_symbols
6721 = search_module_symbols (module_regexp, regexp, type_regexp, kind);
6722
6723 std::sort (module_symbols.begin (), module_symbols.end (),
6724 [] (const module_symbol_search &a, const module_symbol_search &b)
6725 {
6726 if (a.first < b.first)
6727 return true;
6728 else if (a.first == b.first)
6729 return a.second < b.second;
6730 else
6731 return false;
6732 });
6733
6734 const char *last_filename = "";
6735 const symbol *last_module_symbol = nullptr;
6736 for (const module_symbol_search &ms : module_symbols)
6737 {
6738 const symbol_search &p = ms.first;
6739 const symbol_search &q = ms.second;
6740
6741 gdb_assert (q.symbol != nullptr);
6742
6743 if (last_module_symbol != p.symbol)
6744 {
6745 gdb_printf ("\n");
6746 gdb_printf (_("Module \"%s\":\n"), p.symbol->print_name ());
6747 last_module_symbol = p.symbol;
6748 last_filename = "";
6749 }
6750
6752 last_filename);
6753 last_filename
6755 }
6756}
6757
6758/* Hold the option values for the 'info module .....' sub-commands. */
6759
6761{
6762 bool quiet = false;
6763 std::string type_regexp;
6764 std::string module_regexp;
6765};
6766
6767/* The options used by 'info module variables' and 'info module functions'
6768 commands. */
6769
6772 "q",
6773 [] (info_modules_var_func_options *opt) { return &opt->quiet; },
6774 nullptr, /* show_cmd_cb */
6775 nullptr /* set_doc */
6776 },
6777
6779 "t",
6780 [] (info_modules_var_func_options *opt) { return &opt->type_regexp; },
6781 nullptr, /* show_cmd_cb */
6782 nullptr /* set_doc */
6783 },
6784
6786 "m",
6787 [] (info_modules_var_func_options *opt) { return &opt->module_regexp; },
6788 nullptr, /* show_cmd_cb */
6789 nullptr /* set_doc */
6790 }
6791};
6792
6793/* Return the option group used by the 'info module ...' sub-commands. */
6794
6798{
6799 return {{info_modules_var_func_options_defs}, opts};
6800}
6801
6802/* Implements the 'info module functions' command. */
6803
6804static void
6805info_module_functions_command (const char *args, int from_tty)
6806{
6811 if (args != nullptr && *args == '\0')
6812 args = nullptr;
6813
6815 (opts.quiet,
6816 opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
6817 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
6819}
6820
6821/* Implements the 'info module variables' command. */
6822
6823static void
6824info_module_variables_command (const char *args, int from_tty)
6825{
6830 if (args != nullptr && *args == '\0')
6831 args = nullptr;
6832
6834 (opts.quiet,
6835 opts.module_regexp.empty () ? nullptr : opts.module_regexp.c_str (), args,
6836 opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
6838}
6839
6840/* Command completer for 'info module ...' sub-commands. */
6841
6842static void
6844 completion_tracker &tracker,
6845 const char *text,
6846 const char * /* word */)
6847{
6848
6849 const auto group = make_info_modules_var_func_options_def_group (nullptr);
6851 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
6852 return;
6853
6854 const char *word = advance_to_expression_complete_word_point (tracker, text);
6855 symbol_completer (ignore, tracker, text, word);
6856}
6857
6858
6859
6860void _initialize_symtab ();
6861void
6863{
6865
6867
6868 c = add_info ("variables", info_variables_command,
6870All global and static variable names or those matching REGEXPs.\n\
6871Usage: info variables [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6872Prints the global and static variables.\n"),
6873 _("global and static variables"),
6874 true));
6876
6877 c = add_info ("functions", info_functions_command,
6879All function names or those matching REGEXPs.\n\
6880Usage: info functions [-q] [-n] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6881Prints the functions.\n"),
6882 _("functions"),
6883 true));
6885
6886 c = add_info ("types", info_types_command, _("\
6887All type names, or those matching REGEXP.\n\
6888Usage: info types [-q] [REGEXP]\n\
6889Print information about all types matching REGEXP, or all types if no\n\
6890REGEXP is given. The optional flag -q disables printing of headers."));
6892
6893 const auto info_sources_opts
6895
6896 static std::string info_sources_help
6898All source files in the program or those matching REGEXP.\n\
6899Usage: info sources [OPTION]... [REGEXP]\n\
6900By default, REGEXP is used to match anywhere in the filename.\n\
6901\n\
6902Options:\n\
6903%OPTIONS%"),
6904 info_sources_opts);
6905
6906 c = add_info ("sources", info_sources_command, info_sources_help.c_str ());
6908
6909 c = add_info ("modules", info_modules_command,
6910 _("All module names, or those matching REGEXP."));
6912
6913 add_basic_prefix_cmd ("module", class_info, _("\
6914Print information about modules."),
6916
6917 c = add_cmd ("functions", class_info, info_module_functions_command, _("\
6918Display functions arranged by modules.\n\
6919Usage: info module functions [-q] [-m MODREGEXP] [-t TYPEREGEXP] [REGEXP]\n\
6920Print a summary of all functions within each Fortran module, grouped by\n\
6921module and file. For each function the line on which the function is\n\
6922defined is given along with the type signature and name of the function.\n\
6923\n\
6924If REGEXP is provided then only functions whose name matches REGEXP are\n\
6925listed. If MODREGEXP is provided then only functions in modules matching\n\
6926MODREGEXP are listed. If TYPEREGEXP is given then only functions whose\n\
6927type signature matches TYPEREGEXP are listed.\n\
6928\n\
6929The -q flag suppresses printing some header information."),
6933
6934 c = add_cmd ("variables", class_info, info_module_variables_command, _("\
6935Display variables arranged by modules.\n\
6936Usage: info module variables [-q] [-m MODREGEXP] [-t TYPEREGEXP] [REGEXP]\n\
6937Print a summary of all variables within each Fortran module, grouped by\n\
6938module and file. For each variable the line on which the variable is\n\
6939defined is given along with the type and name of the variable.\n\
6940\n\
6941If REGEXP is provided then only variables whose name matches REGEXP are\n\
6942listed. If MODREGEXP is provided then only variables in modules matching\n\
6943MODREGEXP are listed. If TYPEREGEXP is given then only variables whose\n\
6944type matches TYPEREGEXP are listed.\n\
6945\n\
6946The -q flag suppresses printing some header information."),
6950
6952 _("Set a breakpoint for all functions matching REGEXP."));
6953
6954 add_setshow_enum_cmd ("multiple-symbols", no_class,
6956 _("\
6957Set how the debugger handles ambiguities in expressions."), _("\
6958Show how the debugger handles ambiguities in expressions."), _("\
6959Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
6960 NULL, NULL, &setlist, &showlist);
6961
6962 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
6964Set whether a source file may have multiple base names."), _("\
6965Show whether a source file may have multiple base names."), _("\
6966(A \"base name\" is the name of a file with the directory part removed.\n\
6967Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
6968If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
6969before comparing them. Canonicalization is an expensive operation,\n\
6970but it allows the same file be known by more than one base name.\n\
6971If not set (the default), all source files are assumed to have just\n\
6972one base name, and gdb will do file name comparisons more efficiently."),
6973 NULL, NULL,
6974 &setlist, &showlist);
6975
6977 _("Set debugging of symbol table creation."),
6978 _("Show debugging of symbol table creation."), _("\
6979When enabled (non-zero), debugging messages are printed when building\n\
6980symbol tables. A value of 1 (one) normally provides enough information.\n\
6981A value greater than 1 provides more verbose information."),
6982 NULL,
6983 NULL,
6985
6987 _("\
6988Set debugging of symbol lookup."), _("\
6989Show debugging of symbol lookup."), _("\
6990When enabled (non-zero), symbol lookups are logged."),
6991 NULL, NULL,
6993
6994 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class,
6996 _("Set the size of the symbol cache."),
6997 _("Show the size of the symbol cache."), _("\
6998The size of the symbol cache.\n\
6999If zero then the symbol cache is disabled."),
7003
7004 add_setshow_boolean_cmd ("ignore-prologue-end-flag", no_class,
7006 _("Set if the PROLOGUE-END flag is ignored."),
7007 _("Show if the PROLOGUE-END flag is ignored."),
7008 _("\
7009The PROLOGUE-END flag from the line-table entries is used to place \
7010breakpoints past the prologue of functions. Disabeling its use use forces \
7011the use of prologue scanners."),
7012 nullptr, nullptr,
7015
7016
7018 _("Dump the symbol cache for each program space."),
7020
7021 add_cmd ("symbol-cache-statistics", class_maintenance,
7023 _("Print symbol cache statistics for each program space."),
7025
7026 cmd_list_element *maintenance_flush_symbol_cache_cmd
7027 = add_cmd ("symbol-cache", class_maintenance,
7029 _("Flush the symbol cache for each program space."),
7031 c = add_alias_cmd ("flush-symbol-cache", maintenance_flush_symbol_cache_cmd,
7033 deprecate_cmd (c, "maintenancelist flush symbol-cache");
7034
7036 "symtab");
7039}
const char *const name
Definition: aarch64-tdep.c:67
void * xmalloc(YYSIZE_T)
void xfree(void *)
char * ada_main_name(void)
Definition: ada-lang.c:809
const char * ada_decode_symbol(const struct general_symbol_info *arg)
Definition: ada-lang.c:1606
if(!(yy_init))
Definition: ada-lex.c:1109
int code
Definition: ada-lex.l:688
void * xcalloc(size_t number, size_t size)
Definition: alloc.c:85
void * xrealloc(void *ptr, size_t size)
Definition: alloc.c:65
struct gdbarch * target_gdbarch(void)
Definition: arch-utils.c:1453
CORE_ADDR gdbarch_skip_prologue_noexcept(gdbarch *gdbarch, CORE_ADDR pc) noexcept
Definition: arch-utils.c:1047
void f()
Definition: 1.cc:36
bool best_symbol(struct symbol *a, const domain_enum domain)
Definition: block.c:663
struct symbol * better_symbol(struct symbol *a, struct symbol *b, const domain_enum domain)
Definition: block.c:672
struct symbol * block_lookup_symbol_primary(const struct block *block, const char *name, const domain_enum domain)
Definition: block.c:767
const struct block * block_global_block(const struct block *block)
Definition: block.c:376
struct objfile * block_objfile(const struct block *block)
Definition: block.c:46
int block_inlined_p(const struct block *bl)
Definition: block.c:125
struct symbol * block_find_symbol(const struct block *block, const char *name, const domain_enum domain, block_symbol_matcher_ftype *matcher, void *data)
Definition: block.c:829
struct gdbarch * block_gdbarch(const struct block *block)
Definition: block.c:60
struct symbol * block_lookup_symbol(const struct block *block, const char *name, symbol_name_match_type match_type, const domain_enum domain)
Definition: block.c:706
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:283
const struct block * block_for_pc_sect(CORE_ADDR pc, struct obj_section *section)
Definition: block.c:268
const struct block * block_static_block(const struct block *block)
Definition: block.c:361
const char * block_scope(const struct block *block)
Definition: block.c:296
int block_find_non_opaque_type(struct symbol *sym, void *data)
Definition: block.c:856
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:534
#define ALL_BLOCK_SYMBOLS_WITH_NAME(block, name, iter, sym)
Definition: block.h:544
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition: blockframe.c:373
struct symbol * find_pc_sect_containing_function(CORE_ADDR pc, struct obj_section *section)
Definition: blockframe.c:158
struct symbol * find_pc_sect_function(CORE_ADDR pc, struct obj_section *section)
Definition: blockframe.c:136
void break_command(const char *arg, int from_tty)
Definition: breakpoint.c:9223
ui_file_style style() const
Definition: cli-style.c:169
const char * match()
Definition: completer.h:85
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
Definition: completer.c:1579
completion_match_result & reset_completion_match_result()
Definition: completer.h:385
void remove_completion(const char *name)
Definition: completer.c:1599
const char * set_malloc_ptr(gdb::unique_xmalloc_ptr< char > &&str)
Definition: symtab.h:2724
bool seen(const char *file)
const char * m_symbol_name_regexp
Definition: symtab.h:2518
std::vector< symbol_search > search() const
Definition: symtab.c:4852
void set_exclude_minsyms(bool exclude_minsyms)
Definition: symtab.h:2483
const char * m_symbol_type_regexp
Definition: symtab.h:2521
static bool is_suitable_msymbol(const enum search_domain kind, const minimal_symbol *msymbol)
Definition: symtab.c:4621
enum search_domain m_kind
Definition: symtab.h:2515
void set_symbol_type_regexp(const char *regexp)
Definition: symtab.h:2477
bool add_matching_msymbols(objfile *objfile, const gdb::optional< compiled_regex > &preg, std::vector< symbol_search > *results) const
Definition: symtab.c:4807
bool add_matching_symbols(objfile *objfile, const gdb::optional< compiled_regex > &preg, const gdb::optional< compiled_regex > &treg, std::set< symbol_search > *result_set) const
Definition: symtab.c:4725
bool expand_symtabs(objfile *objfile, const gdb::optional< compiled_regex > &preg) const
Definition: symtab.c:4644
std::vector< const char * > filenames
Definition: symtab.h:2505
size_t m_max_search_results
Definition: symtab.h:2529
static const lookup_name_info & match_any()
Definition: symtab.c:1864
void * get(unsigned key)
Definition: registry.h:211
const std::string & string()
Definition: ui-file.h:194
Definition: ui-out.h:160
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition: ui-out.c:511
void text(const char *string)
Definition: ui-out.c:566
bool is_mi_like_p() const
Definition: ui-out.c:810
void void void wrap_hint(int indent)
Definition: ui-out.c:785
struct cmd_list_element * showlist
Definition: cli-cmds.c:125
struct cmd_list_element * infolist
Definition: cli-cmds.c:89
struct cmd_list_element * maintenanceprintlist
Definition: cli-cmds.c:149
struct cmd_list_element * setlist
Definition: cli-cmds.c:117
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:165
struct cmd_list_element * maintenanceflushlist
Definition: cli-cmds.c:157
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:141
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:163
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:752
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:751
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:294
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:233
void set_cmd_completer_handle_brkchars(struct cmd_list_element *cmd, completer_handle_brkchars_ftype *func)
Definition: cli-decode.c:125
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
Definition: cli-decode.c:1310
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:618
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:280
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:739
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:391
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
Definition: cli-decode.c:1294
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:1190
cli_style_option address_style
cli_style_option function_name_style
cli_style_option file_name_style
const char * info_print_args_help(const char *prefix, const char *entity_kind, bool document_n_flag)
Definition: cli-utils.c:196
@ class_obscure
Definition: command.h:64
@ class_maintenance
Definition: command.h:65
@ class_breakpoint
Definition: command.h:60
@ no_class
Definition: command.h:53
@ class_info
Definition: command.h:59
gdb::unique_xmalloc_ptr< char > make_completion_match_str(const char *match_name, const char *text, const char *word)
Definition: completer.c:1646
const char * advance_to_expression_complete_word_point(completion_tracker &tracker, const char *text)
Definition: completer.c:422
void symbol_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1110
std::vector< gdb::unique_xmalloc_ptr< char > > completion_list
Definition: completer.h:70
int is_operator_name(const char *name)
Definition: cp-abi.c:60
enum dtor_kinds is_destructor_name(const char *name)
Definition: cp-abi.c:44
enum ctor_kinds is_constructor_name(const char *name)
Definition: cp-abi.c:36
struct block_symbol cp_lookup_symbol_imports_or_template(const char *scope, const char *name, const struct block *block, const domain_enum domain)
Definition: cp-namespace.c:502
gdb::unique_xmalloc_ptr< char > gdb_demangle(const char *name, int options)
Definition: cp-support.c:1606
gdb::unique_xmalloc_ptr< char > cp_canonicalize_string_no_typedefs(const char *string)
Definition: cp-support.c:616
gdb::unique_xmalloc_ptr< char > cp_canonicalize_string(const char *string)
Definition: cp-support.c:626
gdb::unique_xmalloc_ptr< char > cp_remove_params_if_any(const char *demangled_name, bool completion_mode)
Definition: cp-support.c:966
#define CP_OPERATOR_STR
Definition: cp-support.h:53
#define CP_OPERATOR_LEN
Definition: cp-support.h:57
const char * d_main_name(void)
Definition: d-lang.c:40
gdb::unique_xmalloc_ptr< char > d_demangle(const char *symbol, int options)
Definition: d-lang.c:55
block_enum
Definition: defs.h:630
@ STATIC_BLOCK
Definition: defs.h:632
@ GLOBAL_BLOCK
Definition: defs.h:631
language
Definition: defs.h:211
@ language_ada
Definition: defs.h:226
@ language_unknown
Definition: defs.h:212
@ language_cplus
Definition: defs.h:216
@ language_auto
Definition: defs.h:213
@ language_go
Definition: defs.h:218
@ language_asm
Definition: defs.h:221
@ language_fortran
Definition: defs.h:219
@ language_pascal
Definition: defs.h:222
@ language_rust
Definition: defs.h:224
@ language_c
Definition: defs.h:214
@ language_d
Definition: defs.h:217
@ nr_languages
Definition: defs.h:227
@ language_objc
Definition: defs.h:215
#define QUIT
Definition: defs.h:186
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2602
void gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb, struct objfile *current_objfile)
Definition: gdbarch.c:4972
bool gdbarch_skip_main_prologue_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2647
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1708
CORE_ADDR gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch)
Definition: gdbarch.c:2855
bool gdbarch_skip_entrypoint_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2671
CORE_ADDR gdbarch_skip_entrypoint(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2678
CORE_ADDR gdbarch_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2654
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:3010
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:2169
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:2086
#define TYPE_FN_FIELDLIST(thistype, n)
Definition: gdbtypes.h:2156
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition: gdbtypes.h:2157
#define TYPE_IS_OPAQUE(thistype)
Definition: gdbtypes.h:2217
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:2107
type_code
Definition: gdbtypes.h:99
@ TYPE_CODE_UNDEF
Definition: gdbtypes.h:100
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:2158
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:2108
const char * go_main_name(void)
Definition: go-lang.c:56
unsigned short selector
Definition: go32-nat.c:1
size_t size
Definition: go32-nat.c:241
const char * language_str(enum language lang)
Definition: language.c:452
const struct language_defn * language_def(enum language lang)
Definition: language.c:442
const struct language_defn * current_language
Definition: language.c:83
struct symbol * language_lookup_primitive_type_as_symbol(const struct language_defn *la, struct gdbarch *gdbarch, const char *name)
Definition: language.c:1073
@ macro_expansion_c
Definition: language.h:84
case_sensitivity
Definition: language.h:72
@ case_sensitive_off
Definition: language.h:73
gdb::unique_xmalloc_ptr< struct macro_scope > default_macro_scope(void)
Definition: macroscope.c:99
struct macro_table * macro_user_macros
Definition: macroscope.c:35
void macro_for_each(struct macro_table *table, gdb::function_view< macro_callback_fn > fn)
Definition: macrotab.c:970
void macro_for_each_in_scope(struct macro_source_file *file, int line, gdb::function_view< macro_callback_fn > fn)
Definition: macrotab.c:1005
bound_minimal_symbol lookup_minimal_symbol_by_pc_section(CORE_ADDR pc_in, struct obj_section *section, lookup_msym_prefer prefer, bound_minimal_symbol *previous)
Definition: minsyms.c:725
bound_minimal_symbol lookup_minimal_symbol_linkage(const char *name, struct objfile *objf)
Definition: minsyms.c:573
void iterate_over_minimal_symbols(struct objfile *objf, const lookup_name_info &lookup_name, gdb::function_view< bool(struct minimal_symbol *)> callback)
Definition: minsyms.c:524
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:977
struct minimal_symbol * lookup_minimal_symbol_by_pc_name(CORE_ADDR pc, const char *name, struct objfile *objf)
Definition: minsyms.c:647
struct bound_minimal_symbol lookup_minimal_symbol_text(const char *name, struct objfile *objf)
Definition: minsyms.c:596
bool msymbol_is_function(struct objfile *objfile, minimal_symbol *minsym, CORE_ADDR *func_address_p)
Definition: minsyms.c:113
observable< struct objfile * > free_objfile
observable executable_changed
observable< struct objfile * > new_objfile
bool process_options(const char **args, process_options_mode mode, gdb::array_view< const option_def_group > options_group)
Definition: cli-option.c:616
@ PROCESS_OPTIONS_UNKNOWN_IS_ERROR
Definition: cli-option.h:307
@ PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
Definition: cli-option.h:311
std::string build_help(const char *help_tmpl, gdb::array_view< const option_def_group > options_group)
Definition: cli-option.c:743
bool complete_options(completion_tracker &tracker, const char **args, process_options_mode mode, gdb::array_view< const option_def_group > options_group)
Definition: cli-option.c:457
@ OBJF_MAINLINE
Definition: objfile-flags.h:61
@ OBJF_REORDERED
Definition: objfile-flags.h:36
@ OBJF_READNOW
Definition: objfile-flags.h:45
const char * objfile_debug_name(const struct objfile *objfile)
Definition: objfiles.c:1330
int objfile_has_symbols(struct objfile *objfile)
Definition: objfiles.c:789
int have_partial_symbols(void)
Definition: objfiles.c:803
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1308
int have_full_symbols(void)
Definition: objfiles.c:818
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:130
const char * pascal_main_name(void)
Definition: p-lang.c:59
std::string copy_name(struct stoken token)
Definition: parse.c:407
#define prefix(a, b, R, do)
Definition: ppc64-tdep.c:52
void switch_to_program_space_and_thread(program_space *pspace)
struct program_space * current_program_space
Definition: progspace.c:39
std::vector< struct program_space * > program_spaces
Definition: progspace.c:36
static gdbpy_ref field_name(struct type *type, int field)
Definition: py-type.c:234
@ SEARCH_GLOBAL_BLOCK
Definition: quick-symbol.h:27
@ SEARCH_STATIC_BLOCK
Definition: quick-symbol.h:28
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1252
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1287
void operator()(const char *filename, const char *fullname)
Definition: symtab.c:6087
completion_list * list
Definition: symtab.c:6079
struct filename_seen_cache * filename_seen_cache
Definition: symtab.c:6075
virtual void * find(CORE_ADDR addr) const =0
unsigned int misses
Definition: symtab.c:203
unsigned int collisions
Definition: symtab.c:204
struct symbol_cache_slot symbols[1]
Definition: symtab.c:212
unsigned int hits
Definition: symtab.c:202
unsigned int size
Definition: symtab.c:210
const struct block * block
Definition: symtab.h:1498
struct symbol * symbol
Definition: symtab.h:1494
Definition: block.h:109
const block * superblock() const
Definition: block.h:135
CORE_ADDR start() const
Definition: block.h:111
CORE_ADDR entry_pc() const
Definition: block.h:199
CORE_ADDR end() const
Definition: block.h:119
symbol * function() const
Definition: block.h:127
struct block * block(size_t i)
Definition: block.h:271
addrmap * map()
Definition: block.h:310
struct block * global_block()
Definition: block.h:294
struct objfile * objfile
Definition: minsyms.h:54
CORE_ADDR value_address() const
Definition: minsyms.h:41
struct minimal_symbol * minsym
Definition: minsyms.h:49
completion_match_for_lcd match_for_lcd
Definition: completer.h:212
completion_match match
Definition: completer.h:209
symtab * primary_filetab() const
Definition: symtab.c:397
bool locations_valid() const
Definition: symtab.h:1798
htab_t m_call_site_htab
Definition: symtab.h:1900
enum language language() const
Definition: symtab.c:408
call_site * find_call_site(CORE_ADDR pc) const
Definition: symtab.c:339
struct compunit_symtab * next
Definition: symtab.h:1847
struct blockvector * blockvector()
Definition: symtab.h:1773
void set_call_site_htab(htab_t call_site_htab)
Definition: symtab.c:360
struct objfile * objfile() const
Definition: symtab.h:1714
int block_line_section() const
Definition: symtab.h:1788
symtab_range filetabs() const
Definition: symtab.h:1724
void set_primary_filetab(symtab *primary_filetab)
Definition: symtab.c:369
symtab * m_filetabs
Definition: symtab.h:1861
demangle_for_lookup_info(const lookup_name_info &lookup_name, language lang)
Definition: symtab.c:1835
std::string m_demangled_name
Definition: symtab.h:188
const std::string & lookup_name() const
Definition: symtab.h:183
Definition: symtab.c:798
gdb::string_view mangled
Definition: symtab.c:802
enum language language
Definition: symtab.c:803
demangled_name_entry(gdb::string_view mangled_name)
Definition: symtab.c:799
gdb::unique_xmalloc_ptr< char > demangled
Definition: symtab.c:804
struct type * type
Definition: symtab.h:1979
struct fn_fieldlist * fn_field
Definition: symtab.h:1989
struct field * field
Definition: symtab.h:1984
const char * name() const
Definition: gdbtypes.h:569
const char * physname
Definition: gdbtypes.h:1498
unsigned int is_volatile
Definition: gdbtypes.h:1516
unsigned int is_constructor
Definition: gdbtypes.h:1528
unsigned int is_const
Definition: gdbtypes.h:1515
union general_symbol_info::@177 m_value
void set_section_index(short idx)
Definition: symtab.h:597
CORE_ADDR value_address() const
Definition: symtab.h:516
CORE_ADDR address
Definition: symtab.h:548
void set_demangled_name(const char *name, struct obstack *obstack)
Definition: symtab.c:746
struct obstack * obstack
Definition: symtab.h:568
const char * natural_name() const
Definition: symtab.c:1027
const char * demangled_name
Definition: symtab.h:572
union general_symbol_info::@178 language_specific
const char * print_name() const
Definition: symtab.h:474
void compute_and_set_names(gdb::string_view linkage_name, bool copy_name, struct objfile_per_bfd_storage *per_bfd, gdb::optional< hashval_t > hash=gdb::optional< hashval_t >())
Definition: symtab.c:914
const char * search_name() const
Definition: symtab.c:1077
enum language language() const
Definition: symtab.h:501
unsigned int ada_mangled
Definition: symtab.h:585
const struct block * block
Definition: symtab.h:544
void set_language(enum language language, struct obstack *obstack)
Definition: symtab.c:771
short section_index() const
Definition: symtab.h:604
__extension__ enum language m_language
Definition: symtab.h:580
struct obj_section * obj_section(const struct objfile *objfile) const
Definition: symtab.c:1088
const char * m_name
Definition: symtab.h:532
const char * linkage_name() const
Definition: symtab.h:459
const char * m_regexp
Definition: symtab.h:2843
match_on m_match_type
Definition: symtab.h:2840
bool matches(const char *fullname) const
Definition: symtab.c:4233
info_sources_filter(match_on match_type, const char *regexp)
Definition: symtab.c:4212
gdb::optional< compiled_regex > m_c_regexp
Definition: symtab.h:2847
std::string type_regexp
Definition: symtab.c:5151
enum language la_language
Definition: language.h:275
virtual const char * name_of_this() const
Definition: language.h:586
virtual bool sniff_from_mangled_name(const char *mangled, gdb::unique_xmalloc_ptr< char > *demangled) const
Definition: language.h:441
symbol_name_matcher_ftype * get_symbol_name_matcher(const lookup_name_info &lookup_name) const
Definition: language.c:686
virtual struct block_symbol lookup_symbol_nonlocal(const char *name, const struct block *block, const domain_enum domain) const
Definition: symtab.c:2442
virtual struct type * lookup_transparent_type(const char *name) const
Definition: language.h:352
virtual void collect_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word, enum type_code code) const
Definition: language.h:498
virtual gdb::unique_xmalloc_ptr< char > demangle_symbol(const char *mangled, int options) const
Definition: language.h:448
virtual unsigned int search_name_hash(const char *name) const
Definition: dictionary.c:721
virtual enum macro_expansion macro_expansion() const
Definition: language.h:649
Definition: symtab.h:1548
unsigned is_stmt
Definition: symtab.h:1553
int line
Definition: symtab.h:1550
CORE_ADDR pc
Definition: symtab.h:1560
int nitems
Definition: symtab.h:1582
struct linetable_entry item[1]
Definition: symtab.h:1587
~main_info()
Definition: symtab.c:108
enum language language_of_main
Definition: symtab.c:119
char * name_of_main
Definition: symtab.c:115
main_info()=default
bool text_p() const
Definition: symtab.c:445
__extension__ enum minimal_symbol_type m_type
Definition: symtab.h:815
bool data_p() const
Definition: symtab.c:433
CORE_ADDR value_raw_address() const
Definition: symtab.h:735
minimal_symbol_type type() const
Definition: symtab.h:742
unsigned maybe_copied
Definition: symtab.h:836
CORE_ADDR addr() const
Definition: objfiles.h:822
CORE_ADDR endaddr() const
Definition: objfiles.h:829
CORE_ADDR offset() const
Definition: objfiles.h:810
struct bfd_section * the_bfd_section
Definition: objfiles.h:835
htab_up demangled_names_hash
Definition: objfiles.h:284
enum language language_of_main
Definition: objfiles.h:296
auto_obstack storage_obstack
Definition: objfiles.h:265
const char * name_of_main
Definition: objfiles.h:295
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:646
struct compunit_symtab * lookup_symbol(block_enum kind, const char *name, domain_enum domain)
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:743
struct program_space * pspace
Definition: objfiles.h:641
struct objfile * separate_debug_objfile
Definition: objfiles.h:738
void expand_symtabs_with_fullname(const char *fullname)
struct gdbarch * arch() const
Definition: objfiles.h:482
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:657
bool expand_symtabs_matching(gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info *lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, domain_enum domain, enum search_domain kind)
bool map_symtabs_matching_filename(const char *name, const char *real_path, gdb::function_view< bool(symtab *)> callback)
struct obj_section * sections
Definition: objfiles.h:725
gdb_bfd_ref_ptr obfd
Definition: objfiles.h:653
compunit_symtab_range compunits()
Definition: objfiles.h:426
objfile_flags flags
Definition: objfiles.h:637
bool has_unexpanded_symtabs()
separate_debug_range separate_debug_objfiles()
Definition: objfiles.h:450
enum language lookup_global_symbol_language(const char *name, domain_enum domain, bool *symbol_found_p)
::section_offsets section_offsets
Definition: objfiles.h:699
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
struct compunit_symtab * find_compunit_symtab_by_address(CORE_ADDR address)
struct compunit_symtab * find_pc_sect_compunit_symtab(struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin)
msymbols_range msymbols()
Definition: objfiles.h:439
filename_seen_cache m_filename_seen_cache
Definition: symtab.c:4320
output_source_filename_data(struct ui_out *uiout, const info_sources_filter &filter)
Definition: symtab.c:4272
const info_sources_filter & m_filter
Definition: symtab.c:4323
bool printed_filename_p() const
Definition: symtab.c:4309
void operator()(const char *filename, const char *fullname)
Definition: symtab.c:4299
struct ui_out * m_uiout
Definition: symtab.c:4326
void output(const char *disp_name, const char *fullname, bool expanded_p)
Definition: symtab.c:4332
DISABLE_COPY_AND_ASSIGN(output_source_filename_data)
objfiles_range objfiles()
Definition: progspace.h:209
Definition: value.c:72
void(* find_frame_base_location)(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: symtab.h:1130
enum symbol_cache_slot_state state
Definition: symtab.c:156
struct symbol_cache_slot::@175::@176 not_found
const struct objfile * objfile_context
Definition: symtab.c:174
domain_enum domain
Definition: symtab.c:182
struct block_symbol found
Definition: symtab.c:178
union symbol_cache_slot::@175 value
struct block_symbol_cache * global_symbols
Definition: symtab.c:248
~symbol_cache()
Definition: symtab.c:242
symbol_cache()=default
struct block_symbol_cache * static_symbols
Definition: symtab.c:249
enum symbol_needs_kind(* get_symbol_read_needs)(struct symbol *symbol)
Definition: symtab.h:1084
struct value *(* read_variable)(struct symbol *symbol, frame_info_ptr frame)
Definition: symtab.h:1071
void(* describe_location)(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
Definition: symtab.h:1088
void(* tracepoint_var_ref)(struct symbol *symbol, struct agent_expr *ax, struct axs_value *value)
Definition: symtab.h:1101
enum address_class aclass
Definition: symtab.h:1165
const struct symbol_computed_ops * ops_computed
Definition: symtab.h:1168
const struct symbol_block_ops * ops_block
Definition: symtab.h:1171
const struct symbol_register_ops * ops_register
Definition: symtab.h:1174
static int compare_search_syms(const symbol_search &sym_a, const symbol_search &sym_b)
Definition: symtab.c:4569
struct symbol * symbol
Definition: symtab.h:2447
const block * value_block() const
Definition: symtab.h:1348
address_class aclass() const
Definition: symtab.h:1235
unsigned maybe_copied
Definition: symtab.h:1448
struct type * type() const
Definition: symtab.h:1285
domain_enum domain() const
Definition: symtab.h:1240
bool is_objfile_owned() const
Definition: symtab.h:1250
union symbol::@179 owner
CORE_ADDR value_address() const
Definition: symtab.h:1315
struct objfile * objfile() const
Definition: symtab.c:6477
struct symtab * symtab
Definition: symtab.h:1414
struct gdbarch * arch
Definition: symtab.h:1417
unsigned short line() const
Definition: symtab.h:1295
void set_symtab(struct symtab *symtab)
Definition: symtab.c:6505
bool explicit_line
Definition: symtab.h:2275
struct obj_section * section
Definition: symtab.h:2265
bool explicit_pc
Definition: symtab.h:2274
struct symbol * symbol
Definition: symtab.h:2264
struct symtab * symtab
Definition: symtab.h:2263
CORE_ADDR pc
Definition: symtab.h:2272
CORE_ADDR end
Definition: symtab.h:2273
struct program_space * pspace
Definition: symtab.h:2261
struct minimal_symbol * msymbol
Definition: symtab.h:2266
enum language language() const
Definition: symtab.h:1623
char * fullname
Definition: symtab.h:1670
struct compunit_symtab * compunit() const
Definition: symtab.h:1603
struct linetable * linetable() const
Definition: symtab.h:1613
const char * filename
Definition: symtab.h:1651
struct symtab * next
Definition: symtab.h:1636
Definition: gdbtypes.h:922
struct type * target_type() const
Definition: gdbtypes.h:1000
type_code code() const
Definition: gdbtypes.h:927
struct field & field(int idx) const
Definition: gdbtypes.h:983
int num_fields() const
Definition: gdbtypes.h:965
bool is_pointer_or_reference() const
Definition: gdbtypes.h:1394
const char * name() const
Definition: gdbtypes.h:939
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3133
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3067
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:2978
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3085
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3162
bool expand_symtabs_matching(gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info &lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, enum search_domain kind)
Definition: symfile.c:3727
CORE_ADDR pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3014
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
Definition: symfile.c:3751
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:2940
static const gdb::option::option_def info_sources_option_defs[]
Definition: symtab.c:4394
const char * domain_name(domain_enum e)
Definition: symtab.c:306
struct block_symbol lookup_static_symbol(const char *name, const domain_enum domain)
Definition: symtab.c:2606
static gdb::option::option_def_group make_info_vars_funcs_options_def_group(info_vars_funcs_options *opts)
Definition: symtab.c:5184
struct compunit_symtab * find_pc_sect_compunit_symtab(CORE_ADDR pc, struct obj_section *section)
Definition: symtab.c:2829
#define SYMBOL_LOOKUP_FAILED_P(SIB)
Definition: symtab.c:142
static void print_msymbol_info(struct bound_minimal_symbol msymbol)
Definition: symtab.c:5045
static void info_types_command(const char *args, int from_tty)
Definition: symtab.c:5272
bool find_line_pc(struct symtab *symtab, int line, CORE_ADDR *pc)
Definition: symtab.c:3473
int register_symbol_register_impl(enum address_class aclass, const struct symbol_register_ops *ops)
Definition: symtab.c:6447
bool symbol_is_function_or_method(symbol *sym)
Definition: symtab.c:5622
gdb_static_assert(MAX_SYMBOL_IMPLS<=(1<< SYMBOL_ACLASS_BITS))
void collect_symbol_completion_matches_type(completion_tracker &tracker, const char *text, const char *word, enum type_code code)
Definition: symtab.c:5956
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
Definition: symtab.c:2954
symbol * find_function_alias_target(bound_minimal_symbol msymbol)
Definition: symtab.c:4055
static void symtab_new_objfile_observer(struct objfile *objfile)
Definition: symtab.c:1690
static struct symbol_cache * get_symbol_cache(struct program_space *pspace)
Definition: symtab.c:1341
const char multiple_symbols_all[]
Definition: symtab.c:280
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
int register_symbol_block_impl(enum address_class aclass, const struct symbol_block_ops *ops)
Definition: symtab.c:6424
struct symtab * lookup_symtab(const char *name)
Definition: symtab.c:643
const char multiple_symbols_ask[]
Definition: symtab.c:279
static struct block_symbol lookup_local_symbol(const char *name, symbol_name_match_type match_type, const struct block *block, const domain_enum domain, enum language language)
void fixup_section(struct general_symbol_info *ginfo, CORE_ADDR addr, struct objfile *objfile)
Definition: symtab.c:1708
bound_minimal_symbol find_gnu_ifunc(const symbol *sym)
Definition: symtab.c:5654
static int check_field(struct type *type, const char *name, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:2028
struct type * lookup_transparent_type(const char *name)
Definition: symtab.c:2671
#define MAX_SYMBOL_CACHE_SIZE
Definition: symtab.c:136
static void maintenance_print_symbol_cache(const char *args, int from_tty)
Definition: symtab.c:1599
int register_symbol_computed_impl(enum address_class aclass, const struct symbol_computed_ops *ops)
Definition: symtab.c:6398
static int next_aclass_value
Definition: symtab.c:6371
static int eq_symbol_entry(const struct symbol_cache_slot *slot, const struct objfile *objfile_context, const char *name, domain_enum domain)
Definition: symtab.c:1220
static void completion_list_add_symbol(completion_tracker &tracker, symbol *sym, const lookup_name_info &lookup_name, const char *text, const char *word)
Definition: symtab.c:5439
static void set_symbol_cache_size_handler(const char *args, int from_tty, struct cmd_list_element *c)
Definition: symtab.c:1372
static unsigned int hash_symbol_entry(const struct objfile *objfile_context, const char *name, domain_enum domain)
Definition: symtab.c:1199
static hashval_t hash_demangled_name_entry(const void *data)
Definition: symtab.c:810
static void resize_symbol_cache(struct symbol_cache *cache, unsigned int new_size)
Definition: symtab.c:1305
static unsigned int new_symbol_cache_size
Definition: symtab.c:263
static int not_interesting_fname(const char *fname)
Definition: symtab.c:6055
bool find_pc_line_pc_range(CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3588
static void create_demangled_names_hash(struct objfile_per_bfd_storage *per_bfd)
Definition: symtab.c:845
bool compare_glob_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:499
struct block_symbol lookup_global_symbol(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2614
static void free_demangled_name_entry(void *data)
Definition: symtab.c:832
static void print_symbol_info(enum search_domain kind, struct symbol *sym, int block, const char *last)
Definition: symtab.c:5013
static void info_module_variables_command(const char *args, int from_tty)
Definition: symtab.c:6824
void iterate_over_symtabs(const char *name, gdb::function_view< bool(symtab *)> callback)
Definition: symtab.c:607
static void symtab_observer_executable_changed(void)
Definition: symtab.c:6336
static void info_types_command_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: symtab.c:5287
static gdb::option::option_def_group make_info_types_options_def_group(info_types_options *opts)
Definition: symtab.c:5264
static symtab_and_line find_function_start_sal_1(CORE_ADDR func_addr, obj_section *section, bool funfirstline)
Definition: symtab.c:3602
static struct block_symbol lookup_symbol_via_quick_fns(struct objfile *objfile, enum block_enum block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2399
bool producer_is_realview(const char *producer)
Definition: symtab.c:6346
const char multiple_symbols_cancel[]
Definition: symtab.c:281
static void find_main_name(void)
Definition: symtab.c:6215
void collect_file_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word, const char *srcfile)
Definition: symtab.c:5975
char * gdb_mangle_name(struct type *type, int method_id, int signature_id)
Definition: symtab.c:663
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3956
bool iterate_over_symbols_terminated(const struct block *block, const lookup_name_info &name, const domain_enum domain, gdb::function_view< symbol_found_callback_ftype > callback)
Definition: symtab.c:2814
bool symbol_matches_search_name(const struct general_symbol_info *gsymbol, const lookup_name_info &name)
Definition: symtab.c:1098
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition: symtab.c:3319
static void info_functions_command(const char *args, int from_tty)
Definition: symtab.c:5227
bool find_line_pc_range(struct symtab_and_line sal, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3500
static struct block_symbol lookup_symbol_in_objfile(struct objfile *objfile, enum block_enum block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2520
struct block_symbol lookup_global_symbol_from_objfile(struct objfile *main_objfile, enum block_enum block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2253
static struct block_symbol lookup_symbol_aux(const char *name, symbol_name_match_type match_type, const struct block *block, const domain_enum domain, enum language language, struct field_of_this_result *)
void skip_prologue_sal(struct symtab_and_line *sal)
Definition: symtab.c:3755
symtab_and_line find_function_start_sal(CORE_ADDR func_addr, obj_section *section, bool funfirstline)
Definition: symtab.c:3640
CORE_ADDR get_symbol_address(const struct symbol *sym)
Definition: symtab.c:6514
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1788
static gdb::option::option_def_group make_info_sources_options_def_group(filename_partial_match_opts *isrc_opts)
Definition: symtab.c:4414
static struct main_info * get_main_info(void)
Definition: symtab.c:6175
static gdb::option::option_def_group make_info_modules_var_func_options_def_group(info_modules_var_func_options *opts)
Definition: symtab.c:6797
struct symtab_and_line find_pc_sect_line(CORE_ADDR pc, struct obj_section *section, int notcurrent)
Definition: symtab.c:3033
static void initialize_ordinary_address_classes(void)
Definition: symtab.c:6464
struct block_symbol lookup_symbol_in_language(const char *name, const struct block *block, const domain_enum domain, enum language lang, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1949
static struct type * basic_lookup_transparent_type_1(struct objfile *objfile, enum block_enum block_index, const char *name)
Definition: symtab.c:2708
completion_list make_source_files_completion_list(const char *text, const char *word)
Definition: symtab.c:6115
static void ATTRIBUTE_NORETURN error_in_psymtab_expansion(enum block_enum block_index, const char *name, struct compunit_symtab *cust)
Definition: symtab.c:2382
struct symbol * find_symbol_at_address(CORE_ADDR address)
Definition: symtab.c:2962
const char * main_name()
Definition: symtab.c:6309
static void symbol_cache_stats(struct symbol_cache *cache)
Definition: symtab.c:1634
struct type * basic_lookup_transparent_type(const char *name)
Definition: symtab.c:2739
void default_collect_symbol_completion_matches_break_on(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word, const char *break_on, enum type_code code)
Definition: symtab.c:5732
static void info_modules_command(const char *args, int from_tty)
Definition: symtab.c:5304
bool compare_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:461
static void set_main_name(const char *name, enum language lang)
Definition: symtab.c:6194
static void completion_list_add_fields(completion_tracker &tracker, struct symbol *sym, const lookup_name_info &lookup_name, const char *text, const char *word)
Definition: symtab.c:5599
static struct type * basic_lookup_transparent_type_quick(struct objfile *objfile, enum block_enum block_index, const char *name)
Definition: symtab.c:2680
bool treg_matches_sym_type_name(const compiled_regex &treg, const struct symbol *sym)
Definition: symtab.c:4589
struct symtab * find_line_symtab(struct symtab *sym_tab, int line, int *index, bool *exact_match)
Definition: symtab.c:3340
static void info_vars_funcs_command_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: symtab.c:5192
static void info_variables_command(const char *args, int from_tty)
Definition: symtab.c:5209
static unsigned int symbol_cache_size
Definition: symtab.c:268
static gdb::optional< CORE_ADDR > skip_prologue_using_linetable(CORE_ADDR func_addr)
Definition: symtab.c:3717
static const gdb::option::option_def info_vars_funcs_options_defs[]
Definition: symtab.c:5157
static void info_sources_command(const char *args, int from_tty)
Definition: symtab.c:4513
static const char * language_search_unquoted_string(const char *text, const char *p)
Definition: symtab.c:5556
std::vector< module_symbol_search > search_module_symbols(const char *module_regexp, const char *regexp, const char *type_regexp, search_domain kind)
Definition: symtab.c:6568
const char * multiple_symbols_select_mode(void)
Definition: symtab.c:298
static void info_module_subcommand(bool quiet, const char *module_regexp, const char *regexp, const char *type_regexp, search_domain kind)
Definition: symtab.c:6618
bool basenames_may_differ
Definition: symtab.c:273
static void rbreak_command(const char *, int)
Definition: symtab.c:5318
static void info_module_functions_command(const char *args, int from_tty)
Definition: symtab.c:6805
gdb::unique_xmalloc_ptr< char > symbol_find_demangled_name(struct general_symbol_info *gsymbol, const char *mangled)
Definition: symtab.c:870
bool iterate_over_symbols(const struct block *block, const lookup_name_info &name, const domain_enum domain, gdb::function_view< symbol_found_callback_ftype > callback)
Definition: symtab.c:2789
static void symtab_symbol_info(bool quiet, bool exclude_minsyms, const char *regexp, enum search_domain kind, const char *t_regexp, int from_tty)
Definition: symtab.c:5073
static void symtab_free_objfile_observer(struct objfile *objfile)
Definition: symtab.c:1699
static void symbol_cache_mark_not_found(struct block_symbol_cache *bsc, struct symbol_cache_slot *slot, struct objfile *objfile_context, const char *name, domain_enum domain)
Definition: symtab.c:1477
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition: symtab.c:1979
const char * search_domain_name(enum search_domain e)
Definition: symtab.c:323
#define SYMBOL_LOOKUP_FAILED
Definition: symtab.c:140
static bool ignore_prologue_end_flag
Definition: symtab.c:293
bool iterate_over_some_symtabs(const char *name, const char *real_path, struct compunit_symtab *first, struct compunit_symtab *after_last, gdb::function_view< bool(symtab *)> callback)
Definition: symtab.c:542
void info_sources_worker(struct ui_out *uiout, bool group_by_objfile, const info_sources_filter &filter)
Definition: symtab.c:4435
struct symbol * lookup_symbol_in_block(const char *name, symbol_name_match_type match_type, const struct block *block, const domain_enum domain)
Definition: symtab.c:2220
static const char *const multiple_symbols_modes[]
Definition: symtab.c:282
struct block_symbol lookup_symbol_in_static_block(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2483
static const gdb::option::option_def info_types_options_defs[]
Definition: symtab.c:5252
symbol_cache_slot_state
Definition: symtab.c:148
@ SYMBOL_SLOT_NOT_FOUND
Definition: symtab.c:150
@ SYMBOL_SLOT_UNUSED
Definition: symtab.c:149
@ SYMBOL_SLOT_FOUND
Definition: symtab.c:151
bool completion_list_add_name(completion_tracker &tracker, language symbol_language, const char *symname, const lookup_name_info &lookup_name, const char *text, const char *word)
Definition: symtab.c:5397
static const registry< program_space >::key< symbol_cache > symbol_cache_key
Definition: symtab.c:254
const char * demangle_for_lookup(const char *name, enum language lang, demangle_result_storage &storage)
Definition: symtab.c:1893
static void info_sources_command_completer(cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: symtab.c:4422
static int eq_demangled_name_entry(const void *a, const void *b)
Definition: symtab.c:821
static struct block_symbol symbol_cache_lookup(struct symbol_cache *cache, struct objfile *objfile_context, enum block_enum block, const char *name, domain_enum domain, struct block_symbol_cache **bsc_ptr, struct symbol_cache_slot **slot_ptr)
Definition: symtab.c:1398
bool matching_obj_sections(struct obj_section *obj_first, struct obj_section *obj_second)
Definition: symtab.c:1113
static struct block_symbol lookup_global_or_static_symbol(const char *name, enum block_enum block_index, struct objfile *objfile, const domain_enum domain)
Definition: symtab.c:2559
void collect_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word)
Definition: symtab.c:5941
#define MAX_SYMBOL_IMPLS
Definition: symtab.c:6375
static void symbol_cache_mark_found(struct block_symbol_cache *bsc, struct symbol_cache_slot *slot, struct objfile *objfile_context, struct symbol *symbol, const struct block *block)
Definition: symtab.c:1453
void expand_symtab_containing_pc(CORE_ADDR pc, struct obj_section *section)
Definition: symtab.c:1176
static void info_module_var_func_command_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: symtab.c:6843
unsigned int symbol_lookup_debug
Definition: symtab.c:260
static void set_symbol_cache_size(unsigned int new_size)
Definition: symtab.c:1357
static int find_line_common(struct linetable *, int, int *, int)
Definition: symtab.c:3540
static bool file_matches(const char *file, const std::vector< const char * > &filenames, bool basenames)
Definition: symtab.c:4549
bool symbol_matches_domain(enum language symbol_language, domain_enum symbol_domain, domain_enum domain)
Definition: symtab.c:2649
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3297
static const char * multiple_symbols_mode
Definition: symtab.c:289
static int compare_symbol_name(const char *symbol_name, language symbol_language, const lookup_name_info &lookup_name, completion_match_result &match_res)
Definition: symtab.c:5382
#define DEFAULT_SYMBOL_CACHE_SIZE
Definition: symtab.c:131
struct block_symbol lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1989
static void completion_list_objc_symbol(completion_tracker &tracker, struct minimal_symbol *msymbol, const lookup_name_info &lookup_name, const char *text, const char *word)
Definition: symtab.c:5489
static void maintenance_print_symbol_cache_statistics(const char *args, int from_tty)
Definition: symtab.c:1666
static const gdb::option::option_def info_modules_var_func_options_defs[]
Definition: symtab.c:6770
static const char * operator_chars(const char *p, const char **end)
Definition: symtab.c:4077
std::string symbol_to_info_string(struct symbol *sym, int block, enum search_domain kind)
Definition: symtab.c:4951
static void add_filename_to_list(const char *fname, const char *text, const char *word, completion_list *list)
Definition: symtab.c:6048
static struct block_symbol lookup_symbol_in_objfile_symtabs(struct objfile *objfile, enum block_enum block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2278
static const registry< program_space >::key< main_info > main_progspace_key
Definition: symtab.c:124
static size_t symbol_cache_byte_size(unsigned int size)
Definition: symtab.c:1296
static void symbol_cache_dump(const struct symbol_cache *cache)
Definition: symtab.c:1543
static void completion_list_add_msymbol(completion_tracker &tracker, minimal_symbol *sym, const lookup_name_info &lookup_name, const char *text, const char *word)
Definition: symtab.c:5474
std::vector< CORE_ADDR > find_pcs_for_symtab_line(struct symtab *symtab, int line, struct linetable_entry **best_item)
Definition: symtab.c:3432
static struct cmd_list_element * info_module_cmdlist
Definition: symtab.c:6563
static void add_symtab_completions(struct compunit_symtab *cust, completion_tracker &tracker, complete_symbol_mode mode, const lookup_name_info &lookup_name, const char *text, const char *word, enum type_code code)
Definition: symtab.c:5696
enum language main_language(void)
Definition: symtab.c:6323
static void symbol_cache_flush(struct program_space *pspace)
Definition: symtab.c:1498
static void symbol_cache_clear_slot(struct symbol_cache_slot *slot)
Definition: symtab.c:190
void _initialize_symtab()
Definition: symtab.c:6862
CORE_ADDR get_msymbol_address(struct objfile *objf, const struct minimal_symbol *minsym)
Definition: symtab.c:6537
static CORE_ADDR skip_prologue_using_lineinfo(CORE_ADDR func_addr, struct symtab *symtab)
Definition: symtab.c:3675
unsigned int search_name_hash(enum language language, const char *search_name)
Definition: symtab.c:1931
static struct block_symbol lookup_symbol_in_objfile_from_linkage_name(struct objfile *objfile, const char *linkage_name, domain_enum domain)
Definition: symtab.c:2347
unsigned int symtab_create_debug
Definition: symtab.c:257
static void maintenance_flush_symbol_cache(const char *args, int from_tty)
Definition: symtab.c:1623
static void destroy_block_symbol_cache(struct block_symbol_cache *bsc)
Definition: symtab.c:218
#define symbol_lookup_debug_printf_v(fmt,...)
Definition: symtab.h:2652
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR)
Definition: symtab.c:2954
search_domain
Definition: symtab.h:916
@ VARIABLES_DOMAIN
Definition: symtab.h:919
@ FUNCTIONS_DOMAIN
Definition: symtab.h:922
@ TYPES_DOMAIN
Definition: symtab.h:925
@ MODULES_DOMAIN
Definition: symtab.h:928
@ ALL_DOMAIN
Definition: symtab.h:931
symbol_name_match_type
Definition: symtab.h:62
bool() symbol_name_matcher_ftype(const char *symbol_search_name, const lookup_name_info &lookup_name, completion_match_result *comp_match_res)
Definition: symtab.h:398
address_class
Definition: symtab.h:939
@ LOC_STATIC
Definition: symtab.h:950
@ LOC_BLOCK
Definition: symtab.h:999
@ LOC_LABEL
Definition: symtab.h:993
@ LOC_REGISTER
Definition: symtab.h:964
@ LOC_UNRESOLVED
Definition: symtab.h:1028
@ LOC_CONST
Definition: symtab.h:946
@ LOC_TYPEDEF
Definition: symtab.h:989
@ LOC_FINAL_VALUE
Definition: symtab.h:1044
@ LOC_REGPARM_ADDR
Definition: symtab.h:980
@ LOC_COMPUTED
Definition: symtab.h:1037
struct block_symbol lookup_global_symbol(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2614
#define symbol_lookup_debug_printf(fmt,...)
Definition: symtab.h:2646
#define SYMBOL_ACLASS_BITS
Definition: symtab.h:1053
#define SYMBOL_LOOKUP_SCOPED_DEBUG_ENTER_EXIT
Definition: symtab.h:2658
@ mst_data_gnu_ifunc
Definition: symtab.h:673
@ mst_abs
Definition: symtab.h:679
@ mst_bss
Definition: symtab.h:678
@ mst_data
Definition: symtab.h:677
@ mst_solib_trampoline
Definition: symtab.h:688
@ mst_file_text
Definition: symtab.h:691
@ mst_slot_got_plt
Definition: symtab.h:676
@ mst_file_data
Definition: symtab.h:692
@ mst_text
Definition: symtab.h:655
@ mst_text_gnu_ifunc
Definition: symtab.h:664
@ mst_file_bss
Definition: symtab.h:693
gdb::array_view< const struct symbol_impl > symbol_impls
bool treg_matches_sym_type_name(const compiled_regex &treg, const struct symbol *sym)
Definition: symtab.c:4589
std::pair< symbol_search, symbol_search > module_symbol_search
Definition: symtab.h:2567
domain_enum
Definition: symtab.h:871
@ VAR_DOMAIN
Definition: symtab.h:881
@ STRUCT_DOMAIN
Definition: symtab.h:887
@ LABEL_DOMAIN
Definition: symtab.h:895
@ COMMON_BLOCK_DOMAIN
Definition: symtab.h:899
@ UNDEF_DOMAIN
Definition: symtab.h:876
@ MODULE_DOMAIN
Definition: symtab.h:891
struct symtab_and_line find_pc_sect_line(CORE_ADDR, struct obj_section *, int)
Definition: symtab.c:3033
bool basenames_may_differ
Definition: symtab.c:273
gdb::unique_xmalloc_ptr< char > symbol_find_demangled_name(struct general_symbol_info *gsymbol, const char *mangled)
Definition: symtab.c:870
static bool completion_skip_symbol(complete_symbol_mode mode, Symbol *sym)
Definition: symtab.h:2366
struct block_symbol lookup_symbol_in_static_block(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2483
const char * demangle_for_lookup(const char *name, enum language lang, demangle_result_storage &storage)
Definition: symtab.c:1893
complete_symbol_mode
Definition: symtab.h:2320
CORE_ADDR get_msymbol_address(struct objfile *objf, const struct minimal_symbol *minsym)
Definition: symtab.c:6537
std::string type_to_string(struct type *type)
Definition: typeprint.c:402
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:391
void typedef_print(struct type *type, struct symbol *newobj, struct ui_file *stream)
Definition: typeprint.c:378
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition: ui-out.h:151
#define current_uiout
Definition: ui-out.h:40
std::string ldirname(const char *filename)
Definition: utils.c:3254
int gdb_filename_fnmatch(const char *pattern, const char *string, int flags)
Definition: utils.c:3420
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865
int count_path_elements(const char *path)
Definition: utils.c:3464
const char * strip_leading_path_elements(const char *path, int n)
Definition: utils.c:3500
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1788
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2981
static unsigned int fast_hash(const void *ptr, size_t len, unsigned int start_value=0)
Definition: utils.h:357