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 find_methods
PARAMS ((struct type
*, char *, struct symbol
**));
52 completion_list_add_name
PARAMS ((char *, char *, int));
54 static struct symtabs_and_lines
55 decode_line_2
PARAMS ((struct symbol
*[], int, int));
58 rbreak_command
PARAMS ((char *, int));
61 types_info
PARAMS ((char *, int));
64 functions_info
PARAMS ((char *, int));
67 variables_info
PARAMS ((char *, int));
70 sources_info
PARAMS ((char *, int));
73 list_symbols
PARAMS ((char *, int, int));
76 output_source_filename
PARAMS ((char *, int *));
79 operator_chars
PARAMS ((char *, char **));
82 find_line_common
PARAMS ((struct linetable
*, int, int *));
84 static struct partial_symbol
*
85 lookup_partial_symbol
PARAMS ((struct partial_symtab
*, const char *,
86 int, enum namespace));
88 static struct symtab
*
89 lookup_symtab_1
PARAMS ((char *));
93 /* The single non-language-specific builtin type */
94 struct type
*builtin_type_error
;
96 /* Block in which the most recently searched-for symbol was found.
97 Might be better to make this a parameter to lookup_symbol and
100 const struct block
*block_found
;
102 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
104 /* While the C++ support is still in flux, issue a possibly helpful hint on
105 using the new command completion feature on single quoted demangled C++
106 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
109 cplusplus_hint (name
)
112 printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
113 printf ("(Note leading single quote.)\n");
116 /* Check for a symtab of a specific name; first in symtabs, then in
117 psymtabs. *If* there is no '/' in the name, a match after a '/'
118 in the symtab filename will also work. */
120 static struct symtab
*
121 lookup_symtab_1 (name
)
124 register struct symtab
*s
;
125 register struct partial_symtab
*ps
;
126 register char *slash
;
127 register struct objfile
*objfile
;
131 /* First, search for an exact match */
133 ALL_SYMTABS (objfile
, s
)
134 if (STREQ (name
, s
->filename
))
137 slash
= strchr (name
, '/');
139 /* Now, search for a matching tail (only if name doesn't have any dirs) */
142 ALL_SYMTABS (objfile
, s
)
144 char *p
= s
-> filename
;
145 char *tail
= strrchr (p
, '/');
154 /* Same search rules as above apply here, but now we look thru the
157 ALL_PSYMTABS (objfile
, ps
)
158 if (STREQ (name
, ps
-> filename
))
162 ALL_PSYMTABS (objfile
, ps
)
164 char *p
= ps
-> filename
;
165 char *tail
= strrchr (p
, '/');
179 error ("Internal: readin %s pst for `%s' found when no symtab found.",
180 ps
-> filename
, name
);
182 s
= PSYMTAB_TO_SYMTAB (ps
);
187 /* At this point, we have located the psymtab for this file, but
188 the conversion to a symtab has failed. This usually happens
189 when we are looking up an include file. In this case,
190 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
191 been created. So, we need to run through the symtabs again in
192 order to find the file.
193 XXX - This is a crock, and should be fixed inside of the the
194 symbol parsing routines. */
198 /* Lookup the symbol table of a source file named NAME. Try a couple
199 of variations if the first lookup doesn't work. */
205 register struct symtab
*s
;
208 s
= lookup_symtab_1 (name
);
211 /* If name not found as specified, see if adding ".c" helps. */
213 copy
= (char *) alloca (strlen (name
) + 3);
216 s
= lookup_symtab_1 (copy
);
219 /* We didn't find anything; die. */
223 /* Lookup the partial symbol table of a source file named NAME. This
224 only returns true on an exact match (ie. this semantics are
225 different from lookup_symtab. */
227 struct partial_symtab
*
228 lookup_partial_symtab (name
)
231 register struct partial_symtab
*pst
;
232 register struct objfile
*objfile
;
234 ALL_PSYMTABS (objfile
, pst
)
236 if (STREQ (name
, pst
-> filename
))
244 /* Demangle a GDB method stub type. */
246 gdb_mangle_name (type
, i
, j
)
250 int mangled_name_len
;
252 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
253 struct fn_field
*method
= &f
[j
];
254 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
255 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
256 char *newname
= type_name_no_tag (type
);
257 int is_constructor
= STREQ (field_name
, newname
);
258 int is_destructor
= is_constructor
&& physname
[0] == '_'
259 && physname
[1] == CPLUS_MARKER
&& physname
[2] == '_';
260 /* Need a new type prefix. */
261 char *const_prefix
= method
->is_const
? "C" : "";
262 char *volatile_prefix
= method
->is_volatile
? "V" : "";
264 #ifndef GCC_MANGLE_BUG
265 int len
= strlen (newname
);
269 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
270 strcpy(mangled_name
, physname
);
274 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
275 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
280 /* Only needed for GNU-mangled names. ANSI-mangled names
281 work with the normal mechanisms. */
282 if (OPNAME_PREFIX_P (field_name
))
284 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
286 error ("No mangling for \"%s\"", field_name
);
287 mangled_name_len
+= strlen (opname
);
288 mangled_name
= (char *)xmalloc (mangled_name_len
);
290 strncpy (mangled_name
, field_name
, 3);
291 mangled_name
[3] = '\0';
292 strcat (mangled_name
, opname
);
296 mangled_name
= (char *)xmalloc (mangled_name_len
);
298 mangled_name
[0] = '\0';
300 strcpy (mangled_name
, field_name
);
302 strcat (mangled_name
, buf
);
303 strcat (mangled_name
, newname
);
313 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
316 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
317 + strlen (buf
) + strlen (physname
) + 1);
319 /* Only needed for GNU-mangled names. ANSI-mangled names
320 work with the normal mechanisms. */
321 if (OPNAME_PREFIX_P (field_name
))
323 opname
= cplus_mangle_opname (field_name
+ 3, 0);
326 error ("No mangling for \"%s\"", field_name
);
328 mangled_name_len
+= strlen (opname
);
329 mangled_name
= (char *) xmalloc (mangled_name_len
);
331 strncpy (mangled_name
, field_name
, 3);
332 strcpy (mangled_name
+ 3, opname
);
336 mangled_name
= (char *) xmalloc (mangled_name_len
);
339 mangled_name
[0] = '\0';
343 strcpy (mangled_name
, field_name
);
346 strcat (mangled_name
, buf
);
349 strcat (mangled_name
, physname
);
350 return (mangled_name
);
354 /* Find which partial symtab on contains PC. Return 0 if none. */
356 struct partial_symtab
*
358 register CORE_ADDR pc
;
360 register struct partial_symtab
*pst
;
361 register struct objfile
*objfile
;
363 ALL_PSYMTABS (objfile
, pst
)
365 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
371 /* Find which partial symbol within a psymtab contains PC. Return 0
372 if none. Check all psymtabs if PSYMTAB is 0. */
373 struct partial_symbol
*
374 find_pc_psymbol (psymtab
, pc
)
375 struct partial_symtab
*psymtab
;
378 struct partial_symbol
*best
, *p
;
382 psymtab
= find_pc_psymtab (pc
);
386 best_pc
= psymtab
->textlow
- 1;
388 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
389 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
390 < psymtab
->n_static_syms
);
392 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
393 && SYMBOL_CLASS (p
) == LOC_BLOCK
394 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
395 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
397 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
400 if (best_pc
== psymtab
->textlow
- 1)
406 /* Find the definition for a specified symbol name NAME
407 in namespace NAMESPACE, visible from lexical block BLOCK.
408 Returns the struct symbol pointer, or zero if no symbol is found.
409 If SYMTAB is non-NULL, store the symbol table in which the
410 symbol was found there, or NULL if not found.
411 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
412 NAME is a field of the current implied argument `this'. If so set
413 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
414 BLOCK_FOUND is set to the block in which NAME is found (in the case of
415 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
418 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
420 register const struct block
*block
;
421 const enum namespace namespace;
422 int *is_a_field_of_this
;
423 struct symtab
**symtab
;
425 register struct symbol
*sym
;
426 register struct symtab
*s
;
427 register struct partial_symtab
*ps
;
428 struct blockvector
*bv
;
429 register struct objfile
*objfile
;
430 register struct block
*b
;
431 register struct minimal_symbol
*msymbol
;
433 extern char *gdb_completer_word_break_characters
;
435 /* Search specified block and its superiors. */
439 sym
= lookup_block_symbol (block
, name
, namespace);
445 /* Search the list of symtabs for one which contains the
446 address of the start of this block. */
447 ALL_SYMTABS (objfile
, s
)
449 bv
= BLOCKVECTOR (s
);
450 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
451 if (BLOCK_START (b
) <= BLOCK_START (block
)
452 && BLOCK_END (b
) > BLOCK_START (block
))
461 block
= BLOCK_SUPERBLOCK (block
);
464 /* Don't need to mess with the psymtabs; if we have a block,
465 that file is read in. If we don't, then we deal later with
466 all the psymtab stuff that needs checking. */
467 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
470 /* Find the right symtab. */
471 ALL_SYMTABS (objfile
, s
)
473 bv
= BLOCKVECTOR (s
);
474 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
475 if (BLOCK_START (b
) <= BLOCK_START (block
)
476 && BLOCK_END (b
) > BLOCK_START (block
))
478 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
491 /* C++: If requested to do so by the caller,
492 check to see if NAME is a field of `this'. */
493 if (is_a_field_of_this
)
495 struct value
*v
= value_of_this (0);
497 *is_a_field_of_this
= 0;
498 if (v
&& check_field (v
, name
))
500 *is_a_field_of_this
= 1;
507 /* Now search all global blocks. Do the symtab's first, then
508 check the psymtab's */
510 ALL_SYMTABS (objfile
, s
)
512 bv
= BLOCKVECTOR (s
);
513 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
514 sym
= lookup_block_symbol (block
, name
, namespace);
524 /* Check for the possibility of the symbol being a global function
525 that is stored in one of the minimal symbol tables. Eventually, all
526 global symbols might be resolved in this way. */
528 if (namespace == VAR_NAMESPACE
)
530 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
533 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
534 /* If S is NULL, there are no debug symbols for this file.
535 Skip this stuff and check for matching static symbols below. */
538 bv
= BLOCKVECTOR (s
);
539 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
540 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
542 /* We kept static functions in minimal symbol table as well as
543 in static scope. We want to find them in the symbol table. */
545 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
546 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
550 /* sym == 0 if symbol was found in the minimal symbol table
551 but not in the symtab.
552 Return 0 to use the msymbol definition of "foo_".
554 This happens for Fortran "foo_" symbols,
555 which are "foo" in the symtab.
557 This can also happen if "asm" is used to make a
558 regular symbol but not a debugging symbol, e.g.
570 ALL_PSYMTABS (objfile
, ps
)
572 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
574 s
= PSYMTAB_TO_SYMTAB(ps
);
575 bv
= BLOCKVECTOR (s
);
576 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
577 sym
= lookup_block_symbol (block
, name
, namespace);
579 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
586 /* Now search all per-file blocks.
587 Not strictly correct, but more useful than an error.
588 Do the symtabs first, then check the psymtabs */
590 ALL_SYMTABS (objfile
, s
)
592 bv
= BLOCKVECTOR (s
);
593 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
594 sym
= lookup_block_symbol (block
, name
, namespace);
604 ALL_PSYMTABS (objfile
, ps
)
606 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
608 s
= PSYMTAB_TO_SYMTAB(ps
);
609 bv
= BLOCKVECTOR (s
);
610 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
611 sym
= lookup_block_symbol (block
, name
, namespace);
613 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
620 /* Now search all per-file blocks for static mangled symbols.
621 Do the symtabs first, then check the psymtabs. */
623 if (namespace == VAR_NAMESPACE
)
625 ALL_SYMTABS (objfile
, s
)
627 bv
= BLOCKVECTOR (s
);
628 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
629 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
639 ALL_PSYMTABS (objfile
, ps
)
641 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
643 s
= PSYMTAB_TO_SYMTAB(ps
);
644 bv
= BLOCKVECTOR (s
);
645 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
646 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
648 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
661 /* Look, in partial_symtab PST, for symbol NAME. Check the global
662 symbols if GLOBAL, the static symbols if not */
664 static struct partial_symbol
*
665 lookup_partial_symbol (pst
, name
, global
, namespace)
666 struct partial_symtab
*pst
;
669 enum namespace namespace;
671 struct partial_symbol
*start
, *psym
;
672 struct partial_symbol
*top
, *bottom
, *center
;
673 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
674 int do_linear_search
= 1;
682 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
683 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
685 if (global
) /* This means we can use a binary search. */
687 do_linear_search
= 0;
689 /* Binary search. This search is guaranteed to end with center
690 pointing at the earliest partial symbol with the correct
691 name. At that point *all* partial symbols with that name
692 will be checked against the correct namespace. */
695 top
= start
+ length
- 1;
698 center
= bottom
+ (top
- bottom
) / 2;
699 assert (center
< top
);
700 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
702 do_linear_search
= 1;
704 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
713 assert (top
== bottom
);
714 while (STREQ (SYMBOL_NAME (top
), name
))
716 if (SYMBOL_NAMESPACE (top
) == namespace)
724 /* Can't use a binary search or else we found during the binary search that
725 we should also do a linear search. */
727 if (do_linear_search
)
729 for (psym
= start
; psym
< start
+ length
; psym
++)
731 if (namespace == SYMBOL_NAMESPACE (psym
))
733 if (SYMBOL_MATCHES_NAME (psym
, name
))
744 /* Find the psymtab containing main(). */
745 /* FIXME: What about languages without main() or specially linked
746 executables that have no main() ? */
748 struct partial_symtab
*
751 register struct partial_symtab
*pst
;
752 register struct objfile
*objfile
;
754 ALL_PSYMTABS (objfile
, pst
)
756 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
764 /* Search BLOCK for symbol NAME in NAMESPACE.
766 Note that if NAME is the demangled form of a C++ symbol, we will fail
767 to find a match during the binary search of the non-encoded names, but
768 for now we don't worry about the slight inefficiency of looking for
769 a match we'll never find, since it will go pretty quick. Once the
770 binary search terminates, we drop through and do a straight linear
771 search on the symbols. Each symbol which is marked as being a C++
772 symbol (language_cplus set) has both the encoded and non-encoded names
773 tested for a match. */
776 lookup_block_symbol (block
, name
, namespace)
777 register const struct block
*block
;
779 const enum namespace namespace;
781 register int bot
, top
, inc
;
782 register struct symbol
*sym
;
783 register struct symbol
*sym_found
= NULL
;
784 register int do_linear_search
= 1;
786 /* If the blocks's symbols were sorted, start with a binary search. */
788 if (BLOCK_SHOULD_SORT (block
))
790 /* Reset the linear search flag so if the binary search fails, we
791 won't do the linear search once unless we find some reason to
792 do so, such as finding a C++ symbol during the binary search.
793 Note that for C++ modules, ALL the symbols in a block should
794 end up marked as C++ symbols. */
796 do_linear_search
= 0;
797 top
= BLOCK_NSYMS (block
);
800 /* Advance BOT to not far before the first symbol whose name is NAME. */
804 inc
= (top
- bot
+ 1);
805 /* No need to keep binary searching for the last few bits worth. */
810 inc
= (inc
>> 1) + bot
;
811 sym
= BLOCK_SYM (block
, inc
);
812 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
814 do_linear_search
= 1;
816 if (SYMBOL_NAME (sym
)[0] < name
[0])
820 else if (SYMBOL_NAME (sym
)[0] > name
[0])
824 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
834 /* Now scan forward until we run out of symbols, find one whose name is
835 greater than NAME, or find one we want. If there is more than one
836 symbol with the right name and namespace, we return the first one.
837 dbxread.c is careful to make sure that if one is a register then it
840 top
= BLOCK_NSYMS (block
);
843 sym
= BLOCK_SYM (block
, bot
);
844 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
847 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
849 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
861 /* Here if block isn't sorted, or we fail to find a match during the
862 binary search above. If during the binary search above, we find a
863 symbol which is a C++ symbol, then we have re-enabled the linear
864 search flag which was reset when starting the binary search.
866 This loop is equivalent to the loop above, but hacked greatly for speed.
868 Note that parameter symbols do not always show up last in the
869 list; this loop makes sure to take anything else other than
870 parameter symbols first; it only uses parameter symbols as a
871 last resort. Note that this only takes up extra computation
874 if (do_linear_search
)
876 top
= BLOCK_NSYMS (block
);
880 sym
= BLOCK_SYM (block
, bot
);
881 if (SYMBOL_NAMESPACE (sym
) == namespace &&
882 SYMBOL_MATCHES_NAME (sym
, name
))
885 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
886 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
887 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
888 SYMBOL_CLASS (sym
) != LOC_REGPARM
)
896 return (sym_found
); /* Will be NULL if not found. */
900 /* Return the symbol for the function which contains a specified
901 lexical block, described by a struct block BL. */
907 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
908 bl
= BLOCK_SUPERBLOCK (bl
);
910 return BLOCK_FUNCTION (bl
);
913 /* Find the symtab associated with PC. Look through the psymtabs and read in
914 another symtab if necessary. */
918 register CORE_ADDR pc
;
920 register struct block
*b
;
921 struct blockvector
*bv
;
922 register struct symtab
*s
= NULL
;
923 register struct partial_symtab
*ps
;
924 register struct objfile
*objfile
;
926 /* Search all symtabs for one whose file contains our pc */
928 ALL_SYMTABS (objfile
, s
)
930 bv
= BLOCKVECTOR (s
);
931 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
932 if (BLOCK_START (b
) <= pc
933 && BLOCK_END (b
) > pc
)
938 ps
= find_pc_psymtab (pc
);
942 printf_filtered ("(Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
943 s
= PSYMTAB_TO_SYMTAB (ps
);
948 /* Find the source file and line number for a given PC value.
949 Return a structure containing a symtab pointer, a line number,
950 and a pc range for the entire source line.
951 The value's .pc field is NOT the specified pc.
952 NOTCURRENT nonzero means, if specified pc is on a line boundary,
953 use the line that ends there. Otherwise, in that case, the line
954 that begins there is used. */
956 /* The big complication here is that a line may start in one file, and end just
957 before the start of another file. This usually occurs when you #include
958 code in the middle of a subroutine. To properly find the end of a line's PC
959 range, we must search all symtabs associated with this compilation unit, and
960 find the one whose first PC is closer than that of the next line in this
964 struct symtab_and_line
965 find_pc_line (pc
, notcurrent
)
970 register struct linetable
*l
;
973 register struct linetable_entry
*item
;
974 struct symtab_and_line val
;
975 struct blockvector
*bv
;
977 /* Info on best line seen so far, and where it starts, and its file. */
979 struct linetable_entry
*best
= NULL
;
980 CORE_ADDR best_end
= 0;
981 struct symtab
*best_symtab
= 0;
983 /* Store here the first line number
984 of a file which contains the line at the smallest pc after PC.
985 If we don't find a line whose range contains PC,
986 we will use a line one less than this,
987 with a range from the start of that file to the first line's pc. */
988 struct linetable_entry
*alt
= NULL
;
989 struct symtab
*alt_symtab
= 0;
991 /* Info on best line seen in this file. */
993 struct linetable_entry
*prev
;
995 /* If this pc is not from the current frame,
996 it is the address of the end of a call instruction.
997 Quite likely that is the start of the following statement.
998 But what we want is the statement containing the instruction.
999 Fudge the pc to make sure we get that. */
1001 if (notcurrent
) pc
-= 1;
1003 s
= find_pc_symtab (pc
);
1013 bv
= BLOCKVECTOR (s
);
1015 /* Look at all the symtabs that share this blockvector.
1016 They all have the same apriori range, that we found was right;
1017 but they have different line tables. */
1019 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1021 /* Find the best line in this symtab. */
1028 fprintf (stderr
, "Inconsistent line number info for %s\n",
1034 item
= l
->item
; /* Get first line info */
1036 /* Is this file's first line closer than the first lines of other files?
1037 If so, record this file, and its first line, as best alternate. */
1038 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1044 for (i
= 0; i
< len
; i
++, item
++)
1046 /* Return the last line that did not start after PC. */
1053 /* At this point, prev points at the line whose start addr is <= pc, and
1054 item points at the next line. If we ran off the end of the linetable
1055 (pc >= start of the last line), then prev == item. If pc < start of
1056 the first line, prev will not be set. */
1058 /* Is this file's best line closer than the best in the other files?
1059 If so, record this file, and its best line, as best so far. */
1061 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1065 /* If another line is in the linetable, and its PC is closer
1066 than the best_end we currently have, take it as best_end. */
1067 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1068 best_end
= item
->pc
;
1075 { /* If we didn't find any line # info, just
1084 val
.symtab
= alt_symtab
;
1085 val
.line
= alt
->line
- 1;
1086 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1092 val
.symtab
= best_symtab
;
1093 val
.line
= best
->line
;
1095 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1100 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1105 /* Find the PC value for a given source file and line number.
1106 Returns zero for invalid line number.
1107 The source file is specified with a struct symtab. */
1110 find_line_pc (symtab
, line
)
1111 struct symtab
*symtab
;
1114 register struct linetable
*l
;
1120 l
= LINETABLE (symtab
);
1121 ind
= find_line_common(l
, line
, &dummy
);
1122 return (ind
>= 0) ? l
->item
[ind
].pc
: 0;
1125 /* Find the range of pc values in a line.
1126 Store the starting pc of the line into *STARTPTR
1127 and the ending pc (start of next line) into *ENDPTR.
1128 Returns 1 to indicate success.
1129 Returns 0 if could not find the specified line. */
1132 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1133 struct symtab
*symtab
;
1135 CORE_ADDR
*startptr
, *endptr
;
1137 register struct linetable
*l
;
1139 int exact_match
; /* did we get an exact linenumber match */
1144 l
= LINETABLE (symtab
);
1145 ind
= find_line_common (l
, thisline
, &exact_match
);
1148 *startptr
= l
->item
[ind
].pc
;
1149 /* If we have not seen an entry for the specified line,
1150 assume that means the specified line has zero bytes. */
1151 if (!exact_match
|| ind
== l
->nitems
-1)
1152 *endptr
= *startptr
;
1154 /* Perhaps the following entry is for the following line.
1155 It's worth a try. */
1156 if (ind
+1 < l
->nitems
1157 && l
->item
[ind
+1].line
== thisline
+ 1)
1158 *endptr
= l
->item
[ind
+1].pc
;
1160 *endptr
= find_line_pc (symtab
, thisline
+1);
1167 /* Given a line table and a line number, return the index into the line
1168 table for the pc of the nearest line whose number is >= the specified one.
1169 Return -1 if none is found. The value is >= 0 if it is an index.
1171 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1174 find_line_common (l
, lineno
, exact_match
)
1175 register struct linetable
*l
;
1176 register int lineno
;
1182 /* BEST is the smallest linenumber > LINENO so far seen,
1183 or 0 if none has been seen so far.
1184 BEST_INDEX identifies the item for it. */
1186 int best_index
= -1;
1195 for (i
= 0; i
< len
; i
++)
1197 register struct linetable_entry
*item
= &(l
->item
[i
]);
1199 if (item
->line
== lineno
)
1205 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1212 /* If we got here, we didn't get an exact match. */
1219 find_pc_line_pc_range (pc
, startptr
, endptr
)
1221 CORE_ADDR
*startptr
, *endptr
;
1223 struct symtab_and_line sal
;
1224 sal
= find_pc_line (pc
, 0);
1227 return sal
.symtab
!= 0;
1230 /* If P is of the form "operator[ \t]+..." where `...' is
1231 some legitimate operator text, return a pointer to the
1232 beginning of the substring of the operator text.
1233 Otherwise, return "". */
1235 operator_chars (p
, end
)
1240 if (strncmp (p
, "operator", 8))
1244 /* Don't get faked out by `operator' being part of a longer
1246 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1249 /* Allow some whitespace between `operator' and the operator symbol. */
1250 while (*p
== ' ' || *p
== '\t')
1253 /* Recognize 'operator TYPENAME'. */
1255 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1257 register char *q
= p
+1;
1258 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1283 if (p
[1] == '=' || p
[1] == p
[0])
1294 error ("`operator ()' must be specified without whitespace in `()'");
1299 error ("`operator ?:' must be specified without whitespace in `?:'");
1304 error ("`operator []' must be specified without whitespace in `[]'");
1308 error ("`operator %s' not supported", p
);
1315 /* Recursive helper function for decode_line_1.
1316 * Look for methods named NAME in type T.
1317 * Return number of matches.
1318 * Put matches in SYM_ARR (which better be big enough!).
1319 * These allocations seem to define "big enough":
1320 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1324 find_methods (t
, name
, sym_arr
)
1327 struct symbol
**sym_arr
;
1331 struct symbol
*sym_class
;
1332 char *class_name
= type_name_no_tag (t
);
1333 /* Ignore this class if it doesn't have a name.
1334 This prevents core dumps, but is just a workaround
1335 because we might not find the function in
1336 certain cases, such as
1337 struct D {virtual int f();}
1338 struct C : D {virtual int g();}
1339 (in this case g++ 1.35.1- does not put out a name
1340 for D as such, it defines type 19 (for example) in
1341 the same stab as C, and then does a
1342 .stabs "D:T19" and a .stabs "D:t19".
1344 "break C::f" should not be looking for field f in
1346 but just for the field f in the baseclasses of C
1347 (no matter what their names).
1349 However, I don't know how to replace the code below
1350 that depends on knowing the name of D. */
1352 && (sym_class
= lookup_symbol (class_name
,
1353 (struct block
*)NULL
,
1356 (struct symtab
**)NULL
)))
1359 t
= SYMBOL_TYPE (sym_class
);
1360 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1361 method_counter
>= 0;
1365 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1367 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1368 if (STREQ (name
, method_name
))
1369 /* Find all the fields with that name. */
1370 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1375 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1376 check_stub_method (t
, method_counter
, field_counter
);
1377 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1378 sym_arr
[i1
] = lookup_symbol (phys_name
,
1379 SYMBOL_BLOCK_VALUE (sym_class
),
1382 (struct symtab
**) NULL
);
1383 if (sym_arr
[i1
]) i1
++;
1386 fputs_filtered("(Cannot find method ", stdout
);
1387 fputs_demangled(phys_name
, stdout
, DMGL_PARAMS
);
1388 fputs_filtered(" - possibly inlined.)\n", stdout
);
1393 /* Only search baseclasses if there is no match yet,
1394 * since names in derived classes override those in baseclasses.
1398 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1399 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1404 /* Parse a string that specifies a line number.
1405 Pass the address of a char * variable; that variable will be
1406 advanced over the characters actually parsed.
1410 LINENUM -- that line number in current file. PC returned is 0.
1411 FILE:LINENUM -- that line in that file. PC returned is 0.
1412 FUNCTION -- line number of openbrace of that function.
1413 PC returned is the start of the function.
1414 VARIABLE -- line number of definition of that variable.
1416 FILE:FUNCTION -- likewise, but prefer functions in that file.
1417 *EXPR -- line in which address EXPR appears.
1419 FUNCTION may be an undebuggable function found in minimal symbol table.
1421 If the argument FUNFIRSTLINE is nonzero, we want the first line
1422 of real code inside a function when a function is specified.
1424 DEFAULT_SYMTAB specifies the file to use if none is specified.
1425 It defaults to current_source_symtab.
1426 DEFAULT_LINE specifies the line number to use for relative
1427 line numbers (that start with signs). Defaults to current_source_line.
1429 Note that it is possible to return zero for the symtab
1430 if no file is validly specified. Callers must check that.
1431 Also, the line number returned may be invalid. */
1433 struct symtabs_and_lines
1434 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
)
1437 struct symtab
*default_symtab
;
1440 struct symtabs_and_lines values
;
1441 #ifdef HPPA_COMPILER_BUG
1442 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1443 when optimizing this file with target i960-vxworks. I haven't
1444 been able to construct a simple test case. The problem is that
1445 in the second call to SKIP_PROLOGUE below, the compiler somehow
1446 does not realize that the statement val = find_pc_line (...) will
1447 change the values of the fields of val. It extracts the elements
1448 into registers at the top of the block, and does not update the
1449 registers after the call to find_pc_line. You can check this by
1450 inserting a printf at the end of find_pc_line to show what values
1451 it is returning for val.pc and val.end and another printf after
1452 the call to see what values the function actually got (remember,
1453 this is compiling with cc -O, with this patch removed). You can
1454 also examine the assembly listing: search for the second call to
1455 skip_prologue; the LDO statement before the next call to
1456 find_pc_line loads the address of the structure which
1457 find_pc_line will return; if there is a LDW just before the LDO,
1458 which fetches an element of the structure, then the compiler
1461 Setting val to volatile avoids the problem. We must undef
1462 volatile, because the HPPA native compiler does not define
1463 __STDC__, although it does understand volatile, and so volatile
1464 will have been defined away in defs.h. */
1466 volatile struct symtab_and_line val
;
1467 #define volatile /*nothing*/
1469 struct symtab_and_line val
;
1471 register char *p
, *p1
;
1473 register struct symtab
*s
;
1475 register struct symbol
*sym
;
1476 /* The symtab that SYM was found in. */
1477 struct symtab
*sym_symtab
;
1479 register CORE_ADDR pc
;
1480 register struct minimal_symbol
*msymbol
;
1482 struct symbol
*sym_class
;
1485 struct symbol
**sym_arr
;
1487 char *saved_arg
= *argptr
;
1488 extern char *gdb_completer_quote_characters
;
1490 /* Defaults have defaults. */
1492 if (default_symtab
== 0)
1494 default_symtab
= current_source_symtab
;
1495 default_line
= current_source_line
;
1498 /* See if arg is *PC */
1500 if (**argptr
== '*')
1502 if (**argptr
== '*')
1506 pc
= parse_and_eval_address_1 (argptr
);
1507 values
.sals
= (struct symtab_and_line
*)
1508 xmalloc (sizeof (struct symtab_and_line
));
1510 values
.sals
[0] = find_pc_line (pc
, 0);
1511 values
.sals
[0].pc
= pc
;
1515 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1518 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1520 for (p
= *argptr
; *p
; p
++)
1522 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1525 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1527 if ((p
[0] == ':') && !is_quoted
)
1533 /* Extract the class name. */
1535 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1536 copy
= (char *) alloca (p
- *argptr
+ 1);
1537 memcpy (copy
, *argptr
, p
- *argptr
);
1538 copy
[p
- *argptr
] = 0;
1540 /* Discard the class name from the arg. */
1542 while (*p
== ' ' || *p
== '\t') p
++;
1545 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1546 (struct symtab
**)NULL
);
1549 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1550 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1552 /* Arg token is not digits => try it as a function name
1553 Find the next token (everything up to end or next whitespace). */
1555 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1556 q
= operator_chars (*argptr
, &q1
);
1561 char *tmp
= alloca (q1
- q
+ 1);
1562 memcpy (tmp
, q
, q1
- q
);
1564 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1567 warning ("no mangling for \"%s\"", tmp
);
1568 cplusplus_hint (saved_arg
);
1569 return_to_top_level ();
1571 copy
= (char*) alloca (3 + strlen(opname
));
1572 sprintf (copy
, "__%s", opname
);
1577 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1578 memcpy (copy
, *argptr
, p
- *argptr
);
1579 copy
[p
- *argptr
] = '\0';
1582 /* no line number may be specified */
1583 while (*p
== ' ' || *p
== '\t') p
++;
1587 i1
= 0; /* counter for the symbol array */
1588 t
= SYMBOL_TYPE (sym_class
);
1589 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1591 if (destructor_name_p (copy
, t
))
1593 /* destructors are a special case. */
1594 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1595 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1596 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1598 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1599 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1600 if (sym_arr
[i1
]) i1
++;
1603 i1
= find_methods (t
, copy
, sym_arr
);
1606 /* There is exactly one field with that name. */
1609 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1611 /* Arg is the name of a function */
1612 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1615 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1617 values
.sals
[0] = find_pc_line (pc
, 0);
1618 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1628 /* There is more than one field with that name
1629 (overloaded). Ask the user which one to use. */
1630 return decode_line_2 (sym_arr
, i1
, funfirstline
);
1636 if (OPNAME_PREFIX_P (copy
))
1638 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1639 strcpy (tmp
, "operator ");
1640 strcat (tmp
, copy
+3);
1645 warning ("the class `%s' does not have destructor defined",
1646 SYMBOL_SOURCE_NAME(sym_class
));
1648 warning ("the class %s does not have any method named %s",
1649 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1650 cplusplus_hint (saved_arg
);
1651 return_to_top_level ();
1656 /* The quotes are important if copy is empty. */
1657 warning ("can't find class, struct, or union named \"%s\"",
1659 cplusplus_hint (saved_arg
);
1660 return_to_top_level ();
1666 /* Extract the file name. */
1668 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1669 copy
= (char *) alloca (p
- *argptr
+ 1);
1670 memcpy (copy
, *argptr
, p
- *argptr
);
1671 copy
[p
- *argptr
] = 0;
1673 /* Find that file's data. */
1674 s
= lookup_symtab (copy
);
1677 if (!have_full_symbols () && !have_partial_symbols ())
1678 error (no_symtab_msg
);
1679 error ("No source file named %s.", copy
);
1682 /* Discard the file name from the arg. */
1684 while (*p
== ' ' || *p
== '\t') p
++;
1688 /* S is specified file's symtab, or 0 if no file specified.
1689 arg no longer contains the file name. */
1691 /* Check whether arg is all digits (and sign) */
1694 if (*p
== '-' || *p
== '+') p
++;
1695 while (*p
>= '0' && *p
<= '9')
1698 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1700 /* We found a token consisting of all digits -- at least one digit. */
1701 enum sign
{none
, plus
, minus
} sign
= none
;
1703 /* This is where we need to make sure that we have good defaults.
1704 We must guarantee that this section of code is never executed
1705 when we are called with just a function name, since
1706 select_source_symtab calls us with such an argument */
1708 if (s
== 0 && default_symtab
== 0)
1710 select_source_symtab (0);
1711 default_symtab
= current_source_symtab
;
1712 default_line
= current_source_line
;
1715 if (**argptr
== '+')
1716 sign
= plus
, (*argptr
)++;
1717 else if (**argptr
== '-')
1718 sign
= minus
, (*argptr
)++;
1719 val
.line
= atoi (*argptr
);
1726 val
.line
= default_line
+ val
.line
;
1732 val
.line
= default_line
- val
.line
;
1737 break; /* No need to adjust val.line. */
1740 while (*p
== ' ' || *p
== '\t') p
++;
1746 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1747 values
.sals
[0] = val
;
1752 /* Arg token is not digits => try it as a variable name
1753 Find the next token (everything up to end or next whitespace). */
1755 p
= skip_quoted (*argptr
);
1756 copy
= (char *) alloca (p
- *argptr
+ 1);
1757 memcpy (copy
, *argptr
, p
- *argptr
);
1758 copy
[p
- *argptr
] = '\0';
1759 if ((copy
[0] == copy
[p
- *argptr
- 1])
1760 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1763 copy
[p
- *argptr
- 1] = '\0';
1766 while (*p
== ' ' || *p
== '\t') p
++;
1769 /* Look up that token as a variable.
1770 If file specified, use that file's per-file block to start with. */
1772 sym
= lookup_symbol (copy
,
1773 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1774 : get_selected_block ()),
1775 VAR_NAMESPACE
, 0, &sym_symtab
);
1779 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1781 /* Arg is the name of a function */
1782 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1785 val
= find_pc_line (pc
, 0);
1786 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1787 /* Convex: no need to suppress code on first line, if any */
1790 /* If SKIP_PROLOGUE left us in mid-line, and the next line is still
1791 part of the same function:
1792 advance to next line,
1793 recalculate its line number (might not be N+1). */
1794 if (val
.pc
!= pc
&& val
.end
&&
1795 lookup_minimal_symbol_by_pc (pc
) == lookup_minimal_symbol_by_pc (val
.end
)) {
1796 pc
= val
.end
; /* First pc of next line */
1797 val
= find_pc_line (pc
, 0);
1801 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1802 values
.sals
[0] = val
;
1805 /* I think this is always the same as the line that
1806 we calculate above, but the general principle is
1807 "trust the symbols more than stuff like
1809 if (SYMBOL_LINE (sym
) != 0)
1810 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1814 else if (SYMBOL_LINE (sym
) != 0)
1816 /* We know its line number. */
1817 values
.sals
= (struct symtab_and_line
*)
1818 xmalloc (sizeof (struct symtab_and_line
));
1820 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
1821 values
.sals
[0].symtab
= sym_symtab
;
1822 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1826 /* This can happen if it is compiled with a compiler which doesn't
1827 put out line numbers for variables. */
1828 error ("Line number not known for symbol \"%s\"", copy
);
1831 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
1832 if (msymbol
!= NULL
)
1836 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
) + FUNCTION_START_OFFSET
;
1838 SKIP_PROLOGUE (val
.pc
);
1839 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1840 values
.sals
[0] = val
;
1845 if (!have_full_symbols () &&
1846 !have_partial_symbols () && !have_minimal_symbols ())
1847 error (no_symtab_msg
);
1849 error ("Function \"%s\" not defined.", copy
);
1850 return values
; /* for lint */
1853 struct symtabs_and_lines
1854 decode_line_spec (string
, funfirstline
)
1858 struct symtabs_and_lines sals
;
1860 error ("Empty line specification.");
1861 sals
= decode_line_1 (&string
, funfirstline
,
1862 current_source_symtab
, current_source_line
);
1864 error ("Junk at end of line specification: %s", string
);
1868 /* Given a list of NELTS symbols in sym_arr, return a list of lines to
1869 operate on (ask user if necessary). */
1871 static struct symtabs_and_lines
1872 decode_line_2 (sym_arr
, nelts
, funfirstline
)
1873 struct symbol
*sym_arr
[];
1877 struct symtabs_and_lines values
, return_values
;
1878 register CORE_ADDR pc
;
1884 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
1885 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
1888 printf("[0] cancel\n[1] all\n");
1891 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
1893 /* Arg is the name of a function */
1894 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
1895 + FUNCTION_START_OFFSET
;
1898 values
.sals
[i
] = find_pc_line (pc
, 0);
1899 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
1900 values
.sals
[i
].end
: pc
;
1901 printf("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
1902 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
1904 else printf ("?HERE\n");
1908 if ((prompt
= getenv ("PS2")) == NULL
)
1912 printf("%s ",prompt
);
1915 args
= command_line_input ((char *) NULL
, 0);
1918 error_no_arg ("one or more choice numbers");
1926 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
1927 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
1928 error ("Arguments must be choice numbers.");
1933 error ("cancelled");
1936 memcpy (return_values
.sals
, values
.sals
,
1937 (nelts
* sizeof(struct symtab_and_line
)));
1938 return_values
.nelts
= nelts
;
1939 return return_values
;
1942 if (num
> nelts
+ 2)
1944 printf ("No choice number %d.\n", num
);
1949 if (values
.sals
[num
].pc
)
1951 return_values
.sals
[i
++] = values
.sals
[num
];
1952 values
.sals
[num
].pc
= 0;
1956 printf ("duplicate request for %d ignored.\n", num
);
1961 while (*args
== ' ' || *args
== '\t') args
++;
1963 return_values
.nelts
= i
;
1964 return return_values
;
1968 /* Slave routine for sources_info. Force line breaks at ,'s.
1969 NAME is the name to print and *FIRST is nonzero if this is the first
1970 name printed. Set *FIRST to zero. */
1972 output_source_filename (name
, first
)
1976 /* Table of files printed so far. Since a single source file can
1977 result in several partial symbol tables, we need to avoid printing
1978 it more than once. Note: if some of the psymtabs are read in and
1979 some are not, it gets printed both under "Source files for which
1980 symbols have been read" and "Source files for which symbols will
1981 be read in on demand". I consider this a reasonable way to deal
1982 with the situation. I'm not sure whether this can also happen for
1983 symtabs; it doesn't hurt to check. */
1984 static char **tab
= NULL
;
1985 /* Allocated size of tab in elements.
1986 Start with one 256-byte block (when using GNU malloc.c).
1987 24 is the malloc overhead when range checking is in effect. */
1988 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
1989 /* Current size of tab in elements. */
1990 static int tab_cur_size
;
1997 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2001 /* Is NAME in tab? */
2002 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2003 if (STREQ (*p
, name
))
2004 /* Yes; don't print it again. */
2006 /* No; add it to tab. */
2007 if (tab_cur_size
== tab_alloc_size
)
2009 tab_alloc_size
*= 2;
2010 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2012 tab
[tab_cur_size
++] = name
;
2020 printf_filtered (", ");
2024 fputs_filtered (name
, stdout
);
2028 sources_info (ignore
, from_tty
)
2032 register struct symtab
*s
;
2033 register struct partial_symtab
*ps
;
2034 register struct objfile
*objfile
;
2037 if (!have_full_symbols () && !have_partial_symbols ())
2039 error (no_symtab_msg
);
2042 printf_filtered ("Source files for which symbols have been read in:\n\n");
2045 ALL_SYMTABS (objfile
, s
)
2047 output_source_filename (s
-> filename
, &first
);
2049 printf_filtered ("\n\n");
2051 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2054 ALL_PSYMTABS (objfile
, ps
)
2058 output_source_filename (ps
-> filename
, &first
);
2061 printf_filtered ("\n");
2064 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2065 If CLASS is zero, list all symbols except functions, type names, and
2067 If CLASS is 1, list only functions.
2068 If CLASS is 2, list only type names.
2069 If CLASS is 3, list only method names.
2071 BPT is non-zero if we should set a breakpoint at the functions
2075 list_symbols (regexp
, class, bpt
)
2080 register struct symtab
*s
;
2081 register struct partial_symtab
*ps
;
2082 register struct blockvector
*bv
;
2083 struct blockvector
*prev_bv
= 0;
2084 register struct block
*b
;
2086 register struct symbol
*sym
;
2087 struct partial_symbol
*psym
;
2088 struct objfile
*objfile
;
2089 struct minimal_symbol
*msymbol
;
2091 static char *classnames
[]
2092 = {"variable", "function", "type", "method"};
2093 int found_in_file
= 0;
2095 static enum minimal_symbol_type types
[]
2096 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2097 static enum minimal_symbol_type types2
[]
2098 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2099 enum minimal_symbol_type ourtype
= types
[class];
2100 enum minimal_symbol_type ourtype2
= types2
[class];
2104 /* Make sure spacing is right for C++ operators.
2105 This is just a courtesy to make the matching less sensitive
2106 to how many spaces the user leaves between 'operator'
2107 and <TYPENAME> or <OPERATOR>. */
2109 char *opname
= operator_chars (regexp
, &opend
);
2112 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2113 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2115 /* There should 1 space between 'operator' and 'TYPENAME'. */
2116 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2121 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2122 if (opname
[-1] == ' ')
2125 /* If wrong number of spaces, fix it. */
2128 char *tmp
= (char*) alloca(opend
-opname
+10);
2129 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2134 if (0 != (val
= re_comp (regexp
)))
2135 error ("Invalid regexp (%s): %s", val
, regexp
);
2138 /* Search through the partial symtabs *first* for all symbols
2139 matching the regexp. That way we don't have to reproduce all of
2140 the machinery below. */
2142 ALL_PSYMTABS (objfile
, ps
)
2144 struct partial_symbol
*bound
, *gbound
, *sbound
;
2147 if (ps
->readin
) continue;
2149 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2150 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2153 /* Go through all of the symbols stored in a partial
2154 symtab in one loop. */
2155 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2160 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2162 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2173 /* If it would match (logic taken from loop below)
2174 load the file and go on to the next one */
2175 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2176 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2177 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2178 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2179 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2180 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2182 PSYMTAB_TO_SYMTAB(ps
);
2190 /* Here, we search through the minimal symbol tables for functions that
2191 match, and call find_pc_symtab on them to force their symbols to
2192 be read. The symbol will then be found during the scan of symtabs
2193 below. If find_pc_symtab fails, set found_misc so that we will
2194 rescan to print any matching symbols without debug info. */
2198 ALL_MSYMBOLS (objfile
, msymbol
)
2200 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2201 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2203 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2205 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2214 /* Printout here so as to get after the "Reading in symbols"
2215 messages which will be generated above. */
2217 printf_filtered (regexp
2218 ? "All %ss matching regular expression \"%s\":\n"
2219 : "All defined %ss:\n",
2223 ALL_SYMTABS (objfile
, s
)
2226 bv
= BLOCKVECTOR (s
);
2227 /* Often many files share a blockvector.
2228 Scan each blockvector only once so that
2229 we don't get every symbol many times.
2230 It happens that the first symtab in the list
2231 for any given blockvector is the main file. */
2233 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2235 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2236 /* Skip the sort if this block is always sorted. */
2237 if (!BLOCK_SHOULD_SORT (b
))
2238 sort_block_syms (b
);
2239 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2242 sym
= BLOCK_SYM (b
, j
);
2243 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2244 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2245 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2246 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2247 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2248 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2249 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2253 /* Set a breakpoint here, if it's a function */
2255 break_command (SYMBOL_NAME(sym
), 0);
2257 else if (!found_in_file
)
2259 fputs_filtered ("\nFile ", stdout
);
2260 fputs_filtered (s
->filename
, stdout
);
2261 fputs_filtered (":\n", stdout
);
2265 if (class != 2 && i
== STATIC_BLOCK
)
2266 printf_filtered ("static ");
2268 /* Typedef that is not a C++ class */
2270 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2271 c_typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2272 /* variable, func, or typedef-that-is-c++-class */
2273 else if (class < 2 ||
2275 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2277 type_print (SYMBOL_TYPE (sym
),
2278 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2279 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2282 printf_filtered (";\n");
2286 # if 0 /* FIXME, why is this zapped out? */
2288 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2290 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2292 sprintf (buf
, " %s::", type_name_no_tag (t
));
2293 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2303 /* If there are no eyes, avoid all contact. I mean, if there are
2304 no debug symbols, then print directly from the msymbol_vector. */
2306 if (found_misc
|| class != 1)
2309 ALL_MSYMBOLS (objfile
, msymbol
)
2311 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2312 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2314 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2316 /* Functions: Look up by address. */
2318 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2320 /* Variables/Absolutes: Look up by name */
2321 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2322 (struct block
*) NULL
, VAR_NAMESPACE
,
2323 0, (struct symtab
**) NULL
) == NULL
)
2327 printf_filtered ("\nNon-debugging symbols:\n");
2330 printf_filtered (" %08x %s\n",
2331 SYMBOL_VALUE_ADDRESS (msymbol
),
2332 SYMBOL_SOURCE_NAME (msymbol
));
2342 variables_info (regexp
, from_tty
)
2346 list_symbols (regexp
, 0, 0);
2350 functions_info (regexp
, from_tty
)
2354 list_symbols (regexp
, 1, 0);
2358 types_info (regexp
, from_tty
)
2362 list_symbols (regexp
, 2, 0);
2366 /* Tiemann says: "info methods was never implemented." */
2368 methods_info (regexp
)
2371 list_symbols (regexp
, 3, 0);
2375 /* Breakpoint all functions matching regular expression. */
2377 rbreak_command (regexp
, from_tty
)
2381 list_symbols (regexp
, 1, 1);
2385 /* Return Nonzero if block a is lexically nested within block b,
2386 or if a and b have the same pc range.
2387 Return zero otherwise. */
2390 struct block
*a
, *b
;
2394 return BLOCK_START (a
) >= BLOCK_START (b
)
2395 && BLOCK_END (a
) <= BLOCK_END (b
);
2399 /* Helper routine for make_symbol_completion_list. */
2401 static int return_val_size
;
2402 static int return_val_index
;
2403 static char **return_val
;
2405 #define COMPLETION_LIST_ADD_SYMBOL(symbol, text, len) \
2407 completion_list_add_name (SYMBOL_NAME (symbol), text, len); \
2408 if (SYMBOL_LANGUAGE (symbol) == language_cplus && \
2409 SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2410 completion_list_add_name (SYMBOL_DEMANGLED_NAME (symbol), text, len); \
2413 /* Test to see if the symbol specified by SYMNAME (which is already
2414 demangled for C++ symbols) matches TEXT in the first TEXT_LEN
2415 characters. If so, add it to the current completion list. */
2418 completion_list_add_name (symname
, text
, text_len
)
2426 /* clip symbols that cannot match */
2428 if (strncmp (symname
, text
, text_len
) != 0)
2433 /* Clip any symbol names that we've already considered. (This is a
2434 time optimization) */
2436 for (i
= 0; i
< return_val_index
; ++i
)
2438 if (STREQ (symname
, return_val
[i
]))
2444 /* We have a match for a completion, so add SYMNAME to the current list
2445 of matches. Note that the name is moved to freshly malloc'd space. */
2447 symname
= savestring (symname
, strlen (symname
));
2448 if (return_val_index
+ 3 > return_val_size
)
2450 newsize
= (return_val_size
*= 2) * sizeof (char *);
2451 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2453 return_val
[return_val_index
++] = symname
;
2454 return_val
[return_val_index
] = NULL
;
2457 /* Return a NULL terminated array of all symbols (regardless of class) which
2458 begin by matching TEXT. If the answer is no symbols, then the return value
2459 is an array which contains only a NULL pointer.
2461 Problem: All of the symbols have to be copied because readline frees them.
2462 I'm not going to worry about this; hopefully there won't be that many. */
2465 make_symbol_completion_list (text
)
2468 register struct symbol
*sym
;
2469 register struct symtab
*s
;
2470 register struct partial_symtab
*ps
;
2471 register struct minimal_symbol
*msymbol
;
2472 register struct objfile
*objfile
;
2473 register struct block
*b
, *surrounding_static_block
= 0;
2476 struct partial_symbol
*psym
;
2478 text_len
= strlen (text
);
2479 return_val_size
= 100;
2480 return_val_index
= 0;
2481 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2482 return_val
[0] = NULL
;
2484 /* Look through the partial symtabs for all symbols which begin
2485 by matching TEXT. Add each one that you find to the list. */
2487 ALL_PSYMTABS (objfile
, ps
)
2489 /* If the psymtab's been read in we'll get it when we search
2490 through the blockvector. */
2491 if (ps
->readin
) continue;
2493 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2494 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2495 + ps
->n_global_syms
);
2498 /* If interrupted, then quit. */
2500 COMPLETION_LIST_ADD_SYMBOL (psym
, text
, text_len
);
2503 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2504 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2505 + ps
->n_static_syms
);
2509 COMPLETION_LIST_ADD_SYMBOL (psym
, text
, text_len
);
2513 /* At this point scan through the misc symbol vectors and add each
2514 symbol you find to the list. Eventually we want to ignore
2515 anything that isn't a text symbol (everything else will be
2516 handled by the psymtab code above). */
2518 ALL_MSYMBOLS (objfile
, msymbol
)
2521 COMPLETION_LIST_ADD_SYMBOL (msymbol
, text
, text_len
);
2524 /* Search upwards from currently selected frame (so that we can
2525 complete on local vars. */
2527 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2529 if (!BLOCK_SUPERBLOCK (b
))
2531 surrounding_static_block
= b
; /* For elmin of dups */
2534 /* Also catch fields of types defined in this places which match our
2535 text string. Only complete on types visible from current context. */
2537 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2539 sym
= BLOCK_SYM (b
, i
);
2540 COMPLETION_LIST_ADD_SYMBOL (sym
, text
, text_len
);
2541 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2543 struct type
*t
= SYMBOL_TYPE (sym
);
2544 enum type_code c
= TYPE_CODE (t
);
2546 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2548 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2550 if (TYPE_FIELD_NAME (t
, j
))
2552 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2561 /* Go through the symtabs and check the externs and statics for
2562 symbols which match. */
2564 ALL_SYMTABS (objfile
, s
)
2567 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2568 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2570 sym
= BLOCK_SYM (b
, i
);
2571 COMPLETION_LIST_ADD_SYMBOL (sym
, text
, text_len
);
2575 ALL_SYMTABS (objfile
, s
)
2578 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2579 /* Don't do this block twice. */
2580 if (b
== surrounding_static_block
) continue;
2581 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2583 sym
= BLOCK_SYM (b
, i
);
2584 COMPLETION_LIST_ADD_SYMBOL (sym
, text
, text_len
);
2588 return (return_val
);
2593 /* Add the type of the symbol sym to the type of the current
2594 function whose block we are in (assumed). The type of
2595 this current function is contained in *TYPE.
2597 This basically works as follows: When we find a function
2598 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2599 a pointer to its type in the global in_function_type. Every
2600 time we come across a parameter symbol ('p' in its name), then
2601 this procedure adds the name and type of that parameter
2602 to the function type pointed to by *TYPE. (Which should correspond
2603 to in_function_type if it was called correctly).
2605 Note that since we are modifying a type, the result of
2606 lookup_function_type() should be memcpy()ed before calling
2607 this. When not in strict typing mode, the expression
2608 evaluator can choose to ignore this.
2610 Assumption: All of a function's parameter symbols will
2611 appear before another function symbol is found. The parameters
2612 appear in the same order in the argument list as they do in the
2616 add_param_to_type (type
,sym
)
2620 int num
= ++(TYPE_NFIELDS(*type
));
2622 if(TYPE_NFIELDS(*type
)-1)
2623 TYPE_FIELDS(*type
) = (struct field
*)
2624 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2625 num
*sizeof(struct field
));
2627 TYPE_FIELDS(*type
) = (struct field
*)
2628 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2630 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2631 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2632 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2633 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2638 _initialize_symtab ()
2640 add_info ("variables", variables_info
,
2641 "All global and static variable names, or those matching REGEXP.");
2642 add_info ("functions", functions_info
,
2643 "All function names, or those matching REGEXP.");
2645 /* FIXME: This command has at least the following problems:
2646 1. It prints builtin types (in a very strange and confusing fashion).
2647 2. It doesn't print right, e.g. with
2648 typedef struct foo *FOO
2649 type_print prints "FOO" when we want to make it (in this situation)
2650 print "struct foo *".
2651 I also think "ptype" or "whatis" is more likely to be useful (but if
2652 there is much disagreement "info types" can be fixed). */
2653 add_info ("types", types_info
,
2654 "All type names, or those matching REGEXP.");
2657 add_info ("methods", methods_info
,
2658 "All method names, or those matching REGEXP::REGEXP.\n\
2659 If the class qualifier is omitted, it is assumed to be the current scope.\n\
2660 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
2663 add_info ("sources", sources_info
,
2664 "Source files in the program.");
2666 add_com ("rbreak", no_class
, rbreak_command
,
2667 "Set a breakpoint for all functions matching REGEXP.");
2669 /* Initialize the one built-in type that isn't language dependent... */
2670 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
2671 "<unknown type>", (struct objfile
*) NULL
);