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 ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
115 printf ("(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 ALL_PSYMTABS (objfile
, ps
)
160 if (STREQ (name
, ps
-> filename
))
164 ALL_PSYMTABS (objfile
, ps
)
166 char *p
= ps
-> filename
;
167 char *tail
= strrchr (p
, '/');
181 error ("Internal: readin %s pst for `%s' found when no symtab found.",
182 ps
-> filename
, name
);
184 s
= PSYMTAB_TO_SYMTAB (ps
);
189 /* At this point, we have located the psymtab for this file, but
190 the conversion to a symtab has failed. This usually happens
191 when we are looking up an include file. In this case,
192 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
193 been created. So, we need to run through the symtabs again in
194 order to find the file.
195 XXX - This is a crock, and should be fixed inside of the the
196 symbol parsing routines. */
200 /* Lookup the symbol table of a source file named NAME. Try a couple
201 of variations if the first lookup doesn't work. */
207 register struct symtab
*s
;
210 s
= lookup_symtab_1 (name
);
213 /* If name not found as specified, see if adding ".c" helps. */
215 copy
= (char *) alloca (strlen (name
) + 3);
218 s
= lookup_symtab_1 (copy
);
221 /* We didn't find anything; die. */
225 /* Lookup the partial symbol table of a source file named NAME. This
226 only returns true on an exact match (ie. this semantics are
227 different from lookup_symtab. */
229 struct partial_symtab
*
230 lookup_partial_symtab (name
)
233 register struct partial_symtab
*pst
;
234 register struct objfile
*objfile
;
236 ALL_PSYMTABS (objfile
, pst
)
238 if (STREQ (name
, pst
-> filename
))
246 /* Demangle a GDB method stub type.
247 Note that this function is g++ specific. */
250 gdb_mangle_name (type
, i
, j
)
254 int mangled_name_len
;
256 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
257 struct fn_field
*method
= &f
[j
];
258 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
259 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
260 char *newname
= type_name_no_tag (type
);
261 int is_constructor
= newname
!= NULL
&& STREQ (field_name
, newname
);
262 int is_destructor
= is_constructor
&& DESTRUCTOR_PREFIX_P (physname
);
263 /* Need a new type prefix. */
264 char *const_prefix
= method
->is_const
? "C" : "";
265 char *volatile_prefix
= method
->is_volatile
? "V" : "";
267 #ifndef GCC_MANGLE_BUG
268 int len
= newname
== NULL
? 0 : strlen (newname
);
272 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
273 strcpy(mangled_name
, physname
);
277 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
278 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
283 /* Only needed for GNU-mangled names. ANSI-mangled names
284 work with the normal mechanisms. */
285 if (OPNAME_PREFIX_P (field_name
))
287 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
289 error ("No mangling for \"%s\"", field_name
);
290 mangled_name_len
+= strlen (opname
);
291 mangled_name
= (char *)xmalloc (mangled_name_len
);
293 strncpy (mangled_name
, field_name
, 3);
294 mangled_name
[3] = '\0';
295 strcat (mangled_name
, opname
);
299 mangled_name
= (char *)xmalloc (mangled_name_len
);
301 mangled_name
[0] = '\0';
303 strcpy (mangled_name
, field_name
);
305 strcat (mangled_name
, buf
);
306 /* If the class doesn't have a name, i.e. newname NULL, then we just
307 mangle it using 0 for the length of the class. Thus it gets mangled
308 as something starting with `::' rather than `classname::'. */
310 strcat (mangled_name
, newname
);
320 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
323 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
324 + strlen (buf
) + strlen (physname
) + 1);
326 /* Only needed for GNU-mangled names. ANSI-mangled names
327 work with the normal mechanisms. */
328 if (OPNAME_PREFIX_P (field_name
))
330 opname
= cplus_mangle_opname (field_name
+ 3, 0);
333 error ("No mangling for \"%s\"", field_name
);
335 mangled_name_len
+= strlen (opname
);
336 mangled_name
= (char *) xmalloc (mangled_name_len
);
338 strncpy (mangled_name
, field_name
, 3);
339 strcpy (mangled_name
+ 3, opname
);
343 mangled_name
= (char *) xmalloc (mangled_name_len
);
346 mangled_name
[0] = '\0';
350 strcpy (mangled_name
, field_name
);
353 strcat (mangled_name
, buf
);
356 strcat (mangled_name
, physname
);
357 return (mangled_name
);
361 /* Find which partial symtab on contains PC. Return 0 if none. */
363 struct partial_symtab
*
365 register CORE_ADDR pc
;
367 register struct partial_symtab
*pst
;
368 register struct objfile
*objfile
;
370 ALL_PSYMTABS (objfile
, pst
)
372 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
378 /* Find which partial symbol within a psymtab contains PC. Return 0
379 if none. Check all psymtabs if PSYMTAB is 0. */
380 struct partial_symbol
*
381 find_pc_psymbol (psymtab
, pc
)
382 struct partial_symtab
*psymtab
;
385 struct partial_symbol
*best
, *p
;
389 psymtab
= find_pc_psymtab (pc
);
393 best_pc
= psymtab
->textlow
- 1;
395 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
396 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
397 < psymtab
->n_static_syms
);
399 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
400 && SYMBOL_CLASS (p
) == LOC_BLOCK
401 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
402 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
404 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
407 if (best_pc
== psymtab
->textlow
- 1)
413 /* Find the definition for a specified symbol name NAME
414 in namespace NAMESPACE, visible from lexical block BLOCK.
415 Returns the struct symbol pointer, or zero if no symbol is found.
416 If SYMTAB is non-NULL, store the symbol table in which the
417 symbol was found there, or NULL if not found.
418 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
419 NAME is a field of the current implied argument `this'. If so set
420 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
421 BLOCK_FOUND is set to the block in which NAME is found (in the case of
422 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
425 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
427 register const struct block
*block
;
428 const enum namespace namespace;
429 int *is_a_field_of_this
;
430 struct symtab
**symtab
;
432 register struct symbol
*sym
;
433 register struct symtab
*s
;
434 register struct partial_symtab
*ps
;
435 struct blockvector
*bv
;
436 register struct objfile
*objfile
;
437 register struct block
*b
;
438 register struct minimal_symbol
*msymbol
;
440 /* Search specified block and its superiors. */
444 sym
= lookup_block_symbol (block
, name
, namespace);
450 /* Search the list of symtabs for one which contains the
451 address of the start of this block. */
452 ALL_SYMTABS (objfile
, s
)
454 bv
= BLOCKVECTOR (s
);
455 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
456 if (BLOCK_START (b
) <= BLOCK_START (block
)
457 && BLOCK_END (b
) > BLOCK_START (block
))
466 block
= BLOCK_SUPERBLOCK (block
);
469 /* FIXME: this code is never executed--block is always NULL at this
470 point. What is it trying to do, anyway? We already should have
471 checked the STATIC_BLOCK above (it is the superblock of top-level
472 blocks). Why is VAR_NAMESPACE special-cased? */
473 /* Don't need to mess with the psymtabs; if we have a block,
474 that file is read in. If we don't, then we deal later with
475 all the psymtab stuff that needs checking. */
476 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
479 /* Find the right symtab. */
480 ALL_SYMTABS (objfile
, s
)
482 bv
= BLOCKVECTOR (s
);
483 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
484 if (BLOCK_START (b
) <= BLOCK_START (block
)
485 && BLOCK_END (b
) > BLOCK_START (block
))
487 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
500 /* C++: If requested to do so by the caller,
501 check to see if NAME is a field of `this'. */
502 if (is_a_field_of_this
)
504 struct value
*v
= value_of_this (0);
506 *is_a_field_of_this
= 0;
507 if (v
&& check_field (v
, name
))
509 *is_a_field_of_this
= 1;
516 /* Now search all global blocks. Do the symtab's first, then
517 check the psymtab's */
519 ALL_SYMTABS (objfile
, s
)
521 bv
= BLOCKVECTOR (s
);
522 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
523 sym
= lookup_block_symbol (block
, name
, namespace);
533 /* Check for the possibility of the symbol being a global function
534 that is stored in one of the minimal symbol tables. Eventually, all
535 global symbols might be resolved in this way. */
537 if (namespace == VAR_NAMESPACE
)
539 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
542 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
543 /* If S is NULL, there are no debug symbols for this file.
544 Skip this stuff and check for matching static symbols below. */
547 bv
= BLOCKVECTOR (s
);
548 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
549 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
551 /* We kept static functions in minimal symbol table as well as
552 in static scope. We want to find them in the symbol table. */
554 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
555 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
559 /* sym == 0 if symbol was found in the minimal symbol table
560 but not in the symtab.
561 Return 0 to use the msymbol definition of "foo_".
563 This happens for Fortran "foo_" symbols,
564 which are "foo" in the symtab.
566 This can also happen if "asm" is used to make a
567 regular symbol but not a debugging symbol, e.g.
579 ALL_PSYMTABS (objfile
, ps
)
581 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
583 s
= PSYMTAB_TO_SYMTAB(ps
);
584 bv
= BLOCKVECTOR (s
);
585 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
586 sym
= lookup_block_symbol (block
, name
, namespace);
588 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
595 /* Now search all per-file blocks.
596 Not strictly correct, but more useful than an error.
597 Do the symtabs first, then check the psymtabs */
599 ALL_SYMTABS (objfile
, s
)
601 bv
= BLOCKVECTOR (s
);
602 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
603 sym
= lookup_block_symbol (block
, name
, namespace);
613 ALL_PSYMTABS (objfile
, ps
)
615 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
617 s
= PSYMTAB_TO_SYMTAB(ps
);
618 bv
= BLOCKVECTOR (s
);
619 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
620 sym
= lookup_block_symbol (block
, name
, namespace);
622 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
629 /* Now search all per-file blocks for static mangled symbols.
630 Do the symtabs first, then check the psymtabs. */
632 if (namespace == VAR_NAMESPACE
)
634 ALL_SYMTABS (objfile
, s
)
636 bv
= BLOCKVECTOR (s
);
637 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
638 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
648 ALL_PSYMTABS (objfile
, ps
)
650 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
652 s
= PSYMTAB_TO_SYMTAB(ps
);
653 bv
= BLOCKVECTOR (s
);
654 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
655 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
657 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
670 /* Look, in partial_symtab PST, for symbol NAME. Check the global
671 symbols if GLOBAL, the static symbols if not */
673 static struct partial_symbol
*
674 lookup_partial_symbol (pst
, name
, global
, namespace)
675 struct partial_symtab
*pst
;
678 enum namespace namespace;
680 struct partial_symbol
*start
, *psym
;
681 struct partial_symbol
*top
, *bottom
, *center
;
682 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
683 int do_linear_search
= 1;
691 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
692 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
694 if (global
) /* This means we can use a binary search. */
696 do_linear_search
= 0;
698 /* Binary search. This search is guaranteed to end with center
699 pointing at the earliest partial symbol with the correct
700 name. At that point *all* partial symbols with that name
701 will be checked against the correct namespace. */
704 top
= start
+ length
- 1;
707 center
= bottom
+ (top
- bottom
) / 2;
708 assert (center
< top
);
709 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
711 do_linear_search
= 1;
713 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
722 assert (top
== bottom
);
723 while (STREQ (SYMBOL_NAME (top
), name
))
725 if (SYMBOL_NAMESPACE (top
) == namespace)
733 /* Can't use a binary search or else we found during the binary search that
734 we should also do a linear search. */
736 if (do_linear_search
)
738 for (psym
= start
; psym
< start
+ length
; psym
++)
740 if (namespace == SYMBOL_NAMESPACE (psym
))
742 if (SYMBOL_MATCHES_NAME (psym
, name
))
753 /* Find the psymtab containing main(). */
754 /* FIXME: What about languages without main() or specially linked
755 executables that have no main() ? */
757 struct partial_symtab
*
760 register struct partial_symtab
*pst
;
761 register struct objfile
*objfile
;
763 ALL_PSYMTABS (objfile
, pst
)
765 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
773 /* Search BLOCK for symbol NAME in NAMESPACE.
775 Note that if NAME is the demangled form of a C++ symbol, we will fail
776 to find a match during the binary search of the non-encoded names, but
777 for now we don't worry about the slight inefficiency of looking for
778 a match we'll never find, since it will go pretty quick. Once the
779 binary search terminates, we drop through and do a straight linear
780 search on the symbols. Each symbol which is marked as being a C++
781 symbol (language_cplus set) has both the encoded and non-encoded names
782 tested for a match. */
785 lookup_block_symbol (block
, name
, namespace)
786 register const struct block
*block
;
788 const enum namespace namespace;
790 register int bot
, top
, inc
;
791 register struct symbol
*sym
;
792 register struct symbol
*sym_found
= NULL
;
793 register int do_linear_search
= 1;
795 /* If the blocks's symbols were sorted, start with a binary search. */
797 if (BLOCK_SHOULD_SORT (block
))
799 /* Reset the linear search flag so if the binary search fails, we
800 won't do the linear search once unless we find some reason to
801 do so, such as finding a C++ symbol during the binary search.
802 Note that for C++ modules, ALL the symbols in a block should
803 end up marked as C++ symbols. */
805 do_linear_search
= 0;
806 top
= BLOCK_NSYMS (block
);
809 /* Advance BOT to not far before the first symbol whose name is NAME. */
813 inc
= (top
- bot
+ 1);
814 /* No need to keep binary searching for the last few bits worth. */
819 inc
= (inc
>> 1) + bot
;
820 sym
= BLOCK_SYM (block
, inc
);
821 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
823 do_linear_search
= 1;
825 if (SYMBOL_NAME (sym
)[0] < name
[0])
829 else if (SYMBOL_NAME (sym
)[0] > name
[0])
833 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
843 /* Now scan forward until we run out of symbols, find one whose
844 name is greater than NAME, or find one we want. If there is
845 more than one symbol with the right name and namespace, we
846 return the first one; I believe it is now impossible for us
847 to encounter two symbols with the same name and namespace
848 here, because blocks containing argument symbols are no
851 top
= BLOCK_NSYMS (block
);
854 sym
= BLOCK_SYM (block
, bot
);
855 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
858 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
860 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
872 /* Here if block isn't sorted, or we fail to find a match during the
873 binary search above. If during the binary search above, we find a
874 symbol which is a C++ symbol, then we have re-enabled the linear
875 search flag which was reset when starting the binary search.
877 This loop is equivalent to the loop above, but hacked greatly for speed.
879 Note that parameter symbols do not always show up last in the
880 list; this loop makes sure to take anything else other than
881 parameter symbols first; it only uses parameter symbols as a
882 last resort. Note that this only takes up extra computation
885 if (do_linear_search
)
887 top
= BLOCK_NSYMS (block
);
891 sym
= BLOCK_SYM (block
, bot
);
892 if (SYMBOL_NAMESPACE (sym
) == namespace &&
893 SYMBOL_MATCHES_NAME (sym
, name
))
896 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
897 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
898 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
899 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
900 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
901 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
909 return (sym_found
); /* Will be NULL if not found. */
913 /* Return the symbol for the function which contains a specified
914 lexical block, described by a struct block BL. */
920 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
921 bl
= BLOCK_SUPERBLOCK (bl
);
923 return BLOCK_FUNCTION (bl
);
926 /* Find the symtab associated with PC. Look through the psymtabs and read in
927 another symtab if necessary. */
931 register CORE_ADDR pc
;
933 register struct block
*b
;
934 struct blockvector
*bv
;
935 register struct symtab
*s
= NULL
;
936 register struct symtab
*best_s
= NULL
;
937 register struct partial_symtab
*ps
;
938 register struct objfile
*objfile
;
941 /* Search all symtabs for the one whose file contains our address, and which
942 is the smallest of all the ones containing the address. This is designed
943 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
944 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
945 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
946 This is said to happen for the mips; it might be swifter to create
947 several symtabs with the same name like xcoff does (I'm not sure). */
949 ALL_SYMTABS (objfile
, s
)
951 bv
= BLOCKVECTOR (s
);
952 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
953 if (BLOCK_START (b
) <= pc
954 && BLOCK_END (b
) > pc
956 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
958 distance
= BLOCK_END (b
) - BLOCK_START (b
);
967 ps
= find_pc_psymtab (pc
);
971 /* Might want to error() here (in case symtab is corrupt and
972 will cause a core dump), but maybe we can successfully
973 continue, so let's not. */
975 (Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
976 s
= PSYMTAB_TO_SYMTAB (ps
);
981 /* Find the source file and line number for a given PC value.
982 Return a structure containing a symtab pointer, a line number,
983 and a pc range for the entire source line.
984 The value's .pc field is NOT the specified pc.
985 NOTCURRENT nonzero means, if specified pc is on a line boundary,
986 use the line that ends there. Otherwise, in that case, the line
987 that begins there is used. */
989 /* The big complication here is that a line may start in one file, and end just
990 before the start of another file. This usually occurs when you #include
991 code in the middle of a subroutine. To properly find the end of a line's PC
992 range, we must search all symtabs associated with this compilation unit, and
993 find the one whose first PC is closer than that of the next line in this
996 FIXME: We used to complain here about zero length or negative length line
997 tables, but there are two problems with this: (1) some symtabs may not have
998 any line numbers due to gcc -g1 compilation, and (2) this function is called
999 during single stepping, when we don't own the terminal and thus can't
1000 produce any output. One solution might be to implement a mechanism whereby
1001 complaints can be queued until we regain control of the terminal. -fnf
1004 /* If it's worth the effort, we could be using a binary search. */
1006 struct symtab_and_line
1007 find_pc_line (pc
, notcurrent
)
1012 register struct linetable
*l
;
1015 register struct linetable_entry
*item
;
1016 struct symtab_and_line val
;
1017 struct blockvector
*bv
;
1019 /* Info on best line seen so far, and where it starts, and its file. */
1021 struct linetable_entry
*best
= NULL
;
1022 CORE_ADDR best_end
= 0;
1023 struct symtab
*best_symtab
= 0;
1025 /* Store here the first line number
1026 of a file which contains the line at the smallest pc after PC.
1027 If we don't find a line whose range contains PC,
1028 we will use a line one less than this,
1029 with a range from the start of that file to the first line's pc. */
1030 struct linetable_entry
*alt
= NULL
;
1031 struct symtab
*alt_symtab
= 0;
1033 /* Info on best line seen in this file. */
1035 struct linetable_entry
*prev
;
1037 /* If this pc is not from the current frame,
1038 it is the address of the end of a call instruction.
1039 Quite likely that is the start of the following statement.
1040 But what we want is the statement containing the instruction.
1041 Fudge the pc to make sure we get that. */
1043 if (notcurrent
) pc
-= 1;
1045 s
= find_pc_symtab (pc
);
1055 bv
= BLOCKVECTOR (s
);
1057 /* Look at all the symtabs that share this blockvector.
1058 They all have the same apriori range, that we found was right;
1059 but they have different line tables. */
1061 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1063 /* Find the best line in this symtab. */
1068 if (len
<= 0) /* See FIXME above. */
1074 item
= l
->item
; /* Get first line info */
1076 /* Is this file's first line closer than the first lines of other files?
1077 If so, record this file, and its first line, as best alternate. */
1078 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1084 for (i
= 0; i
< len
; i
++, item
++)
1086 /* Return the last line that did not start after PC. */
1093 /* At this point, prev points at the line whose start addr is <= pc, and
1094 item points at the next line. If we ran off the end of the linetable
1095 (pc >= start of the last line), then prev == item. If pc < start of
1096 the first line, prev will not be set. */
1098 /* Is this file's best line closer than the best in the other files?
1099 If so, record this file, and its best line, as best so far. */
1101 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1105 /* If another line is in the linetable, and its PC is closer
1106 than the best_end we currently have, take it as best_end. */
1107 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1108 best_end
= item
->pc
;
1115 { /* If we didn't find any line # info, just
1124 val
.symtab
= alt_symtab
;
1125 val
.line
= alt
->line
- 1;
1126 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1132 val
.symtab
= best_symtab
;
1133 val
.line
= best
->line
;
1135 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1140 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1145 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1148 /* Find line number LINE in any symtab whose name is the same as
1151 If found, return 1, set *LINETABLE to the linetable in which it was
1152 found, set *INDEX to the index in the linetable of the best entry
1153 found, and set *EXACT_MATCH nonzero if the value returned is an
1156 If not found, return 0. */
1159 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1160 struct symtab
*symtab
;
1162 struct linetable
**linetable
;
1168 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1172 struct linetable
*best_linetable
;
1174 /* First try looking it up in the given symtab. */
1175 best_linetable
= LINETABLE (symtab
);
1176 best_index
= find_line_common (best_linetable
, line
, &exact
);
1177 if (best_index
< 0 || !exact
)
1179 /* Didn't find an exact match. So we better keep looking for
1180 another symtab with the same name. In the case of xcoff,
1181 multiple csects for one source file (produced by IBM's FORTRAN
1182 compiler) produce multiple symtabs (this is unavoidable
1183 assuming csects can be at arbitrary places in memory and that
1184 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1186 /* BEST is the smallest linenumber > LINE so far seen,
1187 or 0 if none has been seen so far.
1188 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1191 struct objfile
*objfile
;
1194 if (best_index
>= 0)
1195 best
= best_linetable
->item
[best_index
].line
;
1199 ALL_SYMTABS (objfile
, s
)
1201 struct linetable
*l
;
1204 if (!STREQ (symtab
->filename
, s
->filename
))
1207 ind
= find_line_common (l
, line
, &exact
);
1216 if (best
== 0 || l
->item
[ind
].line
< best
)
1218 best
= l
->item
[ind
].line
;
1230 *index
= best_index
;
1232 *linetable
= best_linetable
;
1234 *exact_match
= exact
;
1238 /* Find the PC value for a given source file and line number.
1239 Returns zero for invalid line number.
1240 The source file is specified with a struct symtab. */
1243 find_line_pc (symtab
, line
)
1244 struct symtab
*symtab
;
1247 struct linetable
*l
;
1252 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1253 return l
->item
[ind
].pc
;
1258 /* Find the range of pc values in a line.
1259 Store the starting pc of the line into *STARTPTR
1260 and the ending pc (start of next line) into *ENDPTR.
1261 Returns 1 to indicate success.
1262 Returns 0 if could not find the specified line. */
1265 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1266 struct symtab
*symtab
;
1268 CORE_ADDR
*startptr
, *endptr
;
1270 struct linetable
*l
;
1272 int exact_match
; /* did we get an exact linenumber match */
1277 if (find_line_symtab (symtab
, thisline
, &l
, &ind
, &exact_match
))
1279 *startptr
= l
->item
[ind
].pc
;
1280 /* If we have not seen an entry for the specified line,
1281 assume that means the specified line has zero bytes. */
1282 if (!exact_match
|| ind
== l
->nitems
-1)
1283 *endptr
= *startptr
;
1285 /* Perhaps the following entry is for the following line.
1286 It's worth a try. */
1287 if (ind
+1 < l
->nitems
1288 && l
->item
[ind
+1].line
== thisline
+ 1)
1289 *endptr
= l
->item
[ind
+1].pc
;
1291 *endptr
= find_line_pc (symtab
, thisline
+1);
1298 /* Given a line table and a line number, return the index into the line
1299 table for the pc of the nearest line whose number is >= the specified one.
1300 Return -1 if none is found. The value is >= 0 if it is an index.
1302 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1305 find_line_common (l
, lineno
, exact_match
)
1306 register struct linetable
*l
;
1307 register int lineno
;
1313 /* BEST is the smallest linenumber > LINENO so far seen,
1314 or 0 if none has been seen so far.
1315 BEST_INDEX identifies the item for it. */
1317 int best_index
= -1;
1326 for (i
= 0; i
< len
; i
++)
1328 register struct linetable_entry
*item
= &(l
->item
[i
]);
1330 if (item
->line
== lineno
)
1332 /* Return the first (lowest address) entry which matches. */
1337 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1344 /* If we got here, we didn't get an exact match. */
1351 find_pc_line_pc_range (pc
, startptr
, endptr
)
1353 CORE_ADDR
*startptr
, *endptr
;
1355 struct symtab_and_line sal
;
1356 sal
= find_pc_line (pc
, 0);
1359 return sal
.symtab
!= 0;
1362 /* If P is of the form "operator[ \t]+..." where `...' is
1363 some legitimate operator text, return a pointer to the
1364 beginning of the substring of the operator text.
1365 Otherwise, return "". */
1367 operator_chars (p
, end
)
1372 if (strncmp (p
, "operator", 8))
1376 /* Don't get faked out by `operator' being part of a longer
1378 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1381 /* Allow some whitespace between `operator' and the operator symbol. */
1382 while (*p
== ' ' || *p
== '\t')
1385 /* Recognize 'operator TYPENAME'. */
1387 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1389 register char *q
= p
+1;
1390 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1415 if (p
[1] == '=' || p
[1] == p
[0])
1426 error ("`operator ()' must be specified without whitespace in `()'");
1431 error ("`operator ?:' must be specified without whitespace in `?:'");
1436 error ("`operator []' must be specified without whitespace in `[]'");
1440 error ("`operator %s' not supported", p
);
1447 /* Recursive helper function for decode_line_1.
1448 * Look for methods named NAME in type T.
1449 * Return number of matches.
1450 * Put matches in SYM_ARR (which better be big enough!).
1451 * These allocations seem to define "big enough":
1452 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1453 * Note that this function is g++ specific.
1457 find_methods (t
, name
, sym_arr
)
1460 struct symbol
**sym_arr
;
1464 struct symbol
*sym_class
;
1465 char *class_name
= type_name_no_tag (t
);
1466 /* Ignore this class if it doesn't have a name. This is ugly, but
1467 unless we figure out how to get the physname without the name of
1468 the class, then the loop can't do any good. */
1470 && (sym_class
= lookup_symbol (class_name
,
1471 (struct block
*)NULL
,
1474 (struct symtab
**)NULL
)))
1477 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1478 t
= SYMBOL_TYPE (sym_class
);
1479 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1480 method_counter
>= 0;
1484 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1486 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1487 if (STREQ (name
, method_name
))
1488 /* Find all the fields with that name. */
1489 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1494 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1495 check_stub_method (t
, method_counter
, field_counter
);
1496 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1497 /* Destructor is handled by caller, dont add it to the list */
1498 if (DESTRUCTOR_PREFIX_P (phys_name
))
1501 /* FIXME: Why are we looking this up in the
1502 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1503 for nested types? If so, it should probably hook to the
1504 type, not the symbol. mipsread.c is the only symbol
1505 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1506 this is not documented in symtab.h. -26Aug93. */
1508 sym_arr
[i1
] = lookup_symbol (phys_name
,
1509 SYMBOL_BLOCK_VALUE (sym_class
),
1512 (struct symtab
**) NULL
);
1513 if (sym_arr
[i1
]) i1
++;
1516 fputs_filtered("(Cannot find method ", stdout
);
1517 fprintf_symbol_filtered (stdout
, phys_name
,
1518 language_cplus
, DMGL_PARAMS
);
1519 fputs_filtered(" - possibly inlined.)\n", stdout
);
1525 /* Only search baseclasses if there is no match yet, since names in
1526 derived classes override those in baseclasses.
1528 FIXME: The above is not true; it is only true of member functions
1529 if they have the same number of arguments (??? - section 13.1 of the
1530 ARM says the function members are not in the same scope but doesn't
1531 really spell out the rules in a way I understand. In any case, if
1532 the number of arguments differ this is a case in which we can overload
1533 rather than hiding without any problem, and gcc 2.4.5 does overload
1534 rather than hiding in this case). */
1538 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1539 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1544 /* Helper function for decode_line_1.
1545 Build a canonical line spec in CANONICAL if it is non-NULL and if
1546 the SAL has a symtab.
1547 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1548 If SYMNAME is NULL the line number from SAL is used and the canonical
1549 line spec is `filename:linenum'. */
1552 build_canonical_line_spec (sal
, symname
, canonical
)
1553 struct symtab_and_line
*sal
;
1557 char **canonical_arr
;
1558 char *canonical_name
;
1560 struct symtab
*s
= sal
->symtab
;
1562 if (s
== (struct symtab
*)NULL
1563 || s
->filename
== (char *)NULL
1564 || canonical
== (char ***)NULL
)
1567 canonical_arr
= (char **) xmalloc (sizeof (char *));
1568 *canonical
= canonical_arr
;
1570 filename
= s
->filename
;
1571 if (symname
!= NULL
)
1573 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1574 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1578 canonical_name
= xmalloc (strlen (filename
) + 30);
1579 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1581 canonical_arr
[0] = canonical_name
;
1584 /* Parse a string that specifies a line number.
1585 Pass the address of a char * variable; that variable will be
1586 advanced over the characters actually parsed.
1590 LINENUM -- that line number in current file. PC returned is 0.
1591 FILE:LINENUM -- that line in that file. PC returned is 0.
1592 FUNCTION -- line number of openbrace of that function.
1593 PC returned is the start of the function.
1594 VARIABLE -- line number of definition of that variable.
1596 FILE:FUNCTION -- likewise, but prefer functions in that file.
1597 *EXPR -- line in which address EXPR appears.
1599 FUNCTION may be an undebuggable function found in minimal symbol table.
1601 If the argument FUNFIRSTLINE is nonzero, we want the first line
1602 of real code inside a function when a function is specified.
1604 DEFAULT_SYMTAB specifies the file to use if none is specified.
1605 It defaults to current_source_symtab.
1606 DEFAULT_LINE specifies the line number to use for relative
1607 line numbers (that start with signs). Defaults to current_source_line.
1608 If CANONICAL is non-NULL, store an array of strings containing the canonical
1609 line specs there if necessary. Currently overloaded member functions and
1610 line numbers or static functions without a filename yield a canonical
1611 line spec. The array and the line spec strings are allocated on the heap,
1612 it is the callers responsibility to free them.
1614 Note that it is possible to return zero for the symtab
1615 if no file is validly specified. Callers must check that.
1616 Also, the line number returned may be invalid. */
1618 struct symtabs_and_lines
1619 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1622 struct symtab
*default_symtab
;
1626 struct symtabs_and_lines values
;
1627 #ifdef HPPA_COMPILER_BUG
1628 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1629 when optimizing this file with target i960-vxworks. I haven't
1630 been able to construct a simple test case. The problem is that
1631 in the second call to SKIP_PROLOGUE below, the compiler somehow
1632 does not realize that the statement val = find_pc_line (...) will
1633 change the values of the fields of val. It extracts the elements
1634 into registers at the top of the block, and does not update the
1635 registers after the call to find_pc_line. You can check this by
1636 inserting a printf at the end of find_pc_line to show what values
1637 it is returning for val.pc and val.end and another printf after
1638 the call to see what values the function actually got (remember,
1639 this is compiling with cc -O, with this patch removed). You can
1640 also examine the assembly listing: search for the second call to
1641 skip_prologue; the LDO statement before the next call to
1642 find_pc_line loads the address of the structure which
1643 find_pc_line will return; if there is a LDW just before the LDO,
1644 which fetches an element of the structure, then the compiler
1647 Setting val to volatile avoids the problem. We must undef
1648 volatile, because the HPPA native compiler does not define
1649 __STDC__, although it does understand volatile, and so volatile
1650 will have been defined away in defs.h. */
1652 volatile struct symtab_and_line val
;
1653 #define volatile /*nothing*/
1655 struct symtab_and_line val
;
1657 register char *p
, *p1
;
1659 register struct symtab
*s
;
1661 register struct symbol
*sym
;
1662 /* The symtab that SYM was found in. */
1663 struct symtab
*sym_symtab
;
1665 register CORE_ADDR pc
;
1666 register struct minimal_symbol
*msymbol
;
1668 struct symbol
*sym_class
;
1671 struct symbol
**sym_arr
;
1673 char *saved_arg
= *argptr
;
1674 extern char *gdb_completer_quote_characters
;
1676 /* Defaults have defaults. */
1678 if (default_symtab
== 0)
1680 default_symtab
= current_source_symtab
;
1681 default_line
= current_source_line
;
1684 /* See if arg is *PC */
1686 if (**argptr
== '*')
1688 if (**argptr
== '*')
1692 pc
= parse_and_eval_address_1 (argptr
);
1693 values
.sals
= (struct symtab_and_line
*)
1694 xmalloc (sizeof (struct symtab_and_line
));
1696 values
.sals
[0] = find_pc_line (pc
, 0);
1697 values
.sals
[0].pc
= pc
;
1698 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1702 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1705 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1707 for (p
= *argptr
; *p
; p
++)
1709 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1712 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1714 if ((p
[0] == ':') && !is_quoted
)
1720 /* Extract the class name. */
1722 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1723 copy
= (char *) alloca (p
- *argptr
+ 1);
1724 memcpy (copy
, *argptr
, p
- *argptr
);
1725 copy
[p
- *argptr
] = 0;
1727 /* Discard the class name from the arg. */
1729 while (*p
== ' ' || *p
== '\t') p
++;
1732 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1733 (struct symtab
**)NULL
);
1736 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1737 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1739 /* Arg token is not digits => try it as a function name
1740 Find the next token (everything up to end or next whitespace). */
1742 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1743 q
= operator_chars (*argptr
, &q1
);
1748 char *tmp
= alloca (q1
- q
+ 1);
1749 memcpy (tmp
, q
, q1
- q
);
1751 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1754 warning ("no mangling for \"%s\"", tmp
);
1755 cplusplus_hint (saved_arg
);
1756 return_to_top_level (RETURN_ERROR
);
1758 copy
= (char*) alloca (3 + strlen(opname
));
1759 sprintf (copy
, "__%s", opname
);
1764 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1765 memcpy (copy
, *argptr
, p
- *argptr
);
1766 copy
[p
- *argptr
] = '\0';
1769 /* no line number may be specified */
1770 while (*p
== ' ' || *p
== '\t') p
++;
1774 i1
= 0; /* counter for the symbol array */
1775 t
= SYMBOL_TYPE (sym_class
);
1776 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1778 /* Cfront objects don't have fieldlists. */
1779 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1781 /* destructors are a special case. */
1782 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1783 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1784 /* gcc 1.x puts destructor in last field,
1785 gcc 2.x puts destructor in first field. */
1786 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1787 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1789 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1790 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1794 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1795 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1796 if (sym_arr
[i1
]) i1
++;
1799 i1
= find_methods (t
, copy
, sym_arr
);
1802 /* There is exactly one field with that name. */
1805 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1807 /* Arg is the name of a function */
1808 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1811 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1813 values
.sals
[0] = find_pc_line (pc
, 0);
1814 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1824 /* There is more than one field with that name
1825 (overloaded). Ask the user which one to use. */
1826 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1832 if (OPNAME_PREFIX_P (copy
))
1834 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1835 strcpy (tmp
, "operator ");
1836 strcat (tmp
, copy
+3);
1841 warning ("the class `%s' does not have destructor defined",
1842 SYMBOL_SOURCE_NAME(sym_class
));
1844 warning ("the class %s does not have any method named %s",
1845 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1846 cplusplus_hint (saved_arg
);
1847 return_to_top_level (RETURN_ERROR
);
1852 /* The quotes are important if copy is empty. */
1853 warning ("can't find class, struct, or union named \"%s\"",
1855 cplusplus_hint (saved_arg
);
1856 return_to_top_level (RETURN_ERROR
);
1862 /* Extract the file name. */
1864 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1865 copy
= (char *) alloca (p
- *argptr
+ 1);
1866 memcpy (copy
, *argptr
, p
- *argptr
);
1867 copy
[p
- *argptr
] = 0;
1869 /* Find that file's data. */
1870 s
= lookup_symtab (copy
);
1873 if (!have_full_symbols () && !have_partial_symbols ())
1874 error (no_symtab_msg
);
1875 error ("No source file named %s.", copy
);
1878 /* Discard the file name from the arg. */
1880 while (*p
== ' ' || *p
== '\t') p
++;
1884 /* S is specified file's symtab, or 0 if no file specified.
1885 arg no longer contains the file name. */
1887 /* Check whether arg is all digits (and sign) */
1890 if (*p
== '-' || *p
== '+') p
++;
1891 while (*p
>= '0' && *p
<= '9')
1894 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1896 /* We found a token consisting of all digits -- at least one digit. */
1897 enum sign
{none
, plus
, minus
} sign
= none
;
1899 /* We might need a canonical line spec if no file was specified. */
1900 int need_canonical
= (s
== 0) ? 1 : 0;
1902 /* This is where we need to make sure that we have good defaults.
1903 We must guarantee that this section of code is never executed
1904 when we are called with just a function name, since
1905 select_source_symtab calls us with such an argument */
1907 if (s
== 0 && default_symtab
== 0)
1909 select_source_symtab (0);
1910 default_symtab
= current_source_symtab
;
1911 default_line
= current_source_line
;
1914 if (**argptr
== '+')
1915 sign
= plus
, (*argptr
)++;
1916 else if (**argptr
== '-')
1917 sign
= minus
, (*argptr
)++;
1918 val
.line
= atoi (*argptr
);
1925 val
.line
= default_line
+ val
.line
;
1931 val
.line
= default_line
- val
.line
;
1936 break; /* No need to adjust val.line. */
1939 while (*p
== ' ' || *p
== '\t') p
++;
1945 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1946 values
.sals
[0] = val
;
1949 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1953 /* Arg token is not digits => try it as a variable name
1954 Find the next token (everything up to end or next whitespace). */
1956 p
= skip_quoted (*argptr
);
1957 if (is_quoted
&& p
[-1] != '\'')
1958 error ("Unmatched single quote.");
1959 copy
= (char *) alloca (p
- *argptr
+ 1);
1960 memcpy (copy
, *argptr
, p
- *argptr
);
1961 copy
[p
- *argptr
] = '\0';
1962 if ((copy
[0] == copy
[p
- *argptr
- 1])
1963 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1965 copy
[p
- *argptr
- 1] = '\0';
1968 while (*p
== ' ' || *p
== '\t') p
++;
1971 /* Look up that token as a variable.
1972 If file specified, use that file's per-file block to start with. */
1974 sym
= lookup_symbol (copy
,
1975 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1976 : get_selected_block ()),
1977 VAR_NAMESPACE
, 0, &sym_symtab
);
1981 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1983 /* Arg is the name of a function */
1984 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1987 val
= find_pc_line (pc
, 0);
1988 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1989 /* Convex: no need to suppress code on first line, if any */
1992 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1993 line is still part of the same function. */
1995 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
1996 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1998 /* First pc of next line */
2000 /* Recalculate the line number (might not be N+1). */
2001 val
= find_pc_line (pc
, 0);
2005 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2006 values
.sals
[0] = val
;
2009 /* I think this is always the same as the line that
2010 we calculate above, but the general principle is
2011 "trust the symbols more than stuff like
2013 if (SYMBOL_LINE (sym
) != 0)
2014 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2016 /* We might need a canonical line spec if it is a static function. */
2019 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2020 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2021 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2022 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2026 else if (SYMBOL_LINE (sym
) != 0)
2028 /* We know its line number. */
2029 values
.sals
= (struct symtab_and_line
*)
2030 xmalloc (sizeof (struct symtab_and_line
));
2032 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2033 values
.sals
[0].symtab
= sym_symtab
;
2034 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2038 /* This can happen if it is compiled with a compiler which doesn't
2039 put out line numbers for variables. */
2040 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2041 return? For example, "info line foo" could print the address. */
2042 error ("Line number not known for symbol \"%s\"", copy
);
2045 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2046 if (msymbol
!= NULL
)
2050 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
) + FUNCTION_START_OFFSET
;
2052 SKIP_PROLOGUE (val
.pc
);
2053 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2054 values
.sals
[0] = val
;
2059 if (!have_full_symbols () &&
2060 !have_partial_symbols () && !have_minimal_symbols ())
2061 error (no_symtab_msg
);
2063 error ("Function \"%s\" not defined.", copy
);
2064 return values
; /* for lint */
2067 struct symtabs_and_lines
2068 decode_line_spec (string
, funfirstline
)
2072 struct symtabs_and_lines sals
;
2074 error ("Empty line specification.");
2075 sals
= decode_line_1 (&string
, funfirstline
,
2076 current_source_symtab
, current_source_line
,
2079 error ("Junk at end of line specification: %s", string
);
2083 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2084 operate on (ask user if necessary).
2085 If CANONICAL is non-NULL return a corresponding array of mangled names
2086 as canonical line specs there. */
2088 static struct symtabs_and_lines
2089 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2090 struct symbol
*sym_arr
[];
2095 struct symtabs_and_lines values
, return_values
;
2096 register CORE_ADDR pc
;
2101 struct cleanup
*old_chain
;
2102 char **canonical_arr
= (char **)NULL
;
2104 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2105 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2106 old_chain
= make_cleanup (free
, return_values
.sals
);
2110 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2111 make_cleanup (free
, canonical_arr
);
2112 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2113 *canonical
= canonical_arr
;
2117 printf("[0] cancel\n[1] all\n");
2120 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2122 /* Arg is the name of a function */
2123 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2124 + FUNCTION_START_OFFSET
;
2127 values
.sals
[i
] = find_pc_line (pc
, 0);
2128 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2129 values
.sals
[i
].end
: pc
;
2130 printf("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2131 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2133 else printf ("?HERE\n");
2137 if ((prompt
= getenv ("PS2")) == NULL
)
2141 printf("%s ",prompt
);
2144 args
= command_line_input ((char *) NULL
, 0);
2146 if (args
== 0 || *args
== 0)
2147 error_no_arg ("one or more choice numbers");
2155 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2156 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2157 error ("Arguments must be choice numbers.");
2162 error ("cancelled");
2167 for (i
= 0; i
< nelts
; i
++)
2169 if (canonical_arr
[i
] == NULL
)
2171 symname
= SYMBOL_NAME (sym_arr
[i
]);
2172 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2176 memcpy (return_values
.sals
, values
.sals
,
2177 (nelts
* sizeof(struct symtab_and_line
)));
2178 return_values
.nelts
= nelts
;
2179 discard_cleanups (old_chain
);
2180 return return_values
;
2183 if (num
> nelts
+ 2)
2185 printf ("No choice number %d.\n", num
);
2190 if (values
.sals
[num
].pc
)
2194 symname
= SYMBOL_NAME (sym_arr
[num
]);
2195 make_cleanup (free
, symname
);
2196 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2198 return_values
.sals
[i
++] = values
.sals
[num
];
2199 values
.sals
[num
].pc
= 0;
2203 printf ("duplicate request for %d ignored.\n", num
);
2208 while (*args
== ' ' || *args
== '\t') args
++;
2210 return_values
.nelts
= i
;
2211 discard_cleanups (old_chain
);
2212 return return_values
;
2216 /* Slave routine for sources_info. Force line breaks at ,'s.
2217 NAME is the name to print and *FIRST is nonzero if this is the first
2218 name printed. Set *FIRST to zero. */
2220 output_source_filename (name
, first
)
2224 /* Table of files printed so far. Since a single source file can
2225 result in several partial symbol tables, we need to avoid printing
2226 it more than once. Note: if some of the psymtabs are read in and
2227 some are not, it gets printed both under "Source files for which
2228 symbols have been read" and "Source files for which symbols will
2229 be read in on demand". I consider this a reasonable way to deal
2230 with the situation. I'm not sure whether this can also happen for
2231 symtabs; it doesn't hurt to check. */
2232 static char **tab
= NULL
;
2233 /* Allocated size of tab in elements.
2234 Start with one 256-byte block (when using GNU malloc.c).
2235 24 is the malloc overhead when range checking is in effect. */
2236 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2237 /* Current size of tab in elements. */
2238 static int tab_cur_size
;
2245 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2249 /* Is NAME in tab? */
2250 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2251 if (STREQ (*p
, name
))
2252 /* Yes; don't print it again. */
2254 /* No; add it to tab. */
2255 if (tab_cur_size
== tab_alloc_size
)
2257 tab_alloc_size
*= 2;
2258 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2260 tab
[tab_cur_size
++] = name
;
2268 printf_filtered (", ");
2272 fputs_filtered (name
, stdout
);
2276 sources_info (ignore
, from_tty
)
2280 register struct symtab
*s
;
2281 register struct partial_symtab
*ps
;
2282 register struct objfile
*objfile
;
2285 if (!have_full_symbols () && !have_partial_symbols ())
2287 error (no_symtab_msg
);
2290 printf_filtered ("Source files for which symbols have been read in:\n\n");
2293 ALL_SYMTABS (objfile
, s
)
2295 output_source_filename (s
-> filename
, &first
);
2297 printf_filtered ("\n\n");
2299 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2302 ALL_PSYMTABS (objfile
, ps
)
2306 output_source_filename (ps
-> filename
, &first
);
2309 printf_filtered ("\n");
2312 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2313 If CLASS is zero, list all symbols except functions, type names, and
2315 If CLASS is 1, list only functions.
2316 If CLASS is 2, list only type names.
2317 If CLASS is 3, list only method names.
2319 BPT is non-zero if we should set a breakpoint at the functions
2323 list_symbols (regexp
, class, bpt
)
2328 register struct symtab
*s
;
2329 register struct partial_symtab
*ps
;
2330 register struct blockvector
*bv
;
2331 struct blockvector
*prev_bv
= 0;
2332 register struct block
*b
;
2334 register struct symbol
*sym
;
2335 struct partial_symbol
*psym
;
2336 struct objfile
*objfile
;
2337 struct minimal_symbol
*msymbol
;
2339 static char *classnames
[]
2340 = {"variable", "function", "type", "method"};
2341 int found_in_file
= 0;
2343 static enum minimal_symbol_type types
[]
2344 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2345 static enum minimal_symbol_type types2
[]
2346 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2347 enum minimal_symbol_type ourtype
= types
[class];
2348 enum minimal_symbol_type ourtype2
= types2
[class];
2352 /* Make sure spacing is right for C++ operators.
2353 This is just a courtesy to make the matching less sensitive
2354 to how many spaces the user leaves between 'operator'
2355 and <TYPENAME> or <OPERATOR>. */
2357 char *opname
= operator_chars (regexp
, &opend
);
2360 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2361 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2363 /* There should 1 space between 'operator' and 'TYPENAME'. */
2364 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2369 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2370 if (opname
[-1] == ' ')
2373 /* If wrong number of spaces, fix it. */
2376 char *tmp
= (char*) alloca(opend
-opname
+10);
2377 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2382 if (0 != (val
= re_comp (regexp
)))
2383 error ("Invalid regexp (%s): %s", val
, regexp
);
2386 /* Search through the partial symtabs *first* for all symbols
2387 matching the regexp. That way we don't have to reproduce all of
2388 the machinery below. */
2390 ALL_PSYMTABS (objfile
, ps
)
2392 struct partial_symbol
*bound
, *gbound
, *sbound
;
2395 if (ps
->readin
) continue;
2397 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2398 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2401 /* Go through all of the symbols stored in a partial
2402 symtab in one loop. */
2403 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2408 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2410 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2421 /* If it would match (logic taken from loop below)
2422 load the file and go on to the next one */
2423 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2424 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2425 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2426 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2427 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2428 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2430 PSYMTAB_TO_SYMTAB(ps
);
2438 /* Here, we search through the minimal symbol tables for functions that
2439 match, and call find_pc_symtab on them to force their symbols to
2440 be read. The symbol will then be found during the scan of symtabs
2441 below. If find_pc_symtab fails, set found_misc so that we will
2442 rescan to print any matching symbols without debug info. */
2446 ALL_MSYMBOLS (objfile
, msymbol
)
2448 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2449 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2451 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2453 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2462 /* Printout here so as to get after the "Reading in symbols"
2463 messages which will be generated above. */
2465 printf_filtered (regexp
2466 ? "All %ss matching regular expression \"%s\":\n"
2467 : "All defined %ss:\n",
2471 ALL_SYMTABS (objfile
, s
)
2474 bv
= BLOCKVECTOR (s
);
2475 /* Often many files share a blockvector.
2476 Scan each blockvector only once so that
2477 we don't get every symbol many times.
2478 It happens that the first symtab in the list
2479 for any given blockvector is the main file. */
2481 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2483 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2484 /* Skip the sort if this block is always sorted. */
2485 if (!BLOCK_SHOULD_SORT (b
))
2486 sort_block_syms (b
);
2487 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2490 sym
= BLOCK_SYM (b
, j
);
2491 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2492 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2493 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2494 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2495 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2496 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2497 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2501 /* Set a breakpoint here, if it's a function */
2504 /* There may be more than one function with the
2505 same name but in different files. In order to
2506 set breakpoints on all of them, we must give
2507 both the file name and the function name to
2510 (char *) alloca (strlen (s
->filename
)
2511 + strlen (SYMBOL_NAME(sym
))
2513 strcpy (string
, s
->filename
);
2514 strcat (string
, ":");
2515 strcat (string
, SYMBOL_NAME(sym
));
2516 break_command (string
, 0);
2519 else if (!found_in_file
)
2521 fputs_filtered ("\nFile ", stdout
);
2522 fputs_filtered (s
->filename
, stdout
);
2523 fputs_filtered (":\n", stdout
);
2527 if (class != 2 && i
== STATIC_BLOCK
)
2528 printf_filtered ("static ");
2530 /* Typedef that is not a C++ class */
2532 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2533 c_typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2534 /* variable, func, or typedef-that-is-c++-class */
2535 else if (class < 2 ||
2537 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2539 type_print (SYMBOL_TYPE (sym
),
2540 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2541 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2544 printf_filtered (";\n");
2548 # if 0 /* FIXME, why is this zapped out? */
2550 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2552 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2554 sprintf (buf
, " %s::", type_name_no_tag (t
));
2555 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2565 /* If there are no eyes, avoid all contact. I mean, if there are
2566 no debug symbols, then print directly from the msymbol_vector. */
2568 if (found_misc
|| class != 1)
2571 ALL_MSYMBOLS (objfile
, msymbol
)
2573 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2574 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2576 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2578 /* Functions: Look up by address. */
2580 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2582 /* Variables/Absolutes: Look up by name */
2583 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2584 (struct block
*) NULL
, VAR_NAMESPACE
,
2585 0, (struct symtab
**) NULL
) == NULL
)
2589 printf_filtered ("\nNon-debugging symbols:\n");
2592 printf_filtered (" %08x %s\n",
2593 SYMBOL_VALUE_ADDRESS (msymbol
),
2594 SYMBOL_SOURCE_NAME (msymbol
));
2604 variables_info (regexp
, from_tty
)
2608 list_symbols (regexp
, 0, 0);
2612 functions_info (regexp
, from_tty
)
2616 list_symbols (regexp
, 1, 0);
2620 types_info (regexp
, from_tty
)
2624 list_symbols (regexp
, 2, 0);
2628 /* Tiemann says: "info methods was never implemented." */
2630 methods_info (regexp
)
2633 list_symbols (regexp
, 3, 0);
2637 /* Breakpoint all functions matching regular expression. */
2639 rbreak_command (regexp
, from_tty
)
2643 list_symbols (regexp
, 1, 1);
2647 /* Return Nonzero if block a is lexically nested within block b,
2648 or if a and b have the same pc range.
2649 Return zero otherwise. */
2652 struct block
*a
, *b
;
2656 return BLOCK_START (a
) >= BLOCK_START (b
)
2657 && BLOCK_END (a
) <= BLOCK_END (b
);
2661 /* Helper routine for make_symbol_completion_list. */
2663 static int return_val_size
;
2664 static int return_val_index
;
2665 static char **return_val
;
2667 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2669 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2670 /* Put only the mangled name on the list. */ \
2671 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2672 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2673 completion_list_add_name \
2674 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2676 completion_list_add_name \
2677 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2680 /* Test to see if the symbol specified by SYMNAME (which is already
2681 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2682 characters. If so, add it to the current completion list. */
2685 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2695 /* clip symbols that cannot match */
2697 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2702 /* Clip any symbol names that we've already considered. (This is a
2703 time optimization) */
2705 for (i
= 0; i
< return_val_index
; ++i
)
2707 if (STREQ (symname
, return_val
[i
]))
2713 /* We have a match for a completion, so add SYMNAME to the current list
2714 of matches. Note that the name is moved to freshly malloc'd space. */
2718 if (word
== sym_text
)
2720 new = xmalloc (strlen (symname
) + 5);
2721 strcpy (new, symname
);
2723 else if (word
> sym_text
)
2725 /* Return some portion of symname. */
2726 new = xmalloc (strlen (symname
) + 5);
2727 strcpy (new, symname
+ (word
- sym_text
));
2731 /* Return some of SYM_TEXT plus symname. */
2732 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2733 strncpy (new, word
, sym_text
- word
);
2734 new[sym_text
- word
] = '\0';
2735 strcat (new, symname
);
2738 if (return_val_index
+ 3 > return_val_size
)
2740 newsize
= (return_val_size
*= 2) * sizeof (char *);
2741 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2743 return_val
[return_val_index
++] = new;
2744 return_val
[return_val_index
] = NULL
;
2748 /* Return a NULL terminated array of all symbols (regardless of class) which
2749 begin by matching TEXT. If the answer is no symbols, then the return value
2750 is an array which contains only a NULL pointer.
2752 Problem: All of the symbols have to be copied because readline frees them.
2753 I'm not going to worry about this; hopefully there won't be that many. */
2756 make_symbol_completion_list (text
, word
)
2760 register struct symbol
*sym
;
2761 register struct symtab
*s
;
2762 register struct partial_symtab
*ps
;
2763 register struct minimal_symbol
*msymbol
;
2764 register struct objfile
*objfile
;
2765 register struct block
*b
, *surrounding_static_block
= 0;
2767 struct partial_symbol
*psym
;
2768 /* The symbol we are completing on. Points in same buffer as text. */
2770 /* Length of sym_text. */
2773 /* Now look for the symbol we are supposed to complete on.
2774 FIXME: This should be language-specific. */
2780 /* First see if this is a quoted string. */
2782 for (p
= text
; *p
!= '\0'; ++p
)
2784 if (quote_found
!= '\0')
2786 if (*p
== quote_found
)
2787 /* Found close quote. */
2789 else if (*p
== '\\' && p
[1] == quote_found
)
2790 /* A backslash followed by the quote character
2791 doesn't end the string. */
2794 else if (*p
== '\'' || *p
== '"')
2800 if (quote_found
== '\'')
2801 /* A string within single quotes can be a symbol, so complete on it. */
2802 sym_text
= quote_pos
+ 1;
2803 else if (quote_found
== '"')
2804 /* A double-quoted string is never a symbol, nor does it make sense
2805 to complete it any other way. */
2809 /* It is not a quoted string. Break it based on the characters
2810 which are in symbols. */
2813 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2822 sym_text_len
= strlen (sym_text
);
2824 return_val_size
= 100;
2825 return_val_index
= 0;
2826 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2827 return_val
[0] = NULL
;
2829 /* Look through the partial symtabs for all symbols which begin
2830 by matching SYM_TEXT. Add each one that you find to the list. */
2832 ALL_PSYMTABS (objfile
, ps
)
2834 /* If the psymtab's been read in we'll get it when we search
2835 through the blockvector. */
2836 if (ps
->readin
) continue;
2838 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2839 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2840 + ps
->n_global_syms
);
2843 /* If interrupted, then quit. */
2845 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2848 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2849 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2850 + ps
->n_static_syms
);
2854 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2858 /* At this point scan through the misc symbol vectors and add each
2859 symbol you find to the list. Eventually we want to ignore
2860 anything that isn't a text symbol (everything else will be
2861 handled by the psymtab code above). */
2863 ALL_MSYMBOLS (objfile
, msymbol
)
2866 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2869 /* Search upwards from currently selected frame (so that we can
2870 complete on local vars. */
2872 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2874 if (!BLOCK_SUPERBLOCK (b
))
2876 surrounding_static_block
= b
; /* For elmin of dups */
2879 /* Also catch fields of types defined in this places which match our
2880 text string. Only complete on types visible from current context. */
2882 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2884 sym
= BLOCK_SYM (b
, i
);
2885 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2886 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2888 struct type
*t
= SYMBOL_TYPE (sym
);
2889 enum type_code c
= TYPE_CODE (t
);
2891 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2893 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2895 if (TYPE_FIELD_NAME (t
, j
))
2897 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2898 sym_text
, sym_text_len
, text
, word
);
2906 /* Go through the symtabs and check the externs and statics for
2907 symbols which match. */
2909 ALL_SYMTABS (objfile
, s
)
2912 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2913 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2915 sym
= BLOCK_SYM (b
, i
);
2916 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2920 ALL_SYMTABS (objfile
, s
)
2923 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2924 /* Don't do this block twice. */
2925 if (b
== surrounding_static_block
) continue;
2926 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2928 sym
= BLOCK_SYM (b
, i
);
2929 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2933 return (return_val
);
2938 /* Add the type of the symbol sym to the type of the current
2939 function whose block we are in (assumed). The type of
2940 this current function is contained in *TYPE.
2942 This basically works as follows: When we find a function
2943 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2944 a pointer to its type in the global in_function_type. Every
2945 time we come across a parameter symbol ('p' in its name), then
2946 this procedure adds the name and type of that parameter
2947 to the function type pointed to by *TYPE. (Which should correspond
2948 to in_function_type if it was called correctly).
2950 Note that since we are modifying a type, the result of
2951 lookup_function_type() should be memcpy()ed before calling
2952 this. When not in strict typing mode, the expression
2953 evaluator can choose to ignore this.
2955 Assumption: All of a function's parameter symbols will
2956 appear before another function symbol is found. The parameters
2957 appear in the same order in the argument list as they do in the
2961 add_param_to_type (type
,sym
)
2965 int num
= ++(TYPE_NFIELDS(*type
));
2967 if(TYPE_NFIELDS(*type
)-1)
2968 TYPE_FIELDS(*type
) = (struct field
*)
2969 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2970 num
*sizeof(struct field
));
2972 TYPE_FIELDS(*type
) = (struct field
*)
2973 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2975 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2976 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2977 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2978 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2983 _initialize_symtab ()
2985 add_info ("variables", variables_info
,
2986 "All global and static variable names, or those matching REGEXP.");
2987 add_info ("functions", functions_info
,
2988 "All function names, or those matching REGEXP.");
2990 /* FIXME: This command has at least the following problems:
2991 1. It prints builtin types (in a very strange and confusing fashion).
2992 2. It doesn't print right, e.g. with
2993 typedef struct foo *FOO
2994 type_print prints "FOO" when we want to make it (in this situation)
2995 print "struct foo *".
2996 I also think "ptype" or "whatis" is more likely to be useful (but if
2997 there is much disagreement "info types" can be fixed). */
2998 add_info ("types", types_info
,
2999 "All type names, or those matching REGEXP.");
3002 add_info ("methods", methods_info
,
3003 "All method names, or those matching REGEXP::REGEXP.\n\
3004 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3005 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3008 add_info ("sources", sources_info
,
3009 "Source files in the program.");
3011 add_com ("rbreak", no_class
, rbreak_command
,
3012 "Set a breakpoint for all functions matching REGEXP.");
3014 /* Initialize the one built-in type that isn't language dependent... */
3015 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3016 "<unknown type>", (struct objfile
*) NULL
);