* Makefile.in (install-only): Use $(SHELL) when running
[deliverable/binutils-gdb.git] / gdb / symtab.c
CommitLineData
c906108c 1/* Symbol table lookup for the GNU debugger, GDB.
8926118c
AC
2
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
083ae935
DJ
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
5 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
11 the Free Software Foundation; either version 2 of the License, or
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
JM
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
c906108c
SS
23
24#include "defs.h"
25#include "symtab.h"
26#include "gdbtypes.h"
27#include "gdbcore.h"
28#include "frame.h"
29#include "target.h"
30#include "value.h"
31#include "symfile.h"
32#include "objfiles.h"
33#include "gdbcmd.h"
34#include "call-cmds.h"
88987551 35#include "gdb_regex.h"
c906108c
SS
36#include "expression.h"
37#include "language.h"
38#include "demangle.h"
39#include "inferior.h"
c5f0f3d0 40#include "linespec.h"
0378c332 41#include "source.h"
a7fdf62f 42#include "filenames.h" /* for FILENAME_CMP */
1bae87b9 43#include "objc-lang.h"
c906108c 44
2de7ced7
DJ
45#include "hashtab.h"
46
04ea0df1 47#include "gdb_obstack.h"
fe898f56 48#include "block.h"
c906108c
SS
49
50#include <sys/types.h>
51#include <fcntl.h>
52#include "gdb_string.h"
53#include "gdb_stat.h"
54#include <ctype.h>
015a42b4 55#include "cp-abi.h"
c906108c 56
c906108c
SS
57/* Prototypes for local functions */
58
a14ed312 59static void completion_list_add_name (char *, char *, int, char *, char *);
c906108c 60
a14ed312 61static void rbreak_command (char *, int);
c906108c 62
a14ed312 63static void types_info (char *, int);
c906108c 64
a14ed312 65static void functions_info (char *, int);
c906108c 66
a14ed312 67static void variables_info (char *, int);
c906108c 68
a14ed312 69static void sources_info (char *, int);
c906108c 70
a14ed312 71static void output_source_filename (char *, int *);
c906108c 72
a14ed312 73static int find_line_common (struct linetable *, int, int *);
c906108c 74
50641945
FN
75/* This one is used by linespec.c */
76
77char *operator_chars (char *p, char **end);
78
b37bcaa8 79static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
3d4e8fd2 80 const char *,
b37bcaa8
KB
81 const char *, int,
82 namespace_enum);
c906108c 83
3121eff0
DJ
84static struct symbol *lookup_symbol_aux (const char *name,
85 const char *mangled_name,
86 const struct block *block,
87 const namespace_enum namespace,
88 int *is_a_field_of_this,
89 struct symtab **symtab);
fba7f19c 90
e4051eeb
DC
91static
92struct symbol *lookup_symbol_aux_local (const char *name,
93 const char *mangled_name,
94 const struct block *block,
95 const namespace_enum namespace,
96 struct symtab **symtab,
97 const struct block **static_block);
8155455b 98
f61e8913
DC
99static
100struct symbol *lookup_symbol_aux_block (const char *name,
101 const char *mangled_name,
102 const struct block *block,
103 const namespace_enum namespace,
104 struct symtab **symtab);
105
8155455b
DC
106static
107struct symbol *lookup_symbol_aux_symtabs (int block_index,
108 const char *name,
109 const char *mangled_name,
110 const namespace_enum namespace,
111 struct symtab **symtab);
112
113static
114struct symbol *lookup_symbol_aux_psymtabs (int block_index,
115 const char *name,
116 const char *mangled_name,
117 const namespace_enum namespace,
118 struct symtab **symtab);
fba7f19c 119
406bc4de
DC
120static
121struct symbol *lookup_symbol_aux_minsyms (const char *name,
122 const char *mangled_name,
123 const namespace_enum namespace,
124 int *is_a_field_of_this,
e45febe2 125 struct symtab **symtab);
406bc4de 126
a14ed312 127static struct symbol *find_active_alias (struct symbol *sym, CORE_ADDR addr);
c906108c
SS
128
129/* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */
130/* Signals the presence of objects compiled by HP compilers */
131int hp_som_som_object_present = 0;
132
a14ed312 133static void fixup_section (struct general_symbol_info *, struct objfile *);
c906108c 134
a14ed312 135static int file_matches (char *, char **, int);
c906108c 136
a14ed312
KB
137static void print_symbol_info (namespace_enum,
138 struct symtab *, struct symbol *, int, char *);
c906108c 139
a14ed312 140static void print_msymbol_info (struct minimal_symbol *);
c906108c 141
a14ed312 142static void symtab_symbol_info (char *, namespace_enum, int);
c906108c 143
a14ed312 144static void overload_list_add_symbol (struct symbol *sym, char *oload_name);
392a587b 145
a14ed312 146void _initialize_symtab (void);
c906108c
SS
147
148/* */
149
150/* The single non-language-specific builtin type */
151struct type *builtin_type_error;
152
153/* Block in which the most recently searched-for symbol was found.
154 Might be better to make this a parameter to lookup_symbol and
155 value_of_this. */
156
157const struct block *block_found;
158
c906108c
SS
159/* Check for a symtab of a specific name; first in symtabs, then in
160 psymtabs. *If* there is no '/' in the name, a match after a '/'
161 in the symtab filename will also work. */
162
1b15f1fa
TT
163struct symtab *
164lookup_symtab (const char *name)
c906108c
SS
165{
166 register struct symtab *s;
167 register struct partial_symtab *ps;
c906108c 168 register struct objfile *objfile;
58d370e0 169 char *real_path = NULL;
f079a2e5 170 char *full_path = NULL;
58d370e0
TT
171
172 /* Here we are interested in canonicalizing an absolute path, not
173 absolutizing a relative path. */
174 if (IS_ABSOLUTE_PATH (name))
f079a2e5
JB
175 {
176 full_path = xfullpath (name);
177 make_cleanup (xfree, full_path);
178 real_path = gdb_realpath (name);
179 make_cleanup (xfree, real_path);
180 }
c906108c 181
c5aa993b 182got_symtab:
c906108c
SS
183
184 /* First, search for an exact match */
185
186 ALL_SYMTABS (objfile, s)
58d370e0 187 {
a7fdf62f 188 if (FILENAME_CMP (name, s->filename) == 0)
58d370e0 189 {
58d370e0
TT
190 return s;
191 }
f079a2e5 192
58d370e0
TT
193 /* If the user gave us an absolute path, try to find the file in
194 this symtab and use its absolute path. */
f079a2e5
JB
195
196 if (full_path != NULL)
197 {
198 const char *fp = symtab_to_filename (s);
199 if (FILENAME_CMP (full_path, fp) == 0)
200 {
201 return s;
202 }
203 }
204
58d370e0
TT
205 if (real_path != NULL)
206 {
25f1b008 207 char *rp = gdb_realpath (symtab_to_filename (s));
f079a2e5 208 make_cleanup (xfree, rp);
58d370e0
TT
209 if (FILENAME_CMP (real_path, rp) == 0)
210 {
58d370e0
TT
211 return s;
212 }
213 }
214 }
215
c906108c
SS
216 /* Now, search for a matching tail (only if name doesn't have any dirs) */
217
caadab2c 218 if (lbasename (name) == name)
c906108c 219 ALL_SYMTABS (objfile, s)
c5aa993b 220 {
31889e00 221 if (FILENAME_CMP (lbasename (s->filename), name) == 0)
c5aa993b
JM
222 return s;
223 }
c906108c
SS
224
225 /* Same search rules as above apply here, but now we look thru the
226 psymtabs. */
227
228 ps = lookup_partial_symtab (name);
229 if (!ps)
230 return (NULL);
231
c5aa993b 232 if (ps->readin)
c906108c 233 error ("Internal: readin %s pst for `%s' found when no symtab found.",
c5aa993b 234 ps->filename, name);
c906108c
SS
235
236 s = PSYMTAB_TO_SYMTAB (ps);
237
238 if (s)
239 return s;
240
241 /* At this point, we have located the psymtab for this file, but
242 the conversion to a symtab has failed. This usually happens
243 when we are looking up an include file. In this case,
244 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
245 been created. So, we need to run through the symtabs again in
246 order to find the file.
247 XXX - This is a crock, and should be fixed inside of the the
248 symbol parsing routines. */
249 goto got_symtab;
250}
251
c906108c
SS
252/* Lookup the partial symbol table of a source file named NAME.
253 *If* there is no '/' in the name, a match after a '/'
254 in the psymtab filename will also work. */
255
256struct partial_symtab *
1f8cc6db 257lookup_partial_symtab (const char *name)
c906108c
SS
258{
259 register struct partial_symtab *pst;
260 register struct objfile *objfile;
f079a2e5 261 char *full_path = NULL;
58d370e0
TT
262 char *real_path = NULL;
263
264 /* Here we are interested in canonicalizing an absolute path, not
265 absolutizing a relative path. */
266 if (IS_ABSOLUTE_PATH (name))
f079a2e5
JB
267 {
268 full_path = xfullpath (name);
269 make_cleanup (xfree, full_path);
270 real_path = gdb_realpath (name);
271 make_cleanup (xfree, real_path);
272 }
c5aa993b 273
c906108c 274 ALL_PSYMTABS (objfile, pst)
c5aa993b 275 {
a7fdf62f 276 if (FILENAME_CMP (name, pst->filename) == 0)
c5aa993b
JM
277 {
278 return (pst);
279 }
f079a2e5 280
58d370e0
TT
281 /* If the user gave us an absolute path, try to find the file in
282 this symtab and use its absolute path. */
f079a2e5 283 if (full_path != NULL)
58d370e0
TT
284 {
285 if (pst->fullname == NULL)
286 source_full_path_of (pst->filename, &pst->fullname);
287 if (pst->fullname != NULL
f079a2e5 288 && FILENAME_CMP (full_path, pst->fullname) == 0)
58d370e0 289 {
58d370e0
TT
290 return pst;
291 }
292 }
c906108c 293
f079a2e5
JB
294 if (real_path != NULL)
295 {
296 char *rp = NULL;
297 if (pst->fullname == NULL)
298 source_full_path_of (pst->filename, &pst->fullname);
299 if (pst->fullname != NULL)
300 {
301 rp = gdb_realpath (pst->fullname);
302 make_cleanup (xfree, rp);
303 }
304 if (rp != NULL && FILENAME_CMP (real_path, rp) == 0)
305 {
306 return pst;
307 }
308 }
309 }
58d370e0 310
c906108c
SS
311 /* Now, search for a matching tail (only if name doesn't have any dirs) */
312
caadab2c 313 if (lbasename (name) == name)
c906108c 314 ALL_PSYMTABS (objfile, pst)
c5aa993b 315 {
31889e00 316 if (FILENAME_CMP (lbasename (pst->filename), name) == 0)
c5aa993b
JM
317 return (pst);
318 }
c906108c
SS
319
320 return (NULL);
321}
322\f
323/* Mangle a GDB method stub type. This actually reassembles the pieces of the
324 full method name, which consist of the class name (from T), the unadorned
325 method name from METHOD_ID, and the signature for the specific overload,
326 specified by SIGNATURE_ID. Note that this function is g++ specific. */
327
328char *
fba45db2 329gdb_mangle_name (struct type *type, int method_id, int signature_id)
c906108c
SS
330{
331 int mangled_name_len;
332 char *mangled_name;
333 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
334 struct fn_field *method = &f[signature_id];
335 char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
336 char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
337 char *newname = type_name_no_tag (type);
338
339 /* Does the form of physname indicate that it is the full mangled name
340 of a constructor (not just the args)? */
341 int is_full_physname_constructor;
342
343 int is_constructor;
015a42b4 344 int is_destructor = is_destructor_name (physname);
c906108c
SS
345 /* Need a new type prefix. */
346 char *const_prefix = method->is_const ? "C" : "";
347 char *volatile_prefix = method->is_volatile ? "V" : "";
348 char buf[20];
349 int len = (newname == NULL ? 0 : strlen (newname));
350
43630227
PS
351 /* Nothing to do if physname already contains a fully mangled v3 abi name
352 or an operator name. */
353 if ((physname[0] == '_' && physname[1] == 'Z')
354 || is_operator_name (field_name))
235d1e03
EZ
355 return xstrdup (physname);
356
015a42b4 357 is_full_physname_constructor = is_constructor_name (physname);
c906108c
SS
358
359 is_constructor =
c5aa993b 360 is_full_physname_constructor || (newname && STREQ (field_name, newname));
c906108c
SS
361
362 if (!is_destructor)
c5aa993b 363 is_destructor = (strncmp (physname, "__dt", 4) == 0);
c906108c
SS
364
365 if (is_destructor || is_full_physname_constructor)
366 {
c5aa993b
JM
367 mangled_name = (char *) xmalloc (strlen (physname) + 1);
368 strcpy (mangled_name, physname);
c906108c
SS
369 return mangled_name;
370 }
371
372 if (len == 0)
373 {
374 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
375 }
376 else if (physname[0] == 't' || physname[0] == 'Q')
377 {
378 /* The physname for template and qualified methods already includes
c5aa993b 379 the class name. */
c906108c
SS
380 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
381 newname = NULL;
382 len = 0;
383 }
384 else
385 {
386 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
387 }
388 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
235d1e03 389 + strlen (buf) + len + strlen (physname) + 1);
c906108c 390
c906108c 391 {
c5aa993b 392 mangled_name = (char *) xmalloc (mangled_name_len);
c906108c
SS
393 if (is_constructor)
394 mangled_name[0] = '\0';
395 else
396 strcpy (mangled_name, field_name);
397 }
398 strcat (mangled_name, buf);
399 /* If the class doesn't have a name, i.e. newname NULL, then we just
400 mangle it using 0 for the length of the class. Thus it gets mangled
c5aa993b 401 as something starting with `::' rather than `classname::'. */
c906108c
SS
402 if (newname != NULL)
403 strcat (mangled_name, newname);
404
405 strcat (mangled_name, physname);
406 return (mangled_name);
407}
12af6855
JB
408
409\f
89aad1f9
EZ
410/* Initialize the language dependent portion of a symbol
411 depending upon the language for the symbol. */
412void
413symbol_init_language_specific (struct general_symbol_info *gsymbol,
414 enum language language)
415{
416 gsymbol->language = language;
417 if (gsymbol->language == language_cplus
5784d15e
AF
418 || gsymbol->language == language_java
419 || gsymbol->language == language_objc)
89aad1f9
EZ
420 {
421 gsymbol->language_specific.cplus_specific.demangled_name = NULL;
422 }
89aad1f9
EZ
423 else
424 {
425 memset (&gsymbol->language_specific, 0,
426 sizeof (gsymbol->language_specific));
427 }
428}
429
2de7ced7
DJ
430/* Functions to initialize a symbol's mangled name. */
431
432/* Create the hash table used for demangled names. Each hash entry is
433 a pair of strings; one for the mangled name and one for the demangled
434 name. The entry is hashed via just the mangled name. */
435
436static void
437create_demangled_names_hash (struct objfile *objfile)
438{
439 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
440 The hash table code will round this up to the next prime number.
441 Choosing a much larger table size wastes memory, and saves only about
442 1% in symbol reading. */
443
444 objfile->demangled_names_hash = htab_create_alloc_ex
445 (256, htab_hash_string, (int (*) (const void *, const void *)) streq,
446 NULL, objfile->md, xmcalloc, xmfree);
447}
12af6855 448
2de7ced7 449/* Try to determine the demangled name for a symbol, based on the
12af6855
JB
450 language of that symbol. If the language is set to language_auto,
451 it will attempt to find any demangling algorithm that works and
2de7ced7
DJ
452 then set the language appropriately. The returned name is allocated
453 by the demangler and should be xfree'd. */
12af6855 454
2de7ced7
DJ
455static char *
456symbol_find_demangled_name (struct general_symbol_info *gsymbol,
457 const char *mangled)
12af6855 458{
12af6855
JB
459 char *demangled = NULL;
460
461 if (gsymbol->language == language_unknown)
462 gsymbol->language = language_auto;
1bae87b9
AF
463
464 if (gsymbol->language == language_objc
465 || gsymbol->language == language_auto)
466 {
467 demangled =
468 objc_demangle (mangled, 0);
469 if (demangled != NULL)
470 {
471 gsymbol->language = language_objc;
472 return demangled;
473 }
474 }
12af6855
JB
475 if (gsymbol->language == language_cplus
476 || gsymbol->language == language_auto)
477 {
478 demangled =
2de7ced7 479 cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
12af6855 480 if (demangled != NULL)
2de7ced7
DJ
481 {
482 gsymbol->language = language_cplus;
483 return demangled;
484 }
12af6855
JB
485 }
486 if (gsymbol->language == language_java)
487 {
488 demangled =
2de7ced7 489 cplus_demangle (mangled,
12af6855
JB
490 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA);
491 if (demangled != NULL)
2de7ced7
DJ
492 {
493 gsymbol->language = language_java;
494 return demangled;
495 }
496 }
497 return NULL;
498}
499
980cae7a
DC
500/* Set both the mangled and demangled (if any) names for GSYMBOL based
501 on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
502 is used, and the memory comes from that objfile's symbol_obstack.
503 LINKAGE_NAME is copied, so the pointer can be discarded after
504 calling this function. */
2de7ced7 505
d2a52b27
DC
506/* We have to be careful when dealing with Java names: when we run
507 into a Java minimal symbol, we don't know it's a Java symbol, so it
508 gets demangled as a C++ name. This is unfortunate, but there's not
509 much we can do about it: but when demangling partial symbols and
510 regular symbols, we'd better not reuse the wrong demangled name.
511 (See PR gdb/1039.) We solve this by putting a distinctive prefix
512 on Java names when storing them in the hash table. */
513
514/* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
515 don't mind the Java prefix so much: different languages have
516 different demangling requirements, so it's only natural that we
517 need to keep language data around in our demangling cache. But
518 it's not good that the minimal symbol has the wrong demangled name.
519 Unfortunately, I can't think of any easy solution to that
520 problem. */
521
522#define JAVA_PREFIX "##JAVA$$"
523#define JAVA_PREFIX_LEN 8
524
2de7ced7
DJ
525void
526symbol_set_names (struct general_symbol_info *gsymbol,
980cae7a 527 const char *linkage_name, int len, struct objfile *objfile)
2de7ced7
DJ
528{
529 char **slot;
980cae7a
DC
530 /* A 0-terminated copy of the linkage name. */
531 const char *linkage_name_copy;
d2a52b27
DC
532 /* A copy of the linkage name that might have a special Java prefix
533 added to it, for use when looking names up in the hash table. */
534 const char *lookup_name;
535 /* The length of lookup_name. */
536 int lookup_len;
2de7ced7
DJ
537
538 if (objfile->demangled_names_hash == NULL)
539 create_demangled_names_hash (objfile);
540
980cae7a
DC
541 /* The stabs reader generally provides names that are not
542 NUL-terminated; most of the other readers don't do this, so we
d2a52b27
DC
543 can just use the given copy, unless we're in the Java case. */
544 if (gsymbol->language == language_java)
545 {
546 char *alloc_name;
547 lookup_len = len + JAVA_PREFIX_LEN;
548
549 alloc_name = alloca (lookup_len + 1);
550 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
551 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
552 alloc_name[lookup_len] = '\0';
553
554 lookup_name = alloc_name;
555 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
556 }
557 else if (linkage_name[len] != '\0')
2de7ced7 558 {
980cae7a 559 char *alloc_name;
d2a52b27 560 lookup_len = len;
980cae7a 561
d2a52b27 562 alloc_name = alloca (lookup_len + 1);
980cae7a 563 memcpy (alloc_name, linkage_name, len);
d2a52b27 564 alloc_name[lookup_len] = '\0';
980cae7a 565
d2a52b27 566 lookup_name = alloc_name;
980cae7a 567 linkage_name_copy = alloc_name;
2de7ced7
DJ
568 }
569 else
980cae7a 570 {
d2a52b27
DC
571 lookup_len = len;
572 lookup_name = linkage_name;
980cae7a
DC
573 linkage_name_copy = linkage_name;
574 }
2de7ced7 575
980cae7a 576 slot = (char **) htab_find_slot (objfile->demangled_names_hash,
d2a52b27 577 lookup_name, INSERT);
2de7ced7
DJ
578
579 /* If this name is not in the hash table, add it. */
580 if (*slot == NULL)
581 {
980cae7a
DC
582 char *demangled_name = symbol_find_demangled_name (gsymbol,
583 linkage_name_copy);
2de7ced7
DJ
584 int demangled_len = demangled_name ? strlen (demangled_name) : 0;
585
586 /* If there is a demangled name, place it right after the mangled name.
587 Otherwise, just place a second zero byte after the end of the mangled
588 name. */
589 *slot = obstack_alloc (&objfile->symbol_obstack,
d2a52b27
DC
590 lookup_len + demangled_len + 2);
591 memcpy (*slot, lookup_name, lookup_len + 1);
980cae7a 592 if (demangled_name != NULL)
2de7ced7 593 {
d2a52b27 594 memcpy (*slot + lookup_len + 1, demangled_name, demangled_len + 1);
2de7ced7
DJ
595 xfree (demangled_name);
596 }
597 else
d2a52b27 598 (*slot)[lookup_len + 1] = '\0';
2de7ced7
DJ
599 }
600
d2a52b27
DC
601 gsymbol->name = *slot + lookup_len - len;
602 if ((*slot)[lookup_len + 1] != '\0')
2de7ced7 603 gsymbol->language_specific.cplus_specific.demangled_name
d2a52b27 604 = &(*slot)[lookup_len + 1];
2de7ced7
DJ
605 else
606 gsymbol->language_specific.cplus_specific.demangled_name = NULL;
607}
608
609/* Initialize the demangled name of GSYMBOL if possible. Any required space
610 to store the name is obtained from the specified obstack. The function
611 symbol_set_names, above, should be used instead where possible for more
612 efficient memory usage. */
613
614void
615symbol_init_demangled_name (struct general_symbol_info *gsymbol,
616 struct obstack *obstack)
617{
618 char *mangled = gsymbol->name;
619 char *demangled = NULL;
620
621 demangled = symbol_find_demangled_name (gsymbol, mangled);
622 if (gsymbol->language == language_cplus
1bae87b9
AF
623 || gsymbol->language == language_java
624 || gsymbol->language == language_objc)
2de7ced7
DJ
625 {
626 if (demangled)
627 {
628 gsymbol->language_specific.cplus_specific.demangled_name
629 = obsavestring (demangled, strlen (demangled), obstack);
630 xfree (demangled);
631 }
12af6855 632 else
2de7ced7
DJ
633 gsymbol->language_specific.cplus_specific.demangled_name = NULL;
634 }
635 else
636 {
637 /* Unknown language; just clean up quietly. */
638 if (demangled)
639 xfree (demangled);
12af6855 640 }
12af6855
JB
641}
642
22abf04a
DC
643/* Return the source code name of a symbol. In languages where
644 demangling is necessary, this is the demangled name. */
645
646char *
647symbol_natural_name (const struct general_symbol_info *gsymbol)
648{
649 if ((gsymbol->language == language_cplus
650 || gsymbol->language == language_java
651 || gsymbol->language == language_objc)
652 && (gsymbol->language_specific.cplus_specific.demangled_name != NULL))
653 {
654 return gsymbol->language_specific.cplus_specific.demangled_name;
655 }
656 else
657 {
658 return gsymbol->name;
659 }
660}
661
9cc0d196
EZ
662/* Return the demangled name for a symbol based on the language for
663 that symbol. If no demangled name exists, return NULL. */
664char *
665symbol_demangled_name (struct general_symbol_info *gsymbol)
666{
667 if (gsymbol->language == language_cplus
5784d15e
AF
668 || gsymbol->language == language_java
669 || gsymbol->language == language_objc)
9cc0d196 670 return gsymbol->language_specific.cplus_specific.demangled_name;
12af6855 671
9cc0d196
EZ
672 else
673 return NULL;
9cc0d196 674}
fe39c653
EZ
675
676/* Initialize the structure fields to zero values. */
677void
678init_sal (struct symtab_and_line *sal)
679{
680 sal->symtab = 0;
681 sal->section = 0;
682 sal->line = 0;
683 sal->pc = 0;
684 sal->end = 0;
685}
c906108c
SS
686\f
687
c5aa993b 688
c906108c
SS
689/* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
690
691struct partial_symtab *
fba45db2 692find_pc_sect_psymtab (CORE_ADDR pc, asection *section)
c906108c
SS
693{
694 register struct partial_symtab *pst;
695 register struct objfile *objfile;
8a48e967
DJ
696 struct minimal_symbol *msymbol;
697
698 /* If we know that this is not a text address, return failure. This is
699 necessary because we loop based on texthigh and textlow, which do
700 not include the data ranges. */
701 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
702 if (msymbol
703 && (msymbol->type == mst_data
704 || msymbol->type == mst_bss
705 || msymbol->type == mst_abs
706 || msymbol->type == mst_file_data
707 || msymbol->type == mst_file_bss))
708 return NULL;
c906108c
SS
709
710 ALL_PSYMTABS (objfile, pst)
c5aa993b 711 {
c5aa993b 712 if (pc >= pst->textlow && pc < pst->texthigh)
c5aa993b 713 {
c5aa993b
JM
714 struct partial_symtab *tpst;
715
716 /* An objfile that has its functions reordered might have
717 many partial symbol tables containing the PC, but
718 we want the partial symbol table that contains the
719 function containing the PC. */
720 if (!(objfile->flags & OBJF_REORDERED) &&
721 section == 0) /* can't validate section this way */
722 return (pst);
723
c5aa993b
JM
724 if (msymbol == NULL)
725 return (pst);
726
727 for (tpst = pst; tpst != NULL; tpst = tpst->next)
728 {
c5aa993b 729 if (pc >= tpst->textlow && pc < tpst->texthigh)
c5aa993b
JM
730 {
731 struct partial_symbol *p;
c906108c 732
c5aa993b
JM
733 p = find_pc_sect_psymbol (tpst, pc, section);
734 if (p != NULL
735 && SYMBOL_VALUE_ADDRESS (p)
736 == SYMBOL_VALUE_ADDRESS (msymbol))
737 return (tpst);
738 }
739 }
740 return (pst);
741 }
742 }
c906108c
SS
743 return (NULL);
744}
745
746/* Find which partial symtab contains PC. Return 0 if none.
747 Backward compatibility, no section */
748
749struct partial_symtab *
fba45db2 750find_pc_psymtab (CORE_ADDR pc)
c906108c
SS
751{
752 return find_pc_sect_psymtab (pc, find_pc_mapped_section (pc));
753}
754
755/* Find which partial symbol within a psymtab matches PC and SECTION.
756 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
757
758struct partial_symbol *
fba45db2
KB
759find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc,
760 asection *section)
c906108c
SS
761{
762 struct partial_symbol *best = NULL, *p, **pp;
763 CORE_ADDR best_pc;
c5aa993b 764
c906108c
SS
765 if (!psymtab)
766 psymtab = find_pc_sect_psymtab (pc, section);
767 if (!psymtab)
768 return 0;
769
770 /* Cope with programs that start at address 0 */
771 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0;
772
773 /* Search the global symbols as well as the static symbols, so that
774 find_pc_partial_function doesn't use a minimal symbol and thus
775 cache a bad endaddr. */
776 for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
c5aa993b
JM
777 (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
778 < psymtab->n_global_syms);
c906108c
SS
779 pp++)
780 {
781 p = *pp;
782 if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
783 && SYMBOL_CLASS (p) == LOC_BLOCK
784 && pc >= SYMBOL_VALUE_ADDRESS (p)
785 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
786 || (psymtab->textlow == 0
787 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
788 {
c5aa993b 789 if (section) /* match on a specific section */
c906108c
SS
790 {
791 fixup_psymbol_section (p, psymtab->objfile);
792 if (SYMBOL_BFD_SECTION (p) != section)
793 continue;
794 }
795 best_pc = SYMBOL_VALUE_ADDRESS (p);
796 best = p;
797 }
798 }
799
800 for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
c5aa993b
JM
801 (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
802 < psymtab->n_static_syms);
c906108c
SS
803 pp++)
804 {
805 p = *pp;
806 if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
807 && SYMBOL_CLASS (p) == LOC_BLOCK
808 && pc >= SYMBOL_VALUE_ADDRESS (p)
809 && (SYMBOL_VALUE_ADDRESS (p) > best_pc
c5aa993b 810 || (psymtab->textlow == 0
c906108c
SS
811 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0)))
812 {
c5aa993b 813 if (section) /* match on a specific section */
c906108c
SS
814 {
815 fixup_psymbol_section (p, psymtab->objfile);
816 if (SYMBOL_BFD_SECTION (p) != section)
817 continue;
818 }
819 best_pc = SYMBOL_VALUE_ADDRESS (p);
820 best = p;
821 }
822 }
823
824 return best;
825}
826
827/* Find which partial symbol within a psymtab matches PC. Return 0 if none.
828 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
829
830struct partial_symbol *
fba45db2 831find_pc_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc)
c906108c
SS
832{
833 return find_pc_sect_psymbol (psymtab, pc, find_pc_mapped_section (pc));
834}
835\f
836/* Debug symbols usually don't have section information. We need to dig that
837 out of the minimal symbols and stash that in the debug symbol. */
838
839static void
fba45db2 840fixup_section (struct general_symbol_info *ginfo, struct objfile *objfile)
c906108c
SS
841{
842 struct minimal_symbol *msym;
843 msym = lookup_minimal_symbol (ginfo->name, NULL, objfile);
844
845 if (msym)
7a78d0ee
KB
846 {
847 ginfo->bfd_section = SYMBOL_BFD_SECTION (msym);
848 ginfo->section = SYMBOL_SECTION (msym);
849 }
c906108c
SS
850}
851
852struct symbol *
fba45db2 853fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
c906108c
SS
854{
855 if (!sym)
856 return NULL;
857
858 if (SYMBOL_BFD_SECTION (sym))
859 return sym;
860
861 fixup_section (&sym->ginfo, objfile);
862
863 return sym;
864}
865
7a78d0ee 866struct partial_symbol *
fba45db2 867fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile)
c906108c
SS
868{
869 if (!psym)
870 return NULL;
871
872 if (SYMBOL_BFD_SECTION (psym))
873 return psym;
874
875 fixup_section (&psym->ginfo, objfile);
876
877 return psym;
878}
879
880/* Find the definition for a specified symbol name NAME
881 in namespace NAMESPACE, visible from lexical block BLOCK.
882 Returns the struct symbol pointer, or zero if no symbol is found.
883 If SYMTAB is non-NULL, store the symbol table in which the
884 symbol was found there, or NULL if not found.
885 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
886 NAME is a field of the current implied argument `this'. If so set
887 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
888 BLOCK_FOUND is set to the block in which NAME is found (in the case of
889 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
890
891/* This function has a bunch of loops in it and it would seem to be
892 attractive to put in some QUIT's (though I'm not really sure
893 whether it can run long enough to be really important). But there
894 are a few calls for which it would appear to be bad news to quit
7ca9f392
AC
895 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
896 that there is C++ code below which can error(), but that probably
897 doesn't affect these calls since they are looking for a known
898 variable and thus can probably assume it will never hit the C++
899 code). */
c906108c
SS
900
901struct symbol *
fba7f19c 902lookup_symbol (const char *name, const struct block *block,
fba45db2
KB
903 const namespace_enum namespace, int *is_a_field_of_this,
904 struct symtab **symtab)
c906108c 905{
729051e6
DJ
906 char *demangled_name = NULL;
907 const char *modified_name = NULL;
3121eff0 908 const char *mangled_name = NULL;
fba7f19c
EZ
909 int needtofreename = 0;
910 struct symbol *returnval;
c906108c 911
729051e6
DJ
912 modified_name = name;
913
914 /* If we are using C++ language, demangle the name before doing a lookup, so
915 we can always binary search. */
916 if (current_language->la_language == language_cplus)
917 {
918 demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
919 if (demangled_name)
920 {
921 mangled_name = name;
922 modified_name = demangled_name;
923 needtofreename = 1;
924 }
925 }
926
63872f9d
JG
927 if (case_sensitivity == case_sensitive_off)
928 {
929 char *copy;
930 int len, i;
931
932 len = strlen (name);
933 copy = (char *) alloca (len + 1);
934 for (i= 0; i < len; i++)
935 copy[i] = tolower (name[i]);
936 copy[len] = 0;
fba7f19c 937 modified_name = copy;
63872f9d 938 }
fba7f19c 939
3121eff0
DJ
940 returnval = lookup_symbol_aux (modified_name, mangled_name, block,
941 namespace, is_a_field_of_this, symtab);
fba7f19c 942 if (needtofreename)
729051e6 943 xfree (demangled_name);
fba7f19c
EZ
944
945 return returnval;
946}
947
948static struct symbol *
3121eff0
DJ
949lookup_symbol_aux (const char *name, const char *mangled_name,
950 const struct block *block, const namespace_enum namespace,
951 int *is_a_field_of_this, struct symtab **symtab)
fba7f19c 952{
8155455b 953 struct symbol *sym;
e4051eeb 954 const struct block *static_block;
406bc4de 955
e4051eeb
DC
956 /* Search specified block and its superiors. Don't search
957 STATIC_BLOCK or GLOBAL_BLOCK. */
c906108c 958
8155455b 959 sym = lookup_symbol_aux_local (name, mangled_name, block, namespace,
e4051eeb 960 symtab, &static_block);
8155455b
DC
961 if (sym != NULL)
962 return sym;
c906108c 963
8155455b
DC
964#if 0
965 /* NOTE: carlton/2002-11-05: At the time that this code was
966 #ifdeffed out, the value of 'block' was always NULL at this
967 point, hence the bemused comments below. */
c906108c
SS
968
969 /* FIXME: this code is never executed--block is always NULL at this
970 point. What is it trying to do, anyway? We already should have
971 checked the STATIC_BLOCK above (it is the superblock of top-level
972 blocks). Why is VAR_NAMESPACE special-cased? */
973 /* Don't need to mess with the psymtabs; if we have a block,
974 that file is read in. If we don't, then we deal later with
975 all the psymtab stuff that needs checking. */
976 /* Note (RT): The following never-executed code looks unnecessary to me also.
977 * If we change the code to use the original (passed-in)
978 * value of 'block', we could cause it to execute, but then what
979 * would it do? The STATIC_BLOCK of the symtab containing the passed-in
980 * 'block' was already searched by the above code. And the STATIC_BLOCK's
981 * of *other* symtabs (those files not containing 'block' lexically)
982 * should not contain 'block' address-wise. So we wouldn't expect this
983 * code to find any 'sym''s that were not found above. I vote for
984 * deleting the following paragraph of code.
985 */
986 if (namespace == VAR_NAMESPACE && block != NULL)
987 {
988 struct block *b;
989 /* Find the right symtab. */
990 ALL_SYMTABS (objfile, s)
c5aa993b
JM
991 {
992 bv = BLOCKVECTOR (s);
993 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
994 if (BLOCK_START (b) <= BLOCK_START (block)
995 && BLOCK_END (b) > BLOCK_START (block))
996 {
3121eff0 997 sym = lookup_block_symbol (b, name, mangled_name, VAR_NAMESPACE);
c5aa993b
JM
998 if (sym)
999 {
1000 block_found = b;
1001 if (symtab != NULL)
1002 *symtab = s;
1003 return fixup_symbol_section (sym, objfile);
1004 }
1005 }
1006 }
c906108c 1007 }
8155455b 1008#endif /* 0 */
c906108c 1009
1bae87b9 1010 /* C++/Java/Objective-C: If requested to do so by the caller,
c906108c
SS
1011 check to see if NAME is a field of `this'. */
1012 if (is_a_field_of_this)
1013 {
1014 struct value *v = value_of_this (0);
c5aa993b 1015
c906108c
SS
1016 *is_a_field_of_this = 0;
1017 if (v && check_field (v, name))
1018 {
1019 *is_a_field_of_this = 1;
1020 if (symtab != NULL)
1021 *symtab = NULL;
1022 return NULL;
1023 }
1024 }
1025
e4051eeb
DC
1026 /* If there's a static block to search, search it next. */
1027
1028 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1029 not it would be appropriate to search the current global block
1030 here as well. (That's what this code used to do before the
1031 is_a_field_of_this check was moved up.) On the one hand, it's
1032 redundant with the lookup_symbol_aux_symtabs search that happens
1033 next. On the other hand, if decode_line_1 is passed an argument
1034 like filename:var, then the user presumably wants 'var' to be
1035 searched for in filename. On the third hand, there shouldn't be
1036 multiple global variables all of which are named 'var', and it's
1037 not like decode_line_1 has ever restricted its search to only
1038 global variables in a single filename. All in all, only
1039 searching the static block here seems best: it's correct and it's
1040 cleanest. */
1041
1042 /* NOTE: carlton/2002-12-05: There's also a possible performance
1043 issue here: if you usually search for global symbols in the
1044 current file, then it would be slightly better to search the
1045 current global block before searching all the symtabs. But there
1046 are other factors that have a much greater effect on performance
1047 than that one, so I don't think we should worry about that for
1048 now. */
1049
1050 if (static_block != NULL)
1051 {
1052 sym = lookup_symbol_aux_block (name, mangled_name, static_block,
1053 namespace, symtab);
1054 if (sym != NULL)
1055 return sym;
1056 }
1057
c906108c
SS
1058 /* Now search all global blocks. Do the symtab's first, then
1059 check the psymtab's. If a psymtab indicates the existence
1060 of the desired name as a global, then do psymtab-to-symtab
1061 conversion on the fly and return the found symbol. */
c5aa993b 1062
8155455b
DC
1063 sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, mangled_name,
1064 namespace, symtab);
1065 if (sym != NULL)
1066 return sym;
c906108c
SS
1067
1068#ifndef HPUXHPPA
1069
1070 /* Check for the possibility of the symbol being a function or
1071 a mangled variable that is stored in one of the minimal symbol tables.
1072 Eventually, all global symbols might be resolved in this way. */
c5aa993b 1073
406bc4de
DC
1074 sym = lookup_symbol_aux_minsyms (name, mangled_name,
1075 namespace, is_a_field_of_this,
e45febe2 1076 symtab);
406bc4de 1077
e45febe2 1078 if (sym != NULL)
406bc4de 1079 return sym;
c5aa993b 1080
c906108c
SS
1081#endif
1082
8155455b
DC
1083 sym = lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, mangled_name,
1084 namespace, symtab);
1085 if (sym != NULL)
1086 return sym;
c906108c 1087
8155455b
DC
1088 /* Now search all static file-level symbols. Not strictly correct,
1089 but more useful than an error. Do the symtabs first, then check
1090 the psymtabs. If a psymtab indicates the existence of the
1091 desired name as a file-level static, then do psymtab-to-symtab
c906108c
SS
1092 conversion on the fly and return the found symbol. */
1093
8155455b
DC
1094 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, mangled_name,
1095 namespace, symtab);
1096 if (sym != NULL)
1097 return sym;
1098
1099 sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, mangled_name,
1100 namespace, symtab);
1101 if (sym != NULL)
1102 return sym;
c906108c
SS
1103
1104#ifdef HPUXHPPA
1105
1106 /* Check for the possibility of the symbol being a function or
1107 a global variable that is stored in one of the minimal symbol tables.
1108 The "minimal symbol table" is built from linker-supplied info.
1109
1110 RT: I moved this check to last, after the complete search of
1111 the global (p)symtab's and static (p)symtab's. For HP-generated
1112 symbol tables, this check was causing a premature exit from
1113 lookup_symbol with NULL return, and thus messing up symbol lookups
1114 of things like "c::f". It seems to me a check of the minimal
1115 symbol table ought to be a last resort in any case. I'm vaguely
1116 worried about the comment below which talks about FORTRAN routines "foo_"
1117 though... is it saying we need to do the "minsym" check before
1118 the static check in this case?
1119 */
c5aa993b 1120
c906108c 1121
406bc4de
DC
1122 sym = lookup_symbol_aux_minsyms (name, mangled_name,
1123 namespace, is_a_field_of_this,
e45febe2 1124 symtab);
406bc4de 1125
e45febe2 1126 if (sym != NULL)
406bc4de 1127 return sym;
c906108c
SS
1128
1129#endif
1130
1131 if (symtab != NULL)
1132 *symtab = NULL;
8155455b 1133 return NULL;
c906108c 1134}
8155455b 1135
e4051eeb
DC
1136/* Check to see if the symbol is defined in BLOCK or its superiors.
1137 Don't search STATIC_BLOCK or GLOBAL_BLOCK. If we don't find a
1138 match, store the address of STATIC_BLOCK in static_block. */
8155455b
DC
1139
1140static struct symbol *
1141lookup_symbol_aux_local (const char *name, const char *mangled_name,
1142 const struct block *block,
1143 const namespace_enum namespace,
e4051eeb
DC
1144 struct symtab **symtab,
1145 const struct block **static_block)
8155455b
DC
1146{
1147 struct symbol *sym;
f61e8913 1148
e4051eeb
DC
1149 /* Check if either no block is specified or it's a global block. */
1150
1151 if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL)
1152 {
1153 *static_block = NULL;
1154 return NULL;
1155 }
1156
1157 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
f61e8913
DC
1158 {
1159 sym = lookup_symbol_aux_block (name, mangled_name, block, namespace,
1160 symtab);
1161 if (sym != NULL)
1162 return sym;
1163 block = BLOCK_SUPERBLOCK (block);
1164 }
1165
e4051eeb
DC
1166 /* We've reached the static block. */
1167
1168 *static_block = block;
f61e8913
DC
1169 return NULL;
1170}
1171
1172/* Look up a symbol in a block; if found, locate its symtab, fixup the
1173 symbol, and set block_found appropriately. */
1174
1175static struct symbol *
1176lookup_symbol_aux_block (const char *name, const char *mangled_name,
1177 const struct block *block,
1178 const namespace_enum namespace,
1179 struct symtab **symtab)
1180{
1181 struct symbol *sym;
8155455b
DC
1182 struct objfile *objfile = NULL;
1183 struct blockvector *bv;
1184 struct block *b;
1185 struct symtab *s = NULL;
f61e8913
DC
1186
1187 sym = lookup_block_symbol (block, name, mangled_name, namespace);
1188 if (sym)
8155455b 1189 {
f61e8913
DC
1190 block_found = block;
1191 if (symtab != NULL)
8155455b 1192 {
f61e8913
DC
1193 /* Search the list of symtabs for one which contains the
1194 address of the start of this block. */
1195 ALL_SYMTABS (objfile, s)
8155455b 1196 {
f61e8913
DC
1197 bv = BLOCKVECTOR (s);
1198 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1199 if (BLOCK_START (b) <= BLOCK_START (block)
1200 && BLOCK_END (b) > BLOCK_START (block))
1201 goto found;
8155455b 1202 }
f61e8913
DC
1203 found:
1204 *symtab = s;
8155455b 1205 }
f61e8913
DC
1206
1207 return fixup_symbol_section (sym, objfile);
8155455b
DC
1208 }
1209
1210 return NULL;
1211}
1212
1213/* Check to see if the symbol is defined in one of the symtabs.
1214 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1215 depending on whether or not we want to search global symbols or
1216 static symbols. */
1217
1218static struct symbol *
1219lookup_symbol_aux_symtabs (int block_index,
1220 const char *name, const char *mangled_name,
1221 const namespace_enum namespace,
1222 struct symtab **symtab)
1223{
1224 struct symbol *sym;
1225 struct objfile *objfile;
1226 struct blockvector *bv;
1227 const struct block *block;
1228 struct symtab *s;
1229
1230 ALL_SYMTABS (objfile, s)
1231 {
1232 bv = BLOCKVECTOR (s);
1233 block = BLOCKVECTOR_BLOCK (bv, block_index);
1234 sym = lookup_block_symbol (block, name, mangled_name, namespace);
1235 if (sym)
1236 {
1237 block_found = block;
1238 if (symtab != NULL)
1239 *symtab = s;
1240 return fixup_symbol_section (sym, objfile);
1241 }
1242 }
1243
1244 return NULL;
1245}
1246
1247/* Check to see if the symbol is defined in one of the partial
1248 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1249 STATIC_BLOCK, depending on whether or not we want to search global
1250 symbols or static symbols. */
1251
1252static struct symbol *
1253lookup_symbol_aux_psymtabs (int block_index, const char *name,
1254 const char *mangled_name,
1255 const namespace_enum namespace,
1256 struct symtab **symtab)
1257{
1258 struct symbol *sym;
1259 struct objfile *objfile;
1260 struct blockvector *bv;
1261 const struct block *block;
1262 struct partial_symtab *ps;
1263 struct symtab *s;
1264 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0);
1265
1266 ALL_PSYMTABS (objfile, ps)
1267 {
1268 if (!ps->readin
3d4e8fd2
DC
1269 && lookup_partial_symbol (ps, name, mangled_name,
1270 psymtab_index, namespace))
8155455b
DC
1271 {
1272 s = PSYMTAB_TO_SYMTAB (ps);
1273 bv = BLOCKVECTOR (s);
1274 block = BLOCKVECTOR_BLOCK (bv, block_index);
1275 sym = lookup_block_symbol (block, name, mangled_name, namespace);
1276 if (!sym)
1277 {
1278 /* This shouldn't be necessary, but as a last resort try
1279 looking in the statics even though the psymtab claimed
1280 the symbol was global, or vice-versa. It's possible
1281 that the psymtab gets it wrong in some cases. */
1282
1283 /* FIXME: carlton/2002-09-30: Should we really do that?
1284 If that happens, isn't it likely to be a GDB error, in
1285 which case we should fix the GDB error rather than
1286 silently dealing with it here? So I'd vote for
1287 removing the check for the symbol in the other
1288 block. */
1289 block = BLOCKVECTOR_BLOCK (bv,
1290 block_index == GLOBAL_BLOCK ?
1291 STATIC_BLOCK : GLOBAL_BLOCK);
1292 sym = lookup_block_symbol (block, name, mangled_name, namespace);
1293 if (!sym)
1294 error ("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>).",
1295 block_index == GLOBAL_BLOCK ? "global" : "static",
1296 name, ps->filename, name, name);
1297 }
1298 if (symtab != NULL)
1299 *symtab = s;
1300 return fixup_symbol_section (sym, objfile);
1301 }
1302 }
1303
1304 return NULL;
1305}
1306
406bc4de
DC
1307/* Check for the possibility of the symbol being a function or a
1308 mangled variable that is stored in one of the minimal symbol
1309 tables. Eventually, all global symbols might be resolved in this
1310 way. */
1311
e45febe2
DC
1312/* NOTE: carlton/2002-12-05: At one point, this function was part of
1313 lookup_symbol_aux, and what are now 'return' statements within
1314 lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
1315 sym was NULL. As far as I can tell, this was basically accidental;
1316 it didn't happen every time that msymbol was non-NULL, but only if
1317 some additional conditions held as well, and it caused problems
1318 with HP-generated symbol tables. */
1319
406bc4de
DC
1320static struct symbol *
1321lookup_symbol_aux_minsyms (const char *name,
1322 const char *mangled_name,
1323 const namespace_enum namespace,
1324 int *is_a_field_of_this,
e45febe2 1325 struct symtab **symtab)
406bc4de
DC
1326{
1327 struct symbol *sym;
1328 struct blockvector *bv;
1329 const struct block *block;
1330 struct minimal_symbol *msymbol;
1331 struct symtab *s;
1332
1333 if (namespace == VAR_NAMESPACE)
1334 {
1335 msymbol = lookup_minimal_symbol (name, NULL, NULL);
1336
1337 if (msymbol != NULL)
1338 {
1339 /* OK, we found a minimal symbol in spite of not finding any
1340 symbol. There are various possible explanations for
1341 this. One possibility is the symbol exists in code not
1342 compiled -g. Another possibility is that the 'psymtab'
1343 isn't doing its job. A third possibility, related to #2,
1344 is that we were confused by name-mangling. For instance,
1345 maybe the psymtab isn't doing its job because it only
1346 know about demangled names, but we were given a mangled
1347 name... */
1348
1349 /* We first use the address in the msymbol to try to locate
1350 the appropriate symtab. Note that find_pc_sect_symtab()
1351 has a side-effect of doing psymtab-to-symtab expansion,
1352 for the found symtab. */
1353 s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
1354 SYMBOL_BFD_SECTION (msymbol));
1355 if (s != NULL)
1356 {
1357 /* This is a function which has a symtab for its address. */
1358 bv = BLOCKVECTOR (s);
1359 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1360
22abf04a 1361 /* This call used to pass `DEPRECATED_SYMBOL_NAME (msymbol)' as the
406bc4de
DC
1362 `name' argument to lookup_block_symbol. But the name
1363 of a minimal symbol is always mangled, so that seems
1364 to be clearly the wrong thing to pass as the
1365 unmangled name. */
1366 sym =
1367 lookup_block_symbol (block, name, mangled_name, namespace);
1368 /* We kept static functions in minimal symbol table as well as
1369 in static scope. We want to find them in the symbol table. */
1370 if (!sym)
1371 {
1372 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1373 sym = lookup_block_symbol (block, name,
1374 mangled_name, namespace);
1375 }
1376
1377 /* NOTE: carlton/2002-12-04: The following comment was
1378 taken from a time when two versions of this function
1379 were part of the body of lookup_symbol_aux: this
1380 comment was taken from the version of the function
1381 that was #ifdef HPUXHPPA, and the comment was right
1382 before the 'return NULL' part of lookup_symbol_aux.
1383 (Hence the "Fall through and return 0" comment.)
1384 Elena did some digging into the situation for
1385 Fortran, and she reports:
1386
1387 "I asked around (thanks to Jeff Knaggs), and I think
1388 the story for Fortran goes like this:
1389
1390 "Apparently, in older Fortrans, '_' was not part of
1391 the user namespace. g77 attached a final '_' to
1392 procedure names as the exported symbols for linkage
1393 (foo_) , but the symbols went in the debug info just
1394 like 'foo'. The rationale behind this is not
1395 completely clear, and maybe it was done to other
1396 symbols as well, not just procedures." */
1397
1398 /* If we get here with sym == 0, the symbol was
1399 found in the minimal symbol table
1400 but not in the symtab.
1401 Fall through and return 0 to use the msymbol
1402 definition of "foo_".
1403 (Note that outer code generally follows up a call
1404 to this routine with a call to lookup_minimal_symbol(),
1405 so a 0 return means we'll just flow into that other routine).
1406
1407 This happens for Fortran "foo_" symbols,
1408 which are "foo" in the symtab.
1409
1410 This can also happen if "asm" is used to make a
1411 regular symbol but not a debugging symbol, e.g.
1412 asm(".globl _main");
1413 asm("_main:");
1414 */
1415
1416 if (symtab != NULL && sym != NULL)
1417 *symtab = s;
406bc4de
DC
1418 return fixup_symbol_section (sym, s->objfile);
1419 }
1420 else if (MSYMBOL_TYPE (msymbol) != mst_text
1421 && MSYMBOL_TYPE (msymbol) != mst_file_text
22abf04a 1422 && !STREQ (name, DEPRECATED_SYMBOL_NAME (msymbol)))
406bc4de
DC
1423 {
1424 /* This is a mangled variable, look it up by its
1425 mangled name. */
22abf04a 1426 return lookup_symbol_aux (DEPRECATED_SYMBOL_NAME (msymbol), mangled_name,
406bc4de
DC
1427 NULL, namespace, is_a_field_of_this,
1428 symtab);
1429 }
1430 }
1431 }
1432
1433 return NULL;
1434}
1435
3d4e8fd2
DC
1436/* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1437 If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1438 linkage name matches it. Check the global symbols if GLOBAL, the
1439 static symbols if not */
c906108c
SS
1440
1441static struct partial_symbol *
3d4e8fd2
DC
1442lookup_partial_symbol (struct partial_symtab *pst, const char *name,
1443 const char *linkage_name, int global,
fba45db2 1444 namespace_enum namespace)
c906108c 1445{
357e46e7 1446 struct partial_symbol *temp;
c906108c 1447 struct partial_symbol **start, **psym;
38d49aff 1448 struct partial_symbol **top, **real_top, **bottom, **center;
c906108c
SS
1449 int length = (global ? pst->n_global_syms : pst->n_static_syms);
1450 int do_linear_search = 1;
357e46e7 1451
c906108c
SS
1452 if (length == 0)
1453 {
1454 return (NULL);
1455 }
c906108c
SS
1456 start = (global ?
1457 pst->objfile->global_psymbols.list + pst->globals_offset :
c5aa993b 1458 pst->objfile->static_psymbols.list + pst->statics_offset);
357e46e7 1459
c5aa993b 1460 if (global) /* This means we can use a binary search. */
c906108c
SS
1461 {
1462 do_linear_search = 0;
1463
1464 /* Binary search. This search is guaranteed to end with center
0fe19209
DC
1465 pointing at the earliest partial symbol whose name might be
1466 correct. At that point *all* partial symbols with an
1467 appropriate name will be checked against the correct
1468 namespace. */
c906108c
SS
1469
1470 bottom = start;
1471 top = start + length - 1;
38d49aff 1472 real_top = top;
c906108c
SS
1473 while (top > bottom)
1474 {
1475 center = bottom + (top - bottom) / 2;
1476 if (!(center < top))
e1e9e218 1477 internal_error (__FILE__, __LINE__, "failed internal consistency check");
c906108c 1478 if (!do_linear_search
357e46e7 1479 && (SYMBOL_LANGUAGE (*center) == language_java))
c906108c
SS
1480 {
1481 do_linear_search = 1;
1482 }
c8be8951 1483 if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center), name) >= 0)
c906108c
SS
1484 {
1485 top = center;
1486 }
1487 else
1488 {
1489 bottom = center + 1;
1490 }
1491 }
1492 if (!(top == bottom))
e1e9e218 1493 internal_error (__FILE__, __LINE__, "failed internal consistency check");
357e46e7 1494
3d4e8fd2
DC
1495 while (top <= real_top
1496 && (linkage_name != NULL
1497 ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0
1498 : SYMBOL_MATCHES_NATURAL_NAME (*top,name)))
c906108c
SS
1499 {
1500 if (SYMBOL_NAMESPACE (*top) == namespace)
1501 {
357e46e7 1502 return (*top);
c906108c 1503 }
c5aa993b 1504 top++;
c906108c
SS
1505 }
1506 }
1507
1508 /* Can't use a binary search or else we found during the binary search that
1509 we should also do a linear search. */
1510
1511 if (do_linear_search)
357e46e7 1512 {
c906108c
SS
1513 for (psym = start; psym < start + length; psym++)
1514 {
1515 if (namespace == SYMBOL_NAMESPACE (*psym))
1516 {
3d4e8fd2
DC
1517 if (linkage_name != NULL
1518 ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0
1519 : SYMBOL_MATCHES_NATURAL_NAME (*psym, name))
c906108c
SS
1520 {
1521 return (*psym);
1522 }
1523 }
1524 }
1525 }
1526
1527 return (NULL);
1528}
1529
1530/* Look up a type named NAME in the struct_namespace. The type returned
1531 must not be opaque -- i.e., must have at least one field defined
1532
1533 This code was modelled on lookup_symbol -- the parts not relevant to looking
1534 up types were just left out. In particular it's assumed here that types
1535 are available in struct_namespace and only at file-static or global blocks. */
1536
1537
1538struct type *
fba45db2 1539lookup_transparent_type (const char *name)
c906108c
SS
1540{
1541 register struct symbol *sym;
1542 register struct symtab *s = NULL;
1543 register struct partial_symtab *ps;
1544 struct blockvector *bv;
1545 register struct objfile *objfile;
1546 register struct block *block;
c906108c
SS
1547
1548 /* Now search all the global symbols. Do the symtab's first, then
1549 check the psymtab's. If a psymtab indicates the existence
1550 of the desired name as a global, then do psymtab-to-symtab
1551 conversion on the fly and return the found symbol. */
c5aa993b 1552
c906108c 1553 ALL_SYMTABS (objfile, s)
c5aa993b
JM
1554 {
1555 bv = BLOCKVECTOR (s);
1556 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
3121eff0 1557 sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
c5aa993b
JM
1558 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1559 {
1560 return SYMBOL_TYPE (sym);
1561 }
1562 }
c906108c
SS
1563
1564 ALL_PSYMTABS (objfile, ps)
c5aa993b 1565 {
3d4e8fd2
DC
1566 if (!ps->readin && lookup_partial_symbol (ps, name, NULL,
1567 1, STRUCT_NAMESPACE))
c5aa993b
JM
1568 {
1569 s = PSYMTAB_TO_SYMTAB (ps);
1570 bv = BLOCKVECTOR (s);
1571 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
3121eff0 1572 sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
c5aa993b
JM
1573 if (!sym)
1574 {
1575 /* This shouldn't be necessary, but as a last resort
1576 * try looking in the statics even though the psymtab
1577 * claimed the symbol was global. It's possible that
1578 * the psymtab gets it wrong in some cases.
1579 */
1580 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
3121eff0 1581 sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
c5aa993b
JM
1582 if (!sym)
1583 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
c906108c
SS
1584%s may be an inlined function, or may be a template function\n\
1585(if a template, try specifying an instantiation: %s<type>).",
c5aa993b
JM
1586 name, ps->filename, name, name);
1587 }
1588 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1589 return SYMBOL_TYPE (sym);
1590 }
1591 }
c906108c
SS
1592
1593 /* Now search the static file-level symbols.
1594 Not strictly correct, but more useful than an error.
1595 Do the symtab's first, then
1596 check the psymtab's. If a psymtab indicates the existence
1597 of the desired name as a file-level static, then do psymtab-to-symtab
1598 conversion on the fly and return the found symbol.
1599 */
1600
1601 ALL_SYMTABS (objfile, s)
c5aa993b
JM
1602 {
1603 bv = BLOCKVECTOR (s);
1604 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
3121eff0 1605 sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
c5aa993b
JM
1606 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1607 {
1608 return SYMBOL_TYPE (sym);
1609 }
1610 }
c906108c
SS
1611
1612 ALL_PSYMTABS (objfile, ps)
c5aa993b 1613 {
3d4e8fd2 1614 if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_NAMESPACE))
c5aa993b
JM
1615 {
1616 s = PSYMTAB_TO_SYMTAB (ps);
1617 bv = BLOCKVECTOR (s);
1618 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
3121eff0 1619 sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
c5aa993b
JM
1620 if (!sym)
1621 {
1622 /* This shouldn't be necessary, but as a last resort
1623 * try looking in the globals even though the psymtab
1624 * claimed the symbol was static. It's possible that
1625 * the psymtab gets it wrong in some cases.
1626 */
1627 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
3121eff0 1628 sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
c5aa993b
JM
1629 if (!sym)
1630 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
c906108c
SS
1631%s may be an inlined function, or may be a template function\n\
1632(if a template, try specifying an instantiation: %s<type>).",
c5aa993b
JM
1633 name, ps->filename, name, name);
1634 }
1635 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
1636 return SYMBOL_TYPE (sym);
1637 }
1638 }
c906108c
SS
1639 return (struct type *) 0;
1640}
1641
1642
1643/* Find the psymtab containing main(). */
1644/* FIXME: What about languages without main() or specially linked
1645 executables that have no main() ? */
1646
1647struct partial_symtab *
fba45db2 1648find_main_psymtab (void)
c906108c
SS
1649{
1650 register struct partial_symtab *pst;
1651 register struct objfile *objfile;
1652
1653 ALL_PSYMTABS (objfile, pst)
c5aa993b 1654 {
3d4e8fd2 1655 if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_NAMESPACE))
c5aa993b
JM
1656 {
1657 return (pst);
1658 }
1659 }
c906108c
SS
1660 return (NULL);
1661}
1662
1663/* Search BLOCK for symbol NAME in NAMESPACE.
1664
1665 Note that if NAME is the demangled form of a C++ symbol, we will fail
1666 to find a match during the binary search of the non-encoded names, but
1667 for now we don't worry about the slight inefficiency of looking for
1668 a match we'll never find, since it will go pretty quick. Once the
1669 binary search terminates, we drop through and do a straight linear
1bae87b9
AF
1670 search on the symbols. Each symbol which is marked as being a ObjC/C++
1671 symbol (language_cplus or language_objc set) has both the encoded and
1672 non-encoded names tested for a match.
3121eff0
DJ
1673
1674 If MANGLED_NAME is non-NULL, verify that any symbol we find has this
1675 particular mangled name.
1676*/
c906108c
SS
1677
1678struct symbol *
fba45db2 1679lookup_block_symbol (register const struct block *block, const char *name,
3121eff0 1680 const char *mangled_name,
fba45db2 1681 const namespace_enum namespace)
c906108c
SS
1682{
1683 register int bot, top, inc;
1684 register struct symbol *sym;
1685 register struct symbol *sym_found = NULL;
1686 register int do_linear_search = 1;
1687
261397f8
DJ
1688 if (BLOCK_HASHTABLE (block))
1689 {
1690 unsigned int hash_index;
1691 hash_index = msymbol_hash_iw (name);
1692 hash_index = hash_index % BLOCK_BUCKETS (block);
1693 for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next)
1694 {
1695 if (SYMBOL_NAMESPACE (sym) == namespace
1696 && (mangled_name
22abf04a 1697 ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0
8e437497 1698 : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
261397f8
DJ
1699 return sym;
1700 }
1701 return NULL;
1702 }
1703
c906108c
SS
1704 /* If the blocks's symbols were sorted, start with a binary search. */
1705
1706 if (BLOCK_SHOULD_SORT (block))
1707 {
1708 /* Reset the linear search flag so if the binary search fails, we
c5aa993b 1709 won't do the linear search once unless we find some reason to
fba7f19c 1710 do so */
c906108c
SS
1711
1712 do_linear_search = 0;
1713 top = BLOCK_NSYMS (block);
1714 bot = 0;
1715
1716 /* Advance BOT to not far before the first symbol whose name is NAME. */
1717
1718 while (1)
1719 {
1720 inc = (top - bot + 1);
1721 /* No need to keep binary searching for the last few bits worth. */
1722 if (inc < 4)
1723 {
1724 break;
1725 }
1726 inc = (inc >> 1) + bot;
1727 sym = BLOCK_SYM (block, inc);
fba7f19c 1728 if (!do_linear_search && (SYMBOL_LANGUAGE (sym) == language_java))
c906108c
SS
1729 {
1730 do_linear_search = 1;
1731 }
c8be8951 1732 if (SYMBOL_NATURAL_NAME (sym)[0] < name[0])
c906108c
SS
1733 {
1734 bot = inc;
1735 }
c8be8951 1736 else if (SYMBOL_NATURAL_NAME (sym)[0] > name[0])
c906108c
SS
1737 {
1738 top = inc;
1739 }
c8be8951 1740 else if (strcmp (SYMBOL_NATURAL_NAME (sym), name) < 0)
c906108c
SS
1741 {
1742 bot = inc;
1743 }
1744 else
1745 {
1746 top = inc;
1747 }
1748 }
1749
1750 /* Now scan forward until we run out of symbols, find one whose
c5aa993b
JM
1751 name is greater than NAME, or find one we want. If there is
1752 more than one symbol with the right name and namespace, we
1753 return the first one; I believe it is now impossible for us
1754 to encounter two symbols with the same name and namespace
1755 here, because blocks containing argument symbols are no
3121eff0
DJ
1756 longer sorted. The exception is for C++, where multiple functions
1757 (cloned constructors / destructors, in particular) can have
1758 the same demangled name. So if we have a particular
1759 mangled name to match, try to do so. */
c906108c
SS
1760
1761 top = BLOCK_NSYMS (block);
1762 while (bot < top)
1763 {
1764 sym = BLOCK_SYM (block, bot);
3121eff0
DJ
1765 if (SYMBOL_NAMESPACE (sym) == namespace
1766 && (mangled_name
22abf04a 1767 ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0
8e437497 1768 : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
c9049fc9
MC
1769 {
1770 return sym;
1771 }
de5ad195 1772 if (SYMBOL_PRINT_NAME (sym)[0] > name[0])
1ba7c32c
JM
1773 {
1774 break;
1775 }
c906108c
SS
1776 bot++;
1777 }
1778 }
1779
1780 /* Here if block isn't sorted, or we fail to find a match during the
1781 binary search above. If during the binary search above, we find a
8cc1c882 1782 symbol which is a Java symbol, then we have re-enabled the linear
c906108c
SS
1783 search flag which was reset when starting the binary search.
1784
1785 This loop is equivalent to the loop above, but hacked greatly for speed.
1786
1787 Note that parameter symbols do not always show up last in the
1788 list; this loop makes sure to take anything else other than
1789 parameter symbols first; it only uses parameter symbols as a
1790 last resort. Note that this only takes up extra computation
1791 time on a match. */
1792
1793 if (do_linear_search)
1794 {
1795 top = BLOCK_NSYMS (block);
1796 bot = 0;
1797 while (bot < top)
1798 {
1799 sym = BLOCK_SYM (block, bot);
3121eff0
DJ
1800 if (SYMBOL_NAMESPACE (sym) == namespace
1801 && (mangled_name
22abf04a 1802 ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0
8e437497 1803 : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
c906108c
SS
1804 {
1805 /* If SYM has aliases, then use any alias that is active
c5aa993b
JM
1806 at the current PC. If no alias is active at the current
1807 PC, then use the main symbol.
c906108c 1808
c5aa993b 1809 ?!? Is checking the current pc correct? Is this routine
a0b3c4fd
JM
1810 ever called to look up a symbol from another context?
1811
1812 FIXME: No, it's not correct. If someone sets a
1813 conditional breakpoint at an address, then the
1814 breakpoint's `struct expression' should refer to the
1815 `struct symbol' appropriate for the breakpoint's
1816 address, which may not be the PC.
1817
1818 Even if it were never called from another context,
1819 it's totally bizarre for lookup_symbol's behavior to
1820 depend on the value of the inferior's current PC. We
1821 should pass in the appropriate PC as well as the
1822 block. The interface to lookup_symbol should change
1823 to require the caller to provide a PC. */
1824
c5aa993b
JM
1825 if (SYMBOL_ALIASES (sym))
1826 sym = find_active_alias (sym, read_pc ());
c906108c
SS
1827
1828 sym_found = sym;
1829 if (SYMBOL_CLASS (sym) != LOC_ARG &&
1830 SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
1831 SYMBOL_CLASS (sym) != LOC_REF_ARG &&
1832 SYMBOL_CLASS (sym) != LOC_REGPARM &&
1833 SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
4c2df51b
DJ
1834 SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
1835 SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
c906108c
SS
1836 {
1837 break;
1838 }
1839 }
1840 bot++;
1841 }
1842 }
1843 return (sym_found); /* Will be NULL if not found. */
1844}
1845
1846/* Given a main symbol SYM and ADDR, search through the alias
1847 list to determine if an alias is active at ADDR and return
1848 the active alias.
1849
1850 If no alias is active, then return SYM. */
1851
1852static struct symbol *
fba45db2 1853find_active_alias (struct symbol *sym, CORE_ADDR addr)
c906108c
SS
1854{
1855 struct range_list *r;
1856 struct alias_list *aliases;
1857
1858 /* If we have aliases, check them first. */
1859 aliases = SYMBOL_ALIASES (sym);
1860
1861 while (aliases)
1862 {
1863 if (!SYMBOL_RANGES (aliases->sym))
c5aa993b 1864 return aliases->sym;
c906108c
SS
1865 for (r = SYMBOL_RANGES (aliases->sym); r; r = r->next)
1866 {
1867 if (r->start <= addr && r->end > addr)
1868 return aliases->sym;
1869 }
1870 aliases = aliases->next;
1871 }
1872
1873 /* Nothing found, return the main symbol. */
1874 return sym;
1875}
c906108c 1876\f
c5aa993b 1877
c906108c
SS
1878/* Find the symtab associated with PC and SECTION. Look through the
1879 psymtabs and read in another symtab if necessary. */
1880
1881struct symtab *
fba45db2 1882find_pc_sect_symtab (CORE_ADDR pc, asection *section)
c906108c
SS
1883{
1884 register struct block *b;
1885 struct blockvector *bv;
1886 register struct symtab *s = NULL;
1887 register struct symtab *best_s = NULL;
1888 register struct partial_symtab *ps;
1889 register struct objfile *objfile;
1890 CORE_ADDR distance = 0;
8a48e967
DJ
1891 struct minimal_symbol *msymbol;
1892
1893 /* If we know that this is not a text address, return failure. This is
1894 necessary because we loop based on the block's high and low code
1895 addresses, which do not include the data ranges, and because
1896 we call find_pc_sect_psymtab which has a similar restriction based
1897 on the partial_symtab's texthigh and textlow. */
1898 msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
1899 if (msymbol
1900 && (msymbol->type == mst_data
1901 || msymbol->type == mst_bss
1902 || msymbol->type == mst_abs
1903 || msymbol->type == mst_file_data
1904 || msymbol->type == mst_file_bss))
1905 return NULL;
c906108c
SS
1906
1907 /* Search all symtabs for the one whose file contains our address, and which
1908 is the smallest of all the ones containing the address. This is designed
1909 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1910 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1911 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1912
1913 This happens for native ecoff format, where code from included files
1914 gets its own symtab. The symtab for the included file should have
1915 been read in already via the dependency mechanism.
1916 It might be swifter to create several symtabs with the same name
1917 like xcoff does (I'm not sure).
1918
1919 It also happens for objfiles that have their functions reordered.
1920 For these, the symtab we are looking for is not necessarily read in. */
1921
1922 ALL_SYMTABS (objfile, s)
c5aa993b
JM
1923 {
1924 bv = BLOCKVECTOR (s);
1925 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
c906108c 1926
c5aa993b 1927 if (BLOCK_START (b) <= pc
c5aa993b 1928 && BLOCK_END (b) > pc
c5aa993b
JM
1929 && (distance == 0
1930 || BLOCK_END (b) - BLOCK_START (b) < distance))
1931 {
1932 /* For an objfile that has its functions reordered,
1933 find_pc_psymtab will find the proper partial symbol table
1934 and we simply return its corresponding symtab. */
1935 /* In order to better support objfiles that contain both
1936 stabs and coff debugging info, we continue on if a psymtab
1937 can't be found. */
1938 if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs)
1939 {
1940 ps = find_pc_sect_psymtab (pc, section);
1941 if (ps)
1942 return PSYMTAB_TO_SYMTAB (ps);
1943 }
1944 if (section != 0)
1945 {
1946 int i;
261397f8 1947 struct symbol *sym = NULL;
c906108c 1948
261397f8 1949 ALL_BLOCK_SYMBOLS (b, i, sym)
c5aa993b 1950 {
261397f8
DJ
1951 fixup_symbol_section (sym, objfile);
1952 if (section == SYMBOL_BFD_SECTION (sym))
c5aa993b
JM
1953 break;
1954 }
261397f8 1955 if ((i >= BLOCK_BUCKETS (b)) && (sym == NULL))
c5aa993b
JM
1956 continue; /* no symbol in this symtab matches section */
1957 }
1958 distance = BLOCK_END (b) - BLOCK_START (b);
1959 best_s = s;
1960 }
1961 }
c906108c
SS
1962
1963 if (best_s != NULL)
c5aa993b 1964 return (best_s);
c906108c
SS
1965
1966 s = NULL;
1967 ps = find_pc_sect_psymtab (pc, section);
1968 if (ps)
1969 {
1970 if (ps->readin)
1971 /* Might want to error() here (in case symtab is corrupt and
1972 will cause a core dump), but maybe we can successfully
1973 continue, so let's not. */
c906108c 1974 warning ("\
d730266b
AC
1975(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
1976 paddr_nz (pc));
c906108c
SS
1977 s = PSYMTAB_TO_SYMTAB (ps);
1978 }
1979 return (s);
1980}
1981
1982/* Find the symtab associated with PC. Look through the psymtabs and
1983 read in another symtab if necessary. Backward compatibility, no section */
1984
1985struct symtab *
fba45db2 1986find_pc_symtab (CORE_ADDR pc)
c906108c
SS
1987{
1988 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
1989}
c906108c 1990\f
c5aa993b 1991
7e73cedf 1992/* Find the source file and line number for a given PC value and SECTION.
c906108c
SS
1993 Return a structure containing a symtab pointer, a line number,
1994 and a pc range for the entire source line.
1995 The value's .pc field is NOT the specified pc.
1996 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1997 use the line that ends there. Otherwise, in that case, the line
1998 that begins there is used. */
1999
2000/* The big complication here is that a line may start in one file, and end just
2001 before the start of another file. This usually occurs when you #include
2002 code in the middle of a subroutine. To properly find the end of a line's PC
2003 range, we must search all symtabs associated with this compilation unit, and
2004 find the one whose first PC is closer than that of the next line in this
2005 symtab. */
2006
2007/* If it's worth the effort, we could be using a binary search. */
2008
2009struct symtab_and_line
fba45db2 2010find_pc_sect_line (CORE_ADDR pc, struct sec *section, int notcurrent)
c906108c
SS
2011{
2012 struct symtab *s;
2013 register struct linetable *l;
2014 register int len;
2015 register int i;
2016 register struct linetable_entry *item;
2017 struct symtab_and_line val;
2018 struct blockvector *bv;
2019 struct minimal_symbol *msymbol;
2020 struct minimal_symbol *mfunsym;
2021
2022 /* Info on best line seen so far, and where it starts, and its file. */
2023
2024 struct linetable_entry *best = NULL;
2025 CORE_ADDR best_end = 0;
2026 struct symtab *best_symtab = 0;
2027
2028 /* Store here the first line number
2029 of a file which contains the line at the smallest pc after PC.
2030 If we don't find a line whose range contains PC,
2031 we will use a line one less than this,
2032 with a range from the start of that file to the first line's pc. */
2033 struct linetable_entry *alt = NULL;
2034 struct symtab *alt_symtab = 0;
2035
2036 /* Info on best line seen in this file. */
2037
2038 struct linetable_entry *prev;
2039
2040 /* If this pc is not from the current frame,
2041 it is the address of the end of a call instruction.
2042 Quite likely that is the start of the following statement.
2043 But what we want is the statement containing the instruction.
2044 Fudge the pc to make sure we get that. */
2045
fe39c653 2046 init_sal (&val); /* initialize to zeroes */
c906108c 2047
b77b1eb7
JB
2048 /* It's tempting to assume that, if we can't find debugging info for
2049 any function enclosing PC, that we shouldn't search for line
2050 number info, either. However, GAS can emit line number info for
2051 assembly files --- very helpful when debugging hand-written
2052 assembly code. In such a case, we'd have no debug info for the
2053 function, but we would have line info. */
648f4f79 2054
c906108c
SS
2055 if (notcurrent)
2056 pc -= 1;
2057
c5aa993b 2058 /* elz: added this because this function returned the wrong
c906108c
SS
2059 information if the pc belongs to a stub (import/export)
2060 to call a shlib function. This stub would be anywhere between
2061 two functions in the target, and the line info was erroneously
2062 taken to be the one of the line before the pc.
c5aa993b 2063 */
c906108c 2064 /* RT: Further explanation:
c5aa993b 2065
c906108c
SS
2066 * We have stubs (trampolines) inserted between procedures.
2067 *
2068 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2069 * exists in the main image.
2070 *
2071 * In the minimal symbol table, we have a bunch of symbols
2072 * sorted by start address. The stubs are marked as "trampoline",
2073 * the others appear as text. E.g.:
2074 *
2075 * Minimal symbol table for main image
2076 * main: code for main (text symbol)
2077 * shr1: stub (trampoline symbol)
2078 * foo: code for foo (text symbol)
2079 * ...
2080 * Minimal symbol table for "shr1" image:
2081 * ...
2082 * shr1: code for shr1 (text symbol)
2083 * ...
2084 *
2085 * So the code below is trying to detect if we are in the stub
2086 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2087 * and if found, do the symbolization from the real-code address
2088 * rather than the stub address.
2089 *
2090 * Assumptions being made about the minimal symbol table:
2091 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2092 * if we're really in the trampoline. If we're beyond it (say
2093 * we're in "foo" in the above example), it'll have a closer
2094 * symbol (the "foo" text symbol for example) and will not
2095 * return the trampoline.
2096 * 2. lookup_minimal_symbol_text() will find a real text symbol
2097 * corresponding to the trampoline, and whose address will
2098 * be different than the trampoline address. I put in a sanity
2099 * check for the address being the same, to avoid an
2100 * infinite recursion.
2101 */
c5aa993b
JM
2102 msymbol = lookup_minimal_symbol_by_pc (pc);
2103 if (msymbol != NULL)
c906108c 2104 if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
c5aa993b 2105 {
22abf04a 2106 mfunsym = lookup_minimal_symbol_text (DEPRECATED_SYMBOL_NAME (msymbol), NULL, NULL);
c5aa993b
JM
2107 if (mfunsym == NULL)
2108 /* I eliminated this warning since it is coming out
2109 * in the following situation:
2110 * gdb shmain // test program with shared libraries
2111 * (gdb) break shr1 // function in shared lib
2112 * Warning: In stub for ...
2113 * In the above situation, the shared lib is not loaded yet,
2114 * so of course we can't find the real func/line info,
2115 * but the "break" still works, and the warning is annoying.
2116 * So I commented out the warning. RT */
22abf04a 2117 /* warning ("In stub for %s; unable to find real function/line info", DEPRECATED_SYMBOL_NAME (msymbol)) */ ;
c5aa993b
JM
2118 /* fall through */
2119 else if (SYMBOL_VALUE (mfunsym) == SYMBOL_VALUE (msymbol))
2120 /* Avoid infinite recursion */
2121 /* See above comment about why warning is commented out */
22abf04a 2122 /* warning ("In stub for %s; unable to find real function/line info", DEPRECATED_SYMBOL_NAME (msymbol)) */ ;
c5aa993b
JM
2123 /* fall through */
2124 else
2125 return find_pc_line (SYMBOL_VALUE (mfunsym), 0);
2126 }
c906108c
SS
2127
2128
2129 s = find_pc_sect_symtab (pc, section);
2130 if (!s)
2131 {
2132 /* if no symbol information, return previous pc */
2133 if (notcurrent)
2134 pc++;
2135 val.pc = pc;
2136 return val;
2137 }
2138
2139 bv = BLOCKVECTOR (s);
2140
2141 /* Look at all the symtabs that share this blockvector.
2142 They all have the same apriori range, that we found was right;
2143 but they have different line tables. */
2144
2145 for (; s && BLOCKVECTOR (s) == bv; s = s->next)
2146 {
2147 /* Find the best line in this symtab. */
2148 l = LINETABLE (s);
2149 if (!l)
c5aa993b 2150 continue;
c906108c
SS
2151 len = l->nitems;
2152 if (len <= 0)
2153 {
2154 /* I think len can be zero if the symtab lacks line numbers
2155 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2156 I'm not sure which, and maybe it depends on the symbol
2157 reader). */
2158 continue;
2159 }
2160
2161 prev = NULL;
2162 item = l->item; /* Get first line info */
2163
2164 /* Is this file's first line closer than the first lines of other files?
c5aa993b 2165 If so, record this file, and its first line, as best alternate. */
c906108c
SS
2166 if (item->pc > pc && (!alt || item->pc < alt->pc))
2167 {
2168 alt = item;
2169 alt_symtab = s;
2170 }
2171
2172 for (i = 0; i < len; i++, item++)
2173 {
2174 /* Leave prev pointing to the linetable entry for the last line
2175 that started at or before PC. */
2176 if (item->pc > pc)
2177 break;
2178
2179 prev = item;
2180 }
2181
2182 /* At this point, prev points at the line whose start addr is <= pc, and
c5aa993b
JM
2183 item points at the next line. If we ran off the end of the linetable
2184 (pc >= start of the last line), then prev == item. If pc < start of
2185 the first line, prev will not be set. */
c906108c
SS
2186
2187 /* Is this file's best line closer than the best in the other files?
083ae935
DJ
2188 If so, record this file, and its best line, as best so far. Don't
2189 save prev if it represents the end of a function (i.e. line number
2190 0) instead of a real line. */
c906108c 2191
083ae935 2192 if (prev && prev->line && (!best || prev->pc > best->pc))
c906108c
SS
2193 {
2194 best = prev;
2195 best_symtab = s;
25d53da1
KB
2196
2197 /* Discard BEST_END if it's before the PC of the current BEST. */
2198 if (best_end <= best->pc)
2199 best_end = 0;
c906108c 2200 }
25d53da1
KB
2201
2202 /* If another line (denoted by ITEM) is in the linetable and its
2203 PC is after BEST's PC, but before the current BEST_END, then
2204 use ITEM's PC as the new best_end. */
2205 if (best && i < len && item->pc > best->pc
2206 && (best_end == 0 || best_end > item->pc))
2207 best_end = item->pc;
c906108c
SS
2208 }
2209
2210 if (!best_symtab)
2211 {
2212 if (!alt_symtab)
2213 { /* If we didn't find any line # info, just
2214 return zeros. */
2215 val.pc = pc;
2216 }
2217 else
2218 {
2219 val.symtab = alt_symtab;
2220 val.line = alt->line - 1;
2221
2222 /* Don't return line 0, that means that we didn't find the line. */
c5aa993b
JM
2223 if (val.line == 0)
2224 ++val.line;
c906108c
SS
2225
2226 val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2227 val.end = alt->pc;
2228 }
2229 }
e8717518
FF
2230 else if (best->line == 0)
2231 {
2232 /* If our best fit is in a range of PC's for which no line
2233 number info is available (line number is zero) then we didn't
2234 find any valid line information. */
2235 val.pc = pc;
2236 }
c906108c
SS
2237 else
2238 {
2239 val.symtab = best_symtab;
2240 val.line = best->line;
2241 val.pc = best->pc;
2242 if (best_end && (!alt || best_end < alt->pc))
2243 val.end = best_end;
2244 else if (alt)
2245 val.end = alt->pc;
2246 else
2247 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
2248 }
2249 val.section = section;
2250 return val;
2251}
2252
2253/* Backward compatibility (no section) */
2254
2255struct symtab_and_line
fba45db2 2256find_pc_line (CORE_ADDR pc, int notcurrent)
c906108c 2257{
c5aa993b 2258 asection *section;
c906108c
SS
2259
2260 section = find_pc_overlay (pc);
2261 if (pc_in_unmapped_range (pc, section))
2262 pc = overlay_mapped_address (pc, section);
2263 return find_pc_sect_line (pc, section, notcurrent);
2264}
c906108c 2265\f
c906108c
SS
2266/* Find line number LINE in any symtab whose name is the same as
2267 SYMTAB.
2268
2269 If found, return the symtab that contains the linetable in which it was
2270 found, set *INDEX to the index in the linetable of the best entry
2271 found, and set *EXACT_MATCH nonzero if the value returned is an
2272 exact match.
2273
2274 If not found, return NULL. */
2275
50641945 2276struct symtab *
fba45db2 2277find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match)
c906108c
SS
2278{
2279 int exact;
2280
2281 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2282 so far seen. */
2283
2284 int best_index;
2285 struct linetable *best_linetable;
2286 struct symtab *best_symtab;
2287
2288 /* First try looking it up in the given symtab. */
2289 best_linetable = LINETABLE (symtab);
2290 best_symtab = symtab;
2291 best_index = find_line_common (best_linetable, line, &exact);
2292 if (best_index < 0 || !exact)
2293 {
2294 /* Didn't find an exact match. So we better keep looking for
c5aa993b
JM
2295 another symtab with the same name. In the case of xcoff,
2296 multiple csects for one source file (produced by IBM's FORTRAN
2297 compiler) produce multiple symtabs (this is unavoidable
2298 assuming csects can be at arbitrary places in memory and that
2299 the GLOBAL_BLOCK of a symtab has a begin and end address). */
c906108c
SS
2300
2301 /* BEST is the smallest linenumber > LINE so far seen,
c5aa993b
JM
2302 or 0 if none has been seen so far.
2303 BEST_INDEX and BEST_LINETABLE identify the item for it. */
c906108c
SS
2304 int best;
2305
2306 struct objfile *objfile;
2307 struct symtab *s;
2308
2309 if (best_index >= 0)
2310 best = best_linetable->item[best_index].line;
2311 else
2312 best = 0;
2313
2314 ALL_SYMTABS (objfile, s)
c5aa993b
JM
2315 {
2316 struct linetable *l;
2317 int ind;
c906108c 2318
c5aa993b
JM
2319 if (!STREQ (symtab->filename, s->filename))
2320 continue;
2321 l = LINETABLE (s);
2322 ind = find_line_common (l, line, &exact);
2323 if (ind >= 0)
2324 {
2325 if (exact)
2326 {
2327 best_index = ind;
2328 best_linetable = l;
2329 best_symtab = s;
2330 goto done;
2331 }
2332 if (best == 0 || l->item[ind].line < best)
2333 {
2334 best = l->item[ind].line;
2335 best_index = ind;
2336 best_linetable = l;
2337 best_symtab = s;
2338 }
2339 }
2340 }
c906108c 2341 }
c5aa993b 2342done:
c906108c
SS
2343 if (best_index < 0)
2344 return NULL;
2345
2346 if (index)
2347 *index = best_index;
2348 if (exact_match)
2349 *exact_match = exact;
2350
2351 return best_symtab;
2352}
2353\f
2354/* Set the PC value for a given source file and line number and return true.
2355 Returns zero for invalid line number (and sets the PC to 0).
2356 The source file is specified with a struct symtab. */
2357
2358int
fba45db2 2359find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc)
c906108c
SS
2360{
2361 struct linetable *l;
2362 int ind;
2363
2364 *pc = 0;
2365 if (symtab == 0)
2366 return 0;
2367
2368 symtab = find_line_symtab (symtab, line, &ind, NULL);
2369 if (symtab != NULL)
2370 {
2371 l = LINETABLE (symtab);
2372 *pc = l->item[ind].pc;
2373 return 1;
2374 }
2375 else
2376 return 0;
2377}
2378
2379/* Find the range of pc values in a line.
2380 Store the starting pc of the line into *STARTPTR
2381 and the ending pc (start of next line) into *ENDPTR.
2382 Returns 1 to indicate success.
2383 Returns 0 if could not find the specified line. */
2384
2385int
fba45db2
KB
2386find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr,
2387 CORE_ADDR *endptr)
c906108c
SS
2388{
2389 CORE_ADDR startaddr;
2390 struct symtab_and_line found_sal;
2391
2392 startaddr = sal.pc;
c5aa993b 2393 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr))
c906108c
SS
2394 return 0;
2395
2396 /* This whole function is based on address. For example, if line 10 has
2397 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2398 "info line *0x123" should say the line goes from 0x100 to 0x200
2399 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2400 This also insures that we never give a range like "starts at 0x134
2401 and ends at 0x12c". */
2402
2403 found_sal = find_pc_sect_line (startaddr, sal.section, 0);
2404 if (found_sal.line != sal.line)
2405 {
2406 /* The specified line (sal) has zero bytes. */
2407 *startptr = found_sal.pc;
2408 *endptr = found_sal.pc;
2409 }
2410 else
2411 {
2412 *startptr = found_sal.pc;
2413 *endptr = found_sal.end;
2414 }
2415 return 1;
2416}
2417
2418/* Given a line table and a line number, return the index into the line
2419 table for the pc of the nearest line whose number is >= the specified one.
2420 Return -1 if none is found. The value is >= 0 if it is an index.
2421
2422 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2423
2424static int
fba45db2
KB
2425find_line_common (register struct linetable *l, register int lineno,
2426 int *exact_match)
c906108c
SS
2427{
2428 register int i;
2429 register int len;
2430
2431 /* BEST is the smallest linenumber > LINENO so far seen,
2432 or 0 if none has been seen so far.
2433 BEST_INDEX identifies the item for it. */
2434
2435 int best_index = -1;
2436 int best = 0;
2437
2438 if (lineno <= 0)
2439 return -1;
2440 if (l == 0)
2441 return -1;
2442
2443 len = l->nitems;
2444 for (i = 0; i < len; i++)
2445 {
2446 register struct linetable_entry *item = &(l->item[i]);
2447
2448 if (item->line == lineno)
2449 {
2450 /* Return the first (lowest address) entry which matches. */
2451 *exact_match = 1;
2452 return i;
2453 }
2454
2455 if (item->line > lineno && (best == 0 || item->line < best))
2456 {
2457 best = item->line;
2458 best_index = i;
2459 }
2460 }
2461
2462 /* If we got here, we didn't get an exact match. */
2463
2464 *exact_match = 0;
2465 return best_index;
2466}
2467
2468int
fba45db2 2469find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
c906108c
SS
2470{
2471 struct symtab_and_line sal;
2472 sal = find_pc_line (pc, 0);
2473 *startptr = sal.pc;
2474 *endptr = sal.end;
2475 return sal.symtab != 0;
2476}
2477
2478/* Given a function symbol SYM, find the symtab and line for the start
2479 of the function.
2480 If the argument FUNFIRSTLINE is nonzero, we want the first line
2481 of real code inside the function. */
2482
50641945 2483struct symtab_and_line
fba45db2 2484find_function_start_sal (struct symbol *sym, int funfirstline)
c906108c
SS
2485{
2486 CORE_ADDR pc;
2487 struct symtab_and_line sal;
2488
2489 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2490 fixup_symbol_section (sym, NULL);
2491 if (funfirstline)
c5aa993b 2492 { /* skip "first line" of function (which is actually its prologue) */
c906108c
SS
2493 asection *section = SYMBOL_BFD_SECTION (sym);
2494 /* If function is in an unmapped overlay, use its unmapped LMA
c5aa993b 2495 address, so that SKIP_PROLOGUE has something unique to work on */
c906108c
SS
2496 if (section_is_overlay (section) &&
2497 !section_is_mapped (section))
2498 pc = overlay_unmapped_address (pc, section);
2499
2500 pc += FUNCTION_START_OFFSET;
b83266a0 2501 pc = SKIP_PROLOGUE (pc);
c906108c
SS
2502
2503 /* For overlays, map pc back into its mapped VMA range */
2504 pc = overlay_mapped_address (pc, section);
2505 }
2506 sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
2507
2508#ifdef PROLOGUE_FIRSTLINE_OVERLAP
2509 /* Convex: no need to suppress code on first line, if any */
2510 sal.pc = pc;
2511#else
2512 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2513 line is still part of the same function. */
2514 if (sal.pc != pc
2515 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end
2516 && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2517 {
2518 /* First pc of next line */
2519 pc = sal.end;
2520 /* Recalculate the line number (might not be N+1). */
2521 sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
2522 }
2523 sal.pc = pc;
2524#endif
2525
2526 return sal;
2527}
50641945 2528
c906108c
SS
2529/* If P is of the form "operator[ \t]+..." where `...' is
2530 some legitimate operator text, return a pointer to the
2531 beginning of the substring of the operator text.
2532 Otherwise, return "". */
2533char *
fba45db2 2534operator_chars (char *p, char **end)
c906108c
SS
2535{
2536 *end = "";
2537 if (strncmp (p, "operator", 8))
2538 return *end;
2539 p += 8;
2540
2541 /* Don't get faked out by `operator' being part of a longer
2542 identifier. */
c5aa993b 2543 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0')
c906108c
SS
2544 return *end;
2545
2546 /* Allow some whitespace between `operator' and the operator symbol. */
2547 while (*p == ' ' || *p == '\t')
2548 p++;
2549
2550 /* Recognize 'operator TYPENAME'. */
2551
c5aa993b 2552 if (isalpha (*p) || *p == '_' || *p == '$')
c906108c 2553 {
c5aa993b
JM
2554 register char *q = p + 1;
2555 while (isalnum (*q) || *q == '_' || *q == '$')
c906108c
SS
2556 q++;
2557 *end = q;
2558 return p;
2559 }
2560
53e8ad3d
MS
2561 while (*p)
2562 switch (*p)
2563 {
2564 case '\\': /* regexp quoting */
2565 if (p[1] == '*')
2566 {
2567 if (p[2] == '=') /* 'operator\*=' */
2568 *end = p + 3;
2569 else /* 'operator\*' */
2570 *end = p + 2;
2571 return p;
2572 }
2573 else if (p[1] == '[')
2574 {
2575 if (p[2] == ']')
2576 error ("mismatched quoting on brackets, try 'operator\\[\\]'");
2577 else if (p[2] == '\\' && p[3] == ']')
2578 {
2579 *end = p + 4; /* 'operator\[\]' */
2580 return p;
2581 }
2582 else
2583 error ("nothing is allowed between '[' and ']'");
2584 }
2585 else
2586 {
2587 /* Gratuitous qoute: skip it and move on. */
2588 p++;
2589 continue;
2590 }
2591 break;
2592 case '!':
2593 case '=':
2594 case '*':
2595 case '/':
2596 case '%':
2597 case '^':
2598 if (p[1] == '=')
2599 *end = p + 2;
2600 else
2601 *end = p + 1;
2602 return p;
2603 case '<':
2604 case '>':
2605 case '+':
2606 case '-':
2607 case '&':
2608 case '|':
2609 if (p[0] == '-' && p[1] == '>')
2610 {
2611 /* Struct pointer member operator 'operator->'. */
2612 if (p[2] == '*')
2613 {
2614 *end = p + 3; /* 'operator->*' */
2615 return p;
2616 }
2617 else if (p[2] == '\\')
2618 {
2619 *end = p + 4; /* Hopefully 'operator->\*' */
2620 return p;
2621 }
2622 else
2623 {
2624 *end = p + 2; /* 'operator->' */
2625 return p;
2626 }
2627 }
2628 if (p[1] == '=' || p[1] == p[0])
2629 *end = p + 2;
2630 else
2631 *end = p + 1;
2632 return p;
2633 case '~':
2634 case ',':
c5aa993b 2635 *end = p + 1;
53e8ad3d
MS
2636 return p;
2637 case '(':
2638 if (p[1] != ')')
2639 error ("`operator ()' must be specified without whitespace in `()'");
c5aa993b 2640 *end = p + 2;
53e8ad3d
MS
2641 return p;
2642 case '?':
2643 if (p[1] != ':')
2644 error ("`operator ?:' must be specified without whitespace in `?:'");
2645 *end = p + 2;
2646 return p;
2647 case '[':
2648 if (p[1] != ']')
2649 error ("`operator []' must be specified without whitespace in `[]'");
2650 *end = p + 2;
2651 return p;
2652 default:
2653 error ("`operator %s' not supported", p);
2654 break;
2655 }
2656
c906108c
SS
2657 *end = "";
2658 return *end;
2659}
c906108c 2660\f
c5aa993b 2661
c94fdfd0
EZ
2662/* If FILE is not already in the table of files, return zero;
2663 otherwise return non-zero. Optionally add FILE to the table if ADD
2664 is non-zero. If *FIRST is non-zero, forget the old table
2665 contents. */
2666static int
2667filename_seen (const char *file, int add, int *first)
c906108c 2668{
c94fdfd0
EZ
2669 /* Table of files seen so far. */
2670 static const char **tab = NULL;
c906108c
SS
2671 /* Allocated size of tab in elements.
2672 Start with one 256-byte block (when using GNU malloc.c).
2673 24 is the malloc overhead when range checking is in effect. */
2674 static int tab_alloc_size = (256 - 24) / sizeof (char *);
2675 /* Current size of tab in elements. */
2676 static int tab_cur_size;
c94fdfd0 2677 const char **p;
c906108c
SS
2678
2679 if (*first)
2680 {
2681 if (tab == NULL)
c94fdfd0 2682 tab = (const char **) xmalloc (tab_alloc_size * sizeof (*tab));
c906108c
SS
2683 tab_cur_size = 0;
2684 }
2685
c94fdfd0 2686 /* Is FILE in tab? */
c906108c 2687 for (p = tab; p < tab + tab_cur_size; p++)
c94fdfd0
EZ
2688 if (strcmp (*p, file) == 0)
2689 return 1;
2690
2691 /* No; maybe add it to tab. */
2692 if (add)
c906108c 2693 {
c94fdfd0
EZ
2694 if (tab_cur_size == tab_alloc_size)
2695 {
2696 tab_alloc_size *= 2;
2697 tab = (const char **) xrealloc ((char *) tab,
2698 tab_alloc_size * sizeof (*tab));
2699 }
2700 tab[tab_cur_size++] = file;
c906108c 2701 }
c906108c 2702
c94fdfd0
EZ
2703 return 0;
2704}
2705
2706/* Slave routine for sources_info. Force line breaks at ,'s.
2707 NAME is the name to print and *FIRST is nonzero if this is the first
2708 name printed. Set *FIRST to zero. */
2709static void
2710output_source_filename (char *name, int *first)
2711{
2712 /* Since a single source file can result in several partial symbol
2713 tables, we need to avoid printing it more than once. Note: if
2714 some of the psymtabs are read in and some are not, it gets
2715 printed both under "Source files for which symbols have been
2716 read" and "Source files for which symbols will be read in on
2717 demand". I consider this a reasonable way to deal with the
2718 situation. I'm not sure whether this can also happen for
2719 symtabs; it doesn't hurt to check. */
2720
2721 /* Was NAME already seen? */
2722 if (filename_seen (name, 1, first))
2723 {
2724 /* Yes; don't print it again. */
2725 return;
2726 }
2727 /* No; print it and reset *FIRST. */
c906108c
SS
2728 if (*first)
2729 {
2730 *first = 0;
2731 }
2732 else
2733 {
2734 printf_filtered (", ");
2735 }
2736
2737 wrap_here ("");
2738 fputs_filtered (name, gdb_stdout);
c5aa993b 2739}
c906108c
SS
2740
2741static void
fba45db2 2742sources_info (char *ignore, int from_tty)
c906108c
SS
2743{
2744 register struct symtab *s;
2745 register struct partial_symtab *ps;
2746 register struct objfile *objfile;
2747 int first;
c5aa993b 2748
c906108c
SS
2749 if (!have_full_symbols () && !have_partial_symbols ())
2750 {
e85428fc 2751 error ("No symbol table is loaded. Use the \"file\" command.");
c906108c 2752 }
c5aa993b 2753
c906108c
SS
2754 printf_filtered ("Source files for which symbols have been read in:\n\n");
2755
2756 first = 1;
2757 ALL_SYMTABS (objfile, s)
c5aa993b
JM
2758 {
2759 output_source_filename (s->filename, &first);
2760 }
c906108c 2761 printf_filtered ("\n\n");
c5aa993b 2762
c906108c
SS
2763 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2764
2765 first = 1;
2766 ALL_PSYMTABS (objfile, ps)
c5aa993b
JM
2767 {
2768 if (!ps->readin)
2769 {
2770 output_source_filename (ps->filename, &first);
2771 }
2772 }
c906108c
SS
2773 printf_filtered ("\n");
2774}
2775
2776static int
fd118b61 2777file_matches (char *file, char *files[], int nfiles)
c906108c
SS
2778{
2779 int i;
2780
2781 if (file != NULL && nfiles != 0)
2782 {
2783 for (i = 0; i < nfiles; i++)
c5aa993b 2784 {
31889e00 2785 if (strcmp (files[i], lbasename (file)) == 0)
c5aa993b
JM
2786 return 1;
2787 }
c906108c
SS
2788 }
2789 else if (nfiles == 0)
2790 return 1;
2791 return 0;
2792}
2793
2794/* Free any memory associated with a search. */
2795void
fba45db2 2796free_search_symbols (struct symbol_search *symbols)
c906108c
SS
2797{
2798 struct symbol_search *p;
2799 struct symbol_search *next;
2800
2801 for (p = symbols; p != NULL; p = next)
2802 {
2803 next = p->next;
b8c9b27d 2804 xfree (p);
c906108c
SS
2805 }
2806}
2807
5bd98722
AC
2808static void
2809do_free_search_symbols_cleanup (void *symbols)
2810{
2811 free_search_symbols (symbols);
2812}
2813
2814struct cleanup *
2815make_cleanup_free_search_symbols (struct symbol_search *symbols)
2816{
2817 return make_cleanup (do_free_search_symbols_cleanup, symbols);
2818}
2819
434d2d4f
DJ
2820/* Helper function for sort_search_symbols and qsort. Can only
2821 sort symbols, not minimal symbols. */
2822static int
2823compare_search_syms (const void *sa, const void *sb)
2824{
2825 struct symbol_search **sym_a = (struct symbol_search **) sa;
2826 struct symbol_search **sym_b = (struct symbol_search **) sb;
2827
de5ad195
DC
2828 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol),
2829 SYMBOL_PRINT_NAME ((*sym_b)->symbol));
434d2d4f
DJ
2830}
2831
2832/* Sort the ``nfound'' symbols in the list after prevtail. Leave
2833 prevtail where it is, but update its next pointer to point to
2834 the first of the sorted symbols. */
2835static struct symbol_search *
2836sort_search_symbols (struct symbol_search *prevtail, int nfound)
2837{
2838 struct symbol_search **symbols, *symp, *old_next;
2839 int i;
2840
2841 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
2842 * nfound);
2843 symp = prevtail->next;
2844 for (i = 0; i < nfound; i++)
2845 {
2846 symbols[i] = symp;
2847 symp = symp->next;
2848 }
2849 /* Generally NULL. */
2850 old_next = symp;
2851
2852 qsort (symbols, nfound, sizeof (struct symbol_search *),
2853 compare_search_syms);
2854
2855 symp = prevtail;
2856 for (i = 0; i < nfound; i++)
2857 {
2858 symp->next = symbols[i];
2859 symp = symp->next;
2860 }
2861 symp->next = old_next;
2862
8ed32cc0 2863 xfree (symbols);
434d2d4f
DJ
2864 return symp;
2865}
5bd98722 2866
c906108c
SS
2867/* Search the symbol table for matches to the regular expression REGEXP,
2868 returning the results in *MATCHES.
2869
2870 Only symbols of KIND are searched:
c5aa993b
JM
2871 FUNCTIONS_NAMESPACE - search all functions
2872 TYPES_NAMESPACE - search all type names
2873 METHODS_NAMESPACE - search all methods NOT IMPLEMENTED
2874 VARIABLES_NAMESPACE - search all symbols, excluding functions, type names,
2875 and constants (enums)
c906108c
SS
2876
2877 free_search_symbols should be called when *MATCHES is no longer needed.
434d2d4f
DJ
2878
2879 The results are sorted locally; each symtab's global and static blocks are
2880 separately alphabetized.
c5aa993b 2881 */
c906108c 2882void
fd118b61
KB
2883search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[],
2884 struct symbol_search **matches)
c906108c
SS
2885{
2886 register struct symtab *s;
2887 register struct partial_symtab *ps;
2888 register struct blockvector *bv;
2889 struct blockvector *prev_bv = 0;
2890 register struct block *b;
2891 register int i = 0;
2892 register int j;
2893 register struct symbol *sym;
2894 struct partial_symbol **psym;
2895 struct objfile *objfile;
2896 struct minimal_symbol *msymbol;
2897 char *val;
2898 int found_misc = 0;
2899 static enum minimal_symbol_type types[]
c5aa993b
JM
2900 =
2901 {mst_data, mst_text, mst_abs, mst_unknown};
c906108c 2902 static enum minimal_symbol_type types2[]
c5aa993b
JM
2903 =
2904 {mst_bss, mst_file_text, mst_abs, mst_unknown};
c906108c 2905 static enum minimal_symbol_type types3[]
c5aa993b
JM
2906 =
2907 {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
c906108c 2908 static enum minimal_symbol_type types4[]
c5aa993b
JM
2909 =
2910 {mst_file_bss, mst_text, mst_abs, mst_unknown};
c906108c
SS
2911 enum minimal_symbol_type ourtype;
2912 enum minimal_symbol_type ourtype2;
2913 enum minimal_symbol_type ourtype3;
2914 enum minimal_symbol_type ourtype4;
2915 struct symbol_search *sr;
2916 struct symbol_search *psr;
2917 struct symbol_search *tail;
2918 struct cleanup *old_chain = NULL;
2919
993f3aa5 2920 if (kind < VARIABLES_NAMESPACE)
c906108c
SS
2921 error ("must search on specific namespace");
2922
52204a0b
DT
2923 ourtype = types[(int) (kind - VARIABLES_NAMESPACE)];
2924 ourtype2 = types2[(int) (kind - VARIABLES_NAMESPACE)];
2925 ourtype3 = types3[(int) (kind - VARIABLES_NAMESPACE)];
2926 ourtype4 = types4[(int) (kind - VARIABLES_NAMESPACE)];
c906108c
SS
2927
2928 sr = *matches = NULL;
2929 tail = NULL;
2930
2931 if (regexp != NULL)
2932 {
2933 /* Make sure spacing is right for C++ operators.
2934 This is just a courtesy to make the matching less sensitive
2935 to how many spaces the user leaves between 'operator'
2936 and <TYPENAME> or <OPERATOR>. */
2937 char *opend;
2938 char *opname = operator_chars (regexp, &opend);
2939 if (*opname)
c5aa993b
JM
2940 {
2941 int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
2942 if (isalpha (*opname) || *opname == '_' || *opname == '$')
2943 {
2944 /* There should 1 space between 'operator' and 'TYPENAME'. */
2945 if (opname[-1] != ' ' || opname[-2] == ' ')
2946 fix = 1;
2947 }
2948 else
2949 {
2950 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2951 if (opname[-1] == ' ')
2952 fix = 0;
2953 }
2954 /* If wrong number of spaces, fix it. */
2955 if (fix >= 0)
2956 {
045f55a6 2957 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
c5aa993b
JM
2958 sprintf (tmp, "operator%.*s%s", fix, " ", opname);
2959 regexp = tmp;
2960 }
2961 }
2962
c906108c 2963 if (0 != (val = re_comp (regexp)))
c5aa993b 2964 error ("Invalid regexp (%s): %s", val, regexp);
c906108c
SS
2965 }
2966
2967 /* Search through the partial symtabs *first* for all symbols
2968 matching the regexp. That way we don't have to reproduce all of
2969 the machinery below. */
2970
2971 ALL_PSYMTABS (objfile, ps)
c5aa993b
JM
2972 {
2973 struct partial_symbol **bound, **gbound, **sbound;
2974 int keep_going = 1;
2975
2976 if (ps->readin)
2977 continue;
2978
2979 gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2980 sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2981 bound = gbound;
2982
2983 /* Go through all of the symbols stored in a partial
2984 symtab in one loop. */
2985 psym = objfile->global_psymbols.list + ps->globals_offset;
2986 while (keep_going)
2987 {
2988 if (psym >= bound)
2989 {
2990 if (bound == gbound && ps->n_static_syms != 0)
2991 {
2992 psym = objfile->static_psymbols.list + ps->statics_offset;
2993 bound = sbound;
2994 }
2995 else
2996 keep_going = 0;
2997 continue;
2998 }
2999 else
3000 {
3001 QUIT;
3002
3003 /* If it would match (logic taken from loop below)
3004 load the file and go on to the next one */
3005 if (file_matches (ps->filename, files, nfiles)
25120b0d
DC
3006 && ((regexp == NULL
3007 || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0)
c5aa993b
JM
3008 && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
3009 && SYMBOL_CLASS (*psym) != LOC_BLOCK)
3010 || (kind == FUNCTIONS_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_BLOCK)
3011 || (kind == TYPES_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
3012 || (kind == METHODS_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_BLOCK))))
3013 {
3014 PSYMTAB_TO_SYMTAB (ps);
3015 keep_going = 0;
3016 }
3017 }
3018 psym++;
3019 }
3020 }
c906108c
SS
3021
3022 /* Here, we search through the minimal symbol tables for functions
3023 and variables that match, and force their symbols to be read.
3024 This is in particular necessary for demangled variable names,
3025 which are no longer put into the partial symbol tables.
3026 The symbol will then be found during the scan of symtabs below.
3027
3028 For functions, find_pc_symtab should succeed if we have debug info
3029 for the function, for variables we have to call lookup_symbol
3030 to determine if the variable has debug info.
3031 If the lookup fails, set found_misc so that we will rescan to print
3032 any matching symbols without debug info.
c5aa993b 3033 */
c906108c
SS
3034
3035 if (nfiles == 0 && (kind == VARIABLES_NAMESPACE || kind == FUNCTIONS_NAMESPACE))
3036 {
3037 ALL_MSYMBOLS (objfile, msymbol)
c5aa993b
JM
3038 {
3039 if (MSYMBOL_TYPE (msymbol) == ourtype ||
3040 MSYMBOL_TYPE (msymbol) == ourtype2 ||
3041 MSYMBOL_TYPE (msymbol) == ourtype3 ||
3042 MSYMBOL_TYPE (msymbol) == ourtype4)
3043 {
25120b0d
DC
3044 if (regexp == NULL
3045 || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
c5aa993b
JM
3046 {
3047 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
3048 {
b1262a02
DC
3049 /* FIXME: carlton/2003-02-04: Given that the
3050 semantics of lookup_symbol keeps on changing
3051 slightly, it would be a nice idea if we had a
3052 function lookup_symbol_minsym that found the
3053 symbol associated to a given minimal symbol (if
3054 any). */
3055 if (kind == FUNCTIONS_NAMESPACE
22abf04a 3056 || lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol),
b1262a02
DC
3057 (struct block *) NULL,
3058 VAR_NAMESPACE,
3059 0, (struct symtab **) NULL) == NULL)
3060 found_misc = 1;
c5aa993b
JM
3061 }
3062 }
3063 }
3064 }
c906108c
SS
3065 }
3066
3067 ALL_SYMTABS (objfile, s)
c5aa993b
JM
3068 {
3069 bv = BLOCKVECTOR (s);
3070 /* Often many files share a blockvector.
3071 Scan each blockvector only once so that
3072 we don't get every symbol many times.
3073 It happens that the first symtab in the list
3074 for any given blockvector is the main file. */
3075 if (bv != prev_bv)
3076 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
3077 {
434d2d4f
DJ
3078 struct symbol_search *prevtail = tail;
3079 int nfound = 0;
c5aa993b 3080 b = BLOCKVECTOR_BLOCK (bv, i);
261397f8 3081 ALL_BLOCK_SYMBOLS (b, j, sym)
c5aa993b
JM
3082 {
3083 QUIT;
c5aa993b 3084 if (file_matches (s->filename, files, nfiles)
25120b0d
DC
3085 && ((regexp == NULL
3086 || re_exec (SYMBOL_NATURAL_NAME (sym)) != 0)
c5aa993b
JM
3087 && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (sym) != LOC_TYPEDEF
3088 && SYMBOL_CLASS (sym) != LOC_BLOCK
3089 && SYMBOL_CLASS (sym) != LOC_CONST)
3090 || (kind == FUNCTIONS_NAMESPACE && SYMBOL_CLASS (sym) == LOC_BLOCK)
3091 || (kind == TYPES_NAMESPACE && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3092 || (kind == METHODS_NAMESPACE && SYMBOL_CLASS (sym) == LOC_BLOCK))))
3093 {
3094 /* match */
3095 psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
3096 psr->block = i;
3097 psr->symtab = s;
3098 psr->symbol = sym;
3099 psr->msymbol = NULL;
3100 psr->next = NULL;
3101 if (tail == NULL)
434d2d4f 3102 sr = psr;
c5aa993b
JM
3103 else
3104 tail->next = psr;
3105 tail = psr;
434d2d4f
DJ
3106 nfound ++;
3107 }
3108 }
3109 if (nfound > 0)
3110 {
3111 if (prevtail == NULL)
3112 {
3113 struct symbol_search dummy;
3114
3115 dummy.next = sr;
3116 tail = sort_search_symbols (&dummy, nfound);
3117 sr = dummy.next;
3118
3119 old_chain = make_cleanup_free_search_symbols (sr);
c5aa993b 3120 }
434d2d4f
DJ
3121 else
3122 tail = sort_search_symbols (prevtail, nfound);
c5aa993b
JM
3123 }
3124 }
3125 prev_bv = bv;
3126 }
c906108c
SS
3127
3128 /* If there are no eyes, avoid all contact. I mean, if there are
3129 no debug symbols, then print directly from the msymbol_vector. */
3130
3131 if (found_misc || kind != FUNCTIONS_NAMESPACE)
3132 {
3133 ALL_MSYMBOLS (objfile, msymbol)
c5aa993b
JM
3134 {
3135 if (MSYMBOL_TYPE (msymbol) == ourtype ||
3136 MSYMBOL_TYPE (msymbol) == ourtype2 ||
3137 MSYMBOL_TYPE (msymbol) == ourtype3 ||
3138 MSYMBOL_TYPE (msymbol) == ourtype4)
3139 {
25120b0d
DC
3140 if (regexp == NULL
3141 || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
c5aa993b
JM
3142 {
3143 /* Functions: Look up by address. */
3144 if (kind != FUNCTIONS_NAMESPACE ||
3145 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
3146 {
3147 /* Variables/Absolutes: Look up by name */
22abf04a 3148 if (lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol),
c5aa993b
JM
3149 (struct block *) NULL, VAR_NAMESPACE,
3150 0, (struct symtab **) NULL) == NULL)
3151 {
3152 /* match */
3153 psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
3154 psr->block = i;
3155 psr->msymbol = msymbol;
3156 psr->symtab = NULL;
3157 psr->symbol = NULL;
3158 psr->next = NULL;
3159 if (tail == NULL)
3160 {
3161 sr = psr;
5bd98722 3162 old_chain = make_cleanup_free_search_symbols (sr);
c5aa993b
JM
3163 }
3164 else
3165 tail->next = psr;
3166 tail = psr;
3167 }
3168 }
3169 }
3170 }
3171 }
c906108c
SS
3172 }
3173
3174 *matches = sr;
3175 if (sr != NULL)
3176 discard_cleanups (old_chain);
3177}
3178
3179/* Helper function for symtab_symbol_info, this function uses
3180 the data returned from search_symbols() to print information
3181 regarding the match to gdb_stdout.
c5aa993b 3182 */
c906108c 3183static void
fba45db2
KB
3184print_symbol_info (namespace_enum kind, struct symtab *s, struct symbol *sym,
3185 int block, char *last)
c906108c
SS
3186{
3187 if (last == NULL || strcmp (last, s->filename) != 0)
3188 {
3189 fputs_filtered ("\nFile ", gdb_stdout);
3190 fputs_filtered (s->filename, gdb_stdout);
3191 fputs_filtered (":\n", gdb_stdout);
3192 }
3193
3194 if (kind != TYPES_NAMESPACE && block == STATIC_BLOCK)
3195 printf_filtered ("static ");
c5aa993b 3196
c906108c
SS
3197 /* Typedef that is not a C++ class */
3198 if (kind == TYPES_NAMESPACE
3199 && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
a5238fbc 3200 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
c906108c 3201 /* variable, func, or typedef-that-is-c++-class */
c5aa993b
JM
3202 else if (kind < TYPES_NAMESPACE ||
3203 (kind == TYPES_NAMESPACE &&
3204 SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE))
c906108c
SS
3205 {
3206 type_print (SYMBOL_TYPE (sym),
c5aa993b 3207 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
de5ad195 3208 ? "" : SYMBOL_PRINT_NAME (sym)),
c5aa993b 3209 gdb_stdout, 0);
c906108c
SS
3210
3211 printf_filtered (";\n");
3212 }
c906108c
SS
3213}
3214
3215/* This help function for symtab_symbol_info() prints information
3216 for non-debugging symbols to gdb_stdout.
c5aa993b 3217 */
c906108c 3218static void
fba45db2 3219print_msymbol_info (struct minimal_symbol *msymbol)
c906108c 3220{
3ac4495a
MS
3221 char *tmp;
3222
3223 if (TARGET_ADDR_BIT <= 32)
14a5e767
AC
3224 tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol)
3225 & (CORE_ADDR) 0xffffffff,
3226 "08l");
3ac4495a 3227 else
14a5e767
AC
3228 tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol),
3229 "016l");
3ac4495a 3230 printf_filtered ("%s %s\n",
de5ad195 3231 tmp, SYMBOL_PRINT_NAME (msymbol));
c906108c
SS
3232}
3233
3234/* This is the guts of the commands "info functions", "info types", and
3235 "info variables". It calls search_symbols to find all matches and then
3236 print_[m]symbol_info to print out some useful information about the
3237 matches.
c5aa993b 3238 */
c906108c 3239static void
fba45db2 3240symtab_symbol_info (char *regexp, namespace_enum kind, int from_tty)
c906108c
SS
3241{
3242 static char *classnames[]
c5aa993b
JM
3243 =
3244 {"variable", "function", "type", "method"};
c906108c
SS
3245 struct symbol_search *symbols;
3246 struct symbol_search *p;
3247 struct cleanup *old_chain;
3248 char *last_filename = NULL;
3249 int first = 1;
3250
3251 /* must make sure that if we're interrupted, symbols gets freed */
3252 search_symbols (regexp, kind, 0, (char **) NULL, &symbols);
5bd98722 3253 old_chain = make_cleanup_free_search_symbols (symbols);
c906108c
SS
3254
3255 printf_filtered (regexp
c5aa993b
JM
3256 ? "All %ss matching regular expression \"%s\":\n"
3257 : "All defined %ss:\n",
52204a0b 3258 classnames[(int) (kind - VARIABLES_NAMESPACE)], regexp);
c906108c
SS
3259
3260 for (p = symbols; p != NULL; p = p->next)
3261 {
3262 QUIT;
3263
3264 if (p->msymbol != NULL)
c5aa993b
JM
3265 {
3266 if (first)
3267 {
3268 printf_filtered ("\nNon-debugging symbols:\n");
3269 first = 0;
3270 }
3271 print_msymbol_info (p->msymbol);
3272 }
c906108c 3273 else
c5aa993b
JM
3274 {
3275 print_symbol_info (kind,
3276 p->symtab,
3277 p->symbol,
3278 p->block,
3279 last_filename);
3280 last_filename = p->symtab->filename;
3281 }
c906108c
SS
3282 }
3283
3284 do_cleanups (old_chain);
3285}
3286
3287static void
fba45db2 3288variables_info (char *regexp, int from_tty)
c906108c
SS
3289{
3290 symtab_symbol_info (regexp, VARIABLES_NAMESPACE, from_tty);
3291}
3292
3293static void
fba45db2 3294functions_info (char *regexp, int from_tty)
c906108c
SS
3295{
3296 symtab_symbol_info (regexp, FUNCTIONS_NAMESPACE, from_tty);
3297}
3298
357e46e7 3299
c906108c 3300static void
fba45db2 3301types_info (char *regexp, int from_tty)
c906108c
SS
3302{
3303 symtab_symbol_info (regexp, TYPES_NAMESPACE, from_tty);
3304}
3305
c906108c 3306/* Breakpoint all functions matching regular expression. */
8926118c 3307
8b93c638 3308void
fba45db2 3309rbreak_command_wrapper (char *regexp, int from_tty)
8b93c638
JM
3310{
3311 rbreak_command (regexp, from_tty);
3312}
8926118c 3313
c906108c 3314static void
fba45db2 3315rbreak_command (char *regexp, int from_tty)
c906108c
SS
3316{
3317 struct symbol_search *ss;
3318 struct symbol_search *p;
3319 struct cleanup *old_chain;
3320
3321 search_symbols (regexp, FUNCTIONS_NAMESPACE, 0, (char **) NULL, &ss);
5bd98722 3322 old_chain = make_cleanup_free_search_symbols (ss);
c906108c
SS
3323
3324 for (p = ss; p != NULL; p = p->next)
3325 {
3326 if (p->msymbol == NULL)
c5aa993b
JM
3327 {
3328 char *string = (char *) alloca (strlen (p->symtab->filename)
22abf04a 3329 + strlen (DEPRECATED_SYMBOL_NAME (p->symbol))
c5aa993b
JM
3330 + 4);
3331 strcpy (string, p->symtab->filename);
3332 strcat (string, ":'");
22abf04a 3333 strcat (string, DEPRECATED_SYMBOL_NAME (p->symbol));
c5aa993b
JM
3334 strcat (string, "'");
3335 break_command (string, from_tty);
3336 print_symbol_info (FUNCTIONS_NAMESPACE,
3337 p->symtab,
3338 p->symbol,
3339 p->block,
3340 p->symtab->filename);
3341 }
c906108c 3342 else
c5aa993b 3343 {
22abf04a 3344 break_command (DEPRECATED_SYMBOL_NAME (p->msymbol), from_tty);
c5aa993b 3345 printf_filtered ("<function, no debug info> %s;\n",
de5ad195 3346 SYMBOL_PRINT_NAME (p->msymbol));
c5aa993b 3347 }
c906108c
SS
3348 }
3349
3350 do_cleanups (old_chain);
3351}
c906108c 3352\f
c5aa993b 3353
c906108c
SS
3354/* Helper routine for make_symbol_completion_list. */
3355
3356static int return_val_size;
3357static int return_val_index;
3358static char **return_val;
3359
3360#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3361 do { \
3362 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
3363 /* Put only the mangled name on the list. */ \
3364 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
3365 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
3366 completion_list_add_name \
3367 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
3368 else \
3369 completion_list_add_name \
22abf04a 3370 (DEPRECATED_SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
c906108c
SS
3371 } while (0)
3372
3373/* Test to see if the symbol specified by SYMNAME (which is already
c5aa993b
JM
3374 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3375 characters. If so, add it to the current completion list. */
c906108c
SS
3376
3377static void
fba45db2
KB
3378completion_list_add_name (char *symname, char *sym_text, int sym_text_len,
3379 char *text, char *word)
c906108c
SS
3380{
3381 int newsize;
3382 int i;
3383
3384 /* clip symbols that cannot match */
3385
3386 if (strncmp (symname, sym_text, sym_text_len) != 0)
3387 {
3388 return;
3389 }
3390
c906108c
SS
3391 /* We have a match for a completion, so add SYMNAME to the current list
3392 of matches. Note that the name is moved to freshly malloc'd space. */
3393
3394 {
3395 char *new;
3396 if (word == sym_text)
3397 {
3398 new = xmalloc (strlen (symname) + 5);
3399 strcpy (new, symname);
3400 }
3401 else if (word > sym_text)
3402 {
3403 /* Return some portion of symname. */
3404 new = xmalloc (strlen (symname) + 5);
3405 strcpy (new, symname + (word - sym_text));
3406 }
3407 else
3408 {
3409 /* Return some of SYM_TEXT plus symname. */
3410 new = xmalloc (strlen (symname) + (sym_text - word) + 5);
3411 strncpy (new, word, sym_text - word);
3412 new[sym_text - word] = '\0';
3413 strcat (new, symname);
3414 }
3415
c906108c
SS
3416 if (return_val_index + 3 > return_val_size)
3417 {
3418 newsize = (return_val_size *= 2) * sizeof (char *);
3419 return_val = (char **) xrealloc ((char *) return_val, newsize);
3420 }
3421 return_val[return_val_index++] = new;
3422 return_val[return_val_index] = NULL;
3423 }
3424}
3425
c94fdfd0
EZ
3426/* Return a NULL terminated array of all symbols (regardless of class)
3427 which begin by matching TEXT. If the answer is no symbols, then
3428 the return value is an array which contains only a NULL pointer.
c906108c
SS
3429
3430 Problem: All of the symbols have to be copied because readline frees them.
3431 I'm not going to worry about this; hopefully there won't be that many. */
3432
3433char **
fba45db2 3434make_symbol_completion_list (char *text, char *word)
c906108c
SS
3435{
3436 register struct symbol *sym;
3437 register struct symtab *s;
3438 register struct partial_symtab *ps;
3439 register struct minimal_symbol *msymbol;
3440 register struct objfile *objfile;
3441 register struct block *b, *surrounding_static_block = 0;
3442 register int i, j;
3443 struct partial_symbol **psym;
3444 /* The symbol we are completing on. Points in same buffer as text. */
3445 char *sym_text;
3446 /* Length of sym_text. */
3447 int sym_text_len;
3448
3449 /* Now look for the symbol we are supposed to complete on.
3450 FIXME: This should be language-specific. */
3451 {
3452 char *p;
3453 char quote_found;
3454 char *quote_pos = NULL;
3455
3456 /* First see if this is a quoted string. */
3457 quote_found = '\0';
3458 for (p = text; *p != '\0'; ++p)
3459 {
3460 if (quote_found != '\0')
3461 {
3462 if (*p == quote_found)
3463 /* Found close quote. */
3464 quote_found = '\0';
3465 else if (*p == '\\' && p[1] == quote_found)
3466 /* A backslash followed by the quote character
c5aa993b 3467 doesn't end the string. */
c906108c
SS
3468 ++p;
3469 }
3470 else if (*p == '\'' || *p == '"')
3471 {
3472 quote_found = *p;
3473 quote_pos = p;
3474 }
3475 }
3476 if (quote_found == '\'')
3477 /* A string within single quotes can be a symbol, so complete on it. */
3478 sym_text = quote_pos + 1;
3479 else if (quote_found == '"')
3480 /* A double-quoted string is never a symbol, nor does it make sense
c5aa993b 3481 to complete it any other way. */
c94fdfd0
EZ
3482 {
3483 return_val = (char **) xmalloc (sizeof (char *));
3484 return_val[0] = NULL;
3485 return return_val;
3486 }
c906108c
SS
3487 else
3488 {
3489 /* It is not a quoted string. Break it based on the characters
3490 which are in symbols. */
3491 while (p > text)
3492 {
3493 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3494 --p;
3495 else
3496 break;
3497 }
3498 sym_text = p;
3499 }
3500 }
3501
3502 sym_text_len = strlen (sym_text);
3503
3504 return_val_size = 100;
3505 return_val_index = 0;
3506 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3507 return_val[0] = NULL;
3508
3509 /* Look through the partial symtabs for all symbols which begin
3510 by matching SYM_TEXT. Add each one that you find to the list. */
3511
3512 ALL_PSYMTABS (objfile, ps)
c5aa993b
JM
3513 {
3514 /* If the psymtab's been read in we'll get it when we search
3515 through the blockvector. */
3516 if (ps->readin)
3517 continue;
3518
3519 for (psym = objfile->global_psymbols.list + ps->globals_offset;
3520 psym < (objfile->global_psymbols.list + ps->globals_offset
3521 + ps->n_global_syms);
3522 psym++)
3523 {
3524 /* If interrupted, then quit. */
3525 QUIT;
3526 COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
3527 }
3528
3529 for (psym = objfile->static_psymbols.list + ps->statics_offset;
3530 psym < (objfile->static_psymbols.list + ps->statics_offset
3531 + ps->n_static_syms);
3532 psym++)
3533 {
3534 QUIT;
3535 COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word);
3536 }
3537 }
c906108c
SS
3538
3539 /* At this point scan through the misc symbol vectors and add each
3540 symbol you find to the list. Eventually we want to ignore
3541 anything that isn't a text symbol (everything else will be
3542 handled by the psymtab code above). */
3543
3544 ALL_MSYMBOLS (objfile, msymbol)
c5aa993b
JM
3545 {
3546 QUIT;
3547 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
3548 }
c906108c
SS
3549
3550 /* Search upwards from currently selected frame (so that we can
3551 complete on local vars. */
3552
ae767bfb 3553 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
c906108c
SS
3554 {
3555 if (!BLOCK_SUPERBLOCK (b))
3556 {
c5aa993b 3557 surrounding_static_block = b; /* For elmin of dups */
c906108c 3558 }
c5aa993b 3559
c906108c 3560 /* Also catch fields of types defined in this places which match our
c5aa993b 3561 text string. Only complete on types visible from current context. */
c906108c 3562
e88c90f2 3563 ALL_BLOCK_SYMBOLS (b, i, sym)
c906108c 3564 {
c906108c
SS
3565 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3566 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3567 {
3568 struct type *t = SYMBOL_TYPE (sym);
3569 enum type_code c = TYPE_CODE (t);
3570
3571 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
3572 {
3573 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
3574 {
3575 if (TYPE_FIELD_NAME (t, j))
3576 {
3577 completion_list_add_name (TYPE_FIELD_NAME (t, j),
c5aa993b 3578 sym_text, sym_text_len, text, word);
c906108c
SS
3579 }
3580 }
3581 }
3582 }
3583 }
3584 }
3585
3586 /* Go through the symtabs and check the externs and statics for
3587 symbols which match. */
3588
3589 ALL_SYMTABS (objfile, s)
c5aa993b
JM
3590 {
3591 QUIT;
3592 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
e88c90f2 3593 ALL_BLOCK_SYMBOLS (b, i, sym)
c5aa993b 3594 {
c5aa993b
JM
3595 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3596 }
3597 }
c906108c
SS
3598
3599 ALL_SYMTABS (objfile, s)
c5aa993b
JM
3600 {
3601 QUIT;
3602 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
3603 /* Don't do this block twice. */
3604 if (b == surrounding_static_block)
3605 continue;
e88c90f2 3606 ALL_BLOCK_SYMBOLS (b, i, sym)
c5aa993b 3607 {
c5aa993b
JM
3608 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3609 }
3610 }
c906108c
SS
3611
3612 return (return_val);
3613}
3614
c94fdfd0
EZ
3615/* Like make_symbol_completion_list, but returns a list of symbols
3616 defined in a source file FILE. */
3617
3618char **
3619make_file_symbol_completion_list (char *text, char *word, char *srcfile)
3620{
3621 register struct symbol *sym;
3622 register struct symtab *s;
3623 register struct block *b;
3624 register int i;
3625 /* The symbol we are completing on. Points in same buffer as text. */
3626 char *sym_text;
3627 /* Length of sym_text. */
3628 int sym_text_len;
3629
3630 /* Now look for the symbol we are supposed to complete on.
3631 FIXME: This should be language-specific. */
3632 {
3633 char *p;
3634 char quote_found;
3635 char *quote_pos = NULL;
3636
3637 /* First see if this is a quoted string. */
3638 quote_found = '\0';
3639 for (p = text; *p != '\0'; ++p)
3640 {
3641 if (quote_found != '\0')
3642 {
3643 if (*p == quote_found)
3644 /* Found close quote. */
3645 quote_found = '\0';
3646 else if (*p == '\\' && p[1] == quote_found)
3647 /* A backslash followed by the quote character
3648 doesn't end the string. */
3649 ++p;
3650 }
3651 else if (*p == '\'' || *p == '"')
3652 {
3653 quote_found = *p;
3654 quote_pos = p;
3655 }
3656 }
3657 if (quote_found == '\'')
3658 /* A string within single quotes can be a symbol, so complete on it. */
3659 sym_text = quote_pos + 1;
3660 else if (quote_found == '"')
3661 /* A double-quoted string is never a symbol, nor does it make sense
3662 to complete it any other way. */
3663 {
3664 return_val = (char **) xmalloc (sizeof (char *));
3665 return_val[0] = NULL;
3666 return return_val;
3667 }
3668 else
3669 {
3670 /* It is not a quoted string. Break it based on the characters
3671 which are in symbols. */
3672 while (p > text)
3673 {
3674 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
3675 --p;
3676 else
3677 break;
3678 }
3679 sym_text = p;
3680 }
3681 }
3682
3683 sym_text_len = strlen (sym_text);
3684
3685 return_val_size = 10;
3686 return_val_index = 0;
3687 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3688 return_val[0] = NULL;
3689
3690 /* Find the symtab for SRCFILE (this loads it if it was not yet read
3691 in). */
3692 s = lookup_symtab (srcfile);
3693 if (s == NULL)
3694 {
3695 /* Maybe they typed the file with leading directories, while the
3696 symbol tables record only its basename. */
31889e00 3697 const char *tail = lbasename (srcfile);
c94fdfd0
EZ
3698
3699 if (tail > srcfile)
3700 s = lookup_symtab (tail);
3701 }
3702
3703 /* If we have no symtab for that file, return an empty list. */
3704 if (s == NULL)
3705 return (return_val);
3706
3707 /* Go through this symtab and check the externs and statics for
3708 symbols which match. */
3709
3710 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
e88c90f2 3711 ALL_BLOCK_SYMBOLS (b, i, sym)
c94fdfd0 3712 {
c94fdfd0
EZ
3713 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3714 }
3715
3716 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
e88c90f2 3717 ALL_BLOCK_SYMBOLS (b, i, sym)
c94fdfd0 3718 {
c94fdfd0
EZ
3719 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3720 }
3721
3722 return (return_val);
3723}
3724
3725/* A helper function for make_source_files_completion_list. It adds
3726 another file name to a list of possible completions, growing the
3727 list as necessary. */
3728
3729static void
3730add_filename_to_list (const char *fname, char *text, char *word,
3731 char ***list, int *list_used, int *list_alloced)
3732{
3733 char *new;
3734 size_t fnlen = strlen (fname);
3735
3736 if (*list_used + 1 >= *list_alloced)
3737 {
3738 *list_alloced *= 2;
3739 *list = (char **) xrealloc ((char *) *list,
3740 *list_alloced * sizeof (char *));
3741 }
3742
3743 if (word == text)
3744 {
3745 /* Return exactly fname. */
3746 new = xmalloc (fnlen + 5);
3747 strcpy (new, fname);
3748 }
3749 else if (word > text)
3750 {
3751 /* Return some portion of fname. */
3752 new = xmalloc (fnlen + 5);
3753 strcpy (new, fname + (word - text));
3754 }
3755 else
3756 {
3757 /* Return some of TEXT plus fname. */
3758 new = xmalloc (fnlen + (text - word) + 5);
3759 strncpy (new, word, text - word);
3760 new[text - word] = '\0';
3761 strcat (new, fname);
3762 }
3763 (*list)[*list_used] = new;
3764 (*list)[++*list_used] = NULL;
3765}
3766
3767static int
3768not_interesting_fname (const char *fname)
3769{
3770 static const char *illegal_aliens[] = {
3771 "_globals_", /* inserted by coff_symtab_read */
3772 NULL
3773 };
3774 int i;
3775
3776 for (i = 0; illegal_aliens[i]; i++)
3777 {
3778 if (strcmp (fname, illegal_aliens[i]) == 0)
3779 return 1;
3780 }
3781 return 0;
3782}
3783
3784/* Return a NULL terminated array of all source files whose names
3785 begin with matching TEXT. The file names are looked up in the
3786 symbol tables of this program. If the answer is no matchess, then
3787 the return value is an array which contains only a NULL pointer. */
3788
3789char **
3790make_source_files_completion_list (char *text, char *word)
3791{
3792 register struct symtab *s;
3793 register struct partial_symtab *ps;
3794 register struct objfile *objfile;
3795 int first = 1;
3796 int list_alloced = 1;
3797 int list_used = 0;
3798 size_t text_len = strlen (text);
3799 char **list = (char **) xmalloc (list_alloced * sizeof (char *));
31889e00 3800 const char *base_name;
c94fdfd0
EZ
3801
3802 list[0] = NULL;
3803
3804 if (!have_full_symbols () && !have_partial_symbols ())
3805 return list;
3806
3807 ALL_SYMTABS (objfile, s)
3808 {
3809 if (not_interesting_fname (s->filename))
3810 continue;
3811 if (!filename_seen (s->filename, 1, &first)
3812#if HAVE_DOS_BASED_FILE_SYSTEM
3813 && strncasecmp (s->filename, text, text_len) == 0
3814#else
3815 && strncmp (s->filename, text, text_len) == 0
3816#endif
3817 )
3818 {
3819 /* This file matches for a completion; add it to the current
3820 list of matches. */
3821 add_filename_to_list (s->filename, text, word,
3822 &list, &list_used, &list_alloced);
3823 }
3824 else
3825 {
3826 /* NOTE: We allow the user to type a base name when the
3827 debug info records leading directories, but not the other
3828 way around. This is what subroutines of breakpoint
3829 command do when they parse file names. */
31889e00 3830 base_name = lbasename (s->filename);
c94fdfd0
EZ
3831 if (base_name != s->filename
3832 && !filename_seen (base_name, 1, &first)
3833#if HAVE_DOS_BASED_FILE_SYSTEM
3834 && strncasecmp (base_name, text, text_len) == 0
3835#else
3836 && strncmp (base_name, text, text_len) == 0
3837#endif
3838 )
3839 add_filename_to_list (base_name, text, word,
3840 &list, &list_used, &list_alloced);
3841 }
3842 }
3843
3844 ALL_PSYMTABS (objfile, ps)
3845 {
3846 if (not_interesting_fname (ps->filename))
3847 continue;
3848 if (!ps->readin)
3849 {
3850 if (!filename_seen (ps->filename, 1, &first)
3851#if HAVE_DOS_BASED_FILE_SYSTEM
3852 && strncasecmp (ps->filename, text, text_len) == 0
3853#else
3854 && strncmp (ps->filename, text, text_len) == 0
3855#endif
3856 )
3857 {
3858 /* This file matches for a completion; add it to the
3859 current list of matches. */
3860 add_filename_to_list (ps->filename, text, word,
3861 &list, &list_used, &list_alloced);
3862
3863 }
3864 else
3865 {
31889e00 3866 base_name = lbasename (ps->filename);
c94fdfd0
EZ
3867 if (base_name != ps->filename
3868 && !filename_seen (base_name, 1, &first)
3869#if HAVE_DOS_BASED_FILE_SYSTEM
3870 && strncasecmp (base_name, text, text_len) == 0
3871#else
3872 && strncmp (base_name, text, text_len) == 0
3873#endif
3874 )
3875 add_filename_to_list (base_name, text, word,
3876 &list, &list_used, &list_alloced);
3877 }
3878 }
3879 }
3880
3881 return list;
3882}
3883
c906108c
SS
3884/* Determine if PC is in the prologue of a function. The prologue is the area
3885 between the first instruction of a function, and the first executable line.
3886 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3887
3888 If non-zero, func_start is where we think the prologue starts, possibly
3889 by previous examination of symbol table information.
3890 */
3891
3892int
fba45db2 3893in_prologue (CORE_ADDR pc, CORE_ADDR func_start)
c906108c
SS
3894{
3895 struct symtab_and_line sal;
3896 CORE_ADDR func_addr, func_end;
3897
54cf9c03
EZ
3898 /* We have several sources of information we can consult to figure
3899 this out.
3900 - Compilers usually emit line number info that marks the prologue
3901 as its own "source line". So the ending address of that "line"
3902 is the end of the prologue. If available, this is the most
3903 reliable method.
3904 - The minimal symbols and partial symbols, which can usually tell
3905 us the starting and ending addresses of a function.
3906 - If we know the function's start address, we can call the
3907 architecture-defined SKIP_PROLOGUE function to analyze the
3908 instruction stream and guess where the prologue ends.
3909 - Our `func_start' argument; if non-zero, this is the caller's
3910 best guess as to the function's entry point. At the time of
3911 this writing, handle_inferior_event doesn't get this right, so
3912 it should be our last resort. */
3913
3914 /* Consult the partial symbol table, to find which function
3915 the PC is in. */
3916 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end))
3917 {
3918 CORE_ADDR prologue_end;
c906108c 3919
54cf9c03
EZ
3920 /* We don't even have minsym information, so fall back to using
3921 func_start, if given. */
3922 if (! func_start)
3923 return 1; /* We *might* be in a prologue. */
c906108c 3924
54cf9c03 3925 prologue_end = SKIP_PROLOGUE (func_start);
c906108c 3926
54cf9c03
EZ
3927 return func_start <= pc && pc < prologue_end;
3928 }
c906108c 3929
54cf9c03
EZ
3930 /* If we have line number information for the function, that's
3931 usually pretty reliable. */
3932 sal = find_pc_line (func_addr, 0);
c906108c 3933
54cf9c03
EZ
3934 /* Now sal describes the source line at the function's entry point,
3935 which (by convention) is the prologue. The end of that "line",
3936 sal.end, is the end of the prologue.
3937
3938 Note that, for functions whose source code is all on a single
3939 line, the line number information doesn't always end up this way.
3940 So we must verify that our purported end-of-prologue address is
3941 *within* the function, not at its start or end. */
3942 if (sal.line == 0
3943 || sal.end <= func_addr
3944 || func_end <= sal.end)
3945 {
3946 /* We don't have any good line number info, so use the minsym
3947 information, together with the architecture-specific prologue
3948 scanning code. */
3949 CORE_ADDR prologue_end = SKIP_PROLOGUE (func_addr);
c906108c 3950
54cf9c03
EZ
3951 return func_addr <= pc && pc < prologue_end;
3952 }
c906108c 3953
54cf9c03
EZ
3954 /* We have line number info, and it looks good. */
3955 return func_addr <= pc && pc < sal.end;
c906108c
SS
3956}
3957
3958
3959/* Begin overload resolution functions */
228c6d41
DJ
3960
3961static char *
3962remove_params (const char *demangled_name)
3963{
3964 const char *argp;
3965 char *new_name;
3966 int depth;
3967
3968 if (demangled_name == NULL)
3969 return NULL;
3970
3971 /* First find the end of the arg list. */
3972 argp = strrchr (demangled_name, ')');
3973 if (argp == NULL)
3974 return NULL;
3975
3976 /* Back up to the beginning. */
3977 depth = 1;
3978
3979 while (argp-- > demangled_name)
3980 {
3981 if (*argp == ')')
3982 depth ++;
3983 else if (*argp == '(')
3984 {
3985 depth --;
3986
3987 if (depth == 0)
3988 break;
3989 }
3990 }
3991 if (depth != 0)
3992 internal_error (__FILE__, __LINE__,
3993 "bad demangled name %s\n", demangled_name);
3994 while (argp[-1] == ' ' && argp > demangled_name)
3995 argp --;
3996
3997 new_name = xmalloc (argp - demangled_name + 1);
3998 memcpy (new_name, demangled_name, argp - demangled_name);
3999 new_name[argp - demangled_name] = '\0';
4000 return new_name;
4001}
4002
c906108c
SS
4003/* Helper routine for make_symbol_completion_list. */
4004
4005static int sym_return_val_size;
4006static int sym_return_val_index;
4007static struct symbol **sym_return_val;
4008
4009/* Test to see if the symbol specified by SYMNAME (which is already
c5aa993b
JM
4010 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4011 characters. If so, add it to the current completion list. */
c906108c
SS
4012
4013static void
fba45db2 4014overload_list_add_symbol (struct symbol *sym, char *oload_name)
c906108c
SS
4015{
4016 int newsize;
4017 int i;
228c6d41
DJ
4018 char *sym_name;
4019
4020 /* If there is no type information, we can't do anything, so skip */
4021 if (SYMBOL_TYPE (sym) == NULL)
4022 return;
4023
4024 /* skip any symbols that we've already considered. */
4025 for (i = 0; i < sym_return_val_index; ++i)
22abf04a 4026 if (!strcmp (DEPRECATED_SYMBOL_NAME (sym), DEPRECATED_SYMBOL_NAME (sym_return_val[i])))
228c6d41 4027 return;
c906108c
SS
4028
4029 /* Get the demangled name without parameters */
228c6d41 4030 sym_name = remove_params (SYMBOL_DEMANGLED_NAME (sym));
c906108c 4031 if (!sym_name)
228c6d41 4032 return;
c906108c
SS
4033
4034 /* skip symbols that cannot match */
4035 if (strcmp (sym_name, oload_name) != 0)
917317f4 4036 {
b8c9b27d 4037 xfree (sym_name);
917317f4
JM
4038 return;
4039 }
c906108c 4040
228c6d41 4041 xfree (sym_name);
c906108c
SS
4042
4043 /* We have a match for an overload instance, so add SYM to the current list
4044 * of overload instances */
4045 if (sym_return_val_index + 3 > sym_return_val_size)
4046 {
4047 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
4048 sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
4049 }
4050 sym_return_val[sym_return_val_index++] = sym;
4051 sym_return_val[sym_return_val_index] = NULL;
c906108c
SS
4052}
4053
4054/* Return a null-terminated list of pointers to function symbols that
4055 * match name of the supplied symbol FSYM.
4056 * This is used in finding all overloaded instances of a function name.
4057 * This has been modified from make_symbol_completion_list. */
4058
4059
4060struct symbol **
fba45db2 4061make_symbol_overload_list (struct symbol *fsym)
c906108c
SS
4062{
4063 register struct symbol *sym;
4064 register struct symtab *s;
4065 register struct partial_symtab *ps;
c906108c
SS
4066 register struct objfile *objfile;
4067 register struct block *b, *surrounding_static_block = 0;
d4f3574e 4068 register int i;
c906108c
SS
4069 /* The name we are completing on. */
4070 char *oload_name = NULL;
4071 /* Length of name. */
4072 int oload_name_len = 0;
4073
228c6d41 4074 /* Look for the symbol we are supposed to complete on. */
c906108c 4075
228c6d41 4076 oload_name = remove_params (SYMBOL_DEMANGLED_NAME (fsym));
c906108c
SS
4077 if (!oload_name)
4078 {
228c6d41
DJ
4079 sym_return_val_size = 1;
4080 sym_return_val = (struct symbol **) xmalloc (2 * sizeof (struct symbol *));
4081 sym_return_val[0] = fsym;
4082 sym_return_val[1] = NULL;
4083
4084 return sym_return_val;
c906108c
SS
4085 }
4086 oload_name_len = strlen (oload_name);
4087
4088 sym_return_val_size = 100;
4089 sym_return_val_index = 0;
4090 sym_return_val = (struct symbol **) xmalloc ((sym_return_val_size + 1) * sizeof (struct symbol *));
4091 sym_return_val[0] = NULL;
4092
49fa1dc2
DC
4093 /* Read in all partial symtabs containing a partial symbol named
4094 OLOAD_NAME. */
c906108c
SS
4095
4096 ALL_PSYMTABS (objfile, ps)
c5aa993b 4097 {
d4f3574e
SS
4098 struct partial_symbol **psym;
4099
c5aa993b
JM
4100 /* If the psymtab's been read in we'll get it when we search
4101 through the blockvector. */
4102 if (ps->readin)
4103 continue;
4104
3d4e8fd2
DC
4105 if ((lookup_partial_symbol (ps, oload_name, NULL, 1, VAR_NAMESPACE)
4106 != NULL)
4107 || (lookup_partial_symbol (ps, oload_name, NULL, 0, VAR_NAMESPACE)
4108 != NULL))
49fa1dc2 4109 PSYMTAB_TO_SYMTAB (ps);
c5aa993b 4110 }
c906108c 4111
c906108c
SS
4112 /* Search upwards from currently selected frame (so that we can
4113 complete on local vars. */
4114
ae767bfb 4115 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
c906108c
SS
4116 {
4117 if (!BLOCK_SUPERBLOCK (b))
4118 {
c5aa993b 4119 surrounding_static_block = b; /* For elimination of dups */
c906108c 4120 }
c5aa993b 4121
c906108c 4122 /* Also catch fields of types defined in this places which match our
c5aa993b 4123 text string. Only complete on types visible from current context. */
c906108c 4124
e88c90f2 4125 ALL_BLOCK_SYMBOLS (b, i, sym)
c906108c 4126 {
c906108c
SS
4127 overload_list_add_symbol (sym, oload_name);
4128 }
4129 }
4130
4131 /* Go through the symtabs and check the externs and statics for
4132 symbols which match. */
4133
4134 ALL_SYMTABS (objfile, s)
c5aa993b
JM
4135 {
4136 QUIT;
4137 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
e88c90f2 4138 ALL_BLOCK_SYMBOLS (b, i, sym)
c5aa993b 4139 {
c5aa993b
JM
4140 overload_list_add_symbol (sym, oload_name);
4141 }
4142 }
c906108c
SS
4143
4144 ALL_SYMTABS (objfile, s)
c5aa993b
JM
4145 {
4146 QUIT;
4147 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
4148 /* Don't do this block twice. */
4149 if (b == surrounding_static_block)
4150 continue;
e88c90f2 4151 ALL_BLOCK_SYMBOLS (b, i, sym)
c5aa993b 4152 {
c5aa993b
JM
4153 overload_list_add_symbol (sym, oload_name);
4154 }
4155 }
c906108c 4156
b8c9b27d 4157 xfree (oload_name);
c906108c
SS
4158
4159 return (sym_return_val);
4160}
4161
4162/* End of overload resolution functions */
c906108c 4163\f
50641945
FN
4164struct symtabs_and_lines
4165decode_line_spec (char *string, int funfirstline)
4166{
4167 struct symtabs_and_lines sals;
0378c332
FN
4168 struct symtab_and_line cursal;
4169
50641945
FN
4170 if (string == 0)
4171 error ("Empty line specification.");
0378c332
FN
4172
4173 /* We use whatever is set as the current source line. We do not try
4174 and get a default or it will recursively call us! */
4175 cursal = get_current_source_symtab_and_line ();
4176
50641945 4177 sals = decode_line_1 (&string, funfirstline,
0378c332 4178 cursal.symtab, cursal.line,
50641945 4179 (char ***) NULL);
0378c332 4180
50641945
FN
4181 if (*string)
4182 error ("Junk at end of line specification: %s", string);
4183 return sals;
4184}
c5aa993b 4185
51cc5b07
AC
4186/* Track MAIN */
4187static char *name_of_main;
4188
4189void
4190set_main_name (const char *name)
4191{
4192 if (name_of_main != NULL)
4193 {
4194 xfree (name_of_main);
4195 name_of_main = NULL;
4196 }
4197 if (name != NULL)
4198 {
4199 name_of_main = xstrdup (name);
4200 }
4201}
4202
4203char *
4204main_name (void)
4205{
4206 if (name_of_main != NULL)
4207 return name_of_main;
4208 else
4209 return "main";
4210}
4211
4212
c906108c 4213void
fba45db2 4214_initialize_symtab (void)
c906108c
SS
4215{
4216 add_info ("variables", variables_info,
c5aa993b 4217 "All global and static variable names, or those matching REGEXP.");
c906108c 4218 if (dbx_commands)
c5aa993b
JM
4219 add_com ("whereis", class_info, variables_info,
4220 "All global and static variable names, or those matching REGEXP.");
c906108c
SS
4221
4222 add_info ("functions", functions_info,
4223 "All function names, or those matching REGEXP.");
4224
357e46e7 4225
c906108c
SS
4226 /* FIXME: This command has at least the following problems:
4227 1. It prints builtin types (in a very strange and confusing fashion).
4228 2. It doesn't print right, e.g. with
c5aa993b
JM
4229 typedef struct foo *FOO
4230 type_print prints "FOO" when we want to make it (in this situation)
4231 print "struct foo *".
c906108c
SS
4232 I also think "ptype" or "whatis" is more likely to be useful (but if
4233 there is much disagreement "info types" can be fixed). */
4234 add_info ("types", types_info,
4235 "All type names, or those matching REGEXP.");
4236
c906108c
SS
4237 add_info ("sources", sources_info,
4238 "Source files in the program.");
4239
4240 add_com ("rbreak", class_breakpoint, rbreak_command,
c5aa993b 4241 "Set a breakpoint for all functions matching REGEXP.");
c906108c
SS
4242
4243 if (xdb_commands)
4244 {
4245 add_com ("lf", class_info, sources_info, "Source files in the program");
4246 add_com ("lg", class_info, variables_info,
c5aa993b 4247 "All global and static variable names, or those matching REGEXP.");
c906108c
SS
4248 }
4249
4250 /* Initialize the one built-in type that isn't language dependent... */
4251 builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
4252 "<unknown type>", (struct objfile *) NULL);
4253}
This page took 0.663592 seconds and 4 git commands to generate.