Bug Summary

File:src/gnu/usr.bin/binutils/gdb/symtab.c
Warning:line 2287, column 3
Value stored to 'best_linetable' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

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