GDB (xrefs)

/tmp/gdb-8.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-2018 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 "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 "fnmatch.h"
45 #include "hashtab.h"
46
47 #include "gdb_obstack.h"
48 #include "block.h"
49 #include "dictionary.h"
50
51 #include <sys/types.h>
52 #include <fcntl.h>
53 #include <sys/stat.h>
54 #include <ctype.h>
55 #include "cp-abi.h"
56 #include "cp-support.h"
57 #include "observer.h"
58 #include "solist.h"
59 #include "macrotab.h"
60 #include "macroscope.h"
61
62 #include "parser-defs.h"
63 #include "completer.h"
64 #include "progspace-and-thread.h"
65 #include "common/gdb_optional.h"
66 #include "filename-seen-cache.h"
67 #include "arch-utils.h"
68 #include <algorithm>
69
70 /* Forward declarations for local functions. */
71
72 static void rbreak_command (const char *, int);
73
74 static int find_line_common (struct linetable *, int, int *, int);
75
76 static struct block_symbol
77 lookup_symbol_aux (const char *name,
78 symbol_name_match_type match_type,
79 const struct block *block,
80 const domain_enum domain,
81 enum language language,
82 struct field_of_this_result *);
83
84 static
85 struct block_symbol lookup_local_symbol (const char *name,
86 symbol_name_match_type match_type,
87 const struct block *block,
88 const domain_enum domain,
89 enum language language);
90
91 static struct block_symbol
92 lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
93 const char *name, const domain_enum domain);
94
95 /* See symtab.h. */
96 const struct block_symbol null_block_symbol = { NULL, NULL };
97
98 /* Program space key for finding name and language of "main". */
99
100 static const struct program_space_data *main_progspace_key;
101
102 /* Type of the data stored on the program space. */
103
104 struct main_info
105 {
106 /* Name of "main". */
107
108 char *name_of_main;
109
110 /* Language of "main". */
111
112 enum language language_of_main;
113 };
114
115 /* Program space key for finding its symbol cache. */
116
117 static const struct program_space_data *symbol_cache_key;
118
119 /* The default symbol cache size.
120 There is no extra cpu cost for large N (except when flushing the cache,
121 which is rare). The value here is just a first attempt. A better default
122 value may be higher or lower. A prime number can make up for a bad hash
123 computation, so that's why the number is what it is. */
124 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
125
126 /* The maximum symbol cache size.
127 There's no method to the decision of what value to use here, other than
128 there's no point in allowing a user typo to make gdb consume all memory. */
129 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
130
131 /* symbol_cache_lookup returns this if a previous lookup failed to find the
132 symbol in any objfile. */
133 #define SYMBOL_LOOKUP_FAILED \
134 ((struct block_symbol) {(struct symbol *) 1, NULL})
135 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
136
137 /* Recording lookups that don't find the symbol is just as important, if not
138 more so, than recording found symbols. */
139
140 enum symbol_cache_slot_state
141 {
142 SYMBOL_SLOT_UNUSED,
143 SYMBOL_SLOT_NOT_FOUND,
144 SYMBOL_SLOT_FOUND
145 };
146
147 struct symbol_cache_slot
148 {
149 enum symbol_cache_slot_state state;
150
151 /* The objfile that was current when the symbol was looked up.
152 This is only needed for global blocks, but for simplicity's sake
153 we allocate the space for both. If data shows the extra space used
154 for static blocks is a problem, we can split things up then.
155
156 Global blocks need cache lookup to include the objfile context because
157 we need to account for gdbarch_iterate_over_objfiles_in_search_order
158 which can traverse objfiles in, effectively, any order, depending on
159 the current objfile, thus affecting which symbol is found. Normally,
160 only the current objfile is searched first, and then the rest are
161 searched in recorded order; but putting cache lookup inside
162 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
163 Instead we just make the current objfile part of the context of
164 cache lookup. This means we can record the same symbol multiple times,
165 each with a different "current objfile" that was in effect when the
166 lookup was saved in the cache, but cache space is pretty cheap. */
167 const struct objfile *objfile_context;
168
169 union
170 {
171 struct block_symbol found;
172 struct
173 {
174 char *name;
175 domain_enum domain;
176 } not_found;
177 } value;
178 };
179
180 /* Symbols don't specify global vs static block.
181 So keep them in separate caches. */
182
183 struct block_symbol_cache
184 {
185 unsigned int hits;
186 unsigned int misses;
187 unsigned int collisions;
188
189 /* SYMBOLS is a variable length array of this size.
190 One can imagine that in general one cache (global/static) should be a
191 fraction of the size of the other, but there's no data at the moment
192 on which to decide. */
193 unsigned int size;
194
195 struct symbol_cache_slot symbols[1];
196 };
197
198 /* The symbol cache.
199
200 Searching for symbols in the static and global blocks over multiple objfiles
201 again and again can be slow, as can searching very big objfiles. This is a
202 simple cache to improve symbol lookup performance, which is critical to
203 overall gdb performance.
204
205 Symbols are hashed on the name, its domain, and block.
206 They are also hashed on their objfile for objfile-specific lookups. */
207
208 struct symbol_cache
209 {
210 struct block_symbol_cache *global_symbols;
211 struct block_symbol_cache *static_symbols;
212 };
213
214 /* When non-zero, print debugging messages related to symtab creation. */
215 unsigned int symtab_create_debug = 0;
216
217 /* When non-zero, print debugging messages related to symbol lookup. */
218 unsigned int symbol_lookup_debug = 0;
219
220 /* The size of the cache is staged here. */
221 static unsigned int new_symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
222
223 /* The current value of the symbol cache size.
224 This is saved so that if the user enters a value too big we can restore
225 the original value from here. */
226 static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE;
227
228 /* Non-zero if a file may be known by two different basenames.
229 This is the uncommon case, and significantly slows down gdb.
230 Default set to "off" to not slow down the common case. */
231 int basenames_may_differ = 0;
232
233 /* Allow the user to configure the debugger behavior with respect
234 to multiple-choice menus when more than one symbol matches during
235 a symbol lookup. */
236
237 const char multiple_symbols_ask[] = "ask";
238 const char multiple_symbols_all[] = "all";
239 const char multiple_symbols_cancel[] = "cancel";
240 static const char *const multiple_symbols_modes[] =
241 {
242 multiple_symbols_ask,
243 multiple_symbols_all,
244 multiple_symbols_cancel,
245 NULL
246 };
247 static const char *multiple_symbols_mode = multiple_symbols_all;
248
249 /* Read-only accessor to AUTO_SELECT_MODE. */
250
251 const char *
252 multiple_symbols_select_mode (void)
253 {
254 return multiple_symbols_mode;
255 }
256
257 /* Return the name of a domain_enum. */
258
259 const char *
260 domain_name (domain_enum e)
261 {
262 switch (e)
263 {
264 case UNDEF_DOMAIN: return "UNDEF_DOMAIN";
265 case VAR_DOMAIN: return "VAR_DOMAIN";
266 case STRUCT_DOMAIN: return "STRUCT_DOMAIN";
267 case MODULE_DOMAIN: return "MODULE_DOMAIN";
268 case LABEL_DOMAIN: return "LABEL_DOMAIN";
269 case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN";
270 default: gdb_assert_not_reached ("bad domain_enum");
271 }
272 }
273
274 /* Return the name of a search_domain . */
275
276 const char *
277 search_domain_name (enum search_domain e)
278 {
279 switch (e)
280 {
281 case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN";
282 case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN";
283 case TYPES_DOMAIN: return "TYPES_DOMAIN";
284 case ALL_DOMAIN: return "ALL_DOMAIN";
285 default: gdb_assert_not_reached ("bad search_domain");
286 }
287 }
288
289 /* See symtab.h. */
290
291 struct symtab *
292 compunit_primary_filetab (const struct compunit_symtab *cust)
293 {
294 gdb_assert (COMPUNIT_FILETABS (cust) != NULL);
295
296 /* The primary file symtab is the first one in the list. */
297 return COMPUNIT_FILETABS (cust);
298 }
299
300 /* See symtab.h. */
301
302 enum language
303 compunit_language (const struct compunit_symtab *cust)
304 {
305 struct symtab *symtab = compunit_primary_filetab (cust);
306
307 /* The language of the compunit symtab is the language of its primary
308 source file. */
309 return SYMTAB_LANGUAGE (symtab);
310 }
311
312 /* See whether FILENAME matches SEARCH_NAME using the rule that we
313 advertise to the user. (The manual's description of linespecs
314 describes what we advertise). Returns true if they match, false
315 otherwise. */
316
317 int
318 compare_filenames_for_search (const char *filename, const char *search_name)
319 {
320 int len = strlen (filename);
321 size_t search_len = strlen (search_name);
322
323 if (len < search_len)
324 return 0;
325
326 /* The tail of FILENAME must match. */
327 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
328 return 0;
329
330 /* Either the names must completely match, or the character
331 preceding the trailing SEARCH_NAME segment of FILENAME must be a
332 directory separator.
333
334 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
335 cannot match FILENAME "/path//dir/file.c" - as user has requested
336 absolute path. The sama applies for "c:\file.c" possibly
337 incorrectly hypothetically matching "d:\dir\c:\file.c".
338
339 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
340 compatible with SEARCH_NAME "file.c". In such case a compiler had
341 to put the "c:file.c" name into debug info. Such compatibility
342 works only on GDB built for DOS host. */
343 return (len == search_len
344 || (!IS_ABSOLUTE_PATH (search_name)
345 && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
346 || (HAS_DRIVE_SPEC (filename)
347 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
348 }
349
350 /* Same as compare_filenames_for_search, but for glob-style patterns.
351 Heads up on the order of the arguments. They match the order of
352 compare_filenames_for_search, but it's the opposite of the order of
353 arguments to gdb_filename_fnmatch. */
354
355 int
356 compare_glob_filenames_for_search (const char *filename,
357 const char *search_name)
358 {
359 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
360 all /s have to be explicitly specified. */
361 int file_path_elements = count_path_elements (filename);
362 int search_path_elements = count_path_elements (search_name);
363
364 if (search_path_elements > file_path_elements)
365 return 0;
366
367 if (IS_ABSOLUTE_PATH (search_name))
368 {
369 return (search_path_elements == file_path_elements
370 && gdb_filename_fnmatch (search_name, filename,
371 FNM_FILE_NAME | FNM_NOESCAPE) == 0);
372 }
373
374 {
375 const char *file_to_compare
376 = strip_leading_path_elements (filename,
377 file_path_elements - search_path_elements);
378
379 return gdb_filename_fnmatch (search_name, file_to_compare,
380 FNM_FILE_NAME | FNM_NOESCAPE) == 0;
381 }
382 }
383
384 /* Check for a symtab of a specific name by searching some symtabs.
385 This is a helper function for callbacks of iterate_over_symtabs.
386
387 If NAME is not absolute, then REAL_PATH is NULL
388 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
389
390 The return value, NAME, REAL_PATH and CALLBACK are identical to the
391 `map_symtabs_matching_filename' method of quick_symbol_functions.
392
393 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
394 Each symtab within the specified compunit symtab is also searched.
395 AFTER_LAST is one past the last compunit symtab to search; NULL means to
396 search until the end of the list. */
397
398 bool
399 iterate_over_some_symtabs (const char *name,
400 const char *real_path,
401 struct compunit_symtab *first,
402 struct compunit_symtab *after_last,
403 gdb::function_view<bool (symtab *)> callback)
404 {
405 struct compunit_symtab *cust;
406 struct symtab *s;
407 const char* base_name = lbasename (name);
408
409 for (cust = first; cust != NULL && cust != after_last; cust = cust->next)
410 {
411 ALL_COMPUNIT_FILETABS (cust, s)
412 {
413 if (compare_filenames_for_search (s->filename, name))
414 {
415 if (callback (s))
416 return true;
417 continue;
418 }
419
420 /* Before we invoke realpath, which can get expensive when many
421 files are involved, do a quick comparison of the basenames. */
422 if (! basenames_may_differ
423 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
424 continue;
425
426 if (compare_filenames_for_search (symtab_to_fullname (s), name))
427 {
428 if (callback (s))
429 return true;
430 continue;
431 }
432
433 /* If the user gave us an absolute path, try to find the file in
434 this symtab and use its absolute path. */
435 if (real_path != NULL)
436 {
437 const char *fullname = symtab_to_fullname (s);
438
439 gdb_assert (IS_ABSOLUTE_PATH (real_path));
440 gdb_assert (IS_ABSOLUTE_PATH (name));
441 if (FILENAME_CMP (real_path, fullname) == 0)
442 {
443 if (callback (s))
444 return true;
445 continue;
446 }
447 }
448 }
449 }
450
451 return false;
452 }
453
454 /* Check for a symtab of a specific name; first in symtabs, then in
455 psymtabs. *If* there is no '/' in the name, a match after a '/'
456 in the symtab filename will also work.
457
458 Calls CALLBACK with each symtab that is found. If CALLBACK returns
459 true, the search stops. */
460
461 void
462 iterate_over_symtabs (const char *name,
463 gdb::function_view<bool (symtab *)> callback)
464 {
465 struct objfile *objfile;
466 gdb::unique_xmalloc_ptr<char> real_path;
467
468 /* Here we are interested in canonicalizing an absolute path, not
469 absolutizing a relative path. */
470 if (IS_ABSOLUTE_PATH (name))
471 {
472 real_path = gdb_realpath (name);
473 gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
474 }
475
476 ALL_OBJFILES (objfile)
477 {
478 if (iterate_over_some_symtabs (name, real_path.get (),
479 objfile->compunit_symtabs, NULL,
480 callback))
481 return;
482 }
483
484 /* Same search rules as above apply here, but now we look thru the
485 psymtabs. */
486
487 ALL_OBJFILES (objfile)
488 {
489 if (objfile->sf
490 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
491 name,
492 real_path.get (),
493 callback))
494 return;
495 }
496 }
497
498 /* A wrapper for iterate_over_symtabs that returns the first matching
499 symtab, or NULL. */
500
501 struct symtab *
502 lookup_symtab (const char *name)
503 {
504 struct symtab *result = NULL;
505
506 iterate_over_symtabs (name, [&] (symtab *symtab)
507 {
508 result = symtab;
509 return true;
510 });
511
512 return result;
513 }
514
515
516 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
517 full method name, which consist of the class name (from T), the unadorned
518 method name from METHOD_ID, and the signature for the specific overload,
519 specified by SIGNATURE_ID. Note that this function is g++ specific. */
520
521 char *
522 gdb_mangle_name (struct type *type, int method_id, int signature_id)
523 {
524 int mangled_name_len;
525 char *mangled_name;
526 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
527 struct fn_field *method = &f[signature_id];
528 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
529 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
530 const char *newname = type_name_no_tag (type);
531
532 /* Does the form of physname indicate that it is the full mangled name
533 of a constructor (not just the args)? */
534 int is_full_physname_constructor;
535
536 int is_constructor;
537 int is_destructor = is_destructor_name (physname);
538 /* Need a new type prefix. */
539 const char *const_prefix = method->is_const ? "C" : "";
540 const char *volatile_prefix = method->is_volatile ? "V" : "";
541 char buf[20];
542 int len = (newname == NULL ? 0 : strlen (newname));
543
544 /* Nothing to do if physname already contains a fully mangled v3 abi name
545 or an operator name. */
546 if ((physname[0] == '_' && physname[1] == 'Z')
547 || is_operator_name (field_name))
548 return xstrdup (physname);
549
550 is_full_physname_constructor = is_constructor_name (physname);
551
552 is_constructor = is_full_physname_constructor
553 || (newname && strcmp (field_name, newname) == 0);
554
555 if (!is_destructor)
556 is_destructor = (startswith (physname, "__dt"));
557
558 if (is_destructor || is_full_physname_constructor)
559 {
560 mangled_name = (char *) xmalloc (strlen (physname) + 1);
561 strcpy (mangled_name, physname);
562 return mangled_name;
563 }
564
565 if (len == 0)
566 {
567 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
568 }
569 else if (physname[0] == 't' || physname[0] == 'Q')
570 {
571 /* The physname for template and qualified methods already includes
572 the class name. */
573 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
574 newname = NULL;
575 len = 0;
576 }
577 else
578 {
579 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
580 volatile_prefix, len);
581 }
582 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
583 + strlen (buf) + len + strlen (physname) + 1);
584
585 mangled_name = (char *) xmalloc (mangled_name_len);
586 if (is_constructor)
587 mangled_name[0] = '\0';
588 else
589 strcpy (mangled_name, field_name);
590
591 strcat (mangled_name, buf);
592 /* If the class doesn't have a name, i.e. newname NULL, then we just
593 mangle it using 0 for the length of the class. Thus it gets mangled
594 as something starting with `::' rather than `classname::'. */
595 if (newname != NULL)
596 strcat (mangled_name, newname);
597
598 strcat (mangled_name, physname);
599 return (mangled_name);
600 }
601
602 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
603 correctly allocated. */
604
605 void
606 symbol_set_demangled_name (struct general_symbol_info *gsymbol,
607 const char *name,
608 struct obstack *obstack)
609 {
610 if (gsymbol->language == language_ada)
611 {
612 if (name == NULL)
613 {
614 gsymbol->ada_mangled = 0;
615 gsymbol->language_specific.obstack = obstack;
616 }
617 else
618 {
619 gsymbol->ada_mangled = 1;
620 gsymbol->language_specific.demangled_name = name;
621 }
622 }
623 else
624 gsymbol->language_specific.demangled_name = name;
625 }
626
627 /* Return the demangled name of GSYMBOL. */
628
629 const char *
630 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
631 {
632 if (gsymbol->language == language_ada)
633 {
634 if (!gsymbol->ada_mangled)
635 return NULL;
636 /* Fall through. */
637 }
638
639 return gsymbol->language_specific.demangled_name;
640 }
641
642
643 /* Initialize the language dependent portion of a symbol
644 depending upon the language for the symbol. */
645
646 void
647 symbol_set_language (struct general_symbol_info *gsymbol,
648 enum language language,
649 struct obstack *obstack)
650 {
651 gsymbol->language = language;
652 if (gsymbol->language == language_cplus
653 || gsymbol->language == language_d
654 || gsymbol->language == language_go
655 || gsymbol->language == language_objc
656 || gsymbol->language == language_fortran)
657 {
658 symbol_set_demangled_name (gsymbol, NULL, obstack);
659 }
660 else if (gsymbol->language == language_ada)
661 {
662 gdb_assert (gsymbol->ada_mangled == 0);
663 gsymbol->language_specific.obstack = obstack;
664 }
665 else
666 {
667 memset (&gsymbol->language_specific, 0,
668 sizeof (gsymbol->language_specific));
669 }
670 }
671
672 /* Functions to initialize a symbol's mangled name. */
673
674 /* Objects of this type are stored in the demangled name hash table. */
675 struct demangled_name_entry
676 {
677 const char *mangled;
678 char demangled[1];
679 };
680
681 /* Hash function for the demangled name hash. */
682
683 static hashval_t
684 hash_demangled_name_entry (const void *data)
685 {
686 const struct demangled_name_entry *e
687 = (const struct demangled_name_entry *) data;
688
689 return htab_hash_string (e->mangled);
690 }
691
692 /* Equality function for the demangled name hash. */
693
694 static int
695 eq_demangled_name_entry (const void *a, const void *b)
696 {
697 const struct demangled_name_entry *da
698 = (const struct demangled_name_entry *) a;
699 const struct demangled_name_entry *db
700 = (const struct demangled_name_entry *) b;
701
702 return strcmp (da->mangled, db->mangled) == 0;
703 }
704
705 /* Create the hash table used for demangled names. Each hash entry is
706 a pair of strings; one for the mangled name and one for the demangled
707 name. The entry is hashed via just the mangled name. */
708
709 static void
710 create_demangled_names_hash (struct objfile *objfile)
711 {
712 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
713 The hash table code will round this up to the next prime number.
714 Choosing a much larger table size wastes memory, and saves only about
715 1% in symbol reading. */
716
717 objfile->per_bfd->demangled_names_hash = htab_create_alloc
718 (256, hash_demangled_name_entry, eq_demangled_name_entry,
719 NULL, xcalloc, xfree);
720 }
721
722 /* Try to determine the demangled name for a symbol, based on the
723 language of that symbol. If the language is set to language_auto,
724 it will attempt to find any demangling algorithm that works and
725 then set the language appropriately. The returned name is allocated
726 by the demangler and should be xfree'd. */
727
728 static char *
729 symbol_find_demangled_name (struct general_symbol_info *gsymbol,
730 const char *mangled)
731 {
732 char *demangled = NULL;
733 int i;
734
735 if (gsymbol->language == language_unknown)
736 gsymbol->language = language_auto;
737
738 if (gsymbol->language != language_auto)
739 {
740 const struct language_defn *lang = language_def (gsymbol->language);
741
742 language_sniff_from_mangled_name (lang, mangled, &demangled);
743 return demangled;
744 }
745
746 for (i = language_unknown; i < nr_languages; ++i)
747 {
748 enum language l = (enum language) i;
749 const struct language_defn *lang = language_def (l);
750
751 if (language_sniff_from_mangled_name (lang, mangled, &demangled))
752 {
753 gsymbol->language = l;
754 return demangled;
755 }
756 }
757
758 return NULL;
759 }
760
761 /* Set both the mangled and demangled (if any) names for GSYMBOL based
762 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
763 objfile's obstack; but if COPY_NAME is 0 and if NAME is
764 NUL-terminated, then this function assumes that NAME is already
765 correctly saved (either permanently or with a lifetime tied to the
766 objfile), and it will not be copied.
767
768 The hash table corresponding to OBJFILE is used, and the memory
769 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
770 so the pointer can be discarded after calling this function. */
771
772 void
773 symbol_set_names (struct general_symbol_info *gsymbol,
774 const char *linkage_name, int len, int copy_name,
775 struct objfile *objfile)
776 {
777 struct demangled_name_entry **slot;
778 /* A 0-terminated copy of the linkage name. */
779 const char *linkage_name_copy;
780 struct demangled_name_entry entry;
781 struct objfile_per_bfd_storage *per_bfd = objfile->per_bfd;
782
783 if (gsymbol->language == language_ada)
784 {
785 /* In Ada, we do the symbol lookups using the mangled name, so
786 we can save some space by not storing the demangled name. */
787 if (!copy_name)
788 gsymbol->name = linkage_name;
789 else
790 {
791 char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,
792 len + 1);
793
794 memcpy (name, linkage_name, len);
795 name[len] = '\0';
796 gsymbol->name = name;
797 }
798 symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
799
800 return;
801 }
802
803 if (per_bfd->demangled_names_hash == NULL)
804 create_demangled_names_hash (objfile);
805
806 if (linkage_name[len] != '\0')
807 {
808 char *alloc_name;
809
810 alloc_name = (char *) alloca (len + 1);
811 memcpy (alloc_name, linkage_name, len);
812 alloc_name[len] = '\0';
813
814 linkage_name_copy = alloc_name;
815 }
816 else
817 linkage_name_copy = linkage_name;
818
819 entry.mangled = linkage_name_copy;
820 slot = ((struct demangled_name_entry **)
821 htab_find_slot (per_bfd->demangled_names_hash,
822 &entry, INSERT));
823
824 /* If this name is not in the hash table, add it. */
825 if (*slot == NULL
826 /* A C version of the symbol may have already snuck into the table.
827 This happens to, e.g., main.init (__go_init_main). Cope. */
828 || (gsymbol->language == language_go
829 && (*slot)->demangled[0] == '\0'))
830 {
831 char *demangled_name = symbol_find_demangled_name (gsymbol,
832 linkage_name_copy);
833 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
834
835 /* Suppose we have demangled_name==NULL, copy_name==0, and
836 linkage_name_copy==linkage_name. In this case, we already have the
837 mangled name saved, and we don't have a demangled name. So,
838 you might think we could save a little space by not recording
839 this in the hash table at all.
840
841 It turns out that it is actually important to still save such
842 an entry in the hash table, because storing this name gives
843 us better bcache hit rates for partial symbols. */
844 if (!copy_name && linkage_name_copy == linkage_name)
845 {
846 *slot
847 = ((struct demangled_name_entry *)
848 obstack_alloc (&per_bfd->storage_obstack,
849 offsetof (struct demangled_name_entry, demangled)
850 + demangled_len + 1));
851 (*slot)->mangled = linkage_name;
852 }
853 else
854 {
855 char *mangled_ptr;
856
857 /* If we must copy the mangled name, put it directly after
858 the demangled name so we can have a single
859 allocation. */
860 *slot
861 = ((struct demangled_name_entry *)
862 obstack_alloc (&per_bfd->storage_obstack,
863 offsetof (struct demangled_name_entry, demangled)
864 + len + demangled_len + 2));
865 mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
866 strcpy (mangled_ptr, linkage_name_copy);
867 (*slot)->mangled = mangled_ptr;
868 }
869
870 if (demangled_name != NULL)
871 {
872 strcpy ((*slot)->demangled, demangled_name);
873 xfree (demangled_name);
874 }
875 else
876 (*slot)->demangled[0] = '\0';
877 }
878
879 gsymbol->name = (*slot)->mangled;
880 if ((*slot)->demangled[0] != '\0')
881 symbol_set_demangled_name (gsymbol, (*slot)->demangled,
882 &per_bfd->storage_obstack);
883 else
884 symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
885 }
886
887 /* Return the source code name of a symbol. In languages where
888 demangling is necessary, this is the demangled name. */
889
890 const char *
891 symbol_natural_name (const struct general_symbol_info *gsymbol)
892 {
893 switch (gsymbol->language)
894 {
895 case language_cplus:
896 case language_d:
897 case language_go:
898 case language_objc:
899 case language_fortran:
900 if (symbol_get_demangled_name (gsymbol) != NULL)
901 return symbol_get_demangled_name (gsymbol);
902 break;
903 case language_ada:
904 return ada_decode_symbol (gsymbol);
905 default:
906 break;
907 }
908 return gsymbol->name;
909 }
910
911 /* Return the demangled name for a symbol based on the language for
912 that symbol. If no demangled name exists, return NULL. */
913
914 const char *
915 symbol_demangled_name (const struct general_symbol_info *gsymbol)
916 {
917 const char *dem_name = NULL;
918
919 switch (gsymbol->language)
920 {
921 case language_cplus:
922 case language_d:
923 case language_go:
924 case language_objc:
925 case language_fortran:
926 dem_name = symbol_get_demangled_name (gsymbol);
927 break;
928 case language_ada:
929 dem_name = ada_decode_symbol (gsymbol);
930 break;
931 default:
932 break;
933 }
934 return dem_name;
935 }
936
937 /* Return the search name of a symbol---generally the demangled or
938 linkage name of the symbol, depending on how it will be searched for.
939 If there is no distinct demangled name, then returns the same value
940 (same pointer) as SYMBOL_LINKAGE_NAME. */
941
942 const char *
943 symbol_search_name (const struct general_symbol_info *gsymbol)
944 {
945 if (gsymbol->language == language_ada)
946 return gsymbol->name;
947 else
948 return symbol_natural_name (gsymbol);
949 }
950
951 /* See symtab.h. */
952
953 bool
954 symbol_matches_search_name (const struct general_symbol_info *gsymbol,
955 const lookup_name_info &name)
956 {
957 symbol_name_matcher_ftype *name_match
958 = get_symbol_name_matcher (language_def (gsymbol->language), name);
959 return name_match (symbol_search_name (gsymbol), name, NULL);
960 }
961
962
963
964 /* Return 1 if the two sections are the same, or if they could
965 plausibly be copies of each other, one in an original object
966 file and another in a separated debug file. */
967
968 int
969 matching_obj_sections (struct obj_section *obj_first,
970 struct obj_section *obj_second)
971 {
972 asection *first = obj_first? obj_first->the_bfd_section : NULL;
973 asection *second = obj_second? obj_second->the_bfd_section : NULL;
974 struct objfile *obj;
975
976 /* If they're the same section, then they match. */
977 if (first == second)
978 return 1;
979
980 /* If either is NULL, give up. */
981 if (first == NULL || second == NULL)
982 return 0;
983
984 /* This doesn't apply to absolute symbols. */
985 if (first->owner == NULL || second->owner == NULL)
986 return 0;
987
988 /* If they're in the same object file, they must be different sections. */
989 if (first->owner == second->owner)
990 return 0;
991
992 /* Check whether the two sections are potentially corresponding. They must
993 have the same size, address, and name. We can't compare section indexes,
994 which would be more reliable, because some sections may have been
995 stripped. */
996 if (bfd_get_section_size (first) != bfd_get_section_size (second))
997 return 0;
998
999 /* In-memory addresses may start at a different offset, relativize them. */
1000 if (bfd_get_section_vma (first->owner, first)
1001 - bfd_get_start_address (first->owner)
1002 != bfd_get_section_vma (second->owner, second)
1003 - bfd_get_start_address (second->owner))
1004 return 0;
1005
1006 if (bfd_get_section_name (first->owner, first) == NULL
1007 || bfd_get_section_name (second->owner, second) == NULL
1008 || strcmp (bfd_get_section_name (first->owner, first),
1009 bfd_get_section_name (second->owner, second)) != 0)
1010 return 0;
1011
1012 /* Otherwise check that they are in corresponding objfiles. */
1013
1014 ALL_OBJFILES (obj)
1015 if (obj->obfd == first->owner)
1016 break;
1017 gdb_assert (obj != NULL);
1018
1019 if (obj->separate_debug_objfile != NULL
1020 && obj->separate_debug_objfile->obfd == second->owner)
1021 return 1;
1022 if (obj->separate_debug_objfile_backlink != NULL
1023 && obj->separate_debug_objfile_backlink->obfd == second->owner)
1024 return 1;
1025
1026 return 0;
1027 }
1028
1029 /* See symtab.h. */
1030
1031 void
1032 expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section)
1033 {
1034 struct objfile *objfile;
1035 struct bound_minimal_symbol msymbol;
1036
1037 /* If we know that this is not a text address, return failure. This is
1038 necessary because we loop based on texthigh and textlow, which do
1039 not include the data ranges. */
1040 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1041 if (msymbol.minsym
1042 && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
1043 || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
1044 || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
1045 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
1046 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
1047 return;
1048
1049 ALL_OBJFILES (objfile)
1050 {
1051 struct compunit_symtab *cust = NULL;
1052
1053 if (objfile->sf)
1054 cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
1055 pc, section, 0);
1056 if (cust)
1057 return;
1058 }
1059 }
1060
1061 /* Hash function for the symbol cache. */
1062
1063 static unsigned int
1064 hash_symbol_entry (const struct objfile *objfile_context,
1065 const char *name, domain_enum domain)
1066 {
1067 unsigned int hash = (uintptr_t) objfile_context;
1068
1069 if (name != NULL)
1070 hash += htab_hash_string (name);
1071
1072 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1073 to map to the same slot. */
1074 if (domain == STRUCT_DOMAIN)
1075 hash += VAR_DOMAIN * 7;
1076 else
1077 hash += domain * 7;
1078
1079 return hash;
1080 }
1081
1082 /* Equality function for the symbol cache. */
1083
1084 static int
1085 eq_symbol_entry (const struct symbol_cache_slot *slot,
1086 const struct objfile *objfile_context,
1087 const char *name, domain_enum domain)
1088 {
1089 const char *slot_name;
1090 domain_enum slot_domain;
1091
1092 if (slot->state == SYMBOL_SLOT_UNUSED)
1093 return 0;
1094
1095 if (slot->objfile_context != objfile_context)
1096 return 0;
1097
1098 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1099 {
1100 slot_name = slot->value.not_found.name;
1101 slot_domain = slot->value.not_found.domain;
1102 }
1103 else
1104 {
1105 slot_name = SYMBOL_SEARCH_NAME (slot->value.found.symbol);
1106 slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol);
1107 }
1108
1109 /* NULL names match. */
1110 if (slot_name == NULL && name == NULL)
1111 {
1112 /* But there's no point in calling symbol_matches_domain in the
1113 SYMBOL_SLOT_FOUND case. */
1114 if (slot_domain != domain)
1115 return 0;
1116 }
1117 else if (slot_name != NULL && name != NULL)
1118 {
1119 /* It's important that we use the same comparison that was done
1120 the first time through. If the slot records a found symbol,
1121 then this means using the symbol name comparison function of
1122 the symbol's language with SYMBOL_SEARCH_NAME. See
1123 dictionary.c. It also means using symbol_matches_domain for
1124 found symbols. See block.c.
1125
1126 If the slot records a not-found symbol, then require a precise match.
1127 We could still be lax with whitespace like strcmp_iw though. */
1128
1129 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1130 {
1131 if (strcmp (slot_name, name) != 0)
1132 return 0;
1133 if (slot_domain != domain)
1134 return 0;
1135 }
1136 else
1137 {
1138 struct symbol *sym = slot->value.found.symbol;
1139 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
1140
1141 if (!SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
1142 return 0;
1143
1144 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym),
1145 slot_domain, domain))
1146 return 0;
1147 }
1148 }
1149 else
1150 {
1151 /* Only one name is NULL. */
1152 return 0;
1153 }
1154
1155 return 1;
1156 }
1157
1158 /* Given a cache of size SIZE, return the size of the struct (with variable
1159 length array) in bytes. */
1160
1161 static size_t
1162 symbol_cache_byte_size (unsigned int size)
1163 {
1164 return (sizeof (struct block_symbol_cache)
1165 + ((size - 1) * sizeof (struct symbol_cache_slot)));
1166 }
1167
1168 /* Resize CACHE. */
1169
1170 static void
1171 resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size)
1172 {
1173 /* If there's no change in size, don't do anything.
1174 All caches have the same size, so we can just compare with the size
1175 of the global symbols cache. */
1176 if ((cache->global_symbols != NULL
1177 && cache->global_symbols->size == new_size)
1178 || (cache->global_symbols == NULL
1179 && new_size == 0))
1180 return;
1181
1182 xfree (cache->global_symbols);
1183 xfree (cache->static_symbols);
1184
1185 if (new_size == 0)
1186 {
1187 cache->global_symbols = NULL;
1188 cache->static_symbols = NULL;
1189 }
1190 else
1191 {
1192 size_t total_size = symbol_cache_byte_size (new_size);
1193
1194 cache->global_symbols
1195 = (struct block_symbol_cache *) xcalloc (1, total_size);
1196 cache->static_symbols
1197 = (struct block_symbol_cache *) xcalloc (1, total_size);
1198 cache->global_symbols->size = new_size;
1199 cache->static_symbols->size = new_size;
1200 }
1201 }
1202
1203 /* Make a symbol cache of size SIZE. */
1204
1205 static struct symbol_cache *
1206 make_symbol_cache (unsigned int size)
1207 {
1208 struct symbol_cache *cache;
1209
1210 cache = XCNEW (struct symbol_cache);
1211 resize_symbol_cache (cache, symbol_cache_size);
1212 return cache;
1213 }
1214
1215 /* Free the space used by CACHE. */
1216
1217 static void
1218 free_symbol_cache (struct symbol_cache *cache)
1219 {
1220 xfree (cache->global_symbols);
1221 xfree (cache->static_symbols);
1222 xfree (cache);
1223 }
1224
1225 /* Return the symbol cache of PSPACE.
1226 Create one if it doesn't exist yet. */
1227
1228 static struct symbol_cache *
1229 get_symbol_cache (struct program_space *pspace)
1230 {
1231 struct symbol_cache *cache
1232 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1233
1234 if (cache == NULL)
1235 {
1236 cache = make_symbol_cache (symbol_cache_size);
1237 set_program_space_data (pspace, symbol_cache_key, cache);
1238 }
1239
1240 return cache;
1241 }
1242
1243 /* Delete the symbol cache of PSPACE.
1244 Called when PSPACE is destroyed. */
1245
1246 static void
1247 symbol_cache_cleanup (struct program_space *pspace, void *data)
1248 {
1249 struct symbol_cache *cache = (struct symbol_cache *) data;
1250
1251 free_symbol_cache (cache);
1252 }
1253
1254 /* Set the size of the symbol cache in all program spaces. */
1255
1256 static void
1257 set_symbol_cache_size (unsigned int new_size)
1258 {
1259 struct program_space *pspace;
1260
1261 ALL_PSPACES (pspace)
1262 {
1263 struct symbol_cache *cache
1264 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1265
1266 /* The pspace could have been created but not have a cache yet. */
1267 if (cache != NULL)
1268 resize_symbol_cache (cache, new_size);
1269 }
1270 }
1271
1272 /* Called when symbol-cache-size is set. */
1273
1274 static void
1275 set_symbol_cache_size_handler (const char *args, int from_tty,
1276 struct cmd_list_element *c)
1277 {
1278 if (new_symbol_cache_size > MAX_SYMBOL_CACHE_SIZE)
1279 {
1280 /* Restore the previous value.
1281 This is the value the "show" command prints. */
1282 new_symbol_cache_size = symbol_cache_size;
1283
1284 error (_("Symbol cache size is too large, max is %u."),
1285 MAX_SYMBOL_CACHE_SIZE);
1286 }
1287 symbol_cache_size = new_symbol_cache_size;
1288
1289 set_symbol_cache_size (symbol_cache_size);
1290 }
1291
1292 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1293 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1294 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1295 failed (and thus this one will too), or NULL if the symbol is not present
1296 in the cache.
1297 If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
1298 set to the cache and slot of the symbol to save the result of a full lookup
1299 attempt. */
1300
1301 static struct block_symbol
1302 symbol_cache_lookup (struct symbol_cache *cache,
1303 struct objfile *objfile_context, int block,
1304 const char *name, domain_enum domain,
1305 struct block_symbol_cache **bsc_ptr,
1306 struct symbol_cache_slot **slot_ptr)
1307 {
1308 struct block_symbol_cache *bsc;
1309 unsigned int hash;
1310 struct symbol_cache_slot *slot;
1311
1312 if (block == GLOBAL_BLOCK)
1313 bsc = cache->global_symbols;
1314 else
1315 bsc = cache->static_symbols;
1316 if (bsc == NULL)
1317 {
1318 *bsc_ptr = NULL;
1319 *slot_ptr = NULL;
1320 return (struct block_symbol) {NULL, NULL};
1321 }
1322
1323 hash = hash_symbol_entry (objfile_context, name, domain);
1324 slot = bsc->symbols + hash % bsc->size;
1325
1326 if (eq_symbol_entry (slot, objfile_context, name, domain))
1327 {
1328 if (symbol_lookup_debug)
1329 fprintf_unfiltered (gdb_stdlog,
1330 "%s block symbol cache hit%s for %s, %s\n",
1331 block == GLOBAL_BLOCK ? "Global" : "Static",
1332 slot->state == SYMBOL_SLOT_NOT_FOUND
1333 ? " (not found)" : "",
1334 name, domain_name (domain));
1335 ++bsc->hits;
1336 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1337 return SYMBOL_LOOKUP_FAILED;
1338 return slot->value.found;
1339 }
1340
1341 /* Symbol is not present in the cache. */
1342
1343 *bsc_ptr = bsc;
1344 *slot_ptr = slot;
1345
1346 if (symbol_lookup_debug)
1347 {
1348 fprintf_unfiltered (gdb_stdlog,
1349 "%s block symbol cache miss for %s, %s\n",
1350 block == GLOBAL_BLOCK ? "Global" : "Static",
1351 name, domain_name (domain));
1352 }
1353 ++bsc->misses;
1354 return (struct block_symbol) {NULL, NULL};
1355 }
1356
1357 /* Clear out SLOT. */
1358
1359 static void
1360 symbol_cache_clear_slot (struct symbol_cache_slot *slot)
1361 {
1362 if (slot->state == SYMBOL_SLOT_NOT_FOUND)
1363 xfree (slot->value.not_found.name);
1364 slot->state = SYMBOL_SLOT_UNUSED;
1365 }
1366
1367 /* Mark SYMBOL as found in SLOT.
1368 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1369 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1370 necessarily the objfile the symbol was found in. */
1371
1372 static void
1373 symbol_cache_mark_found (struct block_symbol_cache *bsc,
1374 struct symbol_cache_slot *slot,
1375 struct objfile *objfile_context,
1376 struct symbol *symbol,
1377 const struct block *block)
1378 {
1379 if (bsc == NULL)
1380 return;
1381 if (slot->state != SYMBOL_SLOT_UNUSED)
1382 {
1383 ++bsc->collisions;
1384 symbol_cache_clear_slot (slot);
1385 }
1386 slot->state = SYMBOL_SLOT_FOUND;
1387 slot->objfile_context = objfile_context;
1388 slot->value.found.symbol = symbol;
1389 slot->value.found.block = block;
1390 }
1391
1392 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1393 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1394 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1395
1396 static void
1397 symbol_cache_mark_not_found (struct block_symbol_cache *bsc,
1398 struct symbol_cache_slot *slot,
1399 struct objfile *objfile_context,
1400 const char *name, domain_enum domain)
1401 {
1402 if (bsc == NULL)
1403 return;
1404 if (slot->state != SYMBOL_SLOT_UNUSED)
1405 {
1406 ++bsc->collisions;
1407 symbol_cache_clear_slot (slot);
1408 }
1409 slot->state = SYMBOL_SLOT_NOT_FOUND;
1410 slot->objfile_context = objfile_context;
1411 slot->value.not_found.name = xstrdup (name);
1412 slot->value.not_found.domain = domain;
1413 }
1414
1415 /* Flush the symbol cache of PSPACE. */
1416
1417 static void
1418 symbol_cache_flush (struct program_space *pspace)
1419 {
1420 struct symbol_cache *cache
1421 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1422 int pass;
1423
1424 if (cache == NULL)
1425 return;
1426 if (cache->global_symbols == NULL)
1427 {
1428 gdb_assert (symbol_cache_size == 0);
1429 gdb_assert (cache->static_symbols == NULL);
1430 return;
1431 }
1432
1433 /* If the cache is untouched since the last flush, early exit.
1434 This is important for performance during the startup of a program linked
1435 with 100s (or 1000s) of shared libraries. */
1436 if (cache->global_symbols->misses == 0
1437 && cache->static_symbols->misses == 0)
1438 return;
1439
1440 gdb_assert (cache->global_symbols->size == symbol_cache_size);
1441 gdb_assert (cache->static_symbols->size == symbol_cache_size);
1442
1443 for (pass = 0; pass < 2; ++pass)
1444 {
1445 struct block_symbol_cache *bsc
1446 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1447 unsigned int i;
1448
1449 for (i = 0; i < bsc->size; ++i)
1450 symbol_cache_clear_slot (&bsc->symbols[i]);
1451 }
1452
1453 cache->global_symbols->hits = 0;
1454 cache->global_symbols->misses = 0;
1455 cache->global_symbols->collisions = 0;
1456 cache->static_symbols->hits = 0;
1457 cache->static_symbols->misses = 0;
1458 cache->static_symbols->collisions = 0;
1459 }
1460
1461 /* Dump CACHE. */
1462
1463 static void
1464 symbol_cache_dump (const struct symbol_cache *cache)
1465 {
1466 int pass;
1467
1468 if (cache->global_symbols == NULL)
1469 {
1470 printf_filtered (" <disabled>\n");
1471 return;
1472 }
1473
1474 for (pass = 0; pass < 2; ++pass)
1475 {
1476 const struct block_symbol_cache *bsc
1477 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1478 unsigned int i;
1479
1480 if (pass == 0)
1481 printf_filtered ("Global symbols:\n");
1482 else
1483 printf_filtered ("Static symbols:\n");
1484
1485 for (i = 0; i < bsc->size; ++i)
1486 {
1487 const struct symbol_cache_slot *slot = &bsc->symbols[i];
1488
1489 QUIT;
1490
1491 switch (slot->state)
1492 {
1493 case SYMBOL_SLOT_UNUSED:
1494 break;
1495 case SYMBOL_SLOT_NOT_FOUND:
1496 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i,
1497 host_address_to_string (slot->objfile_context),
1498 slot->value.not_found.name,
1499 domain_name (slot->value.not_found.domain));
1500 break;
1501 case SYMBOL_SLOT_FOUND:
1502 {
1503 struct symbol *found = slot->value.found.symbol;
1504 const struct objfile *context = slot->objfile_context;
1505
1506 printf_filtered (" [%4u] = %s, %s %s\n", i,
1507 host_address_to_string (context),
1508 SYMBOL_PRINT_NAME (found),
1509 domain_name (SYMBOL_DOMAIN (found)));
1510 break;
1511 }
1512 }
1513 }
1514 }
1515 }
1516
1517 /* The "mt print symbol-cache" command. */
1518
1519 static void
1520 maintenance_print_symbol_cache (const char *args, int from_tty)
1521 {
1522 struct program_space *pspace;
1523
1524 ALL_PSPACES (pspace)
1525 {
1526 struct symbol_cache *cache;
1527
1528 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1529 pspace->num,
1530 pspace->symfile_object_file != NULL
1531 ? objfile_name (pspace->symfile_object_file)
1532 : "(no object file)");
1533
1534 /* If the cache hasn't been created yet, avoid creating one. */
1535 cache
1536 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1537 if (cache == NULL)
1538 printf_filtered (" <empty>\n");
1539 else
1540 symbol_cache_dump (cache);
1541 }
1542 }
1543
1544 /* The "mt flush-symbol-cache" command. */
1545
1546 static void
1547 maintenance_flush_symbol_cache (const char *args, int from_tty)
1548 {
1549 struct program_space *pspace;
1550
1551 ALL_PSPACES (pspace)
1552 {
1553 symbol_cache_flush (pspace);
1554 }
1555 }
1556
1557 /* Print usage statistics of CACHE. */
1558
1559 static void
1560 symbol_cache_stats (struct symbol_cache *cache)
1561 {
1562 int pass;
1563
1564 if (cache->global_symbols == NULL)
1565 {
1566 printf_filtered (" <disabled>\n");
1567 return;
1568 }
1569
1570 for (pass = 0; pass < 2; ++pass)
1571 {
1572 const struct block_symbol_cache *bsc
1573 = pass == 0 ? cache->global_symbols : cache->static_symbols;
1574
1575 QUIT;
1576
1577 if (pass == 0)
1578 printf_filtered ("Global block cache stats:\n");
1579 else
1580 printf_filtered ("Static block cache stats:\n");
1581
1582 printf_filtered (" size: %u\n", bsc->size);
1583 printf_filtered (" hits: %u\n", bsc->hits);
1584 printf_filtered (" misses: %u\n", bsc->misses);
1585 printf_filtered (" collisions: %u\n", bsc->collisions);
1586 }
1587 }
1588
1589 /* The "mt print symbol-cache-statistics" command. */
1590
1591 static void
1592 maintenance_print_symbol_cache_statistics (const char *args, int from_tty)
1593 {
1594 struct program_space *pspace;
1595
1596 ALL_PSPACES (pspace)
1597 {
1598 struct symbol_cache *cache;
1599
1600 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1601 pspace->num,
1602 pspace->symfile_object_file != NULL
1603 ? objfile_name (pspace->symfile_object_file)
1604 : "(no object file)");
1605
1606 /* If the cache hasn't been created yet, avoid creating one. */
1607 cache
1608 = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key);
1609 if (cache == NULL)
1610 printf_filtered (" empty, no stats available\n");
1611 else
1612 symbol_cache_stats (cache);
1613 }
1614 }
1615
1616 /* This module's 'new_objfile' observer. */
1617
1618 static void
1619 symtab_new_objfile_observer (struct objfile *objfile)
1620 {
1621 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1622 symbol_cache_flush (current_program_space);
1623 }
1624
1625 /* This module's 'free_objfile' observer. */
1626
1627 static void
1628 symtab_free_objfile_observer (struct objfile *objfile)
1629 {
1630 symbol_cache_flush (objfile->pspace);
1631 }
1632
1633 /* Debug symbols usually don't have section information. We need to dig that
1634 out of the minimal symbols and stash that in the debug symbol. */
1635
1636 void
1637 fixup_section (struct general_symbol_info *ginfo,
1638 CORE_ADDR addr, struct objfile *objfile)
1639 {
1640 struct minimal_symbol *msym;
1641
1642 /* First, check whether a minimal symbol with the same name exists
1643 and points to the same address. The address check is required
1644 e.g. on PowerPC64, where the minimal symbol for a function will
1645 point to the function descriptor, while the debug symbol will
1646 point to the actual function code. */
1647 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1648 if (msym)
1649 ginfo->section = MSYMBOL_SECTION (msym);
1650 else
1651 {
1652 /* Static, function-local variables do appear in the linker
1653 (minimal) symbols, but are frequently given names that won't
1654 be found via lookup_minimal_symbol(). E.g., it has been
1655 observed in frv-uclinux (ELF) executables that a static,
1656 function-local variable named "foo" might appear in the
1657 linker symbols as "foo.6" or "foo.3". Thus, there is no
1658 point in attempting to extend the lookup-by-name mechanism to
1659 handle this case due to the fact that there can be multiple
1660 names.
1661
1662 So, instead, search the section table when lookup by name has
1663 failed. The ``addr'' and ``endaddr'' fields may have already
1664 been relocated. If so, the relocation offset (i.e. the
1665 ANOFFSET value) needs to be subtracted from these values when
1666 performing the comparison. We unconditionally subtract it,
1667 because, when no relocation has been performed, the ANOFFSET
1668 value will simply be zero.
1669
1670 The address of the symbol whose section we're fixing up HAS
1671 NOT BEEN adjusted (relocated) yet. It can't have been since
1672 the section isn't yet known and knowing the section is
1673 necessary in order to add the correct relocation value. In
1674 other words, we wouldn't even be in this function (attempting
1675 to compute the section) if it were already known.
1676
1677 Note that it is possible to search the minimal symbols
1678 (subtracting the relocation value if necessary) to find the
1679 matching minimal symbol, but this is overkill and much less
1680 efficient. It is not necessary to find the matching minimal
1681 symbol, only its section.
1682
1683 Note that this technique (of doing a section table search)
1684 can fail when unrelocated section addresses overlap. For
1685 this reason, we still attempt a lookup by name prior to doing
1686 a search of the section table. */
1687
1688 struct obj_section *s;
1689 int fallback = -1;
1690
1691 ALL_OBJFILE_OSECTIONS (objfile, s)
1692 {
1693 int idx = s - objfile->sections;
1694 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1695
1696 if (fallback == -1)
1697 fallback = idx;
1698
1699 if (obj_section_addr (s) - offset <= addr
1700 && addr < obj_section_endaddr (s) - offset)
1701 {
1702 ginfo->section = idx;
1703 return;
1704 }
1705 }
1706
1707 /* If we didn't find the section, assume it is in the first
1708 section. If there is no allocated section, then it hardly
1709 matters what we pick, so just pick zero. */
1710 if (fallback == -1)
1711 ginfo->section = 0;
1712 else
1713 ginfo->section = fallback;
1714 }
1715 }
1716
1717 struct symbol *
1718 fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
1719 {
1720 CORE_ADDR addr;
1721
1722 if (!sym)
1723 return NULL;
1724
1725 if (!SYMBOL_OBJFILE_OWNED (sym))
1726 return sym;
1727
1728 /* We either have an OBJFILE, or we can get at it from the sym's
1729 symtab. Anything else is a bug. */
1730 gdb_assert (objfile || symbol_symtab (sym));
1731
1732 if (objfile == NULL)
1733 objfile = symbol_objfile (sym);
1734
1735 if (SYMBOL_OBJ_SECTION (objfile, sym))
1736 return sym;
1737
1738 /* We should have an objfile by now. */
1739 gdb_assert (objfile);
1740
1741 switch (SYMBOL_CLASS (sym))
1742 {
1743 case LOC_STATIC:
1744 case LOC_LABEL:
1745 addr = SYMBOL_VALUE_ADDRESS (sym);
1746 break;
1747 case LOC_BLOCK:
1748 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1749 break;
1750
1751 default:
1752 /* Nothing else will be listed in the minsyms -- no use looking
1753 it up. */
1754 return sym;
1755 }
1756
1757 fixup_section (&sym->ginfo, addr, objfile);
1758
1759 return sym;
1760 }
1761
1762 /* See symtab.h. */
1763
1764 demangle_for_lookup_info::demangle_for_lookup_info
1765 (const lookup_name_info &lookup_name, language lang)
1766 {
1767 demangle_result_storage storage;
1768
1769 if (lookup_name.ignore_parameters () && lang == language_cplus)
1770 {
1771 gdb::unique_xmalloc_ptr<char> without_params
1772 = cp_remove_params_if_any (lookup_name.name ().c_str (),
1773 lookup_name.completion_mode ());
1774
1775 if (without_params != NULL)
1776 {
1777 if (lookup_name.match_type () != symbol_name_match_type::SEARCH_NAME)
1778 m_demangled_name = demangle_for_lookup (without_params.get (),
1779 lang, storage);
1780 return;
1781 }
1782 }
1783
1784 if (lookup_name.match_type () == symbol_name_match_type::SEARCH_NAME)
1785 m_demangled_name = lookup_name.name ();
1786 else
1787 m_demangled_name = demangle_for_lookup (lookup_name.name ().c_str (),
1788 lang, storage);
1789 }
1790
1791 /* See symtab.h. */
1792
1793 const lookup_name_info &
1794 lookup_name_info::match_any ()
1795 {
1796 /* Lookup any symbol that "" would complete. I.e., this matches all
1797 symbol names. */
1798 static const lookup_name_info lookup_name ({}, symbol_name_match_type::FULL,
1799 true);
1800
1801 return lookup_name;
1802 }
1803
1804 /* Compute the demangled form of NAME as used by the various symbol
1805 lookup functions. The result can either be the input NAME
1806 directly, or a pointer to a buffer owned by the STORAGE object.
1807
1808 For Ada, this function just returns NAME, unmodified.
1809 Normally, Ada symbol lookups are performed using the encoded name
1810 rather than the demangled name, and so it might seem to make sense
1811 for this function to return an encoded version of NAME.
1812 Unfortunately, we cannot do this, because this function is used in
1813 circumstances where it is not appropriate to try to encode NAME.
1814 For instance, when displaying the frame info, we demangle the name
1815 of each parameter, and then perform a symbol lookup inside our
1816 function using that demangled name. In Ada, certain functions
1817 have internally-generated parameters whose name contain uppercase
1818 characters. Encoding those name would result in those uppercase
1819 characters to become lowercase, and thus cause the symbol lookup
1820 to fail. */
1821
1822 const char *
1823 demangle_for_lookup (const char *name, enum language lang,
1824 demangle_result_storage &storage)
1825 {
1826 /* If we are using C++, D, or Go, demangle the name before doing a
1827 lookup, so we can always binary search. */
1828 if (lang == language_cplus)
1829 {
1830 char *demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1831 if (demangled_name != NULL)
1832 return storage.set_malloc_ptr (demangled_name);
1833
1834 /* If we were given a non-mangled name, canonicalize it
1835 according to the language (so far only for C++). */
1836 std::string canon = cp_canonicalize_string (name);
1837 if (!canon.empty ())
1838 return storage.swap_string (canon);
1839 }
1840 else if (lang == language_d)
1841 {
1842 char *demangled_name = d_demangle (name, 0);
1843 if (demangled_name != NULL)
1844 return storage.set_malloc_ptr (demangled_name);
1845 }
1846 else if (lang == language_go)
1847 {
1848 char *demangled_name = go_demangle (name, 0);
1849 if (demangled_name != NULL)
1850 return storage.set_malloc_ptr (demangled_name);
1851 }
1852
1853 return name;
1854 }
1855
1856 /* See symtab.h. */
1857
1858 unsigned int
1859 search_name_hash (enum language language, const char *search_name)
1860 {
1861 return language_def (language)->la_search_name_hash (search_name);
1862 }
1863
1864 /* See symtab.h.
1865
1866 This function (or rather its subordinates) have a bunch of loops and
1867 it would seem to be attractive to put in some QUIT's (though I'm not really
1868 sure whether it can run long enough to be really important). But there
1869 are a few calls for which it would appear to be bad news to quit
1870 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1871 that there is C++ code below which can error(), but that probably
1872 doesn't affect these calls since they are looking for a known
1873 variable and thus can probably assume it will never hit the C++
1874 code). */
1875
1876 struct block_symbol
1877 lookup_symbol_in_language (const char *name, const struct block *block,
1878 const domain_enum domain, enum language lang,
1879 struct field_of_this_result *is_a_field_of_this)
1880 {
1881 demangle_result_storage storage;
1882 const char *modified_name = demangle_for_lookup (name, lang, storage);
1883
1884 return lookup_symbol_aux (modified_name,
1885 symbol_name_match_type::FULL,
1886 block, domain, lang,
1887 is_a_field_of_this);
1888 }
1889
1890 /* See symtab.h. */
1891
1892 struct block_symbol
1893 lookup_symbol (const char *name, const struct block *block,
1894 domain_enum domain,
1895 struct field_of_this_result *is_a_field_of_this)
1896 {
1897 return lookup_symbol_in_language (name, block, domain,
1898 current_language->la_language,
1899 is_a_field_of_this);
1900 }
1901
1902 /* See symtab.h. */
1903
1904 struct block_symbol
1905 lookup_symbol_search_name (const char *search_name, const struct block *block,
1906 domain_enum domain)
1907 {
1908 return lookup_symbol_aux (search_name, symbol_name_match_type::SEARCH_NAME,
1909 block, domain, language_asm, NULL);
1910 }
1911
1912 /* See symtab.h. */
1913
1914 struct block_symbol
1915 lookup_language_this (const struct language_defn *lang,
1916 const struct block *block)
1917 {
1918 if (lang->la_name_of_this == NULL || block == NULL)
1919 return (struct block_symbol) {NULL, NULL};
1920
1921 if (symbol_lookup_debug > 1)
1922 {
1923 struct objfile *objfile = lookup_objfile_from_block (block);
1924
1925 fprintf_unfiltered (gdb_stdlog,
1926 "lookup_language_this (%s, %s (objfile %s))",
1927 lang->la_name, host_address_to_string (block),
1928 objfile_debug_name (objfile));
1929 }
1930
1931 while (block)
1932 {
1933 struct symbol *sym;
1934
1935 sym = block_lookup_symbol (block, lang->la_name_of_this,
1936 symbol_name_match_type::SEARCH_NAME,
1937 VAR_DOMAIN);
1938 if (sym != NULL)
1939 {
1940 if (symbol_lookup_debug > 1)
1941 {
1942 fprintf_unfiltered (gdb_stdlog, " = %s (%s, block %s)\n",
1943 SYMBOL_PRINT_NAME (sym),
1944 host_address_to_string (sym),
1945 host_address_to_string (block));
1946 }
1947 return (struct block_symbol) {sym, block};
1948 }
1949 if (BLOCK_FUNCTION (block))
1950 break;
1951 block = BLOCK_SUPERBLOCK (block);
1952 }
1953
1954 if (symbol_lookup_debug > 1)
1955 fprintf_unfiltered (gdb_stdlog, " = NULL\n");
1956 return (struct block_symbol) {NULL, NULL};
1957 }
1958
1959 /* Given TYPE, a structure/union,
1960 return 1 if the component named NAME from the ultimate target
1961 structure/union is defined, otherwise, return 0. */
1962
1963 static int
1964 check_field (struct type *type, const char *name,
1965 struct field_of_this_result *is_a_field_of_this)
1966 {
1967 int i;
1968
1969 /* The type may be a stub. */
1970 type = check_typedef (type);
1971
1972 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1973 {
1974 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1975
1976 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1977 {
1978 is_a_field_of_this->type = type;
1979 is_a_field_of_this->field = &TYPE_FIELD (type, i);
1980 return 1;
1981 }
1982 }
1983
1984 /* C++: If it was not found as a data field, then try to return it
1985 as a pointer to a method. */
1986
1987 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1988 {
1989 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1990 {
1991 is_a_field_of_this->type = type;
1992 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1993 return 1;
1994 }
1995 }
1996
1997 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1998 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
1999 return 1;
2000
2001 return 0;
2002 }
2003
2004 /* Behave like lookup_symbol except that NAME is the natural name
2005 (e.g., demangled name) of the symbol that we're looking for. */
2006
2007 static struct block_symbol
2008 lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
2009 const struct block *block,
2010 const domain_enum domain, enum language language,
2011 struct field_of_this_result *is_a_field_of_this)
2012 {
2013 struct block_symbol result;
2014 const struct language_defn *langdef;
2015
2016 if (symbol_lookup_debug)
2017 {
2018 struct objfile *objfile = lookup_objfile_from_block (block);
2019
2020 fprintf_unfiltered (gdb_stdlog,
2021 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
2022 name, host_address_to_string (block),
2023 objfile != NULL
2024 ? objfile_debug_name (objfile) : "NULL",
2025 domain_name (domain), language_str (language));
2026 }
2027
2028 /* Make sure we do something sensible with is_a_field_of_this, since
2029 the callers that set this parameter to some non-null value will
2030 certainly use it later. If we don't set it, the contents of
2031 is_a_field_of_this are undefined. */
2032 if (is_a_field_of_this != NULL)
2033 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
2034
2035 /* Search specified block and its superiors. Don't search
2036 STATIC_BLOCK or GLOBAL_BLOCK. */
2037
2038 result = lookup_local_symbol (name, match_type, block, domain, language);
2039 if (result.symbol != NULL)
2040 {
2041 if (symbol_lookup_debug)
2042 {
2043 fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2044 host_address_to_string (result.symbol));
2045 }
2046 return result;
2047 }
2048
2049 /* If requested to do so by the caller and if appropriate for LANGUAGE,
2050 check to see if NAME is a field of `this'. */
2051
2052 langdef = language_def (language);
2053
2054 /* Don't do this check if we are searching for a struct. It will
2055 not be found by check_field, but will be found by other
2056 means. */
2057 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
2058 {
2059 result = lookup_language_this (langdef, block);
2060
2061 if (result.symbol)
2062 {
2063 struct type *t = result.symbol->type;
2064
2065 /* I'm not really sure that type of this can ever
2066 be typedefed; just be safe. */
2067 t = check_typedef (t);
2068 if (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
2069 t = TYPE_TARGET_TYPE (t);
2070
2071 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2072 && TYPE_CODE (t) != TYPE_CODE_UNION)
2073 error (_("Internal error: `%s' is not an aggregate"),
2074 langdef->la_name_of_this);
2075
2076 if (check_field (t, name, is_a_field_of_this))
2077 {
2078 if (symbol_lookup_debug)
2079 {
2080 fprintf_unfiltered (gdb_stdlog,
2081 "lookup_symbol_aux (...) = NULL\n");
2082 }
2083 return (struct block_symbol) {NULL, NULL};
2084 }
2085 }
2086 }
2087
2088 /* Now do whatever is appropriate for LANGUAGE to look
2089 up static and global variables. */
2090
2091 result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
2092 if (result.symbol != NULL)
2093 {
2094 if (symbol_lookup_debug)
2095 {
2096 fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2097 host_address_to_string (result.symbol));
2098 }
2099 return result;
2100 }
2101
2102 /* Now search all static file-level symbols. Not strictly correct,
2103 but more useful than an error. */
2104
2105 result = lookup_static_symbol (name, domain);
2106 if (symbol_lookup_debug)
2107 {
2108 fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
2109 result.symbol != NULL
2110 ? host_address_to_string (result.symbol)
2111 : "NULL");
2112 }
2113 return result;
2114 }
2115
2116 /* Check to see if the symbol is defined in BLOCK or its superiors.
2117 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2118
2119 static struct block_symbol
2120 lookup_local_symbol (const char *name,
2121 symbol_name_match_type match_type,
2122 const struct block *block,
2123 const domain_enum domain,
2124 enum language language)
2125 {
2126 struct symbol *sym;
2127 const struct block *static_block = block_static_block (block);
2128 const char *scope = block_scope (block);
2129
2130 /* Check if either no block is specified or it's a global block. */
2131
2132 if (static_block == NULL)
2133 return (struct block_symbol) {NULL, NULL};
2134
2135 while (block != static_block)
2136 {
2137 sym = lookup_symbol_in_block (name, match_type, block, domain);
2138 if (sym != NULL)
2139 return (struct block_symbol) {sym, block};
2140
2141 if (language == language_cplus || language == language_fortran)
2142 {
2143 struct block_symbol sym
2144 = cp_lookup_symbol_imports_or_template (scope, name, block,
2145 domain);
2146
2147 if (sym.symbol != NULL)
2148 return sym;
2149 }
2150
2151 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
2152 break;
2153 block = BLOCK_SUPERBLOCK (block);
2154 }
2155
2156 /* We've reached the end of the function without finding a result. */
2157
2158 return (struct block_symbol) {NULL, NULL};
2159 }
2160
2161 /* See symtab.h. */
2162
2163 struct objfile *
2164 lookup_objfile_from_block (const struct block *block)
2165 {
2166 struct objfile *obj;
2167 struct compunit_symtab *cust;
2168
2169 if (block == NULL)
2170 return NULL;
2171
2172 block = block_global_block (block);
2173 /* Look through all blockvectors. */
2174 ALL_COMPUNITS (obj, cust)
2175 if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
2176 GLOBAL_BLOCK))
2177 {
2178 if (obj->separate_debug_objfile_backlink)
2179 obj = obj->separate_debug_objfile_backlink;
2180
2181 return obj;
2182 }
2183
2184 return NULL;
2185 }
2186
2187 /* See symtab.h. */
2188
2189 struct symbol *
2190 lookup_symbol_in_block (const char *name, symbol_name_match_type match_type,
2191 const struct block *block,
2192 const domain_enum domain)
2193 {
2194 struct symbol *sym;
2195
2196 if (symbol_lookup_debug > 1)
2197 {
2198 struct objfile *objfile = lookup_objfile_from_block (block);
2199
2200 fprintf_unfiltered (gdb_stdlog,
2201 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2202 name, host_address_to_string (block),
2203 objfile_debug_name (objfile),
2204 domain_name (domain));
2205 }
2206
2207 sym = block_lookup_symbol (block, name, match_type, domain);
2208 if (sym)
2209 {
2210 if (symbol_lookup_debug > 1)
2211 {
2212 fprintf_unfiltered (gdb_stdlog, " = %s\n",
2213 host_address_to_string (sym));
2214 }
2215 return fixup_symbol_section (sym, NULL);
2216 }
2217
2218 if (symbol_lookup_debug > 1)
2219 fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2220 return NULL;
2221 }
2222
2223 /* See symtab.h. */
2224
2225 struct block_symbol
2226 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
2227 const char *name,
2228 const domain_enum domain)
2229 {
2230 struct objfile *objfile;
2231
2232 for (objfile = main_objfile;
2233 objfile;
2234 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
2235 {
2236 struct block_symbol result
2237 = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, name, domain);
2238
2239 if (result.symbol != NULL)
2240 return result;
2241 }
2242
2243 return (struct block_symbol) {NULL, NULL};
2244 }
2245
2246 /* Check to see if the symbol is defined in one of the OBJFILE's
2247 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2248 depending on whether or not we want to search global symbols or
2249 static symbols. */
2250
2251 static struct block_symbol
2252 lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index,
2253 const char *name, const domain_enum domain)
2254 {
2255 struct compunit_symtab *cust;
2256
2257 gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
2258
2259 if (symbol_lookup_debug > 1)
2260 {
2261 fprintf_unfiltered (gdb_stdlog,
2262 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2263 objfile_debug_name (objfile),
2264 block_index == GLOBAL_BLOCK
2265 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2266 name, domain_name (domain));
2267 }
2268
2269 ALL_OBJFILE_COMPUNITS (objfile, cust)
2270 {
2271 const struct blockvector *bv;
2272 const struct block *block;
2273 struct block_symbol result;
2274
2275 bv = COMPUNIT_BLOCKVECTOR (cust);
2276 block = BLOCKVECTOR_BLOCK (bv, block_index);
2277 result.symbol = block_lookup_symbol_primary (block, name, domain);
2278 result.block = block;
2279 if (result.symbol != NULL)
2280 {
2281 if (symbol_lookup_debug > 1)
2282 {
2283 fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n",
2284 host_address_to_string (result.symbol),
2285 host_address_to_string (block));
2286 }
2287 result.symbol = fixup_symbol_section (result.symbol, objfile);
2288 return result;
2289
2290 }
2291 }
2292
2293 if (symbol_lookup_debug > 1)
2294 fprintf_unfiltered (gdb_stdlog, " = NULL\n");
2295 return (struct block_symbol) {NULL, NULL};
2296 }
2297
2298 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2299 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2300 and all associated separate debug objfiles.
2301
2302 Normally we only look in OBJFILE, and not any separate debug objfiles
2303 because the outer loop will cause them to be searched too. This case is
2304 different. Here we're called from search_symbols where it will only
2305 call us for the the objfile that contains a matching minsym. */
2306
2307 static struct block_symbol
2308 lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
2309 const char *linkage_name,
2310 domain_enum domain)
2311 {
2312 enum language lang = current_language->la_language;
2313 struct objfile *main_objfile, *cur_objfile;
2314
2315 demangle_result_storage storage;
2316 const char *modified_name = demangle_for_lookup (linkage_name, lang, storage);
2317
2318 if (objfile->separate_debug_objfile_backlink)
2319 main_objfile = objfile->separate_debug_objfile_backlink;
2320 else
2321 main_objfile = objfile;
2322
2323 for (cur_objfile = main_objfile;
2324 cur_objfile;
2325 cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
2326 {
2327 struct block_symbol result;
2328
2329 result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK,
2330 modified_name, domain);
2331 if (result.symbol == NULL)
2332 result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK,
2333 modified_name, domain);
2334 if (result.symbol != NULL)
2335 return result;
2336 }
2337
2338 return (struct block_symbol) {NULL, NULL};
2339 }
2340
2341 /* A helper function that throws an exception when a symbol was found
2342 in a psymtab but not in a symtab. */
2343
2344 static void ATTRIBUTE_NORETURN
2345 error_in_psymtab_expansion (int block_index, const char *name,
2346 struct compunit_symtab *cust)
2347 {
2348 error (_("\
2349 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2350 %s may be an inlined function, or may be a template function\n \
2351 (if a template, try specifying an instantiation: %s<type>)."),
2352 block_index == GLOBAL_BLOCK ? "global" : "static",
2353 name,
2354 symtab_to_filename_for_display (compunit_primary_filetab (cust)),
2355 name, name);
2356 }
2357
2358 /* A helper function for various lookup routines that interfaces with
2359 the "quick" symbol table functions. */
2360
2361 static struct block_symbol
2362 lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index,
2363 const char *name, const domain_enum domain)
2364 {
2365 struct compunit_symtab *cust;
2366 const struct blockvector *bv;
2367 const struct block *block;
2368 struct block_symbol result;
2369
2370 if (!objfile->sf)
2371 return (struct block_symbol) {NULL, NULL};
2372
2373 if (symbol_lookup_debug > 1)
2374 {
2375 fprintf_unfiltered (gdb_stdlog,
2376 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2377 objfile_debug_name (objfile),
2378 block_index == GLOBAL_BLOCK
2379 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2380 name, domain_name (domain));
2381 }
2382
2383 cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, domain);
2384 if (cust == NULL)
2385 {
2386 if (symbol_lookup_debug > 1)
2387 {
2388 fprintf_unfiltered (gdb_stdlog,
2389 "lookup_symbol_via_quick_fns (...) = NULL\n");
2390 }
2391 return (struct block_symbol) {NULL, NULL};
2392 }
2393
2394 bv = COMPUNIT_BLOCKVECTOR (cust);
2395 block = BLOCKVECTOR_BLOCK (bv, block_index);
2396 result.symbol = block_lookup_symbol (block, name,
2397 symbol_name_match_type::FULL, domain);
2398 if (result.symbol == NULL)
2399 error_in_psymtab_expansion (block_index, name, cust);
2400
2401 if (symbol_lookup_debug > 1)
2402 {
2403 fprintf_unfiltered (gdb_stdlog,
2404 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2405 host_address_to_string (result.symbol),
2406 host_address_to_string (block));
2407 }
2408
2409 result.symbol = fixup_symbol_section (result.symbol, objfile);
2410 result.block = block;
2411 return result;
2412 }
2413
2414 /* See symtab.h. */
2415
2416 struct block_symbol
2417 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
2418 const char *name,
2419 const struct block *block,
2420 const domain_enum domain)
2421 {
2422 struct block_symbol result;
2423
2424 /* NOTE: carlton/2003-05-19: The comments below were written when
2425 this (or what turned into this) was part of lookup_symbol_aux;
2426 I'm much less worried about these questions now, since these
2427 decisions have turned out well, but I leave these comments here
2428 for posterity. */
2429
2430 /* NOTE: carlton/2002-12-05: There is a question as to whether or
2431 not it would be appropriate to search the current global block
2432 here as well. (That's what this code used to do before the
2433 is_a_field_of_this check was moved up.) On the one hand, it's
2434 redundant with the lookup in all objfiles search that happens
2435 next. On the other hand, if decode_line_1 is passed an argument
2436 like filename:var, then the user presumably wants 'var' to be
2437 searched for in filename. On the third hand, there shouldn't be
2438 multiple global variables all of which are named 'var', and it's
2439 not like decode_line_1 has ever restricted its search to only
2440 global variables in a single filename. All in all, only
2441 searching the static block here seems best: it's correct and it's
2442 cleanest. */
2443
2444 /* NOTE: carlton/2002-12-05: There's also a possible performance
2445 issue here: if you usually search for global symbols in the
2446 current file, then it would be slightly better to search the
2447 current global block before searching all the symtabs. But there
2448 are other factors that have a much greater effect on performance
2449 than that one, so I don't think we should worry about that for
2450 now. */
2451
2452 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2453 the current objfile. Searching the current objfile first is useful
2454 for both matching user expectations as well as performance. */
2455
2456 result = lookup_symbol_in_static_block (name, block, domain);
2457 if (result.symbol != NULL)
2458 return result;
2459
2460 /* If we didn't find a definition for a builtin type in the static block,
2461 search for it now. This is actually the right thing to do and can be
2462 a massive performance win. E.g., when debugging a program with lots of
2463 shared libraries we could search all of them only to find out the
2464 builtin type isn't defined in any of them. This is common for types
2465 like "void". */
2466 if (domain == VAR_DOMAIN)
2467 {
2468 struct gdbarch *gdbarch;
2469
2470 if (block == NULL)
2471 gdbarch = target_gdbarch ();
2472 else
2473 gdbarch = block_gdbarch (block);
2474 result.symbol = language_lookup_primitive_type_as_symbol (langdef,
2475 gdbarch, name);
2476 result.block = NULL;
2477 if (result.symbol != NULL)
2478 return result;
2479 }
2480
2481 return lookup_global_symbol (name, block, domain);
2482 }
2483
2484 /* See symtab.h. */
2485
2486 struct block_symbol
2487 lookup_symbol_in_static_block (const char *name,
2488 const struct block *block,
2489 const domain_enum domain)
2490 {
2491 const struct block *static_block = block_static_block (block);
2492 struct symbol *sym;
2493
2494 if (static_block == NULL)
2495 return (struct block_symbol) {NULL, NULL};
2496
2497 if (symbol_lookup_debug)
2498 {
2499 struct objfile *objfile = lookup_objfile_from_block (static_block);
2500
2501 fprintf_unfiltered (gdb_stdlog,
2502 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2503 " %s)\n",
2504 name,
2505 host_address_to_string (block),
2506 objfile_debug_name (objfile),
2507 domain_name (domain));
2508 }
2509
2510 sym = lookup_symbol_in_block (name,
2511 symbol_name_match_type::FULL,
2512 static_block, domain);
2513 if (symbol_lookup_debug)
2514 {
2515 fprintf_unfiltered (gdb_stdlog,
2516 "lookup_symbol_in_static_block (...) = %s\n",
2517 sym != NULL ? host_address_to_string (sym) : "NULL");
2518 }
2519 return (struct block_symbol) {sym, static_block};
2520 }
2521
2522 /* Perform the standard symbol lookup of NAME in OBJFILE:
2523 1) First search expanded symtabs, and if not found
2524 2) Search the "quick" symtabs (partial or .gdb_index).
2525 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2526
2527 static struct block_symbol
2528 lookup_symbol_in_objfile (struct objfile *objfile, int block_index,
2529 const char *name, const domain_enum domain)
2530 {
2531 struct block_symbol result;
2532
2533 if (symbol_lookup_debug)
2534 {
2535 fprintf_unfiltered (gdb_stdlog,
2536 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2537 objfile_debug_name (objfile),
2538 block_index == GLOBAL_BLOCK
2539 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2540 name, domain_name (domain));
2541 }
2542
2543 result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
2544 name, domain);
2545 if (result.symbol != NULL)
2546 {
2547 if (symbol_lookup_debug)
2548 {
2549 fprintf_unfiltered (gdb_stdlog,
2550 "lookup_symbol_in_objfile (...) = %s"
2551 " (in symtabs)\n",
2552 host_address_to_string (result.symbol));
2553 }
2554 return result;
2555 }
2556
2557 result = lookup_symbol_via_quick_fns (objfile, block_index,
2558 name, domain);
2559 if (symbol_lookup_debug)
2560 {
2561 fprintf_unfiltered (gdb_stdlog,
2562 "lookup_symbol_in_objfile (...) = %s%s\n",
2563 result.symbol != NULL
2564 ? host_address_to_string (result.symbol)
2565 : "NULL",
2566 result.symbol != NULL ? " (via quick fns)" : "");
2567 }
2568 return result;
2569 }
2570
2571 /* See symtab.h. */
2572
2573 struct block_symbol
2574 lookup_static_symbol (const char *name, const domain_enum domain)
2575 {
2576 struct symbol_cache *cache = get_symbol_cache (current_program_space);
2577 struct objfile *objfile;
2578 struct block_symbol result;
2579 struct block_symbol_cache *bsc;
2580 struct symbol_cache_slot *slot;
2581
2582 /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
2583 NULL for OBJFILE_CONTEXT. */
2584 result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
2585 &bsc, &slot);
2586 if (result.symbol != NULL)
2587 {
2588 if (SYMBOL_LOOKUP_FAILED_P (result))
2589 return (struct block_symbol) {NULL, NULL};
2590 return result;
2591 }
2592
2593 ALL_OBJFILES (objfile)
2594 {
2595 result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
2596 if (result.symbol != NULL)
2597 {
2598 /* Still pass NULL for OBJFILE_CONTEXT here. */
2599 symbol_cache_mark_found (bsc, slot, NULL, result.symbol,
2600 result.block);
2601 return result;
2602 }
2603 }
2604
2605 /* Still pass NULL for OBJFILE_CONTEXT here. */
2606 symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
2607 return (struct block_symbol) {NULL, NULL};
2608 }
2609
2610 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2611
2612 struct global_sym_lookup_data
2613 {
2614 /* The name of the symbol we are searching for. */
2615 const char *name;
2616
2617 /* The domain to use for our search. */
2618 domain_enum domain;
2619
2620 /* The field where the callback should store the symbol if found.
2621 It should be initialized to {NULL, NULL} before the search is started. */
2622 struct block_symbol result;
2623 };
2624
2625 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2626 It searches by name for a symbol in the GLOBAL_BLOCK of the given
2627 OBJFILE. The arguments for the search are passed via CB_DATA,
2628 which in reality is a pointer to struct global_sym_lookup_data. */
2629
2630 static int
2631 lookup_symbol_global_iterator_cb (struct objfile *objfile,
2632 void *cb_data)
2633 {
2634 struct global_sym_lookup_data *data =
2635 (struct global_sym_lookup_data *) cb_data;
2636
2637 gdb_assert (data->result.symbol == NULL
2638 && data->result.block == NULL);
2639
2640 data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
2641 data->name, data->domain);
2642
2643 /* If we found a match, tell the iterator to stop. Otherwise,
2644 keep going. */
2645 return (data->result.symbol != NULL);
2646 }
2647
2648 /* See symtab.h. */
2649
2650 struct block_symbol
2651 lookup_global_symbol (const char *name,
2652 const struct block *block,
2653 const domain_enum domain)
2654 {
2655 struct symbol_cache *cache = get_symbol_cache (current_program_space);
2656 struct block_symbol result;
2657 struct objfile *objfile;
2658 struct global_sym_lookup_data lookup_data;
2659 struct block_symbol_cache *bsc;
2660 struct symbol_cache_slot *slot;
2661
2662 objfile = lookup_objfile_from_block (block);
2663
2664 /* First see if we can find the symbol in the cache.
2665 This works because we use the current objfile to qualify the lookup. */
2666 result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
2667 &bsc, &slot);
2668 if (result.symbol != NULL)
2669 {
2670 if (SYMBOL_LOOKUP_FAILED_P (result))
2671 return (struct block_symbol) {NULL, NULL};
2672 return result;
2673 }
2674
2675 /* Call library-specific lookup procedure. */
2676 if (objfile != NULL)
2677 result = solib_global_lookup (objfile, name, domain);
2678
2679 /* If that didn't work go a global search (of global blocks, heh). */
2680 if (result.symbol == NULL)
2681 {
2682 memset (&lookup_data, 0, sizeof (lookup_data));
2683 lookup_data.name = name;
2684 lookup_data.domain = domain;
2685 gdbarch_iterate_over_objfiles_in_search_order
2686 (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
2687 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
2688 result = lookup_data.result;
2689 }
2690
2691 if (result.symbol != NULL)
2692 symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block);
2693 else
2694 symbol_cache_mark_not_found (bsc, slot, objfile, name, domain);
2695
2696 return result;
2697 }
2698
2699 int
2700 symbol_matches_domain (enum language symbol_language,
2701 domain_enum symbol_domain,
2702 domain_enum domain)
2703 {
2704 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2705 Similarly, any Ada type declaration implicitly defines a typedef. */
2706 if (symbol_language == language_cplus
2707 || symbol_language == language_d
2708 || symbol_language == language_ada
2709 || symbol_language == language_rust)
2710 {
2711 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
2712 && symbol_domain == STRUCT_DOMAIN)
2713 return 1;
2714 }
2715 /* For all other languages, strict match is required. */
2716 return (symbol_domain == domain);
2717 }
2718
2719 /* See symtab.h. */
2720
2721 struct type *
2722 lookup_transparent_type (const char *name)
2723 {
2724 return current_language->la_lookup_transparent_type (name);
2725 }
2726
2727 /* A helper for basic_lookup_transparent_type that interfaces with the
2728 "quick" symbol table functions. */
2729
2730 static struct type *
2731 basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index,
2732 const char *name)
2733 {
2734 struct compunit_symtab *cust;
2735 const struct blockvector *bv;
2736 struct block *block;
2737 struct symbol *sym;
2738
2739 if (!objfile->sf)
2740 return NULL;
2741 cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name,
2742 STRUCT_DOMAIN);
2743 if (cust == NULL)
2744 return NULL;
2745
2746 bv = COMPUNIT_BLOCKVECTOR (cust);
2747 block = BLOCKVECTOR_BLOCK (bv, block_index);
2748 sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2749 block_find_non_opaque_type, NULL);
2750 if (sym == NULL)
2751 error_in_psymtab_expansion (block_index, name, cust);
2752 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2753 return SYMBOL_TYPE (sym);
2754 }
2755
2756 /* Subroutine of basic_lookup_transparent_type to simplify it.
2757 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2758 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2759
2760 static struct type *
2761 basic_lookup_transparent_type_1 (struct objfile *objfile, int block_index,
2762 const char *name)
2763 {
2764 const struct compunit_symtab *cust;
2765 const struct blockvector *bv;
2766 const struct block *block;
2767 const struct symbol *sym;
2768
2769 ALL_OBJFILE_COMPUNITS (objfile, cust)
2770 {
2771 bv = COMPUNIT_BLOCKVECTOR (cust);
2772 block = BLOCKVECTOR_BLOCK (bv, block_index);
2773 sym = block_find_symbol (block, name, STRUCT_DOMAIN,
2774 block_find_non_opaque_type, NULL);
2775 if (sym != NULL)
2776 {
2777 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
2778 return SYMBOL_TYPE (sym);
2779 }
2780 }
2781
2782 return NULL;
2783 }
2784
2785 /* The standard implementation of lookup_transparent_type. This code
2786 was modeled on lookup_symbol -- the parts not relevant to looking
2787 up types were just left out. In particular it's assumed here that
2788 types are available in STRUCT_DOMAIN and only in file-static or
2789 global blocks. */
2790
2791 struct type *
2792 basic_lookup_transparent_type (const char *name)
2793 {
2794 struct objfile *objfile;
2795 struct type *t;
2796
2797 /* Now search all the global symbols. Do the symtab's first, then
2798 check the psymtab's. If a psymtab indicates the existence
2799 of the desired name as a global, then do psymtab-to-symtab
2800 conversion on the fly and return the found symbol. */
2801
2802 ALL_OBJFILES (objfile)
2803 {
2804 t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
2805 if (t)
2806 return t;
2807 }
2808
2809 ALL_OBJFILES (objfile)
2810 {
2811 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
2812 if (t)
2813 return t;
2814 }
2815
2816 /* Now search the static file-level symbols.
2817 Not strictly correct, but more useful than an error.
2818 Do the symtab's first, then
2819 check the psymtab's. If a psymtab indicates the existence
2820 of the desired name as a file-level static, then do psymtab-to-symtab
2821 conversion on the fly and return the found symbol. */
2822
2823 ALL_OBJFILES (objfile)
2824 {
2825 t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
2826 if (t)
2827 return t;
2828 }
2829
2830 ALL_OBJFILES (objfile)
2831 {
2832 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
2833 if (t)
2834 return t;
2835 }
2836
2837 return (struct type *) 0;
2838 }
2839
2840 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2841
2842 For each symbol that matches, CALLBACK is called. The symbol is
2843 passed to the callback.
2844
2845 If CALLBACK returns false, the iteration ends. Otherwise, the
2846 search continues. */
2847
2848 void
2849 iterate_over_symbols (const struct block *block,
2850 const lookup_name_info &name,
2851 const domain_enum domain,
2852 gdb::function_view<symbol_found_callback_ftype> callback)
2853 {
2854 struct block_iterator iter;
2855 struct symbol *sym;
2856
2857 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
2858 {
2859 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2860 SYMBOL_DOMAIN (sym), domain))
2861 {
2862 if (!callback (sym))
2863 return;
2864 }
2865 }
2866 }
2867
2868 /* Find the compunit symtab associated with PC and SECTION.
2869 This will read in debug info as necessary. */
2870
2871 struct compunit_symtab *
2872 find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section)
2873 {
2874 struct compunit_symtab *cust;
2875 struct compunit_symtab *best_cust = NULL;
2876 struct objfile *objfile;
2877 CORE_ADDR distance = 0;
2878 struct bound_minimal_symbol msymbol;
2879
2880 /* If we know that this is not a text address, return failure. This is
2881 necessary because we loop based on the block's high and low code
2882 addresses, which do not include the data ranges, and because
2883 we call find_pc_sect_psymtab which has a similar restriction based
2884 on the partial_symtab's texthigh and textlow. */
2885 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2886 if (msymbol.minsym
2887 && (MSYMBOL_TYPE (msymbol.minsym) == mst_data
2888 || MSYMBOL_TYPE (msymbol.minsym) == mst_bss
2889 || MSYMBOL_TYPE (msymbol.minsym) == mst_abs
2890 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data
2891 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss))
2892 return NULL;
2893
2894 /* Search all symtabs for the one whose file contains our address, and which
2895 is the smallest of all the ones containing the address. This is designed
2896 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2897 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2898 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2899
2900 This happens for native ecoff format, where code from included files
2901 gets its own symtab. The symtab for the included file should have
2902 been read in already via the dependency mechanism.
2903 It might be swifter to create several symtabs with the same name
2904 like xcoff does (I'm not sure).
2905
2906 It also happens for objfiles that have their functions reordered.
2907 For these, the symtab we are looking for is not necessarily read in. */
2908
2909 ALL_COMPUNITS (objfile, cust)
2910 {
2911 struct block *b;
2912 const struct blockvector *bv;
2913
2914 bv = COMPUNIT_BLOCKVECTOR (cust);
2915 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2916
2917 if (BLOCK_START (b) <= pc
2918 && BLOCK_END (b) > pc
2919 && (distance == 0
2920 || BLOCK_END (b) - BLOCK_START (b) < distance))
2921 {
2922 /* For an objfile that has its functions reordered,
2923 find_pc_psymtab will find the proper partial symbol table
2924 and we simply return its corresponding symtab. */
2925 /* In order to better support objfiles that contain both
2926 stabs and coff debugging info, we continue on if a psymtab
2927 can't be found. */
2928 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
2929 {
2930 struct compunit_symtab *result;
2931
2932 result
2933 = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2934 msymbol,
2935 pc, section,
2936 0);
2937 if (result != NULL)
2938 return result;
2939 }
2940 if (section != 0)
2941 {
2942 struct block_iterator iter;
2943 struct symbol *sym = NULL;
2944
2945 ALL_BLOCK_SYMBOLS (b, iter, sym)
2946 {
2947 fixup_symbol_section (sym, objfile);
2948 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, sym),
2949 section))
2950 break;
2951 }
2952 if (sym == NULL)
2953 continue; /* No symbol in this symtab matches
2954 section. */
2955 }
2956 distance = BLOCK_END (b) - BLOCK_START (b);
2957 best_cust = cust;
2958 }
2959 }
2960
2961 if (best_cust != NULL)
2962 return best_cust;
2963
2964 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2965
2966 ALL_OBJFILES (objfile)
2967 {
2968 struct compunit_symtab *result;
2969
2970 if (!objfile->sf)
2971 continue;
2972 result = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile,
2973 msymbol,
2974 pc, section,
2975 1);
2976 if (result != NULL)
2977 return result;
2978 }
2979
2980 return NULL;
2981 }
2982
2983 /* Find the compunit symtab associated with PC.
2984 This will read in debug info as necessary.
2985 Backward compatibility, no section. */
2986
2987 struct compunit_symtab *
2988 find_pc_compunit_symtab (CORE_ADDR pc)
2989 {
2990 return find_pc_sect_compunit_symtab (pc, find_pc_mapped_section (pc));
2991 }
2992
2993 /* See symtab.h. */
2994
2995 struct symbol *
2996 find_symbol_at_address (CORE_ADDR address)
2997 {
2998 struct objfile *objfile;
2999
3000 ALL_OBJFILES (objfile)
3001 {
3002 if (objfile->sf == NULL
3003 || objfile->sf->qf->find_compunit_symtab_by_address == NULL)
3004 continue;
3005
3006 struct compunit_symtab *symtab
3007 = objfile->sf->qf->find_compunit_symtab_by_address (objfile, address);
3008 if (symtab != NULL)
3009 {
3010 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (symtab);
3011
3012 for (int i = GLOBAL_BLOCK; i <= STATIC_BLOCK; ++i)
3013 {
3014 struct block *b = BLOCKVECTOR_BLOCK (bv, i);
3015 struct block_iterator iter;
3016 struct symbol *sym;
3017
3018 ALL_BLOCK_SYMBOLS (b, iter, sym)
3019 {
3020 if (SYMBOL_CLASS (sym) == LOC_STATIC
3021 && SYMBOL_VALUE_ADDRESS (sym) == address)
3022 return sym;
3023 }
3024 }
3025 }
3026 }
3027
3028 return NULL;
3029 }
3030
3031
3032
3033 /* Find the source file and line number for a given PC value and SECTION.
3034 Return a structure containing a symtab pointer, a line number,
3035 and a pc range for the entire source line.
3036 The value's .pc field is NOT the specified pc.
3037 NOTCURRENT nonzero means, if specified pc is on a line boundary,
3038 use the line that ends there. Otherwise, in that case, the line
3039 that begins there is used. */
3040
3041 /* The big complication here is that a line may start in one file, and end just
3042 before the start of another file. This usually occurs when you #include
3043 code in the middle of a subroutine. To properly find the end of a line's PC
3044 range, we must search all symtabs associated with this compilation unit, and
3045 find the one whose first PC is closer than that of the next line in this
3046 symtab. */
3047
3048 /* If it's worth the effort, we could be using a binary search. */
3049
3050 struct symtab_and_line
3051 find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
3052 {
3053 struct compunit_symtab *cust;
3054 struct symtab *iter_s;
3055 struct linetable *l;
3056 int len;
3057 int i;
3058 struct linetable_entry *item;
3059 const struct blockvector *bv;
3060 struct bound_minimal_symbol msymbol;
3061
3062 /* Info on best line seen so far, and where it starts, and its file. */
3063
3064 struct linetable_entry *best = NULL;
3065 CORE_ADDR best_end = 0;
3066 struct symtab *best_symtab = 0;
3067
3068 /* Store here the first line number
3069 of a file which contains the line at the smallest pc after PC.
3070 If we don't find a line whose range contains PC,
3071 we will use a line one less than this,
3072 with a range from the start of that file to the first line's pc. */
3073 struct linetable_entry *alt = NULL;
3074
3075 /* Info on best line seen in this file. */
3076
3077 struct linetable_entry *prev;
3078
3079 /* If this pc is not from the current frame,
3080 it is the address of the end of a call instruction.
3081 Quite likely that is the start of the following statement.
3082 But what we want is the statement containing the instruction.
3083 Fudge the pc to make sure we get that. */
3084
3085 /* It's tempting to assume that, if we can't find debugging info for
3086 any function enclosing PC, that we shouldn't search for line
3087 number info, either. However, GAS can emit line number info for
3088 assembly files --- very helpful when debugging hand-written
3089 assembly code. In such a case, we'd have no debug info for the
3090 function, but we would have line info. */
3091
3092 if (notcurrent)
3093 pc -= 1;
3094
3095 /* elz: added this because this function returned the wrong
3096 information if the pc belongs to a stub (import/export)
3097 to call a shlib function. This stub would be anywhere between
3098 two functions in the target, and the line info was erroneously
3099 taken to be the one of the line before the pc. */
3100
3101 /* RT: Further explanation:
3102
3103 * We have stubs (trampolines) inserted between procedures.
3104 *
3105 * Example: "shr1" exists in a shared library, and a "shr1" stub also
3106 * exists in the main image.
3107 *
3108 * In the minimal symbol table, we have a bunch of symbols
3109 * sorted by start address. The stubs are marked as "trampoline",
3110 * the others appear as text. E.g.:
3111 *
3112 * Minimal symbol table for main image
3113 * main: code for main (text symbol)
3114 * shr1: stub (trampoline symbol)
3115 * foo: code for foo (text symbol)
3116 * ...
3117 * Minimal symbol table for "shr1" image:
3118 * ...
3119 * shr1: code for shr1 (text symbol)
3120 * ...
3121 *
3122 * So the code below is trying to detect if we are in the stub
3123 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3124 * and if found, do the symbolization from the real-code address
3125 * rather than the stub address.
3126 *
3127 * Assumptions being made about the minimal symbol table:
3128 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3129 * if we're really in the trampoline.s If we're beyond it (say
3130 * we're in "foo" in the above example), it'll have a closer
3131 * symbol (the "foo" text symbol for example) and will not
3132 * return the trampoline.
3133 * 2. lookup_minimal_symbol_text() will find a real text symbol
3134 * corresponding to the trampoline, and whose address will
3135 * be different than the trampoline address. I put in a sanity
3136 * check for the address being the same, to avoid an
3137 * infinite recursion.
3138 */
3139 msymbol = lookup_minimal_symbol_by_pc (pc);
3140 if (msymbol.minsym != NULL)
3141 if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
3142 {
3143 struct bound_minimal_symbol mfunsym
3144 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
3145 NULL);
3146
3147 if (mfunsym.minsym == NULL)
3148 /* I eliminated this warning since it is coming out
3149 * in the following situation:
3150 * gdb shmain // test program with shared libraries
3151 * (gdb) break shr1 // function in shared lib
3152 * Warning: In stub for ...
3153 * In the above situation, the shared lib is not loaded yet,
3154 * so of course we can't find the real func/line info,
3155 * but the "break" still works, and the warning is annoying.
3156 * So I commented out the warning. RT */
3157 /* warning ("In stub for %s; unable to find real function/line info",
3158 SYMBOL_LINKAGE_NAME (msymbol)); */
3159 ;
3160 /* fall through */
3161 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym)
3162 == BMSYMBOL_VALUE_ADDRESS (msymbol))
3163 /* Avoid infinite recursion */
3164 /* See above comment about why warning is commented out. */
3165 /* warning ("In stub for %s; unable to find real function/line info",
3166 SYMBOL_LINKAGE_NAME (msymbol)); */
3167 ;
3168 /* fall through */
3169 else
3170 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym), 0);
3171 }
3172
3173 symtab_and_line val;
3174 val.pspace = current_program_space;
3175
3176 cust = find_pc_sect_compunit_symtab (pc, section);
3177 if (cust == NULL)
3178 {
3179 /* If no symbol information, return previous pc. */
3180 if (notcurrent)
3181 pc++;
3182 val.pc = pc;
3183 return val;
3184 }
3185
3186 bv = COMPUNIT_BLOCKVECTOR (cust);
3187
3188 /* Look at all the symtabs that share this blockvector.
3189 They all have the same apriori range, that we found was right;
3190 but they have different line tables. */
3191
3192 ALL_COMPUNIT_FILETABS (cust, iter_s)
3193 {
3194 /* Find the best line in this symtab. */
3195 l = SYMTAB_LINETABLE (iter_s);
3196 if (!l)
3197 continue;
3198 len = l->nitems;
3199 if (len <= 0)
3200 {
3201 /* I think len can be zero if the symtab lacks line numbers
3202 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3203 I'm not sure which, and maybe it depends on the symbol
3204 reader). */
3205 continue;
3206 }
3207
3208 prev = NULL;
3209 item = l->item; /* Get first line info. */
3210
3211 /* Is this file's first line closer than the first lines of other files?
3212 If so, record this file, and its first line, as best alternate. */
3213 if (item->pc > pc && (!alt || item->pc < alt->pc))
3214 alt = item;
3215
3216 for (i = 0; i < len; i++, item++)
3217 {
3218 /* Leave prev pointing to the linetable entry for the last line
3219 that started at or before PC. */
3220 if (item->pc > pc)
3221 break;
3222
3223 prev = item;
3224 }
3225
3226 /* At this point, prev points at the line whose start addr is <= pc, and
3227 item points at the next line. If we ran off the end of the linetable
3228 (pc >= start of the last line), then prev == item. If pc < start of
3229 the first line, prev will not be set. */
3230
3231 /* Is this file's best line closer than the best in the other files?
3232 If so, record this file, and its best line, as best so far. Don't
3233 save prev if it represents the end of a function (i.e. line number
3234 0) instead of a real line. */
3235
3236 if (prev && prev->line && (!best || prev->pc > best->pc))
3237 {
3238 best = prev;
3239 best_symtab = iter_s;
3240
3241 /* Discard BEST_END if it's before the PC of the current BEST. */
3242 if (best_end <= best->pc)
3243 best_end = 0;
3244 }
3245
3246 /* If another line (denoted by ITEM) is in the linetable and its
3247 PC is after BEST's PC, but before the current BEST_END, then
3248 use ITEM's PC as the new best_end. */
3249 if (best && i < len && item->pc > best->pc
3250 && (best_end == 0 || best_end > item->pc))
3251 best_end = item->pc;
3252 }
3253
3254 if (!best_symtab)
3255 {
3256 /* If we didn't find any line number info, just return zeros.
3257 We used to return alt->line - 1 here, but that could be
3258 anywhere; if we don't have line number info for this PC,
3259 don't make some up. */
3260 val.pc = pc;
3261 }
3262 else if (best->line == 0)
3263 {
3264 /* If our best fit is in a range of PC's for which no line
3265 number info is available (line number is zero) then we didn't
3266 find any valid line information. */
3267 val.pc = pc;
3268 }
3269 else
3270 {
3271 val.symtab = best_symtab;
3272 val.line = best->line;
3273 val.pc = best->pc;
3274 if (best_end && (!alt || best_end < alt->pc))
3275 val.end = best_end;
3276 else if (alt)
3277 val.end = alt->pc;
3278 else
3279 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
3280 }
3281 val.section = section;
3282 return val;
3283 }
3284
3285 /* Backward compatibility (no section). */
3286
3287 struct symtab_and_line
3288 find_pc_line (CORE_ADDR pc, int notcurrent)
3289 {
3290 struct obj_section *section;
3291
3292 section = find_pc_overlay (pc);
3293 if (pc_in_unmapped_range (pc, section))
3294 pc = overlay_mapped_address (pc, section);
3295 return find_pc_sect_line (pc, section, notcurrent);
3296 }
3297
3298 /* See symtab.h. */
3299
3300 struct symtab *
3301 find_pc_line_symtab (CORE_ADDR pc)
3302 {
3303 struct symtab_and_line sal;
3304
3305 /* This always passes zero for NOTCURRENT to find_pc_line.
3306 There are currently no callers that ever pass non-zero. */
3307 sal = find_pc_line (pc, 0);
3308 return sal.symtab;
3309 }
3310
3311 /* Find line number LINE in any symtab whose name is the same as
3312 SYMTAB.
3313
3314 If found, return the symtab that contains the linetable in which it was
3315 found, set *INDEX to the index in the linetable of the best entry
3316 found, and set *EXACT_MATCH nonzero if the value returned is an
3317 exact match.
3318
3319 If not found, return NULL. */
3320
3321 struct symtab *
3322 find_line_symtab (struct symtab *symtab, int line,
3323 int *index, int *exact_match)
3324 {
3325 int exact = 0; /* Initialized here to avoid a compiler warning. */
3326
3327 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3328 so far seen. */
3329
3330 int best_index;
3331 struct linetable *best_linetable;
3332 struct symtab *best_symtab;
3333
3334 /* First try looking it up in the given symtab. */
3335 best_linetable = SYMTAB_LINETABLE (symtab);
3336 best_symtab = symtab;
3337 best_index = find_line_common (best_linetable, line, &exact, 0);
3338 if (best_index < 0 || !exact)
3339 {
3340 /* Didn't find an exact match. So we better keep looking for
3341 another symtab with the same name. In the case of xcoff,
3342 multiple csects for one source file (produced by IBM's FORTRAN
3343 compiler) produce multiple symtabs (this is unavoidable
3344 assuming csects can be at arbitrary places in memory and that
3345 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3346
3347 /* BEST is the smallest linenumber > LINE so far seen,
3348 or 0 if none has been seen so far.
3349 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3350 int best;
3351
3352 struct objfile *objfile;
3353 struct compunit_symtab *cu;
3354 struct symtab *s;
3355
3356 if (best_index >= 0)
3357 best = best_linetable->item[best_index].line;
3358 else
3359 best = 0;
3360
3361 ALL_OBJFILES (objfile)
3362 {
3363 if (objfile->sf)
3364 objfile->sf->qf->expand_symtabs_with_fullname (objfile,
3365 symtab_to_fullname (symtab));
3366 }
3367
3368 ALL_FILETABS (objfile, cu, s)
3369 {
3370 struct linetable *l;
3371 int ind;
3372
3373 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
3374 continue;
3375 if (FILENAME_CMP (symtab_to_fullname (symtab),
3376 symtab_to_fullname (s)) != 0)
3377 continue;
3378 l = SYMTAB_LINETABLE (s);
3379 ind = find_line_common (l, line, &exact, 0);
3380 if (ind >= 0)
3381 {
3382 if (exact)
3383 {
3384 best_index = ind;
3385 best_linetable = l;
3386 best_symtab = s;
3387 goto done;
3388 }
3389 if (best == 0 || l->item[ind].line < best)
3390 {
3391 best = l->item[ind].line;
3392 best_index = ind;
3393 best_linetable = l;
3394 best_symtab = s;
3395 }
3396 }
3397 }
3398 }
3399 done:
3400 if (best_index < 0)
3401 return NULL;
3402
3403 if (index)
3404 *index = best_index;
3405 if (exact_match)
3406 *exact_match = exact;
3407
3408 return best_symtab;
3409 }
3410
3411 /* Given SYMTAB, returns all the PCs function in the symtab that
3412 exactly match LINE. Returns an empty vector if there are no exact
3413 matches, but updates BEST_ITEM in this case. */
3414
3415 std::vector<CORE_ADDR>
3416 find_pcs_for_symtab_line (struct symtab *symtab, int line,
3417 struct linetable_entry **best_item)
3418 {
3419 int start = 0;
3420 std::vector<CORE_ADDR> result;
3421
3422 /* First, collect all the PCs that are at this line. */
3423 while (1)
3424 {
3425 int was_exact;
3426 int idx;
3427
3428 idx = find_line_common (SYMTAB_LINETABLE (symtab), line, &was_exact,
3429 start);
3430 if (idx < 0)
3431 break;
3432
3433 if (!was_exact)
3434 {
3435 struct linetable_entry *item = &SYMTAB_LINETABLE (symtab)->item[idx];
3436
3437 if (*best_item == NULL || item->line < (*best_item)->line)
3438 *best_item = item;
3439
3440 break;
3441 }
3442
3443 result.push_back (SYMTAB_LINETABLE (symtab)->item[idx].pc);
3444 start = idx + 1;
3445 }
3446
3447 return result;
3448 }
3449
3450
3451 /* Set the PC value for a given source file and line number and return true.
3452 Returns zero for invalid line number (and sets the PC to 0).
3453 The source file is specified with a struct symtab. */
3454
3455 int
3456 find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
3457 {
3458 struct linetable *l;
3459 int ind;
3460
3461 *pc = 0;
3462 if (symtab == 0)
3463 return 0;
3464
3465 symtab = find_line_symtab (symtab, line, &ind, NULL);
3466 if (symtab != NULL)
3467 {
3468 l = SYMTAB_LINETABLE (symtab);
3469 *pc = l->item[ind].pc;
3470 return 1;
3471 }
3472 else
3473 return 0;
3474 }
3475
3476 /* Find the range of pc values in a line.
3477 Store the starting pc of the line into *STARTPTR
3478 and the ending pc (start of next line) into *ENDPTR.
3479 Returns 1 to indicate success.
3480 Returns 0 if could not find the specified line. */
3481
3482 int
3483 find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
3484 CORE_ADDR *endptr)
3485 {
3486 CORE_ADDR startaddr;
3487 struct symtab_and_line found_sal;
3488
3489 startaddr = sal.pc;
3490 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
3491 return 0;
3492
3493 /* This whole function is based on address. For example, if line 10 has
3494 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3495 "info line *0x123" should say the line goes from 0x100 to 0x200
3496 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3497 This also insures that we never give a range like "starts at 0x134
3498 and ends at 0x12c". */
3499
3500 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
3501 if (found_sal.line != sal.line)
3502 {
3503 /* The specified line (sal) has zero bytes. */
3504 *startptr = found_sal.pc;
3505 *endptr = found_sal.pc;
3506 }
3507 else
3508 {
3509 *startptr = found_sal.pc;
3510 *endptr = found_sal.end;
3511 }
3512 return 1;
3513 }
3514
3515 /* Given a line table and a line number, return the index into the line
3516 table for the pc of the nearest line whose number is >= the specified one.
3517 Return -1 if none is found. The value is >= 0 if it is an index.
3518 START is the index at which to start searching the line table.
3519
3520 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3521
3522 static int
3523 find_line_common (struct linetable *l, int lineno,
3524 int *exact_match, int start)
3525 {
3526 int i;
3527 int len;
3528
3529 /* BEST is the smallest linenumber > LINENO so far seen,
3530 or 0 if none has been seen so far.
3531 BEST_INDEX identifies the item for it. */
3532
3533 int best_index = -1;
3534 int best = 0;
3535
3536 *exact_match = 0;
3537
3538 if (lineno <= 0)
3539 return -1;
3540 if (l == 0)
3541 return -1;
3542
3543 len = l->nitems;
3544 for (i = start; i < len; i++)
3545 {
3546 struct linetable_entry *item = &(l->item[i]);
3547
3548 if (item->line == lineno)
3549 {
3550 /* Return the first (lowest address) entry which matches. */
3551 *exact_match = 1;
3552 return i;
3553 }
3554
3555 if (item->line > lineno && (best == 0 || item->line < best))
3556 {
3557 best = item->line;
3558 best_index = i;
3559 }
3560 }
3561
3562 /* If we got here, we didn't get an exact match. */
3563 return best_index;
3564 }
3565
3566 int
3567 find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
3568 {
3569 struct symtab_and_line sal;
3570
3571 sal = find_pc_line (pc, 0);
3572 *startptr = sal.pc;
3573 *endptr = sal.end;
3574 return sal.symtab != 0;
3575 }
3576
3577 /* Given a function symbol SYM, find the symtab and line for the start
3578 of the function.
3579 If the argument FUNFIRSTLINE is nonzero, we want the first line
3580 of real code inside the function.
3581 This function should return SALs matching those from minsym_found,
3582 otherwise false multiple-locations breakpoints could be placed. */
3583
3584 struct symtab_and_line
3585 find_function_start_sal (struct symbol *sym, int funfirstline)
3586 {
3587 fixup_symbol_section (sym, NULL);
3588
3589 obj_section *section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
3590 symtab_and_line sal
3591 = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
3592 sal.symbol = sym;
3593
3594 if (funfirstline && sal.symtab != NULL
3595 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
3596 || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
3597 {
3598 struct gdbarch *gdbarch = symbol_arch (sym);
3599
3600 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3601 if (gdbarch_skip_entrypoint_p (gdbarch))
3602 sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
3603 return sal;
3604 }
3605
3606 /* We always should have a line for the function start address.
3607 If we don't, something is odd. Create a plain SAL refering
3608 just the PC and hope that skip_prologue_sal (if requested)
3609 can find a line number for after the prologue. */
3610 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
3611 {
3612 sal = {};
3613 sal.pspace = current_program_space;
3614 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3615 sal.section = section;
3616 sal.symbol = sym;
3617 }
3618
3619 if (funfirstline)
3620 skip_prologue_sal (&sal);
3621
3622 return sal;
3623 }
3624
3625 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3626 address for that function that has an entry in SYMTAB's line info
3627 table. If such an entry cannot be found, return FUNC_ADDR
3628 unaltered. */
3629
3630 static CORE_ADDR
3631 skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
3632 {
3633 CORE_ADDR func_start, func_end;
3634 struct linetable *l;
3635 int i;
3636
3637 /* Give up if this symbol has no lineinfo table. */
3638 l = SYMTAB_LINETABLE (symtab);
3639 if (l == NULL)
3640 return func_addr;
3641
3642 /* Get the range for the function's PC values, or give up if we
3643 cannot, for some reason. */
3644 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
3645 return func_addr;
3646
3647 /* Linetable entries are ordered by PC values, see the commentary in
3648 symtab.h where `struct linetable' is defined. Thus, the first
3649 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3650 address we are looking for. */
3651 for (i = 0; i < l->nitems; i++)
3652 {
3653 struct linetable_entry *item = &(l->item[i]);
3654
3655 /* Don't use line numbers of zero, they mark special entries in
3656 the table. See the commentary on symtab.h before the
3657 definition of struct linetable. */
3658 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
3659 return item->pc;
3660 }
3661
3662 return func_addr;
3663 }
3664
3665 /* Adjust SAL to the first instruction past the function prologue.
3666 If the PC was explicitly specified, the SAL is not changed.
3667 If the line number was explicitly specified, at most the SAL's PC
3668 is updated. If SAL is already past the prologue, then do nothing. */
3669
3670 void
3671 skip_prologue_sal (struct symtab_and_line *sal)
3672 {
3673 struct symbol *sym;
3674 struct symtab_and_line start_sal;
3675 CORE_ADDR pc, saved_pc;
3676 struct obj_section *section;
3677 const char *name;
3678 struct objfile *objfile;
3679 struct gdbarch *gdbarch;
3680 const struct block *b, *function_block;
3681 int force_skip, skip;
3682
3683 /* Do not change the SAL if PC was specified explicitly. */
3684 if (sal->explicit_pc)
3685 return;
3686
3687 scoped_restore_current_pspace_and_thread restore_pspace_thread;
3688
3689 switch_to_program_space_and_thread (sal->pspace);
3690
3691 sym = find_pc_sect_function (sal->pc, sal->section);
3692 if (sym != NULL)
3693 {
3694 fixup_symbol_section (sym, NULL);
3695
3696 objfile = symbol_objfile (sym);
3697 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
3698 section = SYMBOL_OBJ_SECTION (objfile, sym);
3699 name = SYMBOL_LINKAGE_NAME (sym);
3700 }
3701 else
3702 {
3703 struct bound_minimal_symbol msymbol
3704 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
3705
3706 if (msymbol.minsym == NULL)
3707 return;
3708
3709 objfile = msymbol.objfile;
3710 pc = BMSYMBOL_VALUE_ADDRESS (msymbol);
3711 section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
3712 name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
3713 }
3714
3715 gdbarch = get_objfile_arch (objfile);
3716
3717 /* Process the prologue in two passes. In the first pass try to skip the
3718 prologue (SKIP is true) and verify there is a real need for it (indicated
3719 by FORCE_SKIP). If no such reason was found run a second pass where the
3720 prologue is not skipped (SKIP is false). */
3721
3722 skip = 1;
3723 force_skip = 1;
3724
3725 /* Be conservative - allow direct PC (without skipping prologue) only if we
3726 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3727 have to be set by the caller so we use SYM instead. */
3728 if (sym != NULL
3729 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym))))
3730 force_skip = 0;
3731
3732 saved_pc = pc;
3733 do
3734 {
3735 pc = saved_pc;
3736
3737 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3738 so that gdbarch_skip_prologue has something unique to work on. */
3739 if (section_is_overlay (section) && !section_is_mapped (section))
3740 pc = overlay_unmapped_address (pc, section);
3741
3742 /* Skip "first line" of function (which is actually its prologue). */
3743 pc += gdbarch_deprecated_function_start_offset (gdbarch);
3744 if (gdbarch_skip_entrypoint_p (gdbarch))
3745 pc = gdbarch_skip_entrypoint (gdbarch, pc);
3746 if (skip)
3747 pc = gdbarch_skip_prologue_noexcept (gdbarch, pc);
3748
3749 /* For overlays, map pc back into its mapped VMA range. */
3750 pc = overlay_mapped_address (pc, section);
3751
3752 /* Calculate line number. */
3753 start_sal = find_pc_sect_line (pc, section, 0);
3754
3755 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3756 line is still part of the same function. */
3757 if (skip && start_sal.pc != pc
3758 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
3759 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
3760 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
3761 == lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
3762 {
3763 /* First pc of next line */
3764 pc = start_sal.end;
3765 /* Recalculate the line number (might not be N+1). */
3766 start_sal = find_pc_sect_line (pc, section, 0);
3767 }
3768
3769 /* On targets with executable formats that don't have a concept of
3770 constructors (ELF with .init has, PE doesn't), gcc emits a call
3771 to `__main' in `main' between the prologue and before user
3772 code. */
3773 if (gdbarch_skip_main_prologue_p (gdbarch)
3774 && name && strcmp_iw (name, "main") == 0)
3775 {
3776 pc = gdbarch_skip_main_prologue (gdbarch, pc);
3777 /* Recalculate the line number (might not be N+1). */
3778 start_sal = find_pc_sect_line (pc, section, 0);
3779 force_skip = 1;
3780 }
3781 }
3782 while (!force_skip && skip--);
3783
3784 /* If we still don't have a valid source line, try to find the first
3785 PC in the lineinfo table that belongs to the same function. This
3786 happens with COFF debug info, which does not seem to have an
3787 entry in lineinfo table for the code after the prologue which has
3788 no direct relation to source. For example, this was found to be
3789 the case with the DJGPP target using "gcc -gcoff" when the
3790 compiler inserted code after the prologue to make sure the stack
3791 is aligned. */
3792 if (!force_skip && sym && start_sal.symtab == NULL)
3793 {
3794 pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
3795 /* Recalculate the line number. */
3796 start_sal = find_pc_sect_line (pc, section, 0);
3797 }
3798
3799 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3800 forward SAL to the end of the prologue. */
3801 if (sal->pc >= pc)
3802 return;
3803
3804 sal->pc = pc;
3805 sal->section = section;
3806
3807 /* Unless the explicit_line flag was set, update the SAL line
3808 and symtab to correspond to the modified PC location. */
3809 if (sal->explicit_line)
3810 return;
3811
3812 sal->symtab = start_sal.symtab;
3813 sal->line = start_sal.line;
3814 sal->end = start_sal.end;
3815
3816 /* Check if we are now inside an inlined function. If we can,
3817 use the call site of the function instead. */
3818 b = block_for_pc_sect (sal->pc, sal->section);
3819 function_block = NULL;
3820 while (b != NULL)
3821 {
3822 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
3823 function_block = b;
3824 else if (BLOCK_FUNCTION (b) != NULL)
3825 break;
3826 b = BLOCK_SUPERBLOCK (b);
3827 }
3828 if (function_block != NULL
3829 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
3830 {
3831 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
3832 sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
3833 }
3834 }
3835
3836 /* Given PC at the function's start address, attempt to find the
3837 prologue end using SAL information. Return zero if the skip fails.
3838
3839 A non-optimized prologue traditionally has one SAL for the function
3840 and a second for the function body. A single line function has
3841 them both pointing at the same line.
3842
3843 An optimized prologue is similar but the prologue may contain
3844 instructions (SALs) from the instruction body. Need to skip those
3845 while not getting into the function body.
3846
3847 The functions end point and an increasing SAL line are used as
3848 indicators of the prologue's endpoint.
3849
3850 This code is based on the function refine_prologue_limit
3851 (found in ia64). */
3852
3853 CORE_ADDR
3854 skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
3855 {
3856 struct symtab_and_line prologue_sal;
3857 CORE_ADDR start_pc;
3858 CORE_ADDR end_pc;
3859 const struct block *bl;
3860
3861 /* Get an initial range for the function. */
3862 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
3863 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
3864
3865 prologue_sal = find_pc_line (start_pc, 0);
3866 if (prologue_sal.line != 0)
3867 {
3868 /* For languages other than assembly, treat two consecutive line
3869 entries at the same address as a zero-instruction prologue.
3870 The GNU assembler emits separate line notes for each instruction
3871 in a multi-instruction macro, but compilers generally will not
3872 do this. */
3873 if (prologue_sal.symtab->language != language_asm)
3874 {
3875 struct linetable *linetable = SYMTAB_LINETABLE (prologue_sal.symtab);
3876 int idx = 0;
3877
3878 /* Skip any earlier lines, and any end-of-sequence marker
3879 from a previous function. */
3880 while (linetable->item[idx].pc != prologue_sal.pc
3881 || linetable->item[idx].line == 0)
3882 idx++;
3883
3884 if (idx+1 < linetable->nitems
3885 && linetable->item[idx+1].line != 0
3886 && linetable->item[idx+1].pc == start_pc)
3887 return start_pc;
3888 }
3889
3890 /* If there is only one sal that covers the entire function,
3891 then it is probably a single line function, like
3892 "foo(){}". */
3893 if (prologue_sal.end >= end_pc)
3894 return 0;
3895
3896 while (prologue_sal.end < end_pc)
3897 {
3898 struct symtab_and_line sal;
3899
3900 sal = find_pc_line (prologue_sal.end, 0);
3901 if (sal.line == 0)
3902 break;
3903 /* Assume that a consecutive SAL for the same (or larger)
3904 line mark the prologue -> body transition. */
3905 if (sal.line >= prologue_sal.line)
3906 break;
3907 /* Likewise if we are in a different symtab altogether
3908 (e.g. within a file included via #include). */
3909 if (sal.symtab != prologue_sal.symtab)
3910 break;
3911
3912 /* The line number is smaller. Check that it's from the
3913 same function, not something inlined. If it's inlined,
3914 then there is no point comparing the line numbers. */
3915 bl = block_for_pc (prologue_sal.end);
3916 while (bl)
3917 {
3918 if (block_inlined_p (bl))
3919 break;
3920 if (BLOCK_FUNCTION (bl))
3921 {
3922 bl = NULL;
3923 break;
3924 }
3925 bl = BLOCK_SUPERBLOCK (bl);
3926 }
3927 if (bl != NULL)
3928 break;
3929
3930 /* The case in which compiler's optimizer/scheduler has
3931 moved instructions into the prologue. We look ahead in
3932 the function looking for address ranges whose
3933 corresponding line number is less the first one that we
3934 found for the function. This is more conservative then
3935 refine_prologue_limit which scans a large number of SALs
3936 looking for any in the prologue. */
3937 prologue_sal = sal;
3938 }
3939 }
3940
3941 if (prologue_sal.end < end_pc)
3942 /* Return the end of this line, or zero if we could not find a
3943 line. */
3944 return prologue_sal.end;
3945 else
3946 /* Don't return END_PC, which is past the end of the function. */
3947 return prologue_sal.pc;
3948 }
3949
3950 /* See symtab.h. */
3951
3952 symbol *
3953 find_function_alias_target (bound_minimal_symbol msymbol)
3954 {
3955 CORE_ADDR func_addr;
3956 if (!msymbol_is_function (msymbol.objfile, msymbol.minsym, &func_addr))
3957 return NULL;
3958
3959 symbol *sym = find_pc_function (func_addr);
3960 if (sym != NULL
3961 && SYMBOL_CLASS (sym) == LOC_BLOCK
3962 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == func_addr)
3963 return sym;
3964
3965 return NULL;
3966 }
3967
3968
3969 /* If P is of the form "operator[ \t]+..." where `...' is
3970 some legitimate operator text, return a pointer to the
3971 beginning of the substring of the operator text.
3972 Otherwise, return "". */
3973
3974 static const char *
3975 operator_chars (const char *p, const char **end)
3976 {
3977 *end = "";
3978 if (!startswith (p, CP_OPERATOR_STR))
3979 return *end;
3980 p += CP_OPERATOR_LEN;
3981
3982 /* Don't get faked out by `operator' being part of a longer
3983 identifier. */
3984 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
3985 return *end;
3986
3987 /* Allow some whitespace between `operator' and the operator symbol. */
3988 while (*p == ' ' || *p == '\t')
3989 p++;
3990
3991 /* Recognize 'operator TYPENAME'. */
3992
3993 if (isalpha (*p) || *p == '_' || *p == '$')
3994 {
3995 const char *q = p + 1;
3996
3997 while (isalnum (*q) || *q == '_' || *q == '$')
3998 q++;
3999 *end = q;
4000 return p;
4001 }
4002
4003 while (*p)
4004 switch (*p)
4005 {
4006 case '\\': /* regexp quoting */
4007 if (p[1] == '*')
4008 {
4009 if (p[2] == '=') /* 'operator\*=' */
4010 *end = p + 3;
4011 else /* 'operator\*' */
4012 *end = p + 2;
4013 return p;
4014 }
4015 else if (p[1] == '[')
4016 {
4017 if (p[2] == ']')
4018 error (_("mismatched quoting on brackets, "
4019 "try 'operator\\[\\]'"));
4020 else if (p[2] == '\\' && p[3] == ']')
4021 {
4022 *end = p + 4; /* 'operator\[\]' */
4023 return p;
4024 }
4025 else
4026 error (_("nothing is allowed between '[' and ']'"));
4027 }
4028 else
4029 {
4030 /* Gratuitous qoute: skip it and move on. */
4031 p++;
4032 continue;
4033 }
4034 break;
4035 case '!':
4036 case '=':
4037 case '*':
4038 case '/':
4039 case '%':
4040 case '^':
4041 if (p[1] == '=')
4042 *end = p + 2;
4043 else
4044 *end = p + 1;
4045 return p;
4046 case '<':
4047 case '>':
4048 case '+':
4049 case '-':
4050 case '&':
4051 case '|':
4052 if (p[0] == '-' && p[1] == '>')
4053 {
4054 /* Struct pointer member operator 'operator->'. */
4055 if (p[2] == '*')
4056 {
4057 *end = p + 3; /* 'operator->*' */
4058 return p;
4059 }
4060 else if (p[2] == '\\')
4061 {
4062 *end = p + 4; /* Hopefully 'operator->\*' */
4063 return p;
4064 }
4065 else
4066 {
4067 *end = p + 2; /* 'operator->' */
4068 return p;
4069 }
4070 }
4071 if (p[1] == '=' || p[1] == p[0])
4072 *end = p + 2;
4073 else
4074 *end = p + 1;
4075 return p;
4076 case '~':
4077 case ',':
4078 *end = p + 1;
4079 return p;
4080 case '(':
4081 if (p[1] != ')')
4082 error (_("`operator ()' must be specified "
4083 "without whitespace in `()'"));
4084 *end = p + 2;
4085 return p;
4086 case '?':
4087 if (p[1] != ':')
4088 error (_("`operator ?:' must be specified "
4089 "without whitespace in `?:'"));
4090 *end = p + 2;
4091 return p;
4092 case '[':
4093 if (p[1] != ']')
4094 error (_("`operator []' must be specified "
4095 "without whitespace in `[]'"));
4096 *end = p + 2;
4097 return p;
4098 default:
4099 error (_("`operator %s' not supported"), p);
4100 break;
4101 }
4102
4103 *end = "";
4104 return *end;
4105 }
4106
4107
4108 /* Data structure to maintain printing state for output_source_filename. */
4109
4110 struct output_source_filename_data
4111 {
4112 /* Cache of what we've seen so far. */
4113 struct filename_seen_cache *filename_seen_cache;
4114
4115 /* Flag of whether we're printing the first one. */
4116 int first;
4117 };
4118
4119 /* Slave routine for sources_info. Force line breaks at ,'s.
4120 NAME is the name to print.
4121 DATA contains the state for printing and watching for duplicates. */
4122
4123 static void
4124 output_source_filename (const char *name,
4125 struct output_source_filename_data *data)
4126 {
4127 /* Since a single source file can result in several partial symbol
4128 tables, we need to avoid printing it more than once. Note: if
4129 some of the psymtabs are read in and some are not, it gets
4130 printed both under "Source files for which symbols have been
4131 read" and "Source files for which symbols will be read in on
4132 demand". I consider this a reasonable way to deal with the
4133 situation. I'm not sure whether this can also happen for
4134 symtabs; it doesn't hurt to check. */
4135
4136 /* Was NAME already seen? */
4137 if (data->filename_seen_cache->seen (name))
4138 {
4139 /* Yes; don't print it again. */
4140 return;
4141 }
4142
4143 /* No; print it and reset *FIRST. */
4144 if (! data->first)
4145 printf_filtered (", ");
4146 data->first = 0;
4147
4148 wrap_here ("");
4149 fputs_filtered (name, gdb_stdout);
4150 }
4151
4152 /* A callback for map_partial_symbol_filenames. */
4153
4154 static void
4155 output_partial_symbol_filename (const char *filename, const char *fullname,
4156 void *data)
4157 {
4158 output_source_filename (fullname ? fullname : filename,
4159 (struct output_source_filename_data *) data);
4160 }
4161
4162 static void
4163 info_sources_command (const char *ignore, int from_tty)
4164 {
4165 struct compunit_symtab *cu;
4166 struct symtab *s;
4167 struct objfile *objfile;
4168 struct output_source_filename_data data;
4169
4170 if (!have_full_symbols () && !have_partial_symbols ())
4171 {
4172 error (_("No symbol table is loaded. Use the \"file\" command."));
4173 }
4174
4175 filename_seen_cache filenames_seen;
4176
4177 data.filename_seen_cache = &filenames_seen;
4178
4179 printf_filtered ("Source files for which symbols have been read in:\n\n");
4180
4181 data.first = 1;
4182 ALL_FILETABS (objfile, cu, s)
4183 {
4184 const char *fullname = symtab_to_fullname (s);
4185
4186 output_source_filename (fullname, &data);
4187 }
4188 printf_filtered ("\n\n");
4189
4190 printf_filtered ("Source files for which symbols "
4191 "will be read in on demand:\n\n");
4192
4193 filenames_seen.clear ();
4194 data.first = 1;
4195 map_symbol_filenames (output_partial_symbol_filename, &data,
4196 1 /*need_fullname*/);
4197 printf_filtered ("\n");
4198 }
4199
4200 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4201 non-zero compare only lbasename of FILES. */
4202
4203 static int
4204 file_matches (const char *file, const char *files[], int nfiles, int basenames)
4205 {
4206 int i;
4207
4208 if (file != NULL && nfiles != 0)
4209 {
4210 for (i = 0; i < nfiles; i++)
4211 {
4212 if (compare_filenames_for_search (file, (basenames
4213 ? lbasename (files[i])
4214 : files[i])))
4215 return 1;
4216 }
4217 }
4218 else if (nfiles == 0)
4219 return 1;
4220 return 0;
4221 }
4222
4223 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4224 sort symbols, not minimal symbols. */
4225
4226 int
4227 symbol_search::compare_search_syms (const symbol_search &sym_a,
4228 const symbol_search &sym_b)
4229 {
4230 int c;
4231
4232 c = FILENAME_CMP (symbol_symtab (sym_a.symbol)->filename,
4233 symbol_symtab (sym_b.symbol)->filename);
4234 if (c != 0)
4235 return c;
4236
4237 if (sym_a.block != sym_b.block)
4238 return sym_a.block - sym_b.block;
4239
4240 return strcmp (SYMBOL_PRINT_NAME (sym_a.symbol),
4241 SYMBOL_PRINT_NAME (sym_b.symbol));
4242 }
4243
4244 /* Sort the symbols in RESULT and remove duplicates. */
4245
4246 static void
4247 sort_search_symbols_remove_dups (std::vector<symbol_search> *result)
4248 {
4249 std::sort (result->begin (), result->end ());
4250 result->erase (std::unique (result->begin (), result->end ()),
4251 result->end ());
4252 }
4253
4254 /* Search the symbol table for matches to the regular expression REGEXP,
4255 returning the results.
4256
4257 Only symbols of KIND are searched:
4258 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4259 and constants (enums)
4260 FUNCTIONS_DOMAIN - search all functions
4261 TYPES_DOMAIN - search all type names
4262 ALL_DOMAIN - an internal error for this function
4263
4264 Within each file the results are sorted locally; each symtab's global and
4265 static blocks are separately alphabetized.
4266 Duplicate entries are removed. */
4267
4268 std::vector<symbol_search>
4269 search_symbols (const char *regexp, enum search_domain kind,
4270 int nfiles, const char *files[])
4271 {
4272 struct compunit_symtab *cust;
4273 const struct blockvector *bv;
4274 struct block *b;
4275 int i = 0;
4276 struct block_iterator iter;
4277 struct symbol *sym;
4278 struct objfile *objfile;
4279 struct minimal_symbol *msymbol;
4280 int found_misc = 0;
4281 static const enum minimal_symbol_type types[]
4282 = {mst_data, mst_text, mst_abs};
4283 static const enum minimal_symbol_type types2[]
4284 = {mst_bss, mst_file_text, mst_abs};
4285 static const enum minimal_symbol_type types3[]
4286 = {mst_file_data, mst_solib_trampoline, mst_abs};
4287 static const enum minimal_symbol_type types4[]
4288 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
4289 enum minimal_symbol_type ourtype;
4290 enum minimal_symbol_type ourtype2;
4291 enum minimal_symbol_type ourtype3;
4292 enum minimal_symbol_type ourtype4;
4293 std::vector<symbol_search> result;
4294 gdb::optional<compiled_regex> preg;
4295
4296 gdb_assert (kind <= TYPES_DOMAIN);
4297
4298 ourtype = types[kind];
4299 ourtype2 = types2[kind];
4300 ourtype3 = types3[kind];
4301 ourtype4 = types4[kind];
4302
4303 if (regexp != NULL)
4304 {
4305 /* Make sure spacing is right for C++ operators.
4306 This is just a courtesy to make the matching less sensitive
4307 to how many spaces the user leaves between 'operator'
4308 and <TYPENAME> or <OPERATOR>. */
4309 const char *opend;
4310 const char *opname = operator_chars (regexp, &opend);
4311
4312 if (*opname)
4313 {
4314 int fix = -1; /* -1 means ok; otherwise number of
4315 spaces needed. */
4316
4317 if (isalpha (*opname) || *opname == '_' || *opname == '$')
4318 {
4319 /* There should 1 space between 'operator' and 'TYPENAME'. */
4320 if (opname[-1] != ' ' || opname[-2] == ' ')
4321 fix = 1;
4322 }
4323 else
4324 {
4325 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4326 if (opname[-1] == ' ')
4327 fix = 0;
4328 }
4329 /* If wrong number of spaces, fix it. */
4330 if (fix >= 0)
4331 {
4332 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
4333
4334 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
4335 regexp = tmp;
4336 }
4337 }
4338
4339 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
4340 ? REG_ICASE : 0);
4341 preg.emplace (regexp, cflags, _("Invalid regexp"));
4342 }
4343
4344 /* Search through the partial symtabs *first* for all symbols
4345 matching the regexp. That way we don't have to reproduce all of
4346 the machinery below. */
4347 expand_symtabs_matching ([&] (const char *filename, bool basenames)
4348 {
4349 return file_matches (filename, files, nfiles,
4350 basenames);
4351 },
4352 lookup_name_info::match_any (),
4353 [&] (const char *symname)
4354 {
4355 return (!preg || preg->exec (symname,
4356 0, NULL, 0) == 0);
4357 },
4358 NULL,
4359 kind);
4360
4361 /* Here, we search through the minimal symbol tables for functions
4362 and variables that match, and force their symbols to be read.
4363 This is in particular necessary for demangled variable names,
4364 which are no longer put into the partial symbol tables.
4365 The symbol will then be found during the scan of symtabs below.
4366
4367 For functions, find_pc_symtab should succeed if we have debug info
4368 for the function, for variables we have to call
4369 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4370 has debug info.
4371 If the lookup fails, set found_misc so that we will rescan to print
4372 any matching symbols without debug info.
4373 We only search the objfile the msymbol came from, we no longer search
4374 all objfiles. In large programs (1000s of shared libs) searching all
4375 objfiles is not worth the pain. */
4376
4377 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
4378 {
4379 ALL_MSYMBOLS (objfile, msymbol)
4380 {
4381 QUIT;
4382
4383 if (msymbol->created_by_gdb)
4384 continue;
4385
4386 if (MSYMBOL_TYPE (msymbol) == ourtype
4387 || MSYMBOL_TYPE (msymbol) == ourtype2
4388 || MSYMBOL_TYPE (msymbol) == ourtype3
4389 || MSYMBOL_TYPE (msymbol) == ourtype4)
4390 {
4391 if (!preg
4392 || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
4393 NULL, 0) == 0)
4394 {
4395 /* Note: An important side-effect of these lookup functions
4396 is to expand the symbol table if msymbol is found, for the
4397 benefit of the next loop on ALL_COMPUNITS. */
4398 if (kind == FUNCTIONS_DOMAIN
4399 ? (find_pc_compunit_symtab
4400 (MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL)
4401 : (lookup_symbol_in_objfile_from_linkage_name
4402 (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
4403 .symbol == NULL))
4404 found_misc = 1;
4405 }
4406 }
4407 }
4408 }
4409
4410 ALL_COMPUNITS (objfile, cust)
4411 {
4412 bv = COMPUNIT_BLOCKVECTOR (cust);
4413 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
4414 {
4415 b = BLOCKVECTOR_BLOCK (bv, i);
4416 ALL_BLOCK_SYMBOLS (b, iter, sym)
4417 {
4418 struct symtab *real_symtab = symbol_symtab (sym);
4419
4420 QUIT;
4421
4422 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
4423 a substring of symtab_to_fullname as it may contain "./" etc. */
4424 if ((file_matches (real_symtab->filename, files, nfiles, 0)
4425 || ((basenames_may_differ
4426 || file_matches (lbasename (real_symtab->filename),
4427 files, nfiles, 1))
4428 && file_matches (symtab_to_fullname (real_symtab),
4429 files, nfiles, 0)))
4430 && ((!preg
4431 || preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
4432 NULL, 0) == 0)
4433 && ((kind == VARIABLES_DOMAIN
4434 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
4435 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
4436 && SYMBOL_CLASS (sym) != LOC_BLOCK
4437 /* LOC_CONST can be used for more than just enums,
4438 e.g., c++ static const members.
4439 We only want to skip enums here. */
4440 && !(SYMBOL_CLASS (sym) == LOC_CONST
4441 && (TYPE_CODE (SYMBOL_TYPE (sym))
4442 == TYPE_CODE_ENUM)))
4443 || (kind == FUNCTIONS_DOMAIN
4444 && SYMBOL_CLASS (sym) == LOC_BLOCK)
4445 || (kind == TYPES_DOMAIN
4446 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
4447 {
4448 /* match */
4449 result.emplace_back (i, sym);
4450 }
4451 }
4452 }
4453 }
4454
4455 if (!result.empty ())
4456 sort_search_symbols_remove_dups (&result);
4457
4458 /* If there are no eyes, avoid all contact. I mean, if there are
4459 no debug symbols, then add matching minsyms. */
4460
4461 if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
4462 {
4463 ALL_MSYMBOLS (objfile, msymbol)
4464 {
4465 QUIT;
4466
4467 if (msymbol->created_by_gdb)
4468 continue;
4469
4470 if (MSYMBOL_TYPE (msymbol) == ourtype
4471 || MSYMBOL_TYPE (msymbol) == ourtype2
4472 || MSYMBOL_TYPE (msymbol) == ourtype3
4473 || MSYMBOL_TYPE (msymbol) == ourtype4)
4474 {
4475 if (!preg || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
4476 NULL, 0) == 0)
4477 {
4478 /* For functions we can do a quick check of whether the
4479 symbol might be found via find_pc_symtab. */
4480 if (kind != FUNCTIONS_DOMAIN
4481 || (find_pc_compunit_symtab
4482 (MSYMBOL_VALUE_ADDRESS (objfile, msymbol)) == NULL))
4483 {
4484 if (lookup_symbol_in_objfile_from_linkage_name
4485 (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
4486 .symbol == NULL)
4487 {
4488 /* match */
4489 result.emplace_back (i, msymbol, objfile);
4490 }
4491 }
4492 }
4493 }
4494 }
4495 }
4496
4497 return result;
4498 }
4499
4500 /* Helper function for symtab_symbol_info, this function uses
4501 the data returned from search_symbols() to print information
4502 regarding the match to gdb_stdout. */
4503
4504 static void
4505 print_symbol_info (enum search_domain kind,
4506 struct symbol *sym,
4507 int block, const char *last)
4508 {
4509 struct symtab *s = symbol_symtab (sym);
4510 const char *s_filename = symtab_to_filename_for_display (s);
4511
4512 if (last == NULL || filename_cmp (last, s_filename) != 0)
4513 {
4514 fputs_filtered ("\nFile ", gdb_stdout);
4515 fputs_filtered (s_filename, gdb_stdout);
4516 fputs_filtered (":\n", gdb_stdout);
4517 }
4518
4519 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
4520 printf_filtered ("static ");
4521
4522 /* Typedef that is not a C++ class. */
4523 if (kind == TYPES_DOMAIN
4524 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
4525 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
4526 /* variable, func, or typedef-that-is-c++-class. */
4527 else if (kind < TYPES_DOMAIN
4528 || (kind == TYPES_DOMAIN
4529 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
4530 {
4531 type_print (SYMBOL_TYPE (sym),
4532 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
4533 ? "" : SYMBOL_PRINT_NAME (sym)),
4534 gdb_stdout, 0);
4535
4536 printf_filtered (";\n");
4537 }
4538 }
4539
4540 /* This help function for symtab_symbol_info() prints information
4541 for non-debugging symbols to gdb_stdout. */
4542
4543 static void
4544 print_msymbol_info (struct bound_minimal_symbol msymbol)
4545 {
4546 struct gdbarch *gdbarch = get_objfile_arch (msymbol.objfile);
4547 char *tmp;
4548
4549 if (gdbarch_addr_bit (gdbarch) <= 32)
4550 tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol)
4551 & (CORE_ADDR) 0xffffffff,
4552 8);
4553 else
4554 tmp = hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol),
4555 16);
4556 printf_filtered ("%s %s\n",
4557 tmp, MSYMBOL_PRINT_NAME (msymbol.minsym));
4558 }
4559
4560 /* This is the guts of the commands "info functions", "info types", and
4561 "info variables". It calls search_symbols to find all matches and then
4562 print_[m]symbol_info to print out some useful information about the
4563 matches. */
4564
4565 static void
4566 symtab_symbol_info (const char *regexp, enum search_domain kind, int from_tty)
4567 {
4568 static const char * const classnames[] =
4569 {"variable", "function", "type"};
4570 const char *last_filename = NULL;
4571 int first = 1;
4572
4573 gdb_assert (kind <= TYPES_DOMAIN);
4574
4575 /* Must make sure that if we're interrupted, symbols gets freed. */
4576 std::vector<symbol_search> symbols = search_symbols (regexp, kind, 0, NULL);
4577
4578 if (regexp != NULL)
4579 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4580 classnames[kind], regexp);
4581 else
4582 printf_filtered (_("All defined %ss:\n"), classnames[kind]);
4583
4584 for (const symbol_search &p : symbols)
4585 {
4586 QUIT;
4587
4588 if (p.msymbol.minsym != NULL)
4589 {
4590 if (first)
4591 {
4592 printf_filtered (_("\nNon-debugging symbols:\n"));
4593 first = 0;
4594 }
4595 print_msymbol_info (p.msymbol);
4596 }
4597 else
4598 {
4599 print_symbol_info (kind,
4600 p.symbol,
4601 p.block,
4602 last_filename);
4603 last_filename
4604 = symtab_to_filename_for_display (symbol_symtab (p.symbol));
4605 }
4606 }
4607 }
4608
4609 static void
4610 info_variables_command (const char *regexp, int from_tty)
4611 {
4612 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
4613 }
4614
4615 static void
4616 info_functions_command (const char *regexp, int from_tty)
4617 {
4618 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
4619 }
4620
4621
4622 static void
4623 info_types_command (const char *regexp, int from_tty)
4624 {
4625 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
4626 }
4627
4628 /* Breakpoint all functions matching regular expression. */
4629
4630 void
4631 rbreak_command_wrapper (char *regexp, int from_tty)
4632 {
4633 rbreak_command (regexp, from_tty);
4634 }
4635
4636 static void
4637 rbreak_command (const char *regexp, int from_tty)
4638 {
4639 std::string string;
4640 const char **files = NULL;
4641 const char *file_name;
4642 int nfiles = 0;
4643
4644 if (regexp)
4645 {
4646 const char *colon = strchr (regexp, ':');
4647
4648 if (colon && *(colon + 1) != ':')
4649 {
4650 int colon_index;
4651 char *local_name;
4652
4653 colon_index = colon - regexp;
4654 local_name = (char *) alloca (colon_index + 1);
4655 memcpy (local_name, regexp, colon_index);
4656 local_name[colon_index--] = 0;
4657 while (isspace (local_name[colon_index]))
4658 local_name[colon_index--] = 0;
4659 file_name = local_name;
4660 files = &file_name;
4661 nfiles = 1;
4662 regexp = skip_spaces (colon + 1);
4663 }
4664 }
4665
4666 std::vector<symbol_search> symbols = search_symbols (regexp,
4667 FUNCTIONS_DOMAIN,
4668 nfiles, files);
4669
4670 scoped_rbreak_breakpoints finalize;
4671 for (const symbol_search &p : symbols)
4672 {
4673 if (p.msymbol.minsym == NULL)
4674 {
4675 struct symtab *symtab = symbol_symtab (p.symbol);
4676 const char *fullname = symtab_to_fullname (symtab);
4677
4678 string = string_printf ("%s:'%s'", fullname,
4679 SYMBOL_LINKAGE_NAME (p.symbol));
4680 break_command (&string[0], from_tty);
4681 print_symbol_info (FUNCTIONS_DOMAIN,
4682 p.symbol,
4683 p.block,
4684 symtab_to_filename_for_display (symtab));
4685 }
4686 else
4687 {
4688 string = string_printf ("'%s'",
4689 MSYMBOL_LINKAGE_NAME (p.msymbol.minsym));
4690
4691 break_command (&string[0], from_tty);
4692 printf_filtered ("<function, no debug info> %s;\n",
4693 MSYMBOL_PRINT_NAME (p.msymbol.minsym));
4694 }
4695 }
4696 }
4697
4698
4699 /* Evaluate if SYMNAME matches LOOKUP_NAME. */
4700
4701 static int
4702 compare_symbol_name (const char *symbol_name, language symbol_language,
4703 const lookup_name_info &lookup_name,
4704 completion_match_result &match_res)
4705 {
4706 const language_defn *lang = language_def (symbol_language);
4707
4708 symbol_name_matcher_ftype *name_match
4709 = get_symbol_name_matcher (lang, lookup_name);
4710
4711 return name_match (symbol_name, lookup_name, &match_res);
4712 }
4713
4714 /* See symtab.h. */
4715
4716 void
4717 completion_list_add_name (completion_tracker &tracker,
4718 language symbol_language,
4719 const char *symname,
4720 const lookup_name_info &lookup_name,
4721 const char *text, const char *word)
4722 {
4723 completion_match_result &match_res
4724 = tracker.reset_completion_match_result ();
4725
4726 /* Clip symbols that cannot match. */
4727 if (!compare_symbol_name (symname, symbol_language, lookup_name, match_res))
4728 return;
4729
4730 /* Refresh SYMNAME from the match string. It's potentially
4731 different depending on language. (E.g., on Ada, the match may be
4732 the encoded symbol name wrapped in "<>"). */
4733 symname = match_res.match.match ();
4734 gdb_assert (symname != NULL);
4735
4736 /* We have a match for a completion, so add SYMNAME to the current list
4737 of matches. Note that the name is moved to freshly malloc'd space. */
4738
4739 {
4740 gdb::unique_xmalloc_ptr<char> completion
4741 = make_completion_match_str (symname, text, word);
4742
4743 /* Here we pass the match-for-lcd object to add_completion. Some
4744 languages match the user text against substrings of symbol
4745 names in some cases. E.g., in C++, "b push_ba" completes to
4746 "std::vector::push_back", "std::string::push_back", etc., and
4747 in this case we want the completion lowest common denominator
4748 to be "push_back" instead of "std::". */
4749 tracker.add_completion (std::move (completion),
4750 &match_res.match_for_lcd, text, word);
4751 }
4752 }
4753
4754 /* completion_list_add_name wrapper for struct symbol. */
4755
4756 static void
4757 completion_list_add_symbol (completion_tracker &tracker,
4758 symbol *sym,
4759 const lookup_name_info &lookup_name,
4760 const char *text, const char *word)
4761 {
4762 completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym),
4763 SYMBOL_NATURAL_NAME (sym),
4764 lookup_name, text, word);
4765 }
4766
4767 /* completion_list_add_name wrapper for struct minimal_symbol. */
4768
4769 static void
4770 completion_list_add_msymbol (completion_tracker &tracker,
4771 minimal_symbol *sym,
4772 const lookup_name_info &lookup_name,
4773 const char *text, const char *word)
4774 {
4775 completion_list_add_name (tracker, MSYMBOL_LANGUAGE (sym),
4776 MSYMBOL_NATURAL_NAME (sym),
4777 lookup_name, text, word);
4778 }
4779
4780
4781 /* ObjC: In case we are completing on a selector, look as the msymbol
4782 again and feed all the selectors into the mill. */
4783
4784 static void
4785 completion_list_objc_symbol (completion_tracker &tracker,
4786 struct minimal_symbol *msymbol,
4787 const lookup_name_info &lookup_name,
4788 const char *text, const char *word)
4789 {
4790 static char *tmp = NULL;
4791 static unsigned int tmplen = 0;
4792
4793 const char *method, *category, *selector;
4794 char *tmp2 = NULL;
4795
4796 method = MSYMBOL_NATURAL_NAME (msymbol);
4797
4798 /* Is it a method? */
4799 if ((method[0] != '-') && (method[0] != '+'))
4800 return;
4801
4802 if (text[0] == '[')
4803 /* Complete on shortened method method. */
4804 completion_list_add_name (tracker, language_objc,
4805 method + 1,
4806 lookup_name,
4807 text, word);
4808
4809 while ((strlen (method) + 1) >= tmplen)
4810 {
4811 if (tmplen == 0)
4812 tmplen = 1024;
4813 else
4814 tmplen *= 2;
4815 tmp = (char *) xrealloc (tmp, tmplen);
4816 }
4817 selector = strchr (method, ' ');
4818 if (selector != NULL)
4819 selector++;
4820
4821 category = strchr (method, '(');
4822
4823 if ((category != NULL) && (selector != NULL))
4824 {
4825 memcpy (tmp, method, (category - method));
4826 tmp[category - method] = ' ';
4827 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4828 completion_list_add_name (tracker, language_objc, tmp,
4829 lookup_name, text, word);
4830 if (text[0] == '[')
4831 completion_list_add_name (tracker, language_objc, tmp + 1,
4832 lookup_name, text, word);
4833 }
4834
4835 if (selector != NULL)
4836 {
4837 /* Complete on selector only. */
4838 strcpy (tmp, selector);
4839 tmp2 = strchr (tmp, ']');
4840 if (tmp2 != NULL)
4841 *tmp2 = '\0';
4842
4843 completion_list_add_name (tracker, language_objc, tmp,
4844 lookup_name, text, word);
4845 }
4846 }
4847
4848 /* Break the non-quoted text based on the characters which are in
4849 symbols. FIXME: This should probably be language-specific. */
4850
4851 static const char *
4852 language_search_unquoted_string (const char *text, const char *p)
4853 {
4854 for (; p > text; --p)
4855 {
4856 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4857 continue;
4858 else
4859 {
4860 if ((current_language->la_language == language_objc))
4861 {
4862 if (p[-1] == ':') /* Might be part of a method name. */
4863 continue;
4864 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
4865 p -= 2; /* Beginning of a method name. */
4866 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
4867 { /* Might be part of a method name. */
4868 const char *t = p;
4869
4870 /* Seeing a ' ' or a '(' is not conclusive evidence
4871 that we are in the middle of a method name. However,
4872 finding "-[" or "+[" should be pretty un-ambiguous.
4873 Unfortunately we have to find it now to decide. */
4874
4875 while (t > text)
4876 if (isalnum (t[-1]) || t[-1] == '_' ||
4877 t[-1] == ' ' || t[-1] == ':' ||
4878 t[-1] == '(' || t[-1] == ')')
4879 --t;
4880 else
4881 break;
4882
4883 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
4884 p = t - 2; /* Method name detected. */
4885 /* Else we leave with p unchanged. */
4886 }
4887 }
4888 break;
4889 }
4890 }
4891 return p;
4892 }
4893
4894 static void
4895 completion_list_add_fields (completion_tracker &tracker,
4896 struct symbol *sym,
4897 const lookup_name_info &lookup_name,
4898 const char *text, const char *word)
4899 {
4900 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4901 {
4902 struct type *t = SYMBOL_TYPE (sym);
4903 enum type_code c = TYPE_CODE (t);
4904 int j;
4905
4906 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4907 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4908 if (TYPE_FIELD_NAME (t, j))
4909 completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym),
4910 TYPE_FIELD_NAME (t, j),
4911 lookup_name, text, word);
4912 }
4913 }
4914
4915 /* See symtab.h. */
4916
4917 bool
4918 symbol_is_function_or_method (symbol *sym)
4919 {
4920 switch (TYPE_CODE (SYMBOL_TYPE (sym)))
4921 {
4922 case TYPE_CODE_FUNC:
4923 case TYPE_CODE_METHOD:
4924 return true;
4925 default:
4926 return false;
4927 }
4928 }
4929
4930 /* See symtab.h. */
4931
4932 bool
4933 symbol_is_function_or_method (minimal_symbol *msymbol)
4934 {
4935 switch (MSYMBOL_TYPE (msymbol))
4936 {
4937 case mst_text:
4938 case mst_text_gnu_ifunc:
4939 case mst_solib_trampoline:
4940 case mst_file_text:
4941 return true;
4942 default:
4943 return false;
4944 }
4945 }
4946
4947 /* Add matching symbols from SYMTAB to the current completion list. */
4948
4949 static void
4950 add_symtab_completions (struct compunit_symtab *cust,
4951 completion_tracker &tracker,
4952 complete_symbol_mode mode,
4953 const lookup_name_info &lookup_name,
4954 const char *text, const char *word,
4955 enum type_code code)
4956 {
4957 struct symbol *sym;
4958 const struct block *b;
4959 struct block_iterator iter;
4960 int i;
4961
4962 if (cust == NULL)
4963 return;
4964
4965 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
4966 {
4967 QUIT;
4968 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), i);
4969 ALL_BLOCK_SYMBOLS (b, iter, sym)
4970 {
4971 if (completion_skip_symbol (mode, sym))
4972 continue;
4973
4974 if (code == TYPE_CODE_UNDEF
4975 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4976 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4977 completion_list_add_symbol (tracker, sym,
4978 lookup_name,
4979 text, word);
4980 }
4981 }
4982 }
4983
4984 void
4985 default_collect_symbol_completion_matches_break_on
4986 (completion_tracker &tracker, complete_symbol_mode mode,
4987 symbol_name_match_type name_match_type,
4988 const char *text, const char *word,
4989 const char *break_on, enum type_code code)
4990 {
4991 /* Problem: All of the symbols have to be copied because readline
4992 frees them. I'm not going to worry about this; hopefully there
4993 won't be that many. */
4994
4995 struct symbol *sym;
4996 struct compunit_symtab *cust;
4997 struct minimal_symbol *msymbol;
4998 struct objfile *objfile;
4999 const struct block *b;
5000 const struct block *surrounding_static_block, *surrounding_global_block;
5001 struct block_iterator iter;
5002 /* The symbol we are completing on. Points in same buffer as text. */
5003 const char *sym_text;
5004
5005 /* Now look for the symbol we are supposed to complete on. */
5006 if (mode == complete_symbol_mode::LINESPEC)
5007 sym_text = text;
5008 else
5009 {
5010 const char *p;
5011 char quote_found;
5012 const char *quote_pos = NULL;
5013
5014 /* First see if this is a quoted string. */
5015 quote_found = '\0';
5016 for (p = text; *p != '\0'; ++p)
5017 {
5018 if (quote_found != '\0')
5019 {
5020 if (*p == quote_found)
5021 /* Found close quote. */
5022 quote_found = '\0';
5023 else if (*p == '\\' && p[1] == quote_found)
5024 /* A backslash followed by the quote character
5025 doesn't end the string. */
5026 ++p;
5027 }
5028 else if (*p == '\'' || *p == '"')
5029 {
5030 quote_found = *p;
5031 quote_pos = p;
5032 }
5033 }
5034 if (quote_found == '\'')
5035 /* A string within single quotes can be a symbol, so complete on it. */
5036 sym_text = quote_pos + 1;
5037 else if (quote_found == '"')
5038 /* A double-quoted string is never a symbol, nor does it make sense
5039 to complete it any other way. */
5040 {
5041 return;
5042 }
5043 else
5044 {
5045 /* It is not a quoted string. Break it based on the characters
5046 which are in symbols. */
5047 while (p > text)
5048 {
5049 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
5050 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
5051 --p;
5052 else
5053 break;
5054 }
5055 sym_text = p;
5056 }
5057 }
5058
5059 lookup_name_info lookup_name (sym_text, name_match_type, true);
5060
5061 /* At this point scan through the misc symbol vectors and add each
5062 symbol you find to the list. Eventually we want to ignore
5063 anything that isn't a text symbol (everything else will be
5064 handled by the psymtab code below). */
5065
5066 if (code == TYPE_CODE_UNDEF)
5067 {
5068 ALL_MSYMBOLS (objfile, msymbol)
5069 {
5070 QUIT;
5071
5072 if (completion_skip_symbol (mode, msymbol))
5073 continue;
5074
5075 completion_list_add_msymbol (tracker, msymbol, lookup_name,
5076 sym_text, word);
5077
5078 completion_list_objc_symbol (tracker, msymbol, lookup_name,
5079 sym_text, word);
5080 }
5081 }
5082
5083 /* Add completions for all currently loaded symbol tables. */
5084 ALL_COMPUNITS (objfile, cust)
5085 add_symtab_completions (cust, tracker, mode, lookup_name,
5086 sym_text, word, code);
5087
5088 /* Look through the partial symtabs for all symbols which begin by
5089 matching SYM_TEXT. Expand all CUs that you find to the list. */
5090 expand_symtabs_matching (NULL,
5091 lookup_name,
5092 NULL,
5093 [&] (compunit_symtab *symtab) /* expansion notify */
5094 {
5095 add_symtab_completions (symtab,
5096 tracker, mode, lookup_name,
5097 sym_text, word, code);
5098 },
5099 ALL_DOMAIN);
5100
5101 /* Search upwards from currently selected frame (so that we can
5102 complete on local vars). Also catch fields of types defined in
5103 this places which match our text string. Only complete on types
5104 visible from current context. */
5105
5106 b = get_selected_block (0);
5107 surrounding_static_block = block_static_block (b);
5108 surrounding_global_block = block_global_block (b);
5109 if (surrounding_static_block != NULL)
5110 while (b != surrounding_static_block)
5111 {
5112 QUIT;
5113
5114 ALL_BLOCK_SYMBOLS (b, iter, sym)
5115 {
5116 if (code == TYPE_CODE_UNDEF)
5117 {
5118 completion_list_add_symbol (tracker, sym, lookup_name,
5119 sym_text, word);
5120 completion_list_add_fields (tracker, sym, lookup_name,
5121 sym_text, word);
5122 }
5123 else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
5124 && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
5125 completion_list_add_symbol (tracker, sym, lookup_name,
5126 sym_text, word);
5127 }
5128
5129 /* Stop when we encounter an enclosing function. Do not stop for
5130 non-inlined functions - the locals of the enclosing function
5131 are in scope for a nested function. */
5132 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
5133 break;
5134 b = BLOCK_SUPERBLOCK (b);
5135 }
5136
5137 /* Add fields from the file's types; symbols will be added below. */
5138
5139 if (code == TYPE_CODE_UNDEF)
5140 {
5141 if (surrounding_static_block != NULL)
5142 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
5143 completion_list_add_fields (tracker, sym, lookup_name,
5144 sym_text, word);
5145
5146 if (surrounding_global_block != NULL)
5147 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
5148 completion_list_add_fields (tracker, sym, lookup_name,
5149 sym_text, word);
5150 }
5151
5152 /* Skip macros if we are completing a struct tag -- arguable but
5153 usually what is expected. */
5154 if (current_language->la_macro_expansion == macro_expansion_c
5155 && code == TYPE_CODE_UNDEF)
5156 {
5157 struct macro_scope *scope;
5158
5159 /* This adds a macro's name to the current completion list. */
5160 auto add_macro_name = [&] (const char *macro_name,
5161 const macro_definition *,
5162 macro_source_file *,
5163 int)
5164 {
5165 completion_list_add_name (tracker, language_c, macro_name,
5166 lookup_name, sym_text, word);
5167 };
5168
5169 /* Add any macros visible in the default scope. Note that this
5170 may yield the occasional wrong result, because an expression
5171 might be evaluated in a scope other than the default. For
5172 example, if the user types "break file:line if <TAB>", the
5173 resulting expression will be evaluated at "file:line" -- but
5174 at there does not seem to be a way to detect this at
5175 completion time. */
5176 scope = default_macro_scope ();
5177 if (scope)
5178 {
5179 macro_for_each_in_scope (scope->file, scope->line,
5180 add_macro_name);
5181 xfree (scope);
5182 }
5183
5184 /* User-defined macros are always visible. */
5185 macro_for_each (macro_user_macros, add_macro_name);
5186 }
5187 }
5188
5189 void
5190 default_collect_symbol_completion_matches (completion_tracker &tracker,
5191 complete_symbol_mode mode,
5192 symbol_name_match_type name_match_type,
5193 const char *text, const char *word,
5194 enum type_code code)
5195 {
5196 return default_collect_symbol_completion_matches_break_on (tracker, mode,
5197 name_match_type,
5198 text, word, "",
5199 code);
5200 }
5201
5202 /* Collect all symbols (regardless of class) which begin by matching
5203 TEXT. */
5204
5205 void
5206 collect_symbol_completion_matches (completion_tracker &tracker,
5207 complete_symbol_mode mode,
5208 symbol_name_match_type name_match_type,
5209 const char *text, const char *word)
5210 {
5211 current_language->la_collect_symbol_completion_matches (tracker, mode,
5212 name_match_type,
5213 text, word,
5214 TYPE_CODE_UNDEF);
5215 }
5216
5217 /* Like collect_symbol_completion_matches, but only collect
5218 STRUCT_DOMAIN symbols whose type code is CODE. */
5219
5220 void
5221 collect_symbol_completion_matches_type (completion_tracker &tracker,
5222 const char *text, const char *word,
5223 enum type_code code)
5224 {
5225 complete_symbol_mode mode = complete_symbol_mode::EXPRESSION;
5226 symbol_name_match_type name_match_type = symbol_name_match_type::EXPRESSION;
5227
5228 gdb_assert (code == TYPE_CODE_UNION
5229 || code == TYPE_CODE_STRUCT
5230 || code == TYPE_CODE_ENUM);
5231 current_language->la_collect_symbol_completion_matches (tracker, mode,
5232 name_match_type,
5233 text, word, code);
5234 }
5235
5236 /* Like collect_symbol_completion_matches, but collects a list of
5237 symbols defined in all source files named SRCFILE. */
5238
5239 void
5240 collect_file_symbol_completion_matches (completion_tracker &tracker,
5241 complete_symbol_mode mode,
5242 symbol_name_match_type name_match_type,
5243 const char *text, const char *word,
5244 const char *srcfile)
5245 {
5246 /* The symbol we are completing on. Points in same buffer as text. */
5247 const char *sym_text;
5248
5249 /* Now look for the symbol we are supposed to complete on.
5250 FIXME: This should be language-specific. */
5251 if (mode == complete_symbol_mode::LINESPEC)
5252 sym_text = text;
5253 else
5254 {
5255 const char *p;
5256 char quote_found;
5257 const char *quote_pos = NULL;
5258
5259 /* First see if this is a quoted string. */
5260 quote_found = '\0';
5261 for (p = text; *p != '\0'; ++p)
5262 {
5263 if (quote_found != '\0')
5264 {
5265 if (*p == quote_found)
5266 /* Found close quote. */
5267 quote_found = '\0';
5268 else if (*p == '\\' && p[1] == quote_found)
5269 /* A backslash followed by the quote character
5270 doesn't end the string. */
5271 ++p;
5272 }
5273 else if (*p == '\'' || *p == '"')
5274 {
5275 quote_found = *p;
5276 quote_pos = p;
5277 }
5278 }
5279 if (quote_found == '\'')
5280 /* A string within single quotes can be a symbol, so complete on it. */
5281 sym_text = quote_pos + 1;
5282 else if (quote_found == '"')
5283 /* A double-quoted string is never a symbol, nor does it make sense
5284 to complete it any other way. */
5285 {
5286 return;
5287 }
5288 else
5289 {
5290 /* Not a quoted string. */
5291 sym_text = language_search_unquoted_string (text, p);
5292 }
5293 }
5294
5295 lookup_name_info lookup_name (sym_text, name_match_type, true);
5296
5297 /* Go through symtabs for SRCFILE and check the externs and statics
5298 for symbols which match. */
5299 iterate_over_symtabs (srcfile, [&] (symtab *s)
5300 {
5301 add_symtab_completions (SYMTAB_COMPUNIT (s),
5302 tracker, mode, lookup_name,
5303 sym_text, word, TYPE_CODE_UNDEF);
5304 return false;
5305 });
5306 }
5307
5308 /* A helper function for make_source_files_completion_list. It adds
5309 another file name to a list of possible completions, growing the
5310 list as necessary. */
5311
5312 static void
5313 add_filename_to_list (const char *fname, const char *text, const char *word,
5314 completion_list *list)
5315 {
5316 list->emplace_back (make_completion_match_str (fname, text, word));
5317 }
5318
5319 static int
5320 not_interesting_fname (const char *fname)
5321 {
5322 static const char *illegal_aliens[] = {
5323 "_globals_", /* inserted by coff_symtab_read */
5324 NULL
5325 };
5326 int i;
5327
5328 for (i = 0; illegal_aliens[i]; i++)
5329 {
5330 if (filename_cmp (fname, illegal_aliens[i]) == 0)
5331 return 1;
5332 }
5333 return 0;
5334 }
5335
5336 /* An object of this type is passed as the user_data argument to
5337 map_partial_symbol_filenames. */
5338 struct add_partial_filename_data
5339 {
5340 struct filename_seen_cache *filename_seen_cache;
5341 const char *text;
5342 const char *word;
5343 int text_len;
5344 completion_list *list;
5345 };
5346
5347 /* A callback for map_partial_symbol_filenames. */
5348
5349 static void
5350 maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
5351 void *user_data)
5352 {
5353 struct add_partial_filename_data *data
5354 = (struct add_partial_filename_data *) user_data;
5355
5356 if (not_interesting_fname (filename))
5357 return;
5358 if (!data->filename_seen_cache->seen (filename)
5359 && filename_ncmp (filename, data->text, data->text_len) == 0)
5360 {
5361 /* This file matches for a completion; add it to the
5362 current list of matches. */
5363 add_filename_to_list (filename, data->text, data->word, data->list);
5364 }
5365 else
5366 {
5367 const char *base_name = lbasename (filename);
5368
5369 if (base_name != filename
5370 && !data->filename_seen_cache->seen (base_name)
5371 && filename_ncmp (base_name, data->text, data->text_len) == 0)
5372 add_filename_to_list (base_name, data->text, data->word, data->list);
5373 }
5374 }
5375
5376 /* Return a list of all source files whose names begin with matching
5377 TEXT. The file names are looked up in the symbol tables of this
5378 program. */
5379
5380 completion_list
5381 make_source_files_completion_list (const char *text, const char *word)
5382 {
5383 struct compunit_symtab *cu;
5384 struct symtab *s;
5385 struct objfile *objfile;
5386 size_t text_len = strlen (text);
5387 completion_list list;
5388 const char *base_name;
5389 struct add_partial_filename_data datum;
5390
5391 if (!have_full_symbols () && !have_partial_symbols ())
5392 return list;
5393
5394 filename_seen_cache filenames_seen;
5395
5396 ALL_FILETABS (objfile, cu, s)
5397 {
5398 if (not_interesting_fname (s->filename))
5399 continue;
5400 if (!filenames_seen.seen (s->filename)
5401 && filename_ncmp (s->filename, text, text_len) == 0)
5402 {
5403 /* This file matches for a completion; add it to the current
5404 list of matches. */
5405 add_filename_to_list (s->filename, text, word, &list);
5406 }
5407 else
5408 {
5409 /* NOTE: We allow the user to type a base name when the
5410 debug info records leading directories, but not the other
5411 way around. This is what subroutines of breakpoint
5412 command do when they parse file names. */
5413 base_name = lbasename (s->filename);
5414 if (base_name != s->filename
5415 && !filenames_seen.seen (base_name)
5416 && filename_ncmp (base_name, text, text_len) == 0)
5417 add_filename_to_list (base_name, text, word, &list);
5418 }
5419 }
5420
5421 datum.filename_seen_cache = &filenames_seen;
5422 datum.text = text;
5423 datum.word = word;
5424 datum.text_len = text_len;
5425 datum.list = &list;
5426 map_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
5427 0 /*need_fullname*/);
5428
5429 return list;
5430 }
5431
5432 /* Track MAIN */
5433
5434 /* Return the "main_info" object for the current program space. If
5435 the object has not yet been created, create it and fill in some
5436 default values. */
5437
5438 static struct main_info *
5439 get_main_info (void)
5440 {
5441 struct main_info *info
5442 = (struct main_info *) program_space_data (current_program_space,
5443 main_progspace_key);
5444
5445 if (info == NULL)
5446 {
5447 /* It may seem strange to store the main name in the progspace
5448 and also in whatever objfile happens to see a main name in
5449 its debug info. The reason for this is mainly historical:
5450 gdb returned "main" as the name even if no function named
5451 "main" was defined the program; and this approach lets us
5452 keep compatibility. */
5453 info = XCNEW (struct main_info);
5454 info->language_of_main = language_unknown;
5455 set_program_space_data (current_program_space, main_progspace_key,
5456 info);
5457 }
5458
5459 return info;
5460 }
5461
5462 /* A cleanup to destroy a struct main_info when a progspace is
5463 destroyed. */
5464
5465 static void
5466 main_info_cleanup (struct program_space *pspace, void *data)
5467 {
5468 struct main_info *info = (struct main_info *) data;
5469
5470 if (info != NULL)
5471 xfree (info->name_of_main);
5472 xfree (info);
5473 }
5474
5475 static void
5476 set_main_name (const char *name, enum language lang)
5477 {
5478 struct main_info *info = get_main_info ();
5479
5480 if (info->name_of_main != NULL)
5481 {
5482 xfree (info->name_of_main);
5483 info->name_of_main = NULL;
5484 info->language_of_main = language_unknown;
5485 }
5486 if (name != NULL)
5487 {
5488 info->name_of_main = xstrdup (name);
5489 info->language_of_main = lang;
5490 }
5491 }
5492
5493 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5494 accordingly. */
5495
5496 static void
5497 find_main_name (void)
5498 {
5499 const char *new_main_name;
5500 struct objfile *objfile;
5501
5502 /* First check the objfiles to see whether a debuginfo reader has
5503 picked up the appropriate main name. Historically the main name
5504 was found in a more or less random way; this approach instead
5505 relies on the order of objfile creation -- which still isn't
5506 guaranteed to get the correct answer, but is just probably more
5507 accurate. */
5508 ALL_OBJFILES (objfile)
5509 {
5510 if (objfile->per_bfd->name_of_main != NULL)
5511 {
5512 set_main_name (objfile->per_bfd->name_of_main,
5513 objfile->per_bfd->language_of_main);
5514 return;
5515 }
5516 }
5517
5518 /* Try to see if the main procedure is in Ada. */
5519 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5520 be to add a new method in the language vector, and call this
5521 method for each language until one of them returns a non-empty
5522 name. This would allow us to remove this hard-coded call to
5523 an Ada function. It is not clear that this is a better approach
5524 at this point, because all methods need to be written in a way
5525 such that false positives never be returned. For instance, it is
5526 important that a method does not return a wrong name for the main
5527 procedure if the main procedure is actually written in a different
5528 language. It is easy to guaranty this with Ada, since we use a
5529 special symbol generated only when the main in Ada to find the name
5530 of the main procedure. It is difficult however to see how this can
5531 be guarantied for languages such as C, for instance. This suggests
5532 that order of call for these methods becomes important, which means
5533 a more complicated approach. */
5534 new_main_name = ada_main_name ();
5535 if (new_main_name != NULL)
5536 {
5537 set_main_name (new_main_name, language_ada);
5538 return;
5539 }
5540
5541 new_main_name = d_main_name ();
5542 if (new_main_name != NULL)
5543 {
5544 set_main_name (new_main_name, language_d);
5545 return;
5546 }
5547
5548 new_main_name = go_main_name ();
5549 if (new_main_name != NULL)
5550 {
5551 set_main_name (new_main_name, language_go);
5552 return;
5553 }
5554
5555 new_main_name = pascal_main_name ();
5556 if (new_main_name != NULL)
5557 {
5558 set_main_name (new_main_name, language_pascal);
5559 return;
5560 }
5561
5562 /* The languages above didn't identify the name of the main procedure.
5563 Fallback to "main". */
5564 set_main_name ("main", language_unknown);
5565 }
5566
5567 char *
5568 main_name (void)
5569 {
5570 struct main_info *info = get_main_info ();
5571
5572 if (info->name_of_main == NULL)
5573 find_main_name ();
5574
5575 return info->name_of_main;
5576 }
5577
5578 /* Return the language of the main function. If it is not known,
5579 return language_unknown. */
5580
5581 enum language
5582 main_language (void)
5583 {
5584 struct main_info *info = get_main_info ();
5585
5586 if (info->name_of_main == NULL)
5587 find_main_name ();
5588
5589 return info->language_of_main;
5590 }
5591
5592 /* Handle ``executable_changed'' events for the symtab module. */
5593
5594 static void
5595 symtab_observer_executable_changed (void)
5596 {
5597 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5598 set_main_name (NULL, language_unknown);
5599 }
5600
5601 /* Return 1 if the supplied producer string matches the ARM RealView
5602 compiler (armcc). */
5603
5604 int
5605 producer_is_realview (const char *producer)
5606 {
5607 static const char *const arm_idents[] = {
5608 "ARM C Compiler, ADS",
5609 "Thumb C Compiler, ADS",
5610 "ARM C++ Compiler, ADS",
5611 "Thumb C++ Compiler, ADS",
5612 "ARM/Thumb C/C++ Compiler, RVCT",
5613 "ARM C/C++ Compiler, RVCT"
5614 };
5615 int i;
5616
5617 if (producer == NULL)
5618 return 0;
5619
5620 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5621 if (startswith (producer, arm_idents[i]))
5622 return 1;
5623
5624 return 0;
5625 }
5626
5627
5628
5629 /* The next index to hand out in response to a registration request. */
5630
5631 static int next_aclass_value = LOC_FINAL_VALUE;
5632
5633 /* The maximum number of "aclass" registrations we support. This is
5634 constant for convenience. */
5635 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5636
5637 /* The objects representing the various "aclass" values. The elements
5638 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5639 elements are those registered at gdb initialization time. */
5640
5641 static struct symbol_impl symbol_impl[MAX_SYMBOL_IMPLS];
5642
5643 /* The globally visible pointer. This is separate from 'symbol_impl'
5644 so that it can be const. */
5645
5646 const struct symbol_impl *symbol_impls = &symbol_impl[0];
5647
5648 /* Make sure we saved enough room in struct symbol. */
5649
5650 gdb_static_assert (MAX_SYMBOL_IMPLS <= (1 << SYMBOL_ACLASS_BITS));
5651
5652 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5653 is the ops vector associated with this index. This returns the new
5654 index, which should be used as the aclass_index field for symbols
5655 of this type. */
5656
5657 int
5658 register_symbol_computed_impl (enum address_class aclass,
5659 const struct symbol_computed_ops *ops)
5660 {
5661 int result = next_aclass_value++;
5662
5663 gdb_assert (aclass == LOC_COMPUTED);
5664 gdb_assert (result < MAX_SYMBOL_IMPLS);
5665 symbol_impl[result].aclass = aclass;
5666 symbol_impl[result].ops_computed = ops;
5667
5668 /* Sanity check OPS. */
5669 gdb_assert (ops != NULL);
5670 gdb_assert (ops->tracepoint_var_ref != NULL);
5671 gdb_assert (ops->describe_location != NULL);
5672 gdb_assert (ops->get_symbol_read_needs != NULL);
5673 gdb_assert (ops->read_variable != NULL);
5674
5675 return result;
5676 }
5677
5678 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5679 OPS is the ops vector associated with this index. This returns the
5680 new index, which should be used as the aclass_index field for symbols
5681 of this type. */
5682
5683 int
5684 register_symbol_block_impl (enum address_class aclass,
5685 const struct symbol_block_ops *ops)
5686 {
5687 int result = next_aclass_value++;
5688
5689 gdb_assert (aclass == LOC_BLOCK);
5690 gdb_assert (result < MAX_SYMBOL_IMPLS);
5691 symbol_impl[result].aclass = aclass;
5692 symbol_impl[result].ops_block = ops;
5693
5694 /* Sanity check OPS. */
5695 gdb_assert (ops != NULL);
5696 gdb_assert (ops->find_frame_base_location != NULL);
5697
5698 return result;
5699 }
5700
5701 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5702 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5703 this index. This returns the new index, which should be used as
5704 the aclass_index field for symbols of this type. */
5705
5706 int
5707 register_symbol_register_impl (enum address_class aclass,
5708 const struct symbol_register_ops *ops)
5709 {
5710 int result = next_aclass_value++;
5711
5712 gdb_assert (aclass == LOC_REGISTER || aclass == LOC_REGPARM_ADDR);
5713 gdb_assert (result < MAX_SYMBOL_IMPLS);
5714 symbol_impl[result].aclass = aclass;
5715 symbol_impl[result].ops_register = ops;
5716
5717 return result;
5718 }
5719
5720 /* Initialize elements of 'symbol_impl' for the constants in enum
5721 address_class. */
5722
5723 static void
5724 initialize_ordinary_address_classes (void)
5725 {
5726 int i;
5727
5728 for (i = 0; i < LOC_FINAL_VALUE; ++i)
5729 symbol_impl[i].aclass = (enum address_class) i;
5730 }
5731
5732
5733
5734 /* Helper function to initialize the fields of an objfile-owned symbol.
5735 It assumed that *SYM is already all zeroes. */
5736
5737 static void
5738 initialize_objfile_symbol_1 (struct symbol *sym)
5739 {
5740 SYMBOL_OBJFILE_OWNED (sym) = 1;
5741 SYMBOL_SECTION (sym) = -1;
5742 }
5743
5744 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
5745
5746 void
5747 initialize_objfile_symbol (struct symbol *sym)
5748 {
5749 memset (sym, 0, sizeof (*sym));
5750 initialize_objfile_symbol_1 (sym);
5751 }
5752
5753 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5754 obstack. */
5755
5756 struct symbol *
5757 allocate_symbol (struct objfile *objfile)
5758 {
5759 struct symbol *result;
5760
5761 result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
5762 initialize_objfile_symbol_1 (result);
5763
5764 return result;
5765 }
5766
5767 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5768 obstack. */
5769
5770 struct template_symbol *
5771 allocate_template_symbol (struct objfile *objfile)
5772 {
5773 struct template_symbol *result;
5774
5775 result = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct template_symbol);
5776 initialize_objfile_symbol_1 (result);
5777
5778 return result;
5779 }
5780
5781 /* See symtab.h. */
5782
5783 struct objfile *
5784 symbol_objfile (const struct symbol *symbol)
5785 {
5786 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5787 return SYMTAB_OBJFILE (symbol->owner.symtab);
5788 }
5789
5790 /* See symtab.h. */
5791
5792 struct gdbarch *
5793 symbol_arch (const struct symbol *symbol)
5794 {
5795 if (!SYMBOL_OBJFILE_OWNED (symbol))
5796 return symbol->owner.arch;
5797 return get_objfile_arch (SYMTAB_OBJFILE (symbol->owner.symtab));
5798 }
5799
5800 /* See symtab.h. */
5801
5802 struct symtab *
5803 symbol_symtab (const struct symbol *symbol)
5804 {
5805 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5806 return symbol->owner.symtab;
5807 }
5808
5809 /* See symtab.h. */
5810
5811 void
5812 symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
5813 {
5814 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol));
5815 symbol->owner.symtab = symtab;
5816 }
5817
5818
5819
5820 void
5821 _initialize_symtab (void)
5822 {
5823 initialize_ordinary_address_classes ();
5824
5825 main_progspace_key
5826 = register_program_space_data_with_cleanup (NULL, main_info_cleanup);
5827
5828 symbol_cache_key
5829 = register_program_space_data_with_cleanup (NULL, symbol_cache_cleanup);
5830
5831 add_info ("variables", info_variables_command, _("\
5832 All global and static variable names, or those matching REGEXP."));
5833 if (dbx_commands)
5834 add_com ("whereis", class_info, info_variables_command, _("\
5835 All global and static variable names, or those matching REGEXP."));
5836
5837 add_info ("functions", info_functions_command,
5838 _("All function names, or those matching REGEXP."));
5839
5840 /* FIXME: This command has at least the following problems:
5841 1. It prints builtin types (in a very strange and confusing fashion).
5842 2. It doesn't print right, e.g. with
5843 typedef struct foo *FOO
5844 type_print prints "FOO" when we want to make it (in this situation)
5845 print "struct foo *".
5846 I also think "ptype" or "whatis" is more likely to be useful (but if
5847 there is much disagreement "info types" can be fixed). */
5848 add_info ("types", info_types_command,
5849 _("All type names, or those matching REGEXP."));
5850
5851 add_info ("sources", info_sources_command,
5852 _("Source files in the program."));
5853
5854 add_com ("rbreak", class_breakpoint, rbreak_command,
5855 _("Set a breakpoint for all functions matching REGEXP."));
5856
5857 add_setshow_enum_cmd ("multiple-symbols", no_class,
5858 multiple_symbols_modes, &multiple_symbols_mode,
5859 _("\
5860 Set the debugger behavior when more than one symbol are possible matches\n\
5861 in an expression."), _("\
5862 Show how the debugger handles ambiguities in expressions."), _("\
5863 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5864 NULL, NULL, &setlist, &showlist);
5865
5866 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5867 &basenames_may_differ, _("\
5868 Set whether a source file may have multiple base names."), _("\
5869 Show whether a source file may have multiple base names."), _("\
5870 (A \"base name\" is the name of a file with the directory part removed.\n\
5871 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5872 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5873 before comparing them. Canonicalization is an expensive operation,\n\
5874 but it allows the same file be known by more than one base name.\n\
5875 If not set (the default), all source files are assumed to have just\n\
5876 one base name, and gdb will do file name comparisons more efficiently."),
5877 NULL, NULL,
5878 &setlist, &showlist);
5879
5880 add_setshow_zuinteger_cmd ("symtab-create", no_class, &symtab_create_debug,
5881 _("Set debugging of symbol table creation."),
5882 _("Show debugging of symbol table creation."), _("\
5883 When enabled (non-zero), debugging messages are printed when building\n\
5884 symbol tables. A value of 1 (one) normally provides enough information.\n\
5885 A value greater than 1 provides more verbose information."),
5886 NULL,
5887 NULL,
5888 &setdebuglist, &showdebuglist);
5889
5890 add_setshow_zuinteger_cmd ("symbol-lookup", no_class, &symbol_lookup_debug,
5891 _("\
5892 Set debugging of symbol lookup."), _("\
5893 Show debugging of symbol lookup."), _("\
5894 When enabled (non-zero), symbol lookups are logged."),
5895 NULL, NULL,
5896 &setdebuglist, &showdebuglist);
5897
5898 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class,
5899 &new_symbol_cache_size,
5900 _("Set the size of the symbol cache."),
5901 _("Show the size of the symbol cache."), _("\
5902 The size of the symbol cache.\n\
5903 If zero then the symbol cache is disabled."),
5904 set_symbol_cache_size_handler, NULL,
5905 &maintenance_set_cmdlist,
5906 &maintenance_show_cmdlist);
5907
5908 add_cmd ("symbol-cache", class_maintenance, maintenance_print_symbol_cache,
5909 _("Dump the symbol cache for each program space."),
5910 &maintenanceprintlist);
5911
5912 add_cmd ("symbol-cache-statistics", class_maintenance,
5913 maintenance_print_symbol_cache_statistics,
5914 _("Print symbol cache statistics for each program space."),
5915 &maintenanceprintlist);
5916
5917 add_cmd ("flush-symbol-cache", class_maintenance,
5918 maintenance_flush_symbol_cache,
5919 _("Flush the symbol cache for each program space."),
5920 &maintenancelist);
5921
5922 observer_attach_executable_changed (symtab_observer_executable_changed);
5923 observer_attach_new_objfile (symtab_new_objfile_observer);
5924 observer_attach_free_objfile (symtab_free_objfile_observer);
5925 }
symbol_block_ops
Definition: symtab.h:979
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
language_asm
Definition: defs.h:214
objfile::flags
objfile_flags flags
Definition: objfiles.h:311
string
const char * string
Definition: signals.c:50
scoped_rbreak_breakpoints
Definition: breakpoint.h:1615
lookup_symbol_search_name
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition: symtab.c:1905
nr_languages
Definition: defs.h:220
completion_list_objc_symbol
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:4785
set_symbol_cache_size_handler
static void set_symbol_cache_size_handler(const char *args, int from_tty, struct cmd_list_element *c)
Definition: symtab.c:1275
check_field
static int check_field(struct type *type, const char *name, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1964
symbol_impl::ops_register
const struct symbol_register_ops * ops_register
Definition: symtab.h:1029
main_name
char * main_name(void)
Definition: symtab.c:5568
template_symbol
Definition: symtab.h:1203
main_language
enum language main_language(void)
Definition: symtab.c:5582
symtab_symbol_info
static void symtab_symbol_info(const char *regexp, enum search_domain kind, int from_tty)
Definition: symtab.c:4566
symtab_to_filename_for_display
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1168
count_path_elements
int count_path_elements(const char *path)
Definition: utils.c:3365
type_code
type_code
Definition: gdbtypes.h:80
macro_source_file
Definition: macrotab.h:124
SYMTAB_COMPUNIT
#define SYMTAB_COMPUNIT(symtab)
Definition: symtab.h:1331
symbol::owner
union symbol::@173 owner
completer.h
search_symbols
std::vector< symbol_search > search_symbols(const char *regexp, enum search_domain kind, int nfiles, const char *files[])
Definition: symtab.c:4269
language_lookup_primitive_type_as_symbol
struct symbol * language_lookup_primitive_type_as_symbol(const struct language_defn *la, struct gdbarch *gdbarch, const char *name)
Definition: language.c:1099
make_source_files_completion_list
completion_list make_source_files_completion_list(const char *text, const char *word)
Definition: symtab.c:5381
lookup_minimal_symbol_by_pc_section
struct bound_minimal_symbol lookup_minimal_symbol_by_pc_section(CORE_ADDR pc, struct obj_section *section)
Definition: minsyms.c:906
symbol_cache_stats
static void symbol_cache_stats(struct symbol_cache *cache)
Definition: symtab.c:1560
symbol_search::block
int block
Definition: symtab.h:1949
gdb_obstack.h
symbol_cache_slot_state
symbol_cache_slot_state
Definition: symtab.c:140
SYMTAB_LANGUAGE
#define SYMTAB_LANGUAGE(symtab)
Definition: symtab.h:1333
set_symbol_cache_size
static void set_symbol_cache_size(unsigned int new_size)
Definition: symtab.c:1257
dbx_commands
int dbx_commands
Definition: main.c:56
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
main_info
Definition: symtab.c:104
allocate_template_symbol
struct template_symbol * allocate_template_symbol(struct objfile *objfile)
Definition: symtab.c:5771
macro_scope::file
struct macro_source_file * file
Definition: macroscope.h:34
observer_attach_free_objfile
struct observer * observer_attach_free_objfile(observer_free_objfile_ftype *f)
basic_lookup_transparent_type_quick
static struct type * basic_lookup_transparent_type_quick(struct objfile *objfile, int block_index, const char *name)
Definition: symtab.c:2731
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
symbol_set_symtab
void symbol_set_symtab(struct symbol *symbol, struct symtab *symtab)
Definition: symtab.c:5812
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
MSYMBOL_LANGUAGE
#define MSYMBOL_LANGUAGE(symbol)
Definition: symtab.h:698
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
symbol_set_language
void symbol_set_language(struct general_symbol_info *gsymbol, enum language language, struct obstack *obstack)
Definition: symtab.c:647
linetable::item
struct linetable_entry item[1]
Definition: symtab.h:1258
symbol_find_demangled_name
static char * symbol_find_demangled_name(struct general_symbol_info *gsymbol, const char *mangled)
Definition: symtab.c:729
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
mst_bss
Definition: symtab.h:587
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
symbol_computed_ops::describe_location
void(* describe_location)(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
Definition: symtab.h:943
multiple_symbols_cancel
const char multiple_symbols_cancel[]
Definition: symtab.c:239
go_main_name
const char * go_main_name(void)
Definition: go-lang.c:55
xfree
void xfree(void *)
objfile::separate_debug_objfile_backlink
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:441
LOC_BLOCK
Definition: symtab.h:854
solist.h
no_class
Definition: command.h:41
strcmp_iw
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2517
symbol::symtab
struct symtab * symtab
Definition: symtab.h:1068
TYPE_NFN_FIELDS
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1311
demangle_result_storage::set_malloc_ptr
const char * set_malloc_ptr(char *ptr)
Definition: symtab.h:2056
section_is_overlay
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:2978
add_partial_filename_data
Definition: symtab.c:5338
language_defn::la_lookup_transparent_type
struct type *(* la_lookup_transparent_type)(const char *)
Definition: language.h:278
multiple_symbols_modes
static const char *const multiple_symbols_modes[]
Definition: symtab.c:240
cmd_list_element
Definition: cli-decode.h:46
initialize_objfile_symbol_1
static void initialize_objfile_symbol_1(struct symbol *sym)
Definition: symtab.c:5738
gdb_regex.h
program_space::symfile_object_file
struct objfile * symfile_object_file
Definition: progspace.h:184
obj_section::the_bfd_section
struct bfd_section * the_bfd_section
Definition: objfiles.h:126
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
symbol_search
Definition: symtab.h:1918
symbol_cache::static_symbols
struct block_symbol_cache * static_symbols
Definition: symtab.c:211
symbol_impl::aclass
enum address_class aclass
Definition: symtab.h:1020
expand_symtabs_matching
void 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, enum search_domain kind)
Definition: symfile.c:3803
symtab_and_line::end
CORE_ADDR end
Definition: symtab.h:1760
symbol_search_name
const char * symbol_search_name(const struct general_symbol_info *gsymbol)
Definition: symtab.c:943
macro_scope
Definition: macroscope.h:33
objfile::pspace
struct program_space * pspace
Definition: objfiles.h:315
quick_symbol_functions::map_symtabs_matching_filename
bool(* map_symtabs_matching_filename)(struct objfile *objfile, const char *name, const char *real_path, gdb::function_view< bool(symtab *)> callback)
Definition: symfile.h:163
get_symbol_name_matcher
symbol_name_matcher_ftype * get_symbol_name_matcher(const language_defn *lang, const lookup_name_info &lookup_name)
Definition: language.c:730
ada-lang.h
map_symbol_filenames
void map_symbol_filenames(symbol_filename_ftype *fun, void *data, int need_fullname)
Definition: symfile.c:3826
find_pc_sect_function
struct symbol * find_pc_sect_function(CORE_ADDR pc, struct obj_section *section)
Definition: blockframe.c:136
gdb_mangle_name
char * gdb_mangle_name(struct type *type, int method_id, int signature_id)
Definition: symtab.c:522
block_global_block
const struct block * block_global_block(const struct block *block)
Definition: block.c:379
TYPE_FN_FIELDLIST
#define TYPE_FN_FIELDLIST(thistype, n)
Definition: gdbtypes.h:1413
block_lookup_symbol_primary
struct symbol * block_lookup_symbol_primary(const struct block *block, const char *name, const domain_enum domain)
Definition: block.c:734
lookup_name_info::completion_mode
bool completion_mode() const
Definition: symtab.h:195
LOC_FINAL_VALUE
Definition: symtab.h:899
complete_symbol_mode
complete_symbol_mode
Definition: symtab.h:1826
domain_enum
enum domain_enum_tag domain_enum
compare_filenames_for_search
int compare_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:318
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
collect_file_symbol_completion_matches
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:5240
lookup_symtab
struct symtab * lookup_symtab(const char *name)
Definition: symtab.c:502
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
memset
void * memset(T *s, int c, size_t n)=delete
objfile_per_bfd_storage
Definition: objfiles.h:187
TYPE_IS_OPAQUE
#define TYPE_IS_OPAQUE(thistype)
Definition: gdbtypes.h:1472
quick_symbol_functions::find_pc_sect_compunit_symtab
struct compunit_symtab *(* find_pc_sect_compunit_symtab)(struct objfile *objfile, struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin)
Definition: symfile.h:270
symbol_cache_dump
static void symbol_cache_dump(const struct symbol_cache *cache)
Definition: symtab.c:1464
obj_section_endaddr
#define obj_section_endaddr(s)
Definition: objfiles.h:146
compare_glob_filenames_for_search
int compare_glob_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:356
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
free_symbol_cache
static void free_symbol_cache(struct symbol_cache *cache)
Definition: symtab.c:1218
observer_attach_executable_changed
struct observer * observer_attach_executable_changed(observer_executable_changed_ftype *f)
gdbarch_deprecated_function_start_offset
CORE_ADDR gdbarch_deprecated_function_start_offset(struct gdbarch *gdbarch)
Definition: gdbarch.c:2987
quick_symbol_functions::expand_symtabs_with_fullname
void(* expand_symtabs_with_fullname)(struct objfile *objfile, const char *fullname)
Definition: symfile.h:208
collect_symbol_completion_matches_type
void collect_symbol_completion_matches_type(completion_tracker &tracker, const char *text, const char *word, enum type_code code)
Definition: symtab.c:5221
add_setshow_enum_cmd
void 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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:515
symbol_lookup_debug
unsigned int symbol_lookup_debug
Definition: symtab.c:218
symbol_name_matcher_ftype
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:324
SYMBOL_SLOT_NOT_FOUND
Definition: symtab.c:143
ALL_DOMAIN
Definition: symtab.h:786
general_symbol_info::section
short section
Definition: symtab.h:443
add_cmd
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:262
type_print
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:358
quick_symbol_functions::find_compunit_symtab_by_address
struct compunit_symtab *(* find_compunit_symtab_by_address)(struct objfile *objfile, CORE_ADDR address)
Definition: symfile.h:279
symbol_arch
struct gdbarch * symbol_arch(const struct symbol *symbol)
Definition: symtab.c:5793
symbol_cache_slot::value
union symbol_cache_slot::@169 value
mst_abs
Definition: symtab.h:588
multiple_symbols_ask
const char multiple_symbols_ask[]
Definition: symtab.c:237
SYMBOL_LOOKUP_FAILED_P
#define SYMBOL_LOOKUP_FAILED_P(SIB)
Definition: symtab.c:135
initialize_objfile_symbol
void initialize_objfile_symbol(struct symbol *sym)
Definition: symtab.c:5747
file_matches
static int file_matches(const char *file, const char *files[], int nfiles, int basenames)
Definition: symtab.c:4204
have_partial_symbols
int have_partial_symbols(void)
Definition: objfiles.c:1023
collect_symbol_completion_matches
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:5206
cp-support.h
language_defn::la_language
enum language la_language
Definition: language.h:144
compunit_symtab
Definition: symtab.h:1380
TYPE_CODE_UNDEF
Definition: gdbtypes.h:83
symbol_register_ops
Definition: symtab.h:1010
maintenance_print_symbol_cache_statistics
static void maintenance_print_symbol_cache_statistics(const char *args, int from_tty)
Definition: symtab.c:1592
ALL_OBJFILE_OSECTIONS
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:630
UNDEF_DOMAIN
Definition: symtab.h:734
LOC_TYPEDEF
Definition: symtab.h:844
output_source_filename_data::filename_seen_cache
struct filename_seen_cache * filename_seen_cache
Definition: symtab.c:4113
skip_prologue_using_sal
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3854
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
null_block_symbol
const struct block_symbol null_block_symbol
Definition: symtab.c:96
symtab_and_line::section
struct obj_section * section
Definition: symtab.h:1753
global_sym_lookup_data::result
struct block_symbol result
Definition: symtab.c:2622
lookup_symbol
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:1893
mst_text_gnu_ifunc
Definition: symtab.h:583
symtab::filename
const char * filename
Definition: symtab.h:1309
add_partial_filename_data::text
const char * text
Definition: symtab.c:5341
symtab_free_objfile_observer
static void symtab_free_objfile_observer(struct objfile *objfile)
Definition: symtab.c:1628
gdb_realpath
gdb::unique_xmalloc_ptr< char > gdb_realpath(const char *filename)
Definition: utils.c:2842
search_domain
search_domain
Definition: symtab.h:773
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
symbol_impls
const struct symbol_impl * symbol_impls
Definition: symtab.c:5646
STRUCT_DOMAIN
Definition: symtab.h:745
_
#define _(String)
Definition: gdb_locale.h:35
demangle_result_storage
Definition: symtab.h:2042
mst_file_data
Definition: symtab.h:601
find_function_start_sal
struct symtab_and_line find_function_start_sal(struct symbol *sym, int funfirstline)
Definition: symtab.c:3585
strip_leading_path_elements
const char * strip_leading_path_elements(const char *path, int n)
Definition: utils.c:3401
defs.h
TYPE_FIELD
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1370
general_symbol_info::obstack
struct obstack * obstack
Definition: symtab.h:420
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
symtab_observer_executable_changed
static void symtab_observer_executable_changed(void)
Definition: symtab.c:5595
pascal_main_name
const char * pascal_main_name(void)
Definition: p-lang.c:57
fn_field
Definition: gdbtypes.h:832
add_partial_filename_data::text_len
int text_len
Definition: symtab.c:5343
symbol_search::compare_search_syms
static int compare_search_syms(const symbol_search &sym_a, const symbol_search &sym_b)
Definition: symtab.c:4227
producer_is_realview
int producer_is_realview(const char *producer)
Definition: symtab.c:5605
register_symbol_computed_impl
int register_symbol_computed_impl(enum address_class aclass, const struct symbol_computed_ops *ops)
Definition: symtab.c:5658
register_symbol_block_impl
int register_symbol_block_impl(enum address_class aclass, const struct symbol_block_ops *ops)
Definition: symtab.c:5684
global_sym_lookup_data::name
const char * name
Definition: symtab.c:2615
default_macro_scope
struct macro_scope * default_macro_scope(void)
Definition: macroscope.c:102
rbreak_command_wrapper
void rbreak_command_wrapper(char *regexp, int from_tty)
Definition: symtab.c:4631
objfile::per_bfd
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:347
LABEL_DOMAIN
Definition: symtab.h:753
gdb_static_assert
gdb_static_assert(MAX_SYMBOL_IMPLS<=(1<< SYMBOL_ACLASS_BITS))
lookup_minimal_symbol_text
struct bound_minimal_symbol lookup_minimal_symbol_text(const char *name, struct objfile *objf)
Definition: minsyms.c:519
class_info
Definition: command.h:42
symbol_impl::ops_block
const struct symbol_block_ops * ops_block
Definition: symtab.h:1026
maintenance_set_cmdlist
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:634
symbol_objfile
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:5784
operator_chars
static const char * operator_chars(const char *p, const char **end)
Definition: symtab.c:3975
lookup_symbol_in_objfile_from_linkage_name
static struct block_symbol lookup_symbol_in_objfile_from_linkage_name(struct objfile *objfile, const char *linkage_name, domain_enum domain)
Definition: symtab.c:2308
block_for_pc
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
lookup_symbol_in_objfile
static struct block_symbol lookup_symbol_in_objfile(struct objfile *objfile, int block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2528
progspace-and-thread.h
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
macroscope.h
language_defn::la_name_of_this
const char * la_name_of_this
Definition: language.h:265
macro_user_macros
struct macro_table * macro_user_macros
Definition: macroscope.c:35
search_domain_name
const char * search_domain_name(enum search_domain e)
Definition: symtab.c:277
find_pcs_for_symtab_line
std::vector< CORE_ADDR > find_pcs_for_symtab_line(struct symtab *symtab, int line, struct linetable_entry **best_item)
Definition: symtab.c:3416
objfiles.h
multiple_symbols_select_mode
const char * multiple_symbols_select_mode(void)
Definition: symtab.c:252
host_address_to_string
#define host_address_to_string(ADDR)
Definition: print-utils.h:75
completion_match_result
Definition: completer.h:205
SYMBOL_OBJ_SECTION
#define SYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:471
arch-utils.h
program_space::num
int num
Definition: progspace.h:143
find_pc_overlay
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3173
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
quick_symbol_functions::lookup_symbol
struct compunit_symtab *(* lookup_symbol)(struct objfile *objfile, int block_index, const char *name, domain_enum domain)
Definition: symfile.h:176
language_defn
Definition: language.h:132
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
LOC_REGISTER
Definition: symtab.h:819
observer.h
symtab_to_fullname
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
find_pc_compunit_symtab
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
Definition: symtab.c:2988
print_symbol_info
static void print_symbol_info(enum search_domain kind, struct symbol *sym, int block, const char *last)
Definition: symtab.c:4505
lookup_name_info::match_type
symbol_name_match_type match_type() const
Definition: symtab.h:194
lookup_minimal_symbol_by_pc_name
struct minimal_symbol * lookup_minimal_symbol_by_pc_name(CORE_ADDR pc, const char *name, struct objfile *objf)
Definition: minsyms.c:570
symtab_and_line::explicit_line
bool explicit_line
Definition: symtab.h:1762
initialize_ordinary_address_classes
static void initialize_ordinary_address_classes(void)
Definition: symtab.c:5724
GLOBAL_BLOCK
Definition: defs.h:686
MSYMBOL_OBJ_SECTION
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:700
add_setshow_zuinteger_cmd
void 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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
parser-defs.h
gdbarch_skip_main_prologue_p
int gdbarch_skip_main_prologue_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2779
demangle_for_lookup
const char * demangle_for_lookup(const char *name, enum language lang, demangle_result_storage &storage)
Definition: symtab.c:1823
symtab.h
MSYMBOL_PRINT_NAME
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:708
info_sources_command
static void info_sources_command(const char *ignore, int from_tty)
Definition: symtab.c:4163
field_of_this_result::fn_field
struct fn_fieldlist * fn_field
Definition: symtab.h:1545
symtab_new_objfile_observer
static void symtab_new_objfile_observer(struct objfile *objfile)
Definition: symtab.c:1619
maybe_add_partial_symtab_filename
static void maybe_add_partial_symtab_filename(const char *filename, const char *fullname, void *user_data)
Definition: symtab.c:5350
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
cleanup_check.is_destructor
def is_destructor(decl)
Definition: cleanup_check.py:47
gdb_demangle
char * gdb_demangle(const char *name, int options)
Definition: cp-support.c:1518
DEFAULT_SYMBOL_CACHE_SIZE
#define DEFAULT_SYMBOL_CACHE_SIZE
Definition: symtab.c:124
TYPE_FN_FIELD_PHYSNAME
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:1426
FUNCTIONS_DOMAIN
Definition: symtab.h:780
symbol_block_ops::find_frame_base_location
void(* find_frame_base_location)(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: symtab.h:985
minimal_symbol::created_by_gdb
unsigned int created_by_gdb
Definition: symtab.h:648
language_defn::la_collect_symbol_completion_matches
void(* la_collect_symbol_completion_matches)(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type match_type, const char *text, const char *word, enum type_code code)
Definition: language.h:323
multiple_symbols_mode
static const char * multiple_symbols_mode
Definition: symtab.c:247
gdb_optional.h
OBJF_REORDERED
Definition: objfile-flags.h:36
macro_for_each
void macro_for_each(struct macro_table *table, gdb::function_view< macro_callback_fn > fn)
Definition: macrotab.c:993
hash_demangled_name_entry
static hashval_t hash_demangled_name_entry(const void *data)
Definition: symtab.c:684
ada_main_name
char * ada_main_name(void)
Definition: ada-lang.c:916
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
SYMBOL_VALUE_ADDRESS
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:464
filename_seen_cache
Definition: filename-seen-cache.h:25
LOC_COMPUTED
Definition: symtab.h:892
lookup_symbol_via_quick_fns
static struct block_symbol lookup_symbol_via_quick_fns(struct objfile *objfile, int block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2362
basic_lookup_symbol_nonlocal
struct block_symbol basic_lookup_symbol_nonlocal(const struct language_defn *langdef, const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2417
print_msymbol_info
static void print_msymbol_info(struct bound_minimal_symbol msymbol)
Definition: symtab.c:4544
symbol_cache_flush
static void symbol_cache_flush(struct program_space *pspace)
Definition: symtab.c:1418
set_main_name
static void set_main_name(const char *name, enum language lang)
Definition: symtab.c:5476
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
lookup_transparent_type
struct type * lookup_transparent_type(const char *name)
Definition: symtab.c:2722
MODULE_DOMAIN
Definition: symtab.h:749
expand_symtab_containing_pc
void expand_symtab_containing_pc(CORE_ADDR pc, struct obj_section *section)
Definition: symtab.c:1032
SYMBOL_DOMAIN
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:1152
linetable_entry::pc
CORE_ADDR pc
Definition: symtab.h:1231
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
symbol_is_function_or_method
bool symbol_is_function_or_method(symbol *sym)
Definition: symtab.c:4918
macro_definition
Definition: macrotab.h:288
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
mst_data
Definition: symtab.h:586
typedef_print
void typedef_print(struct type *type, struct symbol *newobj, struct ui_file *stream)
Definition: typeprint.c:336
SYMBOL_MATCHES_SEARCH_NAME
#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)
Definition: symtab.h:557
language_ada
Definition: defs.h:219
COMMON_BLOCK_DOMAIN
Definition: symtab.h:757
is_constructor_name
enum ctor_kinds is_constructor_name(const char *name)
Definition: cp-abi.c:36
add_partial_filename_data::filename_seen_cache
struct filename_seen_cache * filename_seen_cache
Definition: symtab.c:5340
SYMTAB_OBJFILE
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:1336
eq_demangled_name_entry
static int eq_demangled_name_entry(const void *a, const void *b)
Definition: symtab.c:695
iterate_over_some_symtabs
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:399
find_pc_function
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
TYPES_DOMAIN
Definition: symtab.h:783
block_symbol::block
const struct block * block
Definition: symtab.h:1140
eq_symbol_entry
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:1085
macro_expansion_c
Definition: language.h:103
symbol_natural_name
const char * symbol_natural_name(const struct general_symbol_info *gsymbol)
Definition: symtab.c:891
bound_minimal_symbol
Definition: minsyms.h:29
find_symbol_at_address
struct symbol * find_symbol_at_address(CORE_ADDR address)
Definition: symtab.c:2996
scoped_restore_current_pspace_and_thread
Definition: progspace-and-thread.h:29
symbol_get_demangled_name
const char * symbol_get_demangled_name(const struct general_symbol_info *gsymbol)
Definition: symtab.c:630
minimal_symbol::filename
const char * filename
Definition: symtab.h:640
lookup_name_info::match_any
static const lookup_name_info & match_any()
Definition: symtab.c:1794
symbol_computed_ops::read_variable
struct value *(* read_variable)(struct symbol *symbol, struct frame_info *frame)
Definition: symtab.h:926
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
find_function_alias_target
symbol * find_function_alias_target(bound_minimal_symbol msymbol)
Definition: symtab.c:3953
symbol_cache
Definition: symtab.c:208
completion_list
std::vector< gdb::unique_xmalloc_ptr< char > > completion_list
Definition: completer.h:69
language_auto
Definition: defs.h:206
compunit_primary_filetab
struct symtab * compunit_primary_filetab(const struct compunit_symtab *cust)
Definition: symtab.c:292
linetable
Definition: symtab.h:1251
symbol_demangled_name
const char * symbol_demangled_name(const struct general_symbol_info *gsymbol)
Definition: symtab.c:915
symbol_computed_ops::tracepoint_var_ref
void(* tracepoint_var_ref)(struct symbol *symbol, struct agent_expr *ax, struct axs_value *value)
Definition: symtab.h:956
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
maintenance_flush_symbol_cache
static void maintenance_flush_symbol_cache(const char *args, int from_tty)
Definition: symtab.c:1547
fn_field::is_const
unsigned int is_const
Definition: gdbtypes.h:861
cli-utils.h
block_symbol
Definition: symtab.h:1133
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
symbol_name_match_type::EXPRESSION
frame.h
expression.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
macrotab.h
output_source_filename
static void output_source_filename(const char *name, struct output_source_filename_data *data)
Definition: symtab.c:4124
create_demangled_names_hash
static void create_demangled_names_hash(struct objfile *objfile)
Definition: symtab.c:710
objfile::sf
const struct sym_fns * sf
Definition: objfiles.h:381
symbol_cache_cleanup
static void symbol_cache_cleanup(struct program_space *pspace, void *data)
Definition: symtab.c:1247
block_symbol_cache
Definition: symtab.c:183
inferior.h
basic_lookup_transparent_type
struct type * basic_lookup_transparent_type(const char *name)
Definition: symtab.c:2792
language_defn::la_lookup_symbol_nonlocal
struct block_symbol(* la_lookup_symbol_nonlocal)(const struct language_defn *, const char *, const struct block *, const domain_enum)
Definition: language.h:272
ANOFFSET
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:1276
demangled_name_entry::mangled
const char * mangled
Definition: symtab.c:677
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
TYPE_CODE_UNION
Definition: gdbtypes.h:107
ALL_COMPUNITS
#define ALL_COMPUNITS(objfile, cu)
Definition: objfiles.h:619
objfile::sections
struct obj_section * sections
Definition: objfiles.h:423
language_str
const char * language_str(enum language lang)
Definition: language.c:502
linetable_entry
Definition: symtab.h:1228
type
Definition: gdbtypes.h:749
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
completion_skip_symbol
static bool completion_skip_symbol(complete_symbol_mode mode, Symbol *sym)
Definition: symtab.h:1880
is_destructor_name
enum dtor_kinds is_destructor_name(const char *name)
Definition: cp-abi.c:44
language.h
complete_symbol_mode::EXPRESSION
demangle_for_lookup_info::demangle_for_lookup_info
demangle_for_lookup_info(const lookup_name_info &lookup_name, language lang)
Definition: symtab.c:1765
LOC_CONST
Definition: symtab.h:801
LOC_UNRESOLVED
Definition: symtab.h:883
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
make_symbol_cache
static struct symbol_cache * make_symbol_cache(unsigned int size)
Definition: symtab.c:1206
lookup_name_info::ignore_parameters
const bool ignore_parameters() const
Definition: symtab.h:197
general_symbol_info::language_specific
union general_symbol_info::@172 language_specific
objfile_per_bfd_storage::demangled_names_hash
htab * demangled_names_hash
Definition: objfiles.h:218
symtab::language
enum language language
Definition: symtab.h:1323
objfile::separate_debug_objfile
struct objfile * separate_debug_objfile
Definition: objfiles.h:436
MSYMBOL_NATURAL_NAME
#define MSYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:705
address_class
address_class
Definition: symtab.h:793
type
static const char * type
Definition: language.c:113
completion_list_add_fields
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:4895
main_info::name_of_main
char * name_of_main
Definition: symtab.c:108
SYMBOL_ACLASS_BITS
#define SYMBOL_ACLASS_BITS
Definition: symtab.h:908
symbol_cache_slot::objfile_context
const struct objfile * objfile_context
Definition: symtab.c:167
SYMBOL_LINE
#define SYMBOL_LINE(symbol)
Definition: symtab.h:1162
output_source_filename_data::first
int first
Definition: symtab.c:4116
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
objfile::compunit_symtabs
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:320
skip_prologue_using_lineinfo
static CORE_ADDR skip_prologue_using_lineinfo(CORE_ADDR func_addr, struct symtab *symtab)
Definition: symtab.c:3631
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
find_pc_sect_compunit_symtab
struct compunit_symtab * find_pc_sect_compunit_symtab(CORE_ADDR pc, struct obj_section *section)
Definition: symtab.c:2872
is_operator_name
int is_operator_name(const char *name)
Definition: cp-abi.c:60
BLOCK_END
#define BLOCK_END(bl)
Definition: block.h:106
gdbarch_iterate_over_objfiles_in_search_order
void gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
Definition: gdbarch.c:4819
LOC_STATIC
Definition: symtab.h:805
gdbarch_addr_bit
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1848
complete_symbol_mode::LINESPEC
language_fortran
Definition: defs.h:212
compunit_symtab::next
struct compunit_symtab * next
Definition: symtab.h:1383
completion_match::match
const char * match()
Definition: completer.h:84
domain_name
const char * domain_name(domain_enum e)
Definition: symtab.c:260
block_find_non_opaque_type
int block_find_non_opaque_type(struct symbol *sym, void *data)
Definition: block.c:797
TYPE_BASECLASS
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1330
MAX_SYMBOL_IMPLS
#define MAX_SYMBOL_IMPLS
Definition: symtab.c:5635
main_info_cleanup
static void main_info_cleanup(struct program_space *pspace, void *data)
Definition: symtab.c:5466
symbol_cache_slot::name
char * name
Definition: symtab.c:174
lookup_symbol_aux
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 *)
section_is_mapped
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:3017
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
add_partial_filename_data::word
const char * word
Definition: symtab.c:5342
lookup_global_symbol
struct block_symbol lookup_global_symbol(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2651
demangle_result_storage::swap_string
const char * swap_string(std::string &str)
Definition: symtab.h:2048
symtab
Definition: symtab.h:1291
LOC_REGPARM_ADDR
Definition: symtab.h:835
lookup_symbol_in_objfile_symtabs
static struct block_symbol lookup_symbol_in_objfile_symtabs(struct objfile *objfile, int block_index, const char *name, const domain_enum domain)
Definition: symtab.c:2252
objfile_name
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1557
get_symbol_cache
static struct symbol_cache * get_symbol_cache(struct program_space *pspace)
Definition: symtab.c:1229
basenames_may_differ
int basenames_may_differ
Definition: symtab.c:231
xmalloc
void * xmalloc(YYSIZE_T)
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
completion_match_result::match_for_lcd
completion_match_for_lcd match_for_lcd
Definition: completer.h:211
skip_prologue_sal
void skip_prologue_sal(struct symtab_and_line *sal)
Definition: symtab.c:3671
filename-seen-cache.h
ALL_FILETABS
#define ALL_FILETABS(objfile, ps, s)
Definition: objfiles.h:613
block_symbol_cache::collisions
unsigned int collisions
Definition: symtab.c:187
symbol_matches_search_name
bool symbol_matches_search_name(const struct general_symbol_info *gsymbol, const lookup_name_info &name)
Definition: symtab.c:954
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
symbol_set_demangled_name
void symbol_set_demangled_name(struct general_symbol_info *gsymbol, const char *name, struct obstack *obstack)
Definition: symtab.c:606
symbol_cache_slot::found
struct block_symbol found
Definition: symtab.c:171
maintenanceprintlist
struct cmd_list_element * maintenanceprintlist
Definition: cli-cmds.c:143
block_for_pc_sect
const struct block * block_for_pc_sect(CORE_ADDR pc, struct obj_section *section)
Definition: block.c:267
language_d
Definition: defs.h:210
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
general_symbol_info::name
const char * name
Definition: symtab.h:384
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
ALL_OBJFILE_COMPUNITS
#define ALL_OBJFILE_COMPUNITS(objfile, cu)
Definition: objfiles.h:600
field_of_this_result::type
struct type * type
Definition: symtab.h:1535
next_aclass_value
static int next_aclass_value
Definition: symtab.c:5631
main_progspace_key
static const struct program_space_data * main_progspace_key
Definition: symtab.c:100
hash
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
block_symbol_cache::misses
unsigned int misses
Definition: symtab.c:186
find_line_pc
int find_line_pc(struct symtab *symtab, int line, CORE_ADDR *pc)
Definition: symtab.c:3456
wrap_here
void wrap_here(const char *indent)
Definition: utils.c:1596
blockvector
Definition: block.h:112
addrmap.h
CP_OPERATOR_STR
#define CP_OPERATOR_STR
Definition: cp-support.h:51
CP_OPERATOR_LEN
#define CP_OPERATOR_LEN
Definition: cp-support.h:55
error_in_psymtab_expansion
static void ATTRIBUTE_NORETURN error_in_psymtab_expansion(int block_index, const char *name, struct compunit_symtab *cust)
Definition: symtab.c:2345
SYMBOL_OBJFILE_OWNED
#define SYMBOL_OBJFILE_OWNED(symbol)
Definition: symtab.h:1156
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
default_collect_symbol_completion_matches
void default_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)
Definition: symtab.c:5190
selector
unsigned short selector
Definition: go32-nat.c:1066
objfile
Definition: objfiles.h:286
symtab_and_line
Definition: symtab.h:1746
TYPE_CODE_PTR
Definition: gdbtypes.h:84
language_pascal
Definition: defs.h:215
COMPUNIT_BLOCKVECTOR
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1465
fixup_symbol_section
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1718
obj_section
Definition: objfiles.h:123
VARIABLES_DOMAIN
Definition: symtab.h:777
block_inlined_p
int block_inlined_p(const struct block *bl)
Definition: block.c:126
find_line_pc_range
int find_line_pc_range(struct symtab_and_line sal, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3483
MSYMBOL_TYPE
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:680
hex_string_custom
char * hex_string_custom(LONGEST num, int width)
Definition: print-utils.c:231
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
block_find_symbol
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:769
ALL_MSYMBOLS
#define ALL_MSYMBOLS(objfile, m)
Definition: objfiles.h:626
current_language
const struct language_defn * current_language
Definition: language.c:81
find_pc_mapped_section
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3202
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
symbol::type
struct type * type
Definition: symtab.h:1058
default_collect_symbol_completion_matches_break_on
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:4986
source.h
block_symbol_cache::symbols
struct symbol_cache_slot symbols[1]
Definition: symtab.c:195
fn_field::physname
const char * physname
Definition: gdbtypes.h:844
overlay_unmapped_address
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3107
demangled_name_entry::demangled
char demangled[1]
Definition: symtab.c:678
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
allocate_symbol
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:5757
cleanup_check.is_constructor
def is_constructor(decl)
Definition: cleanup_check.py:41
info_functions_command
static void info_functions_command(const char *regexp, int from_tty)
Definition: symtab.c:4616
ALL_PSPACES
#define ALL_PSPACES(pspace)
Definition: progspace.h:243
demangled_name_entry
Definition: symtab.c:675
lookup_global_symbol_from_objfile
struct block_symbol lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
Definition: symtab.c:2226
iterate_over_symtabs
void iterate_over_symtabs(const char *name, gdb::function_view< bool(symtab *)> callback)
Definition: symtab.c:462
gdb::optional< compiled_regex >
gdb::function_view
Definition: function-view.h:177
objfile_per_bfd_storage::name_of_main
const char * name_of_main
Definition: objfiles.h:229
lookup_symbol_global_iterator_cb
static int lookup_symbol_global_iterator_cb(struct objfile *objfile, void *cb_data)
Definition: symtab.c:2631
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
add_partial_filename_data::list
completion_list * list
Definition: symtab.c:5344
lookup_name_info::name
const std::string & name() const
Definition: symtab.h:196
block_symbol_cache::size
unsigned int size
Definition: symtab.c:193
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
make_completion_match_str
gdb::unique_xmalloc_ptr< char > make_completion_match_str(const char *match_name, const char *text, const char *word)
Definition: completer.c:1603
block_static_block
const struct block * block_static_block(const struct block *block)
Definition: block.c:364
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
general_symbol_info
Definition: symtab.h:376
d_demangle
char * d_demangle(const char *symbol, int options)
Definition: d-lang.c:53
d-lang.h
find_line_common
static int find_line_common(struct linetable *, int, int *, int)
Definition: symtab.c:3523
symbol_name_match_type::SEARCH_NAME
field_of_this_result::field
struct field * field
Definition: symtab.h:1540
get_main_info
static struct main_info * get_main_info(void)
Definition: symtab.c:5439
class_breakpoint
Definition: command.h:42
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
general_symbol_info::language
__extension__ enum language language
Definition: symtab.h:432
MSYMBOL_SECTION
#define MSYMBOL_SECTION(symbol)
Definition: symtab.h:699
block_gdbarch
struct gdbarch * block_gdbarch(const struct block *block)
Definition: block.c:60
symbol_cache_slot::not_found
struct symbol_cache_slot::@169::@170 not_found
lookup_static_symbol
struct block_symbol lookup_static_symbol(const char *name, const domain_enum domain)
Definition: symtab.c:2574
go-lang.h
symbol_cache_mark_not_found
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:1397
symbol_cache_slot::state
enum symbol_cache_slot_state state
Definition: symtab.c:149
cp_remove_params_if_any
gdb::unique_xmalloc_ptr< char > cp_remove_params_if_any(const char *demangled_name, bool completion_mode)
Definition: cp-support.c:900
obj_section_addr
#define obj_section_addr(s)
Definition: objfiles.h:140
symbol
const char * symbol
Definition: signals.c:48
search_name_hash
unsigned int search_name_hash(enum language language, const char *search_name)
Definition: symtab.c:1859
symtab_and_line::pspace
struct program_space * pspace
Definition: symtab.h:1749
objfile_separate_debug_iterate
struct objfile * objfile_separate_debug_iterate(const struct objfile *parent, const struct objfile *objfile)
Definition: objfiles.c:488
_initialize_symtab
void _initialize_symtab(void)
Definition: symtab.c:5821
SYMBOL_SLOT_UNUSED
Definition: symtab.c:142
symbol_cache_size
static unsigned int symbol_cache_size
Definition: symtab.c:226
offset
int offset
Definition: agent.c:65
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
language_go
Definition: defs.h:211
new_symbol_cache_size
static unsigned int new_symbol_cache_size
Definition: symtab.c:221
macro_scope::line
int line
Definition: macroscope.h:35
symbol_search::symbol
struct symbol * symbol
Definition: symtab.h:1954
objfile_debug_name
const char * objfile_debug_name(const struct objfile *objfile)
Definition: objfiles.c:1579
code
int code
Definition: ser-unix.c:239
register_symbol_register_impl
int register_symbol_register_impl(enum address_class aclass, const struct symbol_register_ops *ops)
Definition: symtab.c:5707
info_types_command
static void info_types_command(const char *regexp, int from_tty)
Definition: symtab.c:4623
resize_symbol_cache
static void resize_symbol_cache(struct symbol_cache *cache, unsigned int new_size)
Definition: symtab.c:1171
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
symbol::ginfo
struct general_symbol_info ginfo
Definition: symtab.h:1054
general_symbol_info::ada_mangled
unsigned int ada_mangled
Definition: symtab.h:437
objfile_per_bfd_storage::language_of_main
enum language language_of_main
Definition: objfiles.h:230
msymbol_is_function
bool msymbol_is_function(struct objfile *objfile, minimal_symbol *minsym, CORE_ADDR *func_address_p)
Definition: minsyms.c:60
symbol_set_names
void symbol_set_names(struct general_symbol_info *gsymbol, const char *linkage_name, int len, int copy_name, struct objfile *objfile)
Definition: symtab.c:773
compunit_language
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:303
SYMBOL_LANGUAGE
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:469
lookup_symbol_in_block
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:2190
completion_tracker::add_completion
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:1550
COMPUNIT_FILETABS
#define COMPUNIT_FILETABS(cust)
Definition: symtab.h:1461
LOC_LABEL
Definition: symtab.h:848
cp_canonicalize_string
std::string cp_canonicalize_string(const char *string)
Definition: cp-support.c:552
SYMBOL_LOOKUP_FAILED
#define SYMBOL_LOOKUP_FAILED
Definition: symtab.c:133
mst_text
Definition: symtab.h:582
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
symbol_cache::global_symbols
struct block_symbol_cache * global_symbols
Definition: symtab.c:210
filename_seen_cache::seen
bool seen(const char *file)
Definition: filename-seen-cache.c:54
target.h
symbol_matches_domain
int symbol_matches_domain(enum language symbol_language, domain_enum symbol_domain, domain_enum domain)
Definition: symtab.c:2700
completion_match_result::match
completion_match match
Definition: completer.h:208
VAR_DOMAIN
Definition: symtab.h:739
break_command
void break_command(const char *arg, int from_tty)
Definition: breakpoint.c:9596
string_printf
std::string string_printf(const char *fmt,...)
Definition: common-utils.c:150
mst_solib_trampoline
Definition: symtab.h:597
value.h
gdb_filename_fnmatch
int gdb_filename_fnmatch(const char *pattern, const char *string, int flags)
Definition: utils.c:3321
have_full_symbols
int have_full_symbols(void)
Definition: objfiles.c:1040
block_iterator
Definition: block.h:197
language_objc
Definition: defs.h:208
solib_global_lookup
struct block_symbol solib_global_lookup(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solib.c:1466
COMPUNIT_LOCATIONS_VALID
#define COMPUNIT_LOCATIONS_VALID(cust)
Definition: symtab.h:1467
lookup_language_this
struct block_symbol lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1915
symbol_cache_clear_slot
static void symbol_cache_clear_slot(struct symbol_cache_slot *slot)
Definition: symtab.c:1360
completion_list_add_name
void 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:4717
symbol::arch
struct gdbarch * arch
Definition: symtab.h:1071
not_interesting_fname
static int not_interesting_fname(const char *fname)
Definition: symtab.c:5320
get_selected_block
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2216
fixup_section
void fixup_section(struct general_symbol_info *ginfo, CORE_ADDR addr, struct objfile *objfile)
Definition: symtab.c:1637
ada_decode_symbol
const char * ada_decode_symbol(const struct general_symbol_info *arg)
Definition: ada-lang.c:1430
SYMBOL_NATURAL_NAME
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:513
output_partial_symbol_filename
static void output_partial_symbol_filename(const char *filename, const char *fullname, void *data)
Definition: symtab.c:4155
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
symtab_create_debug
unsigned int symtab_create_debug
Definition: symtab.c:215
rbreak_command
static void rbreak_command(const char *, int)
Definition: symtab.c:4637
gdbtypes.h
d_main_name
const char * d_main_name(void)
Definition: d-lang.c:38
STATIC_BLOCK
Definition: defs.h:687
fn_field::is_volatile
unsigned int is_volatile
Definition: gdbtypes.h:862
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
field_name
static PyObject * field_name(struct type *type, int field)
Definition: py-type.c:267
SYMBOL_SEARCH_NAME
#define SYMBOL_SEARCH_NAME(symbol)
Definition: symtab.h:551
find_pc_sect_line
struct symtab_and_line find_pc_sect_line(CORE_ADDR pc, struct obj_section *section, int notcurrent)
Definition: symtab.c:3051
language
language
Definition: defs.h:203
macro_for_each_in_scope
void macro_for_each_in_scope(struct macro_source_file *file, int line, gdb::function_view< macro_callback_fn > fn)
Definition: macrotab.c:1030
cp_lookup_symbol_imports_or_template
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:503
info_variables_command
static void info_variables_command(const char *regexp, int from_tty)
Definition: symtab.c:4610
symtab_and_line::symbol
struct symbol * symbol
Definition: symtab.h:1752
find_main_name
static void find_main_name(void)
Definition: symtab.c:5497
lookup_objfile_from_block
struct objfile * lookup_objfile_from_block(const struct block *block)
Definition: symtab.c:2164
observer_attach_new_objfile
struct observer * observer_attach_new_objfile(observer_new_objfile_ftype *f)
field_of_this_result
Definition: symtab.h:1529
completion_tracker
Definition: completer.h:310
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
linetable::nitems
int nitems
Definition: symtab.h:1253
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
p-lang.h
symbol
Definition: symtab.h:1049
language_sniff_from_mangled_name
int language_sniff_from_mangled_name(const struct language_defn *lang, const char *mangled, char **demangled)
Definition: language.c:633
language_defn::la_macro_expansion
enum macro_expansion la_macro_expansion
Definition: language.h:157
language_search_unquoted_string
static const char * language_search_unquoted_string(const char *text, const char *p)
Definition: symtab.c:4852
maintenancelist
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:135
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
symbol_impl
Definition: symtab.h:1018
sort_search_symbols_remove_dups
static void sort_search_symbols_remove_dups(std::vector< symbol_search > *result)
Definition: symtab.c:4247
completion_list_add_symbol
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:4757
objc-lang.h
language_rust
Definition: defs.h:217
gdbarch_skip_entrypoint_p
int gdbarch_skip_entrypoint_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2803
overlay_mapped_address
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3125
ALL_COMPUNIT_FILETABS
#define ALL_COMPUNIT_FILETABS(cu, s)
Definition: symtab.h:1474
add_symtab_completions
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:4950
symtab_and_line::line
int line
Definition: symtab.h:1757
gdbarch_skip_main_prologue
CORE_ADDR gdbarch_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2786
TYPE_FN_FIELDLIST_NAME
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:1415
OBSTACK_ZALLOC
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
Definition: gdb_obstack.h:27
type_name_no_tag
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1466
global_sym_lookup_data::domain
domain_enum domain
Definition: symtab.c:2618
iterate_over_symbols
void 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:2849
minimal_symbol
Definition: symtab.h:623
lookup_symbol_in_static_block
struct block_symbol lookup_symbol_in_static_block(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2487
matching_obj_sections
int matching_obj_sections(struct obj_section *obj_first, struct obj_section *obj_second)
Definition: symtab.c:969
objfile_per_bfd_storage::storage_obstack
auto_obstack storage_obstack
Definition: objfiles.h:195
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
SYMBOL_SECTION
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:470
gdbarch_skip_entrypoint
CORE_ADDR gdbarch_skip_entrypoint(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition: gdbarch.c:2810
add_filename_to_list
static void add_filename_to_list(const char *fname, const char *text, const char *word, completion_list *list)
Definition: symtab.c:5313
symtab::fullname
char * fullname
Definition: symtab.h:1328
class_maintenance
Definition: command.h:43
ALL_BLOCK_SYMBOLS_WITH_NAME
#define ALL_BLOCK_SYMBOLS_WITH_NAME(block, name, iter, sym)
Definition: block.h:320
symbol_cache_key
static const struct program_space_data * symbol_cache_key
Definition: symtab.c:117
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
symbol_computed_ops::get_symbol_read_needs
enum symbol_needs_kind(* get_symbol_read_needs)(struct symbol *symbol)
Definition: symtab.h:939
language_defn::la_search_name_hash
unsigned int(* la_search_name_hash)(const char *name)
Definition: language.h:396
mst_file_bss
Definition: symtab.h:602
linetable_entry::line
int line
Definition: symtab.h:1230
objfile::objfile_obstack
Definition: objfiles.h:357
completion_tracker::reset_completion_match_result
completion_match_result & reset_completion_match_result()
Definition: completer.h:380
minimal_symbol_type
minimal_symbol_type
Definition: symtab.h:579
language_unknown
Definition: defs.h:205
ALL_OBJFILES
#define ALL_OBJFILES(obj)
Definition: objfiles.h:582
QUIT
#define QUIT
Definition: defs.h:179
find_pc_line_symtab
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition: symtab.c:3301
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
sym_fns::qf
const struct quick_symbol_functions * qf
Definition: symfile.h:369
switch_to_program_space_and_thread
void switch_to_program_space_and_thread(program_space *pspace)
Definition: progspace-and-thread.c:24
symbol_impl::ops_computed
const struct symbol_computed_ops * ops_computed
Definition: symtab.h:1023
symbol_cache_mark_found
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:1373
symbol_name_match_type::FULL
TYPE_CODE_METHOD
Definition: gdbtypes.h:141
filename_seen_cache::clear
void clear()
Definition: filename-seen-cache.c:39
global_sym_lookup_data
Definition: symtab.c:2612
block_lookup_symbol
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:675
xcalloc
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:72
gdbarch_skip_prologue_noexcept
CORE_ADDR gdbarch_skip_prologue_noexcept(gdbarch *gdbarch, CORE_ADDR pc) noexcept
Definition: arch-utils.c:964
symbol_symtab
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:5803
lookup_name_info
Definition: symtab.h:179
class_obscure
Definition: command.h:43
pc_in_unmapped_range
CORE_ADDR pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3053
maintenance_show_cmdlist
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:635
basic_lookup_transparent_type_1
static struct type * basic_lookup_transparent_type_1(struct objfile *objfile, int block_index, const char *name)
Definition: symtab.c:2761
output_source_filename_data
Definition: symtab.c:4110
lookup_symbol_in_language
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:1877
gdbcmd.h
SYMTAB_LINETABLE
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:1332
block_symbol_cache::hits
unsigned int hits
Definition: symtab.c:185
case_sensitivity
case_sensitivity
Definition: language.h:90
symbol_computed_ops
Definition: symtab.h:916
find_line_symtab
struct symtab * find_line_symtab(struct symtab *symtab, int line, int *index, int *exact_match)
Definition: symtab.c:3322
completion_list_add_msymbol
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:4770
main_info::language_of_main
enum language language_of_main
Definition: symtab.c:112
multiple_symbols_all
const char multiple_symbols_all[]
Definition: symtab.c:238
language_cplus
Definition: defs.h:209
error
void error(const char *fmt,...)
Definition: errors.c:38
case_sensitive_off
Definition: language.h:92
size
size_t size
Definition: go32-nat.c:242
language_c
Definition: defs.h:207
lookup_local_symbol
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)
block_scope
const char * block_scope(const struct block *block)
Definition: block.c:295
ALL_BLOCK_SYMBOLS
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:310
dictionary.h
TYPE_FN_FIELDLIST1
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition: gdbtypes.h:1414
block.h
symtab_and_line::explicit_pc
bool explicit_pc
Definition: symtab.h:1761
compare_symbol_name
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:4702
cp-abi.h
MSYMBOL_VALUE_ADDRESS
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:687
go_demangle
char * go_demangle(const char *mangled_name, int options)
Definition: go-lang.c:336
MAX_SYMBOL_CACHE_SIZE
#define MAX_SYMBOL_CACHE_SIZE
Definition: symtab.c:129
symbol_cache_slot
Definition: symtab.c:147
program_space
Definition: progspace.h:137
mst_file_text
Definition: symtab.h:600
find_pc_line_pc_range
int find_pc_line_pc_range(CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3567
symfile.h
copy_name
char * copy_name(struct stoken token)
Definition: parse.c:761
maintenance_print_symbol_cache
static void maintenance_print_symbol_cache(const char *args, int from_tty)
Definition: symtab.c:1520
symbol_name_match_type
symbol_name_match_type
Definition: symtab.h:52
symbol_cache_slot::domain
domain_enum domain
Definition: symtab.c:175
general_symbol_info::demangled_name
const char * demangled_name
Definition: symtab.h:424
symbol::domain
__extension__ enum domain_enum_tag domain
Definition: symtab.h:1076
symbol_cache_lookup
static struct block_symbol symbol_cache_lookup(struct symbol_cache *cache, struct objfile *objfile_context, int block, const char *name, domain_enum domain, struct block_symbol_cache **bsc_ptr, struct symbol_cache_slot **slot_ptr)
Definition: symtab.c:1302
SYMBOL_SLOT_FOUND
Definition: symtab.c:144
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
symbol_cache_byte_size
static size_t symbol_cache_byte_size(unsigned int size)
Definition: symtab.c:1162
hash_symbol_entry
static unsigned int hash_symbol_entry(const struct objfile *objfile_context, const char *name, domain_enum domain)
Definition: symtab.c:1064
compiled_regex::exec
int exec(const char *string, size_t nmatch, regmatch_t pmatch[], int eflags) const
Definition: gdb_regex.c:45