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 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
)
1336 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1343 /* If we got here, we didn't get an exact match. */
1350 find_pc_line_pc_range (pc
, startptr
, endptr
)
1352 CORE_ADDR
*startptr
, *endptr
;
1354 struct symtab_and_line sal
;
1355 sal
= find_pc_line (pc
, 0);
1358 return sal
.symtab
!= 0;
1361 /* If P is of the form "operator[ \t]+..." where `...' is
1362 some legitimate operator text, return a pointer to the
1363 beginning of the substring of the operator text.
1364 Otherwise, return "". */
1366 operator_chars (p
, end
)
1371 if (strncmp (p
, "operator", 8))
1375 /* Don't get faked out by `operator' being part of a longer
1377 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1380 /* Allow some whitespace between `operator' and the operator symbol. */
1381 while (*p
== ' ' || *p
== '\t')
1384 /* Recognize 'operator TYPENAME'. */
1386 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1388 register char *q
= p
+1;
1389 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1414 if (p
[1] == '=' || p
[1] == p
[0])
1425 error ("`operator ()' must be specified without whitespace in `()'");
1430 error ("`operator ?:' must be specified without whitespace in `?:'");
1435 error ("`operator []' must be specified without whitespace in `[]'");
1439 error ("`operator %s' not supported", p
);
1446 /* Recursive helper function for decode_line_1.
1447 * Look for methods named NAME in type T.
1448 * Return number of matches.
1449 * Put matches in SYM_ARR (which better be big enough!).
1450 * These allocations seem to define "big enough":
1451 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1452 * Note that this function is g++ specific.
1456 find_methods (t
, name
, sym_arr
)
1459 struct symbol
**sym_arr
;
1463 struct symbol
*sym_class
;
1464 char *class_name
= type_name_no_tag (t
);
1465 /* Ignore this class if it doesn't have a name.
1466 This prevents core dumps, but is just a workaround
1467 because we might not find the function in
1468 certain cases, such as
1469 struct D {virtual int f();}
1470 struct C : D {virtual int g();}
1471 (in this case g++ 1.35.1- does not put out a name
1472 for D as such, it defines type 19 (for example) in
1473 the same stab as C, and then does a
1474 .stabs "D:T19" and a .stabs "D:t19".
1476 "break C::f" should not be looking for field f in
1478 but just for the field f in the baseclasses of C
1479 (no matter what their names).
1481 However, I don't know how to replace the code below
1482 that depends on knowing the name of D. */
1484 && (sym_class
= lookup_symbol (class_name
,
1485 (struct block
*)NULL
,
1488 (struct symtab
**)NULL
)))
1491 t
= SYMBOL_TYPE (sym_class
);
1492 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1493 method_counter
>= 0;
1497 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1499 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1500 if (STREQ (name
, method_name
))
1501 /* Find all the fields with that name. */
1502 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1507 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1508 check_stub_method (t
, method_counter
, field_counter
);
1509 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1510 /* Destructor is handled by caller, dont add it to the list */
1511 if (DESTRUCTOR_PREFIX_P (phys_name
))
1513 sym_arr
[i1
] = lookup_symbol (phys_name
,
1514 SYMBOL_BLOCK_VALUE (sym_class
),
1517 (struct symtab
**) NULL
);
1518 if (sym_arr
[i1
]) i1
++;
1521 fputs_filtered("(Cannot find method ", stdout
);
1522 fprintf_symbol_filtered (stdout
, phys_name
,
1523 language_cplus
, DMGL_PARAMS
);
1524 fputs_filtered(" - possibly inlined.)\n", stdout
);
1529 /* Only search baseclasses if there is no match yet,
1530 * since names in derived classes override those in baseclasses.
1534 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1535 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1540 /* Helper function for decode_line_1.
1541 Build a canonical line spec in CANONICAL if it is non-NULL and if
1542 the SAL has a symtab.
1543 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1544 If SYMNAME is NULL the line number from SAL is used and the canonical
1545 line spec is `filename:linenum'. */
1548 build_canonical_line_spec (sal
, symname
, canonical
)
1549 struct symtab_and_line
*sal
;
1553 char **canonical_arr
;
1554 char *canonical_name
;
1556 struct symtab
*s
= sal
->symtab
;
1558 if (s
== (struct symtab
*)NULL
1559 || s
->filename
== (char *)NULL
1560 || canonical
== (char ***)NULL
)
1563 canonical_arr
= (char **) xmalloc (sizeof (char *));
1564 *canonical
= canonical_arr
;
1566 filename
= s
->filename
;
1567 if (symname
!= NULL
)
1569 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1570 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1574 canonical_name
= xmalloc (strlen (filename
) + 30);
1575 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1577 canonical_arr
[0] = canonical_name
;
1580 /* Parse a string that specifies a line number.
1581 Pass the address of a char * variable; that variable will be
1582 advanced over the characters actually parsed.
1586 LINENUM -- that line number in current file. PC returned is 0.
1587 FILE:LINENUM -- that line in that file. PC returned is 0.
1588 FUNCTION -- line number of openbrace of that function.
1589 PC returned is the start of the function.
1590 VARIABLE -- line number of definition of that variable.
1592 FILE:FUNCTION -- likewise, but prefer functions in that file.
1593 *EXPR -- line in which address EXPR appears.
1595 FUNCTION may be an undebuggable function found in minimal symbol table.
1597 If the argument FUNFIRSTLINE is nonzero, we want the first line
1598 of real code inside a function when a function is specified.
1600 DEFAULT_SYMTAB specifies the file to use if none is specified.
1601 It defaults to current_source_symtab.
1602 DEFAULT_LINE specifies the line number to use for relative
1603 line numbers (that start with signs). Defaults to current_source_line.
1604 If CANONICAL is non-NULL, store an array of strings containing the canonical
1605 line specs there if necessary. Currently overloaded member functions and
1606 line numbers or static functions without a filename yield a canonical
1607 line spec. The array and the line spec strings are allocated on the heap,
1608 it is the callers responsibility to free them.
1610 Note that it is possible to return zero for the symtab
1611 if no file is validly specified. Callers must check that.
1612 Also, the line number returned may be invalid. */
1614 struct symtabs_and_lines
1615 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1618 struct symtab
*default_symtab
;
1622 struct symtabs_and_lines values
;
1623 #ifdef HPPA_COMPILER_BUG
1624 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1625 when optimizing this file with target i960-vxworks. I haven't
1626 been able to construct a simple test case. The problem is that
1627 in the second call to SKIP_PROLOGUE below, the compiler somehow
1628 does not realize that the statement val = find_pc_line (...) will
1629 change the values of the fields of val. It extracts the elements
1630 into registers at the top of the block, and does not update the
1631 registers after the call to find_pc_line. You can check this by
1632 inserting a printf at the end of find_pc_line to show what values
1633 it is returning for val.pc and val.end and another printf after
1634 the call to see what values the function actually got (remember,
1635 this is compiling with cc -O, with this patch removed). You can
1636 also examine the assembly listing: search for the second call to
1637 skip_prologue; the LDO statement before the next call to
1638 find_pc_line loads the address of the structure which
1639 find_pc_line will return; if there is a LDW just before the LDO,
1640 which fetches an element of the structure, then the compiler
1643 Setting val to volatile avoids the problem. We must undef
1644 volatile, because the HPPA native compiler does not define
1645 __STDC__, although it does understand volatile, and so volatile
1646 will have been defined away in defs.h. */
1648 volatile struct symtab_and_line val
;
1649 #define volatile /*nothing*/
1651 struct symtab_and_line val
;
1653 register char *p
, *p1
;
1655 register struct symtab
*s
;
1657 register struct symbol
*sym
;
1658 /* The symtab that SYM was found in. */
1659 struct symtab
*sym_symtab
;
1661 register CORE_ADDR pc
;
1662 register struct minimal_symbol
*msymbol
;
1664 struct symbol
*sym_class
;
1667 struct symbol
**sym_arr
;
1669 char *saved_arg
= *argptr
;
1670 extern char *gdb_completer_quote_characters
;
1672 /* Defaults have defaults. */
1674 if (default_symtab
== 0)
1676 default_symtab
= current_source_symtab
;
1677 default_line
= current_source_line
;
1680 /* See if arg is *PC */
1682 if (**argptr
== '*')
1684 if (**argptr
== '*')
1688 pc
= parse_and_eval_address_1 (argptr
);
1689 values
.sals
= (struct symtab_and_line
*)
1690 xmalloc (sizeof (struct symtab_and_line
));
1692 values
.sals
[0] = find_pc_line (pc
, 0);
1693 values
.sals
[0].pc
= pc
;
1694 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1698 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1701 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1703 for (p
= *argptr
; *p
; p
++)
1705 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1708 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1710 if ((p
[0] == ':') && !is_quoted
)
1716 /* Extract the class name. */
1718 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1719 copy
= (char *) alloca (p
- *argptr
+ 1);
1720 memcpy (copy
, *argptr
, p
- *argptr
);
1721 copy
[p
- *argptr
] = 0;
1723 /* Discard the class name from the arg. */
1725 while (*p
== ' ' || *p
== '\t') p
++;
1728 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1729 (struct symtab
**)NULL
);
1732 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1733 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1735 /* Arg token is not digits => try it as a function name
1736 Find the next token (everything up to end or next whitespace). */
1738 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1739 q
= operator_chars (*argptr
, &q1
);
1744 char *tmp
= alloca (q1
- q
+ 1);
1745 memcpy (tmp
, q
, q1
- q
);
1747 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1750 warning ("no mangling for \"%s\"", tmp
);
1751 cplusplus_hint (saved_arg
);
1752 return_to_top_level (RETURN_ERROR
);
1754 copy
= (char*) alloca (3 + strlen(opname
));
1755 sprintf (copy
, "__%s", opname
);
1760 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1761 memcpy (copy
, *argptr
, p
- *argptr
);
1762 copy
[p
- *argptr
] = '\0';
1765 /* no line number may be specified */
1766 while (*p
== ' ' || *p
== '\t') p
++;
1770 i1
= 0; /* counter for the symbol array */
1771 t
= SYMBOL_TYPE (sym_class
);
1772 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1774 /* Cfront objects don't have fieldlists. */
1775 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1777 /* destructors are a special case. */
1778 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1779 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1780 /* gcc 1.x puts destructor in last field,
1781 gcc 2.x puts destructor in first field. */
1782 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1783 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1785 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1786 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1790 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1791 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1792 if (sym_arr
[i1
]) i1
++;
1795 i1
= find_methods (t
, copy
, sym_arr
);
1798 /* There is exactly one field with that name. */
1801 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1803 /* Arg is the name of a function */
1804 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1807 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1809 values
.sals
[0] = find_pc_line (pc
, 0);
1810 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1820 /* There is more than one field with that name
1821 (overloaded). Ask the user which one to use. */
1822 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1828 if (OPNAME_PREFIX_P (copy
))
1830 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1831 strcpy (tmp
, "operator ");
1832 strcat (tmp
, copy
+3);
1837 warning ("the class `%s' does not have destructor defined",
1838 SYMBOL_SOURCE_NAME(sym_class
));
1840 warning ("the class %s does not have any method named %s",
1841 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1842 cplusplus_hint (saved_arg
);
1843 return_to_top_level (RETURN_ERROR
);
1848 /* The quotes are important if copy is empty. */
1849 warning ("can't find class, struct, or union named \"%s\"",
1851 cplusplus_hint (saved_arg
);
1852 return_to_top_level (RETURN_ERROR
);
1858 /* Extract the file name. */
1860 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1861 copy
= (char *) alloca (p
- *argptr
+ 1);
1862 memcpy (copy
, *argptr
, p
- *argptr
);
1863 copy
[p
- *argptr
] = 0;
1865 /* Find that file's data. */
1866 s
= lookup_symtab (copy
);
1869 if (!have_full_symbols () && !have_partial_symbols ())
1870 error (no_symtab_msg
);
1871 error ("No source file named %s.", copy
);
1874 /* Discard the file name from the arg. */
1876 while (*p
== ' ' || *p
== '\t') p
++;
1880 /* S is specified file's symtab, or 0 if no file specified.
1881 arg no longer contains the file name. */
1883 /* Check whether arg is all digits (and sign) */
1886 if (*p
== '-' || *p
== '+') p
++;
1887 while (*p
>= '0' && *p
<= '9')
1890 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1892 /* We found a token consisting of all digits -- at least one digit. */
1893 enum sign
{none
, plus
, minus
} sign
= none
;
1895 /* We might need a canonical line spec if no file was specified. */
1896 int need_canonical
= (s
== 0) ? 1 : 0;
1898 /* This is where we need to make sure that we have good defaults.
1899 We must guarantee that this section of code is never executed
1900 when we are called with just a function name, since
1901 select_source_symtab calls us with such an argument */
1903 if (s
== 0 && default_symtab
== 0)
1905 select_source_symtab (0);
1906 default_symtab
= current_source_symtab
;
1907 default_line
= current_source_line
;
1910 if (**argptr
== '+')
1911 sign
= plus
, (*argptr
)++;
1912 else if (**argptr
== '-')
1913 sign
= minus
, (*argptr
)++;
1914 val
.line
= atoi (*argptr
);
1921 val
.line
= default_line
+ val
.line
;
1927 val
.line
= default_line
- val
.line
;
1932 break; /* No need to adjust val.line. */
1935 while (*p
== ' ' || *p
== '\t') p
++;
1941 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1942 values
.sals
[0] = val
;
1945 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1949 /* Arg token is not digits => try it as a variable name
1950 Find the next token (everything up to end or next whitespace). */
1952 p
= skip_quoted (*argptr
);
1953 if (is_quoted
&& p
[-1] != '\'')
1954 error ("Unmatched single quote.");
1955 copy
= (char *) alloca (p
- *argptr
+ 1);
1956 memcpy (copy
, *argptr
, p
- *argptr
);
1957 copy
[p
- *argptr
] = '\0';
1958 if ((copy
[0] == copy
[p
- *argptr
- 1])
1959 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1962 copy
[p
- *argptr
- 1] = '\0';
1965 while (*p
== ' ' || *p
== '\t') p
++;
1968 /* Look up that token as a variable.
1969 If file specified, use that file's per-file block to start with. */
1971 sym
= lookup_symbol (copy
,
1972 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1973 : get_selected_block ()),
1974 VAR_NAMESPACE
, 0, &sym_symtab
);
1978 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1980 /* Arg is the name of a function */
1981 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1984 val
= find_pc_line (pc
, 0);
1985 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1986 /* Convex: no need to suppress code on first line, if any */
1989 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1990 line is still part of the same function. */
1992 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
1993 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1995 /* First pc of next line */
1997 /* Recalculate the line number (might not be N+1). */
1998 val
= find_pc_line (pc
, 0);
2002 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2003 values
.sals
[0] = val
;
2006 /* I think this is always the same as the line that
2007 we calculate above, but the general principle is
2008 "trust the symbols more than stuff like
2010 if (SYMBOL_LINE (sym
) != 0)
2011 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2013 /* We might need a canonical line spec if it is a static function. */
2016 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2017 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2018 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2019 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2023 else if (SYMBOL_LINE (sym
) != 0)
2025 /* We know its line number. */
2026 values
.sals
= (struct symtab_and_line
*)
2027 xmalloc (sizeof (struct symtab_and_line
));
2029 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2030 values
.sals
[0].symtab
= sym_symtab
;
2031 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2035 /* This can happen if it is compiled with a compiler which doesn't
2036 put out line numbers for variables. */
2037 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2038 return? For example, "info line foo" could print the address. */
2039 error ("Line number not known for symbol \"%s\"", copy
);
2042 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2043 if (msymbol
!= NULL
)
2047 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
) + FUNCTION_START_OFFSET
;
2049 SKIP_PROLOGUE (val
.pc
);
2050 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2051 values
.sals
[0] = val
;
2056 if (!have_full_symbols () &&
2057 !have_partial_symbols () && !have_minimal_symbols ())
2058 error (no_symtab_msg
);
2060 error ("Function \"%s\" not defined.", copy
);
2061 return values
; /* for lint */
2064 struct symtabs_and_lines
2065 decode_line_spec (string
, funfirstline
)
2069 struct symtabs_and_lines sals
;
2071 error ("Empty line specification.");
2072 sals
= decode_line_1 (&string
, funfirstline
,
2073 current_source_symtab
, current_source_line
,
2076 error ("Junk at end of line specification: %s", string
);
2080 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2081 operate on (ask user if necessary).
2082 If CANONICAL is non-NULL return a corresponding array of mangled names
2083 as canonical line specs there. */
2085 static struct symtabs_and_lines
2086 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2087 struct symbol
*sym_arr
[];
2092 struct symtabs_and_lines values
, return_values
;
2093 register CORE_ADDR pc
;
2098 struct cleanup
*old_chain
;
2099 char **canonical_arr
= (char **)NULL
;
2101 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2102 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2103 old_chain
= make_cleanup (free
, return_values
.sals
);
2107 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2108 make_cleanup (free
, canonical_arr
);
2109 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2110 *canonical
= canonical_arr
;
2114 printf("[0] cancel\n[1] all\n");
2117 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2119 /* Arg is the name of a function */
2120 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2121 + FUNCTION_START_OFFSET
;
2124 values
.sals
[i
] = find_pc_line (pc
, 0);
2125 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2126 values
.sals
[i
].end
: pc
;
2127 printf("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2128 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2130 else printf ("?HERE\n");
2134 if ((prompt
= getenv ("PS2")) == NULL
)
2138 printf("%s ",prompt
);
2141 args
= command_line_input ((char *) NULL
, 0);
2143 if (args
== 0 || *args
== 0)
2144 error_no_arg ("one or more choice numbers");
2152 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2153 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2154 error ("Arguments must be choice numbers.");
2159 error ("cancelled");
2164 for (i
= 0; i
< nelts
; i
++)
2166 if (canonical_arr
[i
] == NULL
)
2168 symname
= SYMBOL_NAME (sym_arr
[i
]);
2169 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2173 memcpy (return_values
.sals
, values
.sals
,
2174 (nelts
* sizeof(struct symtab_and_line
)));
2175 return_values
.nelts
= nelts
;
2176 discard_cleanups (old_chain
);
2177 return return_values
;
2180 if (num
> nelts
+ 2)
2182 printf ("No choice number %d.\n", num
);
2187 if (values
.sals
[num
].pc
)
2191 symname
= SYMBOL_NAME (sym_arr
[num
]);
2192 make_cleanup (free
, symname
);
2193 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2195 return_values
.sals
[i
++] = values
.sals
[num
];
2196 values
.sals
[num
].pc
= 0;
2200 printf ("duplicate request for %d ignored.\n", num
);
2205 while (*args
== ' ' || *args
== '\t') args
++;
2207 return_values
.nelts
= i
;
2208 discard_cleanups (old_chain
);
2209 return return_values
;
2213 /* Slave routine for sources_info. Force line breaks at ,'s.
2214 NAME is the name to print and *FIRST is nonzero if this is the first
2215 name printed. Set *FIRST to zero. */
2217 output_source_filename (name
, first
)
2221 /* Table of files printed so far. Since a single source file can
2222 result in several partial symbol tables, we need to avoid printing
2223 it more than once. Note: if some of the psymtabs are read in and
2224 some are not, it gets printed both under "Source files for which
2225 symbols have been read" and "Source files for which symbols will
2226 be read in on demand". I consider this a reasonable way to deal
2227 with the situation. I'm not sure whether this can also happen for
2228 symtabs; it doesn't hurt to check. */
2229 static char **tab
= NULL
;
2230 /* Allocated size of tab in elements.
2231 Start with one 256-byte block (when using GNU malloc.c).
2232 24 is the malloc overhead when range checking is in effect. */
2233 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2234 /* Current size of tab in elements. */
2235 static int tab_cur_size
;
2242 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2246 /* Is NAME in tab? */
2247 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2248 if (STREQ (*p
, name
))
2249 /* Yes; don't print it again. */
2251 /* No; add it to tab. */
2252 if (tab_cur_size
== tab_alloc_size
)
2254 tab_alloc_size
*= 2;
2255 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2257 tab
[tab_cur_size
++] = name
;
2265 printf_filtered (", ");
2269 fputs_filtered (name
, stdout
);
2273 sources_info (ignore
, from_tty
)
2277 register struct symtab
*s
;
2278 register struct partial_symtab
*ps
;
2279 register struct objfile
*objfile
;
2282 if (!have_full_symbols () && !have_partial_symbols ())
2284 error (no_symtab_msg
);
2287 printf_filtered ("Source files for which symbols have been read in:\n\n");
2290 ALL_SYMTABS (objfile
, s
)
2292 output_source_filename (s
-> filename
, &first
);
2294 printf_filtered ("\n\n");
2296 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2299 ALL_PSYMTABS (objfile
, ps
)
2303 output_source_filename (ps
-> filename
, &first
);
2306 printf_filtered ("\n");
2309 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2310 If CLASS is zero, list all symbols except functions, type names, and
2312 If CLASS is 1, list only functions.
2313 If CLASS is 2, list only type names.
2314 If CLASS is 3, list only method names.
2316 BPT is non-zero if we should set a breakpoint at the functions
2320 list_symbols (regexp
, class, bpt
)
2325 register struct symtab
*s
;
2326 register struct partial_symtab
*ps
;
2327 register struct blockvector
*bv
;
2328 struct blockvector
*prev_bv
= 0;
2329 register struct block
*b
;
2331 register struct symbol
*sym
;
2332 struct partial_symbol
*psym
;
2333 struct objfile
*objfile
;
2334 struct minimal_symbol
*msymbol
;
2336 static char *classnames
[]
2337 = {"variable", "function", "type", "method"};
2338 int found_in_file
= 0;
2340 static enum minimal_symbol_type types
[]
2341 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2342 static enum minimal_symbol_type types2
[]
2343 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2344 enum minimal_symbol_type ourtype
= types
[class];
2345 enum minimal_symbol_type ourtype2
= types2
[class];
2349 /* Make sure spacing is right for C++ operators.
2350 This is just a courtesy to make the matching less sensitive
2351 to how many spaces the user leaves between 'operator'
2352 and <TYPENAME> or <OPERATOR>. */
2354 char *opname
= operator_chars (regexp
, &opend
);
2357 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2358 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2360 /* There should 1 space between 'operator' and 'TYPENAME'. */
2361 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2366 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2367 if (opname
[-1] == ' ')
2370 /* If wrong number of spaces, fix it. */
2373 char *tmp
= (char*) alloca(opend
-opname
+10);
2374 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2379 if (0 != (val
= re_comp (regexp
)))
2380 error ("Invalid regexp (%s): %s", val
, regexp
);
2383 /* Search through the partial symtabs *first* for all symbols
2384 matching the regexp. That way we don't have to reproduce all of
2385 the machinery below. */
2387 ALL_PSYMTABS (objfile
, ps
)
2389 struct partial_symbol
*bound
, *gbound
, *sbound
;
2392 if (ps
->readin
) continue;
2394 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2395 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2398 /* Go through all of the symbols stored in a partial
2399 symtab in one loop. */
2400 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2405 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2407 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2418 /* If it would match (logic taken from loop below)
2419 load the file and go on to the next one */
2420 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2421 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2422 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2423 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2424 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2425 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2427 PSYMTAB_TO_SYMTAB(ps
);
2435 /* Here, we search through the minimal symbol tables for functions that
2436 match, and call find_pc_symtab on them to force their symbols to
2437 be read. The symbol will then be found during the scan of symtabs
2438 below. If find_pc_symtab fails, set found_misc so that we will
2439 rescan to print any matching symbols without debug info. */
2443 ALL_MSYMBOLS (objfile
, msymbol
)
2445 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2446 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2448 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2450 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2459 /* Printout here so as to get after the "Reading in symbols"
2460 messages which will be generated above. */
2462 printf_filtered (regexp
2463 ? "All %ss matching regular expression \"%s\":\n"
2464 : "All defined %ss:\n",
2468 ALL_SYMTABS (objfile
, s
)
2471 bv
= BLOCKVECTOR (s
);
2472 /* Often many files share a blockvector.
2473 Scan each blockvector only once so that
2474 we don't get every symbol many times.
2475 It happens that the first symtab in the list
2476 for any given blockvector is the main file. */
2478 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2480 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2481 /* Skip the sort if this block is always sorted. */
2482 if (!BLOCK_SHOULD_SORT (b
))
2483 sort_block_syms (b
);
2484 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2487 sym
= BLOCK_SYM (b
, j
);
2488 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2489 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2490 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2491 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2492 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2493 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2494 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2498 /* Set a breakpoint here, if it's a function */
2501 /* There may be more than one function with the
2502 same name but in different files. In order to
2503 set breakpoints on all of them, we must give
2504 both the file name and the function name to
2507 (char *) alloca (strlen (s
->filename
)
2508 + strlen (SYMBOL_NAME(sym
))
2510 strcpy (string
, s
->filename
);
2511 strcat (string
, ":");
2512 strcat (string
, SYMBOL_NAME(sym
));
2513 break_command (string
, 0);
2516 else if (!found_in_file
)
2518 fputs_filtered ("\nFile ", stdout
);
2519 fputs_filtered (s
->filename
, stdout
);
2520 fputs_filtered (":\n", stdout
);
2524 if (class != 2 && i
== STATIC_BLOCK
)
2525 printf_filtered ("static ");
2527 /* Typedef that is not a C++ class */
2529 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2530 c_typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2531 /* variable, func, or typedef-that-is-c++-class */
2532 else if (class < 2 ||
2534 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2536 type_print (SYMBOL_TYPE (sym
),
2537 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2538 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2541 printf_filtered (";\n");
2545 # if 0 /* FIXME, why is this zapped out? */
2547 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2549 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2551 sprintf (buf
, " %s::", type_name_no_tag (t
));
2552 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2562 /* If there are no eyes, avoid all contact. I mean, if there are
2563 no debug symbols, then print directly from the msymbol_vector. */
2565 if (found_misc
|| class != 1)
2568 ALL_MSYMBOLS (objfile
, msymbol
)
2570 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2571 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2573 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2575 /* Functions: Look up by address. */
2577 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2579 /* Variables/Absolutes: Look up by name */
2580 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2581 (struct block
*) NULL
, VAR_NAMESPACE
,
2582 0, (struct symtab
**) NULL
) == NULL
)
2586 printf_filtered ("\nNon-debugging symbols:\n");
2589 printf_filtered (" %08x %s\n",
2590 SYMBOL_VALUE_ADDRESS (msymbol
),
2591 SYMBOL_SOURCE_NAME (msymbol
));
2601 variables_info (regexp
, from_tty
)
2605 list_symbols (regexp
, 0, 0);
2609 functions_info (regexp
, from_tty
)
2613 list_symbols (regexp
, 1, 0);
2617 types_info (regexp
, from_tty
)
2621 list_symbols (regexp
, 2, 0);
2625 /* Tiemann says: "info methods was never implemented." */
2627 methods_info (regexp
)
2630 list_symbols (regexp
, 3, 0);
2634 /* Breakpoint all functions matching regular expression. */
2636 rbreak_command (regexp
, from_tty
)
2640 list_symbols (regexp
, 1, 1);
2644 /* Return Nonzero if block a is lexically nested within block b,
2645 or if a and b have the same pc range.
2646 Return zero otherwise. */
2649 struct block
*a
, *b
;
2653 return BLOCK_START (a
) >= BLOCK_START (b
)
2654 && BLOCK_END (a
) <= BLOCK_END (b
);
2658 /* Helper routine for make_symbol_completion_list. */
2660 static int return_val_size
;
2661 static int return_val_index
;
2662 static char **return_val
;
2664 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2666 completion_list_add_name (SYMBOL_NAME (symbol), (sym_text), (len), \
2668 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2669 completion_list_add_name \
2670 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2673 /* Test to see if the symbol specified by SYMNAME (which is already
2674 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2675 characters. If so, add it to the current completion list. */
2678 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2688 /* clip symbols that cannot match */
2690 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2695 /* Clip any symbol names that we've already considered. (This is a
2696 time optimization) */
2698 for (i
= 0; i
< return_val_index
; ++i
)
2700 if (STREQ (symname
, return_val
[i
]))
2706 /* We have a match for a completion, so add SYMNAME to the current list
2707 of matches. Note that the name is moved to freshly malloc'd space. */
2711 if (word
== sym_text
)
2713 new = xmalloc (strlen (symname
) + 5);
2714 strcpy (new, symname
);
2716 else if (word
> sym_text
)
2718 /* Return some portion of symname. */
2719 new = xmalloc (strlen (symname
) + 5);
2720 strcpy (new, symname
+ (word
- sym_text
));
2724 /* Return some of SYM_TEXT plus symname. */
2725 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2726 strncpy (new, word
, sym_text
- word
);
2727 new[sym_text
- word
] = '\0';
2728 strcat (new, symname
);
2731 if (return_val_index
+ 3 > return_val_size
)
2733 newsize
= (return_val_size
*= 2) * sizeof (char *);
2734 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2736 return_val
[return_val_index
++] = new;
2737 return_val
[return_val_index
] = NULL
;
2741 /* Return a NULL terminated array of all symbols (regardless of class) which
2742 begin by matching TEXT. If the answer is no symbols, then the return value
2743 is an array which contains only a NULL pointer.
2745 Problem: All of the symbols have to be copied because readline frees them.
2746 I'm not going to worry about this; hopefully there won't be that many. */
2749 make_symbol_completion_list (text
, word
)
2753 register struct symbol
*sym
;
2754 register struct symtab
*s
;
2755 register struct partial_symtab
*ps
;
2756 register struct minimal_symbol
*msymbol
;
2757 register struct objfile
*objfile
;
2758 register struct block
*b
, *surrounding_static_block
= 0;
2760 struct partial_symbol
*psym
;
2761 /* The symbol we are completing on. Points in same buffer as text. */
2763 /* Length of sym_text. */
2766 /* Now look for the symbol we are supposed to complete on.
2767 FIXME: This should be language-specific. */
2773 /* First see if this is a quoted string. */
2775 for (p
= text
; *p
!= '\0'; ++p
)
2777 if (quote_found
!= '\0')
2779 if (*p
== quote_found
)
2780 /* Found close quote. */
2782 else if (*p
== '\\' && p
[1] == quote_found
)
2783 /* A backslash followed by the quote character
2784 doesn't end the string. */
2787 else if (*p
== '\'' || *p
== '"')
2793 if (quote_found
== '\'')
2794 /* A string within single quotes can be a symbol, so complete on it. */
2795 sym_text
= quote_pos
+ 1;
2796 else if (quote_found
== '"')
2797 /* A double-quoted string is never a symbol, nor does it make sense
2798 to complete it any other way. */
2802 /* It is not a quoted string. Break it based on the characters
2803 which are in symbols. */
2806 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2815 sym_text_len
= strlen (sym_text
);
2817 return_val_size
= 100;
2818 return_val_index
= 0;
2819 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2820 return_val
[0] = NULL
;
2822 /* Look through the partial symtabs for all symbols which begin
2823 by matching SYM_TEXT. Add each one that you find to the list. */
2825 ALL_PSYMTABS (objfile
, ps
)
2827 /* If the psymtab's been read in we'll get it when we search
2828 through the blockvector. */
2829 if (ps
->readin
) continue;
2831 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2832 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2833 + ps
->n_global_syms
);
2836 /* If interrupted, then quit. */
2838 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2841 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2842 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2843 + ps
->n_static_syms
);
2847 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2851 /* At this point scan through the misc symbol vectors and add each
2852 symbol you find to the list. Eventually we want to ignore
2853 anything that isn't a text symbol (everything else will be
2854 handled by the psymtab code above). */
2856 ALL_MSYMBOLS (objfile
, msymbol
)
2859 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2862 /* Search upwards from currently selected frame (so that we can
2863 complete on local vars. */
2865 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2867 if (!BLOCK_SUPERBLOCK (b
))
2869 surrounding_static_block
= b
; /* For elmin of dups */
2872 /* Also catch fields of types defined in this places which match our
2873 text string. Only complete on types visible from current context. */
2875 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2877 sym
= BLOCK_SYM (b
, i
);
2878 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2879 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2881 struct type
*t
= SYMBOL_TYPE (sym
);
2882 enum type_code c
= TYPE_CODE (t
);
2884 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2886 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2888 if (TYPE_FIELD_NAME (t
, j
))
2890 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2891 sym_text
, sym_text_len
, text
, word
);
2899 /* Go through the symtabs and check the externs and statics for
2900 symbols which match. */
2902 ALL_SYMTABS (objfile
, s
)
2905 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2906 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2908 sym
= BLOCK_SYM (b
, i
);
2909 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2913 ALL_SYMTABS (objfile
, s
)
2916 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2917 /* Don't do this block twice. */
2918 if (b
== surrounding_static_block
) continue;
2919 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2921 sym
= BLOCK_SYM (b
, i
);
2922 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2926 return (return_val
);
2931 /* Add the type of the symbol sym to the type of the current
2932 function whose block we are in (assumed). The type of
2933 this current function is contained in *TYPE.
2935 This basically works as follows: When we find a function
2936 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2937 a pointer to its type in the global in_function_type. Every
2938 time we come across a parameter symbol ('p' in its name), then
2939 this procedure adds the name and type of that parameter
2940 to the function type pointed to by *TYPE. (Which should correspond
2941 to in_function_type if it was called correctly).
2943 Note that since we are modifying a type, the result of
2944 lookup_function_type() should be memcpy()ed before calling
2945 this. When not in strict typing mode, the expression
2946 evaluator can choose to ignore this.
2948 Assumption: All of a function's parameter symbols will
2949 appear before another function symbol is found. The parameters
2950 appear in the same order in the argument list as they do in the
2954 add_param_to_type (type
,sym
)
2958 int num
= ++(TYPE_NFIELDS(*type
));
2960 if(TYPE_NFIELDS(*type
)-1)
2961 TYPE_FIELDS(*type
) = (struct field
*)
2962 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2963 num
*sizeof(struct field
));
2965 TYPE_FIELDS(*type
) = (struct field
*)
2966 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2968 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2969 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2970 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2971 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2976 _initialize_symtab ()
2978 add_info ("variables", variables_info
,
2979 "All global and static variable names, or those matching REGEXP.");
2980 add_info ("functions", functions_info
,
2981 "All function names, or those matching REGEXP.");
2983 /* FIXME: This command has at least the following problems:
2984 1. It prints builtin types (in a very strange and confusing fashion).
2985 2. It doesn't print right, e.g. with
2986 typedef struct foo *FOO
2987 type_print prints "FOO" when we want to make it (in this situation)
2988 print "struct foo *".
2989 I also think "ptype" or "whatis" is more likely to be useful (but if
2990 there is much disagreement "info types" can be fixed). */
2991 add_info ("types", types_info
,
2992 "All type names, or those matching REGEXP.");
2995 add_info ("methods", methods_info
,
2996 "All method names, or those matching REGEXP::REGEXP.\n\
2997 If the class qualifier is omitted, it is assumed to be the current scope.\n\
2998 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3001 add_info ("sources", sources_info
,
3002 "Source files in the program.");
3004 add_com ("rbreak", no_class
, rbreak_command
,
3005 "Set a breakpoint for all functions matching REGEXP.");
3007 /* Initialize the one built-in type that isn't language dependent... */
3008 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3009 "<unknown type>", (struct objfile
*) NULL
);