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 CORE_ADDR startaddr
;
1288 struct symtab_and_line found_sal
;
1293 startaddr
= find_line_pc (sal
.symtab
, sal
.line
);
1298 /* This whole function is based on address. For example, if line 10 has
1299 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1300 "info line *0x123" should say the line goes from 0x100 to 0x200
1301 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1302 This also insures that we never give a range like "starts at 0x134
1303 and ends at 0x12c". */
1305 found_sal
= find_pc_line (startaddr
, 0);
1306 if (found_sal
.line
!= sal
.line
)
1308 /* The specified line (sal) has zero bytes. */
1309 *startptr
= found_sal
.pc
;
1310 *endptr
= found_sal
.pc
;
1314 *startptr
= found_sal
.pc
;
1315 *endptr
= found_sal
.end
;
1320 /* Given a line table and a line number, return the index into the line
1321 table for the pc of the nearest line whose number is >= the specified one.
1322 Return -1 if none is found. The value is >= 0 if it is an index.
1324 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1327 find_line_common (l
, lineno
, exact_match
)
1328 register struct linetable
*l
;
1329 register int lineno
;
1335 /* BEST is the smallest linenumber > LINENO so far seen,
1336 or 0 if none has been seen so far.
1337 BEST_INDEX identifies the item for it. */
1339 int best_index
= -1;
1348 for (i
= 0; i
< len
; i
++)
1350 register struct linetable_entry
*item
= &(l
->item
[i
]);
1352 if (item
->line
== lineno
)
1354 /* Return the first (lowest address) entry which matches. */
1359 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1366 /* If we got here, we didn't get an exact match. */
1373 find_pc_line_pc_range (pc
, startptr
, endptr
)
1375 CORE_ADDR
*startptr
, *endptr
;
1377 struct symtab_and_line sal
;
1378 sal
= find_pc_line (pc
, 0);
1381 return sal
.symtab
!= 0;
1384 /* If P is of the form "operator[ \t]+..." where `...' is
1385 some legitimate operator text, return a pointer to the
1386 beginning of the substring of the operator text.
1387 Otherwise, return "". */
1389 operator_chars (p
, end
)
1394 if (strncmp (p
, "operator", 8))
1398 /* Don't get faked out by `operator' being part of a longer
1400 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1403 /* Allow some whitespace between `operator' and the operator symbol. */
1404 while (*p
== ' ' || *p
== '\t')
1407 /* Recognize 'operator TYPENAME'. */
1409 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1411 register char *q
= p
+1;
1412 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1437 if (p
[1] == '=' || p
[1] == p
[0])
1448 error ("`operator ()' must be specified without whitespace in `()'");
1453 error ("`operator ?:' must be specified without whitespace in `?:'");
1458 error ("`operator []' must be specified without whitespace in `[]'");
1462 error ("`operator %s' not supported", p
);
1469 /* Recursive helper function for decode_line_1.
1470 * Look for methods named NAME in type T.
1471 * Return number of matches.
1472 * Put matches in SYM_ARR (which better be big enough!).
1473 * These allocations seem to define "big enough":
1474 * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1475 * Note that this function is g++ specific.
1479 find_methods (t
, name
, sym_arr
)
1482 struct symbol
**sym_arr
;
1486 struct symbol
*sym_class
;
1487 char *class_name
= type_name_no_tag (t
);
1488 /* Ignore this class if it doesn't have a name. This is ugly, but
1489 unless we figure out how to get the physname without the name of
1490 the class, then the loop can't do any good. */
1492 && (sym_class
= lookup_symbol (class_name
,
1493 (struct block
*)NULL
,
1496 (struct symtab
**)NULL
)))
1499 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1500 t
= SYMBOL_TYPE (sym_class
);
1501 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1502 method_counter
>= 0;
1506 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1508 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1509 if (STREQ (name
, method_name
))
1510 /* Find all the fields with that name. */
1511 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1516 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1517 check_stub_method (t
, method_counter
, field_counter
);
1518 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1519 /* Destructor is handled by caller, dont add it to the list */
1520 if (DESTRUCTOR_PREFIX_P (phys_name
))
1523 /* FIXME: Why are we looking this up in the
1524 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1525 for nested types? If so, it should probably hook to the
1526 type, not the symbol. mipsread.c is the only symbol
1527 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1528 this is not documented in symtab.h. -26Aug93. */
1530 sym_arr
[i1
] = lookup_symbol (phys_name
,
1531 SYMBOL_BLOCK_VALUE (sym_class
),
1534 (struct symtab
**) NULL
);
1535 if (sym_arr
[i1
]) i1
++;
1538 fputs_filtered("(Cannot find method ", gdb_stdout
);
1539 fprintf_symbol_filtered (gdb_stdout
, phys_name
,
1540 language_cplus
, DMGL_PARAMS
);
1541 fputs_filtered(" - possibly inlined.)\n", gdb_stdout
);
1547 /* Only search baseclasses if there is no match yet, since names in
1548 derived classes override those in baseclasses.
1550 FIXME: The above is not true; it is only true of member functions
1551 if they have the same number of arguments (??? - section 13.1 of the
1552 ARM says the function members are not in the same scope but doesn't
1553 really spell out the rules in a way I understand. In any case, if
1554 the number of arguments differ this is a case in which we can overload
1555 rather than hiding without any problem, and gcc 2.4.5 does overload
1556 rather than hiding in this case). */
1560 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1561 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1566 /* Helper function for decode_line_1.
1567 Build a canonical line spec in CANONICAL if it is non-NULL and if
1568 the SAL has a symtab.
1569 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1570 If SYMNAME is NULL the line number from SAL is used and the canonical
1571 line spec is `filename:linenum'. */
1574 build_canonical_line_spec (sal
, symname
, canonical
)
1575 struct symtab_and_line
*sal
;
1579 char **canonical_arr
;
1580 char *canonical_name
;
1582 struct symtab
*s
= sal
->symtab
;
1584 if (s
== (struct symtab
*)NULL
1585 || s
->filename
== (char *)NULL
1586 || canonical
== (char ***)NULL
)
1589 canonical_arr
= (char **) xmalloc (sizeof (char *));
1590 *canonical
= canonical_arr
;
1592 filename
= s
->filename
;
1593 if (symname
!= NULL
)
1595 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1596 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1600 canonical_name
= xmalloc (strlen (filename
) + 30);
1601 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1603 canonical_arr
[0] = canonical_name
;
1606 /* Parse a string that specifies a line number.
1607 Pass the address of a char * variable; that variable will be
1608 advanced over the characters actually parsed.
1612 LINENUM -- that line number in current file. PC returned is 0.
1613 FILE:LINENUM -- that line in that file. PC returned is 0.
1614 FUNCTION -- line number of openbrace of that function.
1615 PC returned is the start of the function.
1616 VARIABLE -- line number of definition of that variable.
1618 FILE:FUNCTION -- likewise, but prefer functions in that file.
1619 *EXPR -- line in which address EXPR appears.
1621 FUNCTION may be an undebuggable function found in minimal symbol table.
1623 If the argument FUNFIRSTLINE is nonzero, we want the first line
1624 of real code inside a function when a function is specified.
1626 DEFAULT_SYMTAB specifies the file to use if none is specified.
1627 It defaults to current_source_symtab.
1628 DEFAULT_LINE specifies the line number to use for relative
1629 line numbers (that start with signs). Defaults to current_source_line.
1630 If CANONICAL is non-NULL, store an array of strings containing the canonical
1631 line specs there if necessary. Currently overloaded member functions and
1632 line numbers or static functions without a filename yield a canonical
1633 line spec. The array and the line spec strings are allocated on the heap,
1634 it is the callers responsibility to free them.
1636 Note that it is possible to return zero for the symtab
1637 if no file is validly specified. Callers must check that.
1638 Also, the line number returned may be invalid. */
1640 struct symtabs_and_lines
1641 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1644 struct symtab
*default_symtab
;
1648 struct symtabs_and_lines values
;
1649 #ifdef HPPA_COMPILER_BUG
1650 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1651 when optimizing this file with target i960-vxworks. I haven't
1652 been able to construct a simple test case. The problem is that
1653 in the second call to SKIP_PROLOGUE below, the compiler somehow
1654 does not realize that the statement val = find_pc_line (...) will
1655 change the values of the fields of val. It extracts the elements
1656 into registers at the top of the block, and does not update the
1657 registers after the call to find_pc_line. You can check this by
1658 inserting a printf at the end of find_pc_line to show what values
1659 it is returning for val.pc and val.end and another printf after
1660 the call to see what values the function actually got (remember,
1661 this is compiling with cc -O, with this patch removed). You can
1662 also examine the assembly listing: search for the second call to
1663 skip_prologue; the LDO statement before the next call to
1664 find_pc_line loads the address of the structure which
1665 find_pc_line will return; if there is a LDW just before the LDO,
1666 which fetches an element of the structure, then the compiler
1669 Setting val to volatile avoids the problem. We must undef
1670 volatile, because the HPPA native compiler does not define
1671 __STDC__, although it does understand volatile, and so volatile
1672 will have been defined away in defs.h. */
1674 volatile struct symtab_and_line val
;
1675 #define volatile /*nothing*/
1677 struct symtab_and_line val
;
1679 register char *p
, *p1
;
1681 register struct symtab
*s
;
1683 register struct symbol
*sym
;
1684 /* The symtab that SYM was found in. */
1685 struct symtab
*sym_symtab
;
1687 register CORE_ADDR pc
;
1688 register struct minimal_symbol
*msymbol
;
1690 struct symbol
*sym_class
;
1693 struct symbol
**sym_arr
;
1695 char *saved_arg
= *argptr
;
1696 extern char *gdb_completer_quote_characters
;
1698 /* Defaults have defaults. */
1700 if (default_symtab
== 0)
1702 default_symtab
= current_source_symtab
;
1703 default_line
= current_source_line
;
1706 /* See if arg is *PC */
1708 if (**argptr
== '*')
1710 if (**argptr
== '*')
1714 pc
= parse_and_eval_address_1 (argptr
);
1715 values
.sals
= (struct symtab_and_line
*)
1716 xmalloc (sizeof (struct symtab_and_line
));
1718 values
.sals
[0] = find_pc_line (pc
, 0);
1719 values
.sals
[0].pc
= pc
;
1720 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1724 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1727 is_quoted
= (strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
1729 for (p
= *argptr
; *p
; p
++)
1731 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1734 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1736 if ((p
[0] == ':') && !is_quoted
)
1742 /* Extract the class name. */
1744 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1745 copy
= (char *) alloca (p
- *argptr
+ 1);
1746 memcpy (copy
, *argptr
, p
- *argptr
);
1747 copy
[p
- *argptr
] = 0;
1749 /* Discard the class name from the arg. */
1751 while (*p
== ' ' || *p
== '\t') p
++;
1754 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1755 (struct symtab
**)NULL
);
1758 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1759 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1761 /* Arg token is not digits => try it as a function name
1762 Find the next token (everything up to end or next whitespace). */
1764 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!=':') p
++;
1765 q
= operator_chars (*argptr
, &q1
);
1770 char *tmp
= alloca (q1
- q
+ 1);
1771 memcpy (tmp
, q
, q1
- q
);
1773 opname
= cplus_mangle_opname (tmp
, DMGL_ANSI
);
1776 warning ("no mangling for \"%s\"", tmp
);
1777 cplusplus_hint (saved_arg
);
1778 return_to_top_level (RETURN_ERROR
);
1780 copy
= (char*) alloca (3 + strlen(opname
));
1781 sprintf (copy
, "__%s", opname
);
1786 copy
= (char *) alloca (p
- *argptr
+ 1 + (q1
- q
));
1787 memcpy (copy
, *argptr
, p
- *argptr
);
1788 copy
[p
- *argptr
] = '\0';
1791 /* no line number may be specified */
1792 while (*p
== ' ' || *p
== '\t') p
++;
1796 i1
= 0; /* counter for the symbol array */
1797 t
= SYMBOL_TYPE (sym_class
);
1798 sym_arr
= (struct symbol
**) alloca(TYPE_NFN_FIELDS_TOTAL (t
) * sizeof(struct symbol
*));
1800 /* Cfront objects don't have fieldlists. */
1801 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
1803 /* destructors are a special case. */
1804 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
1805 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
1806 /* gcc 1.x puts destructor in last field,
1807 gcc 2.x puts destructor in first field. */
1808 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
1809 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1811 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
1812 if (!DESTRUCTOR_PREFIX_P (phys_name
))
1816 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
1817 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
1818 if (sym_arr
[i1
]) i1
++;
1821 i1
= find_methods (t
, copy
, sym_arr
);
1824 /* There is exactly one field with that name. */
1827 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1829 /* Arg is the name of a function */
1830 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1833 pc
+= FUNCTION_START_OFFSET
;
1836 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1838 values
.sals
[0] = find_pc_line (pc
, 0);
1839 values
.sals
[0].pc
= (values
.sals
[0].end
&& values
.sals
[0].pc
!= pc
) ? values
.sals
[0].end
: pc
;
1849 /* There is more than one field with that name
1850 (overloaded). Ask the user which one to use. */
1851 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1857 if (OPNAME_PREFIX_P (copy
))
1859 tmp
= (char *)alloca (strlen (copy
+3) + 9);
1860 strcpy (tmp
, "operator ");
1861 strcat (tmp
, copy
+3);
1866 warning ("the class `%s' does not have destructor defined",
1867 SYMBOL_SOURCE_NAME(sym_class
));
1869 warning ("the class %s does not have any method named %s",
1870 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
1871 cplusplus_hint (saved_arg
);
1872 return_to_top_level (RETURN_ERROR
);
1877 /* The quotes are important if copy is empty. */
1878 warning ("can't find class, struct, or union named \"%s\"",
1880 cplusplus_hint (saved_arg
);
1881 return_to_top_level (RETURN_ERROR
);
1887 /* Extract the file name. */
1889 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1890 copy
= (char *) alloca (p
- *argptr
+ 1);
1891 memcpy (copy
, *argptr
, p
- *argptr
);
1892 copy
[p
- *argptr
] = 0;
1894 /* Find that file's data. */
1895 s
= lookup_symtab (copy
);
1898 if (!have_full_symbols () && !have_partial_symbols ())
1899 error (no_symtab_msg
);
1900 error ("No source file named %s.", copy
);
1903 /* Discard the file name from the arg. */
1905 while (*p
== ' ' || *p
== '\t') p
++;
1909 /* S is specified file's symtab, or 0 if no file specified.
1910 arg no longer contains the file name. */
1912 /* Check whether arg is all digits (and sign) */
1915 if (*p
== '-' || *p
== '+') p
++;
1916 while (*p
>= '0' && *p
<= '9')
1919 if (p
!= *argptr
&& (*p
== 0 || *p
== ' ' || *p
== '\t' || *p
== ','))
1921 /* We found a token consisting of all digits -- at least one digit. */
1922 enum sign
{none
, plus
, minus
} sign
= none
;
1924 /* We might need a canonical line spec if no file was specified. */
1925 int need_canonical
= (s
== 0) ? 1 : 0;
1927 /* This is where we need to make sure that we have good defaults.
1928 We must guarantee that this section of code is never executed
1929 when we are called with just a function name, since
1930 select_source_symtab calls us with such an argument */
1932 if (s
== 0 && default_symtab
== 0)
1934 select_source_symtab (0);
1935 default_symtab
= current_source_symtab
;
1936 default_line
= current_source_line
;
1939 if (**argptr
== '+')
1940 sign
= plus
, (*argptr
)++;
1941 else if (**argptr
== '-')
1942 sign
= minus
, (*argptr
)++;
1943 val
.line
= atoi (*argptr
);
1950 val
.line
= default_line
+ val
.line
;
1956 val
.line
= default_line
- val
.line
;
1961 break; /* No need to adjust val.line. */
1964 while (*p
== ' ' || *p
== '\t') p
++;
1970 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
1971 values
.sals
[0] = val
;
1974 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1978 /* Arg token is not digits => try it as a variable name
1979 Find the next token (everything up to end or next whitespace). */
1981 p
= skip_quoted (*argptr
);
1982 if (is_quoted
&& p
[-1] != '\'')
1983 error ("Unmatched single quote.");
1984 copy
= (char *) alloca (p
- *argptr
+ 1);
1985 memcpy (copy
, *argptr
, p
- *argptr
);
1986 copy
[p
- *argptr
] = '\0';
1987 if ((copy
[0] == copy
[p
- *argptr
- 1])
1988 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
1990 copy
[p
- *argptr
- 1] = '\0';
1993 while (*p
== ' ' || *p
== '\t') p
++;
1996 /* Look up that token as a variable.
1997 If file specified, use that file's per-file block to start with. */
1999 sym
= lookup_symbol (copy
,
2000 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2001 : get_selected_block ()),
2002 VAR_NAMESPACE
, 0, &sym_symtab
);
2006 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2008 /* Arg is the name of a function */
2009 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2012 pc
+= FUNCTION_START_OFFSET
;
2015 val
= find_pc_line (pc
, 0);
2016 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2017 /* Convex: no need to suppress code on first line, if any */
2020 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2021 line is still part of the same function. */
2023 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= val
.end
2024 && val
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2026 /* First pc of next line */
2028 /* Recalculate the line number (might not be N+1). */
2029 val
= find_pc_line (pc
, 0);
2033 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2034 values
.sals
[0] = val
;
2037 /* Don't use the SYMBOL_LINE; if used at all it points to
2038 the line containing the parameters or thereabouts, not
2039 the first line of code. */
2041 /* We might need a canonical line spec if it is a static
2045 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2046 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2047 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2048 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2052 else if (SYMBOL_LINE (sym
) != 0)
2054 /* We know its line number. */
2055 values
.sals
= (struct symtab_and_line
*)
2056 xmalloc (sizeof (struct symtab_and_line
));
2058 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2059 values
.sals
[0].symtab
= sym_symtab
;
2060 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2064 /* This can happen if it is compiled with a compiler which doesn't
2065 put out line numbers for variables. */
2066 /* FIXME: Shouldn't we just set .line and .symtab to zero and
2067 return? For example, "info line foo" could print the address. */
2068 error ("Line number not known for symbol \"%s\"", copy
);
2071 msymbol
= lookup_minimal_symbol (copy
, (struct objfile
*) NULL
);
2072 if (msymbol
!= NULL
)
2076 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2079 val
.pc
+= FUNCTION_START_OFFSET
;
2080 SKIP_PROLOGUE (val
.pc
);
2082 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2083 values
.sals
[0] = val
;
2088 if (!have_full_symbols () &&
2089 !have_partial_symbols () && !have_minimal_symbols ())
2090 error (no_symtab_msg
);
2092 error ("Function \"%s\" not defined.", copy
);
2093 return values
; /* for lint */
2096 struct symtabs_and_lines
2097 decode_line_spec (string
, funfirstline
)
2101 struct symtabs_and_lines sals
;
2103 error ("Empty line specification.");
2104 sals
= decode_line_1 (&string
, funfirstline
,
2105 current_source_symtab
, current_source_line
,
2108 error ("Junk at end of line specification: %s", string
);
2112 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2113 operate on (ask user if necessary).
2114 If CANONICAL is non-NULL return a corresponding array of mangled names
2115 as canonical line specs there. */
2117 static struct symtabs_and_lines
2118 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2119 struct symbol
*sym_arr
[];
2124 struct symtabs_and_lines values
, return_values
;
2125 register CORE_ADDR pc
;
2130 struct cleanup
*old_chain
;
2131 char **canonical_arr
= (char **)NULL
;
2133 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2134 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2135 old_chain
= make_cleanup (free
, return_values
.sals
);
2139 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2140 make_cleanup (free
, canonical_arr
);
2141 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2142 *canonical
= canonical_arr
;
2146 printf_unfiltered("[0] cancel\n[1] all\n");
2149 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2151 /* Arg is the name of a function */
2152 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr
[i
]));
2155 pc
+= FUNCTION_START_OFFSET
;
2158 values
.sals
[i
] = find_pc_line (pc
, 0);
2159 values
.sals
[i
].pc
= (values
.sals
[i
].end
&& values
.sals
[i
].pc
!= pc
) ?
2160 values
.sals
[i
].end
: pc
;
2161 printf_unfiltered("[%d] %s at %s:%d\n", (i
+2), SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2162 values
.sals
[i
].symtab
->filename
, values
.sals
[i
].line
);
2164 else printf_unfiltered ("?HERE\n");
2168 if ((prompt
= getenv ("PS2")) == NULL
)
2172 printf_unfiltered("%s ",prompt
);
2173 gdb_flush(gdb_stdout
);
2175 args
= command_line_input ((char *) NULL
, 0);
2177 if (args
== 0 || *args
== 0)
2178 error_no_arg ("one or more choice numbers");
2186 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2187 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2188 error ("Arguments must be choice numbers.");
2193 error ("cancelled");
2198 for (i
= 0; i
< nelts
; i
++)
2200 if (canonical_arr
[i
] == NULL
)
2202 symname
= SYMBOL_NAME (sym_arr
[i
]);
2203 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2207 memcpy (return_values
.sals
, values
.sals
,
2208 (nelts
* sizeof(struct symtab_and_line
)));
2209 return_values
.nelts
= nelts
;
2210 discard_cleanups (old_chain
);
2211 return return_values
;
2214 if (num
> nelts
+ 2)
2216 printf_unfiltered ("No choice number %d.\n", num
);
2221 if (values
.sals
[num
].pc
)
2225 symname
= SYMBOL_NAME (sym_arr
[num
]);
2226 make_cleanup (free
, symname
);
2227 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2229 return_values
.sals
[i
++] = values
.sals
[num
];
2230 values
.sals
[num
].pc
= 0;
2234 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2239 while (*args
== ' ' || *args
== '\t') args
++;
2241 return_values
.nelts
= i
;
2242 discard_cleanups (old_chain
);
2243 return return_values
;
2247 /* Slave routine for sources_info. Force line breaks at ,'s.
2248 NAME is the name to print and *FIRST is nonzero if this is the first
2249 name printed. Set *FIRST to zero. */
2251 output_source_filename (name
, first
)
2255 /* Table of files printed so far. Since a single source file can
2256 result in several partial symbol tables, we need to avoid printing
2257 it more than once. Note: if some of the psymtabs are read in and
2258 some are not, it gets printed both under "Source files for which
2259 symbols have been read" and "Source files for which symbols will
2260 be read in on demand". I consider this a reasonable way to deal
2261 with the situation. I'm not sure whether this can also happen for
2262 symtabs; it doesn't hurt to check. */
2263 static char **tab
= NULL
;
2264 /* Allocated size of tab in elements.
2265 Start with one 256-byte block (when using GNU malloc.c).
2266 24 is the malloc overhead when range checking is in effect. */
2267 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2268 /* Current size of tab in elements. */
2269 static int tab_cur_size
;
2276 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2280 /* Is NAME in tab? */
2281 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2282 if (STREQ (*p
, name
))
2283 /* Yes; don't print it again. */
2285 /* No; add it to tab. */
2286 if (tab_cur_size
== tab_alloc_size
)
2288 tab_alloc_size
*= 2;
2289 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2291 tab
[tab_cur_size
++] = name
;
2299 printf_filtered (", ");
2303 fputs_filtered (name
, gdb_stdout
);
2307 sources_info (ignore
, from_tty
)
2311 register struct symtab
*s
;
2312 register struct partial_symtab
*ps
;
2313 register struct objfile
*objfile
;
2316 if (!have_full_symbols () && !have_partial_symbols ())
2318 error (no_symtab_msg
);
2321 printf_filtered ("Source files for which symbols have been read in:\n\n");
2324 ALL_SYMTABS (objfile
, s
)
2326 output_source_filename (s
-> filename
, &first
);
2328 printf_filtered ("\n\n");
2330 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2333 ALL_PSYMTABS (objfile
, ps
)
2337 output_source_filename (ps
-> filename
, &first
);
2340 printf_filtered ("\n");
2343 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2344 If CLASS is zero, list all symbols except functions, type names, and
2346 If CLASS is 1, list only functions.
2347 If CLASS is 2, list only type names.
2348 If CLASS is 3, list only method names.
2350 BPT is non-zero if we should set a breakpoint at the functions
2354 list_symbols (regexp
, class, bpt
)
2359 register struct symtab
*s
;
2360 register struct partial_symtab
*ps
;
2361 register struct blockvector
*bv
;
2362 struct blockvector
*prev_bv
= 0;
2363 register struct block
*b
;
2365 register struct symbol
*sym
;
2366 struct partial_symbol
*psym
;
2367 struct objfile
*objfile
;
2368 struct minimal_symbol
*msymbol
;
2370 static char *classnames
[]
2371 = {"variable", "function", "type", "method"};
2372 int found_in_file
= 0;
2374 static enum minimal_symbol_type types
[]
2375 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2376 static enum minimal_symbol_type types2
[]
2377 = {mst_bss
, mst_text
, mst_abs
, mst_unknown
};
2378 enum minimal_symbol_type ourtype
= types
[class];
2379 enum minimal_symbol_type ourtype2
= types2
[class];
2383 /* Make sure spacing is right for C++ operators.
2384 This is just a courtesy to make the matching less sensitive
2385 to how many spaces the user leaves between 'operator'
2386 and <TYPENAME> or <OPERATOR>. */
2388 char *opname
= operator_chars (regexp
, &opend
);
2391 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2392 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2394 /* There should 1 space between 'operator' and 'TYPENAME'. */
2395 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2400 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2401 if (opname
[-1] == ' ')
2404 /* If wrong number of spaces, fix it. */
2407 char *tmp
= (char*) alloca(opend
-opname
+10);
2408 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2413 if (0 != (val
= re_comp (regexp
)))
2414 error ("Invalid regexp (%s): %s", val
, regexp
);
2417 /* Search through the partial symtabs *first* for all symbols
2418 matching the regexp. That way we don't have to reproduce all of
2419 the machinery below. */
2421 ALL_PSYMTABS (objfile
, ps
)
2423 struct partial_symbol
*bound
, *gbound
, *sbound
;
2426 if (ps
->readin
) continue;
2428 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2429 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2432 /* Go through all of the symbols stored in a partial
2433 symtab in one loop. */
2434 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2439 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2441 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2452 /* If it would match (logic taken from loop below)
2453 load the file and go on to the next one */
2454 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2455 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2456 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2457 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2458 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2459 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2461 PSYMTAB_TO_SYMTAB(ps
);
2469 /* Here, we search through the minimal symbol tables for functions that
2470 match, and call find_pc_symtab on them to force their symbols to
2471 be read. The symbol will then be found during the scan of symtabs
2472 below. If find_pc_symtab fails, set found_misc so that we will
2473 rescan to print any matching symbols without debug info. */
2477 ALL_MSYMBOLS (objfile
, msymbol
)
2479 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2480 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2482 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2484 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2493 /* Printout here so as to get after the "Reading in symbols"
2494 messages which will be generated above. */
2496 printf_filtered (regexp
2497 ? "All %ss matching regular expression \"%s\":\n"
2498 : "All defined %ss:\n",
2502 ALL_SYMTABS (objfile
, s
)
2505 bv
= BLOCKVECTOR (s
);
2506 /* Often many files share a blockvector.
2507 Scan each blockvector only once so that
2508 we don't get every symbol many times.
2509 It happens that the first symtab in the list
2510 for any given blockvector is the main file. */
2512 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2514 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2515 /* Skip the sort if this block is always sorted. */
2516 if (!BLOCK_SHOULD_SORT (b
))
2517 sort_block_syms (b
);
2518 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2521 sym
= BLOCK_SYM (b
, j
);
2522 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2523 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2524 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2525 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2526 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2527 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2528 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2532 /* Set a breakpoint here, if it's a function */
2535 /* There may be more than one function with the
2536 same name but in different files. In order to
2537 set breakpoints on all of them, we must give
2538 both the file name and the function name to
2541 (char *) alloca (strlen (s
->filename
)
2542 + strlen (SYMBOL_NAME(sym
))
2544 strcpy (string
, s
->filename
);
2545 strcat (string
, ":");
2546 strcat (string
, SYMBOL_NAME(sym
));
2547 break_command (string
, 0);
2550 else if (!found_in_file
)
2552 fputs_filtered ("\nFile ", gdb_stdout
);
2553 fputs_filtered (s
->filename
, gdb_stdout
);
2554 fputs_filtered (":\n", gdb_stdout
);
2558 if (class != 2 && i
== STATIC_BLOCK
)
2559 printf_filtered ("static ");
2561 /* Typedef that is not a C++ class */
2563 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2564 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2565 /* variable, func, or typedef-that-is-c++-class */
2566 else if (class < 2 ||
2568 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2570 type_print (SYMBOL_TYPE (sym
),
2571 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2572 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2575 printf_filtered (";\n");
2579 # if 0 /* FIXME, why is this zapped out? */
2581 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2583 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2585 sprintf (buf
, " %s::", type_name_no_tag (t
));
2586 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2587 buf
, name
, gdb_stdout
);
2596 /* If there are no eyes, avoid all contact. I mean, if there are
2597 no debug symbols, then print directly from the msymbol_vector. */
2599 if (found_misc
|| class != 1)
2602 ALL_MSYMBOLS (objfile
, msymbol
)
2604 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2605 MSYMBOL_TYPE (msymbol
) == ourtype2
)
2607 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2609 /* Functions: Look up by address. */
2611 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2613 /* Variables/Absolutes: Look up by name */
2614 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2615 (struct block
*) NULL
, VAR_NAMESPACE
,
2616 0, (struct symtab
**) NULL
) == NULL
)
2620 printf_filtered ("\nNon-debugging symbols:\n");
2623 printf_filtered (" %08lx %s\n",
2624 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
2625 SYMBOL_SOURCE_NAME (msymbol
));
2635 variables_info (regexp
, from_tty
)
2639 list_symbols (regexp
, 0, 0);
2643 functions_info (regexp
, from_tty
)
2647 list_symbols (regexp
, 1, 0);
2651 types_info (regexp
, from_tty
)
2655 list_symbols (regexp
, 2, 0);
2659 /* Tiemann says: "info methods was never implemented." */
2661 methods_info (regexp
)
2664 list_symbols (regexp
, 3, 0);
2668 /* Breakpoint all functions matching regular expression. */
2670 rbreak_command (regexp
, from_tty
)
2674 list_symbols (regexp
, 1, 1);
2678 /* Return Nonzero if block a is lexically nested within block b,
2679 or if a and b have the same pc range.
2680 Return zero otherwise. */
2683 struct block
*a
, *b
;
2687 return BLOCK_START (a
) >= BLOCK_START (b
)
2688 && BLOCK_END (a
) <= BLOCK_END (b
);
2692 /* Helper routine for make_symbol_completion_list. */
2694 static int return_val_size
;
2695 static int return_val_index
;
2696 static char **return_val
;
2698 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2700 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2701 /* Put only the mangled name on the list. */ \
2702 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2703 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2704 completion_list_add_name \
2705 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2707 completion_list_add_name \
2708 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2711 /* Test to see if the symbol specified by SYMNAME (which is already
2712 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2713 characters. If so, add it to the current completion list. */
2716 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2726 /* clip symbols that cannot match */
2728 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2733 /* Clip any symbol names that we've already considered. (This is a
2734 time optimization) */
2736 for (i
= 0; i
< return_val_index
; ++i
)
2738 if (STREQ (symname
, return_val
[i
]))
2744 /* We have a match for a completion, so add SYMNAME to the current list
2745 of matches. Note that the name is moved to freshly malloc'd space. */
2749 if (word
== sym_text
)
2751 new = xmalloc (strlen (symname
) + 5);
2752 strcpy (new, symname
);
2754 else if (word
> sym_text
)
2756 /* Return some portion of symname. */
2757 new = xmalloc (strlen (symname
) + 5);
2758 strcpy (new, symname
+ (word
- sym_text
));
2762 /* Return some of SYM_TEXT plus symname. */
2763 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
2764 strncpy (new, word
, sym_text
- word
);
2765 new[sym_text
- word
] = '\0';
2766 strcat (new, symname
);
2769 if (return_val_index
+ 3 > return_val_size
)
2771 newsize
= (return_val_size
*= 2) * sizeof (char *);
2772 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
2774 return_val
[return_val_index
++] = new;
2775 return_val
[return_val_index
] = NULL
;
2779 /* Return a NULL terminated array of all symbols (regardless of class) which
2780 begin by matching TEXT. If the answer is no symbols, then the return value
2781 is an array which contains only a NULL pointer.
2783 Problem: All of the symbols have to be copied because readline frees them.
2784 I'm not going to worry about this; hopefully there won't be that many. */
2787 make_symbol_completion_list (text
, word
)
2791 register struct symbol
*sym
;
2792 register struct symtab
*s
;
2793 register struct partial_symtab
*ps
;
2794 register struct minimal_symbol
*msymbol
;
2795 register struct objfile
*objfile
;
2796 register struct block
*b
, *surrounding_static_block
= 0;
2798 struct partial_symbol
*psym
;
2799 /* The symbol we are completing on. Points in same buffer as text. */
2801 /* Length of sym_text. */
2804 /* Now look for the symbol we are supposed to complete on.
2805 FIXME: This should be language-specific. */
2809 char *quote_pos
= NULL
;
2811 /* First see if this is a quoted string. */
2813 for (p
= text
; *p
!= '\0'; ++p
)
2815 if (quote_found
!= '\0')
2817 if (*p
== quote_found
)
2818 /* Found close quote. */
2820 else if (*p
== '\\' && p
[1] == quote_found
)
2821 /* A backslash followed by the quote character
2822 doesn't end the string. */
2825 else if (*p
== '\'' || *p
== '"')
2831 if (quote_found
== '\'')
2832 /* A string within single quotes can be a symbol, so complete on it. */
2833 sym_text
= quote_pos
+ 1;
2834 else if (quote_found
== '"')
2835 /* A double-quoted string is never a symbol, nor does it make sense
2836 to complete it any other way. */
2840 /* It is not a quoted string. Break it based on the characters
2841 which are in symbols. */
2844 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
2853 sym_text_len
= strlen (sym_text
);
2855 return_val_size
= 100;
2856 return_val_index
= 0;
2857 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
2858 return_val
[0] = NULL
;
2860 /* Look through the partial symtabs for all symbols which begin
2861 by matching SYM_TEXT. Add each one that you find to the list. */
2863 ALL_PSYMTABS (objfile
, ps
)
2865 /* If the psymtab's been read in we'll get it when we search
2866 through the blockvector. */
2867 if (ps
->readin
) continue;
2869 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2870 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
2871 + ps
->n_global_syms
);
2874 /* If interrupted, then quit. */
2876 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2879 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2880 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
2881 + ps
->n_static_syms
);
2885 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
2889 /* At this point scan through the misc symbol vectors and add each
2890 symbol you find to the list. Eventually we want to ignore
2891 anything that isn't a text symbol (everything else will be
2892 handled by the psymtab code above). */
2894 ALL_MSYMBOLS (objfile
, msymbol
)
2897 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
2900 /* Search upwards from currently selected frame (so that we can
2901 complete on local vars. */
2903 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
2905 if (!BLOCK_SUPERBLOCK (b
))
2907 surrounding_static_block
= b
; /* For elmin of dups */
2910 /* Also catch fields of types defined in this places which match our
2911 text string. Only complete on types visible from current context. */
2913 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2915 sym
= BLOCK_SYM (b
, i
);
2916 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2917 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2919 struct type
*t
= SYMBOL_TYPE (sym
);
2920 enum type_code c
= TYPE_CODE (t
);
2922 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
2924 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
2926 if (TYPE_FIELD_NAME (t
, j
))
2928 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
2929 sym_text
, sym_text_len
, text
, word
);
2937 /* Go through the symtabs and check the externs and statics for
2938 symbols which match. */
2940 ALL_SYMTABS (objfile
, s
)
2943 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
2944 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2946 sym
= BLOCK_SYM (b
, i
);
2947 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2951 ALL_SYMTABS (objfile
, s
)
2954 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
2955 /* Don't do this block twice. */
2956 if (b
== surrounding_static_block
) continue;
2957 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
2959 sym
= BLOCK_SYM (b
, i
);
2960 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
2964 return (return_val
);
2969 /* Add the type of the symbol sym to the type of the current
2970 function whose block we are in (assumed). The type of
2971 this current function is contained in *TYPE.
2973 This basically works as follows: When we find a function
2974 symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
2975 a pointer to its type in the global in_function_type. Every
2976 time we come across a parameter symbol ('p' in its name), then
2977 this procedure adds the name and type of that parameter
2978 to the function type pointed to by *TYPE. (Which should correspond
2979 to in_function_type if it was called correctly).
2981 Note that since we are modifying a type, the result of
2982 lookup_function_type() should be memcpy()ed before calling
2983 this. When not in strict typing mode, the expression
2984 evaluator can choose to ignore this.
2986 Assumption: All of a function's parameter symbols will
2987 appear before another function symbol is found. The parameters
2988 appear in the same order in the argument list as they do in the
2992 add_param_to_type (type
,sym
)
2996 int num
= ++(TYPE_NFIELDS(*type
));
2998 if(TYPE_NFIELDS(*type
)-1)
2999 TYPE_FIELDS(*type
) = (struct field
*)
3000 (*current_objfile
->xrealloc
) ((char *)(TYPE_FIELDS(*type
)),
3001 num
*sizeof(struct field
));
3003 TYPE_FIELDS(*type
) = (struct field
*)
3004 (*current_objfile
->xmalloc
) (num
*sizeof(struct field
));
3006 TYPE_FIELD_BITPOS(*type
,num
-1) = num
-1;
3007 TYPE_FIELD_BITSIZE(*type
,num
-1) = 0;
3008 TYPE_FIELD_TYPE(*type
,num
-1) = SYMBOL_TYPE(sym
);
3009 TYPE_FIELD_NAME(*type
,num
-1) = SYMBOL_NAME(sym
);
3014 _initialize_symtab ()
3016 add_info ("variables", variables_info
,
3017 "All global and static variable names, or those matching REGEXP.");
3018 add_info ("functions", functions_info
,
3019 "All function names, or those matching REGEXP.");
3021 /* FIXME: This command has at least the following problems:
3022 1. It prints builtin types (in a very strange and confusing fashion).
3023 2. It doesn't print right, e.g. with
3024 typedef struct foo *FOO
3025 type_print prints "FOO" when we want to make it (in this situation)
3026 print "struct foo *".
3027 I also think "ptype" or "whatis" is more likely to be useful (but if
3028 there is much disagreement "info types" can be fixed). */
3029 add_info ("types", types_info
,
3030 "All type names, or those matching REGEXP.");
3033 add_info ("methods", methods_info
,
3034 "All method names, or those matching REGEXP::REGEXP.\n\
3035 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3036 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3039 add_info ("sources", sources_info
,
3040 "Source files in the program.");
3042 add_com ("rbreak", no_class
, rbreak_command
,
3043 "Set a breakpoint for all functions matching REGEXP.");
3045 /* Initialize the one built-in type that isn't language dependent... */
3046 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3047 "<unknown type>", (struct objfile
*) NULL
);