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