1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "call-cmds.h"
33 #include "expression.h"
40 #include <sys/types.h>
46 /* Prototypes for local functions */
49 find_methods
PARAMS ((struct type
*, char *, struct symbol
**));
52 completion_list_add_name
PARAMS ((char *, char *, int, char *, char *));
55 build_canonical_line_spec
PARAMS ((struct symtab_and_line
*, char *, char ***));
57 static struct symtabs_and_lines
58 decode_line_2
PARAMS ((struct symbol
*[], int, int, char ***));
61 rbreak_command
PARAMS ((char *, int));
64 types_info
PARAMS ((char *, int));
67 functions_info
PARAMS ((char *, int));
70 variables_info
PARAMS ((char *, int));
73 sources_info
PARAMS ((char *, int));
76 list_symbols
PARAMS ((char *, int, int));
79 output_source_filename
PARAMS ((char *, int *));
82 operator_chars
PARAMS ((char *, char **));
84 static int find_line_common
PARAMS ((struct linetable
*, int, int *));
86 static struct partial_symbol
*
87 lookup_partial_symbol
PARAMS ((struct partial_symtab
*, const char *,
88 int, enum namespace));
90 static struct symtab
*
91 lookup_symtab_1
PARAMS ((char *));
95 /* The single non-language-specific builtin type */
96 struct type
*builtin_type_error
;
98 /* Block in which the most recently searched-for symbol was found.
99 Might be better to make this a parameter to lookup_symbol and
102 const struct block
*block_found
;
104 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
106 /* While the C++ support is still in flux, issue a possibly helpful hint on
107 using the new command completion feature on single quoted demangled C++
108 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
111 cplusplus_hint (name
)
114 printf_unfiltered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
115 printf_unfiltered ("(Note leading single quote.)\n");
118 /* Check for a symtab of a specific name; first in symtabs, then in
119 psymtabs. *If* there is no '/' in the name, a match after a '/'
120 in the symtab filename will also work. */
122 static struct symtab
*
123 lookup_symtab_1 (name
)
126 register struct symtab
*s
;
127 register struct partial_symtab
*ps
;
128 register char *slash
;
129 register struct objfile
*objfile
;
133 /* First, search for an exact match */
135 ALL_SYMTABS (objfile
, s
)
136 if (STREQ (name
, s
->filename
))
139 slash
= strchr (name
, '/');
141 /* Now, search for a matching tail (only if name doesn't have any dirs) */
144 ALL_SYMTABS (objfile
, s
)
146 char *p
= s
-> filename
;
147 char *tail
= strrchr (p
, '/');
156 /* Same search rules as above apply here, but now we look thru the
159 ps
= lookup_partial_symtab (name
);
164 error ("Internal: readin %s pst for `%s' found when no symtab found.",
165 ps
-> filename
, name
);
167 s
= PSYMTAB_TO_SYMTAB (ps
);
172 /* At this point, we have located the psymtab for this file, but
173 the conversion to a symtab has failed. This usually happens
174 when we are looking up an include file. In this case,
175 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
176 been created. So, we need to run through the symtabs again in
177 order to find the file.
178 XXX - This is a crock, and should be fixed inside of the the
179 symbol parsing routines. */
183 /* Lookup the symbol table of a source file named NAME. Try a couple
184 of variations if the first lookup doesn't work. */
190 register struct symtab
*s
;
193 s
= lookup_symtab_1 (name
);
196 /* If name not found as specified, see if adding ".c" helps. */
197 /* Why is this? Is it just a user convenience? (If so, it's pretty
198 questionable in the presence of C++, FORTRAN, etc.). It's not in
201 copy
= (char *) alloca (strlen (name
) + 3);
204 s
= lookup_symtab_1 (copy
);
207 /* We didn't find anything; die. */
211 /* Lookup the partial symbol table of a source file named NAME.
212 *If* there is no '/' in the name, a match after a '/'
213 in the psymtab filename will also work. */
215 struct partial_symtab
*
216 lookup_partial_symtab (name
)
219 register struct partial_symtab
*pst
;
220 register struct objfile
*objfile
;
222 ALL_PSYMTABS (objfile
, pst
)
224 if (STREQ (name
, pst
-> filename
))
230 /* Now, search for a matching tail (only if name doesn't have any dirs) */
232 if (!strchr (name
, '/'))
233 ALL_PSYMTABS (objfile
, pst
)
235 char *p
= pst
-> filename
;
236 char *tail
= strrchr (p
, '/');
248 /* Demangle a GDB method stub type.
249 Note that this function is g++ specific. */
252 gdb_mangle_name (type
, i
, j
)
256 int mangled_name_len
;
258 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
259 struct fn_field
*method
= &f
[j
];
260 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
261 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
262 char *newname
= type_name_no_tag (type
);
264 int is_destructor
= DESTRUCTOR_PREFIX_P (physname
);
265 /* Need a new type prefix. */
266 char *const_prefix
= method
->is_const
? "C" : "";
267 char *volatile_prefix
= method
->is_volatile
? "V" : "";
269 int len
= (newname
== NULL
? 0 : strlen (newname
));
271 is_constructor
= newname
&& STREQ(field_name
, newname
);
273 is_constructor
= (physname
[0]=='_' && physname
[1]=='_' &&
274 (isdigit(physname
[2]) || physname
[2]=='Q' || physname
[2]=='t'));
276 is_constructor
= (strncmp(physname
, "__ct", 4) == 0);
278 is_destructor
= (strncmp(physname
, "__dt", 4) == 0);
280 #ifndef GCC_MANGLE_BUG
283 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
284 strcpy(mangled_name
, physname
);
290 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
291 if (strcmp(buf
, "__") == 0)
296 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
298 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
303 /* Only needed for GNU-mangled names. ANSI-mangled names
304 work with the normal mechanisms. */
305 if (OPNAME_PREFIX_P (field_name
))
307 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
309 error ("No mangling for \"%s\"", field_name
);
310 mangled_name_len
+= strlen (opname
);
311 mangled_name
= (char *)xmalloc (mangled_name_len
);
313 strncpy (mangled_name
, field_name
, 3);
314 mangled_name
[3] = '\0';
315 strcat (mangled_name
, opname
);
319 mangled_name
= (char *)xmalloc (mangled_name_len
);
321 mangled_name
[0] = '\0';
323 strcpy (mangled_name
, field_name
);
325 strcat (mangled_name
, buf
);
326 /* If the class doesn't have a name, i.e. newname NULL, then we just
327 mangle it using 0 for the length of the class. Thus it gets mangled
328 as something starting with `::' rather than `classname::'. */
330 strcat (mangled_name
, newname
);
340 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
343 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
344 + strlen (buf
) + strlen (physname
) + 1);
346 /* Only needed for GNU-mangled names. ANSI-mangled names
347 work with the normal mechanisms. */
348 if (OPNAME_PREFIX_P (field_name
))
351 opname
= cplus_mangle_opname (field_name
+ 3, 0);
354 error ("No mangling for \"%s\"", field_name
);
356 mangled_name_len
+= strlen (opname
);
357 mangled_name
= (char *) xmalloc (mangled_name_len
);
359 strncpy (mangled_name
, field_name
, 3);
360 strcpy (mangled_name
+ 3, opname
);
364 mangled_name
= (char *) xmalloc (mangled_name_len
);
367 mangled_name
[0] = '\0';
371 strcpy (mangled_name
, field_name
);
374 strcat (mangled_name
, buf
);
377 strcat (mangled_name
, physname
);
378 return (mangled_name
);
382 /* Find which partial symtab on contains PC. Return 0 if none. */
384 struct partial_symtab
*
386 register CORE_ADDR pc
;
388 register struct partial_symtab
*pst
;
389 register struct objfile
*objfile
;
391 ALL_PSYMTABS (objfile
, pst
)
393 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
399 /* Find which partial symbol within a psymtab contains PC. Return 0
400 if none. Check all psymtabs if PSYMTAB is 0. */
401 struct partial_symbol
*
402 find_pc_psymbol (psymtab
, pc
)
403 struct partial_symtab
*psymtab
;
406 struct partial_symbol
*best
= NULL
, *p
;
410 psymtab
= find_pc_psymtab (pc
);
414 best_pc
= psymtab
->textlow
- 1;
416 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
417 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
418 < psymtab
->n_static_syms
);
420 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
421 && SYMBOL_CLASS (p
) == LOC_BLOCK
422 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
423 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
425 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
428 if (best_pc
== psymtab
->textlow
- 1)
434 /* Find the definition for a specified symbol name NAME
435 in namespace NAMESPACE, visible from lexical block BLOCK.
436 Returns the struct symbol pointer, or zero if no symbol is found.
437 If SYMTAB is non-NULL, store the symbol table in which the
438 symbol was found there, or NULL if not found.
439 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
440 NAME is a field of the current implied argument `this'. If so set
441 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
442 BLOCK_FOUND is set to the block in which NAME is found (in the case of
443 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
446 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
448 register const struct block
*block
;
449 const enum namespace namespace;
450 int *is_a_field_of_this
;
451 struct symtab
**symtab
;
453 register struct symbol
*sym
;
454 register struct symtab
*s
= NULL
;
455 register struct partial_symtab
*ps
;
456 struct blockvector
*bv
;
457 register struct objfile
*objfile
;
458 register struct block
*b
;
459 register struct minimal_symbol
*msymbol
;
461 /* Search specified block and its superiors. */
465 sym
= lookup_block_symbol (block
, name
, namespace);
471 /* Search the list of symtabs for one which contains the
472 address of the start of this block. */
473 ALL_SYMTABS (objfile
, s
)
475 bv
= BLOCKVECTOR (s
);
476 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
477 if (BLOCK_START (b
) <= BLOCK_START (block
)
478 && BLOCK_END (b
) > BLOCK_START (block
))
487 block
= BLOCK_SUPERBLOCK (block
);
490 /* FIXME: this code is never executed--block is always NULL at this
491 point. What is it trying to do, anyway? We already should have
492 checked the STATIC_BLOCK above (it is the superblock of top-level
493 blocks). Why is VAR_NAMESPACE special-cased? */
494 /* Don't need to mess with the psymtabs; if we have a block,
495 that file is read in. If we don't, then we deal later with
496 all the psymtab stuff that needs checking. */
497 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
500 /* Find the right symtab. */
501 ALL_SYMTABS (objfile
, s
)
503 bv
= BLOCKVECTOR (s
);
504 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
505 if (BLOCK_START (b
) <= BLOCK_START (block
)
506 && BLOCK_END (b
) > BLOCK_START (block
))
508 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
521 /* C++: If requested to do so by the caller,
522 check to see if NAME is a field of `this'. */
523 if (is_a_field_of_this
)
525 struct value
*v
= value_of_this (0);
527 *is_a_field_of_this
= 0;
528 if (v
&& check_field (v
, name
))
530 *is_a_field_of_this
= 1;
537 /* Now search all global blocks. Do the symtab's first, then
538 check the psymtab's */
540 ALL_SYMTABS (objfile
, s
)
542 bv
= BLOCKVECTOR (s
);
543 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
544 sym
= lookup_block_symbol (block
, name
, namespace);
554 /* Check for the possibility of the symbol being a global function
555 that is stored in one of the minimal symbol tables. Eventually, all
556 global symbols might be resolved in this way. */
558 if (namespace == VAR_NAMESPACE
)
560 msymbol
= lookup_minimal_symbol (name
, (struct objfile
*) NULL
);
563 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
564 /* If S is NULL, there are no debug symbols for this file.
565 Skip this stuff and check for matching static symbols below. */
568 bv
= BLOCKVECTOR (s
);
569 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
570 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
572 /* We kept static functions in minimal symbol table as well as
573 in static scope. We want to find them in the symbol table. */
575 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
576 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
580 /* sym == 0 if symbol was found in the minimal symbol table
581 but not in the symtab.
582 Return 0 to use the msymbol definition of "foo_".
584 This happens for Fortran "foo_" symbols,
585 which are "foo" in the symtab.
587 This can also happen if "asm" is used to make a
588 regular symbol but not a debugging symbol, e.g.
600 ALL_PSYMTABS (objfile
, ps
)
602 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
604 s
= PSYMTAB_TO_SYMTAB(ps
);
605 bv
= BLOCKVECTOR (s
);
606 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
607 sym
= lookup_block_symbol (block
, name
, namespace);
609 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
616 /* Now search all per-file blocks.
617 Not strictly correct, but more useful than an error.
618 Do the symtabs first, then check the psymtabs */
620 ALL_SYMTABS (objfile
, s
)
622 bv
= BLOCKVECTOR (s
);
623 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
624 sym
= lookup_block_symbol (block
, name
, namespace);
634 ALL_PSYMTABS (objfile
, ps
)
636 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
638 s
= PSYMTAB_TO_SYMTAB(ps
);
639 bv
= BLOCKVECTOR (s
);
640 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
641 sym
= lookup_block_symbol (block
, name
, namespace);
643 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
650 /* Now search all per-file blocks for static mangled symbols.
651 Do the symtabs first, then check the psymtabs. */
653 if (namespace == VAR_NAMESPACE
)
655 ALL_SYMTABS (objfile
, s
)
657 bv
= BLOCKVECTOR (s
);
658 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
659 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
669 ALL_PSYMTABS (objfile
, ps
)
671 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, VAR_NAMESPACE
))
673 s
= PSYMTAB_TO_SYMTAB(ps
);
674 bv
= BLOCKVECTOR (s
);
675 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
676 sym
= lookup_block_symbol (block
, name
, VAR_NAMESPACE
);
678 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
691 /* Look, in partial_symtab PST, for symbol NAME. Check the global
692 symbols if GLOBAL, the static symbols if not */
694 static struct partial_symbol
*
695 lookup_partial_symbol (pst
, name
, global
, namespace)
696 struct partial_symtab
*pst
;
699 enum namespace namespace;
701 struct partial_symbol
*start
, *psym
;
702 struct partial_symbol
*top
, *bottom
, *center
;
703 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
704 int do_linear_search
= 1;
712 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
713 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
715 if (global
) /* This means we can use a binary search. */
717 do_linear_search
= 0;
719 /* Binary search. This search is guaranteed to end with center
720 pointing at the earliest partial symbol with the correct
721 name. At that point *all* partial symbols with that name
722 will be checked against the correct namespace. */
725 top
= start
+ length
- 1;
728 center
= bottom
+ (top
- bottom
) / 2;
729 assert (center
< top
);
730 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
732 do_linear_search
= 1;
734 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
743 assert (top
== bottom
);
744 while (STREQ (SYMBOL_NAME (top
), name
))
746 if (SYMBOL_NAMESPACE (top
) == namespace)
754 /* Can't use a binary search or else we found during the binary search that
755 we should also do a linear search. */
757 if (do_linear_search
)
759 for (psym
= start
; psym
< start
+ length
; psym
++)
761 if (namespace == SYMBOL_NAMESPACE (psym
))
763 if (SYMBOL_MATCHES_NAME (psym
, name
))
774 /* Find the psymtab containing main(). */
775 /* FIXME: What about languages without main() or specially linked
776 executables that have no main() ? */
778 struct partial_symtab
*
781 register struct partial_symtab
*pst
;
782 register struct objfile
*objfile
;
784 ALL_PSYMTABS (objfile
, pst
)
786 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
794 /* Search BLOCK for symbol NAME in NAMESPACE.
796 Note that if NAME is the demangled form of a C++ symbol, we will fail
797 to find a match during the binary search of the non-encoded names, but
798 for now we don't worry about the slight inefficiency of looking for
799 a match we'll never find, since it will go pretty quick. Once the
800 binary search terminates, we drop through and do a straight linear
801 search on the symbols. Each symbol which is marked as being a C++
802 symbol (language_cplus set) has both the encoded and non-encoded names
803 tested for a match. */
806 lookup_block_symbol (block
, name
, namespace)
807 register const struct block
*block
;
809 const enum namespace namespace;
811 register int bot
, top
, inc
;
812 register struct symbol
*sym
;
813 register struct symbol
*sym_found
= NULL
;
814 register int do_linear_search
= 1;
816 /* If the blocks's symbols were sorted, start with a binary search. */
818 if (BLOCK_SHOULD_SORT (block
))
820 /* Reset the linear search flag so if the binary search fails, we
821 won't do the linear search once unless we find some reason to
822 do so, such as finding a C++ symbol during the binary search.
823 Note that for C++ modules, ALL the symbols in a block should
824 end up marked as C++ symbols. */
826 do_linear_search
= 0;
827 top
= BLOCK_NSYMS (block
);
830 /* Advance BOT to not far before the first symbol whose name is NAME. */
834 inc
= (top
- bot
+ 1);
835 /* No need to keep binary searching for the last few bits worth. */
840 inc
= (inc
>> 1) + bot
;
841 sym
= BLOCK_SYM (block
, inc
);
842 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
844 do_linear_search
= 1;
846 if (SYMBOL_NAME (sym
)[0] < name
[0])
850 else if (SYMBOL_NAME (sym
)[0] > name
[0])
854 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
864 /* Now scan forward until we run out of symbols, find one whose
865 name is greater than NAME, or find one we want. If there is
866 more than one symbol with the right name and namespace, we
867 return the first one; I believe it is now impossible for us
868 to encounter two symbols with the same name and namespace
869 here, because blocks containing argument symbols are no
872 top
= BLOCK_NSYMS (block
);
875 sym
= BLOCK_SYM (block
, bot
);
876 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
879 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
881 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
893 /* Here if block isn't sorted, or we fail to find a match during the
894 binary search above. If during the binary search above, we find a
895 symbol which is a C++ symbol, then we have re-enabled the linear
896 search flag which was reset when starting the binary search.
898 This loop is equivalent to the loop above, but hacked greatly for speed.
900 Note that parameter symbols do not always show up last in the
901 list; this loop makes sure to take anything else other than
902 parameter symbols first; it only uses parameter symbols as a
903 last resort. Note that this only takes up extra computation
906 if (do_linear_search
)
908 top
= BLOCK_NSYMS (block
);
912 sym
= BLOCK_SYM (block
, bot
);
913 if (SYMBOL_NAMESPACE (sym
) == namespace &&
914 SYMBOL_MATCHES_NAME (sym
, name
))
917 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
918 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
919 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
920 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
921 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
922 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
930 return (sym_found
); /* Will be NULL if not found. */
934 /* Return the symbol for the function which contains a specified
935 lexical block, described by a struct block BL. */
941 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
942 bl
= BLOCK_SUPERBLOCK (bl
);
944 return BLOCK_FUNCTION (bl
);
947 /* Find the symtab associated with PC. Look through the psymtabs and read in
948 another symtab if necessary. */
952 register CORE_ADDR pc
;
954 register struct block
*b
;
955 struct blockvector
*bv
;
956 register struct symtab
*s
= NULL
;
957 register struct symtab
*best_s
= NULL
;
958 register struct partial_symtab
*ps
;
959 register struct objfile
*objfile
;
962 /* Search all symtabs for the one whose file contains our address, and which
963 is the smallest of all the ones containing the address. This is designed
964 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
965 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
966 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
967 This is said to happen for the mips; it might be swifter to create
968 several symtabs with the same name like xcoff does (I'm not sure). */
970 ALL_SYMTABS (objfile
, s
)
972 bv
= BLOCKVECTOR (s
);
973 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
974 if (BLOCK_START (b
) <= pc
975 && BLOCK_END (b
) > pc
977 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
979 distance
= BLOCK_END (b
) - BLOCK_START (b
);
988 ps
= find_pc_psymtab (pc
);
992 /* Might want to error() here (in case symtab is corrupt and
993 will cause a core dump), but maybe we can successfully
994 continue, so let's not. */
996 (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n",
998 s
= PSYMTAB_TO_SYMTAB (ps
);
1003 /* Find the source file and line number for a given PC value.
1004 Return a structure containing a symtab pointer, a line number,
1005 and a pc range for the entire source line.
1006 The value's .pc field is NOT the specified pc.
1007 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1008 use the line that ends there. Otherwise, in that case, the line
1009 that begins there is used. */
1011 /* The big complication here is that a line may start in one file, and end just
1012 before the start of another file. This usually occurs when you #include
1013 code in the middle of a subroutine. To properly find the end of a line's PC
1014 range, we must search all symtabs associated with this compilation unit, and
1015 find the one whose first PC is closer than that of the next line in this
1018 /* If it's worth the effort, we could be using a binary search. */
1020 struct symtab_and_line
1021 find_pc_line (pc
, notcurrent
)
1026 register struct linetable
*l
;
1029 register struct linetable_entry
*item
;
1030 struct symtab_and_line val
;
1031 struct blockvector
*bv
;
1033 /* Info on best line seen so far, and where it starts, and its file. */
1035 struct linetable_entry
*best
= NULL
;
1036 CORE_ADDR best_end
= 0;
1037 struct symtab
*best_symtab
= 0;
1039 /* Store here the first line number
1040 of a file which contains the line at the smallest pc after PC.
1041 If we don't find a line whose range contains PC,
1042 we will use a line one less than this,
1043 with a range from the start of that file to the first line's pc. */
1044 struct linetable_entry
*alt
= NULL
;
1045 struct symtab
*alt_symtab
= 0;
1047 /* Info on best line seen in this file. */
1049 struct linetable_entry
*prev
;
1051 /* If this pc is not from the current frame,
1052 it is the address of the end of a call instruction.
1053 Quite likely that is the start of the following statement.
1054 But what we want is the statement containing the instruction.
1055 Fudge the pc to make sure we get that. */
1057 if (notcurrent
) pc
-= 1;
1059 s
= find_pc_symtab (pc
);
1069 bv
= BLOCKVECTOR (s
);
1071 /* Look at all the symtabs that share this blockvector.
1072 They all have the same apriori range, that we found was right;
1073 but they have different line tables. */
1075 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1077 /* Find the best line in this symtab. */
1084 /* I think len can be zero if the symtab lacks line numbers
1085 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1086 I'm not sure which, and maybe it depends on the symbol
1092 item
= l
->item
; /* Get first line info */
1094 /* Is this file's first line closer than the first lines of other files?
1095 If so, record this file, and its first line, as best alternate. */
1096 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1102 for (i
= 0; i
< len
; i
++, item
++)
1104 /* Return the last line that did not start after PC. */
1111 /* At this point, prev points at the line whose start addr is <= pc, and
1112 item points at the next line. If we ran off the end of the linetable
1113 (pc >= start of the last line), then prev == item. If pc < start of
1114 the first line, prev will not be set. */
1116 /* Is this file's best line closer than the best in the other files?
1117 If so, record this file, and its best line, as best so far. */
1119 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1123 /* If another line is in the linetable, and its PC is closer
1124 than the best_end we currently have, take it as best_end. */
1125 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1126 best_end
= item
->pc
;
1133 { /* If we didn't find any line # info, just
1142 val
.symtab
= alt_symtab
;
1143 val
.line
= alt
->line
- 1;
1144 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1150 val
.symtab
= best_symtab
;
1151 val
.line
= best
->line
;
1153 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1158 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1163 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1166 /* Find line number LINE in any symtab whose name is the same as
1169 If found, return 1, set *LINETABLE to the linetable in which it was
1170 found, set *INDEX to the index in the linetable of the best entry
1171 found, and set *EXACT_MATCH nonzero if the value returned is an
1174 If not found, return 0. */
1177 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1178 struct symtab
*symtab
;
1180 struct linetable
**linetable
;
1186 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1190 struct linetable
*best_linetable
;
1192 /* First try looking it up in the given symtab. */
1193 best_linetable
= LINETABLE (symtab
);
1194 best_index
= find_line_common (best_linetable
, line
, &exact
);
1195 if (best_index
< 0 || !exact
)
1197 /* Didn't find an exact match. So we better keep looking for
1198 another symtab with the same name. In the case of xcoff,
1199 multiple csects for one source file (produced by IBM's FORTRAN
1200 compiler) produce multiple symtabs (this is unavoidable
1201 assuming csects can be at arbitrary places in memory and that
1202 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1204 /* BEST is the smallest linenumber > LINE so far seen,
1205 or 0 if none has been seen so far.
1206 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1209 struct objfile
*objfile
;
1212 if (best_index
>= 0)
1213 best
= best_linetable
->item
[best_index
].line
;
1217 ALL_SYMTABS (objfile
, s
)
1219 struct linetable
*l
;
1222 if (!STREQ (symtab
->filename
, s
->filename
))
1225 ind
= find_line_common (l
, line
, &exact
);
1234 if (best
== 0 || l
->item
[ind
].line
< best
)
1236 best
= l
->item
[ind
].line
;
1248 *index
= best_index
;
1250 *linetable
= best_linetable
;
1252 *exact_match
= exact
;
1256 /* Find the PC value for a given source file and line number.
1257 Returns zero for invalid line number.
1258 The source file is specified with a struct symtab. */
1261 find_line_pc (symtab
, line
)
1262 struct symtab
*symtab
;
1265 struct linetable
*l
;
1270 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1271 return l
->item
[ind
].pc
;
1276 /* Find the range of pc values in a line.
1277 Store the starting pc of the line into *STARTPTR
1278 and the ending pc (start of next line) into *ENDPTR.
1279 Returns 1 to indicate success.
1280 Returns 0 if could not find the specified line. */
1283 find_line_pc_range (sal
, startptr
, endptr
)
1284 struct symtab_and_line sal
;
1285 CORE_ADDR
*startptr
, *endptr
;
1287 struct linetable
*l
;
1289 int exact_match
; /* did we get an exact linenumber match */
1290 CORE_ADDR startaddr
;
1291 struct symtab_and_line found_sal
;
1296 startaddr
= find_line_pc (sal
.symtab
, sal
.line
);
1301 /* This whole function is based on address. For example, if line 10 has
1302 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1303 "info line *0x123" should say the line goes from 0x100 to 0x200
1304 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1305 This also insures that we never give a range like "starts at 0x134
1306 and ends at 0x12c". */
1308 found_sal
= find_pc_line (startaddr
, 0);
1309 if (found_sal
.line
!= sal
.line
)
1311 /* The specified line (sal) has zero bytes. */
1312 *startptr
= found_sal
.pc
;
1313 *endptr
= found_sal
.pc
;
1317 *startptr
= found_sal
.pc
;
1318 *endptr
= found_sal
.end
;
1323 /* Given a line table and a line number, return the index into the line
1324 table for the pc of the nearest line whose number is >= the specified one.
1325 Return -1 if none is found. The value is >= 0 if it is an index.
1327 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1330 find_line_common (l
, lineno
, exact_match
)
1331 register struct linetable
*l
;
1332 register int lineno
;
1338 /* BEST is the smallest linenumber > LINENO so far seen,
1339 or 0 if none has been seen so far.
1340 BEST_INDEX identifies the item for it. */
1342 int best_index
= -1;
1351 for (i
= 0; i
< len
; i
++)
1353 register struct linetable_entry
*item
= &(l
->item
[i
]);
1355 if (item
->line
== lineno
)
1357 /* Return the first (lowest address) entry which matches. */
1362 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1369 /* If we got here, we didn't get an exact match. */
1376 find_pc_line_pc_range (pc
, startptr
, endptr
)
1378 CORE_ADDR
*startptr
, *endptr
;
1380 struct symtab_and_line sal
;
1381 sal
= find_pc_line (pc
, 0);
1384 return sal
.symtab
!= 0;
1387 /* If P is of the form "operator[ \t]+..." where `...' is
1388 some legitimate operator text, return a pointer to the
1389 beginning of the substring of the operator text.
1390 Otherwise, return "". */
1392 operator_chars (p
, end
)
1397 if (strncmp (p
, "operator", 8))
1401 /* Don't get faked out by `operator' being part of a longer
1403 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1406 /* Allow some whitespace between `operator' and the operator symbol. */
1407 while (*p
== ' ' || *p
== '\t')
1410 /* Recognize 'operator TYPENAME'. */
1412 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1414 register char *q
= p
+1;
1415 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1440 if (p
[1] == '=' || p
[1] == p
[0])
1451 error ("`operator ()' must be specified without whitespace in `()'");
1456 error ("`operator ?:' must be specified without whitespace in `?:'");
1461 error ("`operator []' must be specified without whitespace in `[]'");
1465 error ("`operator %s' not supported", p
);
1472 /* Recursive helper function for decode_line_1.
1473 * Look for methods named NAME in type T.
1474 * Return number of matches.
1475 * Put matches in SYM_ARR (which better be big enough!).
1476 * These allocations seem to define "big enough":
1477 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1478 * Note that this function is g++ specific.
1482 find_methods (t
, name
, sym_arr
)
1485 struct symbol
**sym_arr
;
1489 struct symbol
*sym_class
;
1490 char *class_name
= type_name_no_tag (t
);
1491 /* Ignore this class if it doesn't have a name. This is ugly, but
1492 unless we figure out how to get the physname without the name of
1493 the class, then the loop can't do any good. */
1495 && (sym_class
= lookup_symbol (class_name
,
1496 (struct block
*)NULL
,
1499 (struct symtab
**)NULL
)))
1502 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1503 t
= SYMBOL_TYPE (sym_class
);
1504 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1505 method_counter
>= 0;
1509 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1511 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1512 if (STREQ (name
, method_name
))
1513 /* Find all the fields with that name. */
1514 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1519 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1520 check_stub_method (t
, method_counter
, field_counter
);
1521 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1522 /* Destructor is handled by caller, dont add it to the list */
1523 if (DESTRUCTOR_PREFIX_P (phys_name
))
1526 /* FIXME: Why are we looking this up in the
1527 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1528 for nested types? If so, it should probably hook to the
1529 type, not the symbol. mipsread.c is the only symbol
1530 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1531 this is not documented in symtab.h. -26Aug93. */
1533 sym_arr
[i1
] = lookup_symbol (phys_name
,
1534 SYMBOL_BLOCK_VALUE (sym_class
),
1537 (struct symtab
**) NULL
);
1538 if (sym_arr
[i1
]) i1
++;
1541 fputs_filtered("(Cannot find method ", gdb_stdout
);
1542 fprintf_symbol_filtered (gdb_stdout
, phys_name
,
1543 language_cplus
, DMGL_PARAMS
);
1544 fputs_filtered(" - possibly inlined.)\n", gdb_stdout
);
1550 /* Only search baseclasses if there is no match yet, since names in
1551 derived classes override those in baseclasses.
1553 FIXME: The above is not true; it is only true of member functions
1554 if they have the same number of arguments (??? - section 13.1 of the
1555 ARM says the function members are not in the same scope but doesn't
1556 really spell out the rules in a way I understand. In any case, if
1557 the number of arguments differ this is a case in which we can overload
1558 rather than hiding without any problem, and gcc 2.4.5 does overload
1559 rather than hiding in this case). */
1563 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1564 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1569 /* Helper function for decode_line_1.
1570 Build a canonical line spec in CANONICAL if it is non-NULL and if
1571 the SAL has a symtab.
1572 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1573 If SYMNAME is NULL the line number from SAL is used and the canonical
1574 line spec is `filename:linenum'. */
1577 build_canonical_line_spec (sal
, symname
, canonical
)
1578 struct symtab_and_line
*sal
;
1582 char **canonical_arr
;
1583 char *canonical_name
;
1585 struct symtab
*s
= sal
->symtab
;
1587 if (s
== (struct symtab
*)NULL
1588 || s
->filename
== (char *)NULL
1589 || canonical
== (char ***)NULL
)
1592 canonical_arr
= (char **) xmalloc (sizeof (char *));
1593 *canonical
= canonical_arr
;
1595 filename
= s
->filename
;
1596 if (symname
!= NULL
)
1598 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1599 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1603 canonical_name
= xmalloc (strlen (filename
) + 30);
1604 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1606 canonical_arr
[0] = canonical_name
;
1609 /* Parse a string that specifies a line number.
1610 Pass the address of a char * variable; that variable will be
1611 advanced over the characters actually parsed.
1615 LINENUM -- that line number in current file. PC returned is 0.
1616 FILE:LINENUM -- that line in that file. PC returned is 0.
1617 FUNCTION -- line number of openbrace of that function.
1618 PC returned is the start of the function.
1619 VARIABLE -- line number of definition of that variable.
1621 FILE:FUNCTION -- likewise, but prefer functions in that file.
1622 *EXPR -- line in which address EXPR appears.
1624 FUNCTION may be an undebuggable function found in minimal symbol table.
1626 If the argument FUNFIRSTLINE is nonzero, we want the first line
1627 of real code inside a function when a function is specified.
1629 DEFAULT_SYMTAB specifies the file to use if none is specified.
1630 It defaults to current_source_symtab.
1631 DEFAULT_LINE specifies the line number to use for relative
1632 line numbers (that start with signs). Defaults to current_source_line.
1633 If CANONICAL is non-NULL, store an array of strings containing the canonical
1634 line specs there if necessary. Currently overloaded member functions and
1635 line numbers or static functions without a filename yield a canonical
1636 line spec. The array and the line spec strings are allocated on the heap,
1637 it is the callers responsibility to free them.
1639 Note that it is possible to return zero for the symtab
1640 if no file is validly specified. Callers must check that.
1641 Also, the line number returned may be invalid. */
1643 struct symtabs_and_lines
1644 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1647 struct symtab
*default_symtab
;
1651 struct symtabs_and_lines values
;
1652 #ifdef HPPA_COMPILER_BUG
1653 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1654 when optimizing this file with target i960-vxworks. I haven't
1655 been able to construct a simple test case. The problem is that
1656 in the second call to SKIP_PROLOGUE below, the compiler somehow
1657 does not realize that the statement val = find_pc_line (...) will
1658 change the values of the fields of val. It extracts the elements
1659 into registers at the top of the block, and does not update the
1660 registers after the call to find_pc_line. You can check this by
1661 inserting a printf at the end of find_pc_line to show what values
1662 it is returning for val.pc and val.end and another printf after
1663 the call to see what values the function actually got (remember,
1664 this is compiling with cc -O, with this patch removed). You can
1665 also examine the assembly listing: search for the second call to
1666 skip_prologue; the LDO statement before the next call to
1667 find_pc_line loads the address of the structure which
1668 find_pc_line will return; if there is a LDW just before the LDO,
1669 which fetches an element of the structure, then the compiler
1672 Setting val to volatile avoids the problem. We must undef
1673 volatile, because the HPPA native compiler does not define
1674 __STDC__, although it does understand volatile, and so volatile
1675 will have been defined away in defs.h. */
1677 volatile struct symtab_and_line val
;
1678 #define volatile /*nothing*/
1680 struct symtab_and_line val
;
1682 register char *p
, *p1
;
1684 register struct symtab
*s
;
1686 register struct symbol
*sym
;
1687 /* The symtab that SYM was found in. */
1688 struct symtab
*sym_symtab
;
1690 register CORE_ADDR pc
;
1691 register struct minimal_symbol
*msymbol
;
1693 struct symbol
*sym_class
;
1696 struct symbol
**sym_arr
;
1698 char *saved_arg
= *argptr
;
1699 extern char *gdb_completer_quote_characters
;
1701 /* Defaults have defaults. */
1703 if (default_symtab
== 0)
1705 default_symtab
= current_source_symtab
;
1706 default_line
= current_source_line
;
1709 /* See if arg is *PC */
1711 if (**argptr
== '*')
1713 if (**argptr
== '*')
1717 pc
= parse_and_eval_address_1 (argptr
);
1718 values
.sals
= (struct symtab_and_line
*)
1719 xmalloc (sizeof (struct symtab_and_line
));
1721 values
.sals
[0] = find_pc_line (pc
, 0);
1722 values
.sals
[0].pc
= pc
;
1723 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1727 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1730 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1732 for (p
= *argptr
; *p
; p
++)
1734 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1737 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1739 if ((p
[0] == ':') && !is_quoted
)
1745 /* Extract the class name. */
1747 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1748 copy
= (char *) alloca (p
- *argptr
+ 1);
1749 memcpy (copy
, *argptr
, p
- *argptr
);
1750 copy
[p
- *argptr
] = 0;
1752 /* Discard the class name from the arg. */
1754 while (*p
== ' ' || *p
== '\t') p
++;
1757 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1758 (struct symtab
**)NULL
);
1761 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1762 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1764 /* Arg token is not digits => try it as a function name
1765 Find the next token (everything up to end or next whitespace). */
1767 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1768 q
= operator_chars (*argptr
, &q1
);
1773 char *tmp
= alloca (q1
- q
+ 1);
1774 memcpy (tmp
, q
, q1
- q
);
1776 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1779 warning ("no mangling for \"%s\"", tmp
);
1780 cplusplus_hint (saved_arg
);
1781 return_to_top_level (RETURN_ERROR
);
1783 copy
= (char*) alloca (3 + strlen(opname
));
1784 sprintf (copy
, "__%s", opname
);
1789 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1790 memcpy (copy
, *argptr
, p
- *argptr
);
1791 copy
[p
- *argptr
] = '\0';
1794 /* no line number may be specified */
1795 while (*p
== ' ' || *p
== '\t') p
++;
1799 i1
= 0; /* counter for the symbol array */
1800 t
= SYMBOL_TYPE (sym_class
);
1801 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1803 /* Cfront objects don't have fieldlists. */
1804 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1806 /* destructors are a special case. */
1807 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1808 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1809 /* gcc 1.x puts destructor in last field,
1810 gcc 2.x puts destructor in first field. */
1811 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1812 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1814 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1815 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1819 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1820 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1821 if (sym_arr
[i1
]) i1
++;
1824 i1
= find_methods (t
, copy
, sym_arr
);
1827 /* There is exactly one field with that name. */
1830 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1832 /* Arg is the name of a function */
1833 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1836 pc
+= FUNCTION_START_OFFSET
;
1839 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1841 values
.sals
[0] = find_pc_line (pc
, 0);
1842 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1852 /* There is more than one field with that name
1853 (overloaded). Ask the user which one to use. */
1854 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1860 if (OPNAME_PREFIX_P (copy
))
1862 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1863 strcpy (tmp
, "operator ");
1864 strcat (tmp
, copy
+3);
1869 warning ("the class `%s' does not have destructor defined",
1870 SYMBOL_SOURCE_NAME(sym_class
));
1872 warning ("the class %s does not have any method named %s",
1873 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1874 cplusplus_hint (saved_arg
);
1875 return_to_top_level (RETURN_ERROR
);
1880 /* The quotes are important if copy is empty. */
1881 warning ("can't find class, struct, or union named \"%s\"",
1883 cplusplus_hint (saved_arg
);
1884 return_to_top_level (RETURN_ERROR
);
1890 /* Extract the file name. */
1892 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1893 copy
= (char *) alloca (p
- *argptr
+ 1);
1894 memcpy (copy
, *argptr
, p
- *argptr
);
1895 copy
[p
- *argptr
] = 0;
1897 /* Find that file's data. */
1898 s
= lookup_symtab (copy
);
1901 if (!have_full_symbols () && !have_partial_symbols ())
1902 error (no_symtab_msg
);
1903 error ("No source file named %s.", copy
);
1906 /* Discard the file name from the arg. */
1908 while (*p
== ' ' || *p
== '\t') p
++;
1912 /* S is specified file's symtab, or 0 if no file specified.
1913 arg no longer contains the file name. */
1915 /* Check whether arg is all digits (and sign) */
1918 if (*p
== '-' || *p
== '+') p
++;
1919 while (*p
>= '0' && *p
<= '9')
1922 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1924 /* We found a token consisting of all digits -- at least one digit. */
1925 enum sign
{none
, plus
, minus
} sign
= none
;
1927 /* We might need a canonical line spec if no file was specified. */
1928 int need_canonical
= (s
== 0) ? 1 : 0;
1930 /* This is where we need to make sure that we have good defaults.
1931 We must guarantee that this section of code is never executed
1932 when we are called with just a function name, since
1933 select_source_symtab calls us with such an argument */
1935 if (s
== 0 && default_symtab
== 0)
1937 select_source_symtab (0);
1938 default_symtab
= current_source_symtab
;
1939 default_line
= current_source_line
;
1942 if (**argptr
== '+')
1943 sign
= plus
, (*argptr
)++;
1944 else if (**argptr
== '-')
1945 sign
= minus
, (*argptr
)++;
1946 val
.line
= atoi (*argptr
);
1953 val
.line
= default_line
+ val
.line
;
1959 val
.line
= default_line
- val
.line
;
1964 break; /* No need to adjust val.line. */
1967 while (*p
== ' ' || *p
== '\t') p
++;
1973 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1974 values
.sals
[0] = val
;
1977 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1981 /* Arg token is not digits => try it as a variable name
1982 Find the next token (everything up to end or next whitespace). */
1984 p
= skip_quoted (*argptr
);
1985 if (is_quoted
&& p
[-1] != '\'')
1986 error ("Unmatched single quote.");
1987 copy
= (char *) alloca (p
- *argptr
+ 1);
1988 memcpy (copy
, *argptr
, p
- *argptr
);
1989 copy
[p
- *argptr
] = '\0';
1990 if ((copy
[0] == copy
[p
- *argptr
- 1])
1991 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1993 copy
[p
- *argptr
- 1] = '\0';
1996 while (*p
== ' ' || *p
== '\t') p
++;
1999 /* Look up that token as a variable.
2000 If file specified, use that file's per-file block to start with. */
2002 sym
= lookup_symbol (copy
,
2003 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2004 : get_selected_block ()),
2005 VAR_NAMESPACE
, 0, &sym_symtab
);
2009 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2011 /* Arg is the name of a function */
2012 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2015 pc
+= FUNCTION_START_OFFSET
;
2018 val
= find_pc_line (pc
, 0);
2019 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2020 /* Convex: no need to suppress code on first line, if any */
2023 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2024 line is still part of the same function. */
2026 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
2027 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2029 /* First pc of next line */
2031 /* Recalculate the line number (might not be N+1). */
2032 val
= find_pc_line (pc
, 0);
2036 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2037 values
.sals
[0] = val
;
2040 /* Don't use the SYMBOL_LINE; if used at all it points to
2041 the line containing the parameters or thereabouts, not
2042 the first line of code. */
2044 /* We might need a canonical line spec if it is a static
2048 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2049 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2050 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2051 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2055 else if (SYMBOL_LINE (sym
) != 0)
2057 /* We know its line number. */
2058 values
.sals
= (struct symtab_and_line
*)
2059 xmalloc (sizeof (struct symtab_and_line
));
2061 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2062 values
.sals
[0].symtab
= sym_symtab
;
2063 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2067 /* This can happen if it is compiled with a compiler which doesn't
2068 put out line numbers for variables. */
2069 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2070 return? For example, "info line foo" could print the address. */
2071 error ("Line number not known for symbol \"%s\"", copy
);
2074 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2075 if (msymbol
!= NULL
)
2079 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2082 val
.pc
+= FUNCTION_START_OFFSET
;
2083 SKIP_PROLOGUE (val
.pc
);
2085 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2086 values
.sals
[0] = val
;
2091 if (!have_full_symbols () &&
2092 !have_partial_symbols () && !have_minimal_symbols ())
2093 error (no_symtab_msg
);
2095 error ("Function \"%s\" not defined.", copy
);
2096 return values
; /* for lint */
2099 struct symtabs_and_lines
2100 decode_line_spec (string
, funfirstline
)
2104 struct symtabs_and_lines sals
;
2106 error ("Empty line specification.");
2107 sals
= decode_line_1 (&string
, funfirstline
,
2108 current_source_symtab
, current_source_line
,
2111 error ("Junk at end of line specification: %s", string
);
2115 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2116 operate on (ask user if necessary).
2117 If CANONICAL is non-NULL return a corresponding array of mangled names
2118 as canonical line specs there. */
2120 static struct symtabs_and_lines
2121 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2122 struct symbol
*sym_arr
[];
2127 struct symtabs_and_lines values
, return_values
;
2128 register CORE_ADDR pc
;
2133 struct cleanup
*old_chain
;
2134 char **canonical_arr
= (char **)NULL
;
2136 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2137 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2138 old_chain
= make_cleanup (free
, return_values
.sals
);
2142 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2143 make_cleanup (free
, canonical_arr
);
2144 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2145 *canonical
= canonical_arr
;
2149 printf_unfiltered("[0] cancel\n[1] all\n");
2152 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2154 /* Arg is the name of a function */
2155 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]));
2158 pc
+= FUNCTION_START_OFFSET
;
2161 values
.sals
[i
] = find_pc_line (pc
, 0);
2162 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2163 values
.sals
[i
].end
: pc
;
2164 printf_unfiltered("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2165 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2167 else printf_unfiltered ("?HERE\n");
2171 if ((prompt
= getenv ("PS2")) == NULL
)
2175 printf_unfiltered("%s ",prompt
);
2176 gdb_flush(gdb_stdout
);
2178 args
= command_line_input ((char *) NULL
, 0);
2180 if (args
== 0 || *args
== 0)
2181 error_no_arg ("one or more choice numbers");
2189 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2190 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2191 error ("Arguments must be choice numbers.");
2196 error ("cancelled");
2201 for (i
= 0; i
< nelts
; i
++)
2203 if (canonical_arr
[i
] == NULL
)
2205 symname
= SYMBOL_NAME (sym_arr
[i
]);
2206 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2210 memcpy (return_values
.sals
, values
.sals
,
2211 (nelts
* sizeof(struct symtab_and_line
)));
2212 return_values
.nelts
= nelts
;
2213 discard_cleanups (old_chain
);
2214 return return_values
;
2217 if (num
> nelts
+ 2)
2219 printf_unfiltered ("No choice number %d.\n", num
);
2224 if (values
.sals
[num
].pc
)
2228 symname
= SYMBOL_NAME (sym_arr
[num
]);
2229 make_cleanup (free
, symname
);
2230 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2232 return_values
.sals
[i
++] = values
.sals
[num
];
2233 values
.sals
[num
].pc
= 0;
2237 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2242 while (*args
== ' ' || *args
== '\t') args
++;
2244 return_values
.nelts
= i
;
2245 discard_cleanups (old_chain
);
2246 return return_values
;
2250 /* Slave routine for sources_info. Force line breaks at ,'s.
2251 NAME is the name to print and *FIRST is nonzero if this is the first
2252 name printed. Set *FIRST to zero. */
2254 output_source_filename (name
, first
)
2258 /* Table of files printed so far. Since a single source file can
2259 result in several partial symbol tables, we need to avoid printing
2260 it more than once. Note: if some of the psymtabs are read in and
2261 some are not, it gets printed both under "Source files for which
2262 symbols have been read" and "Source files for which symbols will
2263 be read in on demand". I consider this a reasonable way to deal
2264 with the situation. I'm not sure whether this can also happen for
2265 symtabs; it doesn't hurt to check. */
2266 static char **tab
= NULL
;
2267 /* Allocated size of tab in elements.
2268 Start with one 256-byte block (when using GNU malloc.c).
2269 24 is the malloc overhead when range checking is in effect. */
2270 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2271 /* Current size of tab in elements. */
2272 static int tab_cur_size
;
2279 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2283 /* Is NAME in tab? */
2284 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2285 if (STREQ (*p
, name
))
2286 /* Yes; don't print it again. */
2288 /* No; add it to tab. */
2289 if (tab_cur_size
== tab_alloc_size
)
2291 tab_alloc_size
*= 2;
2292 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2294 tab
[tab_cur_size
++] = name
;
2302 printf_filtered (", ");
2306 fputs_filtered (name
, gdb_stdout
);
2310 sources_info (ignore
, from_tty
)
2314 register struct symtab
*s
;
2315 register struct partial_symtab
*ps
;
2316 register struct objfile
*objfile
;
2319 if (!have_full_symbols () && !have_partial_symbols ())
2321 error (no_symtab_msg
);
2324 printf_filtered ("Source files for which symbols have been read in:\n\n");
2327 ALL_SYMTABS (objfile
, s
)
2329 output_source_filename (s
-> filename
, &first
);
2331 printf_filtered ("\n\n");
2333 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2336 ALL_PSYMTABS (objfile
, ps
)
2340 output_source_filename (ps
-> filename
, &first
);
2343 printf_filtered ("\n");
2346 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2347 If CLASS is zero, list all symbols except functions, type names, and
2349 If CLASS is 1, list only functions.
2350 If CLASS is 2, list only type names.
2351 If CLASS is 3, list only method names.
2353 BPT is non-zero if we should set a breakpoint at the functions
2357 list_symbols (regexp
, class, bpt
)
2362 register struct symtab
*s
;
2363 register struct partial_symtab
*ps
;
2364 register struct blockvector
*bv
;
2365 struct blockvector
*prev_bv
= 0;
2366 register struct block
*b
;
2368 register struct symbol
*sym
;
2369 struct partial_symbol
*psym
;
2370 struct objfile
*objfile
;
2371 struct minimal_symbol
*msymbol
;
2373 static char *classnames
[]
2374 = {"variable", "function", "type", "method"};
2375 int found_in_file
= 0;
2377 static enum minimal_symbol_type types
[]
2378 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2379 static enum minimal_symbol_type types2
[]
2380 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2381 enum minimal_symbol_type ourtype
= types
[class];
2382 enum minimal_symbol_type ourtype2
= types2
[class];
2386 /* Make sure spacing is right for C++ operators.
2387 This is just a courtesy to make the matching less sensitive
2388 to how many spaces the user leaves between 'operator'
2389 and <TYPENAME> or <OPERATOR>. */
2391 char *opname
= operator_chars (regexp
, &opend
);
2394 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2395 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2397 /* There should 1 space between 'operator' and 'TYPENAME'. */
2398 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2403 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2404 if (opname
[-1] == ' ')
2407 /* If wrong number of spaces, fix it. */
2410 char *tmp
= (char*) alloca(opend
-opname
+10);
2411 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2416 if (0 != (val
= re_comp (regexp
)))
2417 error ("Invalid regexp (%s): %s", val
, regexp
);
2420 /* Search through the partial symtabs *first* for all symbols
2421 matching the regexp. That way we don't have to reproduce all of
2422 the machinery below. */
2424 ALL_PSYMTABS (objfile
, ps
)
2426 struct partial_symbol
*bound
, *gbound
, *sbound
;
2429 if (ps
->readin
) continue;
2431 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2432 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2435 /* Go through all of the symbols stored in a partial
2436 symtab in one loop. */
2437 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2442 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2444 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2455 /* If it would match (logic taken from loop below)
2456 load the file and go on to the next one */
2457 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2458 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2459 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2460 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2461 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2462 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2464 PSYMTAB_TO_SYMTAB(ps
);
2472 /* Here, we search through the minimal symbol tables for functions that
2473 match, and call find_pc_symtab on them to force their symbols to
2474 be read. The symbol will then be found during the scan of symtabs
2475 below. If find_pc_symtab fails, set found_misc so that we will
2476 rescan to print any matching symbols without debug info. */
2480 ALL_MSYMBOLS (objfile
, msymbol
)
2482 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2483 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2485 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2487 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2496 /* Printout here so as to get after the "Reading in symbols"
2497 messages which will be generated above. */
2499 printf_filtered (regexp
2500 ? "All %ss matching regular expression \"%s\":\n"
2501 : "All defined %ss:\n",
2505 ALL_SYMTABS (objfile
, s
)
2508 bv
= BLOCKVECTOR (s
);
2509 /* Often many files share a blockvector.
2510 Scan each blockvector only once so that
2511 we don't get every symbol many times.
2512 It happens that the first symtab in the list
2513 for any given blockvector is the main file. */
2515 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2517 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2518 /* Skip the sort if this block is always sorted. */
2519 if (!BLOCK_SHOULD_SORT (b
))
2520 sort_block_syms (b
);
2521 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2524 sym
= BLOCK_SYM (b
, j
);
2525 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2526 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2527 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2528 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2529 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2530 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2531 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2535 /* Set a breakpoint here, if it's a function */
2538 /* There may be more than one function with the
2539 same name but in different files. In order to
2540 set breakpoints on all of them, we must give
2541 both the file name and the function name to
2544 (char *) alloca (strlen (s
->filename
)
2545 + strlen (SYMBOL_NAME(sym
))
2547 strcpy (string
, s
->filename
);
2548 strcat (string
, ":");
2549 strcat (string
, SYMBOL_NAME(sym
));
2550 break_command (string
, 0);
2553 else if (!found_in_file
)
2555 fputs_filtered ("\nFile ", gdb_stdout
);
2556 fputs_filtered (s
->filename
, gdb_stdout
);
2557 fputs_filtered (":\n", gdb_stdout
);
2561 if (class != 2 && i
== STATIC_BLOCK
)
2562 printf_filtered ("static ");
2564 /* Typedef that is not a C++ class */
2566 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2567 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2568 /* variable, func, or typedef-that-is-c++-class */
2569 else if (class < 2 ||
2571 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2573 type_print (SYMBOL_TYPE (sym
),
2574 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2575 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2578 printf_filtered (";\n");
2582 # if 0 /* FIXME, why is this zapped out? */
2584 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2586 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2588 sprintf (buf
, " %s::", type_name_no_tag (t
));
2589 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2590 buf
, name
, gdb_stdout
);
2599 /* If there are no eyes, avoid all contact. I mean, if there are
2600 no debug symbols, then print directly from the msymbol_vector. */
2602 if (found_misc
|| class != 1)
2605 ALL_MSYMBOLS (objfile
, msymbol
)
2607 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2608 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2610 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2612 /* Functions: Look up by address. */
2614 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2616 /* Variables/Absolutes: Look up by name */
2617 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2618 (struct block
*) NULL
, VAR_NAMESPACE
,
2619 0, (struct symtab
**) NULL
) == NULL
)
2623 printf_filtered ("\nNon-debugging symbols:\n");
2626 printf_filtered (" %08lx %s\n",
2627 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
2628 SYMBOL_SOURCE_NAME (msymbol
));
2638 variables_info (regexp
, from_tty
)
2642 list_symbols (regexp
, 0, 0);
2646 functions_info (regexp
, from_tty
)
2650 list_symbols (regexp
, 1, 0);
2654 types_info (regexp
, from_tty
)
2658 list_symbols (regexp
, 2, 0);
2662 /* Tiemann says: "info methods was never implemented." */
2664 methods_info (regexp
)
2667 list_symbols (regexp
, 3, 0);
2671 /* Breakpoint all functions matching regular expression. */
2673 rbreak_command (regexp
, from_tty
)
2677 list_symbols (regexp
, 1, 1);
2681 /* Return Nonzero if block a is lexically nested within block b,
2682 or if a and b have the same pc range.
2683 Return zero otherwise. */
2686 struct block
*a
, *b
;
2690 return BLOCK_START (a
) >= BLOCK_START (b
)
2691 && BLOCK_END (a
) <= BLOCK_END (b
);
2695 /* Helper routine for make_symbol_completion_list. */
2697 static int return_val_size
;
2698 static int return_val_index
;
2699 static char **return_val
;
2701 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2703 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2704 /* Put only the mangled name on the list. */ \
2705 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2706 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2707 completion_list_add_name \
2708 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2710 completion_list_add_name \
2711 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2714 /* Test to see if the symbol specified by SYMNAME (which is already
2715 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2716 characters. If so, add it to the current completion list. */
2719 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2729 /* clip symbols that cannot match */
2731 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2736 /* Clip any symbol names that we've already considered. (This is a
2737 time optimization) */
2739 for (i
= 0; i
< return_val_index
; ++i
)
2741 if (STREQ (symname
, return_val
[i
]))
2747 /* We have a match for a completion, so add SYMNAME to the current list
2748 of matches. Note that the name is moved to freshly malloc'd space. */
2752 if (word
== sym_text
)
2754 new = xmalloc (strlen (symname
) + 5);
2755 strcpy (new, symname
);
2757 else if (word
> sym_text
)
2759 /* Return some portion of symname. */
2760 new = xmalloc (strlen (symname
) + 5);
2761 strcpy (new, symname
+ (word
- sym_text
));
2765 /* Return some of SYM_TEXT plus symname. */
2766 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2767 strncpy (new, word
, sym_text
- word
);
2768 new[sym_text
- word
] = '\0';
2769 strcat (new, symname
);
2772 if (return_val_index
+ 3 > return_val_size
)
2774 newsize
= (return_val_size
*= 2) * sizeof (char *);
2775 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2777 return_val
[return_val_index
++] = new;
2778 return_val
[return_val_index
] = NULL
;
2782 /* Return a NULL terminated array of all symbols (regardless of class) which
2783 begin by matching TEXT. If the answer is no symbols, then the return value
2784 is an array which contains only a NULL pointer.
2786 Problem: All of the symbols have to be copied because readline frees them.
2787 I'm not going to worry about this; hopefully there won't be that many. */
2790 make_symbol_completion_list (text
, word
)
2794 register struct symbol
*sym
;
2795 register struct symtab
*s
;
2796 register struct partial_symtab
*ps
;
2797 register struct minimal_symbol
*msymbol
;
2798 register struct objfile
*objfile
;
2799 register struct block
*b
, *surrounding_static_block
= 0;
2801 struct partial_symbol
*psym
;
2802 /* The symbol we are completing on. Points in same buffer as text. */
2804 /* Length of sym_text. */
2807 /* Now look for the symbol we are supposed to complete on.
2808 FIXME: This should be language-specific. */
2812 char *quote_pos
= NULL
;
2814 /* First see if this is a quoted string. */
2816 for (p
= text
; *p
!= '\0'; ++p
)
2818 if (quote_found
!= '\0')
2820 if (*p
== quote_found
)
2821 /* Found close quote. */
2823 else if (*p
== '\\' && p
[1] == quote_found
)
2824 /* A backslash followed by the quote character
2825 doesn't end the string. */
2828 else if (*p
== '\'' || *p
== '"')
2834 if (quote_found
== '\'')
2835 /* A string within single quotes can be a symbol, so complete on it. */
2836 sym_text
= quote_pos
+ 1;
2837 else if (quote_found
== '"')
2838 /* A double-quoted string is never a symbol, nor does it make sense
2839 to complete it any other way. */
2843 /* It is not a quoted string. Break it based on the characters
2844 which are in symbols. */
2847 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2856 sym_text_len
= strlen (sym_text
);
2858 return_val_size
= 100;
2859 return_val_index
= 0;
2860 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2861 return_val
[0] = NULL
;
2863 /* Look through the partial symtabs for all symbols which begin
2864 by matching SYM_TEXT. Add each one that you find to the list. */
2866 ALL_PSYMTABS (objfile
, ps
)
2868 /* If the psymtab's been read in we'll get it when we search
2869 through the blockvector. */
2870 if (ps
->readin
) continue;
2872 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2873 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2874 + ps
->n_global_syms
);
2877 /* If interrupted, then quit. */
2879 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2882 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2883 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2884 + ps
->n_static_syms
);
2888 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2892 /* At this point scan through the misc symbol vectors and add each
2893 symbol you find to the list. Eventually we want to ignore
2894 anything that isn't a text symbol (everything else will be
2895 handled by the psymtab code above). */
2897 ALL_MSYMBOLS (objfile
, msymbol
)
2900 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2903 /* Search upwards from currently selected frame (so that we can
2904 complete on local vars. */
2906 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2908 if (!BLOCK_SUPERBLOCK (b
))
2910 surrounding_static_block
= b
; /* For elmin of dups */
2913 /* Also catch fields of types defined in this places which match our
2914 text string. Only complete on types visible from current context. */
2916 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2918 sym
= BLOCK_SYM (b
, i
);
2919 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2920 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2922 struct type
*t
= SYMBOL_TYPE (sym
);
2923 enum type_code c
= TYPE_CODE (t
);
2925 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2927 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2929 if (TYPE_FIELD_NAME (t
, j
))
2931 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2932 sym_text
, sym_text_len
, text
, word
);
2940 /* Go through the symtabs and check the externs and statics for
2941 symbols which match. */
2943 ALL_SYMTABS (objfile
, s
)
2946 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2947 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2949 sym
= BLOCK_SYM (b
, i
);
2950 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2954 ALL_SYMTABS (objfile
, s
)
2957 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2958 /* Don't do this block twice. */
2959 if (b
== surrounding_static_block
) continue;
2960 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2962 sym
= BLOCK_SYM (b
, i
);
2963 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2967 return (return_val
);
2972 /* Add the type of the symbol sym to the type of the current
2973 function whose block we are in (assumed). The type of
2974 this current function is contained in *TYPE.
2976 This basically works as follows: When we find a function
2977 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2978 a pointer to its type in the global in_function_type. Every
2979 time we come across a parameter symbol ('p' in its name), then
2980 this procedure adds the name and type of that parameter
2981 to the function type pointed to by *TYPE. (Which should correspond
2982 to in_function_type if it was called correctly).
2984 Note that since we are modifying a type, the result of
2985 lookup_function_type() should be memcpy()ed before calling
2986 this. When not in strict typing mode, the expression
2987 evaluator can choose to ignore this.
2989 Assumption: All of a function's parameter symbols will
2990 appear before another function symbol is found. The parameters
2991 appear in the same order in the argument list as they do in the
2995 add_param_to_type (type
,sym
)
2999 int num
= ++(TYPE_NFIELDS(*type
));
3001 if(TYPE_NFIELDS(*type
)-1)
3002 TYPE_FIELDS(*type
) = (struct field
*)
3003 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
3004 num
*sizeof(struct field
));
3006 TYPE_FIELDS(*type
) = (struct field
*)
3007 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
3009 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
3010 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
3011 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
3012 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
3017 _initialize_symtab ()
3019 add_info ("variables", variables_info
,
3020 "All global and static variable names, or those matching REGEXP.");
3021 add_info ("functions", functions_info
,
3022 "All function names, or those matching REGEXP.");
3024 /* FIXME: This command has at least the following problems:
3025 1. It prints builtin types (in a very strange and confusing fashion).
3026 2. It doesn't print right, e.g. with
3027 typedef struct foo *FOO
3028 type_print prints "FOO" when we want to make it (in this situation)
3029 print "struct foo *".
3030 I also think "ptype" or "whatis" is more likely to be useful (but if
3031 there is much disagreement "info types" can be fixed). */
3032 add_info ("types", types_info
,
3033 "All type names, or those matching REGEXP.");
3036 add_info ("methods", methods_info
,
3037 "All method names, or those matching REGEXP::REGEXP.\n\
3038 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3039 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3042 add_info ("sources", sources_info
,
3043 "Source files in the program.");
3045 add_com ("rbreak", no_class
, rbreak_command
,
3046 "Set a breakpoint for all functions matching REGEXP.");
3048 /* Initialize the one built-in type that isn't language dependent... */
3049 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3050 "<unknown type>", (struct objfile
*) NULL
);