* MAINTAINERS: Add myself as Meta maintainer.
[deliverable/binutils-gdb.git] / gdb / symtab.c
CommitLineData
c906108c 1/* Symbol table lookup for the GNU debugger, GDB.
8926118c 2
28e7fd62 3 Copyright (C) 1986-2013 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"
c906108c 44
2de7ced7
DJ
45#include "hashtab.h"
46
04ea0df1 47#include "gdb_obstack.h"
fe898f56 48#include "block.h"
de4f826b 49#include "dictionary.h"
c906108c
SS
50
51#include <sys/types.h>
52#include <fcntl.h>
53#include "gdb_string.h"
54#include "gdb_stat.h"
55#include <ctype.h>
015a42b4 56#include "cp-abi.h"
71c25dea 57#include "cp-support.h"
ea53e89f 58#include "observer.h"
94277a38 59#include "gdb_assert.h"
3a40aaa0 60#include "solist.h"
9a044a89
TT
61#include "macrotab.h"
62#include "macroscope.h"
c906108c 63
ccefe4c4 64#include "psymtab.h"
270140bd 65#include "parser-defs.h"
ccefe4c4 66
c906108c
SS
67/* Prototypes for local functions */
68
a14ed312 69static void rbreak_command (char *, int);
c906108c 70
a14ed312 71static void types_info (char *, int);
c906108c 72
a14ed312 73static void functions_info (char *, int);
c906108c 74
a14ed312 75static void variables_info (char *, int);
c906108c 76
a14ed312 77static void sources_info (char *, int);
c906108c 78
f8eba3c6 79static int find_line_common (struct linetable *, int, int *, int);
c906108c 80
3121eff0 81static struct symbol *lookup_symbol_aux (const char *name,
3121eff0 82 const struct block *block,
176620f1 83 const domain_enum domain,
53c5240f 84 enum language language,
1993b719 85 struct field_of_this_result *is_a_field_of_this);
fba7f19c 86
e4051eeb
DC
87static
88struct symbol *lookup_symbol_aux_local (const char *name,
e4051eeb 89 const struct block *block,
13387711
SW
90 const domain_enum domain,
91 enum language language);
8155455b
DC
92
93static
94struct symbol *lookup_symbol_aux_symtabs (int block_index,
95 const char *name,
67ff19f7 96 const domain_enum domain);
8155455b
DC
97
98static
ccefe4c4
TT
99struct symbol *lookup_symbol_aux_quick (struct objfile *objfile,
100 int block_index,
101 const char *name,
102 const domain_enum domain);
c906108c 103
a14ed312 104static void print_msymbol_info (struct minimal_symbol *);
c906108c 105
a14ed312 106void _initialize_symtab (void);
c906108c
SS
107
108/* */
109
45cfd468
DE
110/* When non-zero, print debugging messages related to symtab creation. */
111int symtab_create_debug = 0;
112
c011a4f4
DE
113/* Non-zero if a file may be known by two different basenames.
114 This is the uncommon case, and significantly slows down gdb.
115 Default set to "off" to not slow down the common case. */
116int basenames_may_differ = 0;
117
717d2f5a
JB
118/* Allow the user to configure the debugger behavior with respect
119 to multiple-choice menus when more than one symbol matches during
120 a symbol lookup. */
121
7fc830e2
MK
122const char multiple_symbols_ask[] = "ask";
123const char multiple_symbols_all[] = "all";
124const char multiple_symbols_cancel[] = "cancel";
40478521 125static const char *const multiple_symbols_modes[] =
717d2f5a
JB
126{
127 multiple_symbols_ask,
128 multiple_symbols_all,
129 multiple_symbols_cancel,
130 NULL
131};
132static const char *multiple_symbols_mode = multiple_symbols_all;
133
134/* Read-only accessor to AUTO_SELECT_MODE. */
135
136const char *
137multiple_symbols_select_mode (void)
138{
139 return multiple_symbols_mode;
140}
141
c906108c 142/* Block in which the most recently searched-for symbol was found.
9af17804 143 Might be better to make this a parameter to lookup_symbol and
c378eb4e 144 value_of_this. */
c906108c
SS
145
146const struct block *block_found;
147
4aac40c8
TT
148/* See whether FILENAME matches SEARCH_NAME using the rule that we
149 advertise to the user. (The manual's description of linespecs
af529f8f
JK
150 describes what we advertise). Returns true if they match, false
151 otherwise. */
4aac40c8
TT
152
153int
b57a636e 154compare_filenames_for_search (const char *filename, const char *search_name)
4aac40c8
TT
155{
156 int len = strlen (filename);
b57a636e 157 size_t search_len = strlen (search_name);
4aac40c8
TT
158
159 if (len < search_len)
160 return 0;
161
162 /* The tail of FILENAME must match. */
163 if (FILENAME_CMP (filename + len - search_len, search_name) != 0)
164 return 0;
165
166 /* Either the names must completely match, or the character
167 preceding the trailing SEARCH_NAME segment of FILENAME must be a
d84fca2c
JK
168 directory separator.
169
af529f8f
JK
170 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
171 cannot match FILENAME "/path//dir/file.c" - as user has requested
172 absolute path. The sama applies for "c:\file.c" possibly
173 incorrectly hypothetically matching "d:\dir\c:\file.c".
174
d84fca2c
JK
175 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
176 compatible with SEARCH_NAME "file.c". In such case a compiler had
177 to put the "c:file.c" name into debug info. Such compatibility
178 works only on GDB built for DOS host. */
4aac40c8 179 return (len == search_len
af529f8f
JK
180 || (!IS_ABSOLUTE_PATH (search_name)
181 && IS_DIR_SEPARATOR (filename[len - search_len - 1]))
4aac40c8
TT
182 || (HAS_DRIVE_SPEC (filename)
183 && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
184}
185
f8eba3c6
TT
186/* Check for a symtab of a specific name by searching some symtabs.
187 This is a helper function for callbacks of iterate_over_symtabs.
c906108c 188
f5b95b50 189 The return value, NAME, REAL_PATH, CALLBACK, and DATA
f8eba3c6
TT
190 are identical to the `map_symtabs_matching_filename' method of
191 quick_symbol_functions.
192
193 FIRST and AFTER_LAST indicate the range of symtabs to search.
194 AFTER_LAST is one past the last symtab to search; NULL means to
195 search until the end of the list. */
196
197int
198iterate_over_some_symtabs (const char *name,
f8eba3c6
TT
199 const char *real_path,
200 int (*callback) (struct symtab *symtab,
201 void *data),
202 void *data,
203 struct symtab *first,
204 struct symtab *after_last)
c906108c 205{
ccefe4c4 206 struct symtab *s = NULL;
c011a4f4 207 const char* base_name = lbasename (name);
1f84b619 208
f8eba3c6 209 for (s = first; s != NULL && s != after_last; s = s->next)
f079a2e5 210 {
af529f8f 211 if (compare_filenames_for_search (s->filename, name))
4aac40c8
TT
212 {
213 if (callback (s, data))
214 return 1;
288e77a7 215 continue;
4aac40c8
TT
216 }
217
c011a4f4
DE
218 /* Before we invoke realpath, which can get expensive when many
219 files are involved, do a quick comparison of the basenames. */
220 if (! basenames_may_differ
221 && FILENAME_CMP (base_name, lbasename (s->filename)) != 0)
222 continue;
223
05cba821
JK
224 if (compare_filenames_for_search (symtab_to_fullname (s), name))
225 {
226 if (callback (s, data))
227 return 1;
288e77a7 228 continue;
05cba821
JK
229 }
230
58d370e0
TT
231 /* If the user gave us an absolute path, try to find the file in
232 this symtab and use its absolute path. */
9af17804 233
58d370e0
TT
234 if (real_path != NULL)
235 {
0b0865da 236 const char *fullname = symtab_to_fullname (s);
433759f7 237
af529f8f
JK
238 gdb_assert (IS_ABSOLUTE_PATH (real_path));
239 gdb_assert (IS_ABSOLUTE_PATH (name));
f5b95b50 240 if (FILENAME_CMP (real_path, fullname) == 0)
f35a17b5
JK
241 {
242 if (callback (s, data))
f5b95b50 243 return 1;
288e77a7 244 continue;
f35a17b5 245 }
58d370e0 246 }
f8eba3c6 247 }
58d370e0 248
f8eba3c6
TT
249 return 0;
250}
251
252/* Check for a symtab of a specific name; first in symtabs, then in
253 psymtabs. *If* there is no '/' in the name, a match after a '/'
254 in the symtab filename will also work.
255
256 Calls CALLBACK with each symtab that is found and with the supplied
257 DATA. If CALLBACK returns true, the search stops. */
258
259void
260iterate_over_symtabs (const char *name,
261 int (*callback) (struct symtab *symtab,
262 void *data),
263 void *data)
264{
f8eba3c6
TT
265 struct objfile *objfile;
266 char *real_path = NULL;
f8eba3c6
TT
267 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
268
269 /* Here we are interested in canonicalizing an absolute path, not
270 absolutizing a relative path. */
271 if (IS_ABSOLUTE_PATH (name))
272 {
f8eba3c6
TT
273 real_path = gdb_realpath (name);
274 make_cleanup (xfree, real_path);
af529f8f 275 gdb_assert (IS_ABSOLUTE_PATH (real_path));
f8eba3c6
TT
276 }
277
278 ALL_OBJFILES (objfile)
279 {
f5b95b50 280 if (iterate_over_some_symtabs (name, real_path, callback, data,
f8eba3c6
TT
281 objfile->symtabs, NULL))
282 {
283 do_cleanups (cleanups);
284 return;
285 }
286 }
287
c906108c
SS
288 /* Same search rules as above apply here, but now we look thru the
289 psymtabs. */
290
ccefe4c4
TT
291 ALL_OBJFILES (objfile)
292 {
293 if (objfile->sf
f8eba3c6
TT
294 && objfile->sf->qf->map_symtabs_matching_filename (objfile,
295 name,
f8eba3c6
TT
296 real_path,
297 callback,
298 data))
ccefe4c4 299 {
f8eba3c6
TT
300 do_cleanups (cleanups);
301 return;
ccefe4c4
TT
302 }
303 }
c906108c 304
f8eba3c6
TT
305 do_cleanups (cleanups);
306}
307
308/* The callback function used by lookup_symtab. */
309
310static int
311lookup_symtab_callback (struct symtab *symtab, void *data)
312{
313 struct symtab **result_ptr = data;
c906108c 314
f8eba3c6
TT
315 *result_ptr = symtab;
316 return 1;
c906108c 317}
f8eba3c6
TT
318
319/* A wrapper for iterate_over_symtabs that returns the first matching
320 symtab, or NULL. */
321
322struct symtab *
323lookup_symtab (const char *name)
324{
325 struct symtab *result = NULL;
326
327 iterate_over_symtabs (name, lookup_symtab_callback, &result);
328 return result;
329}
330
c906108c
SS
331\f
332/* Mangle a GDB method stub type. This actually reassembles the pieces of the
333 full method name, which consist of the class name (from T), the unadorned
334 method name from METHOD_ID, and the signature for the specific overload,
c378eb4e 335 specified by SIGNATURE_ID. Note that this function is g++ specific. */
c906108c
SS
336
337char *
fba45db2 338gdb_mangle_name (struct type *type, int method_id, int signature_id)
c906108c
SS
339{
340 int mangled_name_len;
341 char *mangled_name;
342 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
343 struct fn_field *method = &f[signature_id];
0d5cff50 344 const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
1d06ead6 345 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
0d5cff50 346 const char *newname = type_name_no_tag (type);
c906108c
SS
347
348 /* Does the form of physname indicate that it is the full mangled name
349 of a constructor (not just the args)? */
350 int is_full_physname_constructor;
351
352 int is_constructor;
015a42b4 353 int is_destructor = is_destructor_name (physname);
c906108c
SS
354 /* Need a new type prefix. */
355 char *const_prefix = method->is_const ? "C" : "";
356 char *volatile_prefix = method->is_volatile ? "V" : "";
357 char buf[20];
358 int len = (newname == NULL ? 0 : strlen (newname));
359
43630227
PS
360 /* Nothing to do if physname already contains a fully mangled v3 abi name
361 or an operator name. */
362 if ((physname[0] == '_' && physname[1] == 'Z')
363 || is_operator_name (field_name))
235d1e03
EZ
364 return xstrdup (physname);
365
015a42b4 366 is_full_physname_constructor = is_constructor_name (physname);
c906108c 367
3e43a32a
MS
368 is_constructor = is_full_physname_constructor
369 || (newname && strcmp (field_name, newname) == 0);
c906108c
SS
370
371 if (!is_destructor)
c5aa993b 372 is_destructor = (strncmp (physname, "__dt", 4) == 0);
c906108c
SS
373
374 if (is_destructor || is_full_physname_constructor)
375 {
c5aa993b
JM
376 mangled_name = (char *) xmalloc (strlen (physname) + 1);
377 strcpy (mangled_name, physname);
c906108c
SS
378 return mangled_name;
379 }
380
381 if (len == 0)
382 {
8c042590 383 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
c906108c
SS
384 }
385 else if (physname[0] == 't' || physname[0] == 'Q')
386 {
387 /* The physname for template and qualified methods already includes
c5aa993b 388 the class name. */
8c042590 389 xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix);
c906108c
SS
390 newname = NULL;
391 len = 0;
392 }
393 else
394 {
8c042590
PM
395 xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix,
396 volatile_prefix, len);
c906108c
SS
397 }
398 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
235d1e03 399 + strlen (buf) + len + strlen (physname) + 1);
c906108c 400
433759f7
MS
401 mangled_name = (char *) xmalloc (mangled_name_len);
402 if (is_constructor)
403 mangled_name[0] = '\0';
404 else
405 strcpy (mangled_name, field_name);
406
c906108c
SS
407 strcat (mangled_name, buf);
408 /* If the class doesn't have a name, i.e. newname NULL, then we just
409 mangle it using 0 for the length of the class. Thus it gets mangled
c378eb4e 410 as something starting with `::' rather than `classname::'. */
c906108c
SS
411 if (newname != NULL)
412 strcat (mangled_name, newname);
413
414 strcat (mangled_name, physname);
415 return (mangled_name);
416}
12af6855 417
29df156d
SW
418/* Initialize the cplus_specific structure. 'cplus_specific' should
419 only be allocated for use with cplus symbols. */
420
421static void
422symbol_init_cplus_specific (struct general_symbol_info *gsymbol,
423 struct objfile *objfile)
424{
425 /* A language_specific structure should not have been previously
426 initialized. */
427 gdb_assert (gsymbol->language_specific.cplus_specific == NULL);
428 gdb_assert (objfile != NULL);
429
430 gsymbol->language_specific.cplus_specific =
431 OBSTACK_ZALLOC (&objfile->objfile_obstack, struct cplus_specific);
432}
433
b250c185 434/* Set the demangled name of GSYMBOL to NAME. NAME must be already
29df156d 435 correctly allocated. For C++ symbols a cplus_specific struct is
c378eb4e 436 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
29df156d 437 OBJFILE can be NULL. */
eca864fe 438
b250c185
SW
439void
440symbol_set_demangled_name (struct general_symbol_info *gsymbol,
cfc594ee 441 const char *name,
29df156d 442 struct objfile *objfile)
b250c185 443{
29df156d
SW
444 if (gsymbol->language == language_cplus)
445 {
446 if (gsymbol->language_specific.cplus_specific == NULL)
447 symbol_init_cplus_specific (gsymbol, objfile);
448
449 gsymbol->language_specific.cplus_specific->demangled_name = name;
450 }
451 else
452 gsymbol->language_specific.mangled_lang.demangled_name = name;
b250c185
SW
453}
454
455/* Return the demangled name of GSYMBOL. */
eca864fe 456
0d5cff50 457const char *
b250c185
SW
458symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
459{
29df156d
SW
460 if (gsymbol->language == language_cplus)
461 {
45c58896
SW
462 if (gsymbol->language_specific.cplus_specific != NULL)
463 return gsymbol->language_specific.cplus_specific->demangled_name;
464 else
465 return NULL;
29df156d
SW
466 }
467 else
468 return gsymbol->language_specific.mangled_lang.demangled_name;
b250c185
SW
469}
470
12af6855 471\f
89aad1f9 472/* Initialize the language dependent portion of a symbol
c378eb4e 473 depending upon the language for the symbol. */
eca864fe 474
89aad1f9 475void
33e5013e
SW
476symbol_set_language (struct general_symbol_info *gsymbol,
477 enum language language)
89aad1f9
EZ
478{
479 gsymbol->language = language;
33e5013e 480 if (gsymbol->language == language_d
a766d390 481 || gsymbol->language == language_go
5784d15e 482 || gsymbol->language == language_java
f55ee35c
JK
483 || gsymbol->language == language_objc
484 || gsymbol->language == language_fortran)
89aad1f9 485 {
29df156d 486 symbol_set_demangled_name (gsymbol, NULL, NULL);
89aad1f9 487 }
29df156d
SW
488 else if (gsymbol->language == language_cplus)
489 gsymbol->language_specific.cplus_specific = NULL;
89aad1f9
EZ
490 else
491 {
492 memset (&gsymbol->language_specific, 0,
493 sizeof (gsymbol->language_specific));
494 }
495}
496
2de7ced7
DJ
497/* Functions to initialize a symbol's mangled name. */
498
04a679b8
TT
499/* Objects of this type are stored in the demangled name hash table. */
500struct demangled_name_entry
501{
9d2ceabe 502 const char *mangled;
04a679b8
TT
503 char demangled[1];
504};
505
506/* Hash function for the demangled name hash. */
eca864fe 507
04a679b8
TT
508static hashval_t
509hash_demangled_name_entry (const void *data)
510{
511 const struct demangled_name_entry *e = data;
433759f7 512
04a679b8
TT
513 return htab_hash_string (e->mangled);
514}
515
516/* Equality function for the demangled name hash. */
eca864fe 517
04a679b8
TT
518static int
519eq_demangled_name_entry (const void *a, const void *b)
520{
521 const struct demangled_name_entry *da = a;
522 const struct demangled_name_entry *db = b;
433759f7 523
04a679b8
TT
524 return strcmp (da->mangled, db->mangled) == 0;
525}
526
2de7ced7
DJ
527/* Create the hash table used for demangled names. Each hash entry is
528 a pair of strings; one for the mangled name and one for the demangled
529 name. The entry is hashed via just the mangled name. */
530
531static void
532create_demangled_names_hash (struct objfile *objfile)
533{
534 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
9af17804 535 The hash table code will round this up to the next prime number.
2de7ced7
DJ
536 Choosing a much larger table size wastes memory, and saves only about
537 1% in symbol reading. */
538
aa2ee5f6 539 objfile->demangled_names_hash = htab_create_alloc
04a679b8 540 (256, hash_demangled_name_entry, eq_demangled_name_entry,
aa2ee5f6 541 NULL, xcalloc, xfree);
2de7ced7 542}
12af6855 543
2de7ced7 544/* Try to determine the demangled name for a symbol, based on the
12af6855
JB
545 language of that symbol. If the language is set to language_auto,
546 it will attempt to find any demangling algorithm that works and
2de7ced7
DJ
547 then set the language appropriately. The returned name is allocated
548 by the demangler and should be xfree'd. */
12af6855 549
2de7ced7
DJ
550static char *
551symbol_find_demangled_name (struct general_symbol_info *gsymbol,
552 const char *mangled)
12af6855 553{
12af6855
JB
554 char *demangled = NULL;
555
556 if (gsymbol->language == language_unknown)
557 gsymbol->language = language_auto;
1bae87b9
AF
558
559 if (gsymbol->language == language_objc
560 || gsymbol->language == language_auto)
561 {
562 demangled =
563 objc_demangle (mangled, 0);
564 if (demangled != NULL)
565 {
566 gsymbol->language = language_objc;
567 return demangled;
568 }
569 }
12af6855
JB
570 if (gsymbol->language == language_cplus
571 || gsymbol->language == language_auto)
572 {
573 demangled =
3f542ed1 574 cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
12af6855 575 if (demangled != NULL)
2de7ced7
DJ
576 {
577 gsymbol->language = language_cplus;
578 return demangled;
579 }
12af6855
JB
580 }
581 if (gsymbol->language == language_java)
582 {
583 demangled =
2de7ced7 584 cplus_demangle (mangled,
12af6855
JB
585 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
586 if (demangled != NULL)
2de7ced7
DJ
587 {
588 gsymbol->language = language_java;
589 return demangled;
590 }
591 }
6aecb9c2
JB
592 if (gsymbol->language == language_d
593 || gsymbol->language == language_auto)
594 {
595 demangled = d_demangle(mangled, 0);
596 if (demangled != NULL)
597 {
598 gsymbol->language = language_d;
599 return demangled;
600 }
601 }
a766d390
DE
602 /* FIXME(dje): Continually adding languages here is clumsy.
603 Better to just call la_demangle if !auto, and if auto then call
604 a utility routine that tries successive languages in turn and reports
605 which one it finds. I realize the la_demangle options may be different
606 for different languages but there's already a FIXME for that. */
607 if (gsymbol->language == language_go
608 || gsymbol->language == language_auto)
609 {
610 demangled = go_demangle (mangled, 0);
611 if (demangled != NULL)
612 {
613 gsymbol->language = language_go;
614 return demangled;
615 }
616 }
617
f55ee35c
JK
618 /* We could support `gsymbol->language == language_fortran' here to provide
619 module namespaces also for inferiors with only minimal symbol table (ELF
620 symbols). Just the mangling standard is not standardized across compilers
621 and there is no DW_AT_producer available for inferiors with only the ELF
622 symbols to check the mangling kind. */
2de7ced7
DJ
623 return NULL;
624}
625
980cae7a 626/* Set both the mangled and demangled (if any) names for GSYMBOL based
04a679b8
TT
627 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
628 objfile's obstack; but if COPY_NAME is 0 and if NAME is
629 NUL-terminated, then this function assumes that NAME is already
630 correctly saved (either permanently or with a lifetime tied to the
631 objfile), and it will not be copied.
632
633 The hash table corresponding to OBJFILE is used, and the memory
634 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
635 so the pointer can be discarded after calling this function. */
2de7ced7 636
d2a52b27
DC
637/* We have to be careful when dealing with Java names: when we run
638 into a Java minimal symbol, we don't know it's a Java symbol, so it
639 gets demangled as a C++ name. This is unfortunate, but there's not
640 much we can do about it: but when demangling partial symbols and
641 regular symbols, we'd better not reuse the wrong demangled name.
642 (See PR gdb/1039.) We solve this by putting a distinctive prefix
643 on Java names when storing them in the hash table. */
644
645/* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
646 don't mind the Java prefix so much: different languages have
647 different demangling requirements, so it's only natural that we
648 need to keep language data around in our demangling cache. But
649 it's not good that the minimal symbol has the wrong demangled name.
650 Unfortunately, I can't think of any easy solution to that
651 problem. */
652
653#define JAVA_PREFIX "##JAVA$$"
654#define JAVA_PREFIX_LEN 8
655
2de7ced7
DJ
656void
657symbol_set_names (struct general_symbol_info *gsymbol,
04a679b8
TT
658 const char *linkage_name, int len, int copy_name,
659 struct objfile *objfile)
2de7ced7 660{
04a679b8 661 struct demangled_name_entry **slot;
980cae7a
DC
662 /* A 0-terminated copy of the linkage name. */
663 const char *linkage_name_copy;
d2a52b27
DC
664 /* A copy of the linkage name that might have a special Java prefix
665 added to it, for use when looking names up in the hash table. */
666 const char *lookup_name;
667 /* The length of lookup_name. */
668 int lookup_len;
04a679b8 669 struct demangled_name_entry entry;
2de7ced7 670
b06ead72
JB
671 if (gsymbol->language == language_ada)
672 {
673 /* In Ada, we do the symbol lookups using the mangled name, so
674 we can save some space by not storing the demangled name.
675
676 As a side note, we have also observed some overlap between
677 the C++ mangling and Ada mangling, similarly to what has
678 been observed with Java. Because we don't store the demangled
679 name with the symbol, we don't need to use the same trick
680 as Java. */
04a679b8 681 if (!copy_name)
0d5cff50 682 gsymbol->name = linkage_name;
04a679b8
TT
683 else
684 {
0d5cff50
DE
685 char *name = obstack_alloc (&objfile->objfile_obstack, len + 1);
686
687 memcpy (name, linkage_name, len);
688 name[len] = '\0';
689 gsymbol->name = name;
04a679b8 690 }
29df156d 691 symbol_set_demangled_name (gsymbol, NULL, NULL);
b06ead72
JB
692
693 return;
694 }
695
04a679b8
TT
696 if (objfile->demangled_names_hash == NULL)
697 create_demangled_names_hash (objfile);
698
980cae7a
DC
699 /* The stabs reader generally provides names that are not
700 NUL-terminated; most of the other readers don't do this, so we
d2a52b27
DC
701 can just use the given copy, unless we're in the Java case. */
702 if (gsymbol->language == language_java)
703 {
704 char *alloc_name;
d2a52b27 705
433759f7 706 lookup_len = len + JAVA_PREFIX_LEN;
d2a52b27
DC
707 alloc_name = alloca (lookup_len + 1);
708 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
709 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
710 alloc_name[lookup_len] = '\0';
711
712 lookup_name = alloc_name;
713 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
714 }
715 else if (linkage_name[len] != '\0')
2de7ced7 716 {
980cae7a
DC
717 char *alloc_name;
718
433759f7 719 lookup_len = len;
d2a52b27 720 alloc_name = alloca (lookup_len + 1);
980cae7a 721 memcpy (alloc_name, linkage_name, len);
d2a52b27 722 alloc_name[lookup_len] = '\0';
980cae7a 723
d2a52b27 724 lookup_name = alloc_name;
980cae7a 725 linkage_name_copy = alloc_name;
2de7ced7
DJ
726 }
727 else
980cae7a 728 {
d2a52b27
DC
729 lookup_len = len;
730 lookup_name = linkage_name;
980cae7a
DC
731 linkage_name_copy = linkage_name;
732 }
2de7ced7 733
9d2ceabe 734 entry.mangled = lookup_name;
04a679b8
TT
735 slot = ((struct demangled_name_entry **)
736 htab_find_slot (objfile->demangled_names_hash,
737 &entry, INSERT));
2de7ced7
DJ
738
739 /* If this name is not in the hash table, add it. */
a766d390
DE
740 if (*slot == NULL
741 /* A C version of the symbol may have already snuck into the table.
742 This happens to, e.g., main.init (__go_init_main). Cope. */
743 || (gsymbol->language == language_go
744 && (*slot)->demangled[0] == '\0'))
2de7ced7 745 {
980cae7a
DC
746 char *demangled_name = symbol_find_demangled_name (gsymbol,
747 linkage_name_copy);
2de7ced7
DJ
748 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
749
04a679b8
TT
750 /* Suppose we have demangled_name==NULL, copy_name==0, and
751 lookup_name==linkage_name. In this case, we already have the
752 mangled name saved, and we don't have a demangled name. So,
753 you might think we could save a little space by not recording
754 this in the hash table at all.
755
756 It turns out that it is actually important to still save such
757 an entry in the hash table, because storing this name gives
705b5767 758 us better bcache hit rates for partial symbols. */
04a679b8
TT
759 if (!copy_name && lookup_name == linkage_name)
760 {
761 *slot = obstack_alloc (&objfile->objfile_obstack,
762 offsetof (struct demangled_name_entry,
763 demangled)
764 + demangled_len + 1);
9d2ceabe 765 (*slot)->mangled = lookup_name;
04a679b8
TT
766 }
767 else
768 {
9d2ceabe
TT
769 char *mangled_ptr;
770
04a679b8
TT
771 /* If we must copy the mangled name, put it directly after
772 the demangled name so we can have a single
773 allocation. */
774 *slot = obstack_alloc (&objfile->objfile_obstack,
775 offsetof (struct demangled_name_entry,
776 demangled)
777 + lookup_len + demangled_len + 2);
9d2ceabe
TT
778 mangled_ptr = &((*slot)->demangled[demangled_len + 1]);
779 strcpy (mangled_ptr, lookup_name);
780 (*slot)->mangled = mangled_ptr;
04a679b8
TT
781 }
782
980cae7a 783 if (demangled_name != NULL)
2de7ced7 784 {
04a679b8 785 strcpy ((*slot)->demangled, demangled_name);
2de7ced7
DJ
786 xfree (demangled_name);
787 }
788 else
04a679b8 789 (*slot)->demangled[0] = '\0';
2de7ced7
DJ
790 }
791
72dcaf82 792 gsymbol->name = (*slot)->mangled + lookup_len - len;
04a679b8 793 if ((*slot)->demangled[0] != '\0')
29df156d 794 symbol_set_demangled_name (gsymbol, (*slot)->demangled, objfile);
2de7ced7 795 else
29df156d 796 symbol_set_demangled_name (gsymbol, NULL, objfile);
2de7ced7
DJ
797}
798
22abf04a
DC
799/* Return the source code name of a symbol. In languages where
800 demangling is necessary, this is the demangled name. */
801
0d5cff50 802const char *
22abf04a
DC
803symbol_natural_name (const struct general_symbol_info *gsymbol)
804{
9af17804 805 switch (gsymbol->language)
22abf04a 806 {
1f8173e6 807 case language_cplus:
6aecb9c2 808 case language_d:
a766d390 809 case language_go:
1f8173e6
PH
810 case language_java:
811 case language_objc:
f55ee35c 812 case language_fortran:
b250c185
SW
813 if (symbol_get_demangled_name (gsymbol) != NULL)
814 return symbol_get_demangled_name (gsymbol);
1f8173e6
PH
815 break;
816 case language_ada:
b250c185
SW
817 if (symbol_get_demangled_name (gsymbol) != NULL)
818 return symbol_get_demangled_name (gsymbol);
1f8173e6
PH
819 else
820 return ada_decode_symbol (gsymbol);
821 break;
822 default:
823 break;
22abf04a 824 }
1f8173e6 825 return gsymbol->name;
22abf04a
DC
826}
827
9cc0d196 828/* Return the demangled name for a symbol based on the language for
c378eb4e 829 that symbol. If no demangled name exists, return NULL. */
eca864fe 830
0d5cff50 831const char *
df8a16a1 832symbol_demangled_name (const struct general_symbol_info *gsymbol)
9cc0d196 833{
c6e5ee5e
SDJ
834 const char *dem_name = NULL;
835
9af17804 836 switch (gsymbol->language)
1f8173e6
PH
837 {
838 case language_cplus:
6aecb9c2 839 case language_d:
a766d390 840 case language_go:
1f8173e6
PH
841 case language_java:
842 case language_objc:
f55ee35c 843 case language_fortran:
c6e5ee5e 844 dem_name = symbol_get_demangled_name (gsymbol);
1f8173e6
PH
845 break;
846 case language_ada:
c6e5ee5e
SDJ
847 dem_name = symbol_get_demangled_name (gsymbol);
848 if (dem_name == NULL)
849 dem_name = ada_decode_symbol (gsymbol);
1f8173e6
PH
850 break;
851 default:
852 break;
853 }
c6e5ee5e 854 return dem_name;
9cc0d196 855}
fe39c653 856
4725b721
PH
857/* Return the search name of a symbol---generally the demangled or
858 linkage name of the symbol, depending on how it will be searched for.
9af17804 859 If there is no distinct demangled name, then returns the same value
c378eb4e 860 (same pointer) as SYMBOL_LINKAGE_NAME. */
eca864fe 861
0d5cff50 862const char *
fc062ac6
JB
863symbol_search_name (const struct general_symbol_info *gsymbol)
864{
1f8173e6
PH
865 if (gsymbol->language == language_ada)
866 return gsymbol->name;
867 else
868 return symbol_natural_name (gsymbol);
4725b721
PH
869}
870
fe39c653 871/* Initialize the structure fields to zero values. */
eca864fe 872
fe39c653
EZ
873void
874init_sal (struct symtab_and_line *sal)
875{
6c95b8df 876 sal->pspace = NULL;
fe39c653
EZ
877 sal->symtab = 0;
878 sal->section = 0;
879 sal->line = 0;
880 sal->pc = 0;
881 sal->end = 0;
ed0616c6
VP
882 sal->explicit_pc = 0;
883 sal->explicit_line = 0;
55aa24fb 884 sal->probe = NULL;
fe39c653 885}
c906108c
SS
886\f
887
94277a38
DJ
888/* Return 1 if the two sections are the same, or if they could
889 plausibly be copies of each other, one in an original object
890 file and another in a separated debug file. */
891
892int
714835d5
UW
893matching_obj_sections (struct obj_section *obj_first,
894 struct obj_section *obj_second)
94277a38 895{
714835d5
UW
896 asection *first = obj_first? obj_first->the_bfd_section : NULL;
897 asection *second = obj_second? obj_second->the_bfd_section : NULL;
94277a38
DJ
898 struct objfile *obj;
899
900 /* If they're the same section, then they match. */
901 if (first == second)
902 return 1;
903
904 /* If either is NULL, give up. */
905 if (first == NULL || second == NULL)
906 return 0;
907
908 /* This doesn't apply to absolute symbols. */
909 if (first->owner == NULL || second->owner == NULL)
910 return 0;
911
912 /* If they're in the same object file, they must be different sections. */
913 if (first->owner == second->owner)
914 return 0;
915
916 /* Check whether the two sections are potentially corresponding. They must
917 have the same size, address, and name. We can't compare section indexes,
918 which would be more reliable, because some sections may have been
919 stripped. */
920 if (bfd_get_section_size (first) != bfd_get_section_size (second))
921 return 0;
922
818f79f6 923 /* In-memory addresses may start at a different offset, relativize them. */
94277a38 924 if (bfd_get_section_vma (first->owner, first)
818f79f6
DJ
925 - bfd_get_start_address (first->owner)
926 != bfd_get_section_vma (second->owner, second)
927 - bfd_get_start_address (second->owner))
94277a38
DJ
928 return 0;
929
930 if (bfd_get_section_name (first->owner, first) == NULL
931 || bfd_get_section_name (second->owner, second) == NULL
932 || strcmp (bfd_get_section_name (first->owner, first),
933 bfd_get_section_name (second->owner, second)) != 0)
934 return 0;
935
936 /* Otherwise check that they are in corresponding objfiles. */
937
938 ALL_OBJFILES (obj)
939 if (obj->obfd == first->owner)
940 break;
941 gdb_assert (obj != NULL);
942
943 if (obj->separate_debug_objfile != NULL
944 && obj->separate_debug_objfile->obfd == second->owner)
945 return 1;
946 if (obj->separate_debug_objfile_backlink != NULL
947 && obj->separate_debug_objfile_backlink->obfd == second->owner)
948 return 1;
949
950 return 0;
951}
c5aa993b 952
ccefe4c4
TT
953struct symtab *
954find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
c906108c 955{
52f0bd74 956 struct objfile *objfile;
8a48e967
DJ
957 struct minimal_symbol *msymbol;
958
959 /* If we know that this is not a text address, return failure. This is
960 necessary because we loop based on texthigh and textlow, which do
961 not include the data ranges. */
962 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
963 if (msymbol
712f90be
TT
964 && (MSYMBOL_TYPE (msymbol) == mst_data
965 || MSYMBOL_TYPE (msymbol) == mst_bss
966 || MSYMBOL_TYPE (msymbol) == mst_abs
967 || MSYMBOL_TYPE (msymbol) == mst_file_data
968 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
8a48e967 969 return NULL;
c906108c 970
ff013f42 971 ALL_OBJFILES (objfile)
ccefe4c4
TT
972 {
973 struct symtab *result = NULL;
433759f7 974
ccefe4c4
TT
975 if (objfile->sf)
976 result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
977 pc, section, 0);
978 if (result)
979 return result;
980 }
ff013f42
JK
981
982 return NULL;
c906108c 983}
c906108c
SS
984\f
985/* Debug symbols usually don't have section information. We need to dig that
986 out of the minimal symbols and stash that in the debug symbol. */
987
ccefe4c4 988void
907fc202
UW
989fixup_section (struct general_symbol_info *ginfo,
990 CORE_ADDR addr, struct objfile *objfile)
c906108c
SS
991{
992 struct minimal_symbol *msym;
c906108c 993
bccdca4a
UW
994 /* First, check whether a minimal symbol with the same name exists
995 and points to the same address. The address check is required
996 e.g. on PowerPC64, where the minimal symbol for a function will
997 point to the function descriptor, while the debug symbol will
998 point to the actual function code. */
907fc202
UW
999 msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
1000 if (msym)
7a78d0ee 1001 {
714835d5 1002 ginfo->obj_section = SYMBOL_OBJ_SECTION (msym);
7a78d0ee
KB
1003 ginfo->section = SYMBOL_SECTION (msym);
1004 }
907fc202 1005 else
19e2d14b
KB
1006 {
1007 /* Static, function-local variables do appear in the linker
1008 (minimal) symbols, but are frequently given names that won't
1009 be found via lookup_minimal_symbol(). E.g., it has been
1010 observed in frv-uclinux (ELF) executables that a static,
1011 function-local variable named "foo" might appear in the
1012 linker symbols as "foo.6" or "foo.3". Thus, there is no
1013 point in attempting to extend the lookup-by-name mechanism to
1014 handle this case due to the fact that there can be multiple
1015 names.
9af17804 1016
19e2d14b
KB
1017 So, instead, search the section table when lookup by name has
1018 failed. The ``addr'' and ``endaddr'' fields may have already
1019 been relocated. If so, the relocation offset (i.e. the
1020 ANOFFSET value) needs to be subtracted from these values when
1021 performing the comparison. We unconditionally subtract it,
1022 because, when no relocation has been performed, the ANOFFSET
1023 value will simply be zero.
9af17804 1024
19e2d14b
KB
1025 The address of the symbol whose section we're fixing up HAS
1026 NOT BEEN adjusted (relocated) yet. It can't have been since
1027 the section isn't yet known and knowing the section is
1028 necessary in order to add the correct relocation value. In
1029 other words, we wouldn't even be in this function (attempting
1030 to compute the section) if it were already known.
1031
1032 Note that it is possible to search the minimal symbols
1033 (subtracting the relocation value if necessary) to find the
1034 matching minimal symbol, but this is overkill and much less
1035 efficient. It is not necessary to find the matching minimal
9af17804
DE
1036 symbol, only its section.
1037
19e2d14b
KB
1038 Note that this technique (of doing a section table search)
1039 can fail when unrelocated section addresses overlap. For
1040 this reason, we still attempt a lookup by name prior to doing
1041 a search of the section table. */
9af17804 1042
19e2d14b 1043 struct obj_section *s;
433759f7 1044
19e2d14b
KB
1045 ALL_OBJFILE_OSECTIONS (objfile, s)
1046 {
1047 int idx = s->the_bfd_section->index;
1048 CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
1049
f1f6aadf
PA
1050 if (obj_section_addr (s) - offset <= addr
1051 && addr < obj_section_endaddr (s) - offset)
19e2d14b 1052 {
714835d5 1053 ginfo->obj_section = s;
19e2d14b
KB
1054 ginfo->section = idx;
1055 return;
1056 }
1057 }
1058 }
c906108c
SS
1059}
1060
1061struct symbol *
fba45db2 1062fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
c906108c 1063{
907fc202
UW
1064 CORE_ADDR addr;
1065
c906108c
SS
1066 if (!sym)
1067 return NULL;
1068
714835d5 1069 if (SYMBOL_OBJ_SECTION (sym))
c906108c
SS
1070 return sym;
1071
907fc202
UW
1072 /* We either have an OBJFILE, or we can get at it from the sym's
1073 symtab. Anything else is a bug. */
1074 gdb_assert (objfile || SYMBOL_SYMTAB (sym));
1075
1076 if (objfile == NULL)
1077 objfile = SYMBOL_SYMTAB (sym)->objfile;
1078
1079 /* We should have an objfile by now. */
1080 gdb_assert (objfile);
1081
1082 switch (SYMBOL_CLASS (sym))
1083 {
1084 case LOC_STATIC:
1085 case LOC_LABEL:
907fc202
UW
1086 addr = SYMBOL_VALUE_ADDRESS (sym);
1087 break;
1088 case LOC_BLOCK:
1089 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1090 break;
1091
1092 default:
1093 /* Nothing else will be listed in the minsyms -- no use looking
1094 it up. */
1095 return sym;
1096 }
1097
1098 fixup_section (&sym->ginfo, addr, objfile);
c906108c
SS
1099
1100 return sym;
1101}
1102
f8eba3c6
TT
1103/* Compute the demangled form of NAME as used by the various symbol
1104 lookup functions. The result is stored in *RESULT_NAME. Returns a
1105 cleanup which can be used to clean up the result.
1106
1107 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1108 Normally, Ada symbol lookups are performed using the encoded name
1109 rather than the demangled name, and so it might seem to make sense
1110 for this function to return an encoded version of NAME.
1111 Unfortunately, we cannot do this, because this function is used in
1112 circumstances where it is not appropriate to try to encode NAME.
1113 For instance, when displaying the frame info, we demangle the name
1114 of each parameter, and then perform a symbol lookup inside our
1115 function using that demangled name. In Ada, certain functions
1116 have internally-generated parameters whose name contain uppercase
1117 characters. Encoding those name would result in those uppercase
1118 characters to become lowercase, and thus cause the symbol lookup
1119 to fail. */
c906108c 1120
f8eba3c6
TT
1121struct cleanup *
1122demangle_for_lookup (const char *name, enum language lang,
1123 const char **result_name)
c906108c 1124{
729051e6
DJ
1125 char *demangled_name = NULL;
1126 const char *modified_name = NULL;
9ee6bb93 1127 struct cleanup *cleanup = make_cleanup (null_cleanup, 0);
c906108c 1128
729051e6
DJ
1129 modified_name = name;
1130
a766d390 1131 /* If we are using C++, D, Go, or Java, demangle the name before doing a
c378eb4e 1132 lookup, so we can always binary search. */
53c5240f 1133 if (lang == language_cplus)
729051e6
DJ
1134 {
1135 demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
1136 if (demangled_name)
1137 {
729051e6 1138 modified_name = demangled_name;
9ee6bb93 1139 make_cleanup (xfree, demangled_name);
729051e6 1140 }
71c25dea
TT
1141 else
1142 {
1143 /* If we were given a non-mangled name, canonicalize it
1144 according to the language (so far only for C++). */
1145 demangled_name = cp_canonicalize_string (name);
1146 if (demangled_name)
1147 {
1148 modified_name = demangled_name;
1149 make_cleanup (xfree, demangled_name);
1150 }
1151 }
729051e6 1152 }
53c5240f 1153 else if (lang == language_java)
987504bb 1154 {
9af17804 1155 demangled_name = cplus_demangle (name,
987504bb
JJ
1156 DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
1157 if (demangled_name)
1158 {
987504bb 1159 modified_name = demangled_name;
9ee6bb93 1160 make_cleanup (xfree, demangled_name);
987504bb
JJ
1161 }
1162 }
6aecb9c2
JB
1163 else if (lang == language_d)
1164 {
1165 demangled_name = d_demangle (name, 0);
1166 if (demangled_name)
1167 {
1168 modified_name = demangled_name;
1169 make_cleanup (xfree, demangled_name);
1170 }
1171 }
a766d390
DE
1172 else if (lang == language_go)
1173 {
1174 demangled_name = go_demangle (name, 0);
1175 if (demangled_name)
1176 {
1177 modified_name = demangled_name;
1178 make_cleanup (xfree, demangled_name);
1179 }
1180 }
729051e6 1181
f8eba3c6
TT
1182 *result_name = modified_name;
1183 return cleanup;
1184}
1185
1186/* Find the definition for a specified symbol name NAME
1187 in domain DOMAIN, visible from lexical block BLOCK.
1188 Returns the struct symbol pointer, or zero if no symbol is found.
1189 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1190 NAME is a field of the current implied argument `this'. If so set
1191 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1192 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1193 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1194
7e082072
DE
1195/* This function (or rather its subordinates) have a bunch of loops and
1196 it would seem to be attractive to put in some QUIT's (though I'm not really
1197 sure whether it can run long enough to be really important). But there
f8eba3c6 1198 are a few calls for which it would appear to be bad news to quit
7e082072 1199 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
f8eba3c6
TT
1200 that there is C++ code below which can error(), but that probably
1201 doesn't affect these calls since they are looking for a known
1202 variable and thus can probably assume it will never hit the C++
1203 code). */
1204
1205struct symbol *
1206lookup_symbol_in_language (const char *name, const struct block *block,
1207 const domain_enum domain, enum language lang,
1993b719 1208 struct field_of_this_result *is_a_field_of_this)
f8eba3c6
TT
1209{
1210 const char *modified_name;
1211 struct symbol *returnval;
1212 struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name);
1213
94af9270 1214 returnval = lookup_symbol_aux (modified_name, block, domain, lang,
774b6a14 1215 is_a_field_of_this);
9ee6bb93 1216 do_cleanups (cleanup);
fba7f19c 1217
9af17804 1218 return returnval;
fba7f19c
EZ
1219}
1220
53c5240f
PA
1221/* Behave like lookup_symbol_in_language, but performed with the
1222 current language. */
1223
1224struct symbol *
1225lookup_symbol (const char *name, const struct block *block,
1993b719
TT
1226 domain_enum domain,
1227 struct field_of_this_result *is_a_field_of_this)
53c5240f
PA
1228{
1229 return lookup_symbol_in_language (name, block, domain,
1230 current_language->la_language,
2570f2b7 1231 is_a_field_of_this);
53c5240f
PA
1232}
1233
66a17cb6
TT
1234/* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1235 found, or NULL if not found. */
1236
1237struct symbol *
1238lookup_language_this (const struct language_defn *lang,
1239 const struct block *block)
1240{
1241 if (lang->la_name_of_this == NULL || block == NULL)
1242 return NULL;
1243
03de6823 1244 while (block)
66a17cb6
TT
1245 {
1246 struct symbol *sym;
1247
1248 sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
1249 if (sym != NULL)
f149aabd
TT
1250 {
1251 block_found = block;
1252 return sym;
1253 }
66a17cb6 1254 if (BLOCK_FUNCTION (block))
03de6823 1255 break;
66a17cb6
TT
1256 block = BLOCK_SUPERBLOCK (block);
1257 }
03de6823
TT
1258
1259 return NULL;
66a17cb6
TT
1260}
1261
2dc3df72
TT
1262/* Given TYPE, a structure/union,
1263 return 1 if the component named NAME from the ultimate target
1264 structure/union is defined, otherwise, return 0. */
1265
1266static int
1993b719
TT
1267check_field (struct type *type, const char *name,
1268 struct field_of_this_result *is_a_field_of_this)
2dc3df72
TT
1269{
1270 int i;
1271
1272 /* The type may be a stub. */
1273 CHECK_TYPEDEF (type);
1274
1275 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1276 {
1277 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1278
1279 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1993b719
TT
1280 {
1281 is_a_field_of_this->type = type;
1282 is_a_field_of_this->field = &TYPE_FIELD (type, i);
1283 return 1;
1284 }
2dc3df72
TT
1285 }
1286
1287 /* C++: If it was not found as a data field, then try to return it
1288 as a pointer to a method. */
1289
1290 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1291 {
1292 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
1993b719
TT
1293 {
1294 is_a_field_of_this->type = type;
1295 is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i);
1296 return 1;
1297 }
2dc3df72
TT
1298 }
1299
1300 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1993b719 1301 if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this))
2dc3df72
TT
1302 return 1;
1303
1304 return 0;
1305}
1306
53c5240f 1307/* Behave like lookup_symbol except that NAME is the natural name
7e082072 1308 (e.g., demangled name) of the symbol that we're looking for. */
5ad1c190 1309
fba7f19c 1310static struct symbol *
94af9270
KS
1311lookup_symbol_aux (const char *name, const struct block *block,
1312 const domain_enum domain, enum language language,
1993b719 1313 struct field_of_this_result *is_a_field_of_this)
fba7f19c 1314{
8155455b 1315 struct symbol *sym;
53c5240f 1316 const struct language_defn *langdef;
406bc4de 1317
9a146a11
EZ
1318 /* Make sure we do something sensible with is_a_field_of_this, since
1319 the callers that set this parameter to some non-null value will
1993b719
TT
1320 certainly use it later. If we don't set it, the contents of
1321 is_a_field_of_this are undefined. */
9a146a11 1322 if (is_a_field_of_this != NULL)
1993b719 1323 memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this));
9a146a11 1324
e4051eeb
DC
1325 /* Search specified block and its superiors. Don't search
1326 STATIC_BLOCK or GLOBAL_BLOCK. */
c906108c 1327
13387711 1328 sym = lookup_symbol_aux_local (name, block, domain, language);
8155455b
DC
1329 if (sym != NULL)
1330 return sym;
c906108c 1331
53c5240f 1332 /* If requested to do so by the caller and if appropriate for LANGUAGE,
13387711 1333 check to see if NAME is a field of `this'. */
53c5240f
PA
1334
1335 langdef = language_def (language);
5f9a71c3 1336
6592e36f
TT
1337 /* Don't do this check if we are searching for a struct. It will
1338 not be found by check_field, but will be found by other
1339 means. */
1340 if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN)
c906108c 1341 {
66a17cb6 1342 struct symbol *sym = lookup_language_this (langdef, block);
2b2d9e11 1343
2b2d9e11 1344 if (sym)
c906108c 1345 {
2b2d9e11 1346 struct type *t = sym->type;
9af17804 1347
2b2d9e11
VP
1348 /* I'm not really sure that type of this can ever
1349 be typedefed; just be safe. */
1350 CHECK_TYPEDEF (t);
1351 if (TYPE_CODE (t) == TYPE_CODE_PTR
1352 || TYPE_CODE (t) == TYPE_CODE_REF)
1353 t = TYPE_TARGET_TYPE (t);
9af17804 1354
2b2d9e11
VP
1355 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1356 && TYPE_CODE (t) != TYPE_CODE_UNION)
9af17804 1357 error (_("Internal error: `%s' is not an aggregate"),
2b2d9e11 1358 langdef->la_name_of_this);
9af17804 1359
1993b719
TT
1360 if (check_field (t, name, is_a_field_of_this))
1361 return NULL;
c906108c
SS
1362 }
1363 }
1364
53c5240f 1365 /* Now do whatever is appropriate for LANGUAGE to look
774b6a14 1366 up static and global variables. */
c906108c 1367
774b6a14
TT
1368 sym = langdef->la_lookup_symbol_nonlocal (name, block, domain);
1369 if (sym != NULL)
1370 return sym;
c906108c 1371
774b6a14
TT
1372 /* Now search all static file-level symbols. Not strictly correct,
1373 but more useful than an error. */
41f62f39
JK
1374
1375 return lookup_static_symbol_aux (name, domain);
1376}
1377
1378/* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1379 first, then check the psymtabs. If a psymtab indicates the existence of the
1380 desired name as a file-level static, then do psymtab-to-symtab conversion on
c378eb4e 1381 the fly and return the found symbol. */
41f62f39
JK
1382
1383struct symbol *
1384lookup_static_symbol_aux (const char *name, const domain_enum domain)
1385{
1386 struct objfile *objfile;
1387 struct symbol *sym;
c906108c 1388
67ff19f7 1389 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
8155455b
DC
1390 if (sym != NULL)
1391 return sym;
9af17804 1392
ccefe4c4
TT
1393 ALL_OBJFILES (objfile)
1394 {
1395 sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
1396 if (sym != NULL)
1397 return sym;
1398 }
c906108c 1399
8155455b 1400 return NULL;
c906108c 1401}
8155455b 1402
e4051eeb 1403/* Check to see if the symbol is defined in BLOCK or its superiors.
89a9d1b1 1404 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
8155455b
DC
1405
1406static struct symbol *
94af9270 1407lookup_symbol_aux_local (const char *name, const struct block *block,
13387711
SW
1408 const domain_enum domain,
1409 enum language language)
8155455b
DC
1410{
1411 struct symbol *sym;
89a9d1b1 1412 const struct block *static_block = block_static_block (block);
13387711
SW
1413 const char *scope = block_scope (block);
1414
e4051eeb
DC
1415 /* Check if either no block is specified or it's a global block. */
1416
89a9d1b1
DC
1417 if (static_block == NULL)
1418 return NULL;
e4051eeb 1419
89a9d1b1 1420 while (block != static_block)
f61e8913 1421 {
94af9270 1422 sym = lookup_symbol_aux_block (name, block, domain);
f61e8913
DC
1423 if (sym != NULL)
1424 return sym;
edb3359d 1425
f55ee35c 1426 if (language == language_cplus || language == language_fortran)
13387711 1427 {
34eaf542
TT
1428 sym = cp_lookup_symbol_imports_or_template (scope, name, block,
1429 domain);
13387711
SW
1430 if (sym != NULL)
1431 return sym;
1432 }
1433
edb3359d
DJ
1434 if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block))
1435 break;
f61e8913
DC
1436 block = BLOCK_SUPERBLOCK (block);
1437 }
1438
edb3359d 1439 /* We've reached the edge of the function without finding a result. */
e4051eeb 1440
f61e8913
DC
1441 return NULL;
1442}
1443
3a40aaa0
UW
1444/* Look up OBJFILE to BLOCK. */
1445
c0201579 1446struct objfile *
3a40aaa0
UW
1447lookup_objfile_from_block (const struct block *block)
1448{
1449 struct objfile *obj;
1450 struct symtab *s;
1451
1452 if (block == NULL)
1453 return NULL;
1454
1455 block = block_global_block (block);
1456 /* Go through SYMTABS. */
1457 ALL_SYMTABS (obj, s)
1458 if (block == BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK))
61f0d762
JK
1459 {
1460 if (obj->separate_debug_objfile_backlink)
1461 obj = obj->separate_debug_objfile_backlink;
1462
1463 return obj;
1464 }
3a40aaa0
UW
1465
1466 return NULL;
1467}
1468
6c9353d3
PA
1469/* Look up a symbol in a block; if found, fixup the symbol, and set
1470 block_found appropriately. */
f61e8913 1471
5f9a71c3 1472struct symbol *
94af9270 1473lookup_symbol_aux_block (const char *name, const struct block *block,
21b556f4 1474 const domain_enum domain)
f61e8913
DC
1475{
1476 struct symbol *sym;
f61e8913 1477
94af9270 1478 sym = lookup_block_symbol (block, name, domain);
f61e8913 1479 if (sym)
8155455b 1480 {
f61e8913 1481 block_found = block;
21b556f4 1482 return fixup_symbol_section (sym, NULL);
8155455b
DC
1483 }
1484
1485 return NULL;
1486}
1487
3a40aaa0
UW
1488/* Check all global symbols in OBJFILE in symtabs and
1489 psymtabs. */
1490
1491struct symbol *
15d123c9 1492lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
3a40aaa0 1493 const char *name,
21b556f4 1494 const domain_enum domain)
3a40aaa0 1495{
15d123c9 1496 const struct objfile *objfile;
3a40aaa0
UW
1497 struct symbol *sym;
1498 struct blockvector *bv;
1499 const struct block *block;
1500 struct symtab *s;
3a40aaa0 1501
15d123c9
TG
1502 for (objfile = main_objfile;
1503 objfile;
1504 objfile = objfile_separate_debug_iterate (main_objfile, objfile))
1505 {
1506 /* Go through symtabs. */
78e5175a
DE
1507 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1508 {
1509 bv = BLOCKVECTOR (s);
1510 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1511 sym = lookup_block_symbol (block, name, domain);
1512 if (sym)
1513 {
1514 block_found = block;
1515 return fixup_symbol_section (sym, (struct objfile *)objfile);
1516 }
1517 }
15d123c9 1518
ccefe4c4
TT
1519 sym = lookup_symbol_aux_quick ((struct objfile *) objfile, GLOBAL_BLOCK,
1520 name, domain);
1521 if (sym)
1522 return sym;
15d123c9 1523 }
56e3f43c 1524
3a40aaa0
UW
1525 return NULL;
1526}
1527
19630284
JB
1528/* Check to see if the symbol is defined in one of the OBJFILE's
1529 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
8155455b
DC
1530 depending on whether or not we want to search global symbols or
1531 static symbols. */
1532
19630284
JB
1533static struct symbol *
1534lookup_symbol_aux_objfile (struct objfile *objfile, int block_index,
1535 const char *name, const domain_enum domain)
1536{
1537 struct symbol *sym = NULL;
1538 struct blockvector *bv;
1539 const struct block *block;
1540 struct symtab *s;
1541
a743abeb
DE
1542 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1543 {
1544 bv = BLOCKVECTOR (s);
1545 block = BLOCKVECTOR_BLOCK (bv, block_index);
1546 sym = lookup_block_symbol (block, name, domain);
1547 if (sym)
1548 {
1549 block_found = block;
1550 return fixup_symbol_section (sym, objfile);
1551 }
1552 }
19630284
JB
1553
1554 return NULL;
1555}
1556
1557/* Same as lookup_symbol_aux_objfile, except that it searches all
1558 objfiles. Return the first match found. */
1559
8155455b 1560static struct symbol *
67ff19f7
JB
1561lookup_symbol_aux_symtabs (int block_index, const char *name,
1562 const domain_enum domain)
8155455b 1563{
67ff19f7
JB
1564 struct symbol *sym;
1565 struct objfile *objfile;
8155455b 1566
67ff19f7
JB
1567 ALL_OBJFILES (objfile)
1568 {
19630284
JB
1569 sym = lookup_symbol_aux_objfile (objfile, block_index, name, domain);
1570 if (sym)
1571 return sym;
8155455b
DC
1572 }
1573
1574 return NULL;
1575}
1576
422d65e7
DE
1577/* Wrapper around lookup_symbol_aux_objfile for search_symbols.
1578 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1579 and all related objfiles. */
1580
1581static struct symbol *
1582lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile,
1583 const char *linkage_name,
1584 domain_enum domain)
1585{
1586 enum language lang = current_language->la_language;
1587 const char *modified_name;
1588 struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang,
1589 &modified_name);
1590 struct objfile *main_objfile, *cur_objfile;
1591
1592 if (objfile->separate_debug_objfile_backlink)
1593 main_objfile = objfile->separate_debug_objfile_backlink;
1594 else
1595 main_objfile = objfile;
1596
1597 for (cur_objfile = main_objfile;
1598 cur_objfile;
1599 cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile))
1600 {
1601 struct symbol *sym;
1602
1603 sym = lookup_symbol_aux_objfile (cur_objfile, GLOBAL_BLOCK,
1604 modified_name, domain);
1605 if (sym == NULL)
1606 sym = lookup_symbol_aux_objfile (cur_objfile, STATIC_BLOCK,
1607 modified_name, domain);
1608 if (sym != NULL)
1609 {
1610 do_cleanups (cleanup);
1611 return sym;
1612 }
1613 }
1614
1615 do_cleanups (cleanup);
1616 return NULL;
1617}
1618
ccefe4c4
TT
1619/* A helper function for lookup_symbol_aux that interfaces with the
1620 "quick" symbol table functions. */
8155455b
DC
1621
1622static struct symbol *
ccefe4c4
TT
1623lookup_symbol_aux_quick (struct objfile *objfile, int kind,
1624 const char *name, const domain_enum domain)
8155455b 1625{
ccefe4c4 1626 struct symtab *symtab;
8155455b
DC
1627 struct blockvector *bv;
1628 const struct block *block;
ccefe4c4 1629 struct symbol *sym;
8155455b 1630
ccefe4c4
TT
1631 if (!objfile->sf)
1632 return NULL;
1633 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, domain);
1634 if (!symtab)
1635 return NULL;
8155455b 1636
ccefe4c4
TT
1637 bv = BLOCKVECTOR (symtab);
1638 block = BLOCKVECTOR_BLOCK (bv, kind);
1639 sym = lookup_block_symbol (block, name, domain);
1640 if (!sym)
1641 {
1642 /* This shouldn't be necessary, but as a last resort try
1643 looking in the statics even though the psymtab claimed
c378eb4e 1644 the symbol was global, or vice-versa. It's possible
ccefe4c4
TT
1645 that the psymtab gets it wrong in some cases. */
1646
1647 /* FIXME: carlton/2002-09-30: Should we really do that?
1648 If that happens, isn't it likely to be a GDB error, in
1649 which case we should fix the GDB error rather than
1650 silently dealing with it here? So I'd vote for
1651 removing the check for the symbol in the other
1652 block. */
1653 block = BLOCKVECTOR_BLOCK (bv,
1654 kind == GLOBAL_BLOCK ?
1655 STATIC_BLOCK : GLOBAL_BLOCK);
1656 sym = lookup_block_symbol (block, name, domain);
1657 if (!sym)
3e43a32a
MS
1658 error (_("\
1659Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1660%s may be an inlined function, or may be a template function\n\
1661(if a template, try specifying an instantiation: %s<type>)."),
ccefe4c4 1662 kind == GLOBAL_BLOCK ? "global" : "static",
05cba821 1663 name, symtab_to_filename_for_display (symtab), name, name);
ccefe4c4
TT
1664 }
1665 return fixup_symbol_section (sym, objfile);
8155455b
DC
1666}
1667
5f9a71c3
DC
1668/* A default version of lookup_symbol_nonlocal for use by languages
1669 that can't think of anything better to do. This implements the C
1670 lookup rules. */
1671
1672struct symbol *
1673basic_lookup_symbol_nonlocal (const char *name,
5f9a71c3 1674 const struct block *block,
21b556f4 1675 const domain_enum domain)
5f9a71c3
DC
1676{
1677 struct symbol *sym;
1678
1679 /* NOTE: carlton/2003-05-19: The comments below were written when
1680 this (or what turned into this) was part of lookup_symbol_aux;
1681 I'm much less worried about these questions now, since these
1682 decisions have turned out well, but I leave these comments here
1683 for posterity. */
1684
1685 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1686 not it would be appropriate to search the current global block
1687 here as well. (That's what this code used to do before the
1688 is_a_field_of_this check was moved up.) On the one hand, it's
1689 redundant with the lookup_symbol_aux_symtabs search that happens
1690 next. On the other hand, if decode_line_1 is passed an argument
1691 like filename:var, then the user presumably wants 'var' to be
1692 searched for in filename. On the third hand, there shouldn't be
1693 multiple global variables all of which are named 'var', and it's
1694 not like decode_line_1 has ever restricted its search to only
1695 global variables in a single filename. All in all, only
1696 searching the static block here seems best: it's correct and it's
1697 cleanest. */
1698
1699 /* NOTE: carlton/2002-12-05: There's also a possible performance
1700 issue here: if you usually search for global symbols in the
1701 current file, then it would be slightly better to search the
1702 current global block before searching all the symtabs. But there
1703 are other factors that have a much greater effect on performance
1704 than that one, so I don't think we should worry about that for
1705 now. */
1706
94af9270 1707 sym = lookup_symbol_static (name, block, domain);
5f9a71c3
DC
1708 if (sym != NULL)
1709 return sym;
1710
94af9270 1711 return lookup_symbol_global (name, block, domain);
5f9a71c3
DC
1712}
1713
1714/* Lookup a symbol in the static block associated to BLOCK, if there
1715 is one; do nothing if BLOCK is NULL or a global block. */
1716
1717struct symbol *
1718lookup_symbol_static (const char *name,
5f9a71c3 1719 const struct block *block,
21b556f4 1720 const domain_enum domain)
5f9a71c3
DC
1721{
1722 const struct block *static_block = block_static_block (block);
1723
1724 if (static_block != NULL)
94af9270 1725 return lookup_symbol_aux_block (name, static_block, domain);
5f9a71c3
DC
1726 else
1727 return NULL;
1728}
1729
19630284
JB
1730/* Private data to be used with lookup_symbol_global_iterator_cb. */
1731
1732struct global_sym_lookup_data
1733{
1734 /* The name of the symbol we are searching for. */
1735 const char *name;
1736
1737 /* The domain to use for our search. */
1738 domain_enum domain;
1739
1740 /* The field where the callback should store the symbol if found.
1741 It should be initialized to NULL before the search is started. */
1742 struct symbol *result;
1743};
1744
1745/* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1746 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1747 OBJFILE. The arguments for the search are passed via CB_DATA,
1748 which in reality is a pointer to struct global_sym_lookup_data. */
1749
1750static int
1751lookup_symbol_global_iterator_cb (struct objfile *objfile,
1752 void *cb_data)
1753{
1754 struct global_sym_lookup_data *data =
1755 (struct global_sym_lookup_data *) cb_data;
1756
1757 gdb_assert (data->result == NULL);
1758
1759 data->result = lookup_symbol_aux_objfile (objfile, GLOBAL_BLOCK,
1760 data->name, data->domain);
1761 if (data->result == NULL)
1762 data->result = lookup_symbol_aux_quick (objfile, GLOBAL_BLOCK,
1763 data->name, data->domain);
1764
1765 /* If we found a match, tell the iterator to stop. Otherwise,
1766 keep going. */
1767 return (data->result != NULL);
1768}
1769
5f9a71c3
DC
1770/* Lookup a symbol in all files' global blocks (searching psymtabs if
1771 necessary). */
1772
1773struct symbol *
1774lookup_symbol_global (const char *name,
3a40aaa0 1775 const struct block *block,
21b556f4 1776 const domain_enum domain)
5f9a71c3 1777{
3a40aaa0
UW
1778 struct symbol *sym = NULL;
1779 struct objfile *objfile = NULL;
19630284 1780 struct global_sym_lookup_data lookup_data;
3a40aaa0
UW
1781
1782 /* Call library-specific lookup procedure. */
67ff19f7
JB
1783 objfile = lookup_objfile_from_block (block);
1784 if (objfile != NULL)
1785 sym = solib_global_lookup (objfile, name, domain);
3a40aaa0
UW
1786 if (sym != NULL)
1787 return sym;
5f9a71c3 1788
19630284
JB
1789 memset (&lookup_data, 0, sizeof (lookup_data));
1790 lookup_data.name = name;
1791 lookup_data.domain = domain;
1792 gdbarch_iterate_over_objfiles_in_search_order
f5656ead 1793 (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
19630284 1794 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
5f9a71c3 1795
19630284 1796 return lookup_data.result;
5f9a71c3
DC
1797}
1798
5eeb2539 1799int
9af17804 1800symbol_matches_domain (enum language symbol_language,
5eeb2539
AR
1801 domain_enum symbol_domain,
1802 domain_enum domain)
1803{
9af17804 1804 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
5eeb2539
AR
1805 A Java class declaration also defines a typedef for the class.
1806 Similarly, any Ada type declaration implicitly defines a typedef. */
1807 if (symbol_language == language_cplus
6aecb9c2 1808 || symbol_language == language_d
5eeb2539
AR
1809 || symbol_language == language_java
1810 || symbol_language == language_ada)
1811 {
1812 if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
1813 && symbol_domain == STRUCT_DOMAIN)
1814 return 1;
1815 }
1816 /* For all other languages, strict match is required. */
1817 return (symbol_domain == domain);
1818}
1819
ccefe4c4
TT
1820/* Look up a type named NAME in the struct_domain. The type returned
1821 must not be opaque -- i.e., must have at least one field
1822 defined. */
c906108c 1823
ccefe4c4
TT
1824struct type *
1825lookup_transparent_type (const char *name)
c906108c 1826{
ccefe4c4
TT
1827 return current_language->la_lookup_transparent_type (name);
1828}
9af17804 1829
ccefe4c4
TT
1830/* A helper for basic_lookup_transparent_type that interfaces with the
1831 "quick" symbol table functions. */
357e46e7 1832
ccefe4c4
TT
1833static struct type *
1834basic_lookup_transparent_type_quick (struct objfile *objfile, int kind,
1835 const char *name)
1836{
1837 struct symtab *symtab;
1838 struct blockvector *bv;
1839 struct block *block;
1840 struct symbol *sym;
c906108c 1841
ccefe4c4
TT
1842 if (!objfile->sf)
1843 return NULL;
1844 symtab = objfile->sf->qf->lookup_symbol (objfile, kind, name, STRUCT_DOMAIN);
1845 if (!symtab)
1846 return NULL;
c906108c 1847
ccefe4c4
TT
1848 bv = BLOCKVECTOR (symtab);
1849 block = BLOCKVECTOR_BLOCK (bv, kind);
1850 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1851 if (!sym)
9af17804 1852 {
ccefe4c4
TT
1853 int other_kind = kind == GLOBAL_BLOCK ? STATIC_BLOCK : GLOBAL_BLOCK;
1854
1855 /* This shouldn't be necessary, but as a last resort
1856 * try looking in the 'other kind' even though the psymtab
c378eb4e 1857 * claimed the symbol was one thing. It's possible that
ccefe4c4
TT
1858 * the psymtab gets it wrong in some cases.
1859 */
1860 block = BLOCKVECTOR_BLOCK (bv, other_kind);
1861 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1862 if (!sym)
c378eb4e 1863 /* FIXME; error is wrong in one case. */
3e43a32a
MS
1864 error (_("\
1865Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
ccefe4c4
TT
1866%s may be an inlined function, or may be a template function\n\
1867(if a template, try specifying an instantiation: %s<type>)."),
05cba821 1868 name, symtab_to_filename_for_display (symtab), name, name);
c906108c 1869 }
ccefe4c4
TT
1870 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1871 return SYMBOL_TYPE (sym);
c906108c 1872
ccefe4c4 1873 return NULL;
b368761e 1874}
c906108c 1875
b368761e
DC
1876/* The standard implementation of lookup_transparent_type. This code
1877 was modeled on lookup_symbol -- the parts not relevant to looking
1878 up types were just left out. In particular it's assumed here that
1879 types are available in struct_domain and only at file-static or
1880 global blocks. */
c906108c
SS
1881
1882struct type *
b368761e 1883basic_lookup_transparent_type (const char *name)
c906108c 1884{
52f0bd74
AC
1885 struct symbol *sym;
1886 struct symtab *s = NULL;
c906108c 1887 struct blockvector *bv;
52f0bd74
AC
1888 struct objfile *objfile;
1889 struct block *block;
ccefe4c4 1890 struct type *t;
c906108c
SS
1891
1892 /* Now search all the global symbols. Do the symtab's first, then
c378eb4e 1893 check the psymtab's. If a psymtab indicates the existence
c906108c
SS
1894 of the desired name as a global, then do psymtab-to-symtab
1895 conversion on the fly and return the found symbol. */
c5aa993b 1896
58b6ab13 1897 ALL_OBJFILES (objfile)
c5aa993b 1898 {
d790cf0a
DE
1899 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
1900 {
1901 bv = BLOCKVECTOR (s);
1902 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1903 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1904 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1905 {
1906 return SYMBOL_TYPE (sym);
1907 }
1908 }
c5aa993b 1909 }
c906108c 1910
ccefe4c4 1911 ALL_OBJFILES (objfile)
c5aa993b 1912 {
ccefe4c4
TT
1913 t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
1914 if (t)
1915 return t;
c5aa993b 1916 }
c906108c
SS
1917
1918 /* Now search the static file-level symbols.
1919 Not strictly correct, but more useful than an error.
1920 Do the symtab's first, then
c378eb4e 1921 check the psymtab's. If a psymtab indicates the existence
c906108c 1922 of the desired name as a file-level static, then do psymtab-to-symtab
c378eb4e 1923 conversion on the fly and return the found symbol. */
c906108c 1924
54ec275a 1925 ALL_OBJFILES (objfile)
c5aa993b 1926 {
78e5175a 1927 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
c5aa993b 1928 {
54ec275a
KS
1929 bv = BLOCKVECTOR (s);
1930 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1931 sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
1932 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1933 {
1934 return SYMBOL_TYPE (sym);
1935 }
c5aa993b
JM
1936 }
1937 }
c906108c 1938
ccefe4c4 1939 ALL_OBJFILES (objfile)
c5aa993b 1940 {
ccefe4c4
TT
1941 t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
1942 if (t)
1943 return t;
c5aa993b 1944 }
ccefe4c4 1945
c906108c
SS
1946 return (struct type *) 0;
1947}
1948
c378eb4e 1949/* Find the name of the file containing main(). */
c906108c 1950/* FIXME: What about languages without main() or specially linked
c378eb4e 1951 executables that have no main() ? */
c906108c 1952
dd786858 1953const char *
ccefe4c4 1954find_main_filename (void)
c906108c 1955{
52f0bd74 1956 struct objfile *objfile;
dd786858 1957 char *name = main_name ();
c906108c 1958
ccefe4c4 1959 ALL_OBJFILES (objfile)
c5aa993b 1960 {
dd786858
TT
1961 const char *result;
1962
ccefe4c4
TT
1963 if (!objfile->sf)
1964 continue;
1965 result = objfile->sf->qf->find_symbol_file (objfile, name);
1966 if (result)
1967 return result;
c5aa993b 1968 }
c906108c
SS
1969 return (NULL);
1970}
1971
176620f1 1972/* Search BLOCK for symbol NAME in DOMAIN.
c906108c
SS
1973
1974 Note that if NAME is the demangled form of a C++ symbol, we will fail
1975 to find a match during the binary search of the non-encoded names, but
1976 for now we don't worry about the slight inefficiency of looking for
1977 a match we'll never find, since it will go pretty quick. Once the
1978 binary search terminates, we drop through and do a straight linear
1bae87b9 1979 search on the symbols. Each symbol which is marked as being a ObjC/C++
9af17804 1980 symbol (language_cplus or language_objc set) has both the encoded and
c378eb4e 1981 non-encoded names tested for a match. */
c906108c
SS
1982
1983struct symbol *
aa1ee363 1984lookup_block_symbol (const struct block *block, const char *name,
176620f1 1985 const domain_enum domain)
c906108c 1986{
8157b174 1987 struct block_iterator iter;
de4f826b 1988 struct symbol *sym;
c906108c 1989
de4f826b 1990 if (!BLOCK_FUNCTION (block))
261397f8 1991 {
8157b174 1992 for (sym = block_iter_name_first (block, name, &iter);
de4f826b 1993 sym != NULL;
8157b174 1994 sym = block_iter_name_next (name, &iter))
261397f8 1995 {
5eeb2539 1996 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
94af9270 1997 SYMBOL_DOMAIN (sym), domain))
261397f8
DJ
1998 return sym;
1999 }
2000 return NULL;
2001 }
526e70c0 2002 else
c906108c 2003 {
526e70c0
DC
2004 /* Note that parameter symbols do not always show up last in the
2005 list; this loop makes sure to take anything else other than
2006 parameter symbols first; it only uses parameter symbols as a
2007 last resort. Note that this only takes up extra computation
2008 time on a match. */
de4f826b
DC
2009
2010 struct symbol *sym_found = NULL;
2011
8157b174 2012 for (sym = block_iter_name_first (block, name, &iter);
de4f826b 2013 sym != NULL;
8157b174 2014 sym = block_iter_name_next (name, &iter))
c906108c 2015 {
5eeb2539 2016 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
94af9270 2017 SYMBOL_DOMAIN (sym), domain))
c906108c 2018 {
c906108c 2019 sym_found = sym;
2a2d4dc3 2020 if (!SYMBOL_IS_ARGUMENT (sym))
c906108c
SS
2021 {
2022 break;
2023 }
2024 }
c906108c 2025 }
c378eb4e 2026 return (sym_found); /* Will be NULL if not found. */
c906108c 2027 }
c906108c
SS
2028}
2029
4eeaa230 2030/* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
f8eba3c6
TT
2031
2032 For each symbol that matches, CALLBACK is called. The symbol and
2033 DATA are passed to the callback.
2034
2035 If CALLBACK returns zero, the iteration ends. Otherwise, the
4eeaa230 2036 search continues. */
f8eba3c6
TT
2037
2038void
2039iterate_over_symbols (const struct block *block, const char *name,
2040 const domain_enum domain,
8e704927 2041 symbol_found_callback_ftype *callback,
f8eba3c6
TT
2042 void *data)
2043{
4eeaa230
DE
2044 struct block_iterator iter;
2045 struct symbol *sym;
f8eba3c6 2046
4eeaa230
DE
2047 for (sym = block_iter_name_first (block, name, &iter);
2048 sym != NULL;
2049 sym = block_iter_name_next (name, &iter))
2050 {
2051 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
2052 SYMBOL_DOMAIN (sym), domain))
f8eba3c6 2053 {
4eeaa230
DE
2054 if (!callback (sym, data))
2055 return;
f8eba3c6 2056 }
f8eba3c6
TT
2057 }
2058}
2059
c906108c 2060/* Find the symtab associated with PC and SECTION. Look through the
c378eb4e 2061 psymtabs and read in another symtab if necessary. */
c906108c
SS
2062
2063struct symtab *
714835d5 2064find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
c906108c 2065{
52f0bd74 2066 struct block *b;
c906108c 2067 struct blockvector *bv;
52f0bd74
AC
2068 struct symtab *s = NULL;
2069 struct symtab *best_s = NULL;
52f0bd74 2070 struct objfile *objfile;
c906108c 2071 CORE_ADDR distance = 0;
8a48e967
DJ
2072 struct minimal_symbol *msymbol;
2073
2074 /* If we know that this is not a text address, return failure. This is
2075 necessary because we loop based on the block's high and low code
2076 addresses, which do not include the data ranges, and because
2077 we call find_pc_sect_psymtab which has a similar restriction based
2078 on the partial_symtab's texthigh and textlow. */
2079 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
2080 if (msymbol
712f90be
TT
2081 && (MSYMBOL_TYPE (msymbol) == mst_data
2082 || MSYMBOL_TYPE (msymbol) == mst_bss
2083 || MSYMBOL_TYPE (msymbol) == mst_abs
2084 || MSYMBOL_TYPE (msymbol) == mst_file_data
2085 || MSYMBOL_TYPE (msymbol) == mst_file_bss))
8a48e967 2086 return NULL;
c906108c
SS
2087
2088 /* Search all symtabs for the one whose file contains our address, and which
2089 is the smallest of all the ones containing the address. This is designed
2090 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2091 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2092 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2093
2094 This happens for native ecoff format, where code from included files
c378eb4e 2095 gets its own symtab. The symtab for the included file should have
c906108c
SS
2096 been read in already via the dependency mechanism.
2097 It might be swifter to create several symtabs with the same name
2098 like xcoff does (I'm not sure).
2099
2100 It also happens for objfiles that have their functions reordered.
2101 For these, the symtab we are looking for is not necessarily read in. */
2102
11309657 2103 ALL_PRIMARY_SYMTABS (objfile, s)
c5aa993b
JM
2104 {
2105 bv = BLOCKVECTOR (s);
2106 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
c906108c 2107
c5aa993b 2108 if (BLOCK_START (b) <= pc
c5aa993b 2109 && BLOCK_END (b) > pc
c5aa993b
JM
2110 && (distance == 0
2111 || BLOCK_END (b) - BLOCK_START (b) < distance))
2112 {
2113 /* For an objfile that has its functions reordered,
2114 find_pc_psymtab will find the proper partial symbol table
2115 and we simply return its corresponding symtab. */
2116 /* In order to better support objfiles that contain both
2117 stabs and coff debugging info, we continue on if a psymtab
c378eb4e 2118 can't be found. */
ccefe4c4 2119 if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
c5aa993b 2120 {
ccefe4c4 2121 struct symtab *result;
433759f7 2122
ccefe4c4
TT
2123 result
2124 = objfile->sf->qf->find_pc_sect_symtab (objfile,
2125 msymbol,
2126 pc, section,
2127 0);
2128 if (result)
2129 return result;
c5aa993b
JM
2130 }
2131 if (section != 0)
2132 {
8157b174 2133 struct block_iterator iter;
261397f8 2134 struct symbol *sym = NULL;
c906108c 2135
de4f826b 2136 ALL_BLOCK_SYMBOLS (b, iter, sym)
c5aa993b 2137 {
261397f8 2138 fixup_symbol_section (sym, objfile);
714835d5 2139 if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym), section))
c5aa993b
JM
2140 break;
2141 }
de4f826b 2142 if (sym == NULL)
c378eb4e
MS
2143 continue; /* No symbol in this symtab matches
2144 section. */
c5aa993b
JM
2145 }
2146 distance = BLOCK_END (b) - BLOCK_START (b);
2147 best_s = s;
2148 }
2149 }
c906108c
SS
2150
2151 if (best_s != NULL)
c5aa993b 2152 return (best_s);
c906108c 2153
072cabfe
DE
2154 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2155
ccefe4c4
TT
2156 ALL_OBJFILES (objfile)
2157 {
2158 struct symtab *result;
433759f7 2159
ccefe4c4
TT
2160 if (!objfile->sf)
2161 continue;
2162 result = objfile->sf->qf->find_pc_sect_symtab (objfile,
2163 msymbol,
2164 pc, section,
2165 1);
2166 if (result)
2167 return result;
2168 }
2169
2170 return NULL;
c906108c
SS
2171}
2172
c378eb4e
MS
2173/* Find the symtab associated with PC. Look through the psymtabs and read
2174 in another symtab if necessary. Backward compatibility, no section. */
c906108c
SS
2175
2176struct symtab *
fba45db2 2177find_pc_symtab (CORE_ADDR pc)
c906108c
SS
2178{
2179 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
2180}
c906108c 2181\f
c5aa993b 2182
7e73cedf 2183/* Find the source file and line number for a given PC value and SECTION.
c906108c
SS
2184 Return a structure containing a symtab pointer, a line number,
2185 and a pc range for the entire source line.
2186 The value's .pc field is NOT the specified pc.
2187 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2188 use the line that ends there. Otherwise, in that case, the line
2189 that begins there is used. */
2190
2191/* The big complication here is that a line may start in one file, and end just
2192 before the start of another file. This usually occurs when you #include
2193 code in the middle of a subroutine. To properly find the end of a line's PC
2194 range, we must search all symtabs associated with this compilation unit, and
2195 find the one whose first PC is closer than that of the next line in this
2196 symtab. */
2197
2198/* If it's worth the effort, we could be using a binary search. */
2199
2200struct symtab_and_line
714835d5 2201find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
c906108c
SS
2202{
2203 struct symtab *s;
52f0bd74
AC
2204 struct linetable *l;
2205 int len;
2206 int i;
2207 struct linetable_entry *item;
c906108c
SS
2208 struct symtab_and_line val;
2209 struct blockvector *bv;
2210 struct minimal_symbol *msymbol;
2211 struct minimal_symbol *mfunsym;
93b55aa1 2212 struct objfile *objfile;
c906108c
SS
2213
2214 /* Info on best line seen so far, and where it starts, and its file. */
2215
2216 struct linetable_entry *best = NULL;
2217 CORE_ADDR best_end = 0;
2218 struct symtab *best_symtab = 0;
2219
2220 /* Store here the first line number
2221 of a file which contains the line at the smallest pc after PC.
2222 If we don't find a line whose range contains PC,
2223 we will use a line one less than this,
2224 with a range from the start of that file to the first line's pc. */
2225 struct linetable_entry *alt = NULL;
c906108c
SS
2226
2227 /* Info on best line seen in this file. */
2228
2229 struct linetable_entry *prev;
2230
2231 /* If this pc is not from the current frame,
2232 it is the address of the end of a call instruction.
2233 Quite likely that is the start of the following statement.
2234 But what we want is the statement containing the instruction.
2235 Fudge the pc to make sure we get that. */
2236
fe39c653 2237 init_sal (&val); /* initialize to zeroes */
c906108c 2238
6c95b8df
PA
2239 val.pspace = current_program_space;
2240
b77b1eb7
JB
2241 /* It's tempting to assume that, if we can't find debugging info for
2242 any function enclosing PC, that we shouldn't search for line
2243 number info, either. However, GAS can emit line number info for
2244 assembly files --- very helpful when debugging hand-written
2245 assembly code. In such a case, we'd have no debug info for the
2246 function, but we would have line info. */
648f4f79 2247
c906108c
SS
2248 if (notcurrent)
2249 pc -= 1;
2250
c5aa993b 2251 /* elz: added this because this function returned the wrong
c906108c 2252 information if the pc belongs to a stub (import/export)
c378eb4e 2253 to call a shlib function. This stub would be anywhere between
9af17804 2254 two functions in the target, and the line info was erroneously
c378eb4e
MS
2255 taken to be the one of the line before the pc. */
2256
c906108c 2257 /* RT: Further explanation:
c5aa993b 2258
c906108c
SS
2259 * We have stubs (trampolines) inserted between procedures.
2260 *
2261 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2262 * exists in the main image.
2263 *
2264 * In the minimal symbol table, we have a bunch of symbols
c378eb4e 2265 * sorted by start address. The stubs are marked as "trampoline",
c906108c
SS
2266 * the others appear as text. E.g.:
2267 *
9af17804 2268 * Minimal symbol table for main image
c906108c
SS
2269 * main: code for main (text symbol)
2270 * shr1: stub (trampoline symbol)
2271 * foo: code for foo (text symbol)
2272 * ...
2273 * Minimal symbol table for "shr1" image:
2274 * ...
2275 * shr1: code for shr1 (text symbol)
2276 * ...
2277 *
2278 * So the code below is trying to detect if we are in the stub
2279 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2280 * and if found, do the symbolization from the real-code address
2281 * rather than the stub address.
2282 *
2283 * Assumptions being made about the minimal symbol table:
2284 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
c378eb4e 2285 * if we're really in the trampoline.s If we're beyond it (say
9af17804 2286 * we're in "foo" in the above example), it'll have a closer
c906108c
SS
2287 * symbol (the "foo" text symbol for example) and will not
2288 * return the trampoline.
2289 * 2. lookup_minimal_symbol_text() will find a real text symbol
2290 * corresponding to the trampoline, and whose address will
c378eb4e 2291 * be different than the trampoline address. I put in a sanity
c906108c
SS
2292 * check for the address being the same, to avoid an
2293 * infinite recursion.
2294 */
c5aa993b
JM
2295 msymbol = lookup_minimal_symbol_by_pc (pc);
2296 if (msymbol != NULL)
c906108c 2297 if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
c5aa993b 2298 {
2335f48e 2299 mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
5520a790 2300 NULL);
c5aa993b
JM
2301 if (mfunsym == NULL)
2302 /* I eliminated this warning since it is coming out
2303 * in the following situation:
2304 * gdb shmain // test program with shared libraries
2305 * (gdb) break shr1 // function in shared lib
2306 * Warning: In stub for ...
9af17804 2307 * In the above situation, the shared lib is not loaded yet,
c5aa993b
JM
2308 * so of course we can't find the real func/line info,
2309 * but the "break" still works, and the warning is annoying.
c378eb4e 2310 * So I commented out the warning. RT */
3e43a32a 2311 /* warning ("In stub for %s; unable to find real function/line info",
c378eb4e
MS
2312 SYMBOL_LINKAGE_NAME (msymbol)); */
2313 ;
c5aa993b 2314 /* fall through */
3e43a32a
MS
2315 else if (SYMBOL_VALUE_ADDRESS (mfunsym)
2316 == SYMBOL_VALUE_ADDRESS (msymbol))
c5aa993b 2317 /* Avoid infinite recursion */
c378eb4e 2318 /* See above comment about why warning is commented out. */
3e43a32a 2319 /* warning ("In stub for %s; unable to find real function/line info",
c378eb4e
MS
2320 SYMBOL_LINKAGE_NAME (msymbol)); */
2321 ;
c5aa993b
JM
2322 /* fall through */
2323 else
82cf6c60 2324 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
c5aa993b 2325 }
c906108c
SS
2326
2327
2328 s = find_pc_sect_symtab (pc, section);
2329 if (!s)
2330 {
c378eb4e 2331 /* If no symbol information, return previous pc. */
c906108c
SS
2332 if (notcurrent)
2333 pc++;
2334 val.pc = pc;
2335 return val;
2336 }
2337
2338 bv = BLOCKVECTOR (s);
93b55aa1 2339 objfile = s->objfile;
c906108c
SS
2340
2341 /* Look at all the symtabs that share this blockvector.
2342 They all have the same apriori range, that we found was right;
2343 but they have different line tables. */
2344
93b55aa1 2345 ALL_OBJFILE_SYMTABS (objfile, s)
c906108c 2346 {
93b55aa1
JK
2347 if (BLOCKVECTOR (s) != bv)
2348 continue;
2349
c906108c
SS
2350 /* Find the best line in this symtab. */
2351 l = LINETABLE (s);
2352 if (!l)
c5aa993b 2353 continue;
c906108c
SS
2354 len = l->nitems;
2355 if (len <= 0)
2356 {
2357 /* I think len can be zero if the symtab lacks line numbers
2358 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2359 I'm not sure which, and maybe it depends on the symbol
2360 reader). */
2361 continue;
2362 }
2363
2364 prev = NULL;
c378eb4e 2365 item = l->item; /* Get first line info. */
c906108c
SS
2366
2367 /* Is this file's first line closer than the first lines of other files?
c5aa993b 2368 If so, record this file, and its first line, as best alternate. */
c906108c 2369 if (item->pc > pc && (!alt || item->pc < alt->pc))
c656bca5 2370 alt = item;
c906108c
SS
2371
2372 for (i = 0; i < len; i++, item++)
2373 {
2374 /* Leave prev pointing to the linetable entry for the last line
2375 that started at or before PC. */
2376 if (item->pc > pc)
2377 break;
2378
2379 prev = item;
2380 }
2381
2382 /* At this point, prev points at the line whose start addr is <= pc, and
c5aa993b
JM
2383 item points at the next line. If we ran off the end of the linetable
2384 (pc >= start of the last line), then prev == item. If pc < start of
2385 the first line, prev will not be set. */
c906108c
SS
2386
2387 /* Is this file's best line closer than the best in the other files?
083ae935
DJ
2388 If so, record this file, and its best line, as best so far. Don't
2389 save prev if it represents the end of a function (i.e. line number
2390 0) instead of a real line. */
c906108c 2391
083ae935 2392 if (prev && prev->line && (!best || prev->pc > best->pc))
c906108c
SS
2393 {
2394 best = prev;
2395 best_symtab = s;
25d53da1
KB
2396
2397 /* Discard BEST_END if it's before the PC of the current BEST. */
2398 if (best_end <= best->pc)
2399 best_end = 0;
c906108c 2400 }
25d53da1
KB
2401
2402 /* If another line (denoted by ITEM) is in the linetable and its
2403 PC is after BEST's PC, but before the current BEST_END, then
2404 use ITEM's PC as the new best_end. */
2405 if (best && i < len && item->pc > best->pc
2406 && (best_end == 0 || best_end > item->pc))
2407 best_end = item->pc;
c906108c
SS
2408 }
2409
2410 if (!best_symtab)
2411 {
e86e87f7
DJ
2412 /* If we didn't find any line number info, just return zeros.
2413 We used to return alt->line - 1 here, but that could be
2414 anywhere; if we don't have line number info for this PC,
2415 don't make some up. */
2416 val.pc = pc;
c906108c 2417 }
e8717518
FF
2418 else if (best->line == 0)
2419 {
2420 /* If our best fit is in a range of PC's for which no line
2421 number info is available (line number is zero) then we didn't
c378eb4e 2422 find any valid line information. */
e8717518
FF
2423 val.pc = pc;
2424 }
c906108c
SS
2425 else
2426 {
2427 val.symtab = best_symtab;
2428 val.line = best->line;
2429 val.pc = best->pc;
2430 if (best_end && (!alt || best_end < alt->pc))
2431 val.end = best_end;
2432 else if (alt)
2433 val.end = alt->pc;
2434 else
2435 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2436 }
2437 val.section = section;
2438 return val;
2439}
2440
c378eb4e 2441/* Backward compatibility (no section). */
c906108c
SS
2442
2443struct symtab_and_line
fba45db2 2444find_pc_line (CORE_ADDR pc, int notcurrent)
c906108c 2445{
714835d5 2446 struct obj_section *section;
c906108c
SS
2447
2448 section = find_pc_overlay (pc);
2449 if (pc_in_unmapped_range (pc, section))
2450 pc = overlay_mapped_address (pc, section);
2451 return find_pc_sect_line (pc, section, notcurrent);
2452}
c906108c 2453\f
c906108c
SS
2454/* Find line number LINE in any symtab whose name is the same as
2455 SYMTAB.
2456
2457 If found, return the symtab that contains the linetable in which it was
2458 found, set *INDEX to the index in the linetable of the best entry
2459 found, and set *EXACT_MATCH nonzero if the value returned is an
2460 exact match.
2461
2462 If not found, return NULL. */
2463
50641945 2464struct symtab *
433759f7
MS
2465find_line_symtab (struct symtab *symtab, int line,
2466 int *index, int *exact_match)
c906108c 2467{
6f43c46f 2468 int exact = 0; /* Initialized here to avoid a compiler warning. */
c906108c
SS
2469
2470 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2471 so far seen. */
2472
2473 int best_index;
2474 struct linetable *best_linetable;
2475 struct symtab *best_symtab;
2476
2477 /* First try looking it up in the given symtab. */
2478 best_linetable = LINETABLE (symtab);
2479 best_symtab = symtab;
f8eba3c6 2480 best_index = find_line_common (best_linetable, line, &exact, 0);
c906108c
SS
2481 if (best_index < 0 || !exact)
2482 {
2483 /* Didn't find an exact match. So we better keep looking for
c5aa993b
JM
2484 another symtab with the same name. In the case of xcoff,
2485 multiple csects for one source file (produced by IBM's FORTRAN
2486 compiler) produce multiple symtabs (this is unavoidable
2487 assuming csects can be at arbitrary places in memory and that
2488 the GLOBAL_BLOCK of a symtab has a begin and end address). */
c906108c
SS
2489
2490 /* BEST is the smallest linenumber > LINE so far seen,
c5aa993b
JM
2491 or 0 if none has been seen so far.
2492 BEST_INDEX and BEST_LINETABLE identify the item for it. */
c906108c
SS
2493 int best;
2494
2495 struct objfile *objfile;
2496 struct symtab *s;
2497
2498 if (best_index >= 0)
2499 best = best_linetable->item[best_index].line;
2500 else
2501 best = 0;
2502
ccefe4c4 2503 ALL_OBJFILES (objfile)
51432cca 2504 {
ccefe4c4 2505 if (objfile->sf)
652a8996 2506 objfile->sf->qf->expand_symtabs_with_fullname (objfile,
05cba821 2507 symtab_to_fullname (symtab));
51432cca
CES
2508 }
2509
c906108c 2510 ALL_SYMTABS (objfile, s)
c5aa993b
JM
2511 {
2512 struct linetable *l;
2513 int ind;
c906108c 2514
3ffc00b8 2515 if (FILENAME_CMP (symtab->filename, s->filename) != 0)
c5aa993b 2516 continue;
d180bcbd
JK
2517 if (FILENAME_CMP (symtab_to_fullname (symtab),
2518 symtab_to_fullname (s)) != 0)
3ffc00b8 2519 continue;
c5aa993b 2520 l = LINETABLE (s);
f8eba3c6 2521 ind = find_line_common (l, line, &exact, 0);
c5aa993b
JM
2522 if (ind >= 0)
2523 {
2524 if (exact)
2525 {
2526 best_index = ind;
2527 best_linetable = l;
2528 best_symtab = s;
2529 goto done;
2530 }
2531 if (best == 0 || l->item[ind].line < best)
2532 {
2533 best = l->item[ind].line;
2534 best_index = ind;
2535 best_linetable = l;
2536 best_symtab = s;
2537 }
2538 }
2539 }
c906108c 2540 }
c5aa993b 2541done:
c906108c
SS
2542 if (best_index < 0)
2543 return NULL;
2544
2545 if (index)
2546 *index = best_index;
2547 if (exact_match)
2548 *exact_match = exact;
2549
2550 return best_symtab;
2551}
f8eba3c6
TT
2552
2553/* Given SYMTAB, returns all the PCs function in the symtab that
2554 exactly match LINE. Returns NULL if there are no exact matches,
2555 but updates BEST_ITEM in this case. */
2556
2557VEC (CORE_ADDR) *
2558find_pcs_for_symtab_line (struct symtab *symtab, int line,
2559 struct linetable_entry **best_item)
2560{
c656bca5 2561 int start = 0;
f8eba3c6
TT
2562 VEC (CORE_ADDR) *result = NULL;
2563
2564 /* First, collect all the PCs that are at this line. */
2565 while (1)
2566 {
2567 int was_exact;
2568 int idx;
2569
2570 idx = find_line_common (LINETABLE (symtab), line, &was_exact, start);
2571 if (idx < 0)
2572 break;
2573
2574 if (!was_exact)
2575 {
2576 struct linetable_entry *item = &LINETABLE (symtab)->item[idx];
2577
2578 if (*best_item == NULL || item->line < (*best_item)->line)
2579 *best_item = item;
2580
2581 break;
2582 }
2583
2584 VEC_safe_push (CORE_ADDR, result, LINETABLE (symtab)->item[idx].pc);
2585 start = idx + 1;
2586 }
2587
2588 return result;
2589}
2590
c906108c
SS
2591\f
2592/* Set the PC value for a given source file and line number and return true.
2593 Returns zero for invalid line number (and sets the PC to 0).
2594 The source file is specified with a struct symtab. */
2595
2596int
fba45db2 2597find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
c906108c
SS
2598{
2599 struct linetable *l;
2600 int ind;
2601
2602 *pc = 0;
2603 if (symtab == 0)
2604 return 0;
2605
2606 symtab = find_line_symtab (symtab, line, &ind, NULL);
2607 if (symtab != NULL)
2608 {
2609 l = LINETABLE (symtab);
2610 *pc = l->item[ind].pc;
2611 return 1;
2612 }
2613 else
2614 return 0;
2615}
2616
2617/* Find the range of pc values in a line.
2618 Store the starting pc of the line into *STARTPTR
2619 and the ending pc (start of next line) into *ENDPTR.
2620 Returns 1 to indicate success.
2621 Returns 0 if could not find the specified line. */
2622
2623int
fba45db2
KB
2624find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2625 CORE_ADDR *endptr)
c906108c
SS
2626{
2627 CORE_ADDR startaddr;
2628 struct symtab_and_line found_sal;
2629
2630 startaddr = sal.pc;
c5aa993b 2631 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
c906108c
SS
2632 return 0;
2633
2634 /* This whole function is based on address. For example, if line 10 has
2635 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2636 "info line *0x123" should say the line goes from 0x100 to 0x200
2637 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2638 This also insures that we never give a range like "starts at 0x134
2639 and ends at 0x12c". */
2640
2641 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2642 if (found_sal.line != sal.line)
2643 {
2644 /* The specified line (sal) has zero bytes. */
2645 *startptr = found_sal.pc;
2646 *endptr = found_sal.pc;
2647 }
2648 else
2649 {
2650 *startptr = found_sal.pc;
2651 *endptr = found_sal.end;
2652 }
2653 return 1;
2654}
2655
2656/* Given a line table and a line number, return the index into the line
2657 table for the pc of the nearest line whose number is >= the specified one.
2658 Return -1 if none is found. The value is >= 0 if it is an index.
f8eba3c6 2659 START is the index at which to start searching the line table.
c906108c
SS
2660
2661 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2662
2663static int
aa1ee363 2664find_line_common (struct linetable *l, int lineno,
f8eba3c6 2665 int *exact_match, int start)
c906108c 2666{
52f0bd74
AC
2667 int i;
2668 int len;
c906108c
SS
2669
2670 /* BEST is the smallest linenumber > LINENO so far seen,
2671 or 0 if none has been seen so far.
2672 BEST_INDEX identifies the item for it. */
2673
2674 int best_index = -1;
2675 int best = 0;
2676
b7589f7d
DJ
2677 *exact_match = 0;
2678
c906108c
SS
2679 if (lineno <= 0)
2680 return -1;
2681 if (l == 0)
2682 return -1;
2683
2684 len = l->nitems;
f8eba3c6 2685 for (i = start; i < len; i++)
c906108c 2686 {
aa1ee363 2687 struct linetable_entry *item = &(l->item[i]);
c906108c
SS
2688
2689 if (item->line == lineno)
2690 {
2691 /* Return the first (lowest address) entry which matches. */
2692 *exact_match = 1;
2693 return i;
2694 }
2695
2696 if (item->line > lineno && (best == 0 || item->line < best))
2697 {
2698 best = item->line;
2699 best_index = i;
2700 }
2701 }
2702
2703 /* If we got here, we didn't get an exact match. */
c906108c
SS
2704 return best_index;
2705}
2706
2707int
fba45db2 2708find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
c906108c
SS
2709{
2710 struct symtab_and_line sal;
433759f7 2711
c906108c
SS
2712 sal = find_pc_line (pc, 0);
2713 *startptr = sal.pc;
2714 *endptr = sal.end;
2715 return sal.symtab != 0;
2716}
2717
8c7a1ee8
EZ
2718/* Given a function start address FUNC_ADDR and SYMTAB, find the first
2719 address for that function that has an entry in SYMTAB's line info
2720 table. If such an entry cannot be found, return FUNC_ADDR
2721 unaltered. */
eca864fe 2722
70221824 2723static CORE_ADDR
8c7a1ee8
EZ
2724skip_prologue_using_lineinfo (CORE_ADDR func_addr, struct symtab *symtab)
2725{
2726 CORE_ADDR func_start, func_end;
2727 struct linetable *l;
952a6d41 2728 int i;
8c7a1ee8
EZ
2729
2730 /* Give up if this symbol has no lineinfo table. */
2731 l = LINETABLE (symtab);
2732 if (l == NULL)
2733 return func_addr;
2734
2735 /* Get the range for the function's PC values, or give up if we
2736 cannot, for some reason. */
2737 if (!find_pc_partial_function (func_addr, NULL, &func_start, &func_end))
2738 return func_addr;
2739
2740 /* Linetable entries are ordered by PC values, see the commentary in
2741 symtab.h where `struct linetable' is defined. Thus, the first
2742 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2743 address we are looking for. */
2744 for (i = 0; i < l->nitems; i++)
2745 {
2746 struct linetable_entry *item = &(l->item[i]);
2747
2748 /* Don't use line numbers of zero, they mark special entries in
2749 the table. See the commentary on symtab.h before the
2750 definition of struct linetable. */
2751 if (item->line > 0 && func_start <= item->pc && item->pc < func_end)
2752 return item->pc;
2753 }
2754
2755 return func_addr;
2756}
2757
c906108c
SS
2758/* Given a function symbol SYM, find the symtab and line for the start
2759 of the function.
2760 If the argument FUNFIRSTLINE is nonzero, we want the first line
2761 of real code inside the function. */
2762
50641945 2763struct symtab_and_line
fba45db2 2764find_function_start_sal (struct symbol *sym, int funfirstline)
c906108c 2765{
059acae7
UW
2766 struct symtab_and_line sal;
2767
2768 fixup_symbol_section (sym, NULL);
2769 sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
2770 SYMBOL_OBJ_SECTION (sym), 0);
2771
86da934b
UW
2772 /* We always should have a line for the function start address.
2773 If we don't, something is odd. Create a plain SAL refering
2774 just the PC and hope that skip_prologue_sal (if requested)
2775 can find a line number for after the prologue. */
2776 if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
2777 {
2778 init_sal (&sal);
2779 sal.pspace = current_program_space;
2780 sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2781 sal.section = SYMBOL_OBJ_SECTION (sym);
2782 }
2783
059acae7
UW
2784 if (funfirstline)
2785 skip_prologue_sal (&sal);
bccdca4a 2786
059acae7
UW
2787 return sal;
2788}
2789
2790/* Adjust SAL to the first instruction past the function prologue.
2791 If the PC was explicitly specified, the SAL is not changed.
2792 If the line number was explicitly specified, at most the SAL's PC
2793 is updated. If SAL is already past the prologue, then do nothing. */
eca864fe 2794
059acae7
UW
2795void
2796skip_prologue_sal (struct symtab_and_line *sal)
2797{
2798 struct symbol *sym;
2799 struct symtab_and_line start_sal;
2800 struct cleanup *old_chain;
8be455d7 2801 CORE_ADDR pc, saved_pc;
059acae7
UW
2802 struct obj_section *section;
2803 const char *name;
2804 struct objfile *objfile;
2805 struct gdbarch *gdbarch;
edb3359d 2806 struct block *b, *function_block;
8be455d7 2807 int force_skip, skip;
c906108c 2808
a4b411d6 2809 /* Do not change the SAL if PC was specified explicitly. */
059acae7
UW
2810 if (sal->explicit_pc)
2811 return;
6c95b8df
PA
2812
2813 old_chain = save_current_space_and_thread ();
059acae7 2814 switch_to_program_space_and_thread (sal->pspace);
6c95b8df 2815
059acae7
UW
2816 sym = find_pc_sect_function (sal->pc, sal->section);
2817 if (sym != NULL)
bccdca4a 2818 {
059acae7
UW
2819 fixup_symbol_section (sym, NULL);
2820
2821 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2822 section = SYMBOL_OBJ_SECTION (sym);
2823 name = SYMBOL_LINKAGE_NAME (sym);
2824 objfile = SYMBOL_SYMTAB (sym)->objfile;
c906108c 2825 }
059acae7
UW
2826 else
2827 {
2828 struct minimal_symbol *msymbol
2829 = lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
433759f7 2830
059acae7
UW
2831 if (msymbol == NULL)
2832 {
2833 do_cleanups (old_chain);
2834 return;
2835 }
2836
2837 pc = SYMBOL_VALUE_ADDRESS (msymbol);
2838 section = SYMBOL_OBJ_SECTION (msymbol);
2839 name = SYMBOL_LINKAGE_NAME (msymbol);
2840 objfile = msymbol_objfile (msymbol);
2841 }
2842
2843 gdbarch = get_objfile_arch (objfile);
2844
8be455d7
JK
2845 /* Process the prologue in two passes. In the first pass try to skip the
2846 prologue (SKIP is true) and verify there is a real need for it (indicated
2847 by FORCE_SKIP). If no such reason was found run a second pass where the
2848 prologue is not skipped (SKIP is false). */
059acae7 2849
8be455d7
JK
2850 skip = 1;
2851 force_skip = 1;
059acae7 2852
8be455d7
JK
2853 /* Be conservative - allow direct PC (without skipping prologue) only if we
2854 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2855 have to be set by the caller so we use SYM instead. */
2856 if (sym && SYMBOL_SYMTAB (sym)->locations_valid)
2857 force_skip = 0;
059acae7 2858
8be455d7
JK
2859 saved_pc = pc;
2860 do
c906108c 2861 {
8be455d7 2862 pc = saved_pc;
4309257c 2863
8be455d7
JK
2864 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2865 so that gdbarch_skip_prologue has something unique to work on. */
2866 if (section_is_overlay (section) && !section_is_mapped (section))
2867 pc = overlay_unmapped_address (pc, section);
2868
2869 /* Skip "first line" of function (which is actually its prologue). */
2870 pc += gdbarch_deprecated_function_start_offset (gdbarch);
2871 if (skip)
2872 pc = gdbarch_skip_prologue (gdbarch, pc);
2873
2874 /* For overlays, map pc back into its mapped VMA range. */
2875 pc = overlay_mapped_address (pc, section);
2876
2877 /* Calculate line number. */
059acae7 2878 start_sal = find_pc_sect_line (pc, section, 0);
8be455d7
JK
2879
2880 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2881 line is still part of the same function. */
2882 if (skip && start_sal.pc != pc
b1d96efd
JK
2883 && (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
2884 && start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
8be455d7
JK
2885 : (lookup_minimal_symbol_by_pc_section (start_sal.end, section)
2886 == lookup_minimal_symbol_by_pc_section (pc, section))))
2887 {
2888 /* First pc of next line */
2889 pc = start_sal.end;
2890 /* Recalculate the line number (might not be N+1). */
2891 start_sal = find_pc_sect_line (pc, section, 0);
2892 }
2893
2894 /* On targets with executable formats that don't have a concept of
2895 constructors (ELF with .init has, PE doesn't), gcc emits a call
2896 to `__main' in `main' between the prologue and before user
2897 code. */
2898 if (gdbarch_skip_main_prologue_p (gdbarch)
7ccffd7c 2899 && name && strcmp_iw (name, "main") == 0)
8be455d7
JK
2900 {
2901 pc = gdbarch_skip_main_prologue (gdbarch, pc);
2902 /* Recalculate the line number (might not be N+1). */
2903 start_sal = find_pc_sect_line (pc, section, 0);
2904 force_skip = 1;
2905 }
4309257c 2906 }
8be455d7 2907 while (!force_skip && skip--);
4309257c 2908
8c7a1ee8
EZ
2909 /* If we still don't have a valid source line, try to find the first
2910 PC in the lineinfo table that belongs to the same function. This
2911 happens with COFF debug info, which does not seem to have an
2912 entry in lineinfo table for the code after the prologue which has
2913 no direct relation to source. For example, this was found to be
2914 the case with the DJGPP target using "gcc -gcoff" when the
2915 compiler inserted code after the prologue to make sure the stack
2916 is aligned. */
8be455d7 2917 if (!force_skip && sym && start_sal.symtab == NULL)
8c7a1ee8
EZ
2918 {
2919 pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
2920 /* Recalculate the line number. */
059acae7 2921 start_sal = find_pc_sect_line (pc, section, 0);
8c7a1ee8
EZ
2922 }
2923
059acae7
UW
2924 do_cleanups (old_chain);
2925
2926 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2927 forward SAL to the end of the prologue. */
2928 if (sal->pc >= pc)
2929 return;
2930
2931 sal->pc = pc;
2932 sal->section = section;
2933
2934 /* Unless the explicit_line flag was set, update the SAL line
2935 and symtab to correspond to the modified PC location. */
2936 if (sal->explicit_line)
2937 return;
2938
2939 sal->symtab = start_sal.symtab;
2940 sal->line = start_sal.line;
2941 sal->end = start_sal.end;
c906108c 2942
edb3359d
DJ
2943 /* Check if we are now inside an inlined function. If we can,
2944 use the call site of the function instead. */
059acae7 2945 b = block_for_pc_sect (sal->pc, sal->section);
edb3359d
DJ
2946 function_block = NULL;
2947 while (b != NULL)
2948 {
2949 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
2950 function_block = b;
2951 else if (BLOCK_FUNCTION (b) != NULL)
2952 break;
2953 b = BLOCK_SUPERBLOCK (b);
2954 }
2955 if (function_block != NULL
2956 && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
2957 {
059acae7
UW
2958 sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
2959 sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
edb3359d 2960 }
c906108c 2961}
50641945 2962
c906108c
SS
2963/* If P is of the form "operator[ \t]+..." where `...' is
2964 some legitimate operator text, return a pointer to the
2965 beginning of the substring of the operator text.
2966 Otherwise, return "". */
eca864fe 2967
fc9f3a69 2968static char *
fba45db2 2969operator_chars (char *p, char **end)
c906108c
SS
2970{
2971 *end = "";
2972 if (strncmp (p, "operator", 8))
2973 return *end;
2974 p += 8;
2975
2976 /* Don't get faked out by `operator' being part of a longer
2977 identifier. */
c5aa993b 2978 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
c906108c
SS
2979 return *end;
2980
2981 /* Allow some whitespace between `operator' and the operator symbol. */
2982 while (*p == ' ' || *p == '\t')
2983 p++;
2984
c378eb4e 2985 /* Recognize 'operator TYPENAME'. */
c906108c 2986
c5aa993b 2987 if (isalpha (*p) || *p == '_' || *p == '$')
c906108c 2988 {
aa1ee363 2989 char *q = p + 1;
433759f7 2990
c5aa993b 2991 while (isalnum (*q) || *q == '_' || *q == '$')
c906108c
SS
2992 q++;
2993 *end = q;
2994 return p;
2995 }
2996
53e8ad3d
MS
2997 while (*p)
2998 switch (*p)
2999 {
3000 case '\\': /* regexp quoting */
3001 if (p[1] == '*')
3002 {
3e43a32a 3003 if (p[2] == '=') /* 'operator\*=' */
53e8ad3d
MS
3004 *end = p + 3;
3005 else /* 'operator\*' */
3006 *end = p + 2;
3007 return p;
3008 }
3009 else if (p[1] == '[')
3010 {
3011 if (p[2] == ']')
3e43a32a
MS
3012 error (_("mismatched quoting on brackets, "
3013 "try 'operator\\[\\]'"));
53e8ad3d
MS
3014 else if (p[2] == '\\' && p[3] == ']')
3015 {
3016 *end = p + 4; /* 'operator\[\]' */
3017 return p;
3018 }
3019 else
8a3fe4f8 3020 error (_("nothing is allowed between '[' and ']'"));
53e8ad3d 3021 }
9af17804 3022 else
53e8ad3d 3023 {
c378eb4e 3024 /* Gratuitous qoute: skip it and move on. */
53e8ad3d
MS
3025 p++;
3026 continue;
3027 }
3028 break;
3029 case '!':
3030 case '=':
3031 case '*':
3032 case '/':
3033 case '%':
3034 case '^':
3035 if (p[1] == '=')
3036 *end = p + 2;
3037 else
3038 *end = p + 1;
3039 return p;
3040 case '<':
3041 case '>':
3042 case '+':
3043 case '-':
3044 case '&':
3045 case '|':
3046 if (p[0] == '-' && p[1] == '>')
3047 {
c378eb4e 3048 /* Struct pointer member operator 'operator->'. */
53e8ad3d
MS
3049 if (p[2] == '*')
3050 {
3051 *end = p + 3; /* 'operator->*' */
3052 return p;
3053 }
3054 else if (p[2] == '\\')
3055 {
3056 *end = p + 4; /* Hopefully 'operator->\*' */
3057 return p;
3058 }
3059 else
3060 {
3061 *end = p + 2; /* 'operator->' */
3062 return p;
3063 }
3064 }
3065 if (p[1] == '=' || p[1] == p[0])
3066 *end = p + 2;
3067 else
3068 *end = p + 1;
3069 return p;
3070 case '~':
3071 case ',':
c5aa993b 3072 *end = p + 1;
53e8ad3d
MS
3073 return p;
3074 case '(':
3075 if (p[1] != ')')
3e43a32a
MS
3076 error (_("`operator ()' must be specified "
3077 "without whitespace in `()'"));
c5aa993b 3078 *end = p + 2;
53e8ad3d
MS
3079 return p;
3080 case '?':
3081 if (p[1] != ':')
3e43a32a
MS
3082 error (_("`operator ?:' must be specified "
3083 "without whitespace in `?:'"));
53e8ad3d
MS
3084 *end = p + 2;
3085 return p;
3086 case '[':
3087 if (p[1] != ']')
3e43a32a
MS
3088 error (_("`operator []' must be specified "
3089 "without whitespace in `[]'"));
53e8ad3d
MS
3090 *end = p + 2;
3091 return p;
3092 default:
8a3fe4f8 3093 error (_("`operator %s' not supported"), p);
53e8ad3d
MS
3094 break;
3095 }
3096
c906108c
SS
3097 *end = "";
3098 return *end;
3099}
c906108c 3100\f
c5aa993b 3101
9fdc877b
DE
3102/* Cache to watch for file names already seen by filename_seen. */
3103
3104struct filename_seen_cache
3105{
3106 /* Table of files seen so far. */
2908cac6
DE
3107 htab_t tab;
3108 /* Initial size of the table. It automagically grows from here. */
9fdc877b 3109#define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
9fdc877b
DE
3110};
3111
3112/* filename_seen_cache constructor. */
3113
3114static struct filename_seen_cache *
3115create_filename_seen_cache (void)
3116{
3117 struct filename_seen_cache *cache;
3118
3119 cache = XNEW (struct filename_seen_cache);
2908cac6
DE
3120 cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
3121 filename_hash, filename_eq,
3122 NULL, xcalloc, xfree);
9fdc877b
DE
3123
3124 return cache;
3125}
3126
3127/* Empty the cache, but do not delete it. */
3128
3129static void
2908cac6 3130clear_filename_seen_cache (struct filename_seen_cache *cache)
9fdc877b 3131{
2908cac6 3132 htab_empty (cache->tab);
9fdc877b
DE
3133}
3134
3135/* filename_seen_cache destructor.
3136 This takes a void * argument as it is generally used as a cleanup. */
3137
3138static void
3139delete_filename_seen_cache (void *ptr)
3140{
3141 struct filename_seen_cache *cache = ptr;
3142
2908cac6 3143 htab_delete (cache->tab);
9fdc877b
DE
3144 xfree (cache);
3145}
3146
a2b6eff5 3147/* If FILE is not already in the table of files in CACHE, return zero;
c94fdfd0 3148 otherwise return non-zero. Optionally add FILE to the table if ADD
2908cac6
DE
3149 is non-zero.
3150
3151 NOTE: We don't manage space for FILE, we assume FILE lives as long
3152 as the caller needs. */
eca864fe 3153
c94fdfd0 3154static int
9fdc877b 3155filename_seen (struct filename_seen_cache *cache, const char *file, int add)
c906108c 3156{
2908cac6 3157 void **slot;
c906108c 3158
c94fdfd0 3159 /* Is FILE in tab? */
2908cac6
DE
3160 slot = htab_find_slot (cache->tab, file, add ? INSERT : NO_INSERT);
3161 if (*slot != NULL)
3162 return 1;
c94fdfd0
EZ
3163
3164 /* No; maybe add it to tab. */
3165 if (add)
2908cac6 3166 *slot = (char *) file;
c906108c 3167
c94fdfd0
EZ
3168 return 0;
3169}
3170
9fdc877b
DE
3171/* Data structure to maintain printing state for output_source_filename. */
3172
3173struct output_source_filename_data
3174{
3175 /* Cache of what we've seen so far. */
3176 struct filename_seen_cache *filename_seen_cache;
3177
3178 /* Flag of whether we're printing the first one. */
3179 int first;
3180};
3181
c94fdfd0 3182/* Slave routine for sources_info. Force line breaks at ,'s.
9fdc877b
DE
3183 NAME is the name to print.
3184 DATA contains the state for printing and watching for duplicates. */
eca864fe 3185
c94fdfd0 3186static void
9fdc877b
DE
3187output_source_filename (const char *name,
3188 struct output_source_filename_data *data)
c94fdfd0
EZ
3189{
3190 /* Since a single source file can result in several partial symbol
3191 tables, we need to avoid printing it more than once. Note: if
3192 some of the psymtabs are read in and some are not, it gets
3193 printed both under "Source files for which symbols have been
3194 read" and "Source files for which symbols will be read in on
3195 demand". I consider this a reasonable way to deal with the
3196 situation. I'm not sure whether this can also happen for
3197 symtabs; it doesn't hurt to check. */
3198
3199 /* Was NAME already seen? */
9fdc877b 3200 if (filename_seen (data->filename_seen_cache, name, 1))
c94fdfd0
EZ
3201 {
3202 /* Yes; don't print it again. */
3203 return;
3204 }
9fdc877b 3205
c94fdfd0 3206 /* No; print it and reset *FIRST. */
9fdc877b
DE
3207 if (! data->first)
3208 printf_filtered (", ");
3209 data->first = 0;
c906108c
SS
3210
3211 wrap_here ("");
3212 fputs_filtered (name, gdb_stdout);
c5aa993b 3213}
c906108c 3214
ccefe4c4 3215/* A callback for map_partial_symbol_filenames. */
eca864fe 3216
ccefe4c4 3217static void
533a737e 3218output_partial_symbol_filename (const char *filename, const char *fullname,
ccefe4c4
TT
3219 void *data)
3220{
3221 output_source_filename (fullname ? fullname : filename, data);
3222}
3223
c906108c 3224static void
fba45db2 3225sources_info (char *ignore, int from_tty)
c906108c 3226{
52f0bd74 3227 struct symtab *s;
52f0bd74 3228 struct objfile *objfile;
9fdc877b
DE
3229 struct output_source_filename_data data;
3230 struct cleanup *cleanups;
c5aa993b 3231
c906108c
SS
3232 if (!have_full_symbols () && !have_partial_symbols ())
3233 {
8a3fe4f8 3234 error (_("No symbol table is loaded. Use the \"file\" command."));
c906108c 3235 }
c5aa993b 3236
9fdc877b
DE
3237 data.filename_seen_cache = create_filename_seen_cache ();
3238 cleanups = make_cleanup (delete_filename_seen_cache,
3239 data.filename_seen_cache);
3240
c906108c
SS
3241 printf_filtered ("Source files for which symbols have been read in:\n\n");
3242
9fdc877b 3243 data.first = 1;
c906108c 3244 ALL_SYMTABS (objfile, s)
c5aa993b 3245 {
d092d1a2 3246 const char *fullname = symtab_to_fullname (s);
433759f7 3247
f35a17b5 3248 output_source_filename (fullname, &data);
c5aa993b 3249 }
c906108c 3250 printf_filtered ("\n\n");
c5aa993b 3251
3e43a32a
MS
3252 printf_filtered ("Source files for which symbols "
3253 "will be read in on demand:\n\n");
c906108c 3254
9fdc877b
DE
3255 clear_filename_seen_cache (data.filename_seen_cache);
3256 data.first = 1;
3257 map_partial_symbol_filenames (output_partial_symbol_filename, &data,
74e2f255 3258 1 /*need_fullname*/);
c906108c 3259 printf_filtered ("\n");
9fdc877b
DE
3260
3261 do_cleanups (cleanups);
c906108c
SS
3262}
3263
fbd9ab74
JK
3264/* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
3265 non-zero compare only lbasename of FILES. */
3266
c906108c 3267static int
fbd9ab74 3268file_matches (const char *file, char *files[], int nfiles, int basenames)
c906108c
SS
3269{
3270 int i;
3271
3272 if (file != NULL && nfiles != 0)
3273 {
3274 for (i = 0; i < nfiles; i++)
c5aa993b 3275 {
fbd9ab74
JK
3276 if (compare_filenames_for_search (file, (basenames
3277 ? lbasename (files[i])
3278 : files[i])))
c5aa993b
JM
3279 return 1;
3280 }
c906108c
SS
3281 }
3282 else if (nfiles == 0)
3283 return 1;
3284 return 0;
3285}
3286
c378eb4e 3287/* Free any memory associated with a search. */
eca864fe 3288
c906108c 3289void
fba45db2 3290free_search_symbols (struct symbol_search *symbols)
c906108c
SS
3291{
3292 struct symbol_search *p;
3293 struct symbol_search *next;
3294
3295 for (p = symbols; p != NULL; p = next)
3296 {
3297 next = p->next;
b8c9b27d 3298 xfree (p);
c906108c
SS
3299 }
3300}
3301
5bd98722
AC
3302static void
3303do_free_search_symbols_cleanup (void *symbols)
3304{
3305 free_search_symbols (symbols);
3306}
3307
3308struct cleanup *
3309make_cleanup_free_search_symbols (struct symbol_search *symbols)
3310{
3311 return make_cleanup (do_free_search_symbols_cleanup, symbols);
3312}
3313
434d2d4f
DJ
3314/* Helper function for sort_search_symbols and qsort. Can only
3315 sort symbols, not minimal symbols. */
eca864fe 3316
434d2d4f
DJ
3317static int
3318compare_search_syms (const void *sa, const void *sb)
3319{
3320 struct symbol_search **sym_a = (struct symbol_search **) sa;
3321 struct symbol_search **sym_b = (struct symbol_search **) sb;
3322
de5ad195
DC
3323 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
3324 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
434d2d4f
DJ
3325}
3326
3327/* Sort the ``nfound'' symbols in the list after prevtail. Leave
3328 prevtail where it is, but update its next pointer to point to
3329 the first of the sorted symbols. */
eca864fe 3330
434d2d4f
DJ
3331static struct symbol_search *
3332sort_search_symbols (struct symbol_search *prevtail, int nfound)
3333{
3334 struct symbol_search **symbols, *symp, *old_next;
3335 int i;
3336
3337 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
3338 * nfound);
3339 symp = prevtail->next;
3340 for (i = 0; i < nfound; i++)
3341 {
3342 symbols[i] = symp;
3343 symp = symp->next;
3344 }
3345 /* Generally NULL. */
3346 old_next = symp;
3347
3348 qsort (symbols, nfound, sizeof (struct symbol_search *),
3349 compare_search_syms);
3350
3351 symp = prevtail;
3352 for (i = 0; i < nfound; i++)
3353 {
3354 symp->next = symbols[i];
3355 symp = symp->next;
3356 }
3357 symp->next = old_next;
3358
8ed32cc0 3359 xfree (symbols);
434d2d4f
DJ
3360 return symp;
3361}
5bd98722 3362
ccefe4c4
TT
3363/* An object of this type is passed as the user_data to the
3364 expand_symtabs_matching method. */
3365struct search_symbols_data
3366{
3367 int nfiles;
3368 char **files;
681bf369
JK
3369
3370 /* It is true if PREG contains valid data, false otherwise. */
3371 unsigned preg_p : 1;
3372 regex_t preg;
ccefe4c4
TT
3373};
3374
3375/* A callback for expand_symtabs_matching. */
eca864fe 3376
ccefe4c4 3377static int
fbd9ab74
JK
3378search_symbols_file_matches (const char *filename, void *user_data,
3379 int basenames)
ccefe4c4
TT
3380{
3381 struct search_symbols_data *data = user_data;
433759f7 3382
fbd9ab74 3383 return file_matches (filename, data->files, data->nfiles, basenames);
ccefe4c4
TT
3384}
3385
3386/* A callback for expand_symtabs_matching. */
eca864fe 3387
ccefe4c4 3388static int
e078317b 3389search_symbols_name_matches (const char *symname, void *user_data)
ccefe4c4
TT
3390{
3391 struct search_symbols_data *data = user_data;
433759f7 3392
681bf369 3393 return !data->preg_p || regexec (&data->preg, symname, 0, NULL, 0) == 0;
ccefe4c4
TT
3394}
3395
c906108c
SS
3396/* Search the symbol table for matches to the regular expression REGEXP,
3397 returning the results in *MATCHES.
3398
3399 Only symbols of KIND are searched:
e8930875
JK
3400 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3401 and constants (enums)
176620f1
EZ
3402 FUNCTIONS_DOMAIN - search all functions
3403 TYPES_DOMAIN - search all type names
7b08b9eb 3404 ALL_DOMAIN - an internal error for this function
c906108c
SS
3405
3406 free_search_symbols should be called when *MATCHES is no longer needed.
434d2d4f
DJ
3407
3408 The results are sorted locally; each symtab's global and static blocks are
c378eb4e
MS
3409 separately alphabetized. */
3410
c906108c 3411void
8903c50d
TT
3412search_symbols (char *regexp, enum search_domain kind,
3413 int nfiles, char *files[],
fd118b61 3414 struct symbol_search **matches)
c906108c 3415{
52f0bd74 3416 struct symtab *s;
52f0bd74 3417 struct blockvector *bv;
52f0bd74
AC
3418 struct block *b;
3419 int i = 0;
8157b174 3420 struct block_iterator iter;
52f0bd74 3421 struct symbol *sym;
c906108c
SS
3422 struct objfile *objfile;
3423 struct minimal_symbol *msymbol;
c906108c 3424 int found_misc = 0;
bc043ef3 3425 static const enum minimal_symbol_type types[]
e8930875 3426 = {mst_data, mst_text, mst_abs};
bc043ef3 3427 static const enum minimal_symbol_type types2[]
e8930875 3428 = {mst_bss, mst_file_text, mst_abs};
bc043ef3 3429 static const enum minimal_symbol_type types3[]
e8930875 3430 = {mst_file_data, mst_solib_trampoline, mst_abs};
bc043ef3 3431 static const enum minimal_symbol_type types4[]
e8930875 3432 = {mst_file_bss, mst_text_gnu_ifunc, mst_abs};
c906108c
SS
3433 enum minimal_symbol_type ourtype;
3434 enum minimal_symbol_type ourtype2;
3435 enum minimal_symbol_type ourtype3;
3436 enum minimal_symbol_type ourtype4;
3437 struct symbol_search *sr;
3438 struct symbol_search *psr;
3439 struct symbol_search *tail;
ccefe4c4 3440 struct search_symbols_data datum;
c906108c 3441
681bf369
JK
3442 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3443 CLEANUP_CHAIN is freed only in the case of an error. */
3444 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
3445 struct cleanup *retval_chain;
3446
e8930875
JK
3447 gdb_assert (kind <= TYPES_DOMAIN);
3448
8903c50d
TT
3449 ourtype = types[kind];
3450 ourtype2 = types2[kind];
3451 ourtype3 = types3[kind];
3452 ourtype4 = types4[kind];
c906108c
SS
3453
3454 sr = *matches = NULL;
3455 tail = NULL;
681bf369 3456 datum.preg_p = 0;
c906108c
SS
3457
3458 if (regexp != NULL)
3459 {
3460 /* Make sure spacing is right for C++ operators.
3461 This is just a courtesy to make the matching less sensitive
3462 to how many spaces the user leaves between 'operator'
c378eb4e 3463 and <TYPENAME> or <OPERATOR>. */
c906108c
SS
3464 char *opend;
3465 char *opname = operator_chars (regexp, &opend);
681bf369 3466 int errcode;
433759f7 3467
c906108c 3468 if (*opname)
c5aa993b 3469 {
3e43a32a
MS
3470 int fix = -1; /* -1 means ok; otherwise number of
3471 spaces needed. */
433759f7 3472
c5aa993b
JM
3473 if (isalpha (*opname) || *opname == '_' || *opname == '$')
3474 {
c378eb4e 3475 /* There should 1 space between 'operator' and 'TYPENAME'. */
c5aa993b
JM
3476 if (opname[-1] != ' ' || opname[-2] == ' ')
3477 fix = 1;
3478 }
3479 else
3480 {
c378eb4e 3481 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
c5aa993b
JM
3482 if (opname[-1] == ' ')
3483 fix = 0;
3484 }
c378eb4e 3485 /* If wrong number of spaces, fix it. */
c5aa993b
JM
3486 if (fix >= 0)
3487 {
045f55a6 3488 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
433759f7 3489
c5aa993b
JM
3490 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
3491 regexp = tmp;
3492 }
3493 }
3494
559a7a62
JK
3495 errcode = regcomp (&datum.preg, regexp,
3496 REG_NOSUB | (case_sensitivity == case_sensitive_off
3497 ? REG_ICASE : 0));
681bf369
JK
3498 if (errcode != 0)
3499 {
3500 char *err = get_regcomp_error (errcode, &datum.preg);
3501
3502 make_cleanup (xfree, err);
3503 error (_("Invalid regexp (%s): %s"), err, regexp);
3504 }
3505 datum.preg_p = 1;
3506 make_regfree_cleanup (&datum.preg);
c906108c
SS
3507 }
3508
3509 /* Search through the partial symtabs *first* for all symbols
3510 matching the regexp. That way we don't have to reproduce all of
c378eb4e 3511 the machinery below. */
c906108c 3512
ccefe4c4
TT
3513 datum.nfiles = nfiles;
3514 datum.files = files;
ccefe4c4 3515 ALL_OBJFILES (objfile)
c5aa993b 3516 {
ccefe4c4
TT
3517 if (objfile->sf)
3518 objfile->sf->qf->expand_symtabs_matching (objfile,
71cddcc1
DE
3519 (nfiles == 0
3520 ? NULL
3521 : search_symbols_file_matches),
ccefe4c4
TT
3522 search_symbols_name_matches,
3523 kind,
3524 &datum);
c5aa993b 3525 }
c906108c 3526
681bf369
JK
3527 retval_chain = old_chain;
3528
c906108c
SS
3529 /* Here, we search through the minimal symbol tables for functions
3530 and variables that match, and force their symbols to be read.
3531 This is in particular necessary for demangled variable names,
3532 which are no longer put into the partial symbol tables.
3533 The symbol will then be found during the scan of symtabs below.
3534
3535 For functions, find_pc_symtab should succeed if we have debug info
422d65e7
DE
3536 for the function, for variables we have to call
3537 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3538 has debug info.
c906108c 3539 If the lookup fails, set found_misc so that we will rescan to print
422d65e7
DE
3540 any matching symbols without debug info.
3541 We only search the objfile the msymbol came from, we no longer search
3542 all objfiles. In large programs (1000s of shared libs) searching all
3543 objfiles is not worth the pain. */
c906108c 3544
176620f1 3545 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
c906108c
SS
3546 {
3547 ALL_MSYMBOLS (objfile, msymbol)
c5aa993b 3548 {
89295b4d
PP
3549 QUIT;
3550
422d65e7
DE
3551 if (msymbol->created_by_gdb)
3552 continue;
3553
d50bd42b
DE
3554 if (MSYMBOL_TYPE (msymbol) == ourtype
3555 || MSYMBOL_TYPE (msymbol) == ourtype2
3556 || MSYMBOL_TYPE (msymbol) == ourtype3
3557 || MSYMBOL_TYPE (msymbol) == ourtype4)
c5aa993b 3558 {
681bf369
JK
3559 if (!datum.preg_p
3560 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3561 NULL, 0) == 0)
c5aa993b 3562 {
422d65e7
DE
3563 /* Note: An important side-effect of these lookup functions
3564 is to expand the symbol table if msymbol is found, for the
3565 benefit of the next loop on ALL_PRIMARY_SYMTABS. */
3566 if (kind == FUNCTIONS_DOMAIN
3567 ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL
3568 : (lookup_symbol_in_objfile_from_linkage_name
3569 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3570 == NULL))
3571 found_misc = 1;
c5aa993b
JM
3572 }
3573 }
3574 }
c906108c
SS
3575 }
3576
11309657 3577 ALL_PRIMARY_SYMTABS (objfile, s)
c5aa993b
JM
3578 {
3579 bv = BLOCKVECTOR (s);
d50bd42b
DE
3580 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3581 {
3582 struct symbol_search *prevtail = tail;
3583 int nfound = 0;
433759f7 3584
d50bd42b
DE
3585 b = BLOCKVECTOR_BLOCK (bv, i);
3586 ALL_BLOCK_SYMBOLS (b, iter, sym)
3587 {
3588 struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
3589
3590 QUIT;
3591
fbd9ab74
JK
3592 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
3593 a substring of symtab_to_fullname as it may contain "./" etc. */
3594 if ((file_matches (real_symtab->filename, files, nfiles, 0)
3595 || ((basenames_may_differ
3596 || file_matches (lbasename (real_symtab->filename),
3597 files, nfiles, 1))
3598 && file_matches (symtab_to_fullname (real_symtab),
3599 files, nfiles, 0)))
d50bd42b
DE
3600 && ((!datum.preg_p
3601 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (sym), 0,
3602 NULL, 0) == 0)
3603 && ((kind == VARIABLES_DOMAIN
3604 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3605 && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
3606 && SYMBOL_CLASS (sym) != LOC_BLOCK
3607 /* LOC_CONST can be used for more than just enums,
3608 e.g., c++ static const members.
3609 We only want to skip enums here. */
3610 && !(SYMBOL_CLASS (sym) == LOC_CONST
3611 && TYPE_CODE (SYMBOL_TYPE (sym))
3612 == TYPE_CODE_ENUM))
3613 || (kind == FUNCTIONS_DOMAIN
3614 && SYMBOL_CLASS (sym) == LOC_BLOCK)
3615 || (kind == TYPES_DOMAIN
3616 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
3617 {
3618 /* match */
3619 psr = (struct symbol_search *)
3620 xmalloc (sizeof (struct symbol_search));
3621 psr->block = i;
3622 psr->symtab = real_symtab;
3623 psr->symbol = sym;
3624 psr->msymbol = NULL;
3625 psr->next = NULL;
3626 if (tail == NULL)
3627 sr = psr;
3628 else
3629 tail->next = psr;
3630 tail = psr;
3631 nfound ++;
3632 }
3633 }
3634 if (nfound > 0)
3635 {
3636 if (prevtail == NULL)
3637 {
3638 struct symbol_search dummy;
434d2d4f 3639
d50bd42b
DE
3640 dummy.next = sr;
3641 tail = sort_search_symbols (&dummy, nfound);
3642 sr = dummy.next;
434d2d4f 3643
d50bd42b
DE
3644 make_cleanup_free_search_symbols (sr);
3645 }
3646 else
3647 tail = sort_search_symbols (prevtail, nfound);
3648 }
3649 }
c5aa993b 3650 }
c906108c
SS
3651
3652 /* If there are no eyes, avoid all contact. I mean, if there are
3653 no debug symbols, then print directly from the msymbol_vector. */
3654
422d65e7 3655 if (found_misc || (nfiles == 0 && kind != FUNCTIONS_DOMAIN))
c906108c
SS
3656 {
3657 ALL_MSYMBOLS (objfile, msymbol)
c5aa993b 3658 {
89295b4d
PP
3659 QUIT;
3660
422d65e7
DE
3661 if (msymbol->created_by_gdb)
3662 continue;
3663
d50bd42b
DE
3664 if (MSYMBOL_TYPE (msymbol) == ourtype
3665 || MSYMBOL_TYPE (msymbol) == ourtype2
3666 || MSYMBOL_TYPE (msymbol) == ourtype3
3667 || MSYMBOL_TYPE (msymbol) == ourtype4)
c5aa993b 3668 {
681bf369
JK
3669 if (!datum.preg_p
3670 || regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
3671 NULL, 0) == 0)
c5aa993b 3672 {
422d65e7
DE
3673 /* For functions we can do a quick check of whether the
3674 symbol might be found via find_pc_symtab. */
3675 if (kind != FUNCTIONS_DOMAIN
3676 || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
c5aa993b 3677 {
422d65e7
DE
3678 if (lookup_symbol_in_objfile_from_linkage_name
3679 (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
3680 == NULL)
c5aa993b
JM
3681 {
3682 /* match */
3e43a32a
MS
3683 psr = (struct symbol_search *)
3684 xmalloc (sizeof (struct symbol_search));
c5aa993b
JM
3685 psr->block = i;
3686 psr->msymbol = msymbol;
3687 psr->symtab = NULL;
3688 psr->symbol = NULL;
3689 psr->next = NULL;
3690 if (tail == NULL)
3691 {
3692 sr = psr;
681bf369 3693 make_cleanup_free_search_symbols (sr);
c5aa993b
JM
3694 }
3695 else
3696 tail->next = psr;
3697 tail = psr;
3698 }
3699 }
3700 }
3701 }
3702 }
c906108c
SS
3703 }
3704
681bf369
JK
3705 discard_cleanups (retval_chain);
3706 do_cleanups (old_chain);
c906108c 3707 *matches = sr;
c906108c
SS
3708}
3709
3710/* Helper function for symtab_symbol_info, this function uses
3711 the data returned from search_symbols() to print information
c378eb4e
MS
3712 regarding the match to gdb_stdout. */
3713
c906108c 3714static void
8903c50d
TT
3715print_symbol_info (enum search_domain kind,
3716 struct symtab *s, struct symbol *sym,
05cba821 3717 int block, const char *last)
c906108c 3718{
05cba821
JK
3719 const char *s_filename = symtab_to_filename_for_display (s);
3720
3721 if (last == NULL || filename_cmp (last, s_filename) != 0)
c906108c
SS
3722 {
3723 fputs_filtered ("\nFile ", gdb_stdout);
05cba821 3724 fputs_filtered (s_filename, gdb_stdout);
c906108c
SS
3725 fputs_filtered (":\n", gdb_stdout);
3726 }
3727
176620f1 3728 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
c906108c 3729 printf_filtered ("static ");
c5aa993b 3730
c378eb4e 3731 /* Typedef that is not a C++ class. */
176620f1
EZ
3732 if (kind == TYPES_DOMAIN
3733 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
a5238fbc 3734 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
c378eb4e 3735 /* variable, func, or typedef-that-is-c++-class. */
d50bd42b
DE
3736 else if (kind < TYPES_DOMAIN
3737 || (kind == TYPES_DOMAIN
3738 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
c906108c
SS
3739 {
3740 type_print (SYMBOL_TYPE (sym),
c5aa993b 3741 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
de5ad195 3742 ? "" : SYMBOL_PRINT_NAME (sym)),
c5aa993b 3743 gdb_stdout, 0);
c906108c
SS
3744
3745 printf_filtered (";\n");
3746 }
c906108c
SS
3747}
3748
3749/* This help function for symtab_symbol_info() prints information
c378eb4e
MS
3750 for non-debugging symbols to gdb_stdout. */
3751
c906108c 3752static void
fba45db2 3753print_msymbol_info (struct minimal_symbol *msymbol)
c906108c 3754{
d80b854b 3755 struct gdbarch *gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
3ac4495a
MS
3756 char *tmp;
3757
d80b854b 3758 if (gdbarch_addr_bit (gdbarch) <= 32)
bb599908
PH
3759 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3760 & (CORE_ADDR) 0xffffffff,
3761 8);
3ac4495a 3762 else
bb599908
PH
3763 tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3764 16);
3ac4495a 3765 printf_filtered ("%s %s\n",
de5ad195 3766 tmp, SYMBOL_PRINT_NAME (msymbol));
c906108c
SS
3767}
3768
3769/* This is the guts of the commands "info functions", "info types", and
c378eb4e 3770 "info variables". It calls search_symbols to find all matches and then
c906108c 3771 print_[m]symbol_info to print out some useful information about the
c378eb4e
MS
3772 matches. */
3773
c906108c 3774static void
8903c50d 3775symtab_symbol_info (char *regexp, enum search_domain kind, int from_tty)
c906108c 3776{
bc043ef3 3777 static const char * const classnames[] =
e8930875 3778 {"variable", "function", "type"};
c906108c
SS
3779 struct symbol_search *symbols;
3780 struct symbol_search *p;
3781 struct cleanup *old_chain;
05cba821 3782 const char *last_filename = NULL;
c906108c
SS
3783 int first = 1;
3784
e8930875
JK
3785 gdb_assert (kind <= TYPES_DOMAIN);
3786
c378eb4e 3787 /* Must make sure that if we're interrupted, symbols gets freed. */
c906108c 3788 search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
5bd98722 3789 old_chain = make_cleanup_free_search_symbols (symbols);
c906108c 3790
ca242aad
YQ
3791 if (regexp != NULL)
3792 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3793 classnames[kind], regexp);
3794 else
3795 printf_filtered (_("All defined %ss:\n"), classnames[kind]);
c906108c
SS
3796
3797 for (p = symbols; p != NULL; p = p->next)
3798 {
3799 QUIT;
3800
3801 if (p->msymbol != NULL)
c5aa993b
JM
3802 {
3803 if (first)
3804 {
ca242aad 3805 printf_filtered (_("\nNon-debugging symbols:\n"));
c5aa993b
JM
3806 first = 0;
3807 }
3808 print_msymbol_info (p->msymbol);
3809 }
c906108c 3810 else
c5aa993b
JM
3811 {
3812 print_symbol_info (kind,
3813 p->symtab,
3814 p->symbol,
3815 p->block,
3816 last_filename);
05cba821 3817 last_filename = symtab_to_filename_for_display (p->symtab);
c5aa993b 3818 }
c906108c
SS
3819 }
3820
3821 do_cleanups (old_chain);
3822}
3823
3824static void
fba45db2 3825variables_info (char *regexp, int from_tty)
c906108c 3826{
176620f1 3827 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
c906108c
SS
3828}
3829
3830static void
fba45db2 3831functions_info (char *regexp, int from_tty)
c906108c 3832{
176620f1 3833 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
c906108c
SS
3834}
3835
357e46e7 3836
c906108c 3837static void
fba45db2 3838types_info (char *regexp, int from_tty)
c906108c 3839{
176620f1 3840 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
c906108c
SS
3841}
3842
c378eb4e 3843/* Breakpoint all functions matching regular expression. */
8926118c 3844
8b93c638 3845void
fba45db2 3846rbreak_command_wrapper (char *regexp, int from_tty)
8b93c638
JM
3847{
3848 rbreak_command (regexp, from_tty);
3849}
8926118c 3850
95a42b64
TT
3851/* A cleanup function that calls end_rbreak_breakpoints. */
3852
3853static void
3854do_end_rbreak_breakpoints (void *ignore)
3855{
3856 end_rbreak_breakpoints ();
3857}
3858
c906108c 3859static void
fba45db2 3860rbreak_command (char *regexp, int from_tty)
c906108c
SS
3861{
3862 struct symbol_search *ss;
3863 struct symbol_search *p;
3864 struct cleanup *old_chain;
95a42b64
TT
3865 char *string = NULL;
3866 int len = 0;
9c1e305a 3867 char **files = NULL, *file_name;
8bd10a10 3868 int nfiles = 0;
c906108c 3869
8bd10a10
CM
3870 if (regexp)
3871 {
3872 char *colon = strchr (regexp, ':');
433759f7 3873
8bd10a10
CM
3874 if (colon && *(colon + 1) != ':')
3875 {
3876 int colon_index;
8bd10a10
CM
3877
3878 colon_index = colon - regexp;
3879 file_name = alloca (colon_index + 1);
3880 memcpy (file_name, regexp, colon_index);
3881 file_name[colon_index--] = 0;
3882 while (isspace (file_name[colon_index]))
3883 file_name[colon_index--] = 0;
3884 files = &file_name;
3885 nfiles = 1;
529480d0 3886 regexp = skip_spaces (colon + 1);
8bd10a10
CM
3887 }
3888 }
3889
3890 search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
5bd98722 3891 old_chain = make_cleanup_free_search_symbols (ss);
95a42b64 3892 make_cleanup (free_current_contents, &string);
c906108c 3893
95a42b64
TT
3894 start_rbreak_breakpoints ();
3895 make_cleanup (do_end_rbreak_breakpoints, NULL);
c906108c
SS
3896 for (p = ss; p != NULL; p = p->next)
3897 {
3898 if (p->msymbol == NULL)
c5aa993b 3899 {
05cba821
JK
3900 const char *fullname = symtab_to_fullname (p->symtab);
3901
3902 int newlen = (strlen (fullname)
95a42b64
TT
3903 + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
3904 + 4);
433759f7 3905
95a42b64
TT
3906 if (newlen > len)
3907 {
3908 string = xrealloc (string, newlen);
3909 len = newlen;
3910 }
05cba821 3911 strcpy (string, fullname);
c5aa993b 3912 strcat (string, ":'");
2335f48e 3913 strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
c5aa993b
JM
3914 strcat (string, "'");
3915 break_command (string, from_tty);
176620f1 3916 print_symbol_info (FUNCTIONS_DOMAIN,
c5aa993b
JM
3917 p->symtab,
3918 p->symbol,
3919 p->block,
05cba821 3920 symtab_to_filename_for_display (p->symtab));
c5aa993b 3921 }
c906108c 3922 else
c5aa993b 3923 {
433759f7
MS
3924 int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
3925
95a42b64
TT
3926 if (newlen > len)
3927 {
3928 string = xrealloc (string, newlen);
3929 len = newlen;
3930 }
6214f497
DJ
3931 strcpy (string, "'");
3932 strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol));
3933 strcat (string, "'");
3934
3935 break_command (string, from_tty);
c5aa993b 3936 printf_filtered ("<function, no debug info> %s;\n",
de5ad195 3937 SYMBOL_PRINT_NAME (p->msymbol));
c5aa993b 3938 }
c906108c
SS
3939 }
3940
3941 do_cleanups (old_chain);
3942}
c906108c 3943\f
c5aa993b 3944
1976171a
JK
3945/* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3946
3947 Either sym_text[sym_text_len] != '(' and then we search for any
3948 symbol starting with SYM_TEXT text.
3949
3950 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3951 be terminated at that point. Partial symbol tables do not have parameters
3952 information. */
3953
3954static int
3955compare_symbol_name (const char *name, const char *sym_text, int sym_text_len)
3956{
3957 int (*ncmp) (const char *, const char *, size_t);
3958
3959 ncmp = (case_sensitivity == case_sensitive_on ? strncmp : strncasecmp);
3960
3961 if (ncmp (name, sym_text, sym_text_len) != 0)
3962 return 0;
3963
3964 if (sym_text[sym_text_len] == '(')
3965 {
3966 /* User searches for `name(someth...'. Require NAME to be terminated.
3967 Normally psymtabs and gdbindex have no parameter types so '\0' will be
3968 present but accept even parameters presence. In this case this
3969 function is in fact strcmp_iw but whitespace skipping is not supported
3970 for tab completion. */
3971
3972 if (name[sym_text_len] != '\0' && name[sym_text_len] != '(')
3973 return 0;
3974 }
3975
3976 return 1;
3977}
3978
821296b7
SA
3979/* Free any memory associated with a completion list. */
3980
3981static void
49c4e619 3982free_completion_list (VEC (char_ptr) **list_ptr)
821296b7 3983{
49c4e619
TT
3984 int i;
3985 char *p;
821296b7 3986
49c4e619
TT
3987 for (i = 0; VEC_iterate (char_ptr, *list_ptr, i, p); ++i)
3988 xfree (p);
3989 VEC_free (char_ptr, *list_ptr);
821296b7
SA
3990}
3991
3992/* Callback for make_cleanup. */
3993
3994static void
3995do_free_completion_list (void *list)
3996{
3997 free_completion_list (list);
3998}
3999
c906108c
SS
4000/* Helper routine for make_symbol_completion_list. */
4001
49c4e619 4002static VEC (char_ptr) *return_val;
c906108c
SS
4003
4004#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
c906108c 4005 completion_list_add_name \
2335f48e 4006 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
c906108c
SS
4007
4008/* Test to see if the symbol specified by SYMNAME (which is already
c5aa993b 4009 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
c378eb4e 4010 characters. If so, add it to the current completion list. */
c906108c
SS
4011
4012static void
0d5cff50
DE
4013completion_list_add_name (const char *symname,
4014 const char *sym_text, int sym_text_len,
4015 const char *text, const char *word)
c906108c 4016{
c378eb4e 4017 /* Clip symbols that cannot match. */
1976171a
JK
4018 if (!compare_symbol_name (symname, sym_text, sym_text_len))
4019 return;
c906108c 4020
c906108c 4021 /* We have a match for a completion, so add SYMNAME to the current list
c378eb4e 4022 of matches. Note that the name is moved to freshly malloc'd space. */
c906108c
SS
4023
4024 {
4025 char *new;
433759f7 4026
c906108c
SS
4027 if (word == sym_text)
4028 {
4029 new = xmalloc (strlen (symname) + 5);
4030 strcpy (new, symname);
4031 }
4032 else if (word > sym_text)
4033 {
4034 /* Return some portion of symname. */
4035 new = xmalloc (strlen (symname) + 5);
4036 strcpy (new, symname + (word - sym_text));
4037 }
4038 else
4039 {
4040 /* Return some of SYM_TEXT plus symname. */
4041 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
4042 strncpy (new, word, sym_text - word);
4043 new[sym_text - word] = '\0';
4044 strcat (new, symname);
4045 }
4046
49c4e619 4047 VEC_safe_push (char_ptr, return_val, new);
c906108c
SS
4048 }
4049}
4050
69636828
AF
4051/* ObjC: In case we are completing on a selector, look as the msymbol
4052 again and feed all the selectors into the mill. */
4053
4054static void
0d5cff50
DE
4055completion_list_objc_symbol (struct minimal_symbol *msymbol,
4056 const char *sym_text, int sym_text_len,
4057 const char *text, const char *word)
69636828
AF
4058{
4059 static char *tmp = NULL;
4060 static unsigned int tmplen = 0;
9af17804 4061
0d5cff50 4062 const char *method, *category, *selector;
69636828 4063 char *tmp2 = NULL;
9af17804 4064
69636828
AF
4065 method = SYMBOL_NATURAL_NAME (msymbol);
4066
4067 /* Is it a method? */
4068 if ((method[0] != '-') && (method[0] != '+'))
4069 return;
4070
4071 if (sym_text[0] == '[')
4072 /* Complete on shortened method method. */
4073 completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
9af17804 4074
69636828
AF
4075 while ((strlen (method) + 1) >= tmplen)
4076 {
4077 if (tmplen == 0)
4078 tmplen = 1024;
4079 else
4080 tmplen *= 2;
4081 tmp = xrealloc (tmp, tmplen);
4082 }
4083 selector = strchr (method, ' ');
4084 if (selector != NULL)
4085 selector++;
9af17804 4086
69636828 4087 category = strchr (method, '(');
9af17804 4088
69636828
AF
4089 if ((category != NULL) && (selector != NULL))
4090 {
4091 memcpy (tmp, method, (category - method));
4092 tmp[category - method] = ' ';
4093 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
4094 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4095 if (sym_text[0] == '[')
4096 completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
4097 }
9af17804 4098
69636828
AF
4099 if (selector != NULL)
4100 {
4101 /* Complete on selector only. */
4102 strcpy (tmp, selector);
4103 tmp2 = strchr (tmp, ']');
4104 if (tmp2 != NULL)
4105 *tmp2 = '\0';
9af17804 4106
69636828
AF
4107 completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
4108 }
4109}
4110
4111/* Break the non-quoted text based on the characters which are in
c378eb4e 4112 symbols. FIXME: This should probably be language-specific. */
69636828 4113
6f937416
PA
4114static const char *
4115language_search_unquoted_string (const char *text, const char *p)
69636828
AF
4116{
4117 for (; p > text; --p)
4118 {
4119 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
4120 continue;
4121 else
4122 {
4123 if ((current_language->la_language == language_objc))
4124 {
c378eb4e 4125 if (p[-1] == ':') /* Might be part of a method name. */
69636828
AF
4126 continue;
4127 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+'))
c378eb4e 4128 p -= 2; /* Beginning of a method name. */
69636828 4129 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')')
c378eb4e 4130 { /* Might be part of a method name. */
6f937416 4131 const char *t = p;
69636828
AF
4132
4133 /* Seeing a ' ' or a '(' is not conclusive evidence
4134 that we are in the middle of a method name. However,
4135 finding "-[" or "+[" should be pretty un-ambiguous.
4136 Unfortunately we have to find it now to decide. */
4137
4138 while (t > text)
4139 if (isalnum (t[-1]) || t[-1] == '_' ||
4140 t[-1] == ' ' || t[-1] == ':' ||
4141 t[-1] == '(' || t[-1] == ')')
4142 --t;
4143 else
4144 break;
4145
4146 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+'))
c378eb4e
MS
4147 p = t - 2; /* Method name detected. */
4148 /* Else we leave with p unchanged. */
69636828
AF
4149 }
4150 }
4151 break;
4152 }
4153 }
4154 return p;
4155}
4156
edb3359d 4157static void
6f937416
PA
4158completion_list_add_fields (struct symbol *sym, const char *sym_text,
4159 int sym_text_len, const char *text,
4160 const char *word)
edb3359d
DJ
4161{
4162 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
4163 {
4164 struct type *t = SYMBOL_TYPE (sym);
4165 enum type_code c = TYPE_CODE (t);
4166 int j;
4167
4168 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
4169 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
4170 if (TYPE_FIELD_NAME (t, j))
4171 completion_list_add_name (TYPE_FIELD_NAME (t, j),
4172 sym_text, sym_text_len, text, word);
4173 }
4174}
4175
ccefe4c4 4176/* Type of the user_data argument passed to add_macro_name or
7b08b9eb 4177 expand_partial_symbol_name. The contents are simply whatever is
ccefe4c4
TT
4178 needed by completion_list_add_name. */
4179struct add_name_data
9a044a89 4180{
6f937416 4181 const char *sym_text;
9a044a89 4182 int sym_text_len;
6f937416
PA
4183 const char *text;
4184 const char *word;
9a044a89
TT
4185};
4186
4187/* A callback used with macro_for_each and macro_for_each_in_scope.
4188 This adds a macro's name to the current completion list. */
eca864fe 4189
9a044a89
TT
4190static void
4191add_macro_name (const char *name, const struct macro_definition *ignore,
9b158ba0 4192 struct macro_source_file *ignore2, int ignore3,
9a044a89
TT
4193 void *user_data)
4194{
ccefe4c4 4195 struct add_name_data *datum = (struct add_name_data *) user_data;
433759f7 4196
ccefe4c4
TT
4197 completion_list_add_name ((char *) name,
4198 datum->sym_text, datum->sym_text_len,
4199 datum->text, datum->word);
4200}
4201
7b08b9eb 4202/* A callback for expand_partial_symbol_names. */
eca864fe 4203
7b08b9eb 4204static int
e078317b 4205expand_partial_symbol_name (const char *name, void *user_data)
ccefe4c4
TT
4206{
4207 struct add_name_data *datum = (struct add_name_data *) user_data;
165195f4 4208
1976171a 4209 return compare_symbol_name (name, datum->sym_text, datum->sym_text_len);
9a044a89
TT
4210}
4211
49c4e619 4212VEC (char_ptr) *
6f937416
PA
4213default_make_symbol_completion_list_break_on (const char *text,
4214 const char *word,
2f68a895
TT
4215 const char *break_on,
4216 enum type_code code)
c906108c 4217{
41d27058
JB
4218 /* Problem: All of the symbols have to be copied because readline
4219 frees them. I'm not going to worry about this; hopefully there
4220 won't be that many. */
4221
de4f826b
DC
4222 struct symbol *sym;
4223 struct symtab *s;
de4f826b
DC
4224 struct minimal_symbol *msymbol;
4225 struct objfile *objfile;
edb3359d
DJ
4226 struct block *b;
4227 const struct block *surrounding_static_block, *surrounding_global_block;
8157b174 4228 struct block_iterator iter;
c906108c 4229 /* The symbol we are completing on. Points in same buffer as text. */
6f937416 4230 const char *sym_text;
c906108c
SS
4231 /* Length of sym_text. */
4232 int sym_text_len;
ccefe4c4 4233 struct add_name_data datum;
821296b7 4234 struct cleanup *back_to;
c906108c 4235
41d27058 4236 /* Now look for the symbol we are supposed to complete on. */
c906108c 4237 {
6f937416 4238 const char *p;
c906108c 4239 char quote_found;
6f937416 4240 const char *quote_pos = NULL;
c906108c
SS
4241
4242 /* First see if this is a quoted string. */
4243 quote_found = '\0';
4244 for (p = text; *p != '\0'; ++p)
4245 {
4246 if (quote_found != '\0')
4247 {
4248 if (*p == quote_found)
4249 /* Found close quote. */
4250 quote_found = '\0';
4251 else if (*p == '\\' && p[1] == quote_found)
4252 /* A backslash followed by the quote character
c5aa993b 4253 doesn't end the string. */
c906108c
SS
4254 ++p;
4255 }
4256 else if (*p == '\'' || *p == '"')
4257 {
4258 quote_found = *p;
4259 quote_pos = p;
4260 }
4261 }
4262 if (quote_found == '\'')
4263 /* A string within single quotes can be a symbol, so complete on it. */
4264 sym_text = quote_pos + 1;
4265 else if (quote_found == '"')
4266 /* A double-quoted string is never a symbol, nor does it make sense
c5aa993b 4267 to complete it any other way. */
c94fdfd0 4268 {
49c4e619 4269 return NULL;
c94fdfd0 4270 }
c906108c
SS
4271 else
4272 {
4273 /* It is not a quoted string. Break it based on the characters
4274 which are in symbols. */
4275 while (p > text)
4276 {
95699ff0 4277 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0'
f55ee35c 4278 || p[-1] == ':' || strchr (break_on, p[-1]) != NULL)
c906108c
SS
4279 --p;
4280 else
4281 break;
4282 }
4283 sym_text = p;
4284 }
4285 }
4286
4287 sym_text_len = strlen (sym_text);
4288
1976171a
JK
4289 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4290
4291 if (current_language->la_language == language_cplus
4292 || current_language->la_language == language_java
4293 || current_language->la_language == language_fortran)
4294 {
4295 /* These languages may have parameters entered by user but they are never
4296 present in the partial symbol tables. */
4297
4298 const char *cs = memchr (sym_text, '(', sym_text_len);
4299
4300 if (cs)
4301 sym_text_len = cs - sym_text;
4302 }
4303 gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
4304
49c4e619 4305 return_val = NULL;
821296b7 4306 back_to = make_cleanup (do_free_completion_list, &return_val);
c906108c 4307
ccefe4c4
TT
4308 datum.sym_text = sym_text;
4309 datum.sym_text_len = sym_text_len;
4310 datum.text = text;
4311 datum.word = word;
4312
c906108c 4313 /* Look through the partial symtabs for all symbols which begin
7b08b9eb
JK
4314 by matching SYM_TEXT. Expand all CUs that you find to the list.
4315 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4316 expand_partial_symbol_names (expand_partial_symbol_name, &datum);
c906108c
SS
4317
4318 /* At this point scan through the misc symbol vectors and add each
4319 symbol you find to the list. Eventually we want to ignore
4320 anything that isn't a text symbol (everything else will be
4321 handled by the psymtab code above). */
4322
2f68a895
TT
4323 if (code == TYPE_CODE_UNDEF)
4324 {
4325 ALL_MSYMBOLS (objfile, msymbol)
4326 {
4327 QUIT;
4328 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
4329 word);
9af17804 4330
2f68a895
TT
4331 completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text,
4332 word);
4333 }
4334 }
c906108c
SS
4335
4336 /* Search upwards from currently selected frame (so that we can
edb3359d
DJ
4337 complete on local vars). Also catch fields of types defined in
4338 this places which match our text string. Only complete on types
c378eb4e 4339 visible from current context. */
edb3359d
DJ
4340
4341 b = get_selected_block (0);
4342 surrounding_static_block = block_static_block (b);
4343 surrounding_global_block = block_global_block (b);
4344 if (surrounding_static_block != NULL)
4345 while (b != surrounding_static_block)
4346 {
4347 QUIT;
c906108c 4348
edb3359d
DJ
4349 ALL_BLOCK_SYMBOLS (b, iter, sym)
4350 {
2f68a895
TT
4351 if (code == TYPE_CODE_UNDEF)
4352 {
4353 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4354 word);
4355 completion_list_add_fields (sym, sym_text, sym_text_len, text,
4356 word);
4357 }
4358 else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4359 && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
4360 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
4361 word);
edb3359d 4362 }
c5aa993b 4363
edb3359d
DJ
4364 /* Stop when we encounter an enclosing function. Do not stop for
4365 non-inlined functions - the locals of the enclosing function
4366 are in scope for a nested function. */
4367 if (BLOCK_FUNCTION (b) != NULL && block_inlined_p (b))
4368 break;
4369 b = BLOCK_SUPERBLOCK (b);
4370 }
c906108c 4371
edb3359d 4372 /* Add fields from the file's types; symbols will be added below. */
c906108c 4373
2f68a895
TT
4374 if (code == TYPE_CODE_UNDEF)
4375 {
4376 if (surrounding_static_block != NULL)
4377 ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
4378 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
edb3359d 4379
2f68a895
TT
4380 if (surrounding_global_block != NULL)
4381 ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
4382 completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
4383 }
c906108c
SS
4384
4385 /* Go through the symtabs and check the externs and statics for
4386 symbols which match. */
4387
11309657 4388 ALL_PRIMARY_SYMTABS (objfile, s)
c5aa993b
JM
4389 {
4390 QUIT;
4391 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
de4f826b 4392 ALL_BLOCK_SYMBOLS (b, iter, sym)
c5aa993b 4393 {
2f68a895
TT
4394 if (code == TYPE_CODE_UNDEF
4395 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4396 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4397 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
c5aa993b
JM
4398 }
4399 }
c906108c 4400
11309657 4401 ALL_PRIMARY_SYMTABS (objfile, s)
c5aa993b
JM
4402 {
4403 QUIT;
4404 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
de4f826b 4405 ALL_BLOCK_SYMBOLS (b, iter, sym)
c5aa993b 4406 {
2f68a895
TT
4407 if (code == TYPE_CODE_UNDEF
4408 || (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
4409 && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
4410 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
c5aa993b
JM
4411 }
4412 }
c906108c 4413
2f68a895
TT
4414 /* Skip macros if we are completing a struct tag -- arguable but
4415 usually what is expected. */
4416 if (current_language->la_macro_expansion == macro_expansion_c
4417 && code == TYPE_CODE_UNDEF)
9a044a89
TT
4418 {
4419 struct macro_scope *scope;
9a044a89
TT
4420
4421 /* Add any macros visible in the default scope. Note that this
4422 may yield the occasional wrong result, because an expression
4423 might be evaluated in a scope other than the default. For
4424 example, if the user types "break file:line if <TAB>", the
4425 resulting expression will be evaluated at "file:line" -- but
4426 at there does not seem to be a way to detect this at
4427 completion time. */
4428 scope = default_macro_scope ();
4429 if (scope)
4430 {
4431 macro_for_each_in_scope (scope->file, scope->line,
4432 add_macro_name, &datum);
4433 xfree (scope);
4434 }
4435
4436 /* User-defined macros are always visible. */
4437 macro_for_each (macro_user_macros, add_macro_name, &datum);
4438 }
4439
821296b7 4440 discard_cleanups (back_to);
c906108c
SS
4441 return (return_val);
4442}
4443
49c4e619 4444VEC (char_ptr) *
6f937416 4445default_make_symbol_completion_list (const char *text, const char *word,
2f68a895 4446 enum type_code code)
f55ee35c 4447{
2f68a895 4448 return default_make_symbol_completion_list_break_on (text, word, "", code);
f55ee35c
JK
4449}
4450
49c4e619
TT
4451/* Return a vector of all symbols (regardless of class) which begin by
4452 matching TEXT. If the answer is no symbols, then the return value
4453 is NULL. */
41d27058 4454
49c4e619 4455VEC (char_ptr) *
6f937416 4456make_symbol_completion_list (const char *text, const char *word)
41d27058 4457{
2f68a895
TT
4458 return current_language->la_make_symbol_completion_list (text, word,
4459 TYPE_CODE_UNDEF);
4460}
4461
4462/* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4463 symbols whose type code is CODE. */
4464
4465VEC (char_ptr) *
6f937416
PA
4466make_symbol_completion_type (const char *text, const char *word,
4467 enum type_code code)
2f68a895
TT
4468{
4469 gdb_assert (code == TYPE_CODE_UNION
4470 || code == TYPE_CODE_STRUCT
4471 || code == TYPE_CODE_CLASS
4472 || code == TYPE_CODE_ENUM);
4473 return current_language->la_make_symbol_completion_list (text, word, code);
41d27058
JB
4474}
4475
d8906c6f
TJB
4476/* Like make_symbol_completion_list, but suitable for use as a
4477 completion function. */
4478
49c4e619 4479VEC (char_ptr) *
d8906c6f 4480make_symbol_completion_list_fn (struct cmd_list_element *ignore,
6f937416 4481 const char *text, const char *word)
d8906c6f
TJB
4482{
4483 return make_symbol_completion_list (text, word);
4484}
4485
c94fdfd0
EZ
4486/* Like make_symbol_completion_list, but returns a list of symbols
4487 defined in a source file FILE. */
4488
49c4e619 4489VEC (char_ptr) *
6f937416
PA
4490make_file_symbol_completion_list (const char *text, const char *word,
4491 const char *srcfile)
c94fdfd0 4492{
52f0bd74
AC
4493 struct symbol *sym;
4494 struct symtab *s;
4495 struct block *b;
8157b174 4496 struct block_iterator iter;
c94fdfd0 4497 /* The symbol we are completing on. Points in same buffer as text. */
6f937416 4498 const char *sym_text;
c94fdfd0
EZ
4499 /* Length of sym_text. */
4500 int sym_text_len;
4501
4502 /* Now look for the symbol we are supposed to complete on.
4503 FIXME: This should be language-specific. */
4504 {
6f937416 4505 const char *p;
c94fdfd0 4506 char quote_found;
6f937416 4507 const char *quote_pos = NULL;
c94fdfd0
EZ
4508
4509 /* First see if this is a quoted string. */
4510 quote_found = '\0';
4511 for (p = text; *p != '\0'; ++p)
4512 {
4513 if (quote_found != '\0')
4514 {
4515 if (*p == quote_found)
4516 /* Found close quote. */
4517 quote_found = '\0';
4518 else if (*p == '\\' && p[1] == quote_found)
4519 /* A backslash followed by the quote character
4520 doesn't end the string. */
4521 ++p;
4522 }
4523 else if (*p == '\'' || *p == '"')
4524 {
4525 quote_found = *p;
4526 quote_pos = p;
4527 }
4528 }
4529 if (quote_found == '\'')
4530 /* A string within single quotes can be a symbol, so complete on it. */
4531 sym_text = quote_pos + 1;
4532 else if (quote_found == '"')
4533 /* A double-quoted string is never a symbol, nor does it make sense
4534 to complete it any other way. */
4535 {
49c4e619 4536 return NULL;
c94fdfd0
EZ
4537 }
4538 else
4539 {
69636828
AF
4540 /* Not a quoted string. */
4541 sym_text = language_search_unquoted_string (text, p);
c94fdfd0
EZ
4542 }
4543 }
4544
4545 sym_text_len = strlen (sym_text);
4546
49c4e619 4547 return_val = NULL;
c94fdfd0
EZ
4548
4549 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4550 in). */
4551 s = lookup_symtab (srcfile);
4552 if (s == NULL)
4553 {
4554 /* Maybe they typed the file with leading directories, while the
4555 symbol tables record only its basename. */
31889e00 4556 const char *tail = lbasename (srcfile);
c94fdfd0
EZ
4557
4558 if (tail > srcfile)
4559 s = lookup_symtab (tail);
4560 }
4561
4562 /* If we have no symtab for that file, return an empty list. */
4563 if (s == NULL)
4564 return (return_val);
4565
4566 /* Go through this symtab and check the externs and statics for
4567 symbols which match. */
4568
4569 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
de4f826b 4570 ALL_BLOCK_SYMBOLS (b, iter, sym)
c94fdfd0 4571 {
c94fdfd0
EZ
4572 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4573 }
4574
4575 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
de4f826b 4576 ALL_BLOCK_SYMBOLS (b, iter, sym)
c94fdfd0 4577 {
c94fdfd0
EZ
4578 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
4579 }
4580
4581 return (return_val);
4582}
4583
4584/* A helper function for make_source_files_completion_list. It adds
4585 another file name to a list of possible completions, growing the
4586 list as necessary. */
4587
4588static void
6f937416 4589add_filename_to_list (const char *fname, const char *text, const char *word,
49c4e619 4590 VEC (char_ptr) **list)
c94fdfd0
EZ
4591{
4592 char *new;
4593 size_t fnlen = strlen (fname);
4594
c94fdfd0
EZ
4595 if (word == text)
4596 {
4597 /* Return exactly fname. */
4598 new = xmalloc (fnlen + 5);
4599 strcpy (new, fname);
4600 }
4601 else if (word > text)
4602 {
4603 /* Return some portion of fname. */
4604 new = xmalloc (fnlen + 5);
4605 strcpy (new, fname + (word - text));
4606 }
4607 else
4608 {
4609 /* Return some of TEXT plus fname. */
4610 new = xmalloc (fnlen + (text - word) + 5);
4611 strncpy (new, word, text - word);
4612 new[text - word] = '\0';
4613 strcat (new, fname);
4614 }
49c4e619 4615 VEC_safe_push (char_ptr, *list, new);
c94fdfd0
EZ
4616}
4617
4618static int
4619not_interesting_fname (const char *fname)
4620{
4621 static const char *illegal_aliens[] = {
4622 "_globals_", /* inserted by coff_symtab_read */
4623 NULL
4624 };
4625 int i;
4626
4627 for (i = 0; illegal_aliens[i]; i++)
4628 {
0ba1096a 4629 if (filename_cmp (fname, illegal_aliens[i]) == 0)
c94fdfd0
EZ
4630 return 1;
4631 }
4632 return 0;
4633}
4634
ccefe4c4
TT
4635/* An object of this type is passed as the user_data argument to
4636 map_partial_symbol_filenames. */
4637struct add_partial_filename_data
4638{
9fdc877b 4639 struct filename_seen_cache *filename_seen_cache;
6f937416
PA
4640 const char *text;
4641 const char *word;
ccefe4c4 4642 int text_len;
49c4e619 4643 VEC (char_ptr) **list;
ccefe4c4
TT
4644};
4645
4646/* A callback for map_partial_symbol_filenames. */
eca864fe 4647
ccefe4c4 4648static void
2837d59e 4649maybe_add_partial_symtab_filename (const char *filename, const char *fullname,
ccefe4c4
TT
4650 void *user_data)
4651{
4652 struct add_partial_filename_data *data = user_data;
4653
4654 if (not_interesting_fname (filename))
4655 return;
9fdc877b 4656 if (!filename_seen (data->filename_seen_cache, filename, 1)
0ba1096a 4657 && filename_ncmp (filename, data->text, data->text_len) == 0)
ccefe4c4
TT
4658 {
4659 /* This file matches for a completion; add it to the
4660 current list of matches. */
49c4e619 4661 add_filename_to_list (filename, data->text, data->word, data->list);
ccefe4c4
TT
4662 }
4663 else
4664 {
4665 const char *base_name = lbasename (filename);
433759f7 4666
ccefe4c4 4667 if (base_name != filename
9fdc877b 4668 && !filename_seen (data->filename_seen_cache, base_name, 1)
0ba1096a 4669 && filename_ncmp (base_name, data->text, data->text_len) == 0)
49c4e619 4670 add_filename_to_list (base_name, data->text, data->word, data->list);
ccefe4c4
TT
4671 }
4672}
4673
49c4e619
TT
4674/* Return a vector of all source files whose names begin with matching
4675 TEXT. The file names are looked up in the symbol tables of this
4676 program. If the answer is no matchess, then the return value is
4677 NULL. */
c94fdfd0 4678
49c4e619 4679VEC (char_ptr) *
6f937416 4680make_source_files_completion_list (const char *text, const char *word)
c94fdfd0 4681{
52f0bd74 4682 struct symtab *s;
52f0bd74 4683 struct objfile *objfile;
c94fdfd0 4684 size_t text_len = strlen (text);
49c4e619 4685 VEC (char_ptr) *list = NULL;
31889e00 4686 const char *base_name;
ccefe4c4 4687 struct add_partial_filename_data datum;
9fdc877b
DE
4688 struct filename_seen_cache *filename_seen_cache;
4689 struct cleanup *back_to, *cache_cleanup;
c94fdfd0 4690
c94fdfd0
EZ
4691 if (!have_full_symbols () && !have_partial_symbols ())
4692 return list;
4693
821296b7
SA
4694 back_to = make_cleanup (do_free_completion_list, &list);
4695
9fdc877b
DE
4696 filename_seen_cache = create_filename_seen_cache ();
4697 cache_cleanup = make_cleanup (delete_filename_seen_cache,
4698 filename_seen_cache);
4699
c94fdfd0
EZ
4700 ALL_SYMTABS (objfile, s)
4701 {
4702 if (not_interesting_fname (s->filename))
4703 continue;
9fdc877b 4704 if (!filename_seen (filename_seen_cache, s->filename, 1)
0ba1096a 4705 && filename_ncmp (s->filename, text, text_len) == 0)
c94fdfd0
EZ
4706 {
4707 /* This file matches for a completion; add it to the current
4708 list of matches. */
49c4e619 4709 add_filename_to_list (s->filename, text, word, &list);
c94fdfd0
EZ
4710 }
4711 else
4712 {
4713 /* NOTE: We allow the user to type a base name when the
4714 debug info records leading directories, but not the other
4715 way around. This is what subroutines of breakpoint
4716 command do when they parse file names. */
31889e00 4717 base_name = lbasename (s->filename);
c94fdfd0 4718 if (base_name != s->filename
9fdc877b 4719 && !filename_seen (filename_seen_cache, base_name, 1)
0ba1096a 4720 && filename_ncmp (base_name, text, text_len) == 0)
49c4e619 4721 add_filename_to_list (base_name, text, word, &list);
c94fdfd0
EZ
4722 }
4723 }
4724
9fdc877b 4725 datum.filename_seen_cache = filename_seen_cache;
ccefe4c4
TT
4726 datum.text = text;
4727 datum.word = word;
4728 datum.text_len = text_len;
4729 datum.list = &list;
74e2f255
DE
4730 map_partial_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
4731 0 /*need_fullname*/);
9fdc877b
DE
4732
4733 do_cleanups (cache_cleanup);
821296b7 4734 discard_cleanups (back_to);
c94fdfd0
EZ
4735
4736 return list;
4737}
4738
c906108c
SS
4739/* Determine if PC is in the prologue of a function. The prologue is the area
4740 between the first instruction of a function, and the first executable line.
4741 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4742
4743 If non-zero, func_start is where we think the prologue starts, possibly
c378eb4e 4744 by previous examination of symbol table information. */
c906108c
SS
4745
4746int
d80b854b 4747in_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_start)
c906108c
SS
4748{
4749 struct symtab_and_line sal;
4750 CORE_ADDR func_addr, func_end;
4751
54cf9c03
EZ
4752 /* We have several sources of information we can consult to figure
4753 this out.
4754 - Compilers usually emit line number info that marks the prologue
4755 as its own "source line". So the ending address of that "line"
4756 is the end of the prologue. If available, this is the most
4757 reliable method.
4758 - The minimal symbols and partial symbols, which can usually tell
4759 us the starting and ending addresses of a function.
4760 - If we know the function's start address, we can call the
a433963d 4761 architecture-defined gdbarch_skip_prologue function to analyze the
54cf9c03
EZ
4762 instruction stream and guess where the prologue ends.
4763 - Our `func_start' argument; if non-zero, this is the caller's
4764 best guess as to the function's entry point. At the time of
4765 this writing, handle_inferior_event doesn't get this right, so
4766 it should be our last resort. */
4767
4768 /* Consult the partial symbol table, to find which function
4769 the PC is in. */
4770 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4771 {
4772 CORE_ADDR prologue_end;
c906108c 4773
54cf9c03
EZ
4774 /* We don't even have minsym information, so fall back to using
4775 func_start, if given. */
4776 if (! func_start)
4777 return 1; /* We *might* be in a prologue. */
c906108c 4778
d80b854b 4779 prologue_end = gdbarch_skip_prologue (gdbarch, func_start);
c906108c 4780
54cf9c03
EZ
4781 return func_start <= pc && pc < prologue_end;
4782 }
c906108c 4783
54cf9c03
EZ
4784 /* If we have line number information for the function, that's
4785 usually pretty reliable. */
4786 sal = find_pc_line (func_addr, 0);
c906108c 4787
54cf9c03
EZ
4788 /* Now sal describes the source line at the function's entry point,
4789 which (by convention) is the prologue. The end of that "line",
4790 sal.end, is the end of the prologue.
4791
4792 Note that, for functions whose source code is all on a single
4793 line, the line number information doesn't always end up this way.
4794 So we must verify that our purported end-of-prologue address is
4795 *within* the function, not at its start or end. */
4796 if (sal.line == 0
4797 || sal.end <= func_addr
4798 || func_end <= sal.end)
4799 {
4800 /* We don't have any good line number info, so use the minsym
4801 information, together with the architecture-specific prologue
4802 scanning code. */
d80b854b 4803 CORE_ADDR prologue_end = gdbarch_skip_prologue (gdbarch, func_addr);
c906108c 4804
54cf9c03
EZ
4805 return func_addr <= pc && pc < prologue_end;
4806 }
c906108c 4807
54cf9c03
EZ
4808 /* We have line number info, and it looks good. */
4809 return func_addr <= pc && pc < sal.end;
c906108c
SS
4810}
4811
634aa483
AC
4812/* Given PC at the function's start address, attempt to find the
4813 prologue end using SAL information. Return zero if the skip fails.
4814
4815 A non-optimized prologue traditionally has one SAL for the function
4816 and a second for the function body. A single line function has
4817 them both pointing at the same line.
4818
4819 An optimized prologue is similar but the prologue may contain
4820 instructions (SALs) from the instruction body. Need to skip those
4821 while not getting into the function body.
4822
4823 The functions end point and an increasing SAL line are used as
4824 indicators of the prologue's endpoint.
4825
7475b06c
TJB
4826 This code is based on the function refine_prologue_limit
4827 (found in ia64). */
634aa483
AC
4828
4829CORE_ADDR
d80b854b 4830skip_prologue_using_sal (struct gdbarch *gdbarch, CORE_ADDR func_addr)
634aa483
AC
4831{
4832 struct symtab_and_line prologue_sal;
4833 CORE_ADDR start_pc;
4834 CORE_ADDR end_pc;
d54be744 4835 struct block *bl;
634aa483
AC
4836
4837 /* Get an initial range for the function. */
4838 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc);
d80b854b 4839 start_pc += gdbarch_deprecated_function_start_offset (gdbarch);
634aa483
AC
4840
4841 prologue_sal = find_pc_line (start_pc, 0);
4842 if (prologue_sal.line != 0)
4843 {
e5dd4106 4844 /* For languages other than assembly, treat two consecutive line
d54be744
DJ
4845 entries at the same address as a zero-instruction prologue.
4846 The GNU assembler emits separate line notes for each instruction
4847 in a multi-instruction macro, but compilers generally will not
4848 do this. */
4849 if (prologue_sal.symtab->language != language_asm)
4850 {
4851 struct linetable *linetable = LINETABLE (prologue_sal.symtab);
d54be744
DJ
4852 int idx = 0;
4853
4854 /* Skip any earlier lines, and any end-of-sequence marker
4855 from a previous function. */
4856 while (linetable->item[idx].pc != prologue_sal.pc
4857 || linetable->item[idx].line == 0)
4858 idx++;
4859
4860 if (idx+1 < linetable->nitems
4861 && linetable->item[idx+1].line != 0
4862 && linetable->item[idx+1].pc == start_pc)
4863 return start_pc;
4864 }
4865
576c2025
FF
4866 /* If there is only one sal that covers the entire function,
4867 then it is probably a single line function, like
c378eb4e 4868 "foo(){}". */
91934273 4869 if (prologue_sal.end >= end_pc)
4e463ff5 4870 return 0;
d54be744 4871
634aa483
AC
4872 while (prologue_sal.end < end_pc)
4873 {
4874 struct symtab_and_line sal;
4875
4876 sal = find_pc_line (prologue_sal.end, 0);
4877 if (sal.line == 0)
4878 break;
4879 /* Assume that a consecutive SAL for the same (or larger)
4880 line mark the prologue -> body transition. */
4881 if (sal.line >= prologue_sal.line)
4882 break;
2077afdd
TD
4883 /* Likewise if we are in a different symtab altogether
4884 (e.g. within a file included via #include).  */
4885 if (sal.symtab != prologue_sal.symtab)
4886 break;
edb3359d
DJ
4887
4888 /* The line number is smaller. Check that it's from the
4889 same function, not something inlined. If it's inlined,
4890 then there is no point comparing the line numbers. */
4891 bl = block_for_pc (prologue_sal.end);
4892 while (bl)
4893 {
4894 if (block_inlined_p (bl))
4895 break;
4896 if (BLOCK_FUNCTION (bl))
4897 {
4898 bl = NULL;
4899 break;
4900 }
4901 bl = BLOCK_SUPERBLOCK (bl);
4902 }
4903 if (bl != NULL)
4904 break;
4905
634aa483
AC
4906 /* The case in which compiler's optimizer/scheduler has
4907 moved instructions into the prologue. We look ahead in
4908 the function looking for address ranges whose
4909 corresponding line number is less the first one that we
4910 found for the function. This is more conservative then
4911 refine_prologue_limit which scans a large number of SALs
c378eb4e 4912 looking for any in the prologue. */
634aa483
AC
4913 prologue_sal = sal;
4914 }
4915 }
d54be744
DJ
4916
4917 if (prologue_sal.end < end_pc)
4918 /* Return the end of this line, or zero if we could not find a
4919 line. */
4920 return prologue_sal.end;
4921 else
4922 /* Don't return END_PC, which is past the end of the function. */
4923 return prologue_sal.pc;
634aa483 4924}
c906108c 4925\f
51cc5b07
AC
4926/* Track MAIN */
4927static char *name_of_main;
01f8c46d 4928enum language language_of_main = language_unknown;
51cc5b07
AC
4929
4930void
4931set_main_name (const char *name)
4932{
4933 if (name_of_main != NULL)
4934 {
4935 xfree (name_of_main);
4936 name_of_main = NULL;
01f8c46d 4937 language_of_main = language_unknown;
51cc5b07
AC
4938 }
4939 if (name != NULL)
4940 {
4941 name_of_main = xstrdup (name);
01f8c46d 4942 language_of_main = language_unknown;
51cc5b07
AC
4943 }
4944}
4945
ea53e89f
JB
4946/* Deduce the name of the main procedure, and set NAME_OF_MAIN
4947 accordingly. */
4948
4949static void
4950find_main_name (void)
4951{
cd6c7346 4952 const char *new_main_name;
ea53e89f
JB
4953
4954 /* Try to see if the main procedure is in Ada. */
4955 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4956 be to add a new method in the language vector, and call this
4957 method for each language until one of them returns a non-empty
4958 name. This would allow us to remove this hard-coded call to
4959 an Ada function. It is not clear that this is a better approach
4960 at this point, because all methods need to be written in a way
c378eb4e 4961 such that false positives never be returned. For instance, it is
ea53e89f
JB
4962 important that a method does not return a wrong name for the main
4963 procedure if the main procedure is actually written in a different
4964 language. It is easy to guaranty this with Ada, since we use a
4965 special symbol generated only when the main in Ada to find the name
c378eb4e 4966 of the main procedure. It is difficult however to see how this can
ea53e89f
JB
4967 be guarantied for languages such as C, for instance. This suggests
4968 that order of call for these methods becomes important, which means
4969 a more complicated approach. */
4970 new_main_name = ada_main_name ();
4971 if (new_main_name != NULL)
9af17804 4972 {
ea53e89f
JB
4973 set_main_name (new_main_name);
4974 return;
4975 }
4976
a766d390
DE
4977 new_main_name = go_main_name ();
4978 if (new_main_name != NULL)
4979 {
4980 set_main_name (new_main_name);
4981 return;
4982 }
4983
cd6c7346
PM
4984 new_main_name = pascal_main_name ();
4985 if (new_main_name != NULL)
9af17804 4986 {
cd6c7346
PM
4987 set_main_name (new_main_name);
4988 return;
4989 }
4990
ea53e89f
JB
4991 /* The languages above didn't identify the name of the main procedure.
4992 Fallback to "main". */
4993 set_main_name ("main");
4994}
4995
51cc5b07
AC
4996char *
4997main_name (void)
4998{
ea53e89f
JB
4999 if (name_of_main == NULL)
5000 find_main_name ();
5001
5002 return name_of_main;
51cc5b07
AC
5003}
5004
ea53e89f
JB
5005/* Handle ``executable_changed'' events for the symtab module. */
5006
5007static void
781b42b0 5008symtab_observer_executable_changed (void)
ea53e89f
JB
5009{
5010 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5011 set_main_name (NULL);
5012}
51cc5b07 5013
a6c727b2
DJ
5014/* Return 1 if the supplied producer string matches the ARM RealView
5015 compiler (armcc). */
5016
5017int
5018producer_is_realview (const char *producer)
5019{
5020 static const char *const arm_idents[] = {
5021 "ARM C Compiler, ADS",
5022 "Thumb C Compiler, ADS",
5023 "ARM C++ Compiler, ADS",
5024 "Thumb C++ Compiler, ADS",
5025 "ARM/Thumb C/C++ Compiler, RVCT",
5026 "ARM C/C++ Compiler, RVCT"
5027 };
5028 int i;
5029
5030 if (producer == NULL)
5031 return 0;
5032
5033 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
5034 if (strncmp (producer, arm_idents[i], strlen (arm_idents[i])) == 0)
5035 return 1;
5036
5037 return 0;
5038}
ed0616c6 5039
c906108c 5040void
fba45db2 5041_initialize_symtab (void)
c906108c 5042{
1bedd215
AC
5043 add_info ("variables", variables_info, _("\
5044All global and static variable names, or those matching REGEXP."));
c906108c 5045 if (dbx_commands)
1bedd215
AC
5046 add_com ("whereis", class_info, variables_info, _("\
5047All global and static variable names, or those matching REGEXP."));
c906108c
SS
5048
5049 add_info ("functions", functions_info,
1bedd215 5050 _("All function names, or those matching REGEXP."));
c906108c
SS
5051
5052 /* FIXME: This command has at least the following problems:
5053 1. It prints builtin types (in a very strange and confusing fashion).
5054 2. It doesn't print right, e.g. with
c5aa993b
JM
5055 typedef struct foo *FOO
5056 type_print prints "FOO" when we want to make it (in this situation)
5057 print "struct foo *".
c906108c
SS
5058 I also think "ptype" or "whatis" is more likely to be useful (but if
5059 there is much disagreement "info types" can be fixed). */
5060 add_info ("types", types_info,
1bedd215 5061 _("All type names, or those matching REGEXP."));
c906108c 5062
c906108c 5063 add_info ("sources", sources_info,
1bedd215 5064 _("Source files in the program."));
c906108c
SS
5065
5066 add_com ("rbreak", class_breakpoint, rbreak_command,
1bedd215 5067 _("Set a breakpoint for all functions matching REGEXP."));
c906108c
SS
5068
5069 if (xdb_commands)
5070 {
1bedd215
AC
5071 add_com ("lf", class_info, sources_info,
5072 _("Source files in the program"));
5073 add_com ("lg", class_info, variables_info, _("\
5074All global and static variable names, or those matching REGEXP."));
c906108c
SS
5075 }
5076
717d2f5a
JB
5077 add_setshow_enum_cmd ("multiple-symbols", no_class,
5078 multiple_symbols_modes, &multiple_symbols_mode,
5079 _("\
5080Set the debugger behavior when more than one symbol are possible matches\n\
5081in an expression."), _("\
5082Show how the debugger handles ambiguities in expressions."), _("\
5083Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5084 NULL, NULL, &setlist, &showlist);
5085
c011a4f4
DE
5086 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure,
5087 &basenames_may_differ, _("\
5088Set whether a source file may have multiple base names."), _("\
5089Show whether a source file may have multiple base names."), _("\
5090(A \"base name\" is the name of a file with the directory part removed.\n\
5091Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5092If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5093before comparing them. Canonicalization is an expensive operation,\n\
5094but it allows the same file be known by more than one base name.\n\
5095If not set (the default), all source files are assumed to have just\n\
5096one base name, and gdb will do file name comparisons more efficiently."),
5097 NULL, NULL,
5098 &setlist, &showlist);
5099
45cfd468
DE
5100 add_setshow_boolean_cmd ("symtab-create", no_class, &symtab_create_debug,
5101 _("Set debugging of symbol table creation."),
5102 _("Show debugging of symbol table creation."), _("\
5103When enabled, debugging messages are printed when building symbol tables."),
5104 NULL,
5105 NULL,
5106 &setdebuglist, &showdebuglist);
5107
ea53e89f 5108 observer_attach_executable_changed (symtab_observer_executable_changed);
c906108c 5109}
This page took 1.667453 seconds and 4 git commands to generate.