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 struct symtabs_and_lines
1648 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1651 struct symtab
*default_symtab
;
1655 struct symtabs_and_lines values
;
1656 #ifdef HPPA_COMPILER_BUG
1657 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1658 when optimizing this file with target i960-vxworks. I haven't
1659 been able to construct a simple test case. The problem is that
1660 in the second call to SKIP_PROLOGUE below, the compiler somehow
1661 does not realize that the statement val = find_pc_line (...) will
1662 change the values of the fields of val. It extracts the elements
1663 into registers at the top of the block, and does not update the
1664 registers after the call to find_pc_line. You can check this by
1665 inserting a printf at the end of find_pc_line to show what values
1666 it is returning for val.pc and val.end and another printf after
1667 the call to see what values the function actually got (remember,
1668 this is compiling with cc -O, with this patch removed). You can
1669 also examine the assembly listing: search for the second call to
1670 skip_prologue; the LDO statement before the next call to
1671 find_pc_line loads the address of the structure which
1672 find_pc_line will return; if there is a LDW just before the LDO,
1673 which fetches an element of the structure, then the compiler
1676 Setting val to volatile avoids the problem. We must undef
1677 volatile, because the HPPA native compiler does not define
1678 __STDC__, although it does understand volatile, and so volatile
1679 will have been defined away in defs.h. */
1681 volatile struct symtab_and_line val
;
1682 #define volatile /*nothing*/
1684 struct symtab_and_line val
;
1686 register char *p
, *p1
;
1688 register struct symtab
*s
;
1690 register struct symbol
*sym
;
1691 /* The symtab that SYM was found in. */
1692 struct symtab
*sym_symtab
;
1694 register CORE_ADDR pc
;
1695 register struct minimal_symbol
*msymbol
;
1697 struct symbol
*sym_class
;
1700 struct symbol
**sym_arr
;
1702 char *saved_arg
= *argptr
;
1703 extern char *gdb_completer_quote_characters
;
1705 /* Defaults have defaults. */
1707 if (default_symtab
== 0)
1709 default_symtab
= current_source_symtab
;
1710 default_line
= current_source_line
;
1713 /* See if arg is *PC */
1715 if (**argptr
== '*')
1717 if (**argptr
== '*')
1721 pc
= parse_and_eval_address_1 (argptr
);
1722 values
.sals
= (struct symtab_and_line
*)
1723 xmalloc (sizeof (struct symtab_and_line
));
1725 values
.sals
[0] = find_pc_line (pc
, 0);
1726 values
.sals
[0].pc
= pc
;
1727 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1731 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1734 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1736 for (p
= *argptr
; *p
; p
++)
1738 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1741 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1743 if ((p
[0] == ':') && !is_quoted
)
1749 /* Extract the class name. */
1751 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1752 copy
= (char *) alloca (p
- *argptr
+ 1);
1753 memcpy (copy
, *argptr
, p
- *argptr
);
1754 copy
[p
- *argptr
] = 0;
1756 /* Discard the class name from the arg. */
1758 while (*p
== ' ' || *p
== '\t') p
++;
1761 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1762 (struct symtab
**)NULL
);
1765 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1766 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1768 /* Arg token is not digits => try it as a function name
1769 Find the next token (everything up to end or next whitespace). */
1771 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1772 q
= operator_chars (*argptr
, &q1
);
1777 char *tmp
= alloca (q1
- q
+ 1);
1778 memcpy (tmp
, q
, q1
- q
);
1780 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1783 warning ("no mangling for \"%s\"", tmp
);
1784 cplusplus_hint (saved_arg
);
1785 return_to_top_level (RETURN_ERROR
);
1787 copy
= (char*) alloca (3 + strlen(opname
));
1788 sprintf (copy
, "__%s", opname
);
1793 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1794 memcpy (copy
, *argptr
, p
- *argptr
);
1795 copy
[p
- *argptr
] = '\0';
1798 /* no line number may be specified */
1799 while (*p
== ' ' || *p
== '\t') p
++;
1803 i1
= 0; /* counter for the symbol array */
1804 t
= SYMBOL_TYPE (sym_class
);
1805 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1807 /* Cfront objects don't have fieldlists. */
1808 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1810 /* destructors are a special case. */
1811 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1812 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1813 /* gcc 1.x puts destructor in last field,
1814 gcc 2.x puts destructor in first field. */
1815 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1816 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1818 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1819 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1823 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1824 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1825 if (sym_arr
[i1
]) i1
++;
1828 i1
= find_methods (t
, copy
, sym_arr
);
1831 /* There is exactly one field with that name. */
1834 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1836 /* Arg is the name of a function */
1837 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1840 pc
+= FUNCTION_START_OFFSET
;
1843 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1845 values
.sals
[0] = find_pc_line (pc
, 0);
1846 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1856 /* There is more than one field with that name
1857 (overloaded). Ask the user which one to use. */
1858 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1864 if (OPNAME_PREFIX_P (copy
))
1866 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1867 strcpy (tmp
, "operator ");
1868 strcat (tmp
, copy
+3);
1873 warning ("the class `%s' does not have destructor defined",
1874 SYMBOL_SOURCE_NAME(sym_class
));
1876 warning ("the class %s does not have any method named %s",
1877 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1878 cplusplus_hint (saved_arg
);
1879 return_to_top_level (RETURN_ERROR
);
1884 /* The quotes are important if copy is empty. */
1885 warning ("can't find class, struct, or union named \"%s\"",
1887 cplusplus_hint (saved_arg
);
1888 return_to_top_level (RETURN_ERROR
);
1894 /* Extract the file name. */
1896 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1897 copy
= (char *) alloca (p
- *argptr
+ 1);
1898 memcpy (copy
, *argptr
, p
- *argptr
);
1899 copy
[p
- *argptr
] = 0;
1901 /* Find that file's data. */
1902 s
= lookup_symtab (copy
);
1905 if (!have_full_symbols () && !have_partial_symbols ())
1906 error (no_symtab_msg
);
1907 error ("No source file named %s.", copy
);
1910 /* Discard the file name from the arg. */
1912 while (*p
== ' ' || *p
== '\t') p
++;
1916 /* S is specified file's symtab, or 0 if no file specified.
1917 arg no longer contains the file name. */
1919 /* Check whether arg is all digits (and sign) */
1922 if (*p
== '-' || *p
== '+') p
++;
1923 while (*p
>= '0' && *p
<= '9')
1926 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1928 /* We found a token consisting of all digits -- at least one digit. */
1929 enum sign
{none
, plus
, minus
} sign
= none
;
1931 /* We might need a canonical line spec if no file was specified. */
1932 int need_canonical
= (s
== 0) ? 1 : 0;
1934 /* This is where we need to make sure that we have good defaults.
1935 We must guarantee that this section of code is never executed
1936 when we are called with just a function name, since
1937 select_source_symtab calls us with such an argument */
1939 if (s
== 0 && default_symtab
== 0)
1941 select_source_symtab (0);
1942 default_symtab
= current_source_symtab
;
1943 default_line
= current_source_line
;
1946 if (**argptr
== '+')
1947 sign
= plus
, (*argptr
)++;
1948 else if (**argptr
== '-')
1949 sign
= minus
, (*argptr
)++;
1950 val
.line
= atoi (*argptr
);
1957 val
.line
= default_line
+ val
.line
;
1963 val
.line
= default_line
- val
.line
;
1968 break; /* No need to adjust val.line. */
1971 while (*p
== ' ' || *p
== '\t') p
++;
1977 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1978 values
.sals
[0] = val
;
1981 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1985 /* Arg token is not digits => try it as a variable name
1986 Find the next token (everything up to end or next whitespace). */
1988 p
= skip_quoted (*argptr
);
1989 if (is_quoted
&& p
[-1] != '\'')
1990 error ("Unmatched single quote.");
1991 copy
= (char *) alloca (p
- *argptr
+ 1);
1992 memcpy (copy
, *argptr
, p
- *argptr
);
1993 copy
[p
- *argptr
] = '\0';
1994 if ((copy
[0] == copy
[p
- *argptr
- 1])
1995 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1997 copy
[p
- *argptr
- 1] = '\0';
2000 while (*p
== ' ' || *p
== '\t') p
++;
2003 /* Look up that token as a variable.
2004 If file specified, use that file's per-file block to start with. */
2006 sym
= lookup_symbol (copy
,
2007 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2008 : get_selected_block ()),
2009 VAR_NAMESPACE
, 0, &sym_symtab
);
2013 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2015 /* Arg is the name of a function */
2016 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2019 pc
+= FUNCTION_START_OFFSET
;
2022 val
= find_pc_line (pc
, 0);
2023 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2024 /* Convex: no need to suppress code on first line, if any */
2027 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2028 line is still part of the same function. */
2030 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
2031 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2033 /* First pc of next line */
2035 /* Recalculate the line number (might not be N+1). */
2036 val
= find_pc_line (pc
, 0);
2040 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2041 values
.sals
[0] = val
;
2044 /* Don't use the SYMBOL_LINE; if used at all it points to
2045 the line containing the parameters or thereabouts, not
2046 the first line of code. */
2048 /* We might need a canonical line spec if it is a static
2052 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2053 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2054 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2055 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2059 else if (SYMBOL_LINE (sym
) != 0)
2061 /* We know its line number. */
2062 values
.sals
= (struct symtab_and_line
*)
2063 xmalloc (sizeof (struct symtab_and_line
));
2065 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2066 values
.sals
[0].symtab
= sym_symtab
;
2067 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2071 /* This can happen if it is compiled with a compiler which doesn't
2072 put out line numbers for variables. */
2073 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2074 return? For example, "info line foo" could print the address. */
2075 error ("Line number not known for symbol \"%s\"", copy
);
2078 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2079 if (msymbol
!= NULL
)
2083 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2086 val
.pc
+= FUNCTION_START_OFFSET
;
2087 SKIP_PROLOGUE (val
.pc
);
2089 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2090 values
.sals
[0] = val
;
2095 if (!have_full_symbols () &&
2096 !have_partial_symbols () && !have_minimal_symbols ())
2097 error (no_symtab_msg
);
2099 error ("Function \"%s\" not defined.", copy
);
2100 return values
; /* for lint */
2103 struct symtabs_and_lines
2104 decode_line_spec (string
, funfirstline
)
2108 struct symtabs_and_lines sals
;
2110 error ("Empty line specification.");
2111 sals
= decode_line_1 (&string
, funfirstline
,
2112 current_source_symtab
, current_source_line
,
2115 error ("Junk at end of line specification: %s", string
);
2119 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2120 operate on (ask user if necessary).
2121 If CANONICAL is non-NULL return a corresponding array of mangled names
2122 as canonical line specs there. */
2124 static struct symtabs_and_lines
2125 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2126 struct symbol
*sym_arr
[];
2131 struct symtabs_and_lines values
, return_values
;
2132 register CORE_ADDR pc
;
2137 struct cleanup
*old_chain
;
2138 char **canonical_arr
= (char **)NULL
;
2140 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2141 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2142 old_chain
= make_cleanup (free
, return_values
.sals
);
2146 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2147 make_cleanup (free
, canonical_arr
);
2148 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2149 *canonical
= canonical_arr
;
2153 printf_unfiltered("[0] cancel\n[1] all\n");
2156 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2158 /* Arg is the name of a function */
2159 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]));
2162 pc
+= FUNCTION_START_OFFSET
;
2165 values
.sals
[i
] = find_pc_line (pc
, 0);
2166 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2167 values
.sals
[i
].end
: pc
;
2168 printf_unfiltered("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2169 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2171 else printf_unfiltered ("?HERE\n");
2175 if ((prompt
= getenv ("PS2")) == NULL
)
2179 printf_unfiltered("%s ",prompt
);
2180 gdb_flush(gdb_stdout
);
2182 args
= command_line_input ((char *) NULL
, 0);
2184 if (args
== 0 || *args
== 0)
2185 error_no_arg ("one or more choice numbers");
2193 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2194 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2195 error ("Arguments must be choice numbers.");
2200 error ("cancelled");
2205 for (i
= 0; i
< nelts
; i
++)
2207 if (canonical_arr
[i
] == NULL
)
2209 symname
= SYMBOL_NAME (sym_arr
[i
]);
2210 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2214 memcpy (return_values
.sals
, values
.sals
,
2215 (nelts
* sizeof(struct symtab_and_line
)));
2216 return_values
.nelts
= nelts
;
2217 discard_cleanups (old_chain
);
2218 return return_values
;
2221 if (num
> nelts
+ 2)
2223 printf_unfiltered ("No choice number %d.\n", num
);
2228 if (values
.sals
[num
].pc
)
2232 symname
= SYMBOL_NAME (sym_arr
[num
]);
2233 make_cleanup (free
, symname
);
2234 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2236 return_values
.sals
[i
++] = values
.sals
[num
];
2237 values
.sals
[num
].pc
= 0;
2241 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2246 while (*args
== ' ' || *args
== '\t') args
++;
2248 return_values
.nelts
= i
;
2249 discard_cleanups (old_chain
);
2250 return return_values
;
2254 /* Slave routine for sources_info. Force line breaks at ,'s.
2255 NAME is the name to print and *FIRST is nonzero if this is the first
2256 name printed. Set *FIRST to zero. */
2258 output_source_filename (name
, first
)
2262 /* Table of files printed so far. Since a single source file can
2263 result in several partial symbol tables, we need to avoid printing
2264 it more than once. Note: if some of the psymtabs are read in and
2265 some are not, it gets printed both under "Source files for which
2266 symbols have been read" and "Source files for which symbols will
2267 be read in on demand". I consider this a reasonable way to deal
2268 with the situation. I'm not sure whether this can also happen for
2269 symtabs; it doesn't hurt to check. */
2270 static char **tab
= NULL
;
2271 /* Allocated size of tab in elements.
2272 Start with one 256-byte block (when using GNU malloc.c).
2273 24 is the malloc overhead when range checking is in effect. */
2274 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2275 /* Current size of tab in elements. */
2276 static int tab_cur_size
;
2283 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2287 /* Is NAME in tab? */
2288 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2289 if (STREQ (*p
, name
))
2290 /* Yes; don't print it again. */
2292 /* No; add it to tab. */
2293 if (tab_cur_size
== tab_alloc_size
)
2295 tab_alloc_size
*= 2;
2296 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2298 tab
[tab_cur_size
++] = name
;
2306 printf_filtered (", ");
2310 fputs_filtered (name
, gdb_stdout
);
2314 sources_info (ignore
, from_tty
)
2318 register struct symtab
*s
;
2319 register struct partial_symtab
*ps
;
2320 register struct objfile
*objfile
;
2323 if (!have_full_symbols () && !have_partial_symbols ())
2325 error (no_symtab_msg
);
2328 printf_filtered ("Source files for which symbols have been read in:\n\n");
2331 ALL_SYMTABS (objfile
, s
)
2333 output_source_filename (s
-> filename
, &first
);
2335 printf_filtered ("\n\n");
2337 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2340 ALL_PSYMTABS (objfile
, ps
)
2344 output_source_filename (ps
-> filename
, &first
);
2347 printf_filtered ("\n");
2350 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2351 If CLASS is zero, list all symbols except functions, type names, and
2353 If CLASS is 1, list only functions.
2354 If CLASS is 2, list only type names.
2355 If CLASS is 3, list only method names.
2357 BPT is non-zero if we should set a breakpoint at the functions
2361 list_symbols (regexp
, class, bpt
)
2366 register struct symtab
*s
;
2367 register struct partial_symtab
*ps
;
2368 register struct blockvector
*bv
;
2369 struct blockvector
*prev_bv
= 0;
2370 register struct block
*b
;
2372 register struct symbol
*sym
;
2373 struct partial_symbol
*psym
;
2374 struct objfile
*objfile
;
2375 struct minimal_symbol
*msymbol
;
2377 static char *classnames
[]
2378 = {"variable", "function", "type", "method"};
2379 int found_in_file
= 0;
2381 static enum minimal_symbol_type types
[]
2382 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2383 static enum minimal_symbol_type types2
[]
2384 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2385 enum minimal_symbol_type ourtype
= types
[class];
2386 enum minimal_symbol_type ourtype2
= types2
[class];
2390 /* Make sure spacing is right for C++ operators.
2391 This is just a courtesy to make the matching less sensitive
2392 to how many spaces the user leaves between 'operator'
2393 and <TYPENAME> or <OPERATOR>. */
2395 char *opname
= operator_chars (regexp
, &opend
);
2398 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2399 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2401 /* There should 1 space between 'operator' and 'TYPENAME'. */
2402 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2407 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2408 if (opname
[-1] == ' ')
2411 /* If wrong number of spaces, fix it. */
2414 char *tmp
= (char*) alloca(opend
-opname
+10);
2415 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2420 if (0 != (val
= re_comp (regexp
)))
2421 error ("Invalid regexp (%s): %s", val
, regexp
);
2424 /* Search through the partial symtabs *first* for all symbols
2425 matching the regexp. That way we don't have to reproduce all of
2426 the machinery below. */
2428 ALL_PSYMTABS (objfile
, ps
)
2430 struct partial_symbol
*bound
, *gbound
, *sbound
;
2433 if (ps
->readin
) continue;
2435 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2436 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2439 /* Go through all of the symbols stored in a partial
2440 symtab in one loop. */
2441 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2446 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2448 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2459 /* If it would match (logic taken from loop below)
2460 load the file and go on to the next one */
2461 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2462 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2463 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2464 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2465 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2466 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2468 PSYMTAB_TO_SYMTAB(ps
);
2476 /* Here, we search through the minimal symbol tables for functions that
2477 match, and call find_pc_symtab on them to force their symbols to
2478 be read. The symbol will then be found during the scan of symtabs
2479 below. If find_pc_symtab fails, set found_misc so that we will
2480 rescan to print any matching symbols without debug info. */
2484 ALL_MSYMBOLS (objfile
, msymbol
)
2486 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2487 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2489 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2491 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2500 /* Printout here so as to get after the "Reading in symbols"
2501 messages which will be generated above. */
2503 printf_filtered (regexp
2504 ? "All %ss matching regular expression \"%s\":\n"
2505 : "All defined %ss:\n",
2509 ALL_SYMTABS (objfile
, s
)
2512 bv
= BLOCKVECTOR (s
);
2513 /* Often many files share a blockvector.
2514 Scan each blockvector only once so that
2515 we don't get every symbol many times.
2516 It happens that the first symtab in the list
2517 for any given blockvector is the main file. */
2519 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2521 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2522 /* Skip the sort if this block is always sorted. */
2523 if (!BLOCK_SHOULD_SORT (b
))
2524 sort_block_syms (b
);
2525 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2528 sym
= BLOCK_SYM (b
, j
);
2529 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2530 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2531 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2532 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2533 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2534 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2535 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2539 /* Set a breakpoint here, if it's a function */
2542 /* There may be more than one function with the
2543 same name but in different files. In order to
2544 set breakpoints on all of them, we must give
2545 both the file name and the function name to
2548 (char *) alloca (strlen (s
->filename
)
2549 + strlen (SYMBOL_NAME(sym
))
2551 strcpy (string
, s
->filename
);
2552 strcat (string
, ":");
2553 strcat (string
, SYMBOL_NAME(sym
));
2554 break_command (string
, 0);
2557 else if (!found_in_file
)
2559 fputs_filtered ("\nFile ", gdb_stdout
);
2560 fputs_filtered (s
->filename
, gdb_stdout
);
2561 fputs_filtered (":\n", gdb_stdout
);
2565 if (class != 2 && i
== STATIC_BLOCK
)
2566 printf_filtered ("static ");
2568 /* Typedef that is not a C++ class */
2570 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2571 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2572 /* variable, func, or typedef-that-is-c++-class */
2573 else if (class < 2 ||
2575 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2577 type_print (SYMBOL_TYPE (sym
),
2578 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2579 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2582 printf_filtered (";\n");
2586 # if 0 /* FIXME, why is this zapped out? */
2588 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2590 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2592 sprintf (buf
, " %s::", type_name_no_tag (t
));
2593 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2594 buf
, name
, gdb_stdout
);
2603 /* If there are no eyes, avoid all contact. I mean, if there are
2604 no debug symbols, then print directly from the msymbol_vector. */
2606 if (found_misc
|| class != 1)
2609 ALL_MSYMBOLS (objfile
, msymbol
)
2611 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2612 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2614 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2616 /* Functions: Look up by address. */
2618 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2620 /* Variables/Absolutes: Look up by name */
2621 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2622 (struct block
*) NULL
, VAR_NAMESPACE
,
2623 0, (struct symtab
**) NULL
) == NULL
)
2627 printf_filtered ("\nNon-debugging symbols:\n");
2630 printf_filtered (" %08lx %s\n",
2631 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
2632 SYMBOL_SOURCE_NAME (msymbol
));
2642 variables_info (regexp
, from_tty
)
2646 list_symbols (regexp
, 0, 0);
2650 functions_info (regexp
, from_tty
)
2654 list_symbols (regexp
, 1, 0);
2658 types_info (regexp
, from_tty
)
2662 list_symbols (regexp
, 2, 0);
2666 /* Tiemann says: "info methods was never implemented." */
2668 methods_info (regexp
)
2671 list_symbols (regexp
, 3, 0);
2675 /* Breakpoint all functions matching regular expression. */
2677 rbreak_command (regexp
, from_tty
)
2681 list_symbols (regexp
, 1, 1);
2685 /* Return Nonzero if block a is lexically nested within block b,
2686 or if a and b have the same pc range.
2687 Return zero otherwise. */
2690 struct block
*a
, *b
;
2694 return BLOCK_START (a
) >= BLOCK_START (b
)
2695 && BLOCK_END (a
) <= BLOCK_END (b
);
2699 /* Helper routine for make_symbol_completion_list. */
2701 static int return_val_size
;
2702 static int return_val_index
;
2703 static char **return_val
;
2705 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2707 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2708 /* Put only the mangled name on the list. */ \
2709 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2710 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2711 completion_list_add_name \
2712 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2714 completion_list_add_name \
2715 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2718 /* Test to see if the symbol specified by SYMNAME (which is already
2719 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2720 characters. If so, add it to the current completion list. */
2723 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2733 /* clip symbols that cannot match */
2735 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2740 /* Clip any symbol names that we've already considered. (This is a
2741 time optimization) */
2743 for (i
= 0; i
< return_val_index
; ++i
)
2745 if (STREQ (symname
, return_val
[i
]))
2751 /* We have a match for a completion, so add SYMNAME to the current list
2752 of matches. Note that the name is moved to freshly malloc'd space. */
2756 if (word
== sym_text
)
2758 new = xmalloc (strlen (symname
) + 5);
2759 strcpy (new, symname
);
2761 else if (word
> sym_text
)
2763 /* Return some portion of symname. */
2764 new = xmalloc (strlen (symname
) + 5);
2765 strcpy (new, symname
+ (word
- sym_text
));
2769 /* Return some of SYM_TEXT plus symname. */
2770 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2771 strncpy (new, word
, sym_text
- word
);
2772 new[sym_text
- word
] = '\0';
2773 strcat (new, symname
);
2776 if (return_val_index
+ 3 > return_val_size
)
2778 newsize
= (return_val_size
*= 2) * sizeof (char *);
2779 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2781 return_val
[return_val_index
++] = new;
2782 return_val
[return_val_index
] = NULL
;
2786 /* Return a NULL terminated array of all symbols (regardless of class) which
2787 begin by matching TEXT. If the answer is no symbols, then the return value
2788 is an array which contains only a NULL pointer.
2790 Problem: All of the symbols have to be copied because readline frees them.
2791 I'm not going to worry about this; hopefully there won't be that many. */
2794 make_symbol_completion_list (text
, word
)
2798 register struct symbol
*sym
;
2799 register struct symtab
*s
;
2800 register struct partial_symtab
*ps
;
2801 register struct minimal_symbol
*msymbol
;
2802 register struct objfile
*objfile
;
2803 register struct block
*b
, *surrounding_static_block
= 0;
2805 struct partial_symbol
*psym
;
2806 /* The symbol we are completing on. Points in same buffer as text. */
2808 /* Length of sym_text. */
2811 /* Now look for the symbol we are supposed to complete on.
2812 FIXME: This should be language-specific. */
2816 char *quote_pos
= NULL
;
2818 /* First see if this is a quoted string. */
2820 for (p
= text
; *p
!= '\0'; ++p
)
2822 if (quote_found
!= '\0')
2824 if (*p
== quote_found
)
2825 /* Found close quote. */
2827 else if (*p
== '\\' && p
[1] == quote_found
)
2828 /* A backslash followed by the quote character
2829 doesn't end the string. */
2832 else if (*p
== '\'' || *p
== '"')
2838 if (quote_found
== '\'')
2839 /* A string within single quotes can be a symbol, so complete on it. */
2840 sym_text
= quote_pos
+ 1;
2841 else if (quote_found
== '"')
2842 /* A double-quoted string is never a symbol, nor does it make sense
2843 to complete it any other way. */
2847 /* It is not a quoted string. Break it based on the characters
2848 which are in symbols. */
2851 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2860 sym_text_len
= strlen (sym_text
);
2862 return_val_size
= 100;
2863 return_val_index
= 0;
2864 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2865 return_val
[0] = NULL
;
2867 /* Look through the partial symtabs for all symbols which begin
2868 by matching SYM_TEXT. Add each one that you find to the list. */
2870 ALL_PSYMTABS (objfile
, ps
)
2872 /* If the psymtab's been read in we'll get it when we search
2873 through the blockvector. */
2874 if (ps
->readin
) continue;
2876 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2877 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2878 + ps
->n_global_syms
);
2881 /* If interrupted, then quit. */
2883 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2886 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2887 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2888 + ps
->n_static_syms
);
2892 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2896 /* At this point scan through the misc symbol vectors and add each
2897 symbol you find to the list. Eventually we want to ignore
2898 anything that isn't a text symbol (everything else will be
2899 handled by the psymtab code above). */
2901 ALL_MSYMBOLS (objfile
, msymbol
)
2904 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2907 /* Search upwards from currently selected frame (so that we can
2908 complete on local vars. */
2910 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2912 if (!BLOCK_SUPERBLOCK (b
))
2914 surrounding_static_block
= b
; /* For elmin of dups */
2917 /* Also catch fields of types defined in this places which match our
2918 text string. Only complete on types visible from current context. */
2920 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2922 sym
= BLOCK_SYM (b
, i
);
2923 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2924 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2926 struct type
*t
= SYMBOL_TYPE (sym
);
2927 enum type_code c
= TYPE_CODE (t
);
2929 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2931 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2933 if (TYPE_FIELD_NAME (t
, j
))
2935 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2936 sym_text
, sym_text_len
, text
, word
);
2944 /* Go through the symtabs and check the externs and statics for
2945 symbols which match. */
2947 ALL_SYMTABS (objfile
, s
)
2950 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2951 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2953 sym
= BLOCK_SYM (b
, i
);
2954 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2958 ALL_SYMTABS (objfile
, s
)
2961 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2962 /* Don't do this block twice. */
2963 if (b
== surrounding_static_block
) continue;
2964 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2966 sym
= BLOCK_SYM (b
, i
);
2967 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2971 return (return_val
);
2976 /* Add the type of the symbol sym to the type of the current
2977 function whose block we are in (assumed). The type of
2978 this current function is contained in *TYPE.
2980 This basically works as follows: When we find a function
2981 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2982 a pointer to its type in the global in_function_type. Every
2983 time we come across a parameter symbol ('p' in its name), then
2984 this procedure adds the name and type of that parameter
2985 to the function type pointed to by *TYPE. (Which should correspond
2986 to in_function_type if it was called correctly).
2988 Note that since we are modifying a type, the result of
2989 lookup_function_type() should be memcpy()ed before calling
2990 this. When not in strict typing mode, the expression
2991 evaluator can choose to ignore this.
2993 Assumption: All of a function's parameter symbols will
2994 appear before another function symbol is found. The parameters
2995 appear in the same order in the argument list as they do in the
2999 add_param_to_type (type
,sym
)
3003 int num
= ++(TYPE_NFIELDS(*type
));
3005 if(TYPE_NFIELDS(*type
)-1)
3006 TYPE_FIELDS(*type
) = (struct field
*)
3007 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
3008 num
*sizeof(struct field
));
3010 TYPE_FIELDS(*type
) = (struct field
*)
3011 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
3013 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
3014 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
3015 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
3016 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
3021 _initialize_symtab ()
3023 add_info ("variables", variables_info
,
3024 "All global and static variable names, or those matching REGEXP.");
3025 add_info ("functions", functions_info
,
3026 "All function names, or those matching REGEXP.");
3028 /* FIXME: This command has at least the following problems:
3029 1. It prints builtin types (in a very strange and confusing fashion).
3030 2. It doesn't print right, e.g. with
3031 typedef struct foo *FOO
3032 type_print prints "FOO" when we want to make it (in this situation)
3033 print "struct foo *".
3034 I also think "ptype" or "whatis" is more likely to be useful (but if
3035 there is much disagreement "info types" can be fixed). */
3036 add_info ("types", types_info
,
3037 "All type names, or those matching REGEXP.");
3040 add_info ("methods", methods_info
,
3041 "All method names, or those matching REGEXP::REGEXP.\n\
3042 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3043 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3046 add_info ("sources", sources_info
,
3047 "Source files in the program.");
3049 add_com ("rbreak", no_class
, rbreak_command
,
3050 "Set a breakpoint for all functions matching REGEXP.");
3052 /* Initialize the one built-in type that isn't language dependent... */
3053 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3054 "<unknown type>", (struct objfile
*) NULL
);