1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include "defs.h"
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "gdbcore.h"
25 #include "frame.h"
26 #include "target.h"
27 #include "value.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "gdbcmd.h"
31 #include "call-cmds.h"
32 #include "regex.h"
33 #include "expression.h"
34 #include "language.h"
35 #include "demangle.h"
36
37 #include <obstack.h>
38 #include <assert.h>
39
40 #include <sys/types.h>
41 #include <fcntl.h>
42 #include <string.h>
43 #include <sys/stat.h>
44 #include <ctype.h>
45
46 /* Prototypes for local functions */
47
48 static char *
49 expensive_mangler PARAMS ((const char *));
50
51 extern int
52 find_methods PARAMS ((struct type *, char *, char **, struct symbol **));
53
54 static void
55 completion_list_add_symbol PARAMS ((char *, char *, int));
56
57 static struct symtabs_and_lines
58 decode_line_2 PARAMS ((struct symbol *[], int, int));
59
60 static void
61 rbreak_command PARAMS ((char *, int));
62
63 static void
64 types_info PARAMS ((char *, int));
65
66 static void
67 functions_info PARAMS ((char *, int));
68
69 static void
70 variables_info PARAMS ((char *, int));
71
72 static void
73 sources_info PARAMS ((char *, int));
74
75 static void
76 list_symbols PARAMS ((char *, int, int));
77
78 static void
79 output_source_filename PARAMS ((char *, int *));
80
81 static char *
82 operator_chars PARAMS ((char *, char **));
83
84 static int
85 find_line_common PARAMS ((struct linetable *, int, int *));
86
87 static struct partial_symbol *
88 lookup_partial_symbol PARAMS ((struct partial_symtab *, const char *,
89 int, enum namespace));
90
91 static struct partial_symbol *
92 lookup_demangled_partial_symbol PARAMS ((const struct partial_symtab *,
93 const char *));
94
95 static struct symbol *
96 lookup_demangled_block_symbol PARAMS ((const struct block *, const char *));
97
98 static struct symtab *
99 lookup_symtab_1 PARAMS ((char *));
100
101 /* */
102
103 /* The single non-language-specific builtin type */
104 struct type *builtin_type_error;
105
106 /* Block in which the most recently searched-for symbol was found.
107 Might be better to make this a parameter to lookup_symbol and
108 value_of_this. */
109
110 const struct block *block_found;
111
112 char no_symtab_msg[] = "No symbol table is loaded. Use the \"file\" command.";
113
114 /* While the C++ support is still in flux, issue a possibly helpful hint on
115 using the new command completion feature on single quoted demangled C++
116 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
117
118 void
cplusplus_hint(name)119 cplusplus_hint (name)
120 char *name;
121 {
122 printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
123 printf ("(Note leading single quote.)\n");
124 }
125
126 /* Check for a symtab of a specific name; first in symtabs, then in
127 psymtabs. *If* there is no '/' in the name, a match after a '/'
128 in the symtab filename will also work. */
129
130 static struct symtab *
lookup_symtab_1(name)131 lookup_symtab_1 (name)
132 char *name;
133 {
134 register struct symtab *s;
135 register struct partial_symtab *ps;
136 register char *slash;
137 register struct objfile *objfile;
138
139 got_symtab:
140
141 /* First, search for an exact match */
142
143 ALL_SYMTABS (objfile, s)
144 if (strcmp (name, s->filename) == 0)
145 return s;
146
147 slash = strchr (name, '/');
148
149 /* Now, search for a matching tail (only if name doesn't have any dirs) */
150
151 if (!slash)
152 ALL_SYMTABS (objfile, s)
153 {
154 char *p = s -> filename;
155 char *tail = strrchr (p, '/');
156
157 if (tail)
158 p = tail + 1;
159
160 if (strcmp (p, name) == 0)
161 return s;
162 }
163
164 /* Same search rules as above apply here, but now we look thru the
165 psymtabs. */
166
167 ALL_PSYMTABS (objfile, ps)
168 if (strcmp (name, ps -> filename) == 0)
169 goto got_psymtab;
170
171 if (!slash)
172 ALL_PSYMTABS (objfile, ps)
173 {
174 char *p = ps -> filename;
175 char *tail = strrchr (p, '/');
176
177 if (tail)
178 p = tail + 1;
179
180 if (strcmp (p, name) == 0)
181 goto got_psymtab;
182 }
183
184 return (NULL);
185
186 got_psymtab:
187
188 if (ps -> readin)
189 error ("Internal: readin %s pst for `%s' found when no symtab found.",
190 ps -> filename, name);
191
192 s = PSYMTAB_TO_SYMTAB (ps);
193
194 if (s)
195 return s;
196
197 /* At this point, we have located the psymtab for this file, but
198 the conversion to a symtab has failed. This usually happens
199 when we are looking up an include file. In this case,
200 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
201 been created. So, we need to run through the symtabs again in
202 order to find the file.
203 XXX - This is a crock, and should be fixed inside of the the
204 symbol parsing routines. */
205 goto got_symtab;
206 }
207
208 /* Lookup the symbol table of a source file named NAME. Try a couple
209 of variations if the first lookup doesn't work. */
210
211 struct symtab *
lookup_symtab(name)212 lookup_symtab (name)
213 char *name;
214 {
215 register struct symtab *s;
216 register char *copy;
217
218 s = lookup_symtab_1 (name);
219 if (s) return s;
220
221 /* If name not found as specified, see if adding ".c" helps. */
222
223 copy = (char *) alloca (strlen (name) + 3);
224 strcpy (copy, name);
225 strcat (copy, ".c");
226 s = lookup_symtab_1 (copy);
227 if (s) return s;
228
229 /* We didn't find anything; die. */
230 return 0;
231 }
232
233 /* Lookup the partial symbol table of a source file named NAME. This
234 only returns true on an exact match (ie. this semantics are
235 different from lookup_symtab. */
236
237 struct partial_symtab *
lookup_partial_symtab(name)238 lookup_partial_symtab (name)
239 char *name;
240 {
241 register struct partial_symtab *pst;
242 register struct objfile *objfile;
243
244 ALL_PSYMTABS (objfile, pst)
245 {
246 if (strcmp (name, pst -> filename) == 0)
247 {
248 return (pst);
249 }
250 }
251 return (NULL);
252 }
253
254 /* Demangle a GDB method stub type. */
255 char *
gdb_mangle_name(type,i,j)256 gdb_mangle_name (type, i, j)
257 struct type *type;
258 int i, j;
259 {
260 int mangled_name_len;
261 char *mangled_name;
262 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
263 struct fn_field *method = &f[j];
264 char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
265 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
266 char *newname = type_name_no_tag (type);
267 int is_constructor = strcmp(field_name, newname) == 0;
268 int is_destructor = is_constructor && physname[0] == '_'
269 && physname[1] == CPLUS_MARKER && physname[2] == '_';
270 /* Need a new type prefix. */
271 char *const_prefix = method->is_const ? "C" : "";
272 char *volatile_prefix = method->is_volatile ? "V" : "";
273 char buf[20];
274 #ifndef GCC_MANGLE_BUG
275 int len = strlen (newname);
276
277 if (is_destructor)
278 {
279 mangled_name = (char*) xmalloc(strlen(physname)+1);
280 strcpy(mangled_name, physname);
281 return mangled_name;
282 }
283
284 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
285 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
286 + strlen (buf) + len
287 + strlen (physname)
288 + 1);
289
290 /* Only needed for GNU-mangled names. ANSI-mangled names
291 work with the normal mechanisms. */
292 if (OPNAME_PREFIX_P (field_name))
293 {
294 char *opname = cplus_mangle_opname (field_name + 3, 0);
295 if (opname == NULL)
296 error ("No mangling for \"%s\"", field_name);
297 mangled_name_len += strlen (opname);
298 mangled_name = (char *)xmalloc (mangled_name_len);
299
300 strncpy (mangled_name, field_name, 3);
301 mangled_name[3] = '\0';
302 strcat (mangled_name, opname);
303 }
304 else
305 {
306 mangled_name = (char *)xmalloc (mangled_name_len);
307 if (is_constructor)
308 mangled_name[0] = '\0';
309 else
310 strcpy (mangled_name, field_name);
311 }
312 strcat (mangled_name, buf);
313 strcat (mangled_name, newname);
314 #else
315 char *opname;
316
317 if (is_constructor)
318 {
319 buf[0] = '\0';
320 }
321 else
322 {
323 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
324 }
325
326 mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
327 + strlen (buf) + strlen (physname) + 1);
328
329 /* Only needed for GNU-mangled names. ANSI-mangled names
330 work with the normal mechanisms. */
331 if (OPNAME_PREFIX_P (field_name))
332 {
333 opname = cplus_mangle_opname (field_name + 3, 0);
334 if (opname == NULL)
335 {
336 error ("No mangling for \"%s\"", field_name);
337 }
338 mangled_name_len += strlen (opname);
339 mangled_name = (char *) xmalloc (mangled_name_len);
340
341 strncpy (mangled_name, field_name, 3);
342 strcpy (mangled_name + 3, opname);
343 }
344 else
345 {
346 mangled_name = (char *) xmalloc (mangled_name_len);
347 if (is_constructor)
348 {
349 mangled_name[0] = '\0';
350 }
351 else
352 {
353 strcpy (mangled_name, field_name);
354 }
355 }
356 strcat (mangled_name, buf);
357
358 #endif
359 strcat (mangled_name, physname);
360 return (mangled_name);
361 }
362
363
364 /* Find which partial symtab on contains PC. Return 0 if none. */
365
366 struct partial_symtab *
find_pc_psymtab(pc)367 find_pc_psymtab (pc)
368 register CORE_ADDR pc;
369 {
370 register struct partial_symtab *pst;
371 register struct objfile *objfile;
372
373 ALL_PSYMTABS (objfile, pst)
374 {
375 if (pc >= pst -> textlow && pc < pst -> texthigh)
376 {
377 return (pst);
378 }
379 }
380 return (NULL);
381 }
382
383 /* Find which partial symbol within a psymtab contains PC. Return 0
384 if none. Check all psymtabs if PSYMTAB is 0. */
385 struct partial_symbol *
find_pc_psymbol(psymtab,pc)386 find_pc_psymbol (psymtab, pc)
387 struct partial_symtab *psymtab;
388 CORE_ADDR pc;
389 {
390 struct partial_symbol *best, *p;
391 CORE_ADDR best_pc;
392
393 if (!psymtab)
394 psymtab = find_pc_psymtab (pc);
395 if (!psymtab)
396 return 0;
397
398 best_pc = psymtab->textlow - 1;
399
400 for (p = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
401 (p - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
402 < psymtab->n_static_syms);
403 p++)
404 if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
405 && SYMBOL_CLASS (p) == LOC_BLOCK
406 && pc >= SYMBOL_VALUE_ADDRESS (p)
407 && SYMBOL_VALUE_ADDRESS (p) > best_pc)
408 {
409 best_pc = SYMBOL_VALUE_ADDRESS (p);
410 best = p;
411 }
412 if (best_pc == psymtab->textlow - 1)
413 return 0;
414 return best;
415 }
416
417
418 /* Find the definition for a specified symbol name NAME
419 in namespace NAMESPACE, visible from lexical block BLOCK.
420 Returns the struct symbol pointer, or zero if no symbol is found.
421 If SYMTAB is non-NULL, store the symbol table in which the
422 symbol was found there, or NULL if not found.
423 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
424 NAME is a field of the current implied argument `this'. If so set
425 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
426 BLOCK_FOUND is set to the block in which NAME is found (in the case of
427 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
428
429 struct symbol *
lookup_symbol(name,block,namespace,is_a_field_of_this,symtab)430 lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
431 const char *name;
432 register const struct block *block;
433 const enum namespace namespace;
434 int *is_a_field_of_this;
435 struct symtab **symtab;
436 {
437 register struct symbol *sym;
438 register struct symtab *s;
439 register struct partial_symtab *ps;
440 struct blockvector *bv;
441 register struct objfile *objfile;
442 register struct block *b;
443 register struct minimal_symbol *msymbol;
444 char *temp;
445 extern char *gdb_completer_word_break_characters;
446
447 /* If NAME contains any characters from gdb_completer_word_break_characters
448 then it is probably from a quoted name string. So check to see if it
449 has a C++ mangled equivalent, and if so, use the mangled equivalent. */
450
451 if (strpbrk (name, gdb_completer_word_break_characters) != NULL)
452 {
453 if ((temp = expensive_mangler (name)) != NULL)
454 {
455 name = temp;
456 }
457 }
458
459 /* Search specified block and its superiors. */
460
461 while (block != 0)
462 {
463 sym = lookup_block_symbol (block, name, namespace);
464 if (sym)
465 {
466 block_found = block;
467 if (symtab != NULL)
468 {
469 /* Search the list of symtabs for one which contains the
470 address of the start of this block. */
471 ALL_SYMTABS (objfile, s)
472 {
473 bv = BLOCKVECTOR (s);
474 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
475 if (BLOCK_START (b) <= BLOCK_START (block)
476 && BLOCK_END (b) > BLOCK_START (block))
477 goto found;
478 }
479 found:
480 *symtab = s;
481 }
482
483 return (sym);
484 }
485 block = BLOCK_SUPERBLOCK (block);
486 }
487
488 /* But that doesn't do any demangling for the STATIC_BLOCK.
489 I'm not sure whether demangling is needed in the case of
490 nested function in inner blocks; if so this needs to be changed.
491
492 Don't need to mess with the psymtabs; if we have a block,
493 that file is read in. If we don't, then we deal later with
494 all the psymtab stuff that needs checking. */
495 if (namespace == VAR_NAMESPACE && block != NULL)
496 {
497 struct block *b;
498 /* Find the right symtab. */
499 ALL_SYMTABS (objfile, s)
500 {
501 bv = BLOCKVECTOR (s);
502 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
503 if (BLOCK_START (b) <= BLOCK_START (block)
504 && BLOCK_END (b) > BLOCK_START (block))
505 {
506 sym = lookup_demangled_block_symbol (b, name);
507 if (sym)
508 {
509 block_found = b;
510 if (symtab != NULL)
511 *symtab = s;
512 return sym;
513 }
514 }
515 }
516 }
517
518
519 /* C++: If requested to do so by the caller,
520 check to see if NAME is a field of `this'. */
521 if (is_a_field_of_this)
522 {
523 struct value *v = value_of_this (0);
524
525 *is_a_field_of_this = 0;
526 if (v && check_field (v, name))
527 {
528 *is_a_field_of_this = 1;
529 if (symtab != NULL)
530 *symtab = NULL;
531 return 0;
532 }
533 }
534
535 /* Now search all global blocks. Do the symtab's first, then
536 check the psymtab's */
537
538 ALL_SYMTABS (objfile, s)
539 {
540 bv = BLOCKVECTOR (s);
541 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
542 sym = lookup_block_symbol (block, name, namespace);
543 if (sym)
544 {
545 block_found = block;
546 if (symtab != NULL)
547 *symtab = s;
548 return sym;
549 }
550 }
551
552 /* Check for the possibility of the symbol being a global function
553 that is stored in one of the minimal symbol tables. Eventually, all
554 global symbols might be resolved in this way. */
555
556 if (namespace == VAR_NAMESPACE)
557 {
558 msymbol = lookup_minimal_symbol (name, (struct objfile *) NULL);
559
560 if (msymbol == NULL)
561 {
562 /* Test each minimal symbol to see if the minimal symbol's name
563 is a C++ mangled name that matches a user visible name. */
564
565 char *demangled;
566
567 ALL_MSYMBOLS (objfile, msymbol)
568 {
569 demangled = demangle_and_match (msymbol -> name, name,
570 DMGL_PARAMS | DMGL_ANSI);
571 if (demangled != NULL)
572 {
573 free (demangled);
574 goto found_msym;
575 }
576 }
577 msymbol = NULL; /* Not found */
578 }
579
580 found_msym:
581 if (msymbol != NULL)
582 {
583 s = find_pc_symtab (msymbol -> address);
584 /* If S is NULL, there are no debug symbols for this file.
585 Skip this stuff and check for matching static symbols below. */
586 if (s != NULL)
587 {
588 bv = BLOCKVECTOR (s);
589 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
590 sym = lookup_block_symbol (block, msymbol -> name, namespace);
591 /* We kept static functions in minimal symbol table as well as
592 in static scope. We want to find them in the symbol table. */
593 if (!sym) {
594 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
595 sym = lookup_block_symbol (block, msymbol -> name,
596 namespace);
597 }
598
599 /* sym == 0 if symbol was found in the minimal symbol table
600 but not in the symtab.
601 Return 0 to use the msymbol definition of "foo_".
602
603 This happens for Fortran "foo_" symbols,
604 which are "foo" in the symtab.
605
606 This can also happen if "asm" is used to make a
607 regular symbol but not a debugging symbol, e.g.
608 asm(".globl _main");
609 asm("_main:");
610 */
611
612 if (symtab != NULL)
613 *symtab = s;
614 return sym;
615 }
616 }
617 }
618
619 ALL_PSYMTABS (objfile, ps)
620 {
621 if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
622 {
623 s = PSYMTAB_TO_SYMTAB(ps);
624 bv = BLOCKVECTOR (s);
625 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
626 sym = lookup_block_symbol (block, name, namespace);
627 if (!sym)
628 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
629 if (symtab != NULL)
630 *symtab = s;
631 return sym;
632 }
633 }
634
635 /* Now search all per-file blocks.
636 Not strictly correct, but more useful than an error.
637 Do the symtabs first, then check the psymtabs */
638
639 ALL_SYMTABS (objfile, s)
640 {
641 bv = BLOCKVECTOR (s);
642 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
643 sym = lookup_block_symbol (block, name, namespace);
644 if (sym)
645 {
646 block_found = block;
647 if (symtab != NULL)
648 *symtab = s;
649 return sym;
650 }
651 }
652
653 ALL_PSYMTABS (objfile, ps)
654 {
655 if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
656 {
657 s = PSYMTAB_TO_SYMTAB(ps);
658 bv = BLOCKVECTOR (s);
659 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
660 sym = lookup_block_symbol (block, name, namespace);
661 if (!sym)
662 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
663 if (symtab != NULL)
664 *symtab = s;
665 return sym;
666 }
667 }
668
669 /* Now search all per-file blocks for static mangled symbols.
670 Do the symtabs first, then check the psymtabs. */
671
672 if (namespace == VAR_NAMESPACE)
673 {
674 ALL_SYMTABS (objfile, s)
675 {
676 bv = BLOCKVECTOR (s);
677 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
678 sym = lookup_demangled_block_symbol (block, name);
679 if (sym)
680 {
681 block_found = block;
682 if (symtab != NULL)
683 *symtab = s;
684 return sym;
685 }
686 }
687
688 ALL_PSYMTABS (objfile, ps)
689 {
690 if (!ps->readin && lookup_demangled_partial_symbol (ps, name))
691 {
692 s = PSYMTAB_TO_SYMTAB(ps);
693 bv = BLOCKVECTOR (s);
694 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
695 sym = lookup_demangled_block_symbol (block, name);
696 if (!sym)
697 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
698 if (symtab != NULL)
699 *symtab = s;
700 return sym;
701 }
702 }
703 }
704
705 if (symtab != NULL)
706 *symtab = NULL;
707 return 0;
708 }
709
710 /* Look for a static demangled symbol in block BLOCK. */
711
712 static struct symbol *
lookup_demangled_block_symbol(block,name)713 lookup_demangled_block_symbol (block, name)
714 register const struct block *block;
715 const char *name;
716 {
717 register int bot, top;
718 register struct symbol *sym;
719 char *demangled;
720
721 bot = 0;
722 top = BLOCK_NSYMS (block);
723
724 while (bot < top)
725 {
726 sym = BLOCK_SYM (block, bot);
727 if (SYMBOL_NAMESPACE (sym) == VAR_NAMESPACE)
728 {
729 demangled = demangle_and_match (SYMBOL_NAME (sym), name,
730 DMGL_PARAMS | DMGL_ANSI);
731 if (demangled != NULL)
732 {
733 free (demangled);
734 return (sym);
735 }
736 }
737 bot++;
738 }
739
740 return (NULL);
741 }
742
743 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
744
745 static struct partial_symbol *
lookup_demangled_partial_symbol(pst,name)746 lookup_demangled_partial_symbol (pst, name)
747 const struct partial_symtab *pst;
748 const char *name;
749 {
750 struct partial_symbol *start, *psym;
751 int length = pst->n_static_syms;
752 char *demangled;
753
754 if (!length)
755 return (struct partial_symbol *) 0;
756
757 start = pst->objfile->static_psymbols.list + pst->statics_offset;
758 for (psym = start; psym < start + length; psym++)
759 {
760 if (SYMBOL_NAMESPACE (psym) == VAR_NAMESPACE)
761 {
762 demangled = demangle_and_match (SYMBOL_NAME (psym), name,
763 DMGL_PARAMS | DMGL_ANSI);
764 if (demangled != NULL)
765 {
766 free (demangled);
767 return (psym);
768 }
769 }
770 }
771
772 return (NULL);
773 }
774
775 /* Look, in partial_symtab PST, for symbol NAME. Check the global
776 symbols if GLOBAL, the static symbols if not */
777
778 static struct partial_symbol *
lookup_partial_symbol(pst,name,global,namespace)779 lookup_partial_symbol (pst, name, global, namespace)
780 struct partial_symtab *pst;
781 const char *name;
782 int global;
783 enum namespace namespace;
784 {
785 struct partial_symbol *start, *psym;
786 int length = (global ? pst->n_global_syms : pst->n_static_syms);
787
788 if (!length)
789 return (struct partial_symbol *) 0;
790
791 start = (global ?
792 pst->objfile->global_psymbols.list + pst->globals_offset :
793 pst->objfile->static_psymbols.list + pst->statics_offset );
794
795 if (global) /* This means we can use a binary */
796 /* search. */
797 {
798 struct partial_symbol *top, *bottom, *center;
799
800 /* Binary search. This search is guaranteed to end with center
801 pointing at the earliest partial symbol with the correct
802 name. At that point *all* partial symbols with that name
803 will be checked against the correct namespace. */
804 bottom = start;
805 top = start + length - 1;
806 while (top > bottom)
807 {
808 center = bottom + (top - bottom) / 2;
809
810 assert (center < top);
811
812 if (strcmp (SYMBOL_NAME (center), name) >= 0)
813 top = center;
814 else
815 bottom = center + 1;
816 }
817 assert (top == bottom);
818
819 while (!strcmp (SYMBOL_NAME (top), name))
820 {
821 if (SYMBOL_NAMESPACE (top) == namespace)
822 return top;
823 top ++;
824 }
825 }
826 else
827 {
828 /* Can't use a binary search */
829 for (psym = start; psym < start + length; psym++)
830 if (namespace == SYMBOL_NAMESPACE (psym)
831 && !strcmp (name, SYMBOL_NAME (psym)))
832 return psym;
833 }
834
835 return (struct partial_symbol *) 0;
836 }
837
838 /* Find the psymtab containing main(). */
839 /* FIXME: What about languages without main() or specially linked
840 executables that have no main() ? */
841
842 struct partial_symtab *
find_main_psymtab()843 find_main_psymtab ()
844 {
845 register struct partial_symtab *pst;
846 register struct objfile *objfile;
847
848 ALL_PSYMTABS (objfile, pst)
849 {
850 if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE))
851 {
852 return (pst);
853 }
854 }
855 return (NULL);
856 }
857
858 /* Look for a symbol in block BLOCK. */
859
860 struct symbol *
lookup_block_symbol(block,name,namespace)861 lookup_block_symbol (block, name, namespace)
862 register const struct block *block;
863 const char *name;
864 const enum namespace namespace;
865 {
866 register int bot, top, inc;
867 register struct symbol *sym, *parameter_sym;
868
869 top = BLOCK_NSYMS (block);
870 bot = 0;
871
872 /* If the blocks's symbols were sorted, start with a binary search. */
873
874 if (BLOCK_SHOULD_SORT (block))
875 {
876 /* First, advance BOT to not far before
877 the first symbol whose name is NAME. */
878
879 while (1)
880 {
881 inc = (top - bot + 1);
882 /* No need to keep binary searching for the last few bits worth. */
883 if (inc < 4)
884 break;
885 inc = (inc >> 1) + bot;
886 sym = BLOCK_SYM (block, inc);
887 if (SYMBOL_NAME (sym)[0] < name[0])
888 bot = inc;
889 else if (SYMBOL_NAME (sym)[0] > name[0])
890 top = inc;
891 else if (strcmp (SYMBOL_NAME (sym), name) < 0)
892 bot = inc;
893 else
894 top = inc;
895 }
896
897 /* Now scan forward until we run out of symbols,
898 find one whose name is greater than NAME,
899 or find one we want.
900 If there is more than one symbol with the right name and namespace,
901 we return the first one. dbxread.c is careful to make sure
902 that if one is a register then it comes first. */
903
904 top = BLOCK_NSYMS (block);
905 while (bot < top)
906 {
907 sym = BLOCK_SYM (block, bot);
908 inc = SYMBOL_NAME (sym)[0] - name[0];
909 if (inc == 0)
910 inc = strcmp (SYMBOL_NAME (sym), name);
911 if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
912 return sym;
913 if (inc > 0)
914 return 0;
915 bot++;
916 }
917 return 0;
918 }
919
920 /* Here if block isn't sorted.
921 This loop is equivalent to the loop above,
922 but hacked greatly for speed.
923
924 Note that parameter symbols do not always show up last in the
925 list; this loop makes sure to take anything else other than
926 parameter symbols first; it only uses parameter symbols as a
927 last resort. Note that this only takes up extra computation
928 time on a match. */
929
930 parameter_sym = (struct symbol *) 0;
931 top = BLOCK_NSYMS (block);
932 inc = name[0];
933 while (bot < top)
934 {
935 sym = BLOCK_SYM (block, bot);
936 if (SYMBOL_NAME (sym)[0] == inc
937 && !strcmp (SYMBOL_NAME (sym), name)
938 && SYMBOL_NAMESPACE (sym) == namespace)
939 {
940 if (SYMBOL_CLASS (sym) == LOC_ARG
941 || SYMBOL_CLASS (sym) == LOC_LOCAL_ARG
942 || SYMBOL_CLASS (sym) == LOC_REF_ARG
943 || SYMBOL_CLASS (sym) == LOC_REGPARM)
944 parameter_sym = sym;
945 else
946 return sym;
947 }
948 bot++;
949 }
950 return parameter_sym; /* Will be 0 if not found. */
951 }
952
953 /* Return the symbol for the function which contains a specified
954 lexical block, described by a struct block BL. */
955
956 struct symbol *
block_function(bl)957 block_function (bl)
958 struct block *bl;
959 {
960 while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
961 bl = BLOCK_SUPERBLOCK (bl);
962
963 return BLOCK_FUNCTION (bl);
964 }
965
966 /* Subroutine of find_pc_line */
967
968 struct symtab *
find_pc_symtab(pc)969 find_pc_symtab (pc)
970 register CORE_ADDR pc;
971 {
972 register struct block *b;
973 struct blockvector *bv;
974 register struct symtab *s = 0;
975 register struct partial_symtab *ps;
976 register struct objfile *objfile;
977
978 /* Search all symtabs for one whose file contains our pc */
979
980 ALL_SYMTABS (objfile, s)
981 {
982 bv = BLOCKVECTOR (s);
983 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
984 if (BLOCK_START (b) <= pc
985 && BLOCK_END (b) > pc)
986 goto found;
987 }
988
989 if (!s)
990 {
991 ps = find_pc_psymtab (pc);
992 if (ps && ps->readin)
993 {
994 printf_filtered ("(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc);
995 }
996 if (ps)
997 {
998 s = PSYMTAB_TO_SYMTAB (ps);
999 }
1000 }
1001
1002 found:
1003 return (s);
1004 }
1005
1006 /* Find the source file and line number for a given PC value.
1007 Return a structure containing a symtab pointer, a line number,
1008 and a pc range for the entire source line.
1009 The value's .pc field is NOT the specified pc.
1010 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1011 use the line that ends there. Otherwise, in that case, the line
1012 that begins there is used. */
1013
1014 struct symtab_and_line
find_pc_line(pc,notcurrent)1015 find_pc_line (pc, notcurrent)
1016 CORE_ADDR pc;
1017 int notcurrent;
1018 {
1019 struct symtab *s;
1020 register struct linetable *l;
1021 register int len;
1022 register int i;
1023 register struct linetable_entry *item;
1024 struct symtab_and_line val;
1025 struct blockvector *bv;
1026
1027 /* Info on best line seen so far, and where it starts, and its file. */
1028
1029 int best_line = 0;
1030 CORE_ADDR best_pc = 0;
1031 CORE_ADDR best_end = 0;
1032 struct symtab *best_symtab = 0;
1033
1034 /* Store here the first line number
1035 of a file which contains the line at the smallest pc after PC.
1036 If we don't find a line whose range contains PC,
1037 we will use a line one less than this,
1038 with a range from the start of that file to the first line's pc. */
1039 int alt_line = 0;
1040 CORE_ADDR alt_pc = 0;
1041 struct symtab *alt_symtab = 0;
1042
1043 /* Info on best line seen in this file. */
1044
1045 int prev_line;
1046 CORE_ADDR prev_pc;
1047
1048 /* Info on first line of this file. */
1049
1050 int first_line;
1051 CORE_ADDR first_pc;
1052
1053 /* If this pc is not from the current frame,
1054 it is the address of the end of a call instruction.
1055 Quite likely that is the start of the following statement.
1056 But what we want is the statement containing the instruction.
1057 Fudge the pc to make sure we get that. */
1058
1059 if (notcurrent) pc -= 1;
1060
1061 s = find_pc_symtab (pc);
1062 if (s == 0)
1063 {
1064 val.symtab = 0;
1065 val.line = 0;
1066 val.pc = pc;
1067 val.end = 0;
1068 return val;
1069 }
1070
1071 bv = BLOCKVECTOR (s);
1072
1073 /* Look at all the symtabs that share this blockvector.
1074 They all have the same apriori range, that we found was right;
1075 but they have different line tables. */
1076
1077 for (; s && BLOCKVECTOR (s) == bv; s = s->next)
1078 {
1079 /* Find the best line in this symtab. */
1080 l = LINETABLE (s);
1081 if (!l)
1082 continue;
1083 len = l->nitems;
1084 prev_line = -1;
1085 first_line = -1;
1086 for (i = 0; i < len; i++)
1087 {
1088 item = &(l->item[i]);
1089
1090 if (first_line < 0)
1091 {
1092 first_line = item->line;
1093 first_pc = item->pc;
1094 }
1095 /* Return the last line that did not start after PC. */
1096 if (pc >= item->pc)
1097 {
1098 prev_line = item->line;
1099 prev_pc = item->pc;
1100 }
1101 else
1102 break;
1103 }
1104
1105 /* Is this file's best line closer than the best in the other files?
1106 If so, record this file, and its best line, as best so far. */
1107 if (prev_line >= 0 && prev_pc > best_pc)
1108 {
1109 best_pc = prev_pc;
1110 best_line = prev_line;
1111 best_symtab = s;
1112 /* If another line is in the linetable, and its PC is closer
1113 than the best_end we currently have, take it as best_end. */
1114 if (i < len && (best_end == 0 || best_end > item->pc))
1115 best_end = item->pc;
1116 }
1117 /* Is this file's first line closer than the first lines of other files?
1118 If so, record this file, and its first line, as best alternate. */
1119 if (first_line >= 0 && first_pc > pc
1120 && (alt_pc == 0 || first_pc < alt_pc))
1121 {
1122 alt_pc = first_pc;
1123 alt_line = first_line;
1124 alt_symtab = s;
1125 }
1126 }
1127 if (best_symtab == 0)
1128 {
1129 val.symtab = alt_symtab;
1130 val.line = alt_line - 1;
1131 val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1132 val.end = alt_pc;
1133 }
1134 else
1135 {
1136 val.symtab = best_symtab;
1137 val.line = best_line;
1138 val.pc = best_pc;
1139 if (best_end && (alt_pc == 0 || best_end < alt_pc))
1140 val.end = best_end;
1141 else if (alt_pc)
1142 val.end = alt_pc;
1143 else
1144 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1145 }
1146 return val;
1147 }
1148
1149 /* Find the PC value for a given source file and line number.
1150 Returns zero for invalid line number.
1151 The source file is specified with a struct symtab. */
1152
1153 CORE_ADDR
find_line_pc(symtab,line)1154 find_line_pc (symtab, line)
1155 struct symtab *symtab;
1156 int line;
1157 {
1158 register struct linetable *l;
1159 register int ind;
1160 int dummy;
1161
1162 if (symtab == 0)
1163 return 0;
1164 l = LINETABLE (symtab);
1165 ind = find_line_common(l, line, &dummy);
1166 return (ind >= 0) ? l->item[ind].pc : 0;
1167 }
1168
1169 /* Find the range of pc values in a line.
1170 Store the starting pc of the line into *STARTPTR
1171 and the ending pc (start of next line) into *ENDPTR.
1172 Returns 1 to indicate success.
1173 Returns 0 if could not find the specified line. */
1174
1175 int
find_line_pc_range(symtab,thisline,startptr,endptr)1176 find_line_pc_range (symtab, thisline, startptr, endptr)
1177 struct symtab *symtab;
1178 int thisline;
1179 CORE_ADDR *startptr, *endptr;
1180 {
1181 register struct linetable *l;
1182 register int ind;
1183 int exact_match; /* did we get an exact linenumber match */
1184
1185 if (symtab == 0)
1186 return 0;
1187
1188 l = LINETABLE (symtab);
1189 ind = find_line_common (l, thisline, &exact_match);
1190 if (ind >= 0)
1191 {
1192 *startptr = l->item[ind].pc;
1193 /* If we have not seen an entry for the specified line,
1194 assume that means the specified line has zero bytes. */
1195 if (!exact_match || ind == l->nitems-1)
1196 *endptr = *startptr;
1197 else
1198 /* Perhaps the following entry is for the following line.
1199 It's worth a try. */
1200 if (ind+1 < l->nitems
1201 && l->item[ind+1].line == thisline + 1)
1202 *endptr = l->item[ind+1].pc;
1203 else
1204 *endptr = find_line_pc (symtab, thisline+1);
1205 return 1;
1206 }
1207
1208 return 0;
1209 }
1210
1211 /* Given a line table and a line number, return the index into the line
1212 table for the pc of the nearest line whose number is >= the specified one.
1213 Return -1 if none is found. The value is >= 0 if it is an index.
1214
1215 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1216
1217 static int
find_line_common(l,lineno,exact_match)1218 find_line_common (l, lineno, exact_match)
1219 register struct linetable *l;
1220 register int lineno;
1221 int *exact_match;
1222 {
1223 register int i;
1224 register int len;
1225
1226 /* BEST is the smallest linenumber > LINENO so far seen,
1227 or 0 if none has been seen so far.
1228 BEST_INDEX identifies the item for it. */
1229
1230 int best_index = -1;
1231 int best = 0;
1232
1233 if (lineno <= 0)
1234 return -1;
1235 if (l == 0)
1236 return -1;
1237
1238 len = l->nitems;
1239 for (i = 0; i < len; i++)
1240 {
1241 register struct linetable_entry *item = &(l->item[i]);
1242
1243 if (item->line == lineno)
1244 {
1245 *exact_match = 1;
1246 return i;
1247 }
1248
1249 if (item->line > lineno && (best == 0 || item->line < best))
1250 {
1251 best = item->line;
1252 best_index = i;
1253 }
1254 }
1255
1256 /* If we got here, we didn't get an exact match. */
1257
1258 *exact_match = 0;
1259 return best_index;
1260 }
1261
1262 int
find_pc_line_pc_range(pc,startptr,endptr)1263 find_pc_line_pc_range (pc, startptr, endptr)
1264 CORE_ADDR pc;
1265 CORE_ADDR *startptr, *endptr;
1266 {
1267 struct symtab_and_line sal;
1268 sal = find_pc_line (pc, 0);
1269 *startptr = sal.pc;
1270 *endptr = sal.end;
1271 return sal.symtab != 0;
1272 }
1273
1274 /* If P is of the form "operator[ \t]+..." where `...' is
1275 some legitimate operator text, return a pointer to the
1276 beginning of the substring of the operator text.
1277 Otherwise, return "". */
1278 static char *
operator_chars(p,end)1279 operator_chars (p, end)
1280 char *p;
1281 char **end;
1282 {
1283 *end = "";
1284 if (strncmp (p, "operator", 8))
1285 return *end;
1286 p += 8;
1287
1288 /* Don't get faked out by `operator' being part of a longer
1289 identifier. */
1290 if (isalpha(*p) || *p == '_' || *p == '$' || *p == '\0')
1291 return *end;
1292
1293 /* Allow some whitespace between `operator' and the operator symbol. */
1294 while (*p == ' ' || *p == '\t')
1295 p++;
1296
1297 /* Recognize 'operator TYPENAME'. */
1298
1299 if (isalpha(*p) || *p == '_' || *p == '$')
1300 {
1301 register char *q = p+1;
1302 while (isalnum(*q) || *q == '_' || *q == '$')
1303 q++;
1304 *end = q;
1305 return p;
1306 }
1307
1308 switch (*p)
1309 {
1310 case '!':
1311 case '=':
1312 case '*':
1313 case '/':
1314 case '%':
1315 case '^':
1316 if (p[1] == '=')
1317 *end = p+2;
1318 else
1319 *end = p+1;
1320 return p;
1321 case '<':
1322 case '>':
1323 case '+':
1324 case '-':
1325 case '&':
1326 case '|':
1327 if (p[1] == '=' || p[1] == p[0])
1328 *end = p+2;
1329 else
1330 *end = p+1;
1331 return p;
1332 case '~':
1333 case ',':
1334 *end = p+1;
1335 return p;
1336 case '(':
1337 if (p[1] != ')')
1338 error ("`operator ()' must be specified without whitespace in `()'");
1339 *end = p+2;
1340 return p;
1341 case '?':
1342 if (p[1] != ':')
1343 error ("`operator ?:' must be specified without whitespace in `?:'");
1344 *end = p+2;
1345 return p;
1346 case '[':
1347 if (p[1] != ']')
1348 error ("`operator []' must be specified without whitespace in `[]'");
1349 *end = p+2;
1350 return p;
1351 default:
1352 error ("`operator %s' not supported", p);
1353 break;
1354 }
1355 *end = "";
1356 return *end;
1357 }
1358
1359 /* Recursive helper function for decode_line_1.
1360 * Look for methods named NAME in type T.
1361 * Return number of matches.
1362 * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1363 * These allocations seem to define "big enough":
1364 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1365 * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1366 */
1367
1368 int
find_methods(t,name,physnames,sym_arr)1369 find_methods (t, name, physnames, sym_arr)
1370 struct type *t;
1371 char *name;
1372 char **physnames;
1373 struct symbol **sym_arr;
1374 {
1375 int i1 = 0;
1376 int ibase;
1377 struct symbol *sym_class;
1378 char *class_name = type_name_no_tag (t);
1379 /* Ignore this class if it doesn't have a name.
1380 This prevents core dumps, but is just a workaround
1381 because we might not find the function in
1382 certain cases, such as
1383 struct D {virtual int f();}
1384 struct C : D {virtual int g();}
1385 (in this case g++ 1.35.1- does not put out a name
1386 for D as such, it defines type 19 (for example) in
1387 the same stab as C, and then does a
1388 .stabs "D:T19" and a .stabs "D:t19".
1389 Thus
1390 "break C::f" should not be looking for field f in
1391 the class named D,
1392 but just for the field f in the baseclasses of C
1393 (no matter what their names).
1394
1395 However, I don't know how to replace the code below
1396 that depends on knowing the name of D. */
1397 if (class_name
1398 && (sym_class = lookup_symbol (class_name,
1399 (struct block *)NULL,
1400 STRUCT_NAMESPACE,
1401 (int *)NULL,
1402 (struct symtab **)NULL)))
1403 {
1404 int method_counter;
1405 t = SYMBOL_TYPE (sym_class);
1406 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
1407 method_counter >= 0;
1408 --method_counter)
1409 {
1410 int field_counter;
1411 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, method_counter);
1412
1413 char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
1414 if (!strcmp (name, method_name))
1415 /* Find all the fields with that name. */
1416 for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
1417 field_counter >= 0;
1418 --field_counter)
1419 {
1420 char *phys_name;
1421 if (TYPE_FN_FIELD_STUB (f, field_counter))
1422 check_stub_method (t, method_counter, field_counter);
1423 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
1424 physnames[i1] = (char*) alloca (strlen (phys_name) + 1);
1425 strcpy (physnames[i1], phys_name);
1426 sym_arr[i1] = lookup_symbol (phys_name,
1427 SYMBOL_BLOCK_VALUE (sym_class),
1428 VAR_NAMESPACE,
1429 (int *) NULL,
1430 (struct symtab **) NULL);
1431 if (sym_arr[i1]) i1++;
1432 else
1433 {
1434 fputs_filtered("(Cannot find method ", stdout);
1435 fputs_demangled(phys_name, stdout, DMGL_PARAMS);
1436 fputs_filtered(" - possibly inlined.)\n", stdout);
1437 }
1438 }
1439 }
1440 }
1441 /* Only search baseclasses if there is no match yet,
1442 * since names in derived classes override those in baseclasses.
1443 */
1444 if (i1)
1445 return i1;
1446 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1447 i1 += find_methods(TYPE_BASECLASS(t, ibase), name,
1448 physnames + i1, sym_arr + i1);
1449 return i1;
1450 }
1451
1452 /* Parse a string that specifies a line number.
1453 Pass the address of a char * variable; that variable will be
1454 advanced over the characters actually parsed.
1455
1456 The string can be:
1457
1458 LINENUM -- that line number in current file. PC returned is 0.
1459 FILE:LINENUM -- that line in that file. PC returned is 0.
1460 FUNCTION -- line number of openbrace of that function.
1461 PC returned is the start of the function.
1462 VARIABLE -- line number of definition of that variable.
1463 PC returned is 0.
1464 FILE:FUNCTION -- likewise, but prefer functions in that file.
1465 *EXPR -- line in which address EXPR appears.
1466
1467 FUNCTION may be an undebuggable function found in minimal symbol table.
1468
1469 If the argument FUNFIRSTLINE is nonzero, we want the first line
1470 of real code inside a function when a function is specified.
1471
1472 DEFAULT_SYMTAB specifies the file to use if none is specified.
1473 It defaults to current_source_symtab.
1474 DEFAULT_LINE specifies the line number to use for relative
1475 line numbers (that start with signs). Defaults to current_source_line.
1476
1477 Note that it is possible to return zero for the symtab
1478 if no file is validly specified. Callers must check that.
1479 Also, the line number returned may be invalid. */
1480
1481 struct symtabs_and_lines
decode_line_1(argptr,funfirstline,default_symtab,default_line)1482 decode_line_1 (argptr, funfirstline, default_symtab, default_line)
1483 char **argptr;
1484 int funfirstline;
1485 struct symtab *default_symtab;
1486 int default_line;
1487 {
1488 struct symtabs_and_lines values;
1489 #ifdef HPPA_COMPILER_BUG
1490 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1491 when optimizing this file with target i960-vxworks. I haven't
1492 been able to construct a simple test case. The problem is that
1493 in the second call to SKIP_PROLOGUE below, the compiler somehow
1494 does not realize that the statement val = find_pc_line (...) will
1495 change the values of the fields of val. It extracts the elements
1496 into registers at the top of the block, and does not update the
1497 registers after the call to find_pc_line. You can check this by
1498 inserting a printf at the end of find_pc_line to show what values
1499 it is returning for val.pc and val.end and another printf after
1500 the call to see what values the function actually got (remember,
1501 this is compiling with cc -O, with this patch removed). You can
1502 also examine the assembly listing: search for the second call to
1503 skip_prologue; the LDO statement before the next call to
1504 find_pc_line loads the address of the structure which
1505 find_pc_line will return; if there is a LDW just before the LDO,
1506 which fetches an element of the structure, then the compiler
1507 still has the bug.
1508
1509 Setting val to volatile avoids the problem. We must undef
1510 volatile, because the HPPA native compiler does not define
1511 __STDC__, although it does understand volatile, and so volatile
1512 will have been defined away in defs.h. */
1513 #undef volatile
1514 volatile struct symtab_and_line val;
1515 #define volatile /*nothing*/
1516 #else
1517 struct symtab_and_line val;
1518 #endif
1519 register char *p, *p1;
1520 char *q, *q1;
1521 register struct symtab *s;
1522
1523 register struct symbol *sym;
1524 /* The symtab that SYM was found in. */
1525 struct symtab *sym_symtab;
1526
1527 register CORE_ADDR pc;
1528 register struct minimal_symbol *msymbol;
1529 char *copy;
1530 struct symbol *sym_class;
1531 int i1;
1532 int is_quoted;
1533 struct symbol **sym_arr;
1534 struct type *t;
1535 char **physnames;
1536 char *saved_arg = *argptr;
1537 extern char *gdb_completer_quote_characters;
1538
1539 /* Defaults have defaults. */
1540
1541 if (default_symtab == 0)
1542 {
1543 default_symtab = current_source_symtab;
1544 default_line = current_source_line;
1545 }
1546
1547 /* See if arg is *PC */
1548
1549 if (**argptr == '*')
1550 {
1551 if (**argptr == '*')
1552 {
1553 (*argptr)++;
1554 }
1555 pc = parse_and_eval_address_1 (argptr);
1556 values.sals = (struct symtab_and_line *)
1557 xmalloc (sizeof (struct symtab_and_line));
1558 values.nelts = 1;
1559 values.sals[0] = find_pc_line (pc, 0);
1560 values.sals[0].pc = pc;
1561 return values;
1562 }
1563
1564 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1565
1566 s = NULL;
1567 is_quoted = (strchr (gdb_completer_quote_characters, **argptr) != NULL);
1568
1569 for (p = *argptr; *p; p++)
1570 {
1571 if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
1572 break;
1573 }
1574 while (p[0] == ' ' || p[0] == '\t') p++;
1575
1576 if ((p[0] == ':') && !is_quoted)
1577 {
1578
1579 /* C++ */
1580 if (p[1] ==':')
1581 {
1582 /* Extract the class name. */
1583 p1 = p;
1584 while (p != *argptr && p[-1] == ' ') --p;
1585 copy = (char *) alloca (p - *argptr + 1);
1586 memcpy (copy, *argptr, p - *argptr);
1587 copy[p - *argptr] = 0;
1588
1589 /* Discard the class name from the arg. */
1590 p = p1 + 2;
1591 while (*p == ' ' || *p == '\t') p++;
1592 *argptr = p;
1593
1594 sym_class = lookup_symbol (copy, 0, STRUCT_NAMESPACE, 0,
1595 (struct symtab **)NULL);
1596
1597 if (sym_class &&
1598 ( TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_STRUCT
1599 || TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_UNION))
1600 {
1601 /* Arg token is not digits => try it as a function name
1602 Find the next token (everything up to end or next whitespace). */
1603 p = *argptr;
1604 while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p !=':') p++;
1605 q = operator_chars (*argptr, &q1);
1606
1607 if (q1 - q)
1608 {
1609 char *opname;
1610 char *tmp = alloca (q1 - q + 1);
1611 memcpy (tmp, q, q1 - q);
1612 tmp[q1 - q] = '\0';
1613 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
1614 if (opname == NULL)
1615 {
1616 warning ("no mangling for \"%s\"", tmp);
1617 cplusplus_hint (saved_arg);
1618 return_to_top_level ();
1619 }
1620 copy = (char*) alloca (3 + strlen(opname));
1621 sprintf (copy, "__%s", opname);
1622 p = q1;
1623 }
1624 else
1625 {
1626 copy = (char *) alloca (p - *argptr + 1 + (q1 - q));
1627 memcpy (copy, *argptr, p - *argptr);
1628 copy[p - *argptr] = '\0';
1629 }
1630
1631 /* no line number may be specified */
1632 while (*p == ' ' || *p == '\t') p++;
1633 *argptr = p;
1634
1635 sym = 0;
1636 i1 = 0; /* counter for the symbol array */
1637 t = SYMBOL_TYPE (sym_class);
1638 sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1639 physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1640
1641 if (destructor_name_p (copy, t))
1642 {
1643 /* destructors are a special case. */
1644 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, 0);
1645 int len = TYPE_FN_FIELDLIST_LENGTH (t, 0) - 1;
1646 char *phys_name = TYPE_FN_FIELD_PHYSNAME (f, len);
1647 physnames[i1] = (char *)alloca (strlen (phys_name) + 1);
1648 strcpy (physnames[i1], phys_name);
1649 sym_arr[i1] =
1650 lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class),
1651 VAR_NAMESPACE, 0, (struct symtab **)NULL);
1652 if (sym_arr[i1]) i1++;
1653 }
1654 else
1655 i1 = find_methods (t, copy, physnames, sym_arr);
1656 if (i1 == 1)
1657 {
1658 /* There is exactly one field with that name. */
1659 sym = sym_arr[0];
1660
1661 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1662 {
1663 /* Arg is the name of a function */
1664 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
1665 if (funfirstline)
1666 SKIP_PROLOGUE (pc);
1667 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1668 values.nelts = 1;
1669 values.sals[0] = find_pc_line (pc, 0);
1670 values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
1671 }
1672 else
1673 {
1674 values.nelts = 0;
1675 }
1676 return values;
1677 }
1678 if (i1 > 0)
1679 {
1680 /* There is more than one field with that name
1681 (overloaded). Ask the user which one to use. */
1682 return decode_line_2 (sym_arr, i1, funfirstline);
1683 }
1684 else
1685 {
1686 char *tmp;
1687
1688 if (OPNAME_PREFIX_P (copy))
1689 {
1690 tmp = (char *)alloca (strlen (copy+3) + 9);
1691 strcpy (tmp, "operator ");
1692 strcat (tmp, copy+3);
1693 }
1694 else
1695 tmp = copy;
1696 if (tmp[0] == '~')
1697 warning ("the class `%s' does not have destructor defined",
1698 sym_class->name);
1699 else
1700 warning ("the class %s does not have any method named %s",
1701 sym_class->name, tmp);
1702 cplusplus_hint (saved_arg);
1703 return_to_top_level ();
1704 }
1705 }
1706 else
1707 {
1708 /* The quotes are important if copy is empty. */
1709 warning ("can't find class, struct, or union named \"%s\"",
1710 copy);
1711 cplusplus_hint (saved_arg);
1712 return_to_top_level ();
1713 }
1714 }
1715 /* end of C++ */
1716
1717
1718 /* Extract the file name. */
1719 p1 = p;
1720 while (p != *argptr && p[-1] == ' ') --p;
1721 copy = (char *) alloca (p - *argptr + 1);
1722 memcpy (copy, *argptr, p - *argptr);
1723 copy[p - *argptr] = 0;
1724
1725 /* Find that file's data. */
1726 s = lookup_symtab (copy);
1727 if (s == 0)
1728 {
1729 if (!have_full_symbols () && !have_partial_symbols ())
1730 error (no_symtab_msg);
1731 error ("No source file named %s.", copy);
1732 }
1733
1734 /* Discard the file name from the arg. */
1735 p = p1 + 1;
1736 while (*p == ' ' || *p == '\t') p++;
1737 *argptr = p;
1738 }
1739
1740 /* S is specified file's symtab, or 0 if no file specified.
1741 arg no longer contains the file name. */
1742
1743 /* Check whether arg is all digits (and sign) */
1744
1745 p = *argptr;
1746 if (*p == '-' || *p == '+') p++;
1747 while (*p >= '0' && *p <= '9')
1748 p++;
1749
1750 if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
1751 {
1752 /* We found a token consisting of all digits -- at least one digit. */
1753 enum sign {none, plus, minus} sign = none;
1754
1755 /* This is where we need to make sure that we have good defaults.
1756 We must guarantee that this section of code is never executed
1757 when we are called with just a function name, since
1758 select_source_symtab calls us with such an argument */
1759
1760 if (s == 0 && default_symtab == 0)
1761 {
1762 select_source_symtab (0);
1763 default_symtab = current_source_symtab;
1764 default_line = current_source_line;
1765 }
1766
1767 if (**argptr == '+')
1768 sign = plus, (*argptr)++;
1769 else if (**argptr == '-')
1770 sign = minus, (*argptr)++;
1771 val.line = atoi (*argptr);
1772 switch (sign)
1773 {
1774 case plus:
1775 if (p == *argptr)
1776 val.line = 5;
1777 if (s == 0)
1778 val.line = default_line + val.line;
1779 break;
1780 case minus:
1781 if (p == *argptr)
1782 val.line = 15;
1783 if (s == 0)
1784 val.line = default_line - val.line;
1785 else
1786 val.line = 1;
1787 break;
1788 case none:
1789 break; /* No need to adjust val.line. */
1790 }
1791
1792 while (*p == ' ' || *p == '\t') p++;
1793 *argptr = p;
1794 if (s == 0)
1795 s = default_symtab;
1796 val.symtab = s;
1797 val.pc = 0;
1798 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1799 values.sals[0] = val;
1800 values.nelts = 1;
1801 return values;
1802 }
1803
1804 /* Arg token is not digits => try it as a variable name
1805 Find the next token (everything up to end or next whitespace). */
1806
1807 p = skip_quoted (*argptr);
1808 copy = (char *) alloca (p - *argptr + 1);
1809 memcpy (copy, *argptr, p - *argptr);
1810 copy[p - *argptr] = '\0';
1811 if ((copy[0] == copy [p - *argptr - 1])
1812 && strchr (gdb_completer_quote_characters, copy[0]) != NULL)
1813 {
1814 char *temp;
1815 copy [p - *argptr - 1] = '\0';
1816 copy++;
1817 if ((temp = expensive_mangler (copy)) != NULL)
1818 {
1819 copy = temp;
1820 }
1821 }
1822 while (*p == ' ' || *p == '\t') p++;
1823 *argptr = p;
1824
1825 /* Look up that token as a variable.
1826 If file specified, use that file's per-file block to start with. */
1827
1828 sym = lookup_symbol (copy,
1829 (s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
1830 : get_selected_block ()),
1831 VAR_NAMESPACE, 0, &sym_symtab);
1832
1833 if (sym != NULL)
1834 {
1835 if (SYMBOL_CLASS (sym) == LOC_BLOCK)
1836 {
1837 /* Arg is the name of a function */
1838 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
1839 if (funfirstline)
1840 SKIP_PROLOGUE (pc);
1841 val = find_pc_line (pc, 0);
1842 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1843 /* Convex: no need to suppress code on first line, if any */
1844 val.pc = pc;
1845 #else
1846 /* If SKIP_PROLOGUE left us in mid-line, and the next line is still
1847 part of the same function:
1848 advance to next line,
1849 recalculate its line number (might not be N+1). */
1850 if (val.pc != pc && val.end &&
1851 lookup_minimal_symbol_by_pc (pc) == lookup_minimal_symbol_by_pc (val.end)) {
1852 pc = val.end; /* First pc of next line */
1853 val = find_pc_line (pc, 0);
1854 }
1855 val.pc = pc;
1856 #endif
1857 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1858 values.sals[0] = val;
1859 values.nelts = 1;
1860
1861 /* I think this is always the same as the line that
1862 we calculate above, but the general principle is
1863 "trust the symbols more than stuff like
1864 SKIP_PROLOGUE". */
1865 if (SYMBOL_LINE (sym) != 0)
1866 values.sals[0].line = SYMBOL_LINE (sym);
1867
1868 return values;
1869 }
1870 else if (SYMBOL_LINE (sym) != 0)
1871 {
1872 /* We know its line number. */
1873 values.sals = (struct symtab_and_line *)
1874 xmalloc (sizeof (struct symtab_and_line));
1875 values.nelts = 1;
1876 memset (&values.sals[0], 0, sizeof (values.sals[0]));
1877 values.sals[0].symtab = sym_symtab;
1878 values.sals[0].line = SYMBOL_LINE (sym);
1879 return values;
1880 }
1881 else
1882 /* This can happen if it is compiled with a compiler which doesn't
1883 put out line numbers for variables. */
1884 error ("Line number not known for symbol \"%s\"", copy);
1885 }
1886
1887 msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL);
1888 if (msymbol != NULL)
1889 {
1890 val.symtab = 0;
1891 val.line = 0;
1892 val.pc = msymbol -> address + FUNCTION_START_OFFSET;
1893 if (funfirstline)
1894 SKIP_PROLOGUE (val.pc);
1895 values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1896 values.sals[0] = val;
1897 values.nelts = 1;
1898 return values;
1899 }
1900
1901 if (!have_full_symbols () &&
1902 !have_partial_symbols () && !have_minimal_symbols ())
1903 error (no_symtab_msg);
1904
1905 error ("Function \"%s\" not defined.", copy);
1906 return values; /* for lint */
1907 }
1908
1909 struct symtabs_and_lines
decode_line_spec(string,funfirstline)1910 decode_line_spec (string, funfirstline)
1911 char *string;
1912 int funfirstline;
1913 {
1914 struct symtabs_and_lines sals;
1915 if (string == 0)
1916 error ("Empty line specification.");
1917 sals = decode_line_1 (&string, funfirstline,
1918 current_source_symtab, current_source_line);
1919 if (*string)
1920 error ("Junk at end of line specification: %s", string);
1921 return sals;
1922 }
1923
1924 /* Given a list of NELTS symbols in sym_arr (with corresponding
1925 mangled names in physnames), return a list of lines to operate on
1926 (ask user if necessary). */
1927 static struct symtabs_and_lines
decode_line_2(sym_arr,nelts,funfirstline)1928 decode_line_2 (sym_arr, nelts, funfirstline)
1929 struct symbol *sym_arr[];
1930 int nelts;
1931 int funfirstline;
1932 {
1933 struct symtabs_and_lines values, return_values;
1934 register CORE_ADDR pc;
1935 char *args, *arg1;
1936 int i;
1937 char *prompt;
1938 char *demangled;
1939
1940 values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
1941 return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));
1942
1943 i = 0;
1944 printf("[0] cancel\n[1] all\n");
1945 while (i < nelts)
1946 {
1947 if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
1948 {
1949 /* Arg is the name of a function */
1950 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]))
1951 + FUNCTION_START_OFFSET;
1952 if (funfirstline)
1953 SKIP_PROLOGUE (pc);
1954 values.sals[i] = find_pc_line (pc, 0);
1955 values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
1956 values.sals[i].end : pc;
1957 demangled = cplus_demangle (SYMBOL_NAME (sym_arr[i]),
1958 DMGL_PARAMS | DMGL_ANSI);
1959 printf("[%d] %s at %s:%d\n", (i+2),
1960 demangled ? demangled : SYMBOL_NAME (sym_arr[i]),
1961 values.sals[i].symtab->filename, values.sals[i].line);
1962 if (demangled != NULL)
1963 {
1964 free (demangled);
1965 }
1966 }
1967 else printf ("?HERE\n");
1968 i++;
1969 }
1970
1971 if ((prompt = getenv ("PS2")) == NULL)
1972 {
1973 prompt = ">";
1974 }
1975 printf("%s ",prompt);
1976 fflush(stdout);
1977
1978 args = command_line_input ((char *) NULL, 0);
1979
1980 if (args == 0)
1981 error_no_arg ("one or more choice numbers");
1982
1983 i = 0;
1984 while (*args)
1985 {
1986 int num;
1987
1988 arg1 = args;
1989 while (*arg1 >= '0' && *arg1 <= '9') arg1++;
1990 if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
1991 error ("Arguments must be choice numbers.");
1992
1993 num = atoi (args);
1994
1995 if (num == 0)
1996 error ("cancelled");
1997 else if (num == 1)
1998 {
1999 memcpy (return_values.sals, values.sals,
2000 (nelts * sizeof(struct symtab_and_line)));
2001 return_values.nelts = nelts;
2002 return return_values;
2003 }
2004
2005 if (num > nelts + 2)
2006 {
2007 printf ("No choice number %d.\n", num);
2008 }
2009 else
2010 {
2011 num -= 2;
2012 if (values.sals[num].pc)
2013 {
2014 return_values.sals[i++] = values.sals[num];
2015 values.sals[num].pc = 0;
2016 }
2017 else
2018 {
2019 printf ("duplicate request for %d ignored.\n", num);
2020 }
2021 }
2022
2023 args = arg1;
2024 while (*args == ' ' || *args == '\t') args++;
2025 }
2026 return_values.nelts = i;
2027 return return_values;
2028 }
2029
2030
2031 /* Slave routine for sources_info. Force line breaks at ,'s.
2032 NAME is the name to print and *FIRST is nonzero if this is the first
2033 name printed. Set *FIRST to zero. */
2034 static void
output_source_filename(name,first)2035 output_source_filename (name, first)
2036 char *name;
2037 int *first;
2038 {
2039 /* Table of files printed so far. Since a single source file can
2040 result in several partial symbol tables, we need to avoid printing
2041 it more than once. Note: if some of the psymtabs are read in and
2042 some are not, it gets printed both under "Source files for which
2043 symbols have been read" and "Source files for which symbols will
2044 be read in on demand". I consider this a reasonable way to deal
2045 with the situation. I'm not sure whether this can also happen for
2046 symtabs; it doesn't hurt to check. */
2047 static char **tab = NULL;
2048 /* Allocated size of tab in elements.
2049 Start with one 256-byte block (when using GNU malloc.c).
2050 24 is the malloc overhead when range checking is in effect. */
2051 static int tab_alloc_size = (256 - 24) / sizeof (char *);
2052 /* Current size of tab in elements. */
2053 static int tab_cur_size;
2054
2055 char **p;
2056
2057 if (*first)
2058 {
2059 if (tab == NULL)
2060 tab = (char **) xmalloc (tab_alloc_size * sizeof (*tab));
2061 tab_cur_size = 0;
2062 }
2063
2064 /* Is NAME in tab? */
2065 for (p = tab; p < tab + tab_cur_size; p++)
2066 if (strcmp (*p, name) == 0)
2067 /* Yes; don't print it again. */
2068 return;
2069 /* No; add it to tab. */
2070 if (tab_cur_size == tab_alloc_size)
2071 {
2072 tab_alloc_size *= 2;
2073 tab = (char **) xrealloc ((char *) tab, tab_alloc_size * sizeof (*tab));
2074 }
2075 tab[tab_cur_size++] = name;
2076
2077 if (*first)
2078 {
2079 *first = 0;
2080 }
2081 else
2082 {
2083 printf_filtered (", ");
2084 }
2085
2086 wrap_here ("");
2087 fputs_filtered (name, stdout);
2088 }
2089
2090 static void
sources_info(ignore,from_tty)2091 sources_info (ignore, from_tty)
2092 char *ignore;
2093 int from_tty;
2094 {
2095 register struct symtab *s;
2096 register struct partial_symtab *ps;
2097 register struct objfile *objfile;
2098 int first;
2099
2100 if (!have_full_symbols () && !have_partial_symbols ())
2101 {
2102 error (no_symtab_msg);
2103 }
2104
2105 printf_filtered ("Source files for which symbols have been read in:\n\n");
2106
2107 first = 1;
2108 ALL_SYMTABS (objfile, s)
2109 {
2110 output_source_filename (s -> filename, &first);
2111 }
2112 printf_filtered ("\n\n");
2113
2114 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2115
2116 first = 1;
2117 ALL_PSYMTABS (objfile, ps)
2118 {
2119 if (!ps->readin)
2120 {
2121 output_source_filename (ps -> filename, &first);
2122 }
2123 }
2124 printf_filtered ("\n");
2125 }
2126
2127 static int
name_match(name)2128 name_match (name)
2129 char *name;
2130 {
2131 char *demangled = cplus_demangle (name, DMGL_ANSI);
2132 if (demangled != NULL)
2133 {
2134 int cond = re_exec (demangled);
2135 free (demangled);
2136 return (cond);
2137 }
2138 return (re_exec (name));
2139 }
2140 #define NAME_MATCH(NAME) name_match(NAME)
2141
2142 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2143 If CLASS is zero, list all symbols except functions, type names, and
2144 constants (enums).
2145 If CLASS is 1, list only functions.
2146 If CLASS is 2, list only type names.
2147 If CLASS is 3, list only method names.
2148
2149 BPT is non-zero if we should set a breakpoint at the functions
2150 we find. */
2151
2152 static void
list_symbols(regexp,class,bpt)2153 list_symbols (regexp, class, bpt)
2154 char *regexp;
2155 int class;
2156 int bpt;
2157 {
2158 register struct symtab *s;
2159 register struct partial_symtab *ps;
2160 register struct blockvector *bv;
2161 struct blockvector *prev_bv = 0;
2162 register struct block *b;
2163 register int i, j;
2164 register struct symbol *sym;
2165 struct partial_symbol *psym;
2166 struct objfile *objfile;
2167 struct minimal_symbol *msymbol;
2168 char *val;
2169 static char *classnames[]
2170 = {"variable", "function", "type", "method"};
2171 int found_in_file = 0;
2172 int found_misc = 0;
2173 static enum minimal_symbol_type types[]
2174 = {mst_data, mst_text, mst_abs, mst_unknown};
2175 static enum minimal_symbol_type types2[]
2176 = {mst_bss, mst_text, mst_abs, mst_unknown};
2177 enum minimal_symbol_type ourtype = types[class];
2178 enum minimal_symbol_type ourtype2 = types2[class];
2179
2180 if (regexp)
2181 {
2182 /* Make sure spacing is right for C++ operators.
2183 This is just a courtesy to make the matching less sensitive
2184 to how many spaces the user leaves between 'operator'
2185 and <TYPENAME> or <OPERATOR>. */
2186 char *opend;
2187 char *opname = operator_chars (regexp, &opend);
2188 if (*opname)
2189 {
2190 int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
2191 if (isalpha(*opname) || *opname == '_' || *opname == '$')
2192 {
2193 /* There should 1 space between 'operator' and 'TYPENAME'. */
2194 if (opname[-1] != ' ' || opname[-2] == ' ')
2195 fix = 1;
2196 }
2197 else
2198 {
2199 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2200 if (opname[-1] == ' ')
2201 fix = 0;
2202 }
2203 /* If wrong number of spaces, fix it. */
2204 if (fix >= 0)
2205 {
2206 char *tmp = (char*) alloca(opend-opname+10);
2207 sprintf(tmp, "operator%.*s%s", fix, " ", opname);
2208 regexp = tmp;
2209 }
2210 }
2211
2212 if (0 != (val = re_comp (regexp)))
2213 error ("Invalid regexp (%s): %s", val, regexp);
2214 }
2215
2216 /* Search through the partial symtabs *first* for all symbols
2217 matching the regexp. That way we don't have to reproduce all of
2218 the machinery below. */
2219
2220 ALL_PSYMTABS (objfile, ps)
2221 {
2222 struct partial_symbol *bound, *gbound, *sbound;
2223 int keep_going = 1;
2224
2225 if (ps->readin) continue;
2226
2227 gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2228 sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2229 bound = gbound;
2230
2231 /* Go through all of the symbols stored in a partial
2232 symtab in one loop. */
2233 psym = objfile->global_psymbols.list + ps->globals_offset;
2234 while (keep_going)
2235 {
2236 if (psym >= bound)
2237 {
2238 if (bound == gbound && ps->n_static_syms != 0)
2239 {
2240 psym = objfile->static_psymbols.list + ps->statics_offset;
2241 bound = sbound;
2242 }
2243 else
2244 keep_going = 0;
2245 continue;
2246 }
2247 else
2248 {
2249 QUIT;
2250
2251 /* If it would match (logic taken from loop below)
2252 load the file and go on to the next one */
2253 if ((regexp == 0 || NAME_MATCH (SYMBOL_NAME (psym)))
2254 && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF
2255 && SYMBOL_CLASS (psym) != LOC_BLOCK)
2256 || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
2257 || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
2258 || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
2259 {
2260 PSYMTAB_TO_SYMTAB(ps);
2261 keep_going = 0;
2262 }
2263 }
2264 psym++;
2265 }
2266 }
2267
2268 /* Here, we search through the minimal symbol tables for functions that
2269 match, and call find_pc_symtab on them to force their symbols to
2270 be read. The symbol will then be found during the scan of symtabs
2271 below. If find_pc_symtab fails, set found_misc so that we will
2272 rescan to print any matching symbols without debug info. */
2273
2274 if (class == 1)
2275 {
2276 ALL_MSYMBOLS (objfile, msymbol)
2277 {
2278 if (msymbol -> type == ourtype || msymbol -> type == ourtype2)
2279 {
2280 if (regexp == 0 || NAME_MATCH (msymbol -> name))
2281 {
2282 if (0 == find_pc_symtab (msymbol -> address))
2283 {
2284 found_misc = 1;
2285 }
2286 }
2287 }
2288 }
2289 }
2290
2291 /* Printout here so as to get after the "Reading in symbols"
2292 messages which will be generated above. */
2293 if (!bpt)
2294 printf_filtered (regexp
2295 ? "All %ss matching regular expression \"%s\":\n"
2296 : "All defined %ss:\n",
2297 classnames[class],
2298 regexp);
2299
2300 ALL_SYMTABS (objfile, s)
2301 {
2302 found_in_file = 0;
2303 bv = BLOCKVECTOR (s);
2304 /* Often many files share a blockvector.
2305 Scan each blockvector only once so that
2306 we don't get every symbol many times.
2307 It happens that the first symtab in the list
2308 for any given blockvector is the main file. */
2309 if (bv != prev_bv)
2310 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
2311 {
2312 b = BLOCKVECTOR_BLOCK (bv, i);
2313 /* Skip the sort if this block is always sorted. */
2314 if (!BLOCK_SHOULD_SORT (b))
2315 sort_block_syms (b);
2316 for (j = 0; j < BLOCK_NSYMS (b); j++)
2317 {
2318 QUIT;
2319 sym = BLOCK_SYM (b, j);
2320 if ((regexp == 0 || NAME_MATCH (SYMBOL_NAME (sym)))
2321 && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
2322 && SYMBOL_CLASS (sym) != LOC_BLOCK
2323 && SYMBOL_CLASS (sym) != LOC_CONST)
2324 || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
2325 || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2326 || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
2327 {
2328 if (bpt)
2329 {
2330 /* Set a breakpoint here, if it's a function */
2331 if (class == 1)
2332 break_command (SYMBOL_NAME(sym), 0);
2333 }
2334 else if (!found_in_file)
2335 {
2336 fputs_filtered ("\nFile ", stdout);
2337 fputs_filtered (s->filename, stdout);
2338 fputs_filtered (":\n", stdout);
2339 }
2340 found_in_file = 1;
2341
2342 if (class != 2 && i == STATIC_BLOCK)
2343 printf_filtered ("static ");
2344
2345 /* Typedef that is not a C++ class */
2346 if (class == 2
2347 && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
2348 typedef_print (SYMBOL_TYPE(sym), sym, stdout);
2349 /* variable, func, or typedef-that-is-c++-class */
2350 else if (class < 2 ||
2351 (class == 2 &&
2352 SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE))
2353 {
2354 type_print (SYMBOL_TYPE (sym),
2355 (SYMBOL_CLASS (sym) == LOC_TYPEDEF
2356 ? "" : SYMBOL_NAME (sym)),
2357 stdout, 0);
2358
2359 printf_filtered (";\n");
2360 }
2361 else
2362 {
2363 # if 0
2364 /* FIXME, why is this zapped out? */
2365 char buf[1024];
2366 type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0);
2367 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0);
2368 sprintf (buf, " %s::", type_name_no_tag (t));
2369 type_print_method_args (TYPE_FN_FIELD_ARGS (t, i), buf, name, stdout);
2370 # endif
2371 }
2372 }
2373 }
2374 }
2375 prev_bv = bv;
2376 }
2377
2378 /* If there are no eyes, avoid all contact. I mean, if there are
2379 no debug symbols, then print directly from the msymbol_vector. */
2380
2381 if (found_misc || class != 1)
2382 {
2383 found_in_file = 0;
2384 ALL_MSYMBOLS (objfile, msymbol)
2385 {
2386 if (msymbol -> type == ourtype || msymbol -> type == ourtype2)
2387 {
2388 if (regexp == 0 || NAME_MATCH (msymbol -> name))
2389 {
2390 /* Functions: Look up by address. */
2391 if (class != 1 ||
2392 (0 == find_pc_symtab (msymbol -> address)))
2393 {
2394 /* Variables/Absolutes: Look up by name */
2395 if (lookup_symbol (msymbol -> name,
2396 (struct block *) 0, VAR_NAMESPACE, 0,
2397 (struct symtab **) 0) == NULL)
2398 {
2399 if (!found_in_file)
2400 {
2401 printf_filtered ("\nNon-debugging symbols:\n");
2402 found_in_file = 1;
2403 }
2404 printf_filtered (" %08x %s\n",
2405 msymbol -> address,
2406 msymbol -> name);
2407 }
2408 }
2409 }
2410 }
2411 }
2412 }
2413 }
2414
2415 static void
variables_info(regexp,from_tty)2416 variables_info (regexp, from_tty)
2417 char *regexp;
2418 int from_tty;
2419 {
2420 list_symbols (regexp, 0, 0);
2421 }
2422
2423 static void
functions_info(regexp,from_tty)2424 functions_info (regexp, from_tty)
2425 char *regexp;
2426 int from_tty;
2427 {
2428 list_symbols (regexp, 1, 0);
2429 }
2430
2431 static void
types_info(regexp,from_tty)2432 types_info (regexp, from_tty)
2433 char *regexp;
2434 int from_tty;
2435 {
2436 list_symbols (regexp, 2, 0);
2437 }
2438
2439 #if 0
2440 /* Tiemann says: "info methods was never implemented." */
2441 static void
2442 methods_info (regexp)
2443 char *regexp;
2444 {
2445 list_symbols (regexp, 3, 0);
2446 }
2447 #endif /* 0 */
2448
2449 /* Breakpoint all functions matching regular expression. */
2450 static void
rbreak_command(regexp,from_tty)2451 rbreak_command (regexp, from_tty)
2452 char *regexp;
2453 int from_tty;
2454 {
2455 list_symbols (regexp, 1, 1);
2456 }
2457
2458
2459 /* Return Nonzero if block a is lexically nested within block b,
2460 or if a and b have the same pc range.
2461 Return zero otherwise. */
2462 int
contained_in(a,b)2463 contained_in (a, b)
2464 struct block *a, *b;
2465 {
2466 if (!a || !b)
2467 return 0;
2468 return BLOCK_START (a) >= BLOCK_START (b)
2469 && BLOCK_END (a) <= BLOCK_END (b);
2470 }
2471
2472
2473 /* Helper routine for make_symbol_completion_list. */
2474
2475 static int return_val_size;
2476 static int return_val_index;
2477 static char **return_val;
2478
2479 static void
completion_list_add_name(name)2480 completion_list_add_name(name)
2481 char *name;
2482 {
2483 if (return_val_index + 3 > return_val_size)
2484 return_val = (char **) xrealloc ((char *) return_val,
2485 (return_val_size *= 2) * sizeof (char *));
2486
2487 return_val[return_val_index] = name;
2488 return_val[++return_val_index] = (char *)NULL;
2489 }
2490
2491 static void
completion_list_check_symbol(symname,text,text_len)2492 completion_list_check_symbol (symname, text, text_len)
2493 char *symname;
2494 char *text;
2495 int text_len;
2496 {
2497 register char *cp;
2498
2499 if ((cp = cplus_demangle(symname, -1)) != NULL)
2500 {
2501 if (strncmp(cp, text, text_len) == 0 && strncmp(symname, "_vt$", 4))
2502 completion_list_add_name(cp);
2503 else
2504 free(cp);
2505 }
2506 else if ((strncmp (symname, text, text_len) == 0))
2507 {
2508 cp = (char *)xmalloc (1 + strlen (symname));
2509 strcpy(cp, symname);
2510 completion_list_add_name(cp);
2511 }
2512 }
2513
2514 /* Return a NULL terminated array of all symbols (regardless of class) which
2515 begin by matching TEXT. If the answer is no symbols, then the return value
2516 is an array which contains only a NULL pointer.
2517
2518 Problem: All of the symbols have to be copied because readline frees them.
2519 I'm not going to worry about this; hopefully there won't be that many. */
2520
2521 char **
make_completion_list(text,wantclass)2522 make_completion_list (text, wantclass)
2523 char *text;
2524 enum address_class wantclass;
2525 {
2526 register struct symbol *sym;
2527 register struct symtab *s;
2528 register struct partial_symtab *ps;
2529 register struct minimal_symbol *msymbol;
2530 register struct objfile *objfile;
2531 register struct block *b, *surrounding_static_block = 0;
2532 register int i, j;
2533 int text_len;
2534 struct partial_symbol *psym;
2535
2536 text_len = strlen (text);
2537 return_val_size = 100;
2538 return_val_index = 0;
2539 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
2540 return_val[0] = NULL;
2541
2542 /* Look through the partial symtabs for all symbols which begin
2543 by matching TEXT. Add each one that you find to the list. */
2544
2545 ALL_PSYMTABS (objfile, ps)
2546 {
2547 /* If the psymtab's been read in we'll get it when we search
2548 through the blockvector. */
2549 if (ps->readin) continue;
2550
2551 for (psym = objfile->global_psymbols.list + ps->globals_offset;
2552 psym < (objfile->global_psymbols.list + ps->globals_offset
2553 + ps->n_global_syms);
2554 psym++)
2555 {
2556 /* If interrupted, then quit. */
2557 QUIT;
2558 if (wantclass && wantclass != SYMBOL_CLASS (psym))
2559 continue;
2560 completion_list_check_symbol (SYMBOL_NAME (psym), text, text_len);
2561 }
2562
2563 for (psym = objfile->static_psymbols.list + ps->statics_offset;
2564 psym < (objfile->static_psymbols.list + ps->statics_offset
2565 + ps->n_static_syms);
2566 psym++)
2567 {
2568 QUIT;
2569 if (wantclass && wantclass != SYMBOL_CLASS (psym))
2570 continue;
2571 completion_list_check_symbol (SYMBOL_NAME (psym), text, text_len);
2572 }
2573 }
2574
2575 /* At this point scan through the misc symbol vectors and add each
2576 symbol you find to the list. Eventually we want to ignore
2577 anything that isn't a text symbol (everything else will be
2578 handled by the psymtab code above). */
2579
2580 ALL_MSYMBOLS (objfile, msymbol)
2581 {
2582 QUIT;
2583 completion_list_check_symbol (msymbol -> name, text, text_len);
2584 }
2585
2586 /* Search upwards from currently selected frame (so that we can
2587 complete on local vars. */
2588
2589 for (b = get_selected_block (); b != NULL; b = BLOCK_SUPERBLOCK (b))
2590 {
2591 if (!BLOCK_SUPERBLOCK (b))
2592 {
2593 surrounding_static_block = b; /* For elmin of dups */
2594 }
2595
2596 /* Also catch fields of types defined in this places which match our
2597 text string. Only complete on types visible from current context. */
2598
2599 for (i = 0; i < BLOCK_NSYMS (b); i++)
2600 {
2601 sym = BLOCK_SYM (b, i);
2602 if (wantclass && wantclass != SYMBOL_CLASS (sym))
2603 continue;
2604 completion_list_check_symbol (SYMBOL_NAME (sym), text, text_len);
2605 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2606 {
2607 struct type *t = SYMBOL_TYPE (sym);
2608 enum type_code c = TYPE_CODE (t);
2609
2610 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
2611 {
2612 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
2613 {
2614 if (TYPE_FIELD_NAME (t, j))
2615 {
2616 completion_list_check_symbol (TYPE_FIELD_NAME (t, j),
2617 text, text_len);
2618 }
2619 }
2620 }
2621 }
2622 }
2623 }
2624
2625 /* Go through the symtabs and check the externs and statics for
2626 symbols which match. */
2627
2628 ALL_SYMTABS (objfile, s)
2629 {
2630 QUIT;
2631 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
2632 for (i = 0; i < BLOCK_NSYMS (b); i++)
2633 {
2634 sym = BLOCK_SYM (b, i);
2635 if (wantclass && wantclass != SYMBOL_CLASS (sym))
2636 continue;
2637 completion_list_check_symbol (SYMBOL_NAME (sym), text, text_len);
2638 }
2639 }
2640
2641 ALL_SYMTABS (objfile, s)
2642 {
2643 QUIT;
2644 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
2645 /* Don't do this block twice. */
2646 if (b == surrounding_static_block) continue;
2647 for (i = 0; i < BLOCK_NSYMS (b); i++)
2648 {
2649 sym = BLOCK_SYM (b, i);
2650 if (wantclass && wantclass != SYMBOL_CLASS (sym))
2651 continue;
2652 completion_list_check_symbol (SYMBOL_NAME (sym), text, text_len);
2653 }
2654 }
2655
2656 return (return_val);
2657 }
2658
2659 char **
make_function_completion_list(text)2660 make_function_completion_list (text)
2661 char *text;
2662 {
2663 return (make_completion_list(text, LOC_BLOCK));
2664 }
2665
2666 char **
make_symbol_completion_list(text)2667 make_symbol_completion_list (text)
2668 char *text;
2669 {
2670 return (make_completion_list(text, 0));
2671 }
2672
2673 /* Find a mangled symbol that corresponds to LOOKFOR using brute force.
2674 Basically we go munging through available symbols, demangling each one,
2675 looking for a match on the demangled result. */
2676
2677 static char *
expensive_mangler(lookfor)2678 expensive_mangler (lookfor)
2679 const char *lookfor;
2680 {
2681 register struct symbol *sym;
2682 register struct symtab *s;
2683 register struct partial_symtab *ps;
2684 register struct minimal_symbol *msymbol;
2685 register struct objfile *objfile;
2686 register struct block *b, *surrounding_static_block = 0;
2687 register int i, j;
2688 struct partial_symbol *psym;
2689 char *demangled;
2690
2691 /* Look through the partial symtabs for a symbol that matches */
2692
2693 ALL_PSYMTABS (objfile, ps)
2694 {
2695 /* If the psymtab's been read in we'll get it when we search
2696 through the blockvector. */
2697 if (ps->readin) continue;
2698
2699 for (psym = objfile->global_psymbols.list + ps->globals_offset;
2700 psym < (objfile->global_psymbols.list + ps->globals_offset
2701 + ps->n_global_syms);
2702 psym++)
2703 {
2704 QUIT; /* If interrupted, then quit. */
2705 demangled = demangle_and_match (SYMBOL_NAME (psym), lookfor,
2706 DMGL_PARAMS | DMGL_ANSI);
2707 if (demangled != NULL)
2708 {
2709 free (demangled);
2710 return (SYMBOL_NAME (psym));
2711 }
2712 }
2713
2714 for (psym = objfile->static_psymbols.list + ps->statics_offset;
2715 psym < (objfile->static_psymbols.list + ps->statics_offset
2716 + ps->n_static_syms);
2717 psym++)
2718 {
2719 QUIT;
2720 demangled = demangle_and_match (SYMBOL_NAME (psym), lookfor,
2721 DMGL_PARAMS | DMGL_ANSI);
2722 if (demangled != NULL)
2723 {
2724 free (demangled);
2725 return (SYMBOL_NAME (psym));
2726 }
2727 }
2728 }
2729
2730 /* Scan through the misc symbol vectors looking for a match. */
2731
2732 ALL_MSYMBOLS (objfile, msymbol)
2733 {
2734 QUIT;
2735 demangled = demangle_and_match (msymbol -> name, lookfor,
2736 DMGL_PARAMS | DMGL_ANSI);
2737 if (demangled != NULL)
2738 {
2739 free (demangled);
2740 return (msymbol -> name);
2741 }
2742 }
2743
2744 /* Search upwards from currently selected frame looking for a match */
2745
2746 for (b = get_selected_block (); b; b = BLOCK_SUPERBLOCK (b))
2747 {
2748 if (!BLOCK_SUPERBLOCK (b))
2749 surrounding_static_block = b; /* For elmin of dups */
2750
2751 /* Also catch fields of types defined in this places which
2752 match our text string. Only complete on types visible
2753 from current context. */
2754 for (i = 0; i < BLOCK_NSYMS (b); i++)
2755 {
2756 sym = BLOCK_SYM (b, i);
2757 demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
2758 DMGL_PARAMS | DMGL_ANSI);
2759 if (demangled != NULL)
2760 {
2761 free (demangled);
2762 return (SYMBOL_NAME (sym));
2763 }
2764 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2765 {
2766 struct type *t = SYMBOL_TYPE (sym);
2767 enum type_code c = TYPE_CODE (t);
2768
2769 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
2770 {
2771 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
2772 {
2773 if (TYPE_FIELD_NAME (t, j))
2774 {
2775 demangled =
2776 demangle_and_match (TYPE_FIELD_NAME (t, j),
2777 lookfor,
2778 DMGL_PARAMS | DMGL_ANSI);
2779 if (demangled != NULL)
2780 {
2781 free (demangled);
2782 return (TYPE_FIELD_NAME (t, j));
2783 }
2784 }
2785 }
2786 }
2787 }
2788 }
2789 }
2790
2791 /* Go through the symtabs and check the externs and statics for
2792 symbols which match. */
2793
2794 ALL_SYMTABS (objfile, s)
2795 {
2796 QUIT;
2797 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
2798 for (i = 0; i < BLOCK_NSYMS (b); i++)
2799 {
2800 sym = BLOCK_SYM (b, i);
2801 demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
2802 DMGL_PARAMS | DMGL_ANSI);
2803 if (demangled != NULL)
2804 {
2805 free (demangled);
2806 return (SYMBOL_NAME (sym));
2807 }
2808 }
2809 }
2810
2811 ALL_SYMTABS (objfile, s)
2812 {
2813 QUIT;
2814 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
2815 /* Don't do this block twice. */
2816 if (b == surrounding_static_block) continue;
2817 for (i = 0; i < BLOCK_NSYMS (b); i++)
2818 {
2819 sym = BLOCK_SYM (b, i);
2820 demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
2821 DMGL_PARAMS | DMGL_ANSI);
2822 if (demangled != NULL)
2823 {
2824 free (demangled);
2825 return (SYMBOL_NAME (sym));
2826 }
2827 }
2828 }
2829
2830 return (NULL);
2831 }
2832
2833 #if 0
2834 /* Add the type of the symbol sym to the type of the current
2835 function whose block we are in (assumed). The type of
2836 this current function is contained in *TYPE.
2837
2838 This basically works as follows: When we find a function
2839 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2840 a pointer to its type in the global in_function_type. Every
2841 time we come across a parameter symbol ('p' in its name), then
2842 this procedure adds the name and type of that parameter
2843 to the function type pointed to by *TYPE. (Which should correspond
2844 to in_function_type if it was called correctly).
2845
2846 Note that since we are modifying a type, the result of
2847 lookup_function_type() should be memcpy()ed before calling
2848 this. When not in strict typing mode, the expression
2849 evaluator can choose to ignore this.
2850
2851 Assumption: All of a function's parameter symbols will
2852 appear before another function symbol is found. The parameters
2853 appear in the same order in the argument list as they do in the
2854 symbol table. */
2855
2856 void
2857 add_param_to_type (type,sym)
2858 struct type **type;
2859 struct symbol *sym;
2860 {
2861 int num = ++(TYPE_NFIELDS(*type));
2862
2863 if(TYPE_NFIELDS(*type)-1)
2864 TYPE_FIELDS(*type) = (struct field *)
2865 (*current_objfile->xrealloc) ((char *)(TYPE_FIELDS(*type)),
2866 num*sizeof(struct field));
2867 else
2868 TYPE_FIELDS(*type) = (struct field *)
2869 (*current_objfile->xmalloc) (num*sizeof(struct field));
2870
2871 TYPE_FIELD_BITPOS(*type,num-1) = num-1;
2872 TYPE_FIELD_BITSIZE(*type,num-1) = 0;
2873 TYPE_FIELD_TYPE(*type,num-1) = SYMBOL_TYPE(sym);
2874 TYPE_FIELD_NAME(*type,num-1) = SYMBOL_NAME(sym);
2875 }
2876 #endif
2877
2878 void
_initialize_symtab()2879 _initialize_symtab ()
2880 {
2881 add_info ("variables", variables_info,
2882 "All global and static variable names, or those matching REGEXP.");
2883 add_info ("functions", functions_info,
2884 "All function names, or those matching REGEXP.");
2885
2886 /* FIXME: This command has at least the following problems:
2887 1. It prints builtin types (in a very strange and confusing fashion).
2888 2. It doesn't print right, e.g. with
2889 typedef struct foo *FOO
2890 type_print prints "FOO" when we want to make it (in this situation)
2891 print "struct foo *".
2892 I also think "ptype" or "whatis" is more likely to be useful (but if
2893 there is much disagreement "info types" can be fixed). */
2894 add_info ("types", types_info,
2895 "All type names, or those matching REGEXP.");
2896
2897 #if 0
2898 add_info ("methods", methods_info,
2899 "All method names, or those matching REGEXP::REGEXP.\n\
2900 If the class qualifier is omitted, it is assumed to be the current scope.\n\
2901 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
2902 are listed.");
2903 #endif
2904 add_info ("sources", sources_info,
2905 "Source files in the program.");
2906
2907 add_com ("rbreak", no_class, rbreak_command,
2908 "Set a breakpoint for all functions matching REGEXP.");
2909
2910 /* Initialize the one built-in type that isn't language dependent... */
2911 builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
2912 "<unknown type>", (struct objfile *) NULL);
2913 }
2914