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