1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
31 #include "call-cmds.h"
33 #include "expression.h"
40 #include <sys/types.h>
46 /* Prototypes for local functions */
49 expensive_mangler
PARAMS ((const char *));
52 find_methods
PARAMS ((struct type
*, char *, char **, struct symbol
**));
55 completion_list_add_symbol
PARAMS ((char *, char *, int));
57 static struct symtabs_and_lines
58 decode_line_2
PARAMS ((struct symbol
*[], int, int));
61 rbreak_command
PARAMS ((char *, int));
64 types_info
PARAMS ((char *, int));
67 functions_info
PARAMS ((char *, int));
70 variables_info
PARAMS ((char *, int));
73 sources_info
PARAMS ((char *, int));
76 list_symbols
PARAMS ((char *, int, int));
79 output_source_filename
PARAMS ((char *, int *));
82 operator_chars
PARAMS ((char *, char **));
85 find_line_common
PARAMS ((struct linetable
*, int, int *));
87 static struct partial_symbol
*
88 lookup_partial_symbol
PARAMS ((struct partial_symtab
*, const char *,
89 int, enum namespace));
91 static struct partial_symbol
*
92 lookup_demangled_partial_symbol
PARAMS ((const struct partial_symtab
*,
95 static struct symbol
*
96 lookup_demangled_block_symbol
PARAMS ((const struct block
*, const char *));
98 static struct symtab
*
99 lookup_symtab_1
PARAMS ((char *));
103 /* The single non-language-specific builtin type */
104 struct type
*builtin_type_error
;
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
110 const struct block
*block_found
;
112 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
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 */
119 cplusplus_hint (name
)
122 printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
123 printf ("(Note leading single quote.)\n");
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. */
130 static struct symtab
*
131 lookup_symtab_1 (name
)
134 register struct symtab
*s
;
135 register struct partial_symtab
*ps
;
136 register char *slash
;
137 register struct objfile
*objfile
;
141 /* First, search for an exact match */
143 ALL_SYMTABS (objfile
, s
)
144 if (strcmp (name
, s
->filename
) == 0)
147 slash
= strchr (name
, '/');
149 /* Now, search for a matching tail (only if name doesn't have any dirs) */
152 ALL_SYMTABS (objfile
, s
)
154 char *p
= s
-> filename
;
155 char *tail
= strrchr (p
, '/');
160 if (strcmp (p
, name
) == 0)
164 /* Same search rules as above apply here, but now we look thru the
167 ALL_PSYMTABS (objfile
, ps
)
168 if (strcmp (name
, ps
-> filename
) == 0)
172 ALL_PSYMTABS (objfile
, ps
)
174 char *p
= ps
-> filename
;
175 char *tail
= strrchr (p
, '/');
180 if (strcmp (p
, name
) == 0)
189 error ("Internal: readin %s pst for `%s' found when no symtab found.",
190 ps
-> filename
, name
);
192 s
= PSYMTAB_TO_SYMTAB (ps
);
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. */
208 /* Lookup the symbol table of a source file named NAME. Try a couple
209 of variations if the first lookup doesn't work. */
215 register struct symtab
*s
;
218 s
= lookup_symtab_1 (name
);
221 /* If name not found as specified, see if adding ".c" helps. */
223 copy
= (char *) alloca (strlen (name
) + 3);
226 s
= lookup_symtab_1 (copy
);
229 /* We didn't find anything; die. */
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. */
237 struct partial_symtab
*
238 lookup_partial_symtab (name
)
241 register struct partial_symtab
*pst
;
242 register struct objfile
*objfile
;
244 ALL_PSYMTABS (objfile
, pst
)
246 if (strcmp (name
, pst
-> filename
) == 0)
254 /* Demangle a GDB method stub type. */
256 gdb_mangle_name (type
, i
, j
)
260 int mangled_name_len
;
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" : "";
274 #ifndef GCC_MANGLE_BUG
275 int len
= strlen (newname
);
279 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
280 strcpy(mangled_name
, physname
);
284 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
285 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
290 /* Only needed for GNU-mangled names. ANSI-mangled names
291 work with the normal mechanisms. */
292 if (OPNAME_PREFIX_P (field_name
))
294 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
296 error ("No mangling for \"%s\"", field_name
);
297 mangled_name_len
+= strlen (opname
);
298 mangled_name
= (char *)xmalloc (mangled_name_len
);
300 strncpy (mangled_name
, field_name
, 3);
301 mangled_name
[3] = '\0';
302 strcat (mangled_name
, opname
);
306 mangled_name
= (char *)xmalloc (mangled_name_len
);
308 mangled_name
[0] = '\0';
310 strcpy (mangled_name
, field_name
);
312 strcat (mangled_name
, buf
);
313 strcat (mangled_name
, newname
);
323 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
326 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
327 + strlen (buf
) + strlen (physname
) + 1);
329 /* Only needed for GNU-mangled names. ANSI-mangled names
330 work with the normal mechanisms. */
331 if (OPNAME_PREFIX_P (field_name
))
333 opname
= cplus_mangle_opname (field_name
+ 3, 0);
336 error ("No mangling for \"%s\"", field_name
);
338 mangled_name_len
+= strlen (opname
);
339 mangled_name
= (char *) xmalloc (mangled_name_len
);
341 strncpy (mangled_name
, field_name
, 3);
342 strcpy (mangled_name
+ 3, opname
);
346 mangled_name
= (char *) xmalloc (mangled_name_len
);
349 mangled_name
[0] = '\0';
353 strcpy (mangled_name
, field_name
);
356 strcat (mangled_name
, buf
);
359 strcat (mangled_name
, physname
);
360 return (mangled_name
);
364 /* Find which partial symtab on contains PC. Return 0 if none. */
366 struct partial_symtab
*
368 register CORE_ADDR pc
;
370 register struct partial_symtab
*pst
;
371 register struct objfile
*objfile
;
373 ALL_PSYMTABS (objfile
, pst
)
375 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
381 /* Find which partial symbol within a psymtab contains PC. Return 0
382 if none. Check all psymtabs if PSYMTAB is 0. */
383 struct partial_symbol
*
384 find_pc_psymbol (psymtab
, pc
)
385 struct partial_symtab
*psymtab
;
388 struct partial_symbol
*best
, *p
;
392 psymtab
= find_pc_psymtab (pc
);
396 best_pc
= psymtab
->textlow
- 1;
398 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
399 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
400 < psymtab
->n_static_syms
);
402 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
403 && SYMBOL_CLASS (p
) == LOC_BLOCK
404 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
405 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
407 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
410 if (best_pc
== psymtab
->textlow
- 1)
416 /* Find the definition for a specified symbol name NAME
417 in namespace NAMESPACE, visible from lexical block BLOCK.
418 Returns the struct symbol pointer, or zero if no symbol is found.
419 If SYMTAB is non-NULL, store the symbol table in which the
420 symbol was found there, or NULL if not found.
421 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
422 NAME is a field of the current implied argument `this'. If so set
423 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
424 BLOCK_FOUND is set to the block in which NAME is found (in the case of
425 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
428 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
430 register const struct block
*block
;
431 const enum namespace namespace;
432 int *is_a_field_of_this
;
433 struct symtab
**symtab
;
435 register struct symbol
*sym
;
436 register struct symtab
*s
;
437 register struct partial_symtab
*ps
;
438 struct blockvector
*bv
;
439 register struct objfile
*objfile
;
440 register struct block
*b
;
441 register struct minimal_symbol
*msymbol
;
443 extern char *gdb_completer_word_break_characters
;
445 /* If NAME contains any characters from gdb_completer_word_break_characters
446 then it is probably from a quoted name string. So check to see if it
447 has a C++ mangled equivalent, and if so, use the mangled equivalent. */
449 if (strpbrk (name
, gdb_completer_word_break_characters
) != NULL
)
451 if ((temp
= expensive_mangler (name
)) != NULL
)
457 /* Search specified block and its superiors. */
461 sym
= lookup_block_symbol (block
, name
, namespace);
467 /* Search the list of symtabs for one which contains the
468 address of the start of this block. */
469 ALL_SYMTABS (objfile
, s
)
471 bv
= BLOCKVECTOR (s
);
472 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
473 if (BLOCK_START (b
) <= BLOCK_START (block
)
474 && BLOCK_END (b
) > BLOCK_START (block
))
483 block
= BLOCK_SUPERBLOCK (block
);
486 /* But that doesn't do any demangling for the STATIC_BLOCK.
487 I'm not sure whether demangling is needed in the case of
488 nested function in inner blocks; if so this needs to be changed.
490 Don't need to mess with the psymtabs; if we have a block,
491 that file is read in. If we don't, then we deal later with
492 all the psymtab stuff that needs checking. */
493 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
496 /* Find the right symtab. */
497 ALL_SYMTABS (objfile
, s
)
499 bv
= BLOCKVECTOR (s
);
500 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
501 if (BLOCK_START (b
) <= BLOCK_START (block
)
502 && BLOCK_END (b
) > BLOCK_START (block
))
504 sym
= lookup_demangled_block_symbol (b
, name
);
517 /* C++: If requested to do so by the caller,
518 check to see if NAME is a field of `this'. */
519 if (is_a_field_of_this
)
521 struct value
*v
= value_of_this (0);
523 *is_a_field_of_this
= 0;
524 if (v
&& check_field (v
, name
))
526 *is_a_field_of_this
= 1;
533 /* Now search all global blocks. Do the symtab's first, then
534 check the psymtab's */
536 ALL_SYMTABS (objfile
, s
)
538 bv
= BLOCKVECTOR (s
);
539 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
540 sym
= lookup_block_symbol (block
, name
, namespace);
550 /* Check for the possibility of the symbol being a global function
551 that is stored in one of the minimal symbol tables. Eventually, all
552 global symbols might be resolved in this way. */
554 if (namespace == VAR_NAMESPACE
)
556 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
560 /* Test each minimal symbol to see if the minimal symbol's name
561 is a C++ mangled name that matches a user visible name. */
565 ALL_MSYMBOLS (objfile
, msymbol
)
567 demangled
= demangle_and_match (msymbol
-> name
, name
,
568 DMGL_PARAMS
| DMGL_ANSI
);
569 if (demangled
!= NULL
)
575 msymbol
= NULL
; /* Not found */
581 s
= find_pc_symtab (msymbol
-> address
);
582 /* If S is NULL, there are no debug symbols for this file.
583 Skip this stuff and check for matching static symbols below. */
586 bv
= BLOCKVECTOR (s
);
587 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
588 sym
= lookup_block_symbol (block
, msymbol
-> name
, namespace);
589 /* We kept static functions in minimal symbol table as well as
590 in static scope. We want to find them in the symbol table. */
592 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
593 sym
= lookup_block_symbol (block
, msymbol
-> name
,
597 /* sym == 0 if symbol was found in the minimal symbol table
598 but not in the symtab.
599 Return 0 to use the msymbol definition of "foo_".
601 This happens for Fortran "foo_" symbols,
602 which are "foo" in the symtab.
604 This can also happen if "asm" is used to make a
605 regular symbol but not a debugging symbol, e.g.
617 ALL_PSYMTABS (objfile
, ps
)
619 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
621 s
= PSYMTAB_TO_SYMTAB(ps
);
622 bv
= BLOCKVECTOR (s
);
623 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
624 sym
= lookup_block_symbol (block
, name
, namespace);
626 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
633 /* Now search all per-file blocks.
634 Not strictly correct, but more useful than an error.
635 Do the symtabs first, then check the psymtabs */
637 ALL_SYMTABS (objfile
, s
)
639 bv
= BLOCKVECTOR (s
);
640 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
641 sym
= lookup_block_symbol (block
, name
, namespace);
651 ALL_PSYMTABS (objfile
, ps
)
653 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
655 s
= PSYMTAB_TO_SYMTAB(ps
);
656 bv
= BLOCKVECTOR (s
);
657 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
658 sym
= lookup_block_symbol (block
, name
, namespace);
660 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
667 /* Now search all per-file blocks for static mangled symbols.
668 Do the symtabs first, then check the psymtabs. */
670 if (namespace == VAR_NAMESPACE
)
672 ALL_SYMTABS (objfile
, s
)
674 bv
= BLOCKVECTOR (s
);
675 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
676 sym
= lookup_demangled_block_symbol (block
, name
);
686 ALL_PSYMTABS (objfile
, ps
)
688 if (!ps
->readin
&& lookup_demangled_partial_symbol (ps
, name
))
690 s
= PSYMTAB_TO_SYMTAB(ps
);
691 bv
= BLOCKVECTOR (s
);
692 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
693 sym
= lookup_demangled_block_symbol (block
, name
);
695 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
708 /* Look for a static demangled symbol in block BLOCK. */
710 static struct symbol
*
711 lookup_demangled_block_symbol (block
, name
)
712 register const struct block
*block
;
715 register int bot
, top
;
716 register struct symbol
*sym
;
720 top
= BLOCK_NSYMS (block
);
724 sym
= BLOCK_SYM (block
, bot
);
725 if (SYMBOL_NAMESPACE (sym
) == VAR_NAMESPACE
)
727 demangled
= demangle_and_match (SYMBOL_NAME (sym
), name
,
728 DMGL_PARAMS
| DMGL_ANSI
);
729 if (demangled
!= NULL
)
741 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
743 static struct partial_symbol
*
744 lookup_demangled_partial_symbol (pst
, name
)
745 const struct partial_symtab
*pst
;
748 struct partial_symbol
*start
, *psym
;
749 int length
= pst
->n_static_syms
;
753 return (struct partial_symbol
*) 0;
755 start
= pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
;
756 for (psym
= start
; psym
< start
+ length
; psym
++)
758 if (SYMBOL_NAMESPACE (psym
) == VAR_NAMESPACE
)
760 demangled
= demangle_and_match (SYMBOL_NAME (psym
), name
,
761 DMGL_PARAMS
| DMGL_ANSI
);
762 if (demangled
!= NULL
)
773 /* Look, in partial_symtab PST, for symbol NAME. Check the global
774 symbols if GLOBAL, the static symbols if not */
776 static struct partial_symbol
*
777 lookup_partial_symbol (pst
, name
, global
, namespace)
778 struct partial_symtab
*pst
;
781 enum namespace namespace;
783 struct partial_symbol
*start
, *psym
;
784 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
787 return (struct partial_symbol
*) 0;
790 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
791 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
793 if (global
) /* This means we can use a binary */
796 struct partial_symbol
*top
, *bottom
, *center
;
798 /* Binary search. This search is guaranteed to end with center
799 pointing at the earliest partial symbol with the correct
800 name. At that point *all* partial symbols with that name
801 will be checked against the correct namespace. */
803 top
= start
+ length
- 1;
806 center
= bottom
+ (top
- bottom
) / 2;
808 assert (center
< top
);
810 if (strcmp (SYMBOL_NAME (center
), name
) >= 0)
815 assert (top
== bottom
);
817 while (!strcmp (SYMBOL_NAME (top
), name
))
819 if (SYMBOL_NAMESPACE (top
) == namespace)
826 /* Can't use a binary search */
827 for (psym
= start
; psym
< start
+ length
; psym
++)
828 if (namespace == SYMBOL_NAMESPACE (psym
)
829 && !strcmp (name
, SYMBOL_NAME (psym
)))
833 return (struct partial_symbol
*) 0;
836 /* Find the psymtab containing main(). */
837 /* FIXME: What about languages without main() or specially linked
838 executables that have no main() ? */
840 struct partial_symtab
*
843 register struct partial_symtab
*pst
;
844 register struct objfile
*objfile
;
846 ALL_PSYMTABS (objfile
, pst
)
848 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
856 /* Look for a symbol in block BLOCK. */
859 lookup_block_symbol (block
, name
, namespace)
860 register const struct block
*block
;
862 const enum namespace namespace;
864 register int bot
, top
, inc
;
865 register struct symbol
*sym
, *parameter_sym
;
867 top
= BLOCK_NSYMS (block
);
870 /* If the blocks's symbols were sorted, start with a binary search. */
872 if (BLOCK_SHOULD_SORT (block
))
874 /* First, advance BOT to not far before
875 the first symbol whose name is NAME. */
879 inc
= (top
- bot
+ 1);
880 /* No need to keep binary searching for the last few bits worth. */
883 inc
= (inc
>> 1) + bot
;
884 sym
= BLOCK_SYM (block
, inc
);
885 if (SYMBOL_NAME (sym
)[0] < name
[0])
887 else if (SYMBOL_NAME (sym
)[0] > name
[0])
889 else if (strcmp (SYMBOL_NAME (sym
), name
) < 0)
895 /* Now scan forward until we run out of symbols,
896 find one whose name is greater than NAME,
898 If there is more than one symbol with the right name and namespace,
899 we return the first one. dbxread.c is careful to make sure
900 that if one is a register then it comes first. */
902 top
= BLOCK_NSYMS (block
);
905 sym
= BLOCK_SYM (block
, bot
);
906 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
908 inc
= strcmp (SYMBOL_NAME (sym
), name
);
909 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
918 /* Here if block isn't sorted.
919 This loop is equivalent to the loop above,
920 but hacked greatly for speed.
922 Note that parameter symbols do not always show up last in the
923 list; this loop makes sure to take anything else other than
924 parameter symbols first; it only uses parameter symbols as a
925 last resort. Note that this only takes up extra computation
928 parameter_sym
= (struct symbol
*) 0;
929 top
= BLOCK_NSYMS (block
);
933 sym
= BLOCK_SYM (block
, bot
);
934 if (SYMBOL_NAME (sym
)[0] == inc
935 && !strcmp (SYMBOL_NAME (sym
), name
)
936 && SYMBOL_NAMESPACE (sym
) == namespace)
938 if (SYMBOL_CLASS (sym
) == LOC_ARG
939 || SYMBOL_CLASS (sym
) == LOC_LOCAL_ARG
940 || SYMBOL_CLASS (sym
) == LOC_REF_ARG
941 || SYMBOL_CLASS (sym
) == LOC_REGPARM
)
948 return parameter_sym
; /* Will be 0 if not found. */
951 /* Return the symbol for the function which contains a specified
952 lexical block, described by a struct block BL. */
958 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
959 bl
= BLOCK_SUPERBLOCK (bl
);
961 return BLOCK_FUNCTION (bl
);
964 /* Find the symtab associated with PC. Look through the psymtabs and read in
965 another symtab if necessary. */
969 register CORE_ADDR pc
;
971 register struct block
*b
;
972 struct blockvector
*bv
;
973 register struct symtab
*s
= NULL
;
974 register struct partial_symtab
*ps
;
975 register struct objfile
*objfile
;
977 /* Search all symtabs for one whose file contains our pc */
979 ALL_SYMTABS (objfile
, s
)
981 bv
= BLOCKVECTOR (s
);
982 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
983 if (BLOCK_START (b
) <= pc
984 && BLOCK_END (b
) > pc
)
989 ps
= find_pc_psymtab (pc
);
993 printf_filtered ("(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
994 s
= PSYMTAB_TO_SYMTAB (ps
);
999 /* Find the source file and line number for a given PC value.
1000 Return a structure containing a symtab pointer, a line number,
1001 and a pc range for the entire source line.
1002 The value's .pc field is NOT the specified pc.
1003 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1004 use the line that ends there. Otherwise, in that case, the line
1005 that begins there is used. */
1007 struct symtab_and_line
1008 find_pc_line (pc
, notcurrent
)
1013 register struct linetable
*l
;
1016 register struct linetable_entry item
;
1017 struct symtab_and_line val
;
1018 struct blockvector
*bv
;
1020 /* Info on best line seen so far, and where it starts, and its file. */
1022 struct linetable_entry best
;
1023 CORE_ADDR best_end
= 0;
1024 struct symtab
*best_symtab
= 0;
1026 /* Store here the first line number
1027 of a file which contains the line at the smallest pc after PC.
1028 If we don't find a line whose range contains PC,
1029 we will use a line one less than this,
1030 with a range from the start of that file to the first line's pc. */
1031 struct linetable_entry alt
;
1032 struct symtab
*alt_symtab
= 0;
1034 /* Info on best line seen in this file. */
1036 struct linetable_entry prev
;
1043 /* If this pc is not from the current frame,
1044 it is the address of the end of a call instruction.
1045 Quite likely that is the start of the following statement.
1046 But what we want is the statement containing the instruction.
1047 Fudge the pc to make sure we get that. */
1049 if (notcurrent
) pc
-= 1;
1051 s
= find_pc_symtab (pc
);
1061 bv
= BLOCKVECTOR (s
);
1063 /* Look at all the symtabs that share this blockvector.
1064 They all have the same apriori range, that we found was right;
1065 but they have different line tables. */
1067 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1069 /* Find the best line in this symtab. */
1076 fprintf (stderr
, "Inconsistent line number info for %s\n",
1082 item
= l
->item
[0]; /* Get first line info */
1084 /* Is this file's first line closer than the first lines of other files?
1085 If so, record this file, and its first line, as best alternate. */
1086 if (item
.pc
> pc
&& (alt
.pc
== 0 || item
.pc
< alt
.pc
))
1092 for (i
= 0; i
< len
; i
++)
1096 /* Return the last line that did not start after PC. */
1103 /* At this point, prev points at the line whose start addr is <= pc, and
1104 item points at the next line. If we ran off the end of the linetable
1105 (pc >= start of the last line), then prev == item. If pc < start of
1106 the first line, prev will not be set. */
1108 /* Is this file's best line closer than the best in the other files?
1109 If so, record this file, and its best line, as best so far. */
1111 if (prev
.line
>= 0 && prev
.pc
> best
.pc
)
1115 /* If another line is in the linetable, and its PC is closer
1116 than the best_end we currently have, take it as best_end. */
1117 if (i
< len
&& (best_end
== 0 || best_end
> item
.pc
))
1125 { /* If we didn't find any line # info, just
1134 val
.symtab
= alt_symtab
;
1135 val
.line
= alt
.line
- 1;
1136 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1142 val
.symtab
= best_symtab
;
1143 val
.line
= best
.line
;
1145 if (best_end
&& (alt
.pc
== 0 || best_end
< alt
.pc
))
1150 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1155 /* Find the PC value for a given source file and line number.
1156 Returns zero for invalid line number.
1157 The source file is specified with a struct symtab. */
1160 find_line_pc (symtab
, line
)
1161 struct symtab
*symtab
;
1164 register struct linetable
*l
;
1170 l
= LINETABLE (symtab
);
1171 ind
= find_line_common(l
, line
, &dummy
);
1172 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1175 /* Find the range of pc values in a line.
1176 Store the starting pc of the line into *STARTPTR
1177 and the ending pc (start of next line) into *ENDPTR.
1178 Returns 1 to indicate success.
1179 Returns 0 if could not find the specified line. */
1182 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1183 struct symtab
*symtab
;
1185 CORE_ADDR
*startptr
, *endptr
;
1187 register struct linetable
*l
;
1189 int exact_match
; /* did we get an exact linenumber match */
1194 l
= LINETABLE (symtab
);
1195 ind
= find_line_common (l
, thisline
, &exact_match
);
1198 *startptr
= l
->item
[ind
].pc
;
1199 /* If we have not seen an entry for the specified line,
1200 assume that means the specified line has zero bytes. */
1201 if (!exact_match
|| ind
== l
->nitems
-1)
1202 *endptr
= *startptr
;
1204 /* Perhaps the following entry is for the following line.
1205 It's worth a try. */
1206 if (ind
+1 < l
->nitems
1207 && l
->item
[ind
+1].line
== thisline
+ 1)
1208 *endptr
= l
->item
[ind
+1].pc
;
1210 *endptr
= find_line_pc (symtab
, thisline
+1);
1217 /* Given a line table and a line number, return the index into the line
1218 table for the pc of the nearest line whose number is >= the specified one.
1219 Return -1 if none is found. The value is >= 0 if it is an index.
1221 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1224 find_line_common (l
, lineno
, exact_match
)
1225 register struct linetable
*l
;
1226 register int lineno
;
1232 /* BEST is the smallest linenumber > LINENO so far seen,
1233 or 0 if none has been seen so far.
1234 BEST_INDEX identifies the item for it. */
1236 int best_index
= -1;
1245 for (i
= 0; i
< len
; i
++)
1247 register struct linetable_entry
*item
= &(l
->item
[i
]);
1249 if (item
->line
== lineno
)
1255 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1262 /* If we got here, we didn't get an exact match. */
1269 find_pc_line_pc_range (pc
, startptr
, endptr
)
1271 CORE_ADDR
*startptr
, *endptr
;
1273 struct symtab_and_line sal
;
1274 sal
= find_pc_line (pc
, 0);
1277 return sal
.symtab
!= 0;
1280 /* If P is of the form "operator[ \t]+..." where `...' is
1281 some legitimate operator text, return a pointer to the
1282 beginning of the substring of the operator text.
1283 Otherwise, return "". */
1285 operator_chars (p
, end
)
1290 if (strncmp (p
, "operator", 8))
1294 /* Don't get faked out by `operator' being part of a longer
1296 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1299 /* Allow some whitespace between `operator' and the operator symbol. */
1300 while (*p
== ' ' || *p
== '\t')
1303 /* Recognize 'operator TYPENAME'. */
1305 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1307 register char *q
= p
+1;
1308 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1333 if (p
[1] == '=' || p
[1] == p
[0])
1344 error ("`operator ()' must be specified without whitespace in `()'");
1349 error ("`operator ?:' must be specified without whitespace in `?:'");
1354 error ("`operator []' must be specified without whitespace in `[]'");
1358 error ("`operator %s' not supported", p
);
1365 /* Recursive helper function for decode_line_1.
1366 * Look for methods named NAME in type T.
1367 * Return number of matches.
1368 * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1369 * These allocations seem to define "big enough":
1370 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1371 * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1375 find_methods (t
, name
, physnames
, sym_arr
)
1379 struct symbol
**sym_arr
;
1383 struct symbol
*sym_class
;
1384 char *class_name
= type_name_no_tag (t
);
1385 /* Ignore this class if it doesn't have a name.
1386 This prevents core dumps, but is just a workaround
1387 because we might not find the function in
1388 certain cases, such as
1389 struct D {virtual int f();}
1390 struct C : D {virtual int g();}
1391 (in this case g++ 1.35.1- does not put out a name
1392 for D as such, it defines type 19 (for example) in
1393 the same stab as C, and then does a
1394 .stabs "D:T19" and a .stabs "D:t19".
1396 "break C::f" should not be looking for field f in
1398 but just for the field f in the baseclasses of C
1399 (no matter what their names).
1401 However, I don't know how to replace the code below
1402 that depends on knowing the name of D. */
1404 && (sym_class
= lookup_symbol (class_name
,
1405 (struct block
*)NULL
,
1408 (struct symtab
**)NULL
)))
1411 t
= SYMBOL_TYPE (sym_class
);
1412 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1413 method_counter
>= 0;
1417 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1419 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1420 if (!strcmp (name
, method_name
))
1421 /* Find all the fields with that name. */
1422 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1427 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1428 check_stub_method (t
, method_counter
, field_counter
);
1429 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1430 physnames
[i1
] = (char*) alloca (strlen (phys_name
) + 1);
1431 strcpy (physnames
[i1
], phys_name
);
1432 sym_arr
[i1
] = lookup_symbol (phys_name
,
1433 SYMBOL_BLOCK_VALUE (sym_class
),
1436 (struct symtab
**) NULL
);
1437 if (sym_arr
[i1
]) i1
++;
1440 fputs_filtered("(Cannot find method ", stdout
);
1441 fputs_demangled(phys_name
, stdout
, DMGL_PARAMS
);
1442 fputs_filtered(" - possibly inlined.)\n", stdout
);
1447 /* Only search baseclasses if there is no match yet,
1448 * since names in derived classes override those in baseclasses.
1452 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1453 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1454 physnames
+ i1
, sym_arr
+ i1
);
1458 /* Parse a string that specifies a line number.
1459 Pass the address of a char * variable; that variable will be
1460 advanced over the characters actually parsed.
1464 LINENUM -- that line number in current file. PC returned is 0.
1465 FILE:LINENUM -- that line in that file. PC returned is 0.
1466 FUNCTION -- line number of openbrace of that function.
1467 PC returned is the start of the function.
1468 VARIABLE -- line number of definition of that variable.
1470 FILE:FUNCTION -- likewise, but prefer functions in that file.
1471 *EXPR -- line in which address EXPR appears.
1473 FUNCTION may be an undebuggable function found in minimal symbol table.
1475 If the argument FUNFIRSTLINE is nonzero, we want the first line
1476 of real code inside a function when a function is specified.
1478 DEFAULT_SYMTAB specifies the file to use if none is specified.
1479 It defaults to current_source_symtab.
1480 DEFAULT_LINE specifies the line number to use for relative
1481 line numbers (that start with signs). Defaults to current_source_line.
1483 Note that it is possible to return zero for the symtab
1484 if no file is validly specified. Callers must check that.
1485 Also, the line number returned may be invalid. */
1487 struct symtabs_and_lines
1488 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1491 struct symtab
*default_symtab
;
1494 struct symtabs_and_lines values
;
1495 #ifdef HPPA_COMPILER_BUG
1496 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1497 when optimizing this file with target i960-vxworks. I haven't
1498 been able to construct a simple test case. The problem is that
1499 in the second call to SKIP_PROLOGUE below, the compiler somehow
1500 does not realize that the statement val = find_pc_line (...) will
1501 change the values of the fields of val. It extracts the elements
1502 into registers at the top of the block, and does not update the
1503 registers after the call to find_pc_line. You can check this by
1504 inserting a printf at the end of find_pc_line to show what values
1505 it is returning for val.pc and val.end and another printf after
1506 the call to see what values the function actually got (remember,
1507 this is compiling with cc -O, with this patch removed). You can
1508 also examine the assembly listing: search for the second call to
1509 skip_prologue; the LDO statement before the next call to
1510 find_pc_line loads the address of the structure which
1511 find_pc_line will return; if there is a LDW just before the LDO,
1512 which fetches an element of the structure, then the compiler
1515 Setting val to volatile avoids the problem. We must undef
1516 volatile, because the HPPA native compiler does not define
1517 __STDC__, although it does understand volatile, and so volatile
1518 will have been defined away in defs.h. */
1520 volatile struct symtab_and_line val
;
1521 #define volatile /*nothing*/
1523 struct symtab_and_line val
;
1525 register char *p
, *p1
;
1527 register struct symtab
*s
;
1529 register struct symbol
*sym
;
1530 /* The symtab that SYM was found in. */
1531 struct symtab
*sym_symtab
;
1533 register CORE_ADDR pc
;
1534 register struct minimal_symbol
*msymbol
;
1536 struct symbol
*sym_class
;
1539 struct symbol
**sym_arr
;
1542 char *saved_arg
= *argptr
;
1543 extern char *gdb_completer_quote_characters
;
1545 /* Defaults have defaults. */
1547 if (default_symtab
== 0)
1549 default_symtab
= current_source_symtab
;
1550 default_line
= current_source_line
;
1553 /* See if arg is *PC */
1555 if (**argptr
== '*')
1557 if (**argptr
== '*')
1561 pc
= parse_and_eval_address_1 (argptr
);
1562 values
.sals
= (struct symtab_and_line
*)
1563 xmalloc (sizeof (struct symtab_and_line
));
1565 values
.sals
[0] = find_pc_line (pc
, 0);
1566 values
.sals
[0].pc
= pc
;
1570 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1573 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1575 for (p
= *argptr
; *p
; p
++)
1577 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1580 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1582 if ((p
[0] == ':') && !is_quoted
)
1588 /* Extract the class name. */
1590 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1591 copy
= (char *) alloca (p
- *argptr
+ 1);
1592 memcpy (copy
, *argptr
, p
- *argptr
);
1593 copy
[p
- *argptr
] = 0;
1595 /* Discard the class name from the arg. */
1597 while (*p
== ' ' || *p
== '\t') p
++;
1600 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1601 (struct symtab
**)NULL
);
1604 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1605 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1607 /* Arg token is not digits => try it as a function name
1608 Find the next token (everything up to end or next whitespace). */
1610 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1611 q
= operator_chars (*argptr
, &q1
);
1616 char *tmp
= alloca (q1
- q
+ 1);
1617 memcpy (tmp
, q
, q1
- q
);
1619 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1622 warning ("no mangling for \"%s\"", tmp
);
1623 cplusplus_hint (saved_arg
);
1624 return_to_top_level ();
1626 copy
= (char*) alloca (3 + strlen(opname
));
1627 sprintf (copy
, "__%s", opname
);
1632 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1633 memcpy (copy
, *argptr
, p
- *argptr
);
1634 copy
[p
- *argptr
] = '\0';
1637 /* no line number may be specified */
1638 while (*p
== ' ' || *p
== '\t') p
++;
1642 i1
= 0; /* counter for the symbol array */
1643 t
= SYMBOL_TYPE (sym_class
);
1644 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1645 physnames
= (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(char*));
1647 if (destructor_name_p (copy
, t
))
1649 /* destructors are a special case. */
1650 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1651 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1652 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1653 physnames
[i1
] = (char *)alloca (strlen (phys_name
) + 1);
1654 strcpy (physnames
[i1
], phys_name
);
1656 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1657 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1658 if (sym_arr
[i1
]) i1
++;
1661 i1
= find_methods (t
, copy
, physnames
, sym_arr
);
1664 /* There is exactly one field with that name. */
1667 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1669 /* Arg is the name of a function */
1670 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1673 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1675 values
.sals
[0] = find_pc_line (pc
, 0);
1676 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1686 /* There is more than one field with that name
1687 (overloaded). Ask the user which one to use. */
1688 return decode_line_2 (sym_arr
, i1
, funfirstline
);
1694 if (OPNAME_PREFIX_P (copy
))
1696 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1697 strcpy (tmp
, "operator ");
1698 strcat (tmp
, copy
+3);
1703 warning ("the class `%s' does not have destructor defined",
1706 warning ("the class %s does not have any method named %s",
1707 sym_class
->name
, tmp
);
1708 cplusplus_hint (saved_arg
);
1709 return_to_top_level ();
1714 /* The quotes are important if copy is empty. */
1715 warning ("can't find class, struct, or union named \"%s\"",
1717 cplusplus_hint (saved_arg
);
1718 return_to_top_level ();
1724 /* Extract the file name. */
1726 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1727 copy
= (char *) alloca (p
- *argptr
+ 1);
1728 memcpy (copy
, *argptr
, p
- *argptr
);
1729 copy
[p
- *argptr
] = 0;
1731 /* Find that file's data. */
1732 s
= lookup_symtab (copy
);
1735 if (!have_full_symbols () && !have_partial_symbols ())
1736 error (no_symtab_msg
);
1737 error ("No source file named %s.", copy
);
1740 /* Discard the file name from the arg. */
1742 while (*p
== ' ' || *p
== '\t') p
++;
1746 /* S is specified file's symtab, or 0 if no file specified.
1747 arg no longer contains the file name. */
1749 /* Check whether arg is all digits (and sign) */
1752 if (*p
== '-' || *p
== '+') p
++;
1753 while (*p
>= '0' && *p
<= '9')
1756 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1758 /* We found a token consisting of all digits -- at least one digit. */
1759 enum sign
{none
, plus
, minus
} sign
= none
;
1761 /* This is where we need to make sure that we have good defaults.
1762 We must guarantee that this section of code is never executed
1763 when we are called with just a function name, since
1764 select_source_symtab calls us with such an argument */
1766 if (s
== 0 && default_symtab
== 0)
1768 select_source_symtab (0);
1769 default_symtab
= current_source_symtab
;
1770 default_line
= current_source_line
;
1773 if (**argptr
== '+')
1774 sign
= plus
, (*argptr
)++;
1775 else if (**argptr
== '-')
1776 sign
= minus
, (*argptr
)++;
1777 val
.line
= atoi (*argptr
);
1784 val
.line
= default_line
+ val
.line
;
1790 val
.line
= default_line
- val
.line
;
1795 break; /* No need to adjust val.line. */
1798 while (*p
== ' ' || *p
== '\t') p
++;
1804 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1805 values
.sals
[0] = val
;
1810 /* Arg token is not digits => try it as a variable name
1811 Find the next token (everything up to end or next whitespace). */
1813 p
= skip_quoted (*argptr
);
1814 copy
= (char *) alloca (p
- *argptr
+ 1);
1815 memcpy (copy
, *argptr
, p
- *argptr
);
1816 copy
[p
- *argptr
] = '\0';
1817 if ((copy
[0] == copy
[p
- *argptr
- 1])
1818 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1821 copy
[p
- *argptr
- 1] = '\0';
1823 if ((temp
= expensive_mangler (copy
)) != NULL
)
1828 while (*p
== ' ' || *p
== '\t') p
++;
1831 /* Look up that token as a variable.
1832 If file specified, use that file's per-file block to start with. */
1834 sym
= lookup_symbol (copy
,
1835 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1836 : get_selected_block ()),
1837 VAR_NAMESPACE
, 0, &sym_symtab
);
1841 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1843 /* Arg is the name of a function */
1844 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1847 val
= find_pc_line (pc
, 0);
1848 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1849 /* Convex: no need to suppress code on first line, if any */
1852 /* If SKIP_PROLOGUE left us in mid-line, and the next line is still
1853 part of the same function:
1854 advance to next line,
1855 recalculate its line number (might not be N+1). */
1856 if (val
.pc
!= pc
&& val
.end
&&
1857 lookup_minimal_symbol_by_pc (pc
) == lookup_minimal_symbol_by_pc (val
.end
)) {
1858 pc
= val
.end
; /* First pc of next line */
1859 val
= find_pc_line (pc
, 0);
1863 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1864 values
.sals
[0] = val
;
1867 /* I think this is always the same as the line that
1868 we calculate above, but the general principle is
1869 "trust the symbols more than stuff like
1871 if (SYMBOL_LINE (sym
) != 0)
1872 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1876 else if (SYMBOL_LINE (sym
) != 0)
1878 /* We know its line number. */
1879 values
.sals
= (struct symtab_and_line
*)
1880 xmalloc (sizeof (struct symtab_and_line
));
1882 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
1883 values
.sals
[0].symtab
= sym_symtab
;
1884 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1888 /* This can happen if it is compiled with a compiler which doesn't
1889 put out line numbers for variables. */
1890 error ("Line number not known for symbol \"%s\"", copy
);
1893 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
1894 if (msymbol
!= NULL
)
1898 val
.pc
= msymbol
-> address
+ FUNCTION_START_OFFSET
;
1900 SKIP_PROLOGUE (val
.pc
);
1901 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1902 values
.sals
[0] = val
;
1907 if (!have_full_symbols () &&
1908 !have_partial_symbols () && !have_minimal_symbols ())
1909 error (no_symtab_msg
);
1911 error ("Function \"%s\" not defined.", copy
);
1912 return values
; /* for lint */
1915 struct symtabs_and_lines
1916 decode_line_spec (string
, funfirstline
)
1920 struct symtabs_and_lines sals
;
1922 error ("Empty line specification.");
1923 sals
= decode_line_1 (&string
, funfirstline
,
1924 current_source_symtab
, current_source_line
);
1926 error ("Junk at end of line specification: %s", string
);
1930 /* Given a list of NELTS symbols in sym_arr (with corresponding
1931 mangled names in physnames), return a list of lines to operate on
1932 (ask user if necessary). */
1933 static struct symtabs_and_lines
1934 decode_line_2 (sym_arr
, nelts
, funfirstline
)
1935 struct symbol
*sym_arr
[];
1939 struct symtabs_and_lines values
, return_values
;
1940 register CORE_ADDR pc
;
1946 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
1947 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
1950 printf("[0] cancel\n[1] all\n");
1953 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
1955 /* Arg is the name of a function */
1956 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
1957 + FUNCTION_START_OFFSET
;
1960 values
.sals
[i
] = find_pc_line (pc
, 0);
1961 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
1962 values
.sals
[i
].end
: pc
;
1963 demangled
= cplus_demangle (SYMBOL_NAME (sym_arr
[i
]),
1964 DMGL_PARAMS
| DMGL_ANSI
);
1965 printf("[%d] %s at %s:%d\n", (i
+2),
1966 demangled
? demangled
: SYMBOL_NAME (sym_arr
[i
]),
1967 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
1968 if (demangled
!= NULL
)
1973 else printf ("?HERE\n");
1977 if ((prompt
= getenv ("PS2")) == NULL
)
1981 printf("%s ",prompt
);
1984 args
= command_line_input ((char *) NULL
, 0);
1987 error_no_arg ("one or more choice numbers");
1995 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
1996 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
1997 error ("Arguments must be choice numbers.");
2002 error ("cancelled");
2005 memcpy (return_values
.sals
, values
.sals
,
2006 (nelts
* sizeof(struct symtab_and_line
)));
2007 return_values
.nelts
= nelts
;
2008 return return_values
;
2011 if (num
> nelts
+ 2)
2013 printf ("No choice number %d.\n", num
);
2018 if (values
.sals
[num
].pc
)
2020 return_values
.sals
[i
++] = values
.sals
[num
];
2021 values
.sals
[num
].pc
= 0;
2025 printf ("duplicate request for %d ignored.\n", num
);
2030 while (*args
== ' ' || *args
== '\t') args
++;
2032 return_values
.nelts
= i
;
2033 return return_values
;
2037 /* Slave routine for sources_info. Force line breaks at ,'s.
2038 NAME is the name to print and *FIRST is nonzero if this is the first
2039 name printed. Set *FIRST to zero. */
2041 output_source_filename (name
, first
)
2045 /* Table of files printed so far. Since a single source file can
2046 result in several partial symbol tables, we need to avoid printing
2047 it more than once. Note: if some of the psymtabs are read in and
2048 some are not, it gets printed both under "Source files for which
2049 symbols have been read" and "Source files for which symbols will
2050 be read in on demand". I consider this a reasonable way to deal
2051 with the situation. I'm not sure whether this can also happen for
2052 symtabs; it doesn't hurt to check. */
2053 static char **tab
= NULL
;
2054 /* Allocated size of tab in elements.
2055 Start with one 256-byte block (when using GNU malloc.c).
2056 24 is the malloc overhead when range checking is in effect. */
2057 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2058 /* Current size of tab in elements. */
2059 static int tab_cur_size
;
2066 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2070 /* Is NAME in tab? */
2071 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2072 if (strcmp (*p
, name
) == 0)
2073 /* Yes; don't print it again. */
2075 /* No; add it to tab. */
2076 if (tab_cur_size
== tab_alloc_size
)
2078 tab_alloc_size
*= 2;
2079 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2081 tab
[tab_cur_size
++] = name
;
2089 printf_filtered (", ");
2093 fputs_filtered (name
, stdout
);
2097 sources_info (ignore
, from_tty
)
2101 register struct symtab
*s
;
2102 register struct partial_symtab
*ps
;
2103 register struct objfile
*objfile
;
2106 if (!have_full_symbols () && !have_partial_symbols ())
2108 error (no_symtab_msg
);
2111 printf_filtered ("Source files for which symbols have been read in:\n\n");
2114 ALL_SYMTABS (objfile
, s
)
2116 output_source_filename (s
-> filename
, &first
);
2118 printf_filtered ("\n\n");
2120 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2123 ALL_PSYMTABS (objfile
, ps
)
2127 output_source_filename (ps
-> filename
, &first
);
2130 printf_filtered ("\n");
2137 char *demangled
= cplus_demangle (name
, DMGL_ANSI
);
2138 if (demangled
!= NULL
)
2140 int cond
= re_exec (demangled
);
2144 return (re_exec (name
));
2146 #define NAME_MATCH(NAME) name_match(NAME)
2148 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2149 If CLASS is zero, list all symbols except functions, type names, and
2151 If CLASS is 1, list only functions.
2152 If CLASS is 2, list only type names.
2153 If CLASS is 3, list only method names.
2155 BPT is non-zero if we should set a breakpoint at the functions
2159 list_symbols (regexp
, class, bpt
)
2164 register struct symtab
*s
;
2165 register struct partial_symtab
*ps
;
2166 register struct blockvector
*bv
;
2167 struct blockvector
*prev_bv
= 0;
2168 register struct block
*b
;
2170 register struct symbol
*sym
;
2171 struct partial_symbol
*psym
;
2172 struct objfile
*objfile
;
2173 struct minimal_symbol
*msymbol
;
2175 static char *classnames
[]
2176 = {"variable", "function", "type", "method"};
2177 int found_in_file
= 0;
2179 static enum minimal_symbol_type types
[]
2180 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2181 static enum minimal_symbol_type types2
[]
2182 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2183 enum minimal_symbol_type ourtype
= types
[class];
2184 enum minimal_symbol_type ourtype2
= types2
[class];
2188 /* Make sure spacing is right for C++ operators.
2189 This is just a courtesy to make the matching less sensitive
2190 to how many spaces the user leaves between 'operator'
2191 and <TYPENAME> or <OPERATOR>. */
2193 char *opname
= operator_chars (regexp
, &opend
);
2196 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2197 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2199 /* There should 1 space between 'operator' and 'TYPENAME'. */
2200 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2205 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2206 if (opname
[-1] == ' ')
2209 /* If wrong number of spaces, fix it. */
2212 char *tmp
= (char*) alloca(opend
-opname
+10);
2213 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2218 if (0 != (val
= re_comp (regexp
)))
2219 error ("Invalid regexp (%s): %s", val
, regexp
);
2222 /* Search through the partial symtabs *first* for all symbols
2223 matching the regexp. That way we don't have to reproduce all of
2224 the machinery below. */
2226 ALL_PSYMTABS (objfile
, ps
)
2228 struct partial_symbol
*bound
, *gbound
, *sbound
;
2231 if (ps
->readin
) continue;
2233 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2234 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2237 /* Go through all of the symbols stored in a partial
2238 symtab in one loop. */
2239 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2244 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2246 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2257 /* If it would match (logic taken from loop below)
2258 load the file and go on to the next one */
2259 if ((regexp
== 0 || NAME_MATCH (SYMBOL_NAME (psym
)))
2260 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2261 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2262 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2263 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2264 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2266 PSYMTAB_TO_SYMTAB(ps
);
2274 /* Here, we search through the minimal symbol tables for functions that
2275 match, and call find_pc_symtab on them to force their symbols to
2276 be read. The symbol will then be found during the scan of symtabs
2277 below. If find_pc_symtab fails, set found_misc so that we will
2278 rescan to print any matching symbols without debug info. */
2282 ALL_MSYMBOLS (objfile
, msymbol
)
2284 if (msymbol
-> type
== ourtype
|| msymbol
-> type
== ourtype2
)
2286 if (regexp
== 0 || NAME_MATCH (msymbol
-> name
))
2288 if (0 == find_pc_symtab (msymbol
-> address
))
2297 /* Printout here so as to get after the "Reading in symbols"
2298 messages which will be generated above. */
2300 printf_filtered (regexp
2301 ? "All %ss matching regular expression \"%s\":\n"
2302 : "All defined %ss:\n",
2306 ALL_SYMTABS (objfile
, s
)
2309 bv
= BLOCKVECTOR (s
);
2310 /* Often many files share a blockvector.
2311 Scan each blockvector only once so that
2312 we don't get every symbol many times.
2313 It happens that the first symtab in the list
2314 for any given blockvector is the main file. */
2316 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2318 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2319 /* Skip the sort if this block is always sorted. */
2320 if (!BLOCK_SHOULD_SORT (b
))
2321 sort_block_syms (b
);
2322 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2325 sym
= BLOCK_SYM (b
, j
);
2326 if ((regexp
== 0 || NAME_MATCH (SYMBOL_NAME (sym
)))
2327 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2328 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2329 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2330 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2331 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2332 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2336 /* Set a breakpoint here, if it's a function */
2338 break_command (SYMBOL_NAME(sym
), 0);
2340 else if (!found_in_file
)
2342 fputs_filtered ("\nFile ", stdout
);
2343 fputs_filtered (s
->filename
, stdout
);
2344 fputs_filtered (":\n", stdout
);
2348 if (class != 2 && i
== STATIC_BLOCK
)
2349 printf_filtered ("static ");
2351 /* Typedef that is not a C++ class */
2353 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2354 typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2355 /* variable, func, or typedef-that-is-c++-class */
2356 else if (class < 2 ||
2358 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2360 type_print (SYMBOL_TYPE (sym
),
2361 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2362 ? "" : SYMBOL_NAME (sym
)),
2365 printf_filtered (";\n");
2370 /* FIXME, why is this zapped out? */
2372 type_print_base (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0, 0);
2373 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
), stdout
, 0);
2374 sprintf (buf
, " %s::", type_name_no_tag (t
));
2375 type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
), buf
, name
, stdout
);
2384 /* If there are no eyes, avoid all contact. I mean, if there are
2385 no debug symbols, then print directly from the msymbol_vector. */
2387 if (found_misc
|| class != 1)
2390 ALL_MSYMBOLS (objfile
, msymbol
)
2392 if (msymbol
-> type
== ourtype
|| msymbol
-> type
== ourtype2
)
2394 if (regexp
== 0 || NAME_MATCH (msymbol
-> name
))
2396 /* Functions: Look up by address. */
2398 (0 == find_pc_symtab (msymbol
-> address
)))
2400 /* Variables/Absolutes: Look up by name */
2401 if (lookup_symbol (msymbol
-> name
,
2402 (struct block
*) 0, VAR_NAMESPACE
, 0,
2403 (struct symtab
**) 0) == NULL
)
2407 printf_filtered ("\nNon-debugging symbols:\n");
2410 printf_filtered (" %08x %s\n",
2422 variables_info (regexp
, from_tty
)
2426 list_symbols (regexp
, 0, 0);
2430 functions_info (regexp
, from_tty
)
2434 list_symbols (regexp
, 1, 0);
2438 types_info (regexp
, from_tty
)
2442 list_symbols (regexp
, 2, 0);
2446 /* Tiemann says: "info methods was never implemented." */
2448 methods_info (regexp
)
2451 list_symbols (regexp
, 3, 0);
2455 /* Breakpoint all functions matching regular expression. */
2457 rbreak_command (regexp
, from_tty
)
2461 list_symbols (regexp
, 1, 1);
2465 /* Return Nonzero if block a is lexically nested within block b,
2466 or if a and b have the same pc range.
2467 Return zero otherwise. */
2470 struct block
*a
, *b
;
2474 return BLOCK_START (a
) >= BLOCK_START (b
)
2475 && BLOCK_END (a
) <= BLOCK_END (b
);
2479 /* Helper routine for make_symbol_completion_list. */
2481 static int return_val_size
;
2482 static int return_val_index
;
2483 static char **return_val
;
2485 /* Test to see if the symbol specified by SYMNAME (or it's demangled
2486 equivalent) matches TEXT in the first TEXT_LEN characters. If so,
2487 add it to the current completion list. */
2490 completion_list_add_symbol (symname
, text
, text_len
)
2499 /* clip symbols that cannot match */
2501 if (!cplus_match (symname
, text
, text_len
)) {
2505 /* matches mangled, may match unmangled. now clip any symbol names
2506 that we've already considered. (This is a time optimization) */
2508 for (i
= 0; i
< return_val_index
; ++i
) {
2509 if (strcmp (symname
, return_val
[i
]) == 0) {
2514 /* See if SYMNAME is a C++ mangled name, and if so, use the
2515 demangled name instead, including any parameters. */
2517 if ((demangled
= cplus_demangle (symname
, DMGL_PARAMS
| DMGL_ANSI
)) != NULL
)
2519 if (strncmp (demangled
, text
, text_len
) != 0) {
2521 } /* demangled, but didn't match so clip it */
2523 symname
= demangled
;
2525 symname
= savestring (symname
, strlen (symname
));
2528 /* If we have a match for a completion, then add SYMNAME to the current
2529 list of matches. Note that the name is in freshly malloc'd space;
2530 either from cplus_demangle or from savestring above. */
2532 if (return_val_index
+ 3 > return_val_size
)
2534 newsize
= (return_val_size
*= 2) * sizeof (char *);
2535 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2537 return_val
[return_val_index
++] = symname
;
2538 return_val
[return_val_index
] = NULL
;
2543 /* Return a NULL terminated array of all symbols (regardless of class) which
2544 begin by matching TEXT. If the answer is no symbols, then the return value
2545 is an array which contains only a NULL pointer.
2547 Problem: All of the symbols have to be copied because readline frees them.
2548 I'm not going to worry about this; hopefully there won't be that many. */
2551 make_symbol_completion_list (text
)
2554 register struct symbol
*sym
;
2555 register struct symtab
*s
;
2556 register struct partial_symtab
*ps
;
2557 register struct minimal_symbol
*msymbol
;
2558 register struct objfile
*objfile
;
2559 register struct block
*b
, *surrounding_static_block
= 0;
2562 struct partial_symbol
*psym
;
2564 text_len
= strlen (text
);
2565 return_val_size
= 100;
2566 return_val_index
= 0;
2567 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2568 return_val
[0] = NULL
;
2570 /* Look through the partial symtabs for all symbols which begin
2571 by matching TEXT. Add each one that you find to the list. */
2573 ALL_PSYMTABS (objfile
, ps
)
2575 /* If the psymtab's been read in we'll get it when we search
2576 through the blockvector. */
2577 if (ps
->readin
) continue;
2579 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2580 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2581 + ps
->n_global_syms
);
2584 /* If interrupted, then quit. */
2586 completion_list_add_symbol (SYMBOL_NAME (psym
), text
, text_len
);
2589 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2590 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2591 + ps
->n_static_syms
);
2595 completion_list_add_symbol (SYMBOL_NAME (psym
), text
, text_len
);
2599 /* At this point scan through the misc symbol vectors and add each
2600 symbol you find to the list. Eventually we want to ignore
2601 anything that isn't a text symbol (everything else will be
2602 handled by the psymtab code above). */
2604 ALL_MSYMBOLS (objfile
, msymbol
)
2607 completion_list_add_symbol (msymbol
-> name
, text
, text_len
);
2610 /* Search upwards from currently selected frame (so that we can
2611 complete on local vars. */
2613 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2615 if (!BLOCK_SUPERBLOCK (b
))
2617 surrounding_static_block
= b
; /* For elmin of dups */
2620 /* Also catch fields of types defined in this places which match our
2621 text string. Only complete on types visible from current context. */
2623 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2625 sym
= BLOCK_SYM (b
, i
);
2626 completion_list_add_symbol (SYMBOL_NAME (sym
), text
, text_len
);
2627 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2629 struct type
*t
= SYMBOL_TYPE (sym
);
2630 enum type_code c
= TYPE_CODE (t
);
2632 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2634 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2636 if (TYPE_FIELD_NAME (t
, j
))
2638 completion_list_add_symbol (TYPE_FIELD_NAME (t
, j
),
2647 /* Go through the symtabs and check the externs and statics for
2648 symbols which match. */
2650 ALL_SYMTABS (objfile
, s
)
2653 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2654 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2656 sym
= BLOCK_SYM (b
, i
);
2657 completion_list_add_symbol (SYMBOL_NAME (sym
), text
, text_len
);
2661 ALL_SYMTABS (objfile
, s
)
2664 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2665 /* Don't do this block twice. */
2666 if (b
== surrounding_static_block
) continue;
2667 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2669 sym
= BLOCK_SYM (b
, i
);
2670 completion_list_add_symbol (SYMBOL_NAME (sym
), text
, text_len
);
2674 return (return_val
);
2678 /* Find a mangled symbol that corresponds to LOOKFOR using brute force.
2679 Basically we go munging through available symbols, demangling each one,
2680 looking for a match on the demangled result. */
2683 expensive_mangler (lookfor
)
2684 const char *lookfor
;
2686 register struct symbol
*sym
;
2687 register struct symtab
*s
;
2688 register struct partial_symtab
*ps
;
2689 register struct minimal_symbol
*msymbol
;
2690 register struct objfile
*objfile
;
2691 register struct block
*b
, *surrounding_static_block
= 0;
2693 struct partial_symbol
*psym
;
2696 /* Look through the partial symtabs for a symbol that matches */
2698 ALL_PSYMTABS (objfile
, ps
)
2700 /* If the psymtab's been read in we'll get it when we search
2701 through the blockvector. */
2702 if (ps
->readin
) continue;
2704 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2705 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2706 + ps
->n_global_syms
);
2709 QUIT
; /* If interrupted, then quit. */
2710 demangled
= demangle_and_match (SYMBOL_NAME (psym
), lookfor
,
2711 DMGL_PARAMS
| DMGL_ANSI
);
2712 if (demangled
!= NULL
)
2715 return (SYMBOL_NAME (psym
));
2719 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2720 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2721 + ps
->n_static_syms
);
2725 demangled
= demangle_and_match (SYMBOL_NAME (psym
), lookfor
,
2726 DMGL_PARAMS
| DMGL_ANSI
);
2727 if (demangled
!= NULL
)
2730 return (SYMBOL_NAME (psym
));
2735 /* Scan through the misc symbol vectors looking for a match. */
2737 ALL_MSYMBOLS (objfile
, msymbol
)
2740 demangled
= demangle_and_match (msymbol
-> name
, lookfor
,
2741 DMGL_PARAMS
| DMGL_ANSI
);
2742 if (demangled
!= NULL
)
2745 return (msymbol
-> name
);
2749 /* Search upwards from currently selected frame looking for a match */
2751 for (b
= get_selected_block (); b
; b
= BLOCK_SUPERBLOCK (b
))
2753 if (!BLOCK_SUPERBLOCK (b
))
2754 surrounding_static_block
= b
; /* For elmin of dups */
2756 /* Also catch fields of types defined in this places which
2757 match our text string. Only complete on types visible
2758 from current context. */
2759 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2761 sym
= BLOCK_SYM (b
, i
);
2762 demangled
= demangle_and_match (SYMBOL_NAME (sym
), lookfor
,
2763 DMGL_PARAMS
| DMGL_ANSI
);
2764 if (demangled
!= NULL
)
2767 return (SYMBOL_NAME (sym
));
2769 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2771 struct type
*t
= SYMBOL_TYPE (sym
);
2772 enum type_code c
= TYPE_CODE (t
);
2774 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2776 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2778 if (TYPE_FIELD_NAME (t
, j
))
2781 demangle_and_match (TYPE_FIELD_NAME (t
, j
),
2783 DMGL_PARAMS
| DMGL_ANSI
);
2784 if (demangled
!= NULL
)
2787 return (TYPE_FIELD_NAME (t
, j
));
2796 /* Go through the symtabs and check the externs and statics for
2797 symbols which match. */
2799 ALL_SYMTABS (objfile
, s
)
2802 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2803 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2805 sym
= BLOCK_SYM (b
, i
);
2806 demangled
= demangle_and_match (SYMBOL_NAME (sym
), lookfor
,
2807 DMGL_PARAMS
| DMGL_ANSI
);
2808 if (demangled
!= NULL
)
2811 return (SYMBOL_NAME (sym
));
2816 ALL_SYMTABS (objfile
, s
)
2819 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2820 /* Don't do this block twice. */
2821 if (b
== surrounding_static_block
) continue;
2822 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2824 sym
= BLOCK_SYM (b
, i
);
2825 demangled
= demangle_and_match (SYMBOL_NAME (sym
), lookfor
,
2826 DMGL_PARAMS
| DMGL_ANSI
);
2827 if (demangled
!= NULL
)
2830 return (SYMBOL_NAME (sym
));
2840 /* Add the type of the symbol sym to the type of the current
2841 function whose block we are in (assumed). The type of
2842 this current function is contained in *TYPE.
2844 This basically works as follows: When we find a function
2845 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2846 a pointer to its type in the global in_function_type. Every
2847 time we come across a parameter symbol ('p' in its name), then
2848 this procedure adds the name and type of that parameter
2849 to the function type pointed to by *TYPE. (Which should correspond
2850 to in_function_type if it was called correctly).
2852 Note that since we are modifying a type, the result of
2853 lookup_function_type() should be memcpy()ed before calling
2854 this. When not in strict typing mode, the expression
2855 evaluator can choose to ignore this.
2857 Assumption: All of a function's parameter symbols will
2858 appear before another function symbol is found. The parameters
2859 appear in the same order in the argument list as they do in the
2863 add_param_to_type (type
,sym
)
2867 int num
= ++(TYPE_NFIELDS(*type
));
2869 if(TYPE_NFIELDS(*type
)-1)
2870 TYPE_FIELDS(*type
) = (struct field
*)
2871 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2872 num
*sizeof(struct field
));
2874 TYPE_FIELDS(*type
) = (struct field
*)
2875 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2877 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2878 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2879 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2880 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2885 _initialize_symtab ()
2887 add_info ("variables", variables_info
,
2888 "All global and static variable names, or those matching REGEXP.");
2889 add_info ("functions", functions_info
,
2890 "All function names, or those matching REGEXP.");
2892 /* FIXME: This command has at least the following problems:
2893 1. It prints builtin types (in a very strange and confusing fashion).
2894 2. It doesn't print right, e.g. with
2895 typedef struct foo *FOO
2896 type_print prints "FOO" when we want to make it (in this situation)
2897 print "struct foo *".
2898 I also think "ptype" or "whatis" is more likely to be useful (but if
2899 there is much disagreement "info types" can be fixed). */
2900 add_info ("types", types_info
,
2901 "All type names, or those matching REGEXP.");
2904 add_info ("methods", methods_info
,
2905 "All method names, or those matching REGEXP::REGEXP.\n\
2906 If the class qualifier is omitted, it is assumed to be the current scope.\n\
2907 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
2910 add_info ("sources", sources_info
,
2911 "Source files in the program.");
2913 add_com ("rbreak", no_class
, rbreak_command
,
2914 "Set a breakpoint for all functions matching REGEXP.");
2916 /* Initialize the one built-in type that isn't language dependent... */
2917 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
2918 "<unknown type>", (struct objfile
*) NULL
);