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
= NULL
, *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
= NULL
;
434 register struct partial_symtab
*ps
;
435 struct blockvector
*bv
;
436 register struct objfile
*objfile
;
437 register struct block
*b
;
438 register struct minimal_symbol
*msymbol
;
440 /* Search specified block and its superiors. */
444 sym
= lookup_block_symbol (block
, name
, namespace);
450 /* Search the list of symtabs for one which contains the
451 address of the start of this block. */
452 ALL_SYMTABS (objfile
, s
)
454 bv
= BLOCKVECTOR (s
);
455 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
456 if (BLOCK_START (b
) <= BLOCK_START (block
)
457 && BLOCK_END (b
) > BLOCK_START (block
))
466 block
= BLOCK_SUPERBLOCK (block
);
469 /* FIXME: this code is never executed--block is always NULL at this
470 point. What is it trying to do, anyway? We already should have
471 checked the STATIC_BLOCK above (it is the superblock of top-level
472 blocks). Why is VAR_NAMESPACE special-cased? */
473 /* Don't need to mess with the psymtabs; if we have a block,
474 that file is read in. If we don't, then we deal later with
475 all the psymtab stuff that needs checking. */
476 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
479 /* Find the right symtab. */
480 ALL_SYMTABS (objfile
, s
)
482 bv
= BLOCKVECTOR (s
);
483 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
484 if (BLOCK_START (b
) <= BLOCK_START (block
)
485 && BLOCK_END (b
) > BLOCK_START (block
))
487 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
500 /* C++: If requested to do so by the caller,
501 check to see if NAME is a field of `this'. */
502 if (is_a_field_of_this
)
504 struct value
*v
= value_of_this (0);
506 *is_a_field_of_this
= 0;
507 if (v
&& check_field (v
, name
))
509 *is_a_field_of_this
= 1;
516 /* Now search all global blocks. Do the symtab's first, then
517 check the psymtab's */
519 ALL_SYMTABS (objfile
, s
)
521 bv
= BLOCKVECTOR (s
);
522 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
523 sym
= lookup_block_symbol (block
, name
, namespace);
533 /* Check for the possibility of the symbol being a global function
534 that is stored in one of the minimal symbol tables. Eventually, all
535 global symbols might be resolved in this way. */
537 if (namespace == VAR_NAMESPACE
)
539 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
542 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
543 /* If S is NULL, there are no debug symbols for this file.
544 Skip this stuff and check for matching static symbols below. */
547 bv
= BLOCKVECTOR (s
);
548 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
549 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
551 /* We kept static functions in minimal symbol table as well as
552 in static scope. We want to find them in the symbol table. */
554 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
555 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
559 /* sym == 0 if symbol was found in the minimal symbol table
560 but not in the symtab.
561 Return 0 to use the msymbol definition of "foo_".
563 This happens for Fortran "foo_" symbols,
564 which are "foo" in the symtab.
566 This can also happen if "asm" is used to make a
567 regular symbol but not a debugging symbol, e.g.
579 ALL_PSYMTABS (objfile
, ps
)
581 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
583 s
= PSYMTAB_TO_SYMTAB(ps
);
584 bv
= BLOCKVECTOR (s
);
585 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
586 sym
= lookup_block_symbol (block
, name
, namespace);
588 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
595 /* Now search all per-file blocks.
596 Not strictly correct, but more useful than an error.
597 Do the symtabs first, then check the psymtabs */
599 ALL_SYMTABS (objfile
, s
)
601 bv
= BLOCKVECTOR (s
);
602 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
603 sym
= lookup_block_symbol (block
, name
, namespace);
613 ALL_PSYMTABS (objfile
, ps
)
615 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
617 s
= PSYMTAB_TO_SYMTAB(ps
);
618 bv
= BLOCKVECTOR (s
);
619 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
620 sym
= lookup_block_symbol (block
, name
, namespace);
622 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
629 /* Now search all per-file blocks for static mangled symbols.
630 Do the symtabs first, then check the psymtabs. */
632 if (namespace == VAR_NAMESPACE
)
634 ALL_SYMTABS (objfile
, s
)
636 bv
= BLOCKVECTOR (s
);
637 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
638 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
648 ALL_PSYMTABS (objfile
, ps
)
650 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
652 s
= PSYMTAB_TO_SYMTAB(ps
);
653 bv
= BLOCKVECTOR (s
);
654 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
655 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
657 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
670 /* Look, in partial_symtab PST, for symbol NAME. Check the global
671 symbols if GLOBAL, the static symbols if not */
673 static struct partial_symbol
*
674 lookup_partial_symbol (pst
, name
, global
, namespace)
675 struct partial_symtab
*pst
;
678 enum namespace namespace;
680 struct partial_symbol
*start
, *psym
;
681 struct partial_symbol
*top
, *bottom
, *center
;
682 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
683 int do_linear_search
= 1;
691 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
692 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
694 if (global
) /* This means we can use a binary search. */
696 do_linear_search
= 0;
698 /* Binary search. This search is guaranteed to end with center
699 pointing at the earliest partial symbol with the correct
700 name. At that point *all* partial symbols with that name
701 will be checked against the correct namespace. */
704 top
= start
+ length
- 1;
707 center
= bottom
+ (top
- bottom
) / 2;
708 assert (center
< top
);
709 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
711 do_linear_search
= 1;
713 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
722 assert (top
== bottom
);
723 while (STREQ (SYMBOL_NAME (top
), name
))
725 if (SYMBOL_NAMESPACE (top
) == namespace)
733 /* Can't use a binary search or else we found during the binary search that
734 we should also do a linear search. */
736 if (do_linear_search
)
738 for (psym
= start
; psym
< start
+ length
; psym
++)
740 if (namespace == SYMBOL_NAMESPACE (psym
))
742 if (SYMBOL_MATCHES_NAME (psym
, name
))
753 /* Find the psymtab containing main(). */
754 /* FIXME: What about languages without main() or specially linked
755 executables that have no main() ? */
757 struct partial_symtab
*
760 register struct partial_symtab
*pst
;
761 register struct objfile
*objfile
;
763 ALL_PSYMTABS (objfile
, pst
)
765 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
773 /* Search BLOCK for symbol NAME in NAMESPACE.
775 Note that if NAME is the demangled form of a C++ symbol, we will fail
776 to find a match during the binary search of the non-encoded names, but
777 for now we don't worry about the slight inefficiency of looking for
778 a match we'll never find, since it will go pretty quick. Once the
779 binary search terminates, we drop through and do a straight linear
780 search on the symbols. Each symbol which is marked as being a C++
781 symbol (language_cplus set) has both the encoded and non-encoded names
782 tested for a match. */
785 lookup_block_symbol (block
, name
, namespace)
786 register const struct block
*block
;
788 const enum namespace namespace;
790 register int bot
, top
, inc
;
791 register struct symbol
*sym
;
792 register struct symbol
*sym_found
= NULL
;
793 register int do_linear_search
= 1;
795 /* If the blocks's symbols were sorted, start with a binary search. */
797 if (BLOCK_SHOULD_SORT (block
))
799 /* Reset the linear search flag so if the binary search fails, we
800 won't do the linear search once unless we find some reason to
801 do so, such as finding a C++ symbol during the binary search.
802 Note that for C++ modules, ALL the symbols in a block should
803 end up marked as C++ symbols. */
805 do_linear_search
= 0;
806 top
= BLOCK_NSYMS (block
);
809 /* Advance BOT to not far before the first symbol whose name is NAME. */
813 inc
= (top
- bot
+ 1);
814 /* No need to keep binary searching for the last few bits worth. */
819 inc
= (inc
>> 1) + bot
;
820 sym
= BLOCK_SYM (block
, inc
);
821 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
823 do_linear_search
= 1;
825 if (SYMBOL_NAME (sym
)[0] < name
[0])
829 else if (SYMBOL_NAME (sym
)[0] > name
[0])
833 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
843 /* Now scan forward until we run out of symbols, find one whose
844 name is greater than NAME, or find one we want. If there is
845 more than one symbol with the right name and namespace, we
846 return the first one; I believe it is now impossible for us
847 to encounter two symbols with the same name and namespace
848 here, because blocks containing argument symbols are no
851 top
= BLOCK_NSYMS (block
);
854 sym
= BLOCK_SYM (block
, bot
);
855 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
858 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
860 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
872 /* Here if block isn't sorted, or we fail to find a match during the
873 binary search above. If during the binary search above, we find a
874 symbol which is a C++ symbol, then we have re-enabled the linear
875 search flag which was reset when starting the binary search.
877 This loop is equivalent to the loop above, but hacked greatly for speed.
879 Note that parameter symbols do not always show up last in the
880 list; this loop makes sure to take anything else other than
881 parameter symbols first; it only uses parameter symbols as a
882 last resort. Note that this only takes up extra computation
885 if (do_linear_search
)
887 top
= BLOCK_NSYMS (block
);
891 sym
= BLOCK_SYM (block
, bot
);
892 if (SYMBOL_NAMESPACE (sym
) == namespace &&
893 SYMBOL_MATCHES_NAME (sym
, name
))
896 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
897 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
898 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
899 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
900 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
901 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
909 return (sym_found
); /* Will be NULL if not found. */
913 /* Return the symbol for the function which contains a specified
914 lexical block, described by a struct block BL. */
920 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
921 bl
= BLOCK_SUPERBLOCK (bl
);
923 return BLOCK_FUNCTION (bl
);
926 /* Find the symtab associated with PC. Look through the psymtabs and read in
927 another symtab if necessary. */
931 register CORE_ADDR pc
;
933 register struct block
*b
;
934 struct blockvector
*bv
;
935 register struct symtab
*s
= NULL
;
936 register struct symtab
*best_s
= NULL
;
937 register struct partial_symtab
*ps
;
938 register struct objfile
*objfile
;
941 /* Search all symtabs for the one whose file contains our address, and which
942 is the smallest of all the ones containing the address. This is designed
943 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
944 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
945 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
946 This is said to happen for the mips; it might be swifter to create
947 several symtabs with the same name like xcoff does (I'm not sure). */
949 ALL_SYMTABS (objfile
, s
)
951 bv
= BLOCKVECTOR (s
);
952 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
953 if (BLOCK_START (b
) <= pc
954 && BLOCK_END (b
) > pc
956 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
958 distance
= BLOCK_END (b
) - BLOCK_START (b
);
967 ps
= find_pc_psymtab (pc
);
971 /* Might want to error() here (in case symtab is corrupt and
972 will cause a core dump), but maybe we can successfully
973 continue, so let's not. */
975 (Internal error: pc 0x%x in read in psymtab, but not in symtab.)\n", pc
);
976 s
= PSYMTAB_TO_SYMTAB (ps
);
981 /* Find the source file and line number for a given PC value.
982 Return a structure containing a symtab pointer, a line number,
983 and a pc range for the entire source line.
984 The value's .pc field is NOT the specified pc.
985 NOTCURRENT nonzero means, if specified pc is on a line boundary,
986 use the line that ends there. Otherwise, in that case, the line
987 that begins there is used. */
989 /* The big complication here is that a line may start in one file, and end just
990 before the start of another file. This usually occurs when you #include
991 code in the middle of a subroutine. To properly find the end of a line's PC
992 range, we must search all symtabs associated with this compilation unit, and
993 find the one whose first PC is closer than that of the next line in this
996 /* If it's worth the effort, we could be using a binary search. */
998 struct symtab_and_line
999 find_pc_line (pc
, notcurrent
)
1004 register struct linetable
*l
;
1007 register struct linetable_entry
*item
;
1008 struct symtab_and_line val
;
1009 struct blockvector
*bv
;
1011 /* Info on best line seen so far, and where it starts, and its file. */
1013 struct linetable_entry
*best
= NULL
;
1014 CORE_ADDR best_end
= 0;
1015 struct symtab
*best_symtab
= 0;
1017 /* Store here the first line number
1018 of a file which contains the line at the smallest pc after PC.
1019 If we don't find a line whose range contains PC,
1020 we will use a line one less than this,
1021 with a range from the start of that file to the first line's pc. */
1022 struct linetable_entry
*alt
= NULL
;
1023 struct symtab
*alt_symtab
= 0;
1025 /* Info on best line seen in this file. */
1027 struct linetable_entry
*prev
;
1029 /* If this pc is not from the current frame,
1030 it is the address of the end of a call instruction.
1031 Quite likely that is the start of the following statement.
1032 But what we want is the statement containing the instruction.
1033 Fudge the pc to make sure we get that. */
1035 if (notcurrent
) pc
-= 1;
1037 s
= find_pc_symtab (pc
);
1047 bv
= BLOCKVECTOR (s
);
1049 /* Look at all the symtabs that share this blockvector.
1050 They all have the same apriori range, that we found was right;
1051 but they have different line tables. */
1053 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1055 /* Find the best line in this symtab. */
1062 /* I think len can be zero if the symtab lacks line numbers
1063 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1064 I'm not sure which, and maybe it depends on the symbol
1070 item
= l
->item
; /* Get first line info */
1072 /* Is this file's first line closer than the first lines of other files?
1073 If so, record this file, and its first line, as best alternate. */
1074 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1080 for (i
= 0; i
< len
; i
++, item
++)
1082 /* Return the last line that did not start after PC. */
1089 /* At this point, prev points at the line whose start addr is <= pc, and
1090 item points at the next line. If we ran off the end of the linetable
1091 (pc >= start of the last line), then prev == item. If pc < start of
1092 the first line, prev will not be set. */
1094 /* Is this file's best line closer than the best in the other files?
1095 If so, record this file, and its best line, as best so far. */
1097 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1101 /* If another line is in the linetable, and its PC is closer
1102 than the best_end we currently have, take it as best_end. */
1103 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1104 best_end
= item
->pc
;
1111 { /* If we didn't find any line # info, just
1120 val
.symtab
= alt_symtab
;
1121 val
.line
= alt
->line
- 1;
1122 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1128 val
.symtab
= best_symtab
;
1129 val
.line
= best
->line
;
1131 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1136 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1141 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1144 /* Find line number LINE in any symtab whose name is the same as
1147 If found, return 1, set *LINETABLE to the linetable in which it was
1148 found, set *INDEX to the index in the linetable of the best entry
1149 found, and set *EXACT_MATCH nonzero if the value returned is an
1152 If not found, return 0. */
1155 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1156 struct symtab
*symtab
;
1158 struct linetable
**linetable
;
1164 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1168 struct linetable
*best_linetable
;
1170 /* First try looking it up in the given symtab. */
1171 best_linetable
= LINETABLE (symtab
);
1172 best_index
= find_line_common (best_linetable
, line
, &exact
);
1173 if (best_index
< 0 || !exact
)
1175 /* Didn't find an exact match. So we better keep looking for
1176 another symtab with the same name. In the case of xcoff,
1177 multiple csects for one source file (produced by IBM's FORTRAN
1178 compiler) produce multiple symtabs (this is unavoidable
1179 assuming csects can be at arbitrary places in memory and that
1180 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1182 /* BEST is the smallest linenumber > LINE so far seen,
1183 or 0 if none has been seen so far.
1184 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1187 struct objfile
*objfile
;
1190 if (best_index
>= 0)
1191 best
= best_linetable
->item
[best_index
].line
;
1195 ALL_SYMTABS (objfile
, s
)
1197 struct linetable
*l
;
1200 if (!STREQ (symtab
->filename
, s
->filename
))
1203 ind
= find_line_common (l
, line
, &exact
);
1212 if (best
== 0 || l
->item
[ind
].line
< best
)
1214 best
= l
->item
[ind
].line
;
1226 *index
= best_index
;
1228 *linetable
= best_linetable
;
1230 *exact_match
= exact
;
1234 /* Find the PC value for a given source file and line number.
1235 Returns zero for invalid line number.
1236 The source file is specified with a struct symtab. */
1239 find_line_pc (symtab
, line
)
1240 struct symtab
*symtab
;
1243 struct linetable
*l
;
1248 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1249 return l
->item
[ind
].pc
;
1254 /* Find the range of pc values in a line.
1255 Store the starting pc of the line into *STARTPTR
1256 and the ending pc (start of next line) into *ENDPTR.
1257 Returns 1 to indicate success.
1258 Returns 0 if could not find the specified line. */
1261 find_line_pc_range (symtab
, thisline
, startptr
, endptr
)
1262 struct symtab
*symtab
;
1264 CORE_ADDR
*startptr
, *endptr
;
1266 struct linetable
*l
;
1268 int exact_match
; /* did we get an exact linenumber match */
1273 if (find_line_symtab (symtab
, thisline
, &l
, &ind
, &exact_match
))
1275 *startptr
= l
->item
[ind
].pc
;
1276 /* If we have not seen an entry for the specified line,
1277 assume that means the specified line has zero bytes. */
1278 if (!exact_match
|| ind
== l
->nitems
-1)
1279 *endptr
= *startptr
;
1281 /* Perhaps the following entry is for the following line.
1282 It's worth a try. */
1283 if (ind
+1 < l
->nitems
1284 && l
->item
[ind
+1].line
== thisline
+ 1)
1285 *endptr
= l
->item
[ind
+1].pc
;
1287 *endptr
= find_line_pc (symtab
, thisline
+1);
1294 /* Given a line table and a line number, return the index into the line
1295 table for the pc of the nearest line whose number is >= the specified one.
1296 Return -1 if none is found. The value is >= 0 if it is an index.
1298 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1301 find_line_common (l
, lineno
, exact_match
)
1302 register struct linetable
*l
;
1303 register int lineno
;
1309 /* BEST is the smallest linenumber > LINENO so far seen,
1310 or 0 if none has been seen so far.
1311 BEST_INDEX identifies the item for it. */
1313 int best_index
= -1;
1322 for (i
= 0; i
< len
; i
++)
1324 register struct linetable_entry
*item
= &(l
->item
[i
]);
1326 if (item
->line
== lineno
)
1328 /* Return the first (lowest address) entry which matches. */
1333 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1340 /* If we got here, we didn't get an exact match. */
1347 find_pc_line_pc_range (pc
, startptr
, endptr
)
1349 CORE_ADDR
*startptr
, *endptr
;
1351 struct symtab_and_line sal
;
1352 sal
= find_pc_line (pc
, 0);
1355 return sal
.symtab
!= 0;
1358 /* If P is of the form "operator[ \t]+..." where `...' is
1359 some legitimate operator text, return a pointer to the
1360 beginning of the substring of the operator text.
1361 Otherwise, return "". */
1363 operator_chars (p
, end
)
1368 if (strncmp (p
, "operator", 8))
1372 /* Don't get faked out by `operator' being part of a longer
1374 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1377 /* Allow some whitespace between `operator' and the operator symbol. */
1378 while (*p
== ' ' || *p
== '\t')
1381 /* Recognize 'operator TYPENAME'. */
1383 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1385 register char *q
= p
+1;
1386 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1411 if (p
[1] == '=' || p
[1] == p
[0])
1422 error ("`operator ()' must be specified without whitespace in `()'");
1427 error ("`operator ?:' must be specified without whitespace in `?:'");
1432 error ("`operator []' must be specified without whitespace in `[]'");
1436 error ("`operator %s' not supported", p
);
1443 /* Recursive helper function for decode_line_1.
1444 * Look for methods named NAME in type T.
1445 * Return number of matches.
1446 * Put matches in SYM_ARR (which better be big enough!).
1447 * These allocations seem to define "big enough":
1448 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1449 * Note that this function is g++ specific.
1453 find_methods (t
, name
, sym_arr
)
1456 struct symbol
**sym_arr
;
1460 struct symbol
*sym_class
;
1461 char *class_name
= type_name_no_tag (t
);
1462 /* Ignore this class if it doesn't have a name. This is ugly, but
1463 unless we figure out how to get the physname without the name of
1464 the class, then the loop can't do any good. */
1466 && (sym_class
= lookup_symbol (class_name
,
1467 (struct block
*)NULL
,
1470 (struct symtab
**)NULL
)))
1473 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1474 t
= SYMBOL_TYPE (sym_class
);
1475 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1476 method_counter
>= 0;
1480 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1482 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1483 if (STREQ (name
, method_name
))
1484 /* Find all the fields with that name. */
1485 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1490 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1491 check_stub_method (t
, method_counter
, field_counter
);
1492 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1493 /* Destructor is handled by caller, dont add it to the list */
1494 if (DESTRUCTOR_PREFIX_P (phys_name
))
1497 /* FIXME: Why are we looking this up in the
1498 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1499 for nested types? If so, it should probably hook to the
1500 type, not the symbol. mipsread.c is the only symbol
1501 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1502 this is not documented in symtab.h. -26Aug93. */
1504 sym_arr
[i1
] = lookup_symbol (phys_name
,
1505 SYMBOL_BLOCK_VALUE (sym_class
),
1508 (struct symtab
**) NULL
);
1509 if (sym_arr
[i1
]) i1
++;
1512 fputs_filtered("(Cannot find method ", stdout
);
1513 fprintf_symbol_filtered (stdout
, phys_name
,
1514 language_cplus
, DMGL_PARAMS
);
1515 fputs_filtered(" - possibly inlined.)\n", stdout
);
1521 /* Only search baseclasses if there is no match yet, since names in
1522 derived classes override those in baseclasses.
1524 FIXME: The above is not true; it is only true of member functions
1525 if they have the same number of arguments (??? - section 13.1 of the
1526 ARM says the function members are not in the same scope but doesn't
1527 really spell out the rules in a way I understand. In any case, if
1528 the number of arguments differ this is a case in which we can overload
1529 rather than hiding without any problem, and gcc 2.4.5 does overload
1530 rather than hiding in this case). */
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
)
1961 copy
[p
- *argptr
- 1] = '\0';
1964 while (*p
== ' ' || *p
== '\t') p
++;
1967 /* Look up that token as a variable.
1968 If file specified, use that file's per-file block to start with. */
1970 sym
= lookup_symbol (copy
,
1971 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1972 : get_selected_block ()),
1973 VAR_NAMESPACE
, 0, &sym_symtab
);
1977 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1979 /* Arg is the name of a function */
1980 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) + FUNCTION_START_OFFSET
;
1983 val
= find_pc_line (pc
, 0);
1984 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1985 /* Convex: no need to suppress code on first line, if any */
1988 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1989 line is still part of the same function. */
1991 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
1992 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1994 /* First pc of next line */
1996 /* Recalculate the line number (might not be N+1). */
1997 val
= find_pc_line (pc
, 0);
2001 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2002 values
.sals
[0] = val
;
2005 /* I think this is always the same as the line that
2006 we calculate above, but the general principle is
2007 "trust the symbols more than stuff like
2009 if (SYMBOL_LINE (sym
) != 0)
2010 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2012 /* We might need a canonical line spec if it is a static function. */
2015 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2016 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2017 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2018 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2022 else if (SYMBOL_LINE (sym
) != 0)
2024 /* We know its line number. */
2025 values
.sals
= (struct symtab_and_line
*)
2026 xmalloc (sizeof (struct symtab_and_line
));
2028 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2029 values
.sals
[0].symtab
= sym_symtab
;
2030 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2034 /* This can happen if it is compiled with a compiler which doesn't
2035 put out line numbers for variables. */
2036 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2037 return? For example, "info line foo" could print the address. */
2038 error ("Line number not known for symbol \"%s\"", copy
);
2041 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2042 if (msymbol
!= NULL
)
2046 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
) + FUNCTION_START_OFFSET
;
2048 SKIP_PROLOGUE (val
.pc
);
2049 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2050 values
.sals
[0] = val
;
2055 if (!have_full_symbols () &&
2056 !have_partial_symbols () && !have_minimal_symbols ())
2057 error (no_symtab_msg
);
2059 error ("Function \"%s\" not defined.", copy
);
2060 return values
; /* for lint */
2063 struct symtabs_and_lines
2064 decode_line_spec (string
, funfirstline
)
2068 struct symtabs_and_lines sals
;
2070 error ("Empty line specification.");
2071 sals
= decode_line_1 (&string
, funfirstline
,
2072 current_source_symtab
, current_source_line
,
2075 error ("Junk at end of line specification: %s", string
);
2079 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2080 operate on (ask user if necessary).
2081 If CANONICAL is non-NULL return a corresponding array of mangled names
2082 as canonical line specs there. */
2084 static struct symtabs_and_lines
2085 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2086 struct symbol
*sym_arr
[];
2091 struct symtabs_and_lines values
, return_values
;
2092 register CORE_ADDR pc
;
2097 struct cleanup
*old_chain
;
2098 char **canonical_arr
= (char **)NULL
;
2100 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2101 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2102 old_chain
= make_cleanup (free
, return_values
.sals
);
2106 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2107 make_cleanup (free
, canonical_arr
);
2108 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2109 *canonical
= canonical_arr
;
2113 printf("[0] cancel\n[1] all\n");
2116 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2118 /* Arg is the name of a function */
2119 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]))
2120 + FUNCTION_START_OFFSET
;
2123 values
.sals
[i
] = find_pc_line (pc
, 0);
2124 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2125 values
.sals
[i
].end
: pc
;
2126 printf("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2127 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2129 else printf ("?HERE\n");
2133 if ((prompt
= getenv ("PS2")) == NULL
)
2137 printf("%s ",prompt
);
2140 args
= command_line_input ((char *) NULL
, 0);
2142 if (args
== 0 || *args
== 0)
2143 error_no_arg ("one or more choice numbers");
2151 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2152 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2153 error ("Arguments must be choice numbers.");
2158 error ("cancelled");
2163 for (i
= 0; i
< nelts
; i
++)
2165 if (canonical_arr
[i
] == NULL
)
2167 symname
= SYMBOL_NAME (sym_arr
[i
]);
2168 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2172 memcpy (return_values
.sals
, values
.sals
,
2173 (nelts
* sizeof(struct symtab_and_line
)));
2174 return_values
.nelts
= nelts
;
2175 discard_cleanups (old_chain
);
2176 return return_values
;
2179 if (num
> nelts
+ 2)
2181 printf ("No choice number %d.\n", num
);
2186 if (values
.sals
[num
].pc
)
2190 symname
= SYMBOL_NAME (sym_arr
[num
]);
2191 make_cleanup (free
, symname
);
2192 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2194 return_values
.sals
[i
++] = values
.sals
[num
];
2195 values
.sals
[num
].pc
= 0;
2199 printf ("duplicate request for %d ignored.\n", num
);
2204 while (*args
== ' ' || *args
== '\t') args
++;
2206 return_values
.nelts
= i
;
2207 discard_cleanups (old_chain
);
2208 return return_values
;
2212 /* Slave routine for sources_info. Force line breaks at ,'s.
2213 NAME is the name to print and *FIRST is nonzero if this is the first
2214 name printed. Set *FIRST to zero. */
2216 output_source_filename (name
, first
)
2220 /* Table of files printed so far. Since a single source file can
2221 result in several partial symbol tables, we need to avoid printing
2222 it more than once. Note: if some of the psymtabs are read in and
2223 some are not, it gets printed both under "Source files for which
2224 symbols have been read" and "Source files for which symbols will
2225 be read in on demand". I consider this a reasonable way to deal
2226 with the situation. I'm not sure whether this can also happen for
2227 symtabs; it doesn't hurt to check. */
2228 static char **tab
= NULL
;
2229 /* Allocated size of tab in elements.
2230 Start with one 256-byte block (when using GNU malloc.c).
2231 24 is the malloc overhead when range checking is in effect. */
2232 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2233 /* Current size of tab in elements. */
2234 static int tab_cur_size
;
2241 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2245 /* Is NAME in tab? */
2246 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2247 if (STREQ (*p
, name
))
2248 /* Yes; don't print it again. */
2250 /* No; add it to tab. */
2251 if (tab_cur_size
== tab_alloc_size
)
2253 tab_alloc_size
*= 2;
2254 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2256 tab
[tab_cur_size
++] = name
;
2264 printf_filtered (", ");
2268 fputs_filtered (name
, stdout
);
2272 sources_info (ignore
, from_tty
)
2276 register struct symtab
*s
;
2277 register struct partial_symtab
*ps
;
2278 register struct objfile
*objfile
;
2281 if (!have_full_symbols () && !have_partial_symbols ())
2283 error (no_symtab_msg
);
2286 printf_filtered ("Source files for which symbols have been read in:\n\n");
2289 ALL_SYMTABS (objfile
, s
)
2291 output_source_filename (s
-> filename
, &first
);
2293 printf_filtered ("\n\n");
2295 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2298 ALL_PSYMTABS (objfile
, ps
)
2302 output_source_filename (ps
-> filename
, &first
);
2305 printf_filtered ("\n");
2308 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2309 If CLASS is zero, list all symbols except functions, type names, and
2311 If CLASS is 1, list only functions.
2312 If CLASS is 2, list only type names.
2313 If CLASS is 3, list only method names.
2315 BPT is non-zero if we should set a breakpoint at the functions
2319 list_symbols (regexp
, class, bpt
)
2324 register struct symtab
*s
;
2325 register struct partial_symtab
*ps
;
2326 register struct blockvector
*bv
;
2327 struct blockvector
*prev_bv
= 0;
2328 register struct block
*b
;
2330 register struct symbol
*sym
;
2331 struct partial_symbol
*psym
;
2332 struct objfile
*objfile
;
2333 struct minimal_symbol
*msymbol
;
2335 static char *classnames
[]
2336 = {"variable", "function", "type", "method"};
2337 int found_in_file
= 0;
2339 static enum minimal_symbol_type types
[]
2340 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2341 static enum minimal_symbol_type types2
[]
2342 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2343 enum minimal_symbol_type ourtype
= types
[class];
2344 enum minimal_symbol_type ourtype2
= types2
[class];
2348 /* Make sure spacing is right for C++ operators.
2349 This is just a courtesy to make the matching less sensitive
2350 to how many spaces the user leaves between 'operator'
2351 and <TYPENAME> or <OPERATOR>. */
2353 char *opname
= operator_chars (regexp
, &opend
);
2356 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2357 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2359 /* There should 1 space between 'operator' and 'TYPENAME'. */
2360 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2365 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2366 if (opname
[-1] == ' ')
2369 /* If wrong number of spaces, fix it. */
2372 char *tmp
= (char*) alloca(opend
-opname
+10);
2373 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2378 if (0 != (val
= re_comp (regexp
)))
2379 error ("Invalid regexp (%s): %s", val
, regexp
);
2382 /* Search through the partial symtabs *first* for all symbols
2383 matching the regexp. That way we don't have to reproduce all of
2384 the machinery below. */
2386 ALL_PSYMTABS (objfile
, ps
)
2388 struct partial_symbol
*bound
, *gbound
, *sbound
;
2391 if (ps
->readin
) continue;
2393 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2394 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2397 /* Go through all of the symbols stored in a partial
2398 symtab in one loop. */
2399 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2404 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2406 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2417 /* If it would match (logic taken from loop below)
2418 load the file and go on to the next one */
2419 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2420 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2421 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2422 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2423 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2424 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2426 PSYMTAB_TO_SYMTAB(ps
);
2434 /* Here, we search through the minimal symbol tables for functions that
2435 match, and call find_pc_symtab on them to force their symbols to
2436 be read. The symbol will then be found during the scan of symtabs
2437 below. If find_pc_symtab fails, set found_misc so that we will
2438 rescan to print any matching symbols without debug info. */
2442 ALL_MSYMBOLS (objfile
, msymbol
)
2444 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2445 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2447 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2449 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2458 /* Printout here so as to get after the "Reading in symbols"
2459 messages which will be generated above. */
2461 printf_filtered (regexp
2462 ? "All %ss matching regular expression \"%s\":\n"
2463 : "All defined %ss:\n",
2467 ALL_SYMTABS (objfile
, s
)
2470 bv
= BLOCKVECTOR (s
);
2471 /* Often many files share a blockvector.
2472 Scan each blockvector only once so that
2473 we don't get every symbol many times.
2474 It happens that the first symtab in the list
2475 for any given blockvector is the main file. */
2477 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2479 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2480 /* Skip the sort if this block is always sorted. */
2481 if (!BLOCK_SHOULD_SORT (b
))
2482 sort_block_syms (b
);
2483 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2486 sym
= BLOCK_SYM (b
, j
);
2487 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2488 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2489 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2490 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2491 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2492 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2493 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2497 /* Set a breakpoint here, if it's a function */
2500 /* There may be more than one function with the
2501 same name but in different files. In order to
2502 set breakpoints on all of them, we must give
2503 both the file name and the function name to
2506 (char *) alloca (strlen (s
->filename
)
2507 + strlen (SYMBOL_NAME(sym
))
2509 strcpy (string
, s
->filename
);
2510 strcat (string
, ":");
2511 strcat (string
, SYMBOL_NAME(sym
));
2512 break_command (string
, 0);
2515 else if (!found_in_file
)
2517 fputs_filtered ("\nFile ", stdout
);
2518 fputs_filtered (s
->filename
, stdout
);
2519 fputs_filtered (":\n", stdout
);
2523 if (class != 2 && i
== STATIC_BLOCK
)
2524 printf_filtered ("static ");
2526 /* Typedef that is not a C++ class */
2528 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2529 c_typedef_print (SYMBOL_TYPE(sym
), sym
, stdout
);
2530 /* variable, func, or typedef-that-is-c++-class */
2531 else if (class < 2 ||
2533 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2535 type_print (SYMBOL_TYPE (sym
),
2536 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2537 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2540 printf_filtered (";\n");
2544 # if 0 /* FIXME, why is this zapped out? */
2546 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2548 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2550 sprintf (buf
, " %s::", type_name_no_tag (t
));
2551 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2561 /* If there are no eyes, avoid all contact. I mean, if there are
2562 no debug symbols, then print directly from the msymbol_vector. */
2564 if (found_misc
|| class != 1)
2567 ALL_MSYMBOLS (objfile
, msymbol
)
2569 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2570 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2572 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2574 /* Functions: Look up by address. */
2576 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2578 /* Variables/Absolutes: Look up by name */
2579 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2580 (struct block
*) NULL
, VAR_NAMESPACE
,
2581 0, (struct symtab
**) NULL
) == NULL
)
2585 printf_filtered ("\nNon-debugging symbols:\n");
2588 printf_filtered (" %08x %s\n",
2589 SYMBOL_VALUE_ADDRESS (msymbol
),
2590 SYMBOL_SOURCE_NAME (msymbol
));
2600 variables_info (regexp
, from_tty
)
2604 list_symbols (regexp
, 0, 0);
2608 functions_info (regexp
, from_tty
)
2612 list_symbols (regexp
, 1, 0);
2616 types_info (regexp
, from_tty
)
2620 list_symbols (regexp
, 2, 0);
2624 /* Tiemann says: "info methods was never implemented." */
2626 methods_info (regexp
)
2629 list_symbols (regexp
, 3, 0);
2633 /* Breakpoint all functions matching regular expression. */
2635 rbreak_command (regexp
, from_tty
)
2639 list_symbols (regexp
, 1, 1);
2643 /* Return Nonzero if block a is lexically nested within block b,
2644 or if a and b have the same pc range.
2645 Return zero otherwise. */
2648 struct block
*a
, *b
;
2652 return BLOCK_START (a
) >= BLOCK_START (b
)
2653 && BLOCK_END (a
) <= BLOCK_END (b
);
2657 /* Helper routine for make_symbol_completion_list. */
2659 static int return_val_size
;
2660 static int return_val_index
;
2661 static char **return_val
;
2663 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2665 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2666 /* Put only the mangled name on the list. */ \
2667 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2668 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2669 completion_list_add_name \
2670 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2672 completion_list_add_name \
2673 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2676 /* Test to see if the symbol specified by SYMNAME (which is already
2677 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2678 characters. If so, add it to the current completion list. */
2681 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2691 /* clip symbols that cannot match */
2693 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2698 /* Clip any symbol names that we've already considered. (This is a
2699 time optimization) */
2701 for (i
= 0; i
< return_val_index
; ++i
)
2703 if (STREQ (symname
, return_val
[i
]))
2709 /* We have a match for a completion, so add SYMNAME to the current list
2710 of matches. Note that the name is moved to freshly malloc'd space. */
2714 if (word
== sym_text
)
2716 new = xmalloc (strlen (symname
) + 5);
2717 strcpy (new, symname
);
2719 else if (word
> sym_text
)
2721 /* Return some portion of symname. */
2722 new = xmalloc (strlen (symname
) + 5);
2723 strcpy (new, symname
+ (word
- sym_text
));
2727 /* Return some of SYM_TEXT plus symname. */
2728 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2729 strncpy (new, word
, sym_text
- word
);
2730 new[sym_text
- word
] = '\0';
2731 strcat (new, symname
);
2734 if (return_val_index
+ 3 > return_val_size
)
2736 newsize
= (return_val_size
*= 2) * sizeof (char *);
2737 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2739 return_val
[return_val_index
++] = new;
2740 return_val
[return_val_index
] = NULL
;
2744 /* Return a NULL terminated array of all symbols (regardless of class) which
2745 begin by matching TEXT. If the answer is no symbols, then the return value
2746 is an array which contains only a NULL pointer.
2748 Problem: All of the symbols have to be copied because readline frees them.
2749 I'm not going to worry about this; hopefully there won't be that many. */
2752 make_symbol_completion_list (text
, word
)
2756 register struct symbol
*sym
;
2757 register struct symtab
*s
;
2758 register struct partial_symtab
*ps
;
2759 register struct minimal_symbol
*msymbol
;
2760 register struct objfile
*objfile
;
2761 register struct block
*b
, *surrounding_static_block
= 0;
2763 struct partial_symbol
*psym
;
2764 /* The symbol we are completing on. Points in same buffer as text. */
2766 /* Length of sym_text. */
2769 /* Now look for the symbol we are supposed to complete on.
2770 FIXME: This should be language-specific. */
2774 char *quote_pos
= NULL
;
2776 /* First see if this is a quoted string. */
2778 for (p
= text
; *p
!= '\0'; ++p
)
2780 if (quote_found
!= '\0')
2782 if (*p
== quote_found
)
2783 /* Found close quote. */
2785 else if (*p
== '\\' && p
[1] == quote_found
)
2786 /* A backslash followed by the quote character
2787 doesn't end the string. */
2790 else if (*p
== '\'' || *p
== '"')
2796 if (quote_found
== '\'')
2797 /* A string within single quotes can be a symbol, so complete on it. */
2798 sym_text
= quote_pos
+ 1;
2799 else if (quote_found
== '"')
2800 /* A double-quoted string is never a symbol, nor does it make sense
2801 to complete it any other way. */
2805 /* It is not a quoted string. Break it based on the characters
2806 which are in symbols. */
2809 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2818 sym_text_len
= strlen (sym_text
);
2820 return_val_size
= 100;
2821 return_val_index
= 0;
2822 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2823 return_val
[0] = NULL
;
2825 /* Look through the partial symtabs for all symbols which begin
2826 by matching SYM_TEXT. Add each one that you find to the list. */
2828 ALL_PSYMTABS (objfile
, ps
)
2830 /* If the psymtab's been read in we'll get it when we search
2831 through the blockvector. */
2832 if (ps
->readin
) continue;
2834 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2835 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2836 + ps
->n_global_syms
);
2839 /* If interrupted, then quit. */
2841 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2844 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2845 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2846 + ps
->n_static_syms
);
2850 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2854 /* At this point scan through the misc symbol vectors and add each
2855 symbol you find to the list. Eventually we want to ignore
2856 anything that isn't a text symbol (everything else will be
2857 handled by the psymtab code above). */
2859 ALL_MSYMBOLS (objfile
, msymbol
)
2862 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2865 /* Search upwards from currently selected frame (so that we can
2866 complete on local vars. */
2868 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2870 if (!BLOCK_SUPERBLOCK (b
))
2872 surrounding_static_block
= b
; /* For elmin of dups */
2875 /* Also catch fields of types defined in this places which match our
2876 text string. Only complete on types visible from current context. */
2878 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2880 sym
= BLOCK_SYM (b
, i
);
2881 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2882 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2884 struct type
*t
= SYMBOL_TYPE (sym
);
2885 enum type_code c
= TYPE_CODE (t
);
2887 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2889 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2891 if (TYPE_FIELD_NAME (t
, j
))
2893 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2894 sym_text
, sym_text_len
, text
, word
);
2902 /* Go through the symtabs and check the externs and statics for
2903 symbols which match. */
2905 ALL_SYMTABS (objfile
, s
)
2908 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2909 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2911 sym
= BLOCK_SYM (b
, i
);
2912 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2916 ALL_SYMTABS (objfile
, s
)
2919 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2920 /* Don't do this block twice. */
2921 if (b
== surrounding_static_block
) continue;
2922 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2924 sym
= BLOCK_SYM (b
, i
);
2925 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2929 return (return_val
);
2934 /* Add the type of the symbol sym to the type of the current
2935 function whose block we are in (assumed). The type of
2936 this current function is contained in *TYPE.
2938 This basically works as follows: When we find a function
2939 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2940 a pointer to its type in the global in_function_type. Every
2941 time we come across a parameter symbol ('p' in its name), then
2942 this procedure adds the name and type of that parameter
2943 to the function type pointed to by *TYPE. (Which should correspond
2944 to in_function_type if it was called correctly).
2946 Note that since we are modifying a type, the result of
2947 lookup_function_type() should be memcpy()ed before calling
2948 this. When not in strict typing mode, the expression
2949 evaluator can choose to ignore this.
2951 Assumption: All of a function's parameter symbols will
2952 appear before another function symbol is found. The parameters
2953 appear in the same order in the argument list as they do in the
2957 add_param_to_type (type
,sym
)
2961 int num
= ++(TYPE_NFIELDS(*type
));
2963 if(TYPE_NFIELDS(*type
)-1)
2964 TYPE_FIELDS(*type
) = (struct field
*)
2965 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
2966 num
*sizeof(struct field
));
2968 TYPE_FIELDS(*type
) = (struct field
*)
2969 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
2971 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
2972 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
2973 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
2974 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
2979 _initialize_symtab ()
2981 add_info ("variables", variables_info
,
2982 "All global and static variable names, or those matching REGEXP.");
2983 add_info ("functions", functions_info
,
2984 "All function names, or those matching REGEXP.");
2986 /* FIXME: This command has at least the following problems:
2987 1. It prints builtin types (in a very strange and confusing fashion).
2988 2. It doesn't print right, e.g. with
2989 typedef struct foo *FOO
2990 type_print prints "FOO" when we want to make it (in this situation)
2991 print "struct foo *".
2992 I also think "ptype" or "whatis" is more likely to be useful (but if
2993 there is much disagreement "info types" can be fixed). */
2994 add_info ("types", types_info
,
2995 "All type names, or those matching REGEXP.");
2998 add_info ("methods", methods_info
,
2999 "All method names, or those matching REGEXP::REGEXP.\n\
3000 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3001 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3004 add_info ("sources", sources_info
,
3005 "Source files in the program.");
3007 add_com ("rbreak", no_class
, rbreak_command
,
3008 "Set a breakpoint for all functions matching REGEXP.");
3010 /* Initialize the one built-in type that isn't language dependent... */
3011 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3012 "<unknown type>", (struct objfile
*) NULL
);