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, char *, char *));
55 build_canonical_line_spec
PARAMS ((struct symtab_and_line
*, char *, char ***));
57 static struct symtabs_and_lines
58 decode_line_2
PARAMS ((struct symbol
*[], int, int, char ***));
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 **));
84 static int find_line_common
PARAMS ((struct linetable
*, int, int *));
86 static struct partial_symbol
*
87 lookup_partial_symbol
PARAMS ((struct partial_symtab
*, const char *,
88 int, enum namespace));
90 static struct symtab
*
91 lookup_symtab_1
PARAMS ((char *));
95 /* The single non-language-specific builtin type */
96 struct type
*builtin_type_error
;
98 /* Block in which the most recently searched-for symbol was found.
99 Might be better to make this a parameter to lookup_symbol and
102 const struct block
*block_found
;
104 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
106 /* While the C++ support is still in flux, issue a possibly helpful hint on
107 using the new command completion feature on single quoted demangled C++
108 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
111 cplusplus_hint (name
)
114 printf_unfiltered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
115 printf_unfiltered ("(Note leading single quote.)\n");
118 /* Check for a symtab of a specific name; first in symtabs, then in
119 psymtabs. *If* there is no '/' in the name, a match after a '/'
120 in the symtab filename will also work. */
122 static struct symtab
*
123 lookup_symtab_1 (name
)
126 register struct symtab
*s
;
127 register struct partial_symtab
*ps
;
128 register char *slash
;
129 register struct objfile
*objfile
;
133 /* First, search for an exact match */
135 ALL_SYMTABS (objfile
, s
)
136 if (STREQ (name
, s
->filename
))
139 slash
= strchr (name
, '/');
141 /* Now, search for a matching tail (only if name doesn't have any dirs) */
144 ALL_SYMTABS (objfile
, s
)
146 char *p
= s
-> filename
;
147 char *tail
= strrchr (p
, '/');
156 /* Same search rules as above apply here, but now we look thru the
159 ps
= lookup_partial_symtab (name
);
164 error ("Internal: readin %s pst for `%s' found when no symtab found.",
165 ps
-> filename
, name
);
167 s
= PSYMTAB_TO_SYMTAB (ps
);
172 /* At this point, we have located the psymtab for this file, but
173 the conversion to a symtab has failed. This usually happens
174 when we are looking up an include file. In this case,
175 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
176 been created. So, we need to run through the symtabs again in
177 order to find the file.
178 XXX - This is a crock, and should be fixed inside of the the
179 symbol parsing routines. */
183 /* Lookup the symbol table of a source file named NAME. Try a couple
184 of variations if the first lookup doesn't work. */
190 register struct symtab
*s
;
193 s
= lookup_symtab_1 (name
);
196 /* If name not found as specified, see if adding ".c" helps. */
197 /* Why is this? Is it just a user convenience? (If so, it's pretty
198 questionable in the presence of C++, FORTRAN, etc.). It's not in
201 copy
= (char *) alloca (strlen (name
) + 3);
204 s
= lookup_symtab_1 (copy
);
207 /* We didn't find anything; die. */
211 /* Lookup the partial symbol table of a source file named NAME.
212 *If* there is no '/' in the name, a match after a '/'
213 in the psymtab filename will also work. */
215 struct partial_symtab
*
216 lookup_partial_symtab (name
)
219 register struct partial_symtab
*pst
;
220 register struct objfile
*objfile
;
222 ALL_PSYMTABS (objfile
, pst
)
224 if (STREQ (name
, pst
-> filename
))
230 /* Now, search for a matching tail (only if name doesn't have any dirs) */
232 if (!strchr (name
, '/'))
233 ALL_PSYMTABS (objfile
, pst
)
235 char *p
= pst
-> filename
;
236 char *tail
= strrchr (p
, '/');
248 /* Demangle a GDB method stub type.
249 Note that this function is g++ specific. */
252 gdb_mangle_name (type
, i
, j
)
256 int mangled_name_len
;
258 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
259 struct fn_field
*method
= &f
[j
];
260 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
261 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
262 char *newname
= type_name_no_tag (type
);
264 /* Does the form of physname indicate that it is the full mangled name
265 of a constructor (not just the args)? */
266 int is_full_physname_constructor
;
269 int is_destructor
= DESTRUCTOR_PREFIX_P (physname
);
270 /* Need a new type prefix. */
271 char *const_prefix
= method
->is_const
? "C" : "";
272 char *volatile_prefix
= method
->is_volatile
? "V" : "";
274 int len
= (newname
== NULL
? 0 : strlen (newname
));
276 is_full_physname_constructor
=
277 ((physname
[0]=='_' && physname
[1]=='_' &&
278 (isdigit(physname
[2]) || physname
[2]=='Q' || physname
[2]=='t'))
279 || (strncmp(physname
, "__ct", 4) == 0));
282 is_full_physname_constructor
|| (newname
&& STREQ(field_name
, newname
));
285 is_destructor
= (strncmp(physname
, "__dt", 4) == 0);
287 #ifndef GCC_MANGLE_BUG
288 if (is_destructor
|| is_full_physname_constructor
)
290 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
291 strcpy(mangled_name
, physname
);
297 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
298 if (strcmp(buf
, "__") == 0)
303 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
305 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
310 /* Only needed for GNU-mangled names. ANSI-mangled names
311 work with the normal mechanisms. */
312 if (OPNAME_PREFIX_P (field_name
))
314 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
316 error ("No mangling for \"%s\"", field_name
);
317 mangled_name_len
+= strlen (opname
);
318 mangled_name
= (char *)xmalloc (mangled_name_len
);
320 strncpy (mangled_name
, field_name
, 3);
321 mangled_name
[3] = '\0';
322 strcat (mangled_name
, opname
);
326 mangled_name
= (char *)xmalloc (mangled_name_len
);
328 mangled_name
[0] = '\0';
330 strcpy (mangled_name
, field_name
);
332 strcat (mangled_name
, buf
);
333 /* If the class doesn't have a name, i.e. newname NULL, then we just
334 mangle it using 0 for the length of the class. Thus it gets mangled
335 as something starting with `::' rather than `classname::'. */
337 strcat (mangled_name
, newname
);
347 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
350 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
351 + strlen (buf
) + strlen (physname
) + 1);
353 /* Only needed for GNU-mangled names. ANSI-mangled names
354 work with the normal mechanisms. */
355 if (OPNAME_PREFIX_P (field_name
))
358 opname
= cplus_mangle_opname (field_name
+ 3, 0);
361 error ("No mangling for \"%s\"", field_name
);
363 mangled_name_len
+= strlen (opname
);
364 mangled_name
= (char *) xmalloc (mangled_name_len
);
366 strncpy (mangled_name
, field_name
, 3);
367 strcpy (mangled_name
+ 3, opname
);
371 mangled_name
= (char *) xmalloc (mangled_name_len
);
374 mangled_name
[0] = '\0';
378 strcpy (mangled_name
, field_name
);
381 strcat (mangled_name
, buf
);
384 strcat (mangled_name
, physname
);
385 return (mangled_name
);
389 /* Find which partial symtab on contains PC. Return 0 if none. */
391 struct partial_symtab
*
393 register CORE_ADDR pc
;
395 register struct partial_symtab
*pst
;
396 register struct objfile
*objfile
;
398 ALL_PSYMTABS (objfile
, pst
)
400 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
406 /* Find which partial symbol within a psymtab contains PC. Return 0
407 if none. Check all psymtabs if PSYMTAB is 0. */
408 struct partial_symbol
*
409 find_pc_psymbol (psymtab
, pc
)
410 struct partial_symtab
*psymtab
;
413 struct partial_symbol
*best
= NULL
, *p
;
417 psymtab
= find_pc_psymtab (pc
);
421 best_pc
= psymtab
->textlow
- 1;
423 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
424 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
425 < psymtab
->n_static_syms
);
427 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
428 && SYMBOL_CLASS (p
) == LOC_BLOCK
429 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
430 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
432 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
435 if (best_pc
== psymtab
->textlow
- 1)
441 /* Find the definition for a specified symbol name NAME
442 in namespace NAMESPACE, visible from lexical block BLOCK.
443 Returns the struct symbol pointer, or zero if no symbol is found.
444 If SYMTAB is non-NULL, store the symbol table in which the
445 symbol was found there, or NULL if not found.
446 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
447 NAME is a field of the current implied argument `this'. If so set
448 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
449 BLOCK_FOUND is set to the block in which NAME is found (in the case of
450 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
453 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
455 register const struct block
*block
;
456 const enum namespace namespace;
457 int *is_a_field_of_this
;
458 struct symtab
**symtab
;
460 register struct symbol
*sym
;
461 register struct symtab
*s
= NULL
;
462 register struct partial_symtab
*ps
;
463 struct blockvector
*bv
;
464 register struct objfile
*objfile
;
465 register struct block
*b
;
466 register struct minimal_symbol
*msymbol
;
468 /* Search specified block and its superiors. */
472 sym
= lookup_block_symbol (block
, name
, namespace);
478 /* Search the list of symtabs for one which contains the
479 address of the start of this block. */
480 ALL_SYMTABS (objfile
, s
)
482 bv
= BLOCKVECTOR (s
);
483 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
484 if (BLOCK_START (b
) <= BLOCK_START (block
)
485 && BLOCK_END (b
) > BLOCK_START (block
))
494 block
= BLOCK_SUPERBLOCK (block
);
497 /* FIXME: this code is never executed--block is always NULL at this
498 point. What is it trying to do, anyway? We already should have
499 checked the STATIC_BLOCK above (it is the superblock of top-level
500 blocks). Why is VAR_NAMESPACE special-cased? */
501 /* Don't need to mess with the psymtabs; if we have a block,
502 that file is read in. If we don't, then we deal later with
503 all the psymtab stuff that needs checking. */
504 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
507 /* Find the right symtab. */
508 ALL_SYMTABS (objfile
, s
)
510 bv
= BLOCKVECTOR (s
);
511 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
512 if (BLOCK_START (b
) <= BLOCK_START (block
)
513 && BLOCK_END (b
) > BLOCK_START (block
))
515 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
528 /* C++: If requested to do so by the caller,
529 check to see if NAME is a field of `this'. */
530 if (is_a_field_of_this
)
532 struct value
*v
= value_of_this (0);
534 *is_a_field_of_this
= 0;
535 if (v
&& check_field (v
, name
))
537 *is_a_field_of_this
= 1;
544 /* Now search all global blocks. Do the symtab's first, then
545 check the psymtab's */
547 ALL_SYMTABS (objfile
, s
)
549 bv
= BLOCKVECTOR (s
);
550 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
551 sym
= lookup_block_symbol (block
, name
, namespace);
561 /* Check for the possibility of the symbol being a global function
562 that is stored in one of the minimal symbol tables. Eventually, all
563 global symbols might be resolved in this way. */
565 if (namespace == VAR_NAMESPACE
)
567 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
570 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
571 /* If S is NULL, there are no debug symbols for this file.
572 Skip this stuff and check for matching static symbols below. */
575 bv
= BLOCKVECTOR (s
);
576 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
577 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
579 /* We kept static functions in minimal symbol table as well as
580 in static scope. We want to find them in the symbol table. */
582 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
583 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
587 /* sym == 0 if symbol was found in the minimal symbol table
588 but not in the symtab.
589 Return 0 to use the msymbol definition of "foo_".
591 This happens for Fortran "foo_" symbols,
592 which are "foo" in the symtab.
594 This can also happen if "asm" is used to make a
595 regular symbol but not a debugging symbol, e.g.
607 ALL_PSYMTABS (objfile
, ps
)
609 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
611 s
= PSYMTAB_TO_SYMTAB(ps
);
612 bv
= BLOCKVECTOR (s
);
613 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
614 sym
= lookup_block_symbol (block
, name
, namespace);
616 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
623 /* Now search all per-file blocks.
624 Not strictly correct, but more useful than an error.
625 Do the symtabs first, then check the psymtabs */
627 ALL_SYMTABS (objfile
, s
)
629 bv
= BLOCKVECTOR (s
);
630 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
631 sym
= lookup_block_symbol (block
, name
, namespace);
641 ALL_PSYMTABS (objfile
, ps
)
643 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
645 s
= PSYMTAB_TO_SYMTAB(ps
);
646 bv
= BLOCKVECTOR (s
);
647 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
648 sym
= lookup_block_symbol (block
, name
, namespace);
650 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
657 /* Now search all per-file blocks for static mangled symbols.
658 Do the symtabs first, then check the psymtabs. */
660 if (namespace == VAR_NAMESPACE
)
662 ALL_SYMTABS (objfile
, s
)
664 bv
= BLOCKVECTOR (s
);
665 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
666 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
676 ALL_PSYMTABS (objfile
, ps
)
678 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
680 s
= PSYMTAB_TO_SYMTAB(ps
);
681 bv
= BLOCKVECTOR (s
);
682 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
683 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
685 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
698 /* Look, in partial_symtab PST, for symbol NAME. Check the global
699 symbols if GLOBAL, the static symbols if not */
701 static struct partial_symbol
*
702 lookup_partial_symbol (pst
, name
, global
, namespace)
703 struct partial_symtab
*pst
;
706 enum namespace namespace;
708 struct partial_symbol
*start
, *psym
;
709 struct partial_symbol
*top
, *bottom
, *center
;
710 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
711 int do_linear_search
= 1;
719 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
720 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
722 if (global
) /* This means we can use a binary search. */
724 do_linear_search
= 0;
726 /* Binary search. This search is guaranteed to end with center
727 pointing at the earliest partial symbol with the correct
728 name. At that point *all* partial symbols with that name
729 will be checked against the correct namespace. */
732 top
= start
+ length
- 1;
735 center
= bottom
+ (top
- bottom
) / 2;
736 assert (center
< top
);
737 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
739 do_linear_search
= 1;
741 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
750 assert (top
== bottom
);
751 while (STREQ (SYMBOL_NAME (top
), name
))
753 if (SYMBOL_NAMESPACE (top
) == namespace)
761 /* Can't use a binary search or else we found during the binary search that
762 we should also do a linear search. */
764 if (do_linear_search
)
766 for (psym
= start
; psym
< start
+ length
; psym
++)
768 if (namespace == SYMBOL_NAMESPACE (psym
))
770 if (SYMBOL_MATCHES_NAME (psym
, name
))
781 /* Find the psymtab containing main(). */
782 /* FIXME: What about languages without main() or specially linked
783 executables that have no main() ? */
785 struct partial_symtab
*
788 register struct partial_symtab
*pst
;
789 register struct objfile
*objfile
;
791 ALL_PSYMTABS (objfile
, pst
)
793 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
801 /* Search BLOCK for symbol NAME in NAMESPACE.
803 Note that if NAME is the demangled form of a C++ symbol, we will fail
804 to find a match during the binary search of the non-encoded names, but
805 for now we don't worry about the slight inefficiency of looking for
806 a match we'll never find, since it will go pretty quick. Once the
807 binary search terminates, we drop through and do a straight linear
808 search on the symbols. Each symbol which is marked as being a C++
809 symbol (language_cplus set) has both the encoded and non-encoded names
810 tested for a match. */
813 lookup_block_symbol (block
, name
, namespace)
814 register const struct block
*block
;
816 const enum namespace namespace;
818 register int bot
, top
, inc
;
819 register struct symbol
*sym
;
820 register struct symbol
*sym_found
= NULL
;
821 register int do_linear_search
= 1;
823 /* If the blocks's symbols were sorted, start with a binary search. */
825 if (BLOCK_SHOULD_SORT (block
))
827 /* Reset the linear search flag so if the binary search fails, we
828 won't do the linear search once unless we find some reason to
829 do so, such as finding a C++ symbol during the binary search.
830 Note that for C++ modules, ALL the symbols in a block should
831 end up marked as C++ symbols. */
833 do_linear_search
= 0;
834 top
= BLOCK_NSYMS (block
);
837 /* Advance BOT to not far before the first symbol whose name is NAME. */
841 inc
= (top
- bot
+ 1);
842 /* No need to keep binary searching for the last few bits worth. */
847 inc
= (inc
>> 1) + bot
;
848 sym
= BLOCK_SYM (block
, inc
);
849 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
851 do_linear_search
= 1;
853 if (SYMBOL_NAME (sym
)[0] < name
[0])
857 else if (SYMBOL_NAME (sym
)[0] > name
[0])
861 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
871 /* Now scan forward until we run out of symbols, find one whose
872 name is greater than NAME, or find one we want. If there is
873 more than one symbol with the right name and namespace, we
874 return the first one; I believe it is now impossible for us
875 to encounter two symbols with the same name and namespace
876 here, because blocks containing argument symbols are no
879 top
= BLOCK_NSYMS (block
);
882 sym
= BLOCK_SYM (block
, bot
);
883 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
886 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
888 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
900 /* Here if block isn't sorted, or we fail to find a match during the
901 binary search above. If during the binary search above, we find a
902 symbol which is a C++ symbol, then we have re-enabled the linear
903 search flag which was reset when starting the binary search.
905 This loop is equivalent to the loop above, but hacked greatly for speed.
907 Note that parameter symbols do not always show up last in the
908 list; this loop makes sure to take anything else other than
909 parameter symbols first; it only uses parameter symbols as a
910 last resort. Note that this only takes up extra computation
913 if (do_linear_search
)
915 top
= BLOCK_NSYMS (block
);
919 sym
= BLOCK_SYM (block
, bot
);
920 if (SYMBOL_NAMESPACE (sym
) == namespace &&
921 SYMBOL_MATCHES_NAME (sym
, name
))
924 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
925 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
926 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
927 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
928 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
929 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
937 return (sym_found
); /* Will be NULL if not found. */
941 /* Return the symbol for the function which contains a specified
942 lexical block, described by a struct block BL. */
948 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
949 bl
= BLOCK_SUPERBLOCK (bl
);
951 return BLOCK_FUNCTION (bl
);
954 /* Find the symtab associated with PC. Look through the psymtabs and read in
955 another symtab if necessary. */
959 register CORE_ADDR pc
;
961 register struct block
*b
;
962 struct blockvector
*bv
;
963 register struct symtab
*s
= NULL
;
964 register struct symtab
*best_s
= NULL
;
965 register struct partial_symtab
*ps
;
966 register struct objfile
*objfile
;
969 /* Search all symtabs for the one whose file contains our address, and which
970 is the smallest of all the ones containing the address. This is designed
971 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
972 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
973 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
974 This is said to happen for the mips; it might be swifter to create
975 several symtabs with the same name like xcoff does (I'm not sure). */
977 ALL_SYMTABS (objfile
, s
)
979 bv
= BLOCKVECTOR (s
);
980 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
981 if (BLOCK_START (b
) <= pc
982 && BLOCK_END (b
) > pc
984 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
986 distance
= BLOCK_END (b
) - BLOCK_START (b
);
995 ps
= find_pc_psymtab (pc
);
999 /* Might want to error() here (in case symtab is corrupt and
1000 will cause a core dump), but maybe we can successfully
1001 continue, so let's not. */
1003 (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n",
1004 (unsigned long) pc
);
1005 s
= PSYMTAB_TO_SYMTAB (ps
);
1010 /* Find the source file and line number for a given PC value.
1011 Return a structure containing a symtab pointer, a line number,
1012 and a pc range for the entire source line.
1013 The value's .pc field is NOT the specified pc.
1014 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1015 use the line that ends there. Otherwise, in that case, the line
1016 that begins there is used. */
1018 /* The big complication here is that a line may start in one file, and end just
1019 before the start of another file. This usually occurs when you #include
1020 code in the middle of a subroutine. To properly find the end of a line's PC
1021 range, we must search all symtabs associated with this compilation unit, and
1022 find the one whose first PC is closer than that of the next line in this
1025 /* If it's worth the effort, we could be using a binary search. */
1027 struct symtab_and_line
1028 find_pc_line (pc
, notcurrent
)
1033 register struct linetable
*l
;
1036 register struct linetable_entry
*item
;
1037 struct symtab_and_line val
;
1038 struct blockvector
*bv
;
1040 /* Info on best line seen so far, and where it starts, and its file. */
1042 struct linetable_entry
*best
= NULL
;
1043 CORE_ADDR best_end
= 0;
1044 struct symtab
*best_symtab
= 0;
1046 /* Store here the first line number
1047 of a file which contains the line at the smallest pc after PC.
1048 If we don't find a line whose range contains PC,
1049 we will use a line one less than this,
1050 with a range from the start of that file to the first line's pc. */
1051 struct linetable_entry
*alt
= NULL
;
1052 struct symtab
*alt_symtab
= 0;
1054 /* Info on best line seen in this file. */
1056 struct linetable_entry
*prev
;
1058 /* If this pc is not from the current frame,
1059 it is the address of the end of a call instruction.
1060 Quite likely that is the start of the following statement.
1061 But what we want is the statement containing the instruction.
1062 Fudge the pc to make sure we get that. */
1064 if (notcurrent
) pc
-= 1;
1066 s
= find_pc_symtab (pc
);
1076 bv
= BLOCKVECTOR (s
);
1078 /* Look at all the symtabs that share this blockvector.
1079 They all have the same apriori range, that we found was right;
1080 but they have different line tables. */
1082 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1084 /* Find the best line in this symtab. */
1091 /* I think len can be zero if the symtab lacks line numbers
1092 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1093 I'm not sure which, and maybe it depends on the symbol
1099 item
= l
->item
; /* Get first line info */
1101 /* Is this file's first line closer than the first lines of other files?
1102 If so, record this file, and its first line, as best alternate. */
1103 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1109 for (i
= 0; i
< len
; i
++, item
++)
1111 /* Return the last line that did not start after PC. */
1118 /* At this point, prev points at the line whose start addr is <= pc, and
1119 item points at the next line. If we ran off the end of the linetable
1120 (pc >= start of the last line), then prev == item. If pc < start of
1121 the first line, prev will not be set. */
1123 /* Is this file's best line closer than the best in the other files?
1124 If so, record this file, and its best line, as best so far. */
1126 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1130 /* If another line is in the linetable, and its PC is closer
1131 than the best_end we currently have, take it as best_end. */
1132 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1133 best_end
= item
->pc
;
1140 { /* If we didn't find any line # info, just
1149 val
.symtab
= alt_symtab
;
1150 val
.line
= alt
->line
- 1;
1151 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1157 val
.symtab
= best_symtab
;
1158 val
.line
= best
->line
;
1160 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1165 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1170 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1173 /* Find line number LINE in any symtab whose name is the same as
1176 If found, return 1, set *LINETABLE to the linetable in which it was
1177 found, set *INDEX to the index in the linetable of the best entry
1178 found, and set *EXACT_MATCH nonzero if the value returned is an
1181 If not found, return 0. */
1184 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1185 struct symtab
*symtab
;
1187 struct linetable
**linetable
;
1193 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1197 struct linetable
*best_linetable
;
1199 /* First try looking it up in the given symtab. */
1200 best_linetable
= LINETABLE (symtab
);
1201 best_index
= find_line_common (best_linetable
, line
, &exact
);
1202 if (best_index
< 0 || !exact
)
1204 /* Didn't find an exact match. So we better keep looking for
1205 another symtab with the same name. In the case of xcoff,
1206 multiple csects for one source file (produced by IBM's FORTRAN
1207 compiler) produce multiple symtabs (this is unavoidable
1208 assuming csects can be at arbitrary places in memory and that
1209 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1211 /* BEST is the smallest linenumber > LINE so far seen,
1212 or 0 if none has been seen so far.
1213 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1216 struct objfile
*objfile
;
1219 if (best_index
>= 0)
1220 best
= best_linetable
->item
[best_index
].line
;
1224 ALL_SYMTABS (objfile
, s
)
1226 struct linetable
*l
;
1229 if (!STREQ (symtab
->filename
, s
->filename
))
1232 ind
= find_line_common (l
, line
, &exact
);
1241 if (best
== 0 || l
->item
[ind
].line
< best
)
1243 best
= l
->item
[ind
].line
;
1255 *index
= best_index
;
1257 *linetable
= best_linetable
;
1259 *exact_match
= exact
;
1263 /* Find the PC value for a given source file and line number.
1264 Returns zero for invalid line number.
1265 The source file is specified with a struct symtab. */
1268 find_line_pc (symtab
, line
)
1269 struct symtab
*symtab
;
1272 struct linetable
*l
;
1277 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1278 return l
->item
[ind
].pc
;
1283 /* Find the range of pc values in a line.
1284 Store the starting pc of the line into *STARTPTR
1285 and the ending pc (start of next line) into *ENDPTR.
1286 Returns 1 to indicate success.
1287 Returns 0 if could not find the specified line. */
1290 find_line_pc_range (sal
, startptr
, endptr
)
1291 struct symtab_and_line sal
;
1292 CORE_ADDR
*startptr
, *endptr
;
1294 CORE_ADDR startaddr
;
1295 struct symtab_and_line found_sal
;
1300 startaddr
= find_line_pc (sal
.symtab
, sal
.line
);
1305 /* This whole function is based on address. For example, if line 10 has
1306 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1307 "info line *0x123" should say the line goes from 0x100 to 0x200
1308 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1309 This also insures that we never give a range like "starts at 0x134
1310 and ends at 0x12c". */
1312 found_sal
= find_pc_line (startaddr
, 0);
1313 if (found_sal
.line
!= sal
.line
)
1315 /* The specified line (sal) has zero bytes. */
1316 *startptr
= found_sal
.pc
;
1317 *endptr
= found_sal
.pc
;
1321 *startptr
= found_sal
.pc
;
1322 *endptr
= found_sal
.end
;
1327 /* Given a line table and a line number, return the index into the line
1328 table for the pc of the nearest line whose number is >= the specified one.
1329 Return -1 if none is found. The value is >= 0 if it is an index.
1331 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1334 find_line_common (l
, lineno
, exact_match
)
1335 register struct linetable
*l
;
1336 register int lineno
;
1342 /* BEST is the smallest linenumber > LINENO so far seen,
1343 or 0 if none has been seen so far.
1344 BEST_INDEX identifies the item for it. */
1346 int best_index
= -1;
1355 for (i
= 0; i
< len
; i
++)
1357 register struct linetable_entry
*item
= &(l
->item
[i
]);
1359 if (item
->line
== lineno
)
1361 /* Return the first (lowest address) entry which matches. */
1366 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1373 /* If we got here, we didn't get an exact match. */
1380 find_pc_line_pc_range (pc
, startptr
, endptr
)
1382 CORE_ADDR
*startptr
, *endptr
;
1384 struct symtab_and_line sal
;
1385 sal
= find_pc_line (pc
, 0);
1388 return sal
.symtab
!= 0;
1391 /* If P is of the form "operator[ \t]+..." where `...' is
1392 some legitimate operator text, return a pointer to the
1393 beginning of the substring of the operator text.
1394 Otherwise, return "". */
1396 operator_chars (p
, end
)
1401 if (strncmp (p
, "operator", 8))
1405 /* Don't get faked out by `operator' being part of a longer
1407 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1410 /* Allow some whitespace between `operator' and the operator symbol. */
1411 while (*p
== ' ' || *p
== '\t')
1414 /* Recognize 'operator TYPENAME'. */
1416 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1418 register char *q
= p
+1;
1419 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1444 if (p
[1] == '=' || p
[1] == p
[0])
1455 error ("`operator ()' must be specified without whitespace in `()'");
1460 error ("`operator ?:' must be specified without whitespace in `?:'");
1465 error ("`operator []' must be specified without whitespace in `[]'");
1469 error ("`operator %s' not supported", p
);
1476 /* Recursive helper function for decode_line_1.
1477 * Look for methods named NAME in type T.
1478 * Return number of matches.
1479 * Put matches in SYM_ARR (which better be big enough!).
1480 * These allocations seem to define "big enough":
1481 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1482 * Note that this function is g++ specific.
1486 find_methods (t
, name
, sym_arr
)
1489 struct symbol
**sym_arr
;
1493 struct symbol
*sym_class
;
1494 char *class_name
= type_name_no_tag (t
);
1495 /* Ignore this class if it doesn't have a name. This is ugly, but
1496 unless we figure out how to get the physname without the name of
1497 the class, then the loop can't do any good. */
1499 && (sym_class
= lookup_symbol (class_name
,
1500 (struct block
*)NULL
,
1503 (struct symtab
**)NULL
)))
1506 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1507 t
= SYMBOL_TYPE (sym_class
);
1508 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1509 method_counter
>= 0;
1513 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1515 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1516 if (STREQ (name
, method_name
))
1517 /* Find all the fields with that name. */
1518 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1523 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1524 check_stub_method (t
, method_counter
, field_counter
);
1525 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1526 /* Destructor is handled by caller, dont add it to the list */
1527 if (DESTRUCTOR_PREFIX_P (phys_name
))
1530 /* FIXME: Why are we looking this up in the
1531 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1532 for nested types? If so, it should probably hook to the
1533 type, not the symbol. mipsread.c is the only symbol
1534 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1535 this is not documented in symtab.h. -26Aug93. */
1537 sym_arr
[i1
] = lookup_symbol (phys_name
,
1538 SYMBOL_BLOCK_VALUE (sym_class
),
1541 (struct symtab
**) NULL
);
1542 if (sym_arr
[i1
]) i1
++;
1545 fputs_filtered("(Cannot find method ", gdb_stdout
);
1546 fprintf_symbol_filtered (gdb_stdout
, phys_name
,
1547 language_cplus
, DMGL_PARAMS
);
1548 fputs_filtered(" - possibly inlined.)\n", gdb_stdout
);
1554 /* Only search baseclasses if there is no match yet, since names in
1555 derived classes override those in baseclasses.
1557 FIXME: The above is not true; it is only true of member functions
1558 if they have the same number of arguments (??? - section 13.1 of the
1559 ARM says the function members are not in the same scope but doesn't
1560 really spell out the rules in a way I understand. In any case, if
1561 the number of arguments differ this is a case in which we can overload
1562 rather than hiding without any problem, and gcc 2.4.5 does overload
1563 rather than hiding in this case). */
1567 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1568 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1573 /* Helper function for decode_line_1.
1574 Build a canonical line spec in CANONICAL if it is non-NULL and if
1575 the SAL has a symtab.
1576 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1577 If SYMNAME is NULL the line number from SAL is used and the canonical
1578 line spec is `filename:linenum'. */
1581 build_canonical_line_spec (sal
, symname
, canonical
)
1582 struct symtab_and_line
*sal
;
1586 char **canonical_arr
;
1587 char *canonical_name
;
1589 struct symtab
*s
= sal
->symtab
;
1591 if (s
== (struct symtab
*)NULL
1592 || s
->filename
== (char *)NULL
1593 || canonical
== (char ***)NULL
)
1596 canonical_arr
= (char **) xmalloc (sizeof (char *));
1597 *canonical
= canonical_arr
;
1599 filename
= s
->filename
;
1600 if (symname
!= NULL
)
1602 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1603 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1607 canonical_name
= xmalloc (strlen (filename
) + 30);
1608 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1610 canonical_arr
[0] = canonical_name
;
1613 /* Parse a string that specifies a line number.
1614 Pass the address of a char * variable; that variable will be
1615 advanced over the characters actually parsed.
1619 LINENUM -- that line number in current file. PC returned is 0.
1620 FILE:LINENUM -- that line in that file. PC returned is 0.
1621 FUNCTION -- line number of openbrace of that function.
1622 PC returned is the start of the function.
1623 VARIABLE -- line number of definition of that variable.
1625 FILE:FUNCTION -- likewise, but prefer functions in that file.
1626 *EXPR -- line in which address EXPR appears.
1628 FUNCTION may be an undebuggable function found in minimal symbol table.
1630 If the argument FUNFIRSTLINE is nonzero, we want the first line
1631 of real code inside a function when a function is specified.
1633 DEFAULT_SYMTAB specifies the file to use if none is specified.
1634 It defaults to current_source_symtab.
1635 DEFAULT_LINE specifies the line number to use for relative
1636 line numbers (that start with signs). Defaults to current_source_line.
1637 If CANONICAL is non-NULL, store an array of strings containing the canonical
1638 line specs there if necessary. Currently overloaded member functions and
1639 line numbers or static functions without a filename yield a canonical
1640 line spec. The array and the line spec strings are allocated on the heap,
1641 it is the callers responsibility to free them.
1643 Note that it is possible to return zero for the symtab
1644 if no file is validly specified. Callers must check that.
1645 Also, the line number returned may be invalid. */
1647 /* We allow single quotes in various places. This is a hideous
1648 kludge, which exists because the completer can't yet deal with the
1649 lack of single quotes. FIXME: write a linespec_completer which we
1650 can use as appropriate instead of make_symbol_completion_list. */
1652 struct symtabs_and_lines
1653 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1656 struct symtab
*default_symtab
;
1660 struct symtabs_and_lines values
;
1661 #ifdef HPPA_COMPILER_BUG
1662 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1663 when optimizing this file with target i960-vxworks. I haven't
1664 been able to construct a simple test case. The problem is that
1665 in the second call to SKIP_PROLOGUE below, the compiler somehow
1666 does not realize that the statement val = find_pc_line (...) will
1667 change the values of the fields of val. It extracts the elements
1668 into registers at the top of the block, and does not update the
1669 registers after the call to find_pc_line. You can check this by
1670 inserting a printf at the end of find_pc_line to show what values
1671 it is returning for val.pc and val.end and another printf after
1672 the call to see what values the function actually got (remember,
1673 this is compiling with cc -O, with this patch removed). You can
1674 also examine the assembly listing: search for the second call to
1675 skip_prologue; the LDO statement before the next call to
1676 find_pc_line loads the address of the structure which
1677 find_pc_line will return; if there is a LDW just before the LDO,
1678 which fetches an element of the structure, then the compiler
1681 Setting val to volatile avoids the problem. We must undef
1682 volatile, because the HPPA native compiler does not define
1683 __STDC__, although it does understand volatile, and so volatile
1684 will have been defined away in defs.h. */
1686 volatile struct symtab_and_line val
;
1687 #define volatile /*nothing*/
1689 struct symtab_and_line val
;
1691 register char *p
, *p1
;
1693 register struct symtab
*s
;
1695 register struct symbol
*sym
;
1696 /* The symtab that SYM was found in. */
1697 struct symtab
*sym_symtab
;
1699 register CORE_ADDR pc
;
1700 register struct minimal_symbol
*msymbol
;
1702 struct symbol
*sym_class
;
1704 int is_quoted
, has_parens
;
1705 struct symbol
**sym_arr
;
1707 char *saved_arg
= *argptr
;
1708 extern char *gdb_completer_quote_characters
;
1710 /* Defaults have defaults. */
1712 if (default_symtab
== 0)
1714 default_symtab
= current_source_symtab
;
1715 default_line
= current_source_line
;
1718 /* See if arg is *PC */
1720 if (**argptr
== '*')
1722 if (**argptr
== '*')
1726 pc
= parse_and_eval_address_1 (argptr
);
1727 values
.sals
= (struct symtab_and_line
*)
1728 xmalloc (sizeof (struct symtab_and_line
));
1730 values
.sals
[0] = find_pc_line (pc
, 0);
1731 values
.sals
[0].pc
= pc
;
1732 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1736 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1739 is_quoted
= (strchr(gdb_completer_quote_characters
, **argptr
) != NULL
);
1740 has_parens
= (( pp
= strchr(*argptr
, '(')) != NULL
&&
1741 (pp
= strchr(pp
, ')')) != NULL
);
1743 for (p
= *argptr
; *p
; p
++)
1747 while(!++p
&& *p
!= '>');
1750 /* FIXME: Why warning() and then return_to_top_level?
1751 What's wrong with error()? */
1752 warning("non-matching '<' and '>' in command");
1753 return_to_top_level (RETURN_ERROR
);
1756 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1759 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1761 if ((p
[0] == ':') && !has_parens
)
1765 if (is_quoted
) *argptr
= *argptr
+1;
1768 /* Extract the class name. */
1770 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1771 copy
= (char *) alloca (p
- *argptr
+ 1);
1772 memcpy (copy
, *argptr
, p
- *argptr
);
1773 copy
[p
- *argptr
] = 0;
1775 /* Discard the class name from the arg. */
1777 while (*p
== ' ' || *p
== '\t') p
++;
1780 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1781 (struct symtab
**)NULL
);
1784 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1785 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1787 /* Arg token is not digits => try it as a function name
1788 Find the next token (everything up to end or next whitespace). */
1790 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1791 q
= operator_chars (*argptr
, &q1
);
1796 char *tmp
= alloca (q1
- q
+ 1);
1797 memcpy (tmp
, q
, q1
- q
);
1799 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1802 warning ("no mangling for \"%s\"", tmp
);
1803 cplusplus_hint (saved_arg
);
1804 return_to_top_level (RETURN_ERROR
);
1806 copy
= (char*) alloca (3 + strlen(opname
));
1807 sprintf (copy
, "__%s", opname
);
1812 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1813 memcpy (copy
, *argptr
, p
- *argptr
);
1814 copy
[p
- *argptr
] = '\0';
1817 /* no line number may be specified */
1818 while (*p
== ' ' || *p
== '\t') p
++;
1822 i1
= 0; /* counter for the symbol array */
1823 t
= SYMBOL_TYPE (sym_class
);
1824 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1826 /* Cfront objects don't have fieldlists. */
1827 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1829 /* destructors are a special case. */
1830 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1831 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1832 /* gcc 1.x puts destructor in last field,
1833 gcc 2.x puts destructor in first field. */
1834 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1835 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1837 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1838 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1842 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1843 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1844 if (sym_arr
[i1
]) i1
++;
1847 i1
= find_methods (t
, copy
, sym_arr
);
1850 /* There is exactly one field with that name. */
1853 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1855 /* Arg is the name of a function */
1856 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1859 pc
+= FUNCTION_START_OFFSET
;
1862 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1864 values
.sals
[0] = find_pc_line (pc
, 0);
1865 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1875 /* There is more than one field with that name
1876 (overloaded). Ask the user which one to use. */
1877 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1883 if (OPNAME_PREFIX_P (copy
))
1885 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1886 strcpy (tmp
, "operator ");
1887 strcat (tmp
, copy
+3);
1892 warning ("the class `%s' does not have destructor defined",
1893 SYMBOL_SOURCE_NAME(sym_class
));
1895 warning ("the class %s does not have any method named %s",
1896 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1897 cplusplus_hint (saved_arg
);
1898 return_to_top_level (RETURN_ERROR
);
1903 /* The quotes are important if copy is empty. */
1904 warning ("can't find class, struct, or union named \"%s\"",
1906 cplusplus_hint (saved_arg
);
1907 return_to_top_level (RETURN_ERROR
);
1913 /* Extract the file name. */
1915 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1916 copy
= (char *) alloca (p
- *argptr
+ 1);
1917 memcpy (copy
, *argptr
, p
- *argptr
);
1918 copy
[p
- *argptr
] = 0;
1920 /* Find that file's data. */
1921 s
= lookup_symtab (copy
);
1924 if (!have_full_symbols () && !have_partial_symbols ())
1925 error (no_symtab_msg
);
1926 error ("No source file named %s.", copy
);
1929 /* Discard the file name from the arg. */
1931 while (*p
== ' ' || *p
== '\t') p
++;
1935 /* S is specified file's symtab, or 0 if no file specified.
1936 arg no longer contains the file name. */
1938 /* Check whether arg is all digits (and sign) */
1941 if (*p
== '-' || *p
== '+') p
++;
1942 while (*p
>= '0' && *p
<= '9')
1945 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1947 /* We found a token consisting of all digits -- at least one digit. */
1948 enum sign
{none
, plus
, minus
} sign
= none
;
1950 /* We might need a canonical line spec if no file was specified. */
1951 int need_canonical
= (s
== 0) ? 1 : 0;
1953 /* This is where we need to make sure that we have good defaults.
1954 We must guarantee that this section of code is never executed
1955 when we are called with just a function name, since
1956 select_source_symtab calls us with such an argument */
1958 if (s
== 0 && default_symtab
== 0)
1960 select_source_symtab (0);
1961 default_symtab
= current_source_symtab
;
1962 default_line
= current_source_line
;
1965 if (**argptr
== '+')
1966 sign
= plus
, (*argptr
)++;
1967 else if (**argptr
== '-')
1968 sign
= minus
, (*argptr
)++;
1969 val
.line
= atoi (*argptr
);
1976 val
.line
= default_line
+ val
.line
;
1982 val
.line
= default_line
- val
.line
;
1987 break; /* No need to adjust val.line. */
1990 while (*p
== ' ' || *p
== '\t') p
++;
1996 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1997 values
.sals
[0] = val
;
2000 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2004 /* Arg token is not digits => try it as a variable name
2005 Find the next token (everything up to end or next whitespace). */
2009 p
= skip_quoted (*argptr
);
2011 error ("Unmatched single quote.");
2013 else if (has_parens
)
2017 copy
= (char *) alloca (p
- *argptr
+ 1);
2018 memcpy (copy
, *argptr
, p
- *argptr
);
2019 copy
[p
- *argptr
] = '\0';
2020 if ((copy
[0] == copy
[p
- *argptr
- 1])
2021 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
2023 copy
[p
- *argptr
- 1] = '\0';
2026 while (*p
== ' ' || *p
== '\t') p
++;
2029 /* Look up that token as a variable.
2030 If file specified, use that file's per-file block to start with. */
2032 sym
= lookup_symbol (copy
,
2033 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2034 : get_selected_block ()),
2035 VAR_NAMESPACE
, 0, &sym_symtab
);
2039 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2041 /* Arg is the name of a function */
2042 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2045 pc
+= FUNCTION_START_OFFSET
;
2048 val
= find_pc_line (pc
, 0);
2049 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2050 /* Convex: no need to suppress code on first line, if any */
2053 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2054 line is still part of the same function. */
2056 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
2057 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2059 /* First pc of next line */
2061 /* Recalculate the line number (might not be N+1). */
2062 val
= find_pc_line (pc
, 0);
2066 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2067 values
.sals
[0] = val
;
2070 /* Don't use the SYMBOL_LINE; if used at all it points to
2071 the line containing the parameters or thereabouts, not
2072 the first line of code. */
2074 /* We might need a canonical line spec if it is a static
2078 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2079 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2080 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2081 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2085 else if (SYMBOL_LINE (sym
) != 0)
2087 /* We know its line number. */
2088 values
.sals
= (struct symtab_and_line
*)
2089 xmalloc (sizeof (struct symtab_and_line
));
2091 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2092 values
.sals
[0].symtab
= sym_symtab
;
2093 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2097 /* This can happen if it is compiled with a compiler which doesn't
2098 put out line numbers for variables. */
2099 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2100 return? For example, "info line foo" could print the address. */
2101 error ("Line number not known for symbol \"%s\"", copy
);
2104 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2105 if (msymbol
!= NULL
)
2109 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2112 val
.pc
+= FUNCTION_START_OFFSET
;
2113 SKIP_PROLOGUE (val
.pc
);
2115 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2116 values
.sals
[0] = val
;
2121 if (!have_full_symbols () &&
2122 !have_partial_symbols () && !have_minimal_symbols ())
2123 error (no_symtab_msg
);
2125 error ("Function \"%s\" not defined.", copy
);
2126 return values
; /* for lint */
2129 struct symtabs_and_lines
2130 decode_line_spec (string
, funfirstline
)
2134 struct symtabs_and_lines sals
;
2136 error ("Empty line specification.");
2137 sals
= decode_line_1 (&string
, funfirstline
,
2138 current_source_symtab
, current_source_line
,
2141 error ("Junk at end of line specification: %s", string
);
2145 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2146 operate on (ask user if necessary).
2147 If CANONICAL is non-NULL return a corresponding array of mangled names
2148 as canonical line specs there. */
2150 static struct symtabs_and_lines
2151 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2152 struct symbol
*sym_arr
[];
2157 struct symtabs_and_lines values
, return_values
;
2158 register CORE_ADDR pc
;
2163 struct cleanup
*old_chain
;
2164 char **canonical_arr
= (char **)NULL
;
2166 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2167 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2168 old_chain
= make_cleanup (free
, return_values
.sals
);
2172 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2173 make_cleanup (free
, canonical_arr
);
2174 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2175 *canonical
= canonical_arr
;
2179 printf_unfiltered("[0] cancel\n[1] all\n");
2182 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2184 /* Arg is the name of a function */
2185 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]));
2188 pc
+= FUNCTION_START_OFFSET
;
2191 values
.sals
[i
] = find_pc_line (pc
, 0);
2192 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2193 values
.sals
[i
].end
: pc
;
2194 printf_unfiltered("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2195 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2197 else printf_unfiltered ("?HERE\n");
2201 if ((prompt
= getenv ("PS2")) == NULL
)
2205 printf_unfiltered("%s ",prompt
);
2206 gdb_flush(gdb_stdout
);
2208 args
= command_line_input ((char *) NULL
, 0);
2210 if (args
== 0 || *args
== 0)
2211 error_no_arg ("one or more choice numbers");
2219 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2220 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2221 error ("Arguments must be choice numbers.");
2226 error ("cancelled");
2231 for (i
= 0; i
< nelts
; i
++)
2233 if (canonical_arr
[i
] == NULL
)
2235 symname
= SYMBOL_NAME (sym_arr
[i
]);
2236 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2240 memcpy (return_values
.sals
, values
.sals
,
2241 (nelts
* sizeof(struct symtab_and_line
)));
2242 return_values
.nelts
= nelts
;
2243 discard_cleanups (old_chain
);
2244 return return_values
;
2247 if (num
> nelts
+ 2)
2249 printf_unfiltered ("No choice number %d.\n", num
);
2254 if (values
.sals
[num
].pc
)
2258 symname
= SYMBOL_NAME (sym_arr
[num
]);
2259 make_cleanup (free
, symname
);
2260 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2262 return_values
.sals
[i
++] = values
.sals
[num
];
2263 values
.sals
[num
].pc
= 0;
2267 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2272 while (*args
== ' ' || *args
== '\t') args
++;
2274 return_values
.nelts
= i
;
2275 discard_cleanups (old_chain
);
2276 return return_values
;
2280 /* Slave routine for sources_info. Force line breaks at ,'s.
2281 NAME is the name to print and *FIRST is nonzero if this is the first
2282 name printed. Set *FIRST to zero. */
2284 output_source_filename (name
, first
)
2288 /* Table of files printed so far. Since a single source file can
2289 result in several partial symbol tables, we need to avoid printing
2290 it more than once. Note: if some of the psymtabs are read in and
2291 some are not, it gets printed both under "Source files for which
2292 symbols have been read" and "Source files for which symbols will
2293 be read in on demand". I consider this a reasonable way to deal
2294 with the situation. I'm not sure whether this can also happen for
2295 symtabs; it doesn't hurt to check. */
2296 static char **tab
= NULL
;
2297 /* Allocated size of tab in elements.
2298 Start with one 256-byte block (when using GNU malloc.c).
2299 24 is the malloc overhead when range checking is in effect. */
2300 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2301 /* Current size of tab in elements. */
2302 static int tab_cur_size
;
2309 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2313 /* Is NAME in tab? */
2314 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2315 if (STREQ (*p
, name
))
2316 /* Yes; don't print it again. */
2318 /* No; add it to tab. */
2319 if (tab_cur_size
== tab_alloc_size
)
2321 tab_alloc_size
*= 2;
2322 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2324 tab
[tab_cur_size
++] = name
;
2332 printf_filtered (", ");
2336 fputs_filtered (name
, gdb_stdout
);
2340 sources_info (ignore
, from_tty
)
2344 register struct symtab
*s
;
2345 register struct partial_symtab
*ps
;
2346 register struct objfile
*objfile
;
2349 if (!have_full_symbols () && !have_partial_symbols ())
2351 error (no_symtab_msg
);
2354 printf_filtered ("Source files for which symbols have been read in:\n\n");
2357 ALL_SYMTABS (objfile
, s
)
2359 output_source_filename (s
-> filename
, &first
);
2361 printf_filtered ("\n\n");
2363 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2366 ALL_PSYMTABS (objfile
, ps
)
2370 output_source_filename (ps
-> filename
, &first
);
2373 printf_filtered ("\n");
2376 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2377 If CLASS is zero, list all symbols except functions, type names, and
2379 If CLASS is 1, list only functions.
2380 If CLASS is 2, list only type names.
2381 If CLASS is 3, list only method names.
2383 BPT is non-zero if we should set a breakpoint at the functions
2387 list_symbols (regexp
, class, bpt
)
2392 register struct symtab
*s
;
2393 register struct partial_symtab
*ps
;
2394 register struct blockvector
*bv
;
2395 struct blockvector
*prev_bv
= 0;
2396 register struct block
*b
;
2398 register struct symbol
*sym
;
2399 struct partial_symbol
*psym
;
2400 struct objfile
*objfile
;
2401 struct minimal_symbol
*msymbol
;
2403 static char *classnames
[]
2404 = {"variable", "function", "type", "method"};
2405 int found_in_file
= 0;
2407 static enum minimal_symbol_type types
[]
2408 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2409 static enum minimal_symbol_type types2
[]
2410 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2411 enum minimal_symbol_type ourtype
= types
[class];
2412 enum minimal_symbol_type ourtype2
= types2
[class];
2416 /* Make sure spacing is right for C++ operators.
2417 This is just a courtesy to make the matching less sensitive
2418 to how many spaces the user leaves between 'operator'
2419 and <TYPENAME> or <OPERATOR>. */
2421 char *opname
= operator_chars (regexp
, &opend
);
2424 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2425 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2427 /* There should 1 space between 'operator' and 'TYPENAME'. */
2428 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2433 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2434 if (opname
[-1] == ' ')
2437 /* If wrong number of spaces, fix it. */
2440 char *tmp
= (char*) alloca(opend
-opname
+10);
2441 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2446 if (0 != (val
= re_comp (regexp
)))
2447 error ("Invalid regexp (%s): %s", val
, regexp
);
2450 /* Search through the partial symtabs *first* for all symbols
2451 matching the regexp. That way we don't have to reproduce all of
2452 the machinery below. */
2454 ALL_PSYMTABS (objfile
, ps
)
2456 struct partial_symbol
*bound
, *gbound
, *sbound
;
2459 if (ps
->readin
) continue;
2461 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2462 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2465 /* Go through all of the symbols stored in a partial
2466 symtab in one loop. */
2467 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2472 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2474 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2485 /* If it would match (logic taken from loop below)
2486 load the file and go on to the next one */
2487 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2488 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2489 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2490 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2491 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2492 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2494 PSYMTAB_TO_SYMTAB(ps
);
2502 /* Here, we search through the minimal symbol tables for functions that
2503 match, and call find_pc_symtab on them to force their symbols to
2504 be read. The symbol will then be found during the scan of symtabs
2505 below. If find_pc_symtab fails, set found_misc so that we will
2506 rescan to print any matching symbols without debug info. */
2510 ALL_MSYMBOLS (objfile
, msymbol
)
2512 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2513 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2515 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2517 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2526 /* Printout here so as to get after the "Reading in symbols"
2527 messages which will be generated above. */
2529 printf_filtered (regexp
2530 ? "All %ss matching regular expression \"%s\":\n"
2531 : "All defined %ss:\n",
2535 ALL_SYMTABS (objfile
, s
)
2538 bv
= BLOCKVECTOR (s
);
2539 /* Often many files share a blockvector.
2540 Scan each blockvector only once so that
2541 we don't get every symbol many times.
2542 It happens that the first symtab in the list
2543 for any given blockvector is the main file. */
2545 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2547 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2548 /* Skip the sort if this block is always sorted. */
2549 if (!BLOCK_SHOULD_SORT (b
))
2550 sort_block_syms (b
);
2551 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2554 sym
= BLOCK_SYM (b
, j
);
2555 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2556 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2557 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2558 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2559 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2560 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2561 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2565 /* Set a breakpoint here, if it's a function */
2568 /* There may be more than one function with the
2569 same name but in different files. In order to
2570 set breakpoints on all of them, we must give
2571 both the file name and the function name to
2574 (char *) alloca (strlen (s
->filename
)
2575 + strlen (SYMBOL_NAME(sym
))
2577 strcpy (string
, s
->filename
);
2578 strcat (string
, ":");
2579 strcat (string
, SYMBOL_NAME(sym
));
2580 break_command (string
, 0);
2583 else if (!found_in_file
)
2585 fputs_filtered ("\nFile ", gdb_stdout
);
2586 fputs_filtered (s
->filename
, gdb_stdout
);
2587 fputs_filtered (":\n", gdb_stdout
);
2591 if (class != 2 && i
== STATIC_BLOCK
)
2592 printf_filtered ("static ");
2594 /* Typedef that is not a C++ class */
2596 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2597 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2598 /* variable, func, or typedef-that-is-c++-class */
2599 else if (class < 2 ||
2601 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2603 type_print (SYMBOL_TYPE (sym
),
2604 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2605 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2608 printf_filtered (";\n");
2612 # if 0 /* FIXME, why is this zapped out? */
2614 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2616 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2618 sprintf (buf
, " %s::", type_name_no_tag (t
));
2619 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2620 buf
, name
, gdb_stdout
);
2629 /* If there are no eyes, avoid all contact. I mean, if there are
2630 no debug symbols, then print directly from the msymbol_vector. */
2632 if (found_misc
|| class != 1)
2635 ALL_MSYMBOLS (objfile
, msymbol
)
2637 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2638 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2640 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2642 /* Functions: Look up by address. */
2644 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2646 /* Variables/Absolutes: Look up by name */
2647 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2648 (struct block
*) NULL
, VAR_NAMESPACE
,
2649 0, (struct symtab
**) NULL
) == NULL
)
2653 printf_filtered ("\nNon-debugging symbols:\n");
2656 printf_filtered (" %08lx %s\n",
2657 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
2658 SYMBOL_SOURCE_NAME (msymbol
));
2668 variables_info (regexp
, from_tty
)
2672 list_symbols (regexp
, 0, 0);
2676 functions_info (regexp
, from_tty
)
2680 list_symbols (regexp
, 1, 0);
2684 types_info (regexp
, from_tty
)
2688 list_symbols (regexp
, 2, 0);
2692 /* Tiemann says: "info methods was never implemented." */
2694 methods_info (regexp
)
2697 list_symbols (regexp
, 3, 0);
2701 /* Breakpoint all functions matching regular expression. */
2703 rbreak_command (regexp
, from_tty
)
2707 list_symbols (regexp
, 1, 1);
2711 /* Return Nonzero if block a is lexically nested within block b,
2712 or if a and b have the same pc range.
2713 Return zero otherwise. */
2716 struct block
*a
, *b
;
2720 return BLOCK_START (a
) >= BLOCK_START (b
)
2721 && BLOCK_END (a
) <= BLOCK_END (b
);
2725 /* Helper routine for make_symbol_completion_list. */
2727 static int return_val_size
;
2728 static int return_val_index
;
2729 static char **return_val
;
2731 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2733 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2734 /* Put only the mangled name on the list. */ \
2735 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2736 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2737 completion_list_add_name \
2738 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2740 completion_list_add_name \
2741 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2744 /* Test to see if the symbol specified by SYMNAME (which is already
2745 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2746 characters. If so, add it to the current completion list. */
2749 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2759 /* clip symbols that cannot match */
2761 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2766 /* Clip any symbol names that we've already considered. (This is a
2767 time optimization) */
2769 for (i
= 0; i
< return_val_index
; ++i
)
2771 if (STREQ (symname
, return_val
[i
]))
2777 /* We have a match for a completion, so add SYMNAME to the current list
2778 of matches. Note that the name is moved to freshly malloc'd space. */
2782 if (word
== sym_text
)
2784 new = xmalloc (strlen (symname
) + 5);
2785 strcpy (new, symname
);
2787 else if (word
> sym_text
)
2789 /* Return some portion of symname. */
2790 new = xmalloc (strlen (symname
) + 5);
2791 strcpy (new, symname
+ (word
- sym_text
));
2795 /* Return some of SYM_TEXT plus symname. */
2796 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2797 strncpy (new, word
, sym_text
- word
);
2798 new[sym_text
- word
] = '\0';
2799 strcat (new, symname
);
2802 if (return_val_index
+ 3 > return_val_size
)
2804 newsize
= (return_val_size
*= 2) * sizeof (char *);
2805 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2807 return_val
[return_val_index
++] = new;
2808 return_val
[return_val_index
] = NULL
;
2812 /* Return a NULL terminated array of all symbols (regardless of class) which
2813 begin by matching TEXT. If the answer is no symbols, then the return value
2814 is an array which contains only a NULL pointer.
2816 Problem: All of the symbols have to be copied because readline frees them.
2817 I'm not going to worry about this; hopefully there won't be that many. */
2820 make_symbol_completion_list (text
, word
)
2824 register struct symbol
*sym
;
2825 register struct symtab
*s
;
2826 register struct partial_symtab
*ps
;
2827 register struct minimal_symbol
*msymbol
;
2828 register struct objfile
*objfile
;
2829 register struct block
*b
, *surrounding_static_block
= 0;
2831 struct partial_symbol
*psym
;
2832 /* The symbol we are completing on. Points in same buffer as text. */
2834 /* Length of sym_text. */
2837 /* Now look for the symbol we are supposed to complete on.
2838 FIXME: This should be language-specific. */
2842 char *quote_pos
= NULL
;
2844 /* First see if this is a quoted string. */
2846 for (p
= text
; *p
!= '\0'; ++p
)
2848 if (quote_found
!= '\0')
2850 if (*p
== quote_found
)
2851 /* Found close quote. */
2853 else if (*p
== '\\' && p
[1] == quote_found
)
2854 /* A backslash followed by the quote character
2855 doesn't end the string. */
2858 else if (*p
== '\'' || *p
== '"')
2864 if (quote_found
== '\'')
2865 /* A string within single quotes can be a symbol, so complete on it. */
2866 sym_text
= quote_pos
+ 1;
2867 else if (quote_found
== '"')
2868 /* A double-quoted string is never a symbol, nor does it make sense
2869 to complete it any other way. */
2873 /* It is not a quoted string. Break it based on the characters
2874 which are in symbols. */
2877 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2886 sym_text_len
= strlen (sym_text
);
2888 return_val_size
= 100;
2889 return_val_index
= 0;
2890 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2891 return_val
[0] = NULL
;
2893 /* Look through the partial symtabs for all symbols which begin
2894 by matching SYM_TEXT. Add each one that you find to the list. */
2896 ALL_PSYMTABS (objfile
, ps
)
2898 /* If the psymtab's been read in we'll get it when we search
2899 through the blockvector. */
2900 if (ps
->readin
) continue;
2902 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2903 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2904 + ps
->n_global_syms
);
2907 /* If interrupted, then quit. */
2909 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2912 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2913 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2914 + ps
->n_static_syms
);
2918 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2922 /* At this point scan through the misc symbol vectors and add each
2923 symbol you find to the list. Eventually we want to ignore
2924 anything that isn't a text symbol (everything else will be
2925 handled by the psymtab code above). */
2927 ALL_MSYMBOLS (objfile
, msymbol
)
2930 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2933 /* Search upwards from currently selected frame (so that we can
2934 complete on local vars. */
2936 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2938 if (!BLOCK_SUPERBLOCK (b
))
2940 surrounding_static_block
= b
; /* For elmin of dups */
2943 /* Also catch fields of types defined in this places which match our
2944 text string. Only complete on types visible from current context. */
2946 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2948 sym
= BLOCK_SYM (b
, i
);
2949 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2950 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2952 struct type
*t
= SYMBOL_TYPE (sym
);
2953 enum type_code c
= TYPE_CODE (t
);
2955 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2957 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2959 if (TYPE_FIELD_NAME (t
, j
))
2961 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2962 sym_text
, sym_text_len
, text
, word
);
2970 /* Go through the symtabs and check the externs and statics for
2971 symbols which match. */
2973 ALL_SYMTABS (objfile
, s
)
2976 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2977 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2979 sym
= BLOCK_SYM (b
, i
);
2980 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2984 ALL_SYMTABS (objfile
, s
)
2987 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2988 /* Don't do this block twice. */
2989 if (b
== surrounding_static_block
) continue;
2990 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2992 sym
= BLOCK_SYM (b
, i
);
2993 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2997 return (return_val
);
3002 /* Add the type of the symbol sym to the type of the current
3003 function whose block we are in (assumed). The type of
3004 this current function is contained in *TYPE.
3006 This basically works as follows: When we find a function
3007 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
3008 a pointer to its type in the global in_function_type. Every
3009 time we come across a parameter symbol ('p' in its name), then
3010 this procedure adds the name and type of that parameter
3011 to the function type pointed to by *TYPE. (Which should correspond
3012 to in_function_type if it was called correctly).
3014 Note that since we are modifying a type, the result of
3015 lookup_function_type() should be memcpy()ed before calling
3016 this. When not in strict typing mode, the expression
3017 evaluator can choose to ignore this.
3019 Assumption: All of a function's parameter symbols will
3020 appear before another function symbol is found. The parameters
3021 appear in the same order in the argument list as they do in the
3025 add_param_to_type (type
,sym
)
3029 int num
= ++(TYPE_NFIELDS(*type
));
3031 if(TYPE_NFIELDS(*type
)-1)
3032 TYPE_FIELDS(*type
) = (struct field
*)
3033 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
3034 num
*sizeof(struct field
));
3036 TYPE_FIELDS(*type
) = (struct field
*)
3037 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
3039 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
3040 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
3041 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
3042 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
3047 _initialize_symtab ()
3049 add_info ("variables", variables_info
,
3050 "All global and static variable names, or those matching REGEXP.");
3051 add_info ("functions", functions_info
,
3052 "All function names, or those matching REGEXP.");
3054 /* FIXME: This command has at least the following problems:
3055 1. It prints builtin types (in a very strange and confusing fashion).
3056 2. It doesn't print right, e.g. with
3057 typedef struct foo *FOO
3058 type_print prints "FOO" when we want to make it (in this situation)
3059 print "struct foo *".
3060 I also think "ptype" or "whatis" is more likely to be useful (but if
3061 there is much disagreement "info types" can be fixed). */
3062 add_info ("types", types_info
,
3063 "All type names, or those matching REGEXP.");
3066 add_info ("methods", methods_info
,
3067 "All method names, or those matching REGEXP::REGEXP.\n\
3068 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3069 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3072 add_info ("sources", sources_info
,
3073 "Source files in the program.");
3075 add_com ("rbreak", no_class
, rbreak_command
,
3076 "Set a breakpoint for all functions matching REGEXP.");
3078 /* Initialize the one built-in type that isn't language dependent... */
3079 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3080 "<unknown type>", (struct objfile
*) NULL
);