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 extern char *gdb_completer_word_break_characters
;
442 /* Search specified block and its superiors. */
446 sym
= lookup_block_symbol (block
, name
, namespace);
452 /* Search the list of symtabs for one which contains the
453 address of the start of this block. */
454 ALL_SYMTABS (objfile
, s
)
456 bv
= BLOCKVECTOR (s
);
457 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
458 if (BLOCK_START (b
) <= BLOCK_START (block
)
459 && BLOCK_END (b
) > BLOCK_START (block
))
468 block
= BLOCK_SUPERBLOCK (block
);
471 /* FIXME: this code is never executed--block is always NULL at this
472 point. What is it trying to do, anyway? We already should have
473 checked the STATIC_BLOCK above (it is the superblock of top-level
474 blocks). Why is VAR_NAMESPACE special-cased? */
475 /* Don't need to mess with the psymtabs; if we have a block,
476 that file is read in. If we don't, then we deal later with
477 all the psymtab stuff that needs checking. */
478 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
481 /* Find the right symtab. */
482 ALL_SYMTABS (objfile
, s
)
484 bv
= BLOCKVECTOR (s
);
485 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
486 if (BLOCK_START (b
) <= BLOCK_START (block
)
487 && BLOCK_END (b
) > BLOCK_START (block
))
489 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
502 /* C++: If requested to do so by the caller,
503 check to see if NAME is a field of `this'. */
504 if (is_a_field_of_this
)
506 struct value
*v
= value_of_this (0);
508 *is_a_field_of_this
= 0;
509 if (v
&& check_field (v
, name
))
511 *is_a_field_of_this
= 1;
518 /* Now search all global blocks. Do the symtab's first, then
519 check the psymtab's */
521 ALL_SYMTABS (objfile
, s
)
523 bv
= BLOCKVECTOR (s
);
524 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
525 sym
= lookup_block_symbol (block
, name
, namespace);
535 /* Check for the possibility of the symbol being a global function
536 that is stored in one of the minimal symbol tables. Eventually, all
537 global symbols might be resolved in this way. */
539 if (namespace == VAR_NAMESPACE
)
541 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
544 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
545 /* If S is NULL, there are no debug symbols for this file.
546 Skip this stuff and check for matching static symbols below. */
549 bv
= BLOCKVECTOR (s
);
550 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
551 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
553 /* We kept static functions in minimal symbol table as well as
554 in static scope. We want to find them in the symbol table. */
556 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
557 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
561 /* sym == 0 if symbol was found in the minimal symbol table
562 but not in the symtab.
563 Return 0 to use the msymbol definition of "foo_".
565 This happens for Fortran "foo_" symbols,
566 which are "foo" in the symtab.
568 This can also happen if "asm" is used to make a
569 regular symbol but not a debugging symbol, e.g.
581 ALL_PSYMTABS (objfile
, ps
)
583 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
585 s
= PSYMTAB_TO_SYMTAB(ps
);
586 bv
= BLOCKVECTOR (s
);
587 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
588 sym
= lookup_block_symbol (block
, name
, namespace);
590 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
597 /* Now search all per-file blocks.
598 Not strictly correct, but more useful than an error.
599 Do the symtabs first, then check the psymtabs */
601 ALL_SYMTABS (objfile
, s
)
603 bv
= BLOCKVECTOR (s
);
604 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
605 sym
= lookup_block_symbol (block
, name
, namespace);
615 ALL_PSYMTABS (objfile
, ps
)
617 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
619 s
= PSYMTAB_TO_SYMTAB(ps
);
620 bv
= BLOCKVECTOR (s
);
621 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
622 sym
= lookup_block_symbol (block
, name
, namespace);
624 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
631 /* Now search all per-file blocks for static mangled symbols.
632 Do the symtabs first, then check the psymtabs. */
634 if (namespace == VAR_NAMESPACE
)
636 ALL_SYMTABS (objfile
, s
)
638 bv
= BLOCKVECTOR (s
);
639 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
640 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
650 ALL_PSYMTABS (objfile
, ps
)
652 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
654 s
= PSYMTAB_TO_SYMTAB(ps
);
655 bv
= BLOCKVECTOR (s
);
656 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
657 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
659 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
672 /* Look, in partial_symtab PST, for symbol NAME. Check the global
673 symbols if GLOBAL, the static symbols if not */
675 static struct partial_symbol
*
676 lookup_partial_symbol (pst
, name
, global
, namespace)
677 struct partial_symtab
*pst
;
680 enum namespace namespace;
682 struct partial_symbol
*start
, *psym
;
683 struct partial_symbol
*top
, *bottom
, *center
;
684 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
685 int do_linear_search
= 1;
693 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
694 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
696 if (global
) /* This means we can use a binary search. */
698 do_linear_search
= 0;
700 /* Binary search. This search is guaranteed to end with center
701 pointing at the earliest partial symbol with the correct
702 name. At that point *all* partial symbols with that name
703 will be checked against the correct namespace. */
706 top
= start
+ length
- 1;
709 center
= bottom
+ (top
- bottom
) / 2;
710 assert (center
< top
);
711 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
713 do_linear_search
= 1;
715 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
724 assert (top
== bottom
);
725 while (STREQ (SYMBOL_NAME (top
), name
))
727 if (SYMBOL_NAMESPACE (top
) == namespace)
735 /* Can't use a binary search or else we found during the binary search that
736 we should also do a linear search. */
738 if (do_linear_search
)
740 for (psym
= start
; psym
< start
+ length
; psym
++)
742 if (namespace == SYMBOL_NAMESPACE (psym
))
744 if (SYMBOL_MATCHES_NAME (psym
, name
))
755 /* Find the psymtab containing main(). */
756 /* FIXME: What about languages without main() or specially linked
757 executables that have no main() ? */
759 struct partial_symtab
*
762 register struct partial_symtab
*pst
;
763 register struct objfile
*objfile
;
765 ALL_PSYMTABS (objfile
, pst
)
767 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
775 /* Search BLOCK for symbol NAME in NAMESPACE.
777 Note that if NAME is the demangled form of a C++ symbol, we will fail
778 to find a match during the binary search of the non-encoded names, but
779 for now we don't worry about the slight inefficiency of looking for
780 a match we'll never find, since it will go pretty quick. Once the
781 binary search terminates, we drop through and do a straight linear
782 search on the symbols. Each symbol which is marked as being a C++
783 symbol (language_cplus set) has both the encoded and non-encoded names
784 tested for a match. */
787 lookup_block_symbol (block
, name
, namespace)
788 register const struct block
*block
;
790 const enum namespace namespace;
792 register int bot
, top
, inc
;
793 register struct symbol
*sym
;
794 register struct symbol
*sym_found
= NULL
;
795 register int do_linear_search
= 1;
797 /* If the blocks's symbols were sorted, start with a binary search. */
799 if (BLOCK_SHOULD_SORT (block
))
801 /* Reset the linear search flag so if the binary search fails, we
802 won't do the linear search once unless we find some reason to
803 do so, such as finding a C++ symbol during the binary search.
804 Note that for C++ modules, ALL the symbols in a block should
805 end up marked as C++ symbols. */
807 do_linear_search
= 0;
808 top
= BLOCK_NSYMS (block
);
811 /* Advance BOT to not far before the first symbol whose name is NAME. */
815 inc
= (top
- bot
+ 1);
816 /* No need to keep binary searching for the last few bits worth. */
821 inc
= (inc
>> 1) + bot
;
822 sym
= BLOCK_SYM (block
, inc
);
823 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
825 do_linear_search
= 1;
827 if (SYMBOL_NAME (sym
)[0] < name
[0])
831 else if (SYMBOL_NAME (sym
)[0] > name
[0])
835 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
845 /* Now scan forward until we run out of symbols, find one whose
846 name is greater than NAME, or find one we want. If there is
847 more than one symbol with the right name and namespace, we
848 return the first one; I believe it is now impossible for us
849 to encounter two symbols with the same name and namespace
850 here, because blocks containing argument symbols are no
853 top
= BLOCK_NSYMS (block
);
856 sym
= BLOCK_SYM (block
, bot
);
857 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
860 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
862 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
874 /* Here if block isn't sorted, or we fail to find a match during the
875 binary search above. If during the binary search above, we find a
876 symbol which is a C++ symbol, then we have re-enabled the linear
877 search flag which was reset when starting the binary search.
879 This loop is equivalent to the loop above, but hacked greatly for speed.
881 Note that parameter symbols do not always show up last in the
882 list; this loop makes sure to take anything else other than
883 parameter symbols first; it only uses parameter symbols as a
884 last resort. Note that this only takes up extra computation
887 if (do_linear_search
)
889 top
= BLOCK_NSYMS (block
);
893 sym
= BLOCK_SYM (block
, bot
);
894 if (SYMBOL_NAMESPACE (sym
) == namespace &&
895 SYMBOL_MATCHES_NAME (sym
, name
))
898 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
899 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
900 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
901 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
902 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
903 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
911 return (sym_found
); /* Will be NULL if not found. */
915 /* Return the symbol for the function which contains a specified
916 lexical block, described by a struct block BL. */
922 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
923 bl
= BLOCK_SUPERBLOCK (bl
);
925 return BLOCK_FUNCTION (bl
);
928 /* Find the symtab associated with PC. Look through the psymtabs and read in
929 another symtab if necessary. */
933 register CORE_ADDR pc
;
935 register struct block
*b
;
936 struct blockvector
*bv
;
937 register struct symtab
*s
= NULL
;
938 register struct symtab
*best_s
= NULL
;
939 register struct partial_symtab
*ps
;
940 register struct objfile
*objfile
;
943 /* Search all symtabs for the one whose file contains our address, and which
944 is the smallest of all the ones containing the address. This is designed
945 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
946 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
947 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
948 This is said to happen for the mips; it might be swifter to create
949 several symtabs with the same name like xcoff does (I'm not sure). */
951 ALL_SYMTABS (objfile
, s
)
953 bv
= BLOCKVECTOR (s
);
954 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
955 if (BLOCK_START (b
) <= pc
956 && BLOCK_END (b
) > pc
958 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
960 distance
= BLOCK_END (b
) - BLOCK_START (b
);
969 ps
= find_pc_psymtab (pc
);
973 /* Might want to error() here (in case symtab is corrupt and
974 will cause a core dump), but maybe we can successfully
975 continue, so let's not. */
977 (Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
978 s
= PSYMTAB_TO_SYMTAB (ps
);
983 /* Find the source file and line number for a given PC value.
984 Return a structure containing a symtab pointer, a line number,
985 and a pc range for the entire source line.
986 The value's .pc field is NOT the specified pc.
987 NOTCURRENT nonzero means, if specified pc is on a line boundary,
988 use the line that ends there. Otherwise, in that case, the line
989 that begins there is used. */
991 /* The big complication here is that a line may start in one file, and end just
992 before the start of another file. This usually occurs when you #include
993 code in the middle of a subroutine. To properly find the end of a line's PC
994 range, we must search all symtabs associated with this compilation unit, and
995 find the one whose first PC is closer than that of the next line in this
998 FIXME: We used to complain here about zero length or negative length line
999 tables, but there are two problems with this: (1) some symtabs may not have
1000 any line numbers due to gcc -g1 compilation, and (2) this function is called
1001 during single stepping, when we don't own the terminal and thus can't
1002 produce any output. One solution might be to implement a mechanism whereby
1003 complaints can be queued until we regain control of the terminal. -fnf
1006 /* If it's worth the effort, we could be using a binary search. */
1008 struct symtab_and_line
1009 find_pc_line (pc
, notcurrent
)
1014 register struct linetable
*l
;
1017 register struct linetable_entry
*item
;
1018 struct symtab_and_line val
;
1019 struct blockvector
*bv
;
1021 /* Info on best line seen so far, and where it starts, and its file. */
1023 struct linetable_entry
*best
= NULL
;
1024 CORE_ADDR best_end
= 0;
1025 struct symtab
*best_symtab
= 0;
1027 /* Store here the first line number
1028 of a file which contains the line at the smallest pc after PC.
1029 If we don't find a line whose range contains PC,
1030 we will use a line one less than this,
1031 with a range from the start of that file to the first line's pc. */
1032 struct linetable_entry
*alt
= NULL
;
1033 struct symtab
*alt_symtab
= 0;
1035 /* Info on best line seen in this file. */
1037 struct linetable_entry
*prev
;
1039 /* If this pc is not from the current frame,
1040 it is the address of the end of a call instruction.
1041 Quite likely that is the start of the following statement.
1042 But what we want is the statement containing the instruction.
1043 Fudge the pc to make sure we get that. */
1045 if (notcurrent
) pc
-= 1;
1047 s
= find_pc_symtab (pc
);
1057 bv
= BLOCKVECTOR (s
);
1059 /* Look at all the symtabs that share this blockvector.
1060 They all have the same apriori range, that we found was right;
1061 but they have different line tables. */
1063 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1065 /* Find the best line in this symtab. */
1070 if (len
<= 0) /* See FIXME above. */
1076 item
= l
->item
; /* Get first line info */
1078 /* Is this file's first line closer than the first lines of other files?
1079 If so, record this file, and its first line, as best alternate. */
1080 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1086 for (i
= 0; i
< len
; i
++, item
++)
1088 /* Return the last line that did not start after PC. */
1095 /* At this point, prev points at the line whose start addr is <= pc, and
1096 item points at the next line. If we ran off the end of the linetable
1097 (pc >= start of the last line), then prev == item. If pc < start of
1098 the first line, prev will not be set. */
1100 /* Is this file's best line closer than the best in the other files?
1101 If so, record this file, and its best line, as best so far. */
1103 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1107 /* If another line is in the linetable, and its PC is closer
1108 than the best_end we currently have, take it as best_end. */
1109 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1110 best_end
= item
->pc
;
1117 { /* If we didn't find any line # info, just
1126 val
.symtab
= alt_symtab
;
1127 val
.line
= alt
->line
- 1;
1128 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1134 val
.symtab
= best_symtab
;
1135 val
.line
= best
->line
;
1137 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1142 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1147 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1150 /* Find line number LINE in any symtab whose name is the same as
1153 If found, return 1, set *LINETABLE to the linetable in which it was
1154 found, set *INDEX to the index in the linetable of the best entry
1155 found, and set *EXACT_MATCH nonzero if the value returned is an
1158 If not found, return 0. */
1161 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1162 struct symtab
*symtab
;
1164 struct linetable
**linetable
;
1170 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1174 struct linetable
*best_linetable
;
1176 /* First try looking it up in the given symtab. */
1177 best_linetable
= LINETABLE (symtab
);
1178 best_index
= find_line_common (best_linetable
, line
, &exact
);
1179 if (best_index
< 0 || !exact
)
1181 /* Didn't find an exact match. So we better keep looking for
1182 another symtab with the same name. In the case of xcoff,
1183 multiple csects for one source file (produced by IBM's FORTRAN
1184 compiler) produce multiple symtabs (this is unavoidable
1185 assuming csects can be at arbitrary places in memory and that
1186 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1188 /* BEST is the smallest linenumber > LINE so far seen,
1189 or 0 if none has been seen so far.
1190 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1193 struct objfile
*objfile
;
1196 if (best_index
>= 0)
1197 best
= best_linetable
->item
[best_index
].line
;
1201 ALL_SYMTABS (objfile
, s
)
1203 struct linetable
*l
;
1206 if (!STREQ (symtab
->filename
, s
->filename
))
1209 ind
= find_line_common (l
, line
, &exact
);
1218 if (best
== 0 || l
->item
[ind
].line
< best
)
1220 best
= l
->item
[ind
].line
;
1232 *index
= best_index
;
1234 *linetable
= best_linetable
;
1236 *exact_match
= exact
;
1240 /* Find the PC value for a given source file and line number.
1241 Returns zero for invalid line number.
1242 The source file is specified with a struct symtab. */
1245 find_line_pc (symtab
, line
)
1246 struct symtab
*symtab
;
1249 struct linetable
*l
;
1254 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1255 return l
->item
[ind
].pc
;
1260 /* Find the range of pc values in a line.
1261 Store the starting pc of the line into *STARTPTR
1262 and the ending pc (start of next line) into *ENDPTR.
1263 Returns 1 to indicate success.
1264 Returns 0 if could not find the specified line. */
1267 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1268 struct symtab
*symtab
;
1270 CORE_ADDR
*startptr
, *endptr
;
1272 struct linetable
*l
;
1274 int exact_match
; /* did we get an exact linenumber match */
1279 if (find_line_symtab (symtab
, thisline
, &l
, &ind
, &exact_match
))
1281 *startptr
= l
->item
[ind
].pc
;
1282 /* If we have not seen an entry for the specified line,
1283 assume that means the specified line has zero bytes. */
1284 if (!exact_match
|| ind
== l
->nitems
-1)
1285 *endptr
= *startptr
;
1287 /* Perhaps the following entry is for the following line.
1288 It's worth a try. */
1289 if (ind
+1 < l
->nitems
1290 && l
->item
[ind
+1].line
== thisline
+ 1)
1291 *endptr
= l
->item
[ind
+1].pc
;
1293 *endptr
= find_line_pc (symtab
, thisline
+1);
1300 /* Given a line table and a line number, return the index into the line
1301 table for the pc of the nearest line whose number is >= the specified one.
1302 Return -1 if none is found. The value is >= 0 if it is an index.
1304 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1307 find_line_common (l
, lineno
, exact_match
)
1308 register struct linetable
*l
;
1309 register int lineno
;
1315 /* BEST is the smallest linenumber > LINENO so far seen,
1316 or 0 if none has been seen so far.
1317 BEST_INDEX identifies the item for it. */
1319 int best_index
= -1;
1328 for (i
= 0; i
< len
; i
++)
1330 register struct linetable_entry
*item
= &(l
->item
[i
]);
1332 if (item
->line
== lineno
)
1334 /* Return the first (lowest address) entry which matches. */
1339 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1346 /* If we got here, we didn't get an exact match. */
1353 find_pc_line_pc_range (pc
, startptr
, endptr
)
1355 CORE_ADDR
*startptr
, *endptr
;
1357 struct symtab_and_line sal
;
1358 sal
= find_pc_line (pc
, 0);
1361 return sal
.symtab
!= 0;
1364 /* If P is of the form "operator[ \t]+..." where `...' is
1365 some legitimate operator text, return a pointer to the
1366 beginning of the substring of the operator text.
1367 Otherwise, return "". */
1369 operator_chars (p
, end
)
1374 if (strncmp (p
, "operator", 8))
1378 /* Don't get faked out by `operator' being part of a longer
1380 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1383 /* Allow some whitespace between `operator' and the operator symbol. */
1384 while (*p
== ' ' || *p
== '\t')
1387 /* Recognize 'operator TYPENAME'. */
1389 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1391 register char *q
= p
+1;
1392 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1417 if (p
[1] == '=' || p
[1] == p
[0])
1428 error ("`operator ()' must be specified without whitespace in `()'");
1433 error ("`operator ?:' must be specified without whitespace in `?:'");
1438 error ("`operator []' must be specified without whitespace in `[]'");
1442 error ("`operator %s' not supported", p
);
1449 /* Recursive helper function for decode_line_1.
1450 * Look for methods named NAME in type T.
1451 * Return number of matches.
1452 * Put matches in SYM_ARR (which better be big enough!).
1453 * These allocations seem to define "big enough":
1454 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1455 * Note that this function is g++ specific.
1459 find_methods (t
, name
, sym_arr
)
1462 struct symbol
**sym_arr
;
1466 struct symbol
*sym_class
;
1467 char *class_name
= type_name_no_tag (t
);
1468 /* Ignore this class if it doesn't have a name. This is ugly, but
1469 unless we figure out how to get the physname without the name of
1470 the class, then the loop can't do any good. */
1472 && (sym_class
= lookup_symbol (class_name
,
1473 (struct block
*)NULL
,
1476 (struct symtab
**)NULL
)))
1479 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1480 t
= SYMBOL_TYPE (sym_class
);
1481 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1482 method_counter
>= 0;
1486 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1488 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1489 if (STREQ (name
, method_name
))
1490 /* Find all the fields with that name. */
1491 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1496 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1497 check_stub_method (t
, method_counter
, field_counter
);
1498 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1499 /* Destructor is handled by caller, dont add it to the list */
1500 if (DESTRUCTOR_PREFIX_P (phys_name
))
1503 /* FIXME: Why are we looking this up in the
1504 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1505 for nested types? If so, it should probably hook to the
1506 type, not the symbol. mipsread.c is the only symbol
1507 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1508 this is not documented in symtab.h. -26Aug93. */
1510 sym_arr
[i1
] = lookup_symbol (phys_name
,
1511 SYMBOL_BLOCK_VALUE (sym_class
),
1514 (struct symtab
**) NULL
);
1515 if (sym_arr
[i1
]) i1
++;
1518 fputs_filtered("(Cannot find method ", stdout
);
1519 fprintf_symbol_filtered (stdout
, phys_name
,
1520 language_cplus
, DMGL_PARAMS
);
1521 fputs_filtered(" - possibly inlined.)\n", stdout
);
1527 /* Only search baseclasses if there is no match yet, since names in
1528 derived classes override those in baseclasses.
1530 FIXME: The above is not true; it is only true of member functions
1531 if they have the same number of arguments (??? - section 13.1 of the
1532 ARM says the function members are not in the same scope but doesn't
1533 really spell out the rules in a way I understand. In any case, if
1534 the number of arguments differ this is a case in which we can overload
1535 rather than hiding without any problem, and gcc 2.4.5 does overload
1536 rather than hiding in this case). */
1540 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1541 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1546 /* Helper function for decode_line_1.
1547 Build a canonical line spec in CANONICAL if it is non-NULL and if
1548 the SAL has a symtab.
1549 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1550 If SYMNAME is NULL the line number from SAL is used and the canonical
1551 line spec is `filename:linenum'. */
1554 build_canonical_line_spec (sal
, symname
, canonical
)
1555 struct symtab_and_line
*sal
;
1559 char **canonical_arr
;
1560 char *canonical_name
;
1562 struct symtab
*s
= sal
->symtab
;
1564 if (s
== (struct symtab
*)NULL
1565 || s
->filename
== (char *)NULL
1566 || canonical
== (char ***)NULL
)
1569 canonical_arr
= (char **) xmalloc (sizeof (char *));
1570 *canonical
= canonical_arr
;
1572 filename
= s
->filename
;
1573 if (symname
!= NULL
)
1575 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1576 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1580 canonical_name
= xmalloc (strlen (filename
) + 30);
1581 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1583 canonical_arr
[0] = canonical_name
;
1586 /* Parse a string that specifies a line number.
1587 Pass the address of a char * variable; that variable will be
1588 advanced over the characters actually parsed.
1592 LINENUM -- that line number in current file. PC returned is 0.
1593 FILE:LINENUM -- that line in that file. PC returned is 0.
1594 FUNCTION -- line number of openbrace of that function.
1595 PC returned is the start of the function.
1596 VARIABLE -- line number of definition of that variable.
1598 FILE:FUNCTION -- likewise, but prefer functions in that file.
1599 *EXPR -- line in which address EXPR appears.
1601 FUNCTION may be an undebuggable function found in minimal symbol table.
1603 If the argument FUNFIRSTLINE is nonzero, we want the first line
1604 of real code inside a function when a function is specified.
1606 DEFAULT_SYMTAB specifies the file to use if none is specified.
1607 It defaults to current_source_symtab.
1608 DEFAULT_LINE specifies the line number to use for relative
1609 line numbers (that start with signs). Defaults to current_source_line.
1610 If CANONICAL is non-NULL, store an array of strings containing the canonical
1611 line specs there if necessary. Currently overloaded member functions and
1612 line numbers or static functions without a filename yield a canonical
1613 line spec. The array and the line spec strings are allocated on the heap,
1614 it is the callers responsibility to free them.
1616 Note that it is possible to return zero for the symtab
1617 if no file is validly specified. Callers must check that.
1618 Also, the line number returned may be invalid. */
1620 struct symtabs_and_lines
1621 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1624 struct symtab
*default_symtab
;
1628 struct symtabs_and_lines values
;
1629 #ifdef HPPA_COMPILER_BUG
1630 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1631 when optimizing this file with target i960-vxworks. I haven't
1632 been able to construct a simple test case. The problem is that
1633 in the second call to SKIP_PROLOGUE below, the compiler somehow
1634 does not realize that the statement val = find_pc_line (...) will
1635 change the values of the fields of val. It extracts the elements
1636 into registers at the top of the block, and does not update the
1637 registers after the call to find_pc_line. You can check this by
1638 inserting a printf at the end of find_pc_line to show what values
1639 it is returning for val.pc and val.end and another printf after
1640 the call to see what values the function actually got (remember,
1641 this is compiling with cc -O, with this patch removed). You can
1642 also examine the assembly listing: search for the second call to
1643 skip_prologue; the LDO statement before the next call to
1644 find_pc_line loads the address of the structure which
1645 find_pc_line will return; if there is a LDW just before the LDO,
1646 which fetches an element of the structure, then the compiler
1649 Setting val to volatile avoids the problem. We must undef
1650 volatile, because the HPPA native compiler does not define
1651 __STDC__, although it does understand volatile, and so volatile
1652 will have been defined away in defs.h. */
1654 volatile struct symtab_and_line val
;
1655 #define volatile /*nothing*/
1657 struct symtab_and_line val
;
1659 register char *p
, *p1
;
1661 register struct symtab
*s
;
1663 register struct symbol
*sym
;
1664 /* The symtab that SYM was found in. */
1665 struct symtab
*sym_symtab
;
1667 register CORE_ADDR pc
;
1668 register struct minimal_symbol
*msymbol
;
1670 struct symbol
*sym_class
;
1673 struct symbol
**sym_arr
;
1675 char *saved_arg
= *argptr
;
1676 extern char *gdb_completer_quote_characters
;
1678 /* Defaults have defaults. */
1680 if (default_symtab
== 0)
1682 default_symtab
= current_source_symtab
;
1683 default_line
= current_source_line
;
1686 /* See if arg is *PC */
1688 if (**argptr
== '*')
1690 if (**argptr
== '*')
1694 pc
= parse_and_eval_address_1 (argptr
);
1695 values
.sals
= (struct symtab_and_line
*)
1696 xmalloc (sizeof (struct symtab_and_line
));
1698 values
.sals
[0] = find_pc_line (pc
, 0);
1699 values
.sals
[0].pc
= pc
;
1700 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1704 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1707 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1709 for (p
= *argptr
; *p
; p
++)
1711 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1714 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1716 if ((p
[0] == ':') && !is_quoted
)
1722 /* Extract the class name. */
1724 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1725 copy
= (char *) alloca (p
- *argptr
+ 1);
1726 memcpy (copy
, *argptr
, p
- *argptr
);
1727 copy
[p
- *argptr
] = 0;
1729 /* Discard the class name from the arg. */
1731 while (*p
== ' ' || *p
== '\t') p
++;
1734 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1735 (struct symtab
**)NULL
);
1738 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1739 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1741 /* Arg token is not digits => try it as a function name
1742 Find the next token (everything up to end or next whitespace). */
1744 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1745 q
= operator_chars (*argptr
, &q1
);
1750 char *tmp
= alloca (q1
- q
+ 1);
1751 memcpy (tmp
, q
, q1
- q
);
1753 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1756 warning ("no mangling for \"%s\"", tmp
);
1757 cplusplus_hint (saved_arg
);
1758 return_to_top_level (RETURN_ERROR
);
1760 copy
= (char*) alloca (3 + strlen(opname
));
1761 sprintf (copy
, "__%s", opname
);
1766 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1767 memcpy (copy
, *argptr
, p
- *argptr
);
1768 copy
[p
- *argptr
] = '\0';
1771 /* no line number may be specified */
1772 while (*p
== ' ' || *p
== '\t') p
++;
1776 i1
= 0; /* counter for the symbol array */
1777 t
= SYMBOL_TYPE (sym_class
);
1778 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1780 /* Cfront objects don't have fieldlists. */
1781 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1783 /* destructors are a special case. */
1784 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1785 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1786 /* gcc 1.x puts destructor in last field,
1787 gcc 2.x puts destructor in first field. */
1788 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1789 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1791 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1792 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1796 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1797 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1798 if (sym_arr
[i1
]) i1
++;
1801 i1
= find_methods (t
, copy
, sym_arr
);
1804 /* There is exactly one field with that name. */
1807 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1809 /* Arg is the name of a function */
1810 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1813 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1815 values
.sals
[0] = find_pc_line (pc
, 0);
1816 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1826 /* There is more than one field with that name
1827 (overloaded). Ask the user which one to use. */
1828 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1834 if (OPNAME_PREFIX_P (copy
))
1836 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1837 strcpy (tmp
, "operator ");
1838 strcat (tmp
, copy
+3);
1843 warning ("the class `%s' does not have destructor defined",
1844 SYMBOL_SOURCE_NAME(sym_class
));
1846 warning ("the class %s does not have any method named %s",
1847 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1848 cplusplus_hint (saved_arg
);
1849 return_to_top_level (RETURN_ERROR
);
1854 /* The quotes are important if copy is empty. */
1855 warning ("can't find class, struct, or union named \"%s\"",
1857 cplusplus_hint (saved_arg
);
1858 return_to_top_level (RETURN_ERROR
);
1864 /* Extract the file name. */
1866 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1867 copy
= (char *) alloca (p
- *argptr
+ 1);
1868 memcpy (copy
, *argptr
, p
- *argptr
);
1869 copy
[p
- *argptr
] = 0;
1871 /* Find that file's data. */
1872 s
= lookup_symtab (copy
);
1875 if (!have_full_symbols () && !have_partial_symbols ())
1876 error (no_symtab_msg
);
1877 error ("No source file named %s.", copy
);
1880 /* Discard the file name from the arg. */
1882 while (*p
== ' ' || *p
== '\t') p
++;
1886 /* S is specified file's symtab, or 0 if no file specified.
1887 arg no longer contains the file name. */
1889 /* Check whether arg is all digits (and sign) */
1892 if (*p
== '-' || *p
== '+') p
++;
1893 while (*p
>= '0' && *p
<= '9')
1896 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1898 /* We found a token consisting of all digits -- at least one digit. */
1899 enum sign
{none
, plus
, minus
} sign
= none
;
1901 /* We might need a canonical line spec if no file was specified. */
1902 int need_canonical
= (s
== 0) ? 1 : 0;
1904 /* This is where we need to make sure that we have good defaults.
1905 We must guarantee that this section of code is never executed
1906 when we are called with just a function name, since
1907 select_source_symtab calls us with such an argument */
1909 if (s
== 0 && default_symtab
== 0)
1911 select_source_symtab (0);
1912 default_symtab
= current_source_symtab
;
1913 default_line
= current_source_line
;
1916 if (**argptr
== '+')
1917 sign
= plus
, (*argptr
)++;
1918 else if (**argptr
== '-')
1919 sign
= minus
, (*argptr
)++;
1920 val
.line
= atoi (*argptr
);
1927 val
.line
= default_line
+ val
.line
;
1933 val
.line
= default_line
- val
.line
;
1938 break; /* No need to adjust val.line. */
1941 while (*p
== ' ' || *p
== '\t') p
++;
1947 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1948 values
.sals
[0] = val
;
1951 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1955 /* Arg token is not digits => try it as a variable name
1956 Find the next token (everything up to end or next whitespace). */
1958 p
= skip_quoted (*argptr
);
1959 if (is_quoted
&& p
[-1] != '\'')
1960 error ("Unmatched single quote.");
1961 copy
= (char *) alloca (p
- *argptr
+ 1);
1962 memcpy (copy
, *argptr
, p
- *argptr
);
1963 copy
[p
- *argptr
] = '\0';
1964 if ((copy
[0] == copy
[p
- *argptr
- 1])
1965 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1968 copy
[p
- *argptr
- 1] = '\0';
1971 while (*p
== ' ' || *p
== '\t') p
++;
1974 /* Look up that token as a variable.
1975 If file specified, use that file's per-file block to start with. */
1977 sym
= lookup_symbol (copy
,
1978 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1979 : get_selected_block ()),
1980 VAR_NAMESPACE
, 0, &sym_symtab
);
1984 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1986 /* Arg is the name of a function */
1987 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1990 val
= find_pc_line (pc
, 0);
1991 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1992 /* Convex: no need to suppress code on first line, if any */
1995 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1996 line is still part of the same function. */
1998 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
1999 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2001 /* First pc of next line */
2003 /* Recalculate the line number (might not be N+1). */
2004 val
= find_pc_line (pc
, 0);
2008 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2009 values
.sals
[0] = val
;
2012 /* I think this is always the same as the line that
2013 we calculate above, but the general principle is
2014 "trust the symbols more than stuff like
2016 if (SYMBOL_LINE (sym
) != 0)
2017 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2019 /* We might need a canonical line spec if it is a static function. */
2022 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2023 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2024 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2025 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2029 else if (SYMBOL_LINE (sym
) != 0)
2031 /* We know its line number. */
2032 values
.sals
= (struct symtab_and_line
*)
2033 xmalloc (sizeof (struct symtab_and_line
));
2035 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2036 values
.sals
[0].symtab
= sym_symtab
;
2037 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2041 /* This can happen if it is compiled with a compiler which doesn't
2042 put out line numbers for variables. */
2043 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2044 return? For example, "info line foo" could print the address. */
2045 error ("Line number not known for symbol \"%s\"", copy
);
2048 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2049 if (msymbol
!= NULL
)
2053 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
) + FUNCTION_START_OFFSET
;
2055 SKIP_PROLOGUE (val
.pc
);
2056 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2057 values
.sals
[0] = val
;
2062 if (!have_full_symbols () &&
2063 !have_partial_symbols () && !have_minimal_symbols ())
2064 error (no_symtab_msg
);
2066 error ("Function \"%s\" not defined.", copy
);
2067 return values
; /* for lint */
2070 struct symtabs_and_lines
2071 decode_line_spec (string
, funfirstline
)
2075 struct symtabs_and_lines sals
;
2077 error ("Empty line specification.");
2078 sals
= decode_line_1 (&string
, funfirstline
,
2079 current_source_symtab
, current_source_line
,
2082 error ("Junk at end of line specification: %s", string
);
2086 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2087 operate on (ask user if necessary).
2088 If CANONICAL is non-NULL return a corresponding array of mangled names
2089 as canonical line specs there. */
2091 static struct symtabs_and_lines
2092 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2093 struct symbol
*sym_arr
[];
2098 struct symtabs_and_lines values
, return_values
;
2099 register CORE_ADDR pc
;
2104 struct cleanup
*old_chain
;
2105 char **canonical_arr
= (char **)NULL
;
2107 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2108 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2109 old_chain
= make_cleanup (free
, return_values
.sals
);
2113 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2114 make_cleanup (free
, canonical_arr
);
2115 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2116 *canonical
= canonical_arr
;
2120 printf("[0] cancel\n[1] all\n");
2123 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2125 /* Arg is the name of a function */
2126 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2127 + FUNCTION_START_OFFSET
;
2130 values
.sals
[i
] = find_pc_line (pc
, 0);
2131 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2132 values
.sals
[i
].end
: pc
;
2133 printf("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2134 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2136 else printf ("?HERE\n");
2140 if ((prompt
= getenv ("PS2")) == NULL
)
2144 printf("%s ",prompt
);
2147 args
= command_line_input ((char *) NULL
, 0);
2149 if (args
== 0 || *args
== 0)
2150 error_no_arg ("one or more choice numbers");
2158 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2159 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2160 error ("Arguments must be choice numbers.");
2165 error ("cancelled");
2170 for (i
= 0; i
< nelts
; i
++)
2172 if (canonical_arr
[i
] == NULL
)
2174 symname
= SYMBOL_NAME (sym_arr
[i
]);
2175 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2179 memcpy (return_values
.sals
, values
.sals
,
2180 (nelts
* sizeof(struct symtab_and_line
)));
2181 return_values
.nelts
= nelts
;
2182 discard_cleanups (old_chain
);
2183 return return_values
;
2186 if (num
> nelts
+ 2)
2188 printf ("No choice number %d.\n", num
);
2193 if (values
.sals
[num
].pc
)
2197 symname
= SYMBOL_NAME (sym_arr
[num
]);
2198 make_cleanup (free
, symname
);
2199 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2201 return_values
.sals
[i
++] = values
.sals
[num
];
2202 values
.sals
[num
].pc
= 0;
2206 printf ("duplicate request for %d ignored.\n", num
);
2211 while (*args
== ' ' || *args
== '\t') args
++;
2213 return_values
.nelts
= i
;
2214 discard_cleanups (old_chain
);
2215 return return_values
;
2219 /* Slave routine for sources_info. Force line breaks at ,'s.
2220 NAME is the name to print and *FIRST is nonzero if this is the first
2221 name printed. Set *FIRST to zero. */
2223 output_source_filename (name
, first
)
2227 /* Table of files printed so far. Since a single source file can
2228 result in several partial symbol tables, we need to avoid printing
2229 it more than once. Note: if some of the psymtabs are read in and
2230 some are not, it gets printed both under "Source files for which
2231 symbols have been read" and "Source files for which symbols will
2232 be read in on demand". I consider this a reasonable way to deal
2233 with the situation. I'm not sure whether this can also happen for
2234 symtabs; it doesn't hurt to check. */
2235 static char **tab
= NULL
;
2236 /* Allocated size of tab in elements.
2237 Start with one 256-byte block (when using GNU malloc.c).
2238 24 is the malloc overhead when range checking is in effect. */
2239 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2240 /* Current size of tab in elements. */
2241 static int tab_cur_size
;
2248 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2252 /* Is NAME in tab? */
2253 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2254 if (STREQ (*p
, name
))
2255 /* Yes; don't print it again. */
2257 /* No; add it to tab. */
2258 if (tab_cur_size
== tab_alloc_size
)
2260 tab_alloc_size
*= 2;
2261 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2263 tab
[tab_cur_size
++] = name
;
2271 printf_filtered (", ");
2275 fputs_filtered (name
, stdout
);
2279 sources_info (ignore
, from_tty
)
2283 register struct symtab
*s
;
2284 register struct partial_symtab
*ps
;
2285 register struct objfile
*objfile
;
2288 if (!have_full_symbols () && !have_partial_symbols ())
2290 error (no_symtab_msg
);
2293 printf_filtered ("Source files for which symbols have been read in:\n\n");
2296 ALL_SYMTABS (objfile
, s
)
2298 output_source_filename (s
-> filename
, &first
);
2300 printf_filtered ("\n\n");
2302 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2305 ALL_PSYMTABS (objfile
, ps
)
2309 output_source_filename (ps
-> filename
, &first
);
2312 printf_filtered ("\n");
2315 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2316 If CLASS is zero, list all symbols except functions, type names, and
2318 If CLASS is 1, list only functions.
2319 If CLASS is 2, list only type names.
2320 If CLASS is 3, list only method names.
2322 BPT is non-zero if we should set a breakpoint at the functions
2326 list_symbols (regexp
, class, bpt
)
2331 register struct symtab
*s
;
2332 register struct partial_symtab
*ps
;
2333 register struct blockvector
*bv
;
2334 struct blockvector
*prev_bv
= 0;
2335 register struct block
*b
;
2337 register struct symbol
*sym
;
2338 struct partial_symbol
*psym
;
2339 struct objfile
*objfile
;
2340 struct minimal_symbol
*msymbol
;
2342 static char *classnames
[]
2343 = {"variable", "function", "type", "method"};
2344 int found_in_file
= 0;
2346 static enum minimal_symbol_type types
[]
2347 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2348 static enum minimal_symbol_type types2
[]
2349 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2350 enum minimal_symbol_type ourtype
= types
[class];
2351 enum minimal_symbol_type ourtype2
= types2
[class];
2355 /* Make sure spacing is right for C++ operators.
2356 This is just a courtesy to make the matching less sensitive
2357 to how many spaces the user leaves between 'operator'
2358 and <TYPENAME> or <OPERATOR>. */
2360 char *opname
= operator_chars (regexp
, &opend
);
2363 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2364 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2366 /* There should 1 space between 'operator' and 'TYPENAME'. */
2367 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2372 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2373 if (opname
[-1] == ' ')
2376 /* If wrong number of spaces, fix it. */
2379 char *tmp
= (char*) alloca(opend
-opname
+10);
2380 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2385 if (0 != (val
= re_comp (regexp
)))
2386 error ("Invalid regexp (%s): %s", val
, regexp
);
2389 /* Search through the partial symtabs *first* for all symbols
2390 matching the regexp. That way we don't have to reproduce all of
2391 the machinery below. */
2393 ALL_PSYMTABS (objfile
, ps
)
2395 struct partial_symbol
*bound
, *gbound
, *sbound
;
2398 if (ps
->readin
) continue;
2400 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2401 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2404 /* Go through all of the symbols stored in a partial
2405 symtab in one loop. */
2406 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2411 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2413 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2424 /* If it would match (logic taken from loop below)
2425 load the file and go on to the next one */
2426 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2427 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2428 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2429 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2430 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2431 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2433 PSYMTAB_TO_SYMTAB(ps
);
2441 /* Here, we search through the minimal symbol tables for functions that
2442 match, and call find_pc_symtab on them to force their symbols to
2443 be read. The symbol will then be found during the scan of symtabs
2444 below. If find_pc_symtab fails, set found_misc so that we will
2445 rescan to print any matching symbols without debug info. */
2449 ALL_MSYMBOLS (objfile
, msymbol
)
2451 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2452 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2454 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2456 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2465 /* Printout here so as to get after the "Reading in symbols"
2466 messages which will be generated above. */
2468 printf_filtered (regexp
2469 ? "All %ss matching regular expression \"%s\":\n"
2470 : "All defined %ss:\n",
2474 ALL_SYMTABS (objfile
, s
)
2477 bv
= BLOCKVECTOR (s
);
2478 /* Often many files share a blockvector.
2479 Scan each blockvector only once so that
2480 we don't get every symbol many times.
2481 It happens that the first symtab in the list
2482 for any given blockvector is the main file. */
2484 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2486 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2487 /* Skip the sort if this block is always sorted. */
2488 if (!BLOCK_SHOULD_SORT (b
))
2489 sort_block_syms (b
);
2490 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2493 sym
= BLOCK_SYM (b
, j
);
2494 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2495 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2496 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2497 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2498 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2499 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2500 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2504 /* Set a breakpoint here, if it's a function */
2507 /* There may be more than one function with the
2508 same name but in different files. In order to
2509 set breakpoints on all of them, we must give
2510 both the file name and the function name to
2513 (char *) alloca (strlen (s
->filename
)
2514 + strlen (SYMBOL_NAME(sym
))
2516 strcpy (string
, s
->filename
);
2517 strcat (string
, ":");
2518 strcat (string
, SYMBOL_NAME(sym
));
2519 break_command (string
, 0);
2522 else if (!found_in_file
)
2524 fputs_filtered ("\nFile ", stdout
);
2525 fputs_filtered (s
->filename
, stdout
);
2526 fputs_filtered (":\n", stdout
);
2530 if (class != 2 && i
== STATIC_BLOCK
)
2531 printf_filtered ("static ");
2533 /* Typedef that is not a C++ class */
2535 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2536 c_typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2537 /* variable, func, or typedef-that-is-c++-class */
2538 else if (class < 2 ||
2540 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2542 type_print (SYMBOL_TYPE (sym
),
2543 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2544 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2547 printf_filtered (";\n");
2551 # if 0 /* FIXME, why is this zapped out? */
2553 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2555 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2557 sprintf (buf
, " %s::", type_name_no_tag (t
));
2558 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2568 /* If there are no eyes, avoid all contact. I mean, if there are
2569 no debug symbols, then print directly from the msymbol_vector. */
2571 if (found_misc
|| class != 1)
2574 ALL_MSYMBOLS (objfile
, msymbol
)
2576 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2577 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2579 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2581 /* Functions: Look up by address. */
2583 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2585 /* Variables/Absolutes: Look up by name */
2586 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2587 (struct block
*) NULL
, VAR_NAMESPACE
,
2588 0, (struct symtab
**) NULL
) == NULL
)
2592 printf_filtered ("\nNon-debugging symbols:\n");
2595 printf_filtered (" %08x %s\n",
2596 SYMBOL_VALUE_ADDRESS (msymbol
),
2597 SYMBOL_SOURCE_NAME (msymbol
));
2607 variables_info (regexp
, from_tty
)
2611 list_symbols (regexp
, 0, 0);
2615 functions_info (regexp
, from_tty
)
2619 list_symbols (regexp
, 1, 0);
2623 types_info (regexp
, from_tty
)
2627 list_symbols (regexp
, 2, 0);
2631 /* Tiemann says: "info methods was never implemented." */
2633 methods_info (regexp
)
2636 list_symbols (regexp
, 3, 0);
2640 /* Breakpoint all functions matching regular expression. */
2642 rbreak_command (regexp
, from_tty
)
2646 list_symbols (regexp
, 1, 1);
2650 /* Return Nonzero if block a is lexically nested within block b,
2651 or if a and b have the same pc range.
2652 Return zero otherwise. */
2655 struct block
*a
, *b
;
2659 return BLOCK_START (a
) >= BLOCK_START (b
)
2660 && BLOCK_END (a
) <= BLOCK_END (b
);
2664 /* Helper routine for make_symbol_completion_list. */
2666 static int return_val_size
;
2667 static int return_val_index
;
2668 static char **return_val
;
2670 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2672 completion_list_add_name (SYMBOL_NAME (symbol), (sym_text), (len), \
2674 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2675 completion_list_add_name \
2676 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2679 /* Test to see if the symbol specified by SYMNAME (which is already
2680 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2681 characters. If so, add it to the current completion list. */
2684 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2694 /* clip symbols that cannot match */
2696 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2701 /* Clip any symbol names that we've already considered. (This is a
2702 time optimization) */
2704 for (i
= 0; i
< return_val_index
; ++i
)
2706 if (STREQ (symname
, return_val
[i
]))
2712 /* We have a match for a completion, so add SYMNAME to the current list
2713 of matches. Note that the name is moved to freshly malloc'd space. */
2717 if (word
== sym_text
)
2719 new = xmalloc (strlen (symname
) + 5);
2720 strcpy (new, symname
);
2722 else if (word
> sym_text
)
2724 /* Return some portion of symname. */
2725 new = xmalloc (strlen (symname
) + 5);
2726 strcpy (new, symname
+ (word
- sym_text
));
2730 /* Return some of SYM_TEXT plus symname. */
2731 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2732 strncpy (new, word
, sym_text
- word
);
2733 new[sym_text
- word
] = '\0';
2734 strcat (new, symname
);
2737 if (return_val_index
+ 3 > return_val_size
)
2739 newsize
= (return_val_size
*= 2) * sizeof (char *);
2740 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2742 return_val
[return_val_index
++] = new;
2743 return_val
[return_val_index
] = NULL
;
2747 /* Return a NULL terminated array of all symbols (regardless of class) which
2748 begin by matching TEXT. If the answer is no symbols, then the return value
2749 is an array which contains only a NULL pointer.
2751 Problem: All of the symbols have to be copied because readline frees them.
2752 I'm not going to worry about this; hopefully there won't be that many. */
2755 make_symbol_completion_list (text
, word
)
2759 register struct symbol
*sym
;
2760 register struct symtab
*s
;
2761 register struct partial_symtab
*ps
;
2762 register struct minimal_symbol
*msymbol
;
2763 register struct objfile
*objfile
;
2764 register struct block
*b
, *surrounding_static_block
= 0;
2766 struct partial_symbol
*psym
;
2767 /* The symbol we are completing on. Points in same buffer as text. */
2769 /* Length of sym_text. */
2772 /* Now look for the symbol we are supposed to complete on.
2773 FIXME: This should be language-specific. */
2779 /* First see if this is a quoted string. */
2781 for (p
= text
; *p
!= '\0'; ++p
)
2783 if (quote_found
!= '\0')
2785 if (*p
== quote_found
)
2786 /* Found close quote. */
2788 else if (*p
== '\\' && p
[1] == quote_found
)
2789 /* A backslash followed by the quote character
2790 doesn't end the string. */
2793 else if (*p
== '\'' || *p
== '"')
2799 if (quote_found
== '\'')
2800 /* A string within single quotes can be a symbol, so complete on it. */
2801 sym_text
= quote_pos
+ 1;
2802 else if (quote_found
== '"')
2803 /* A double-quoted string is never a symbol, nor does it make sense
2804 to complete it any other way. */
2808 /* It is not a quoted string. Break it based on the characters
2809 which are in symbols. */
2812 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2821 sym_text_len
= strlen (sym_text
);
2823 return_val_size
= 100;
2824 return_val_index
= 0;
2825 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2826 return_val
[0] = NULL
;
2828 /* Look through the partial symtabs for all symbols which begin
2829 by matching SYM_TEXT. Add each one that you find to the list. */
2831 ALL_PSYMTABS (objfile
, ps
)
2833 /* If the psymtab's been read in we'll get it when we search
2834 through the blockvector. */
2835 if (ps
->readin
) continue;
2837 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2838 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2839 + ps
->n_global_syms
);
2842 /* If interrupted, then quit. */
2844 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2847 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2848 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2849 + ps
->n_static_syms
);
2853 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2857 /* At this point scan through the misc symbol vectors and add each
2858 symbol you find to the list. Eventually we want to ignore
2859 anything that isn't a text symbol (everything else will be
2860 handled by the psymtab code above). */
2862 ALL_MSYMBOLS (objfile
, msymbol
)
2865 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2868 /* Search upwards from currently selected frame (so that we can
2869 complete on local vars. */
2871 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2873 if (!BLOCK_SUPERBLOCK (b
))
2875 surrounding_static_block
= b
; /* For elmin of dups */
2878 /* Also catch fields of types defined in this places which match our
2879 text string. Only complete on types visible from current context. */
2881 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2883 sym
= BLOCK_SYM (b
, i
);
2884 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2885 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2887 struct type
*t
= SYMBOL_TYPE (sym
);
2888 enum type_code c
= TYPE_CODE (t
);
2890 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2892 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2894 if (TYPE_FIELD_NAME (t
, j
))
2896 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2897 sym_text
, sym_text_len
, text
, word
);
2905 /* Go through the symtabs and check the externs and statics for
2906 symbols which match. */
2908 ALL_SYMTABS (objfile
, s
)
2911 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2912 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2914 sym
= BLOCK_SYM (b
, i
);
2915 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2919 ALL_SYMTABS (objfile
, s
)
2922 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2923 /* Don't do this block twice. */
2924 if (b
== surrounding_static_block
) continue;
2925 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2927 sym
= BLOCK_SYM (b
, i
);
2928 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2932 return (return_val
);
2937 /* Add the type of the symbol sym to the type of the current
2938 function whose block we are in (assumed). The type of
2939 this current function is contained in *TYPE.
2941 This basically works as follows: When we find a function
2942 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2943 a pointer to its type in the global in_function_type. Every
2944 time we come across a parameter symbol ('p' in its name), then
2945 this procedure adds the name and type of that parameter
2946 to the function type pointed to by *TYPE. (Which should correspond
2947 to in_function_type if it was called correctly).
2949 Note that since we are modifying a type, the result of
2950 lookup_function_type() should be memcpy()ed before calling
2951 this. When not in strict typing mode, the expression
2952 evaluator can choose to ignore this.
2954 Assumption: All of a function's parameter symbols will
2955 appear before another function symbol is found. The parameters
2956 appear in the same order in the argument list as they do in the
2960 add_param_to_type (type
,sym
)
2964 int num
= ++(TYPE_NFIELDS(*type
));
2966 if(TYPE_NFIELDS(*type
)-1)
2967 TYPE_FIELDS(*type
) = (struct field
*)
2968 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2969 num
*sizeof(struct field
));
2971 TYPE_FIELDS(*type
) = (struct field
*)
2972 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2974 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2975 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2976 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2977 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2982 _initialize_symtab ()
2984 add_info ("variables", variables_info
,
2985 "All global and static variable names, or those matching REGEXP.");
2986 add_info ("functions", functions_info
,
2987 "All function names, or those matching REGEXP.");
2989 /* FIXME: This command has at least the following problems:
2990 1. It prints builtin types (in a very strange and confusing fashion).
2991 2. It doesn't print right, e.g. with
2992 typedef struct foo *FOO
2993 type_print prints "FOO" when we want to make it (in this situation)
2994 print "struct foo *".
2995 I also think "ptype" or "whatis" is more likely to be useful (but if
2996 there is much disagreement "info types" can be fixed). */
2997 add_info ("types", types_info
,
2998 "All type names, or those matching REGEXP.");
3001 add_info ("methods", methods_info
,
3002 "All method names, or those matching REGEXP::REGEXP.\n\
3003 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3004 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3007 add_info ("sources", sources_info
,
3008 "Source files in the program.");
3010 add_com ("rbreak", no_class
, rbreak_command
,
3011 "Set a breakpoint for all functions matching REGEXP.");
3013 /* Initialize the one built-in type that isn't language dependent... */
3014 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3015 "<unknown type>", (struct objfile
*) NULL
);