1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
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"
39 #include <sys/types.h>
41 #include "gdb_string.h"
45 /* Prototypes for local functions */
48 find_methods
PARAMS ((struct type
*, char *, struct symbol
**));
51 completion_list_add_name
PARAMS ((char *, char *, int, char *, char *));
54 build_canonical_line_spec
PARAMS ((struct symtab_and_line
*, char *, char ***));
56 static struct symtabs_and_lines
57 decode_line_2
PARAMS ((struct symbol
*[], int, int, char ***));
60 rbreak_command
PARAMS ((char *, int));
63 types_info
PARAMS ((char *, int));
66 functions_info
PARAMS ((char *, int));
69 variables_info
PARAMS ((char *, int));
72 sources_info
PARAMS ((char *, int));
75 list_symbols
PARAMS ((char *, int, int, int));
78 output_source_filename
PARAMS ((char *, int *));
81 operator_chars
PARAMS ((char *, char **));
83 static int find_line_common
PARAMS ((struct linetable
*, int, int *));
85 static struct partial_symbol
*
86 lookup_partial_symbol
PARAMS ((struct partial_symtab
*, const char *,
87 int, enum namespace));
89 static struct symtab
*
90 lookup_symtab_1
PARAMS ((char *));
94 /* The single non-language-specific builtin type */
95 struct type
*builtin_type_error
;
97 /* Block in which the most recently searched-for symbol was found.
98 Might be better to make this a parameter to lookup_symbol and
101 const struct block
*block_found
;
103 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
105 /* While the C++ support is still in flux, issue a possibly helpful hint on
106 using the new command completion feature on single quoted demangled C++
107 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
110 cplusplus_hint (name
)
113 printf_filtered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
114 printf_filtered ("(Note leading single quote.)\n");
117 /* Check for a symtab of a specific name; first in symtabs, then in
118 psymtabs. *If* there is no '/' in the name, a match after a '/'
119 in the symtab filename will also work. */
121 static struct symtab
*
122 lookup_symtab_1 (name
)
125 register struct symtab
*s
;
126 register struct partial_symtab
*ps
;
127 register char *slash
;
128 register struct objfile
*objfile
;
132 /* First, search for an exact match */
134 ALL_SYMTABS (objfile
, s
)
135 if (STREQ (name
, s
->filename
))
138 slash
= strchr (name
, '/');
140 /* Now, search for a matching tail (only if name doesn't have any dirs) */
143 ALL_SYMTABS (objfile
, s
)
145 char *p
= s
-> filename
;
146 char *tail
= strrchr (p
, '/');
155 /* Same search rules as above apply here, but now we look thru the
158 ps
= lookup_partial_symtab (name
);
163 error ("Internal: readin %s pst for `%s' found when no symtab found.",
164 ps
-> filename
, name
);
166 s
= PSYMTAB_TO_SYMTAB (ps
);
171 /* At this point, we have located the psymtab for this file, but
172 the conversion to a symtab has failed. This usually happens
173 when we are looking up an include file. In this case,
174 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
175 been created. So, we need to run through the symtabs again in
176 order to find the file.
177 XXX - This is a crock, and should be fixed inside of the the
178 symbol parsing routines. */
182 /* Lookup the symbol table of a source file named NAME. Try a couple
183 of variations if the first lookup doesn't work. */
189 register struct symtab
*s
;
194 s
= lookup_symtab_1 (name
);
198 /* This screws c-exp.y:yylex if there is both a type "tree" and a symtab
201 /* If name not found as specified, see if adding ".c" helps. */
202 /* Why is this? Is it just a user convenience? (If so, it's pretty
203 questionable in the presence of C++, FORTRAN, etc.). It's not in
206 copy
= (char *) alloca (strlen (name
) + 3);
209 s
= lookup_symtab_1 (copy
);
213 /* We didn't find anything; die. */
217 /* Lookup the partial symbol table of a source file named NAME.
218 *If* there is no '/' in the name, a match after a '/'
219 in the psymtab filename will also work. */
221 struct partial_symtab
*
222 lookup_partial_symtab (name
)
225 register struct partial_symtab
*pst
;
226 register struct objfile
*objfile
;
228 ALL_PSYMTABS (objfile
, pst
)
230 if (STREQ (name
, pst
-> filename
))
236 /* Now, search for a matching tail (only if name doesn't have any dirs) */
238 if (!strchr (name
, '/'))
239 ALL_PSYMTABS (objfile
, pst
)
241 char *p
= pst
-> filename
;
242 char *tail
= strrchr (p
, '/');
254 /* Demangle a GDB method stub type.
255 Note that this function is g++ specific. */
258 gdb_mangle_name (type
, i
, j
)
262 int mangled_name_len
;
264 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
265 struct fn_field
*method
= &f
[j
];
266 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
267 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
268 char *newname
= type_name_no_tag (type
);
270 /* Does the form of physname indicate that it is the full mangled name
271 of a constructor (not just the args)? */
272 int is_full_physname_constructor
;
275 int is_destructor
= DESTRUCTOR_PREFIX_P (physname
);
276 /* Need a new type prefix. */
277 char *const_prefix
= method
->is_const
? "C" : "";
278 char *volatile_prefix
= method
->is_volatile
? "V" : "";
280 int len
= (newname
== NULL
? 0 : strlen (newname
));
282 is_full_physname_constructor
=
283 ((physname
[0]=='_' && physname
[1]=='_' &&
284 (isdigit(physname
[2]) || physname
[2]=='Q' || physname
[2]=='t'))
285 || (strncmp(physname
, "__ct", 4) == 0));
288 is_full_physname_constructor
|| (newname
&& STREQ(field_name
, newname
));
291 is_destructor
= (strncmp(physname
, "__dt", 4) == 0);
293 if (is_destructor
|| is_full_physname_constructor
)
295 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
296 strcpy(mangled_name
, physname
);
302 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
303 if (strcmp(buf
, "__") == 0)
306 else if (newname
!= NULL
&& strchr (newname
, '<') != NULL
)
308 /* Template methods are fully mangled. */
309 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
315 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
317 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
322 /* Only needed for GNU-mangled names. ANSI-mangled names
323 work with the normal mechanisms. */
324 if (OPNAME_PREFIX_P (field_name
))
326 char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
328 error ("No mangling for \"%s\"", field_name
);
329 mangled_name_len
+= strlen (opname
);
330 mangled_name
= (char *)xmalloc (mangled_name_len
);
332 strncpy (mangled_name
, field_name
, 3);
333 mangled_name
[3] = '\0';
334 strcat (mangled_name
, opname
);
338 mangled_name
= (char *)xmalloc (mangled_name_len
);
340 mangled_name
[0] = '\0';
342 strcpy (mangled_name
, field_name
);
344 strcat (mangled_name
, buf
);
345 /* If the class doesn't have a name, i.e. newname NULL, then we just
346 mangle it using 0 for the length of the class. Thus it gets mangled
347 as something starting with `::' rather than `classname::'. */
349 strcat (mangled_name
, newname
);
351 strcat (mangled_name
, physname
);
352 return (mangled_name
);
356 /* Find which partial symtab on contains PC. Return 0 if none. */
358 struct partial_symtab
*
360 register CORE_ADDR pc
;
362 register struct partial_symtab
*pst
;
363 register struct objfile
*objfile
;
365 ALL_PSYMTABS (objfile
, pst
)
367 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
369 struct minimal_symbol
*msymbol
;
370 struct partial_symtab
*tpst
;
372 /* An objfile that has its functions reordered might have
373 many partial symbol tables containing the PC, but
374 we want the partial symbol table that contains the
375 function containing the PC. */
376 if (!(objfile
->flags
& OBJF_REORDERED
))
379 msymbol
= lookup_minimal_symbol_by_pc (pc
);
383 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
385 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
387 struct partial_symbol
*p
;
389 p
= find_pc_psymbol (tpst
, pc
);
391 && SYMBOL_VALUE_ADDRESS(p
)
392 == SYMBOL_VALUE_ADDRESS (msymbol
))
402 /* Find which partial symbol within a psymtab contains PC. Return 0
403 if none. Check all psymtabs if PSYMTAB is 0. */
404 struct partial_symbol
*
405 find_pc_psymbol (psymtab
, pc
)
406 struct partial_symtab
*psymtab
;
409 struct partial_symbol
*best
= NULL
, *p
;
413 psymtab
= find_pc_psymtab (pc
);
417 best_pc
= psymtab
->textlow
- 1;
419 /* Search the global symbols as well as the static symbols, so that
420 find_pc_partial_function doesn't use a minimal symbol and thus
421 cache a bad endaddr. */
422 for (p
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
423 (p
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
424 < psymtab
->n_global_syms
);
426 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
427 && SYMBOL_CLASS (p
) == LOC_BLOCK
428 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
429 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
431 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
434 for (p
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
435 (p
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
436 < psymtab
->n_static_syms
);
438 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
439 && SYMBOL_CLASS (p
) == LOC_BLOCK
440 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
441 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
443 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
446 if (best_pc
== psymtab
->textlow
- 1)
452 /* Find the definition for a specified symbol name NAME
453 in namespace NAMESPACE, visible from lexical block BLOCK.
454 Returns the struct symbol pointer, or zero if no symbol is found.
455 If SYMTAB is non-NULL, store the symbol table in which the
456 symbol was found there, or NULL if not found.
457 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
458 NAME is a field of the current implied argument `this'. If so set
459 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
460 BLOCK_FOUND is set to the block in which NAME is found (in the case of
461 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
463 /* This function has a bunch of loops in it and it would seem to be
464 attractive to put in some QUIT's (though I'm not really sure
465 whether it can run long enough to be really important). But there
466 are a few calls for which it would appear to be bad news to quit
467 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c, and
468 nindy_frame_chain_valid in nindy-tdep.c. (Note that there is C++
469 code below which can error(), but that probably doesn't affect
470 these calls since they are looking for a known variable and thus
471 can probably assume it will never hit the C++ code). */
474 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
476 register const struct block
*block
;
477 const enum namespace namespace;
478 int *is_a_field_of_this
;
479 struct symtab
**symtab
;
481 register struct symbol
*sym
;
482 register struct symtab
*s
= NULL
;
483 register struct partial_symtab
*ps
;
484 struct blockvector
*bv
;
485 register struct objfile
*objfile
;
486 register struct block
*b
;
487 register struct minimal_symbol
*msymbol
;
489 /* Search specified block and its superiors. */
493 sym
= lookup_block_symbol (block
, name
, namespace);
499 /* Search the list of symtabs for one which contains the
500 address of the start of this block. */
501 ALL_SYMTABS (objfile
, s
)
503 bv
= BLOCKVECTOR (s
);
504 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
505 if (BLOCK_START (b
) <= BLOCK_START (block
)
506 && BLOCK_END (b
) > BLOCK_START (block
))
515 block
= BLOCK_SUPERBLOCK (block
);
518 /* FIXME: this code is never executed--block is always NULL at this
519 point. What is it trying to do, anyway? We already should have
520 checked the STATIC_BLOCK above (it is the superblock of top-level
521 blocks). Why is VAR_NAMESPACE special-cased? */
522 /* Don't need to mess with the psymtabs; if we have a block,
523 that file is read in. If we don't, then we deal later with
524 all the psymtab stuff that needs checking. */
525 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
528 /* Find the right symtab. */
529 ALL_SYMTABS (objfile
, s
)
531 bv
= BLOCKVECTOR (s
);
532 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
533 if (BLOCK_START (b
) <= BLOCK_START (block
)
534 && BLOCK_END (b
) > BLOCK_START (block
))
536 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
549 /* C++: If requested to do so by the caller,
550 check to see if NAME is a field of `this'. */
551 if (is_a_field_of_this
)
553 struct value
*v
= value_of_this (0);
555 *is_a_field_of_this
= 0;
556 if (v
&& check_field (v
, name
))
558 *is_a_field_of_this
= 1;
565 /* Now search all global blocks. Do the symtab's first, then
566 check the psymtab's */
568 ALL_SYMTABS (objfile
, s
)
570 bv
= BLOCKVECTOR (s
);
571 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
572 sym
= lookup_block_symbol (block
, name
, namespace);
582 /* Check for the possibility of the symbol being a function or
583 a mangled variable that is stored in one of the minimal symbol tables.
584 Eventually, all global symbols might be resolved in this way. */
586 if (namespace == VAR_NAMESPACE
)
588 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
591 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
594 /* This is a function which has a symtab for its address. */
595 bv
= BLOCKVECTOR (s
);
596 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
597 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
599 /* We kept static functions in minimal symbol table as well as
600 in static scope. We want to find them in the symbol table. */
602 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
603 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
607 /* sym == 0 if symbol was found in the minimal symbol table
608 but not in the symtab.
609 Return 0 to use the msymbol definition of "foo_".
611 This happens for Fortran "foo_" symbols,
612 which are "foo" in the symtab.
614 This can also happen if "asm" is used to make a
615 regular symbol but not a debugging symbol, e.g.
624 else if (MSYMBOL_TYPE (msymbol
) != mst_text
625 && MSYMBOL_TYPE (msymbol
) != mst_file_text
626 && !STREQ (name
, SYMBOL_NAME (msymbol
)))
628 /* This is a mangled variable, look it up by its
630 return lookup_symbol (SYMBOL_NAME (msymbol
), block
,
631 namespace, is_a_field_of_this
, symtab
);
633 /* There are no debug symbols for this file, or we are looking
634 for an unmangled variable.
635 Try to find a matching static symbol below. */
639 ALL_PSYMTABS (objfile
, ps
)
641 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
643 s
= PSYMTAB_TO_SYMTAB(ps
);
644 bv
= BLOCKVECTOR (s
);
645 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
646 sym
= lookup_block_symbol (block
, name
, namespace);
648 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
655 /* Now search all per-file blocks.
656 Not strictly correct, but more useful than an error.
657 Do the symtabs first, then check the psymtabs */
659 ALL_SYMTABS (objfile
, s
)
661 bv
= BLOCKVECTOR (s
);
662 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
663 sym
= lookup_block_symbol (block
, name
, namespace);
673 ALL_PSYMTABS (objfile
, ps
)
675 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
677 s
= PSYMTAB_TO_SYMTAB(ps
);
678 bv
= BLOCKVECTOR (s
);
679 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
680 sym
= lookup_block_symbol (block
, name
, namespace);
682 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
694 /* Look, in partial_symtab PST, for symbol NAME. Check the global
695 symbols if GLOBAL, the static symbols if not */
697 static struct partial_symbol
*
698 lookup_partial_symbol (pst
, name
, global
, namespace)
699 struct partial_symtab
*pst
;
702 enum namespace namespace;
704 struct partial_symbol
*start
, *psym
;
705 struct partial_symbol
*top
, *bottom
, *center
;
706 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
707 int do_linear_search
= 1;
715 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
716 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
718 if (global
) /* This means we can use a binary search. */
720 do_linear_search
= 0;
722 /* Binary search. This search is guaranteed to end with center
723 pointing at the earliest partial symbol with the correct
724 name. At that point *all* partial symbols with that name
725 will be checked against the correct namespace. */
728 top
= start
+ length
- 1;
731 center
= bottom
+ (top
- bottom
) / 2;
734 if (!do_linear_search
&& SYMBOL_LANGUAGE (center
) == language_cplus
)
736 do_linear_search
= 1;
738 if (STRCMP (SYMBOL_NAME (center
), name
) >= 0)
747 if (!(top
== bottom
))
749 while (STREQ (SYMBOL_NAME (top
), name
))
751 if (SYMBOL_NAMESPACE (top
) == namespace)
759 /* Can't use a binary search or else we found during the binary search that
760 we should also do a linear search. */
762 if (do_linear_search
)
764 for (psym
= start
; psym
< start
+ length
; psym
++)
766 if (namespace == SYMBOL_NAMESPACE (psym
))
768 if (SYMBOL_MATCHES_NAME (psym
, name
))
779 /* Find the psymtab containing main(). */
780 /* FIXME: What about languages without main() or specially linked
781 executables that have no main() ? */
783 struct partial_symtab
*
786 register struct partial_symtab
*pst
;
787 register struct objfile
*objfile
;
789 ALL_PSYMTABS (objfile
, pst
)
791 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
799 /* Search BLOCK for symbol NAME in NAMESPACE.
801 Note that if NAME is the demangled form of a C++ symbol, we will fail
802 to find a match during the binary search of the non-encoded names, but
803 for now we don't worry about the slight inefficiency of looking for
804 a match we'll never find, since it will go pretty quick. Once the
805 binary search terminates, we drop through and do a straight linear
806 search on the symbols. Each symbol which is marked as being a C++
807 symbol (language_cplus set) has both the encoded and non-encoded names
808 tested for a match. */
811 lookup_block_symbol (block
, name
, namespace)
812 register const struct block
*block
;
814 const enum namespace namespace;
816 register int bot
, top
, inc
;
817 register struct symbol
*sym
;
818 register struct symbol
*sym_found
= NULL
;
819 register int do_linear_search
= 1;
821 /* If the blocks's symbols were sorted, start with a binary search. */
823 if (BLOCK_SHOULD_SORT (block
))
825 /* Reset the linear search flag so if the binary search fails, we
826 won't do the linear search once unless we find some reason to
827 do so, such as finding a C++ symbol during the binary search.
828 Note that for C++ modules, ALL the symbols in a block should
829 end up marked as C++ symbols. */
831 do_linear_search
= 0;
832 top
= BLOCK_NSYMS (block
);
835 /* Advance BOT to not far before the first symbol whose name is NAME. */
839 inc
= (top
- bot
+ 1);
840 /* No need to keep binary searching for the last few bits worth. */
845 inc
= (inc
>> 1) + bot
;
846 sym
= BLOCK_SYM (block
, inc
);
847 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
849 do_linear_search
= 1;
851 if (SYMBOL_NAME (sym
)[0] < name
[0])
855 else if (SYMBOL_NAME (sym
)[0] > name
[0])
859 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
869 /* Now scan forward until we run out of symbols, find one whose
870 name is greater than NAME, or find one we want. If there is
871 more than one symbol with the right name and namespace, we
872 return the first one; I believe it is now impossible for us
873 to encounter two symbols with the same name and namespace
874 here, because blocks containing argument symbols are no
877 top
= BLOCK_NSYMS (block
);
880 sym
= BLOCK_SYM (block
, bot
);
881 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
884 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
886 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
898 /* Here if block isn't sorted, or we fail to find a match during the
899 binary search above. If during the binary search above, we find a
900 symbol which is a C++ symbol, then we have re-enabled the linear
901 search flag which was reset when starting the binary search.
903 This loop is equivalent to the loop above, but hacked greatly for speed.
905 Note that parameter symbols do not always show up last in the
906 list; this loop makes sure to take anything else other than
907 parameter symbols first; it only uses parameter symbols as a
908 last resort. Note that this only takes up extra computation
911 if (do_linear_search
)
913 top
= BLOCK_NSYMS (block
);
917 sym
= BLOCK_SYM (block
, bot
);
918 if (SYMBOL_NAMESPACE (sym
) == namespace &&
919 SYMBOL_MATCHES_NAME (sym
, name
))
922 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
923 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
924 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
925 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
926 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
927 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
935 return (sym_found
); /* Will be NULL if not found. */
939 /* Return the symbol for the function which contains a specified
940 lexical block, described by a struct block BL. */
946 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
947 bl
= BLOCK_SUPERBLOCK (bl
);
949 return BLOCK_FUNCTION (bl
);
952 /* Find the symtab associated with PC. Look through the psymtabs and read in
953 another symtab if necessary. */
957 register CORE_ADDR pc
;
959 register struct block
*b
;
960 struct blockvector
*bv
;
961 register struct symtab
*s
= NULL
;
962 register struct symtab
*best_s
= NULL
;
963 register struct partial_symtab
*ps
;
964 register struct objfile
*objfile
;
967 /* Search all symtabs for the one whose file contains our address, and which
968 is the smallest of all the ones containing the address. This is designed
969 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
970 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
971 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
973 This happens for native ecoff format, where code from included files
974 gets its own symtab. The symtab for the included file should have
975 been read in already via the dependency mechanism.
976 It might be swifter to create several symtabs with the same name
977 like xcoff does (I'm not sure).
979 It also happens for objfiles that have their functions reordered.
980 For these, the symtab we are looking for is not necessarily read in. */
982 ALL_SYMTABS (objfile
, s
)
984 bv
= BLOCKVECTOR (s
);
985 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
986 if (BLOCK_START (b
) <= pc
987 && BLOCK_END (b
) > pc
989 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
991 /* For an objfile that has its functions reordered,
992 find_pc_psymtab will find the proper partial symbol table
993 and we simply return its corresponding symtab. */
994 if (objfile
->flags
& OBJF_REORDERED
)
996 ps
= find_pc_psymtab (pc
);
998 s
= PSYMTAB_TO_SYMTAB (ps
);
1003 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1012 ps
= find_pc_psymtab (pc
);
1016 /* Might want to error() here (in case symtab is corrupt and
1017 will cause a core dump), but maybe we can successfully
1018 continue, so let's not. */
1019 /* FIXME-32x64: assumes pc fits in a long */
1021 (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n",
1022 (unsigned long) pc
);
1023 s
= PSYMTAB_TO_SYMTAB (ps
);
1030 /* Find the closest symbol value (of any sort -- function or variable)
1031 for a given address value. Slow but complete. (currently unused,
1032 mainly because it is too slow. We could fix it if each symtab and
1033 psymtab had contained in it the addresses ranges of each of its
1034 sections, which also would be required to make things like "info
1035 line *0x2345" cause psymtabs to be converted to symtabs). */
1038 find_addr_symbol (addr
, symtabp
, symaddrp
)
1040 struct symtab
**symtabp
;
1041 CORE_ADDR
*symaddrp
;
1043 struct symtab
*symtab
, *best_symtab
;
1044 struct objfile
*objfile
;
1045 register int bot
, top
;
1046 register struct symbol
*sym
;
1047 register CORE_ADDR sym_addr
;
1048 struct block
*block
;
1051 /* Info on best symbol seen so far */
1053 register CORE_ADDR best_sym_addr
= 0;
1054 struct symbol
*best_sym
= 0;
1056 /* FIXME -- we should pull in all the psymtabs, too! */
1057 ALL_SYMTABS (objfile
, symtab
)
1059 /* Search the global and static blocks in this symtab for
1060 the closest symbol-address to the desired address. */
1062 for (blocknum
= GLOBAL_BLOCK
; blocknum
<= STATIC_BLOCK
; blocknum
++)
1065 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), blocknum
);
1066 top
= BLOCK_NSYMS (block
);
1067 for (bot
= 0; bot
< top
; bot
++)
1069 sym
= BLOCK_SYM (block
, bot
);
1070 switch (SYMBOL_CLASS (sym
))
1074 sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1078 sym_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1085 if (sym_addr
<= addr
)
1086 if (sym_addr
> best_sym_addr
)
1088 /* Quit if we found an exact match. */
1090 best_sym_addr
= sym_addr
;
1091 best_symtab
= symtab
;
1092 if (sym_addr
== addr
)
1101 *symtabp
= best_symtab
;
1103 *symaddrp
= best_sym_addr
;
1108 /* Find the source file and line number for a given PC value.
1109 Return a structure containing a symtab pointer, a line number,
1110 and a pc range for the entire source line.
1111 The value's .pc field is NOT the specified pc.
1112 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1113 use the line that ends there. Otherwise, in that case, the line
1114 that begins there is used. */
1116 /* The big complication here is that a line may start in one file, and end just
1117 before the start of another file. This usually occurs when you #include
1118 code in the middle of a subroutine. To properly find the end of a line's PC
1119 range, we must search all symtabs associated with this compilation unit, and
1120 find the one whose first PC is closer than that of the next line in this
1123 /* If it's worth the effort, we could be using a binary search. */
1125 struct symtab_and_line
1126 find_pc_line (pc
, notcurrent
)
1131 register struct linetable
*l
;
1134 register struct linetable_entry
*item
;
1135 struct symtab_and_line val
;
1136 struct blockvector
*bv
;
1138 /* Info on best line seen so far, and where it starts, and its file. */
1140 struct linetable_entry
*best
= NULL
;
1141 CORE_ADDR best_end
= 0;
1142 struct symtab
*best_symtab
= 0;
1144 /* Store here the first line number
1145 of a file which contains the line at the smallest pc after PC.
1146 If we don't find a line whose range contains PC,
1147 we will use a line one less than this,
1148 with a range from the start of that file to the first line's pc. */
1149 struct linetable_entry
*alt
= NULL
;
1150 struct symtab
*alt_symtab
= 0;
1152 /* Info on best line seen in this file. */
1154 struct linetable_entry
*prev
;
1156 /* If this pc is not from the current frame,
1157 it is the address of the end of a call instruction.
1158 Quite likely that is the start of the following statement.
1159 But what we want is the statement containing the instruction.
1160 Fudge the pc to make sure we get that. */
1162 if (notcurrent
) pc
-= 1;
1164 s
= find_pc_symtab (pc
);
1174 bv
= BLOCKVECTOR (s
);
1176 /* Look at all the symtabs that share this blockvector.
1177 They all have the same apriori range, that we found was right;
1178 but they have different line tables. */
1180 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1182 /* Find the best line in this symtab. */
1189 /* I think len can be zero if the symtab lacks line numbers
1190 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1191 I'm not sure which, and maybe it depends on the symbol
1197 item
= l
->item
; /* Get first line info */
1199 /* Is this file's first line closer than the first lines of other files?
1200 If so, record this file, and its first line, as best alternate. */
1201 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1207 for (i
= 0; i
< len
; i
++, item
++)
1209 /* Return the last line that did not start after PC. */
1216 /* At this point, prev points at the line whose start addr is <= pc, and
1217 item points at the next line. If we ran off the end of the linetable
1218 (pc >= start of the last line), then prev == item. If pc < start of
1219 the first line, prev will not be set. */
1221 /* Is this file's best line closer than the best in the other files?
1222 If so, record this file, and its best line, as best so far. */
1224 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1228 /* If another line is in the linetable, and its PC is closer
1229 than the best_end we currently have, take it as best_end. */
1230 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1231 best_end
= item
->pc
;
1238 { /* If we didn't find any line # info, just
1247 val
.symtab
= alt_symtab
;
1248 val
.line
= alt
->line
- 1;
1250 /* Don't return line 0, that means that we didn't find the line. */
1251 if (val
.line
== 0) ++val
.line
;
1253 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1259 val
.symtab
= best_symtab
;
1260 val
.line
= best
->line
;
1262 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1267 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1272 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1275 /* Find line number LINE in any symtab whose name is the same as
1278 If found, return 1, set *LINETABLE to the linetable in which it was
1279 found, set *INDEX to the index in the linetable of the best entry
1280 found, and set *EXACT_MATCH nonzero if the value returned is an
1283 If not found, return 0. */
1286 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1287 struct symtab
*symtab
;
1289 struct linetable
**linetable
;
1295 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1299 struct linetable
*best_linetable
;
1301 /* First try looking it up in the given symtab. */
1302 best_linetable
= LINETABLE (symtab
);
1303 best_index
= find_line_common (best_linetable
, line
, &exact
);
1304 if (best_index
< 0 || !exact
)
1306 /* Didn't find an exact match. So we better keep looking for
1307 another symtab with the same name. In the case of xcoff,
1308 multiple csects for one source file (produced by IBM's FORTRAN
1309 compiler) produce multiple symtabs (this is unavoidable
1310 assuming csects can be at arbitrary places in memory and that
1311 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1313 /* BEST is the smallest linenumber > LINE so far seen,
1314 or 0 if none has been seen so far.
1315 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1318 struct objfile
*objfile
;
1321 if (best_index
>= 0)
1322 best
= best_linetable
->item
[best_index
].line
;
1326 ALL_SYMTABS (objfile
, s
)
1328 struct linetable
*l
;
1331 if (!STREQ (symtab
->filename
, s
->filename
))
1334 ind
= find_line_common (l
, line
, &exact
);
1343 if (best
== 0 || l
->item
[ind
].line
< best
)
1345 best
= l
->item
[ind
].line
;
1357 *index
= best_index
;
1359 *linetable
= best_linetable
;
1361 *exact_match
= exact
;
1365 /* Find the PC value for a given source file and line number.
1366 Returns zero for invalid line number.
1367 The source file is specified with a struct symtab. */
1370 find_line_pc (symtab
, line
)
1371 struct symtab
*symtab
;
1374 struct linetable
*l
;
1379 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1380 return l
->item
[ind
].pc
;
1385 /* Find the range of pc values in a line.
1386 Store the starting pc of the line into *STARTPTR
1387 and the ending pc (start of next line) into *ENDPTR.
1388 Returns 1 to indicate success.
1389 Returns 0 if could not find the specified line. */
1392 find_line_pc_range (sal
, startptr
, endptr
)
1393 struct symtab_and_line sal
;
1394 CORE_ADDR
*startptr
, *endptr
;
1396 CORE_ADDR startaddr
;
1397 struct symtab_and_line found_sal
;
1402 startaddr
= find_line_pc (sal
.symtab
, sal
.line
);
1407 /* This whole function is based on address. For example, if line 10 has
1408 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1409 "info line *0x123" should say the line goes from 0x100 to 0x200
1410 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1411 This also insures that we never give a range like "starts at 0x134
1412 and ends at 0x12c". */
1414 found_sal
= find_pc_line (startaddr
, 0);
1415 if (found_sal
.line
!= sal
.line
)
1417 /* The specified line (sal) has zero bytes. */
1418 *startptr
= found_sal
.pc
;
1419 *endptr
= found_sal
.pc
;
1423 *startptr
= found_sal
.pc
;
1424 *endptr
= found_sal
.end
;
1429 /* Given a line table and a line number, return the index into the line
1430 table for the pc of the nearest line whose number is >= the specified one.
1431 Return -1 if none is found. The value is >= 0 if it is an index.
1433 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1436 find_line_common (l
, lineno
, exact_match
)
1437 register struct linetable
*l
;
1438 register int lineno
;
1444 /* BEST is the smallest linenumber > LINENO so far seen,
1445 or 0 if none has been seen so far.
1446 BEST_INDEX identifies the item for it. */
1448 int best_index
= -1;
1457 for (i
= 0; i
< len
; i
++)
1459 register struct linetable_entry
*item
= &(l
->item
[i
]);
1461 if (item
->line
== lineno
)
1463 /* Return the first (lowest address) entry which matches. */
1468 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1475 /* If we got here, we didn't get an exact match. */
1482 find_pc_line_pc_range (pc
, startptr
, endptr
)
1484 CORE_ADDR
*startptr
, *endptr
;
1486 struct symtab_and_line sal
;
1487 sal
= find_pc_line (pc
, 0);
1490 return sal
.symtab
!= 0;
1493 /* Given a function symbol SYM, find the symtab and line for the start
1495 If the argument FUNFIRSTLINE is nonzero, we want the first line
1496 of real code inside the function. */
1498 static struct symtab_and_line
1499 find_function_start_sal
PARAMS ((struct symbol
*sym
, int));
1501 static struct symtab_and_line
1502 find_function_start_sal (sym
, funfirstline
)
1507 struct symtab_and_line sal
;
1509 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1512 pc
+= FUNCTION_START_OFFSET
;
1515 sal
= find_pc_line (pc
, 0);
1517 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1518 /* Convex: no need to suppress code on first line, if any */
1521 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1522 line is still part of the same function. */
1524 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
1525 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1527 /* First pc of next line */
1529 /* Recalculate the line number (might not be N+1). */
1530 sal
= find_pc_line (pc
, 0);
1538 /* If P is of the form "operator[ \t]+..." where `...' is
1539 some legitimate operator text, return a pointer to the
1540 beginning of the substring of the operator text.
1541 Otherwise, return "". */
1543 operator_chars (p
, end
)
1548 if (strncmp (p
, "operator", 8))
1552 /* Don't get faked out by `operator' being part of a longer
1554 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1557 /* Allow some whitespace between `operator' and the operator symbol. */
1558 while (*p
== ' ' || *p
== '\t')
1561 /* Recognize 'operator TYPENAME'. */
1563 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1565 register char *q
= p
+1;
1566 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1591 if (p
[1] == '=' || p
[1] == p
[0])
1602 error ("`operator ()' must be specified without whitespace in `()'");
1607 error ("`operator ?:' must be specified without whitespace in `?:'");
1612 error ("`operator []' must be specified without whitespace in `[]'");
1616 error ("`operator %s' not supported", p
);
1623 /* Return the number of methods described for TYPE, including the
1624 methods from types it derives from. This can't be done in the symbol
1625 reader because the type of the baseclass might still be stubbed
1626 when the definition of the derived class is parsed. */
1628 static int total_number_of_methods
PARAMS ((struct type
*type
));
1631 total_number_of_methods (type
)
1637 check_stub_type (type
);
1638 count
= TYPE_NFN_FIELDS_TOTAL (type
);
1640 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
1641 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
1646 /* Recursive helper function for decode_line_1.
1647 Look for methods named NAME in type T.
1648 Return number of matches.
1649 Put matches in SYM_ARR, which should have been allocated with
1650 a size of total_number_of_methods (T) * sizeof (struct symbol *).
1651 Note that this function is g++ specific. */
1654 find_methods (t
, name
, sym_arr
)
1657 struct symbol
**sym_arr
;
1661 struct symbol
*sym_class
;
1662 char *class_name
= type_name_no_tag (t
);
1663 /* Ignore this class if it doesn't have a name. This is ugly, but
1664 unless we figure out how to get the physname without the name of
1665 the class, then the loop can't do any good. */
1667 && (sym_class
= lookup_symbol (class_name
,
1668 (struct block
*)NULL
,
1671 (struct symtab
**)NULL
)))
1674 /* FIXME: Shouldn't this just be check_stub_type (t)? */
1675 t
= SYMBOL_TYPE (sym_class
);
1676 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1677 method_counter
>= 0;
1681 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1682 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1683 char dem_opname
[64];
1685 if (strncmp(method_name
, "__", 2)==0 ||
1686 strncmp(method_name
, "op", 2)==0 ||
1687 strncmp(method_name
, "type", 4)==0 )
1689 if (cplus_demangle_opname(method_name
, dem_opname
, DMGL_ANSI
))
1690 method_name
= dem_opname
;
1691 else if (cplus_demangle_opname(method_name
, dem_opname
, 0))
1692 method_name
= dem_opname
;
1694 if (STREQ (name
, method_name
))
1695 /* Find all the fields with that name. */
1696 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1701 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1702 check_stub_method (t
, method_counter
, field_counter
);
1703 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1704 /* Destructor is handled by caller, dont add it to the list */
1705 if (DESTRUCTOR_PREFIX_P (phys_name
))
1708 /* FIXME: Why are we looking this up in the
1709 SYMBOL_BLOCK_VALUE (sym_class)? It is intended as a hook
1710 for nested types? If so, it should probably hook to the
1711 type, not the symbol. mipsread.c is the only symbol
1712 reader which sets the SYMBOL_BLOCK_VALUE for types, and
1713 this is not documented in symtab.h. -26Aug93. */
1715 sym_arr
[i1
] = lookup_symbol (phys_name
,
1716 SYMBOL_BLOCK_VALUE (sym_class
),
1719 (struct symtab
**) NULL
);
1720 if (sym_arr
[i1
]) i1
++;
1723 fputs_filtered("(Cannot find method ", gdb_stdout
);
1724 fprintf_symbol_filtered (gdb_stdout
, phys_name
,
1726 DMGL_PARAMS
| DMGL_ANSI
);
1727 fputs_filtered(" - possibly inlined.)\n", gdb_stdout
);
1733 /* Only search baseclasses if there is no match yet, since names in
1734 derived classes override those in baseclasses.
1736 FIXME: The above is not true; it is only true of member functions
1737 if they have the same number of arguments (??? - section 13.1 of the
1738 ARM says the function members are not in the same scope but doesn't
1739 really spell out the rules in a way I understand. In any case, if
1740 the number of arguments differ this is a case in which we can overload
1741 rather than hiding without any problem, and gcc 2.4.5 does overload
1742 rather than hiding in this case). */
1746 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1747 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1752 /* Helper function for decode_line_1.
1753 Build a canonical line spec in CANONICAL if it is non-NULL and if
1754 the SAL has a symtab.
1755 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1756 If SYMNAME is NULL the line number from SAL is used and the canonical
1757 line spec is `filename:linenum'. */
1760 build_canonical_line_spec (sal
, symname
, canonical
)
1761 struct symtab_and_line
*sal
;
1765 char **canonical_arr
;
1766 char *canonical_name
;
1768 struct symtab
*s
= sal
->symtab
;
1770 if (s
== (struct symtab
*)NULL
1771 || s
->filename
== (char *)NULL
1772 || canonical
== (char ***)NULL
)
1775 canonical_arr
= (char **) xmalloc (sizeof (char *));
1776 *canonical
= canonical_arr
;
1778 filename
= s
->filename
;
1779 if (symname
!= NULL
)
1781 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1782 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1786 canonical_name
= xmalloc (strlen (filename
) + 30);
1787 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1789 canonical_arr
[0] = canonical_name
;
1792 /* Parse a string that specifies a line number.
1793 Pass the address of a char * variable; that variable will be
1794 advanced over the characters actually parsed.
1798 LINENUM -- that line number in current file. PC returned is 0.
1799 FILE:LINENUM -- that line in that file. PC returned is 0.
1800 FUNCTION -- line number of openbrace of that function.
1801 PC returned is the start of the function.
1802 VARIABLE -- line number of definition of that variable.
1804 FILE:FUNCTION -- likewise, but prefer functions in that file.
1805 *EXPR -- line in which address EXPR appears.
1807 FUNCTION may be an undebuggable function found in minimal symbol table.
1809 If the argument FUNFIRSTLINE is nonzero, we want the first line
1810 of real code inside a function when a function is specified, and it is
1811 not OK to specify a variable or type to get its line number.
1813 DEFAULT_SYMTAB specifies the file to use if none is specified.
1814 It defaults to current_source_symtab.
1815 DEFAULT_LINE specifies the line number to use for relative
1816 line numbers (that start with signs). Defaults to current_source_line.
1817 If CANONICAL is non-NULL, store an array of strings containing the canonical
1818 line specs there if necessary. Currently overloaded member functions and
1819 line numbers or static functions without a filename yield a canonical
1820 line spec. The array and the line spec strings are allocated on the heap,
1821 it is the callers responsibility to free them.
1823 Note that it is possible to return zero for the symtab
1824 if no file is validly specified. Callers must check that.
1825 Also, the line number returned may be invalid. */
1827 /* We allow single quotes in various places. This is a hideous
1828 kludge, which exists because the completer can't yet deal with the
1829 lack of single quotes. FIXME: write a linespec_completer which we
1830 can use as appropriate instead of make_symbol_completion_list. */
1832 struct symtabs_and_lines
1833 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1836 struct symtab
*default_symtab
;
1840 struct symtabs_and_lines values
;
1841 #ifdef HPPA_COMPILER_BUG
1842 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1843 when optimizing this file with target i960-vxworks. I haven't
1844 been able to construct a simple test case. The problem is that
1845 in the second call to SKIP_PROLOGUE below, the compiler somehow
1846 does not realize that the statement val = find_pc_line (...) will
1847 change the values of the fields of val. It extracts the elements
1848 into registers at the top of the block, and does not update the
1849 registers after the call to find_pc_line. You can check this by
1850 inserting a printf at the end of find_pc_line to show what values
1851 it is returning for val.pc and val.end and another printf after
1852 the call to see what values the function actually got (remember,
1853 this is compiling with cc -O, with this patch removed). You can
1854 also examine the assembly listing: search for the second call to
1855 skip_prologue; the LDO statement before the next call to
1856 find_pc_line loads the address of the structure which
1857 find_pc_line will return; if there is a LDW just before the LDO,
1858 which fetches an element of the structure, then the compiler
1861 Setting val to volatile avoids the problem. We must undef
1862 volatile, because the HPPA native compiler does not define
1863 __STDC__, although it does understand volatile, and so volatile
1864 will have been defined away in defs.h. */
1866 volatile struct symtab_and_line val
;
1867 #define volatile /*nothing*/
1869 struct symtab_and_line val
;
1871 register char *p
, *p1
;
1876 register struct symtab
*s
;
1878 register struct symbol
*sym
;
1879 /* The symtab that SYM was found in. */
1880 struct symtab
*sym_symtab
;
1882 register CORE_ADDR pc
;
1883 register struct minimal_symbol
*msymbol
;
1885 struct symbol
*sym_class
;
1887 int is_quoted
, has_parens
;
1888 struct symbol
**sym_arr
;
1890 char *saved_arg
= *argptr
;
1891 extern char *gdb_completer_quote_characters
;
1893 /* Defaults have defaults. */
1895 if (default_symtab
== 0)
1897 default_symtab
= current_source_symtab
;
1898 default_line
= current_source_line
;
1901 /* See if arg is *PC */
1903 if (**argptr
== '*')
1906 pc
= parse_and_eval_address_1 (argptr
);
1907 values
.sals
= (struct symtab_and_line
*)
1908 xmalloc (sizeof (struct symtab_and_line
));
1910 values
.sals
[0] = find_pc_line (pc
, 0);
1911 values
.sals
[0].pc
= pc
;
1915 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1918 is_quoted
= (strchr(gdb_completer_quote_characters
, **argptr
) != NULL
);
1919 has_parens
= (( pp
= strchr(*argptr
, '(')) != NULL
&&
1920 (pp
= strchr(pp
, ')')) != NULL
);
1922 for (p
= *argptr
; *p
; p
++)
1926 while(++p
&& *p
!= '>');
1929 error ("non-matching '<' and '>' in command");
1932 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
1935 while (p
[0] == ' ' || p
[0] == '\t') p
++;
1937 if ((p
[0] == ':') && !has_parens
)
1941 if (is_quoted
) *argptr
= *argptr
+1;
1944 /* Extract the class name. */
1946 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
1947 copy
= (char *) alloca (p
- *argptr
+ 1);
1948 memcpy (copy
, *argptr
, p
- *argptr
);
1949 copy
[p
- *argptr
] = 0;
1951 /* Discard the class name from the arg. */
1953 while (*p
== ' ' || *p
== '\t') p
++;
1956 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
1957 (struct symtab
**)NULL
);
1960 ( TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_STRUCT
1961 || TYPE_CODE (SYMBOL_TYPE (sym_class
)) == TYPE_CODE_UNION
))
1963 /* Arg token is not digits => try it as a function name
1964 Find the next token(everything up to end or next blank). */
1965 if (strchr(gdb_completer_quote_characters
, **argptr
) != NULL
)
1967 p
= skip_quoted(*argptr
);
1968 *argptr
= *argptr
+ 1;
1973 while (*p
&& *p
!=' ' && *p
!='\t' && *p
!=',' && *p
!=':') p
++;
1976 q = operator_chars (*argptr, &q1);
1980 char *tmp = alloca (q1 - q + 1);
1981 memcpy (tmp, q, q1 - q);
1983 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
1987 printf_filtered ("no mangling for \"%s\"\n", tmp);
1988 cplusplus_hint (saved_arg);
1989 return_to_top_level (RETURN_ERROR);
1991 copy = (char*) alloca (3 + strlen(opname));
1992 sprintf (copy, "__%s", opname);
1998 copy
= (char *) alloca (p
- *argptr
+ 1 );
1999 memcpy (copy
, *argptr
, p
- *argptr
);
2000 copy
[p
- *argptr
] = '\0';
2001 if (strchr(gdb_completer_quote_characters
, copy
[p
-*argptr
-1]) != NULL
)
2002 copy
[p
- *argptr
-1] = '\0';
2005 /* no line number may be specified */
2006 while (*p
== ' ' || *p
== '\t') p
++;
2010 i1
= 0; /* counter for the symbol array */
2011 t
= SYMBOL_TYPE (sym_class
);
2012 sym_arr
= (struct symbol
**) alloca(total_number_of_methods (t
)
2013 * sizeof(struct symbol
*));
2015 /* Cfront objects don't have fieldlists. */
2016 if (destructor_name_p (copy
, t
) && TYPE_FN_FIELDLISTS (t
) != NULL
)
2018 /* destructors are a special case. */
2019 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, 0);
2020 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, 0) - 1;
2021 /* gcc 1.x puts destructor in last field,
2022 gcc 2.x puts destructor in first field. */
2023 char *phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, len
);
2024 if (!DESTRUCTOR_PREFIX_P (phys_name
))
2026 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, 0);
2027 if (!DESTRUCTOR_PREFIX_P (phys_name
))
2031 lookup_symbol (phys_name
, SYMBOL_BLOCK_VALUE (sym_class
),
2032 VAR_NAMESPACE
, 0, (struct symtab
**)NULL
);
2033 if (sym_arr
[i1
]) i1
++;
2036 i1
= find_methods (t
, copy
, sym_arr
);
2039 /* There is exactly one field with that name. */
2042 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2044 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2046 values
.sals
[0] = find_function_start_sal (sym
,
2057 /* There is more than one field with that name
2058 (overloaded). Ask the user which one to use. */
2059 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
2065 if (OPNAME_PREFIX_P (copy
))
2067 tmp
= (char *)alloca (strlen (copy
+3) + 9);
2068 strcpy (tmp
, "operator ");
2069 strcat (tmp
, copy
+3);
2076 ("the class `%s' does not have destructor defined\n",
2077 SYMBOL_SOURCE_NAME(sym_class
));
2080 ("the class %s does not have any method named %s\n",
2081 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
2082 cplusplus_hint (saved_arg
);
2083 return_to_top_level (RETURN_ERROR
);
2089 /* The quotes are important if copy is empty. */
2091 ("can't find class, struct, or union named \"%s\"\n", copy
);
2092 cplusplus_hint (saved_arg
);
2093 return_to_top_level (RETURN_ERROR
);
2099 /* Extract the file name. */
2101 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2102 copy
= (char *) alloca (p
- *argptr
+ 1);
2103 memcpy (copy
, *argptr
, p
- *argptr
);
2104 copy
[p
- *argptr
] = 0;
2106 /* Find that file's data. */
2107 s
= lookup_symtab (copy
);
2110 if (!have_full_symbols () && !have_partial_symbols ())
2111 error (no_symtab_msg
);
2112 error ("No source file named %s.", copy
);
2115 /* Discard the file name from the arg. */
2117 while (*p
== ' ' || *p
== '\t') p
++;
2121 /* S is specified file's symtab, or 0 if no file specified.
2122 arg no longer contains the file name. */
2124 /* Check whether arg is all digits (and sign) */
2127 if (*q
== '-' || *q
== '+') q
++;
2128 while (*q
>= '0' && *q
<= '9')
2131 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
2133 /* We found a token consisting of all digits -- at least one digit. */
2134 enum sign
{none
, plus
, minus
} sign
= none
;
2136 /* We might need a canonical line spec if no file was specified. */
2137 int need_canonical
= (s
== 0) ? 1 : 0;
2139 /* This is where we need to make sure that we have good defaults.
2140 We must guarantee that this section of code is never executed
2141 when we are called with just a function name, since
2142 select_source_symtab calls us with such an argument */
2144 if (s
== 0 && default_symtab
== 0)
2146 select_source_symtab (0);
2147 default_symtab
= current_source_symtab
;
2148 default_line
= current_source_line
;
2151 if (**argptr
== '+')
2152 sign
= plus
, (*argptr
)++;
2153 else if (**argptr
== '-')
2154 sign
= minus
, (*argptr
)++;
2155 val
.line
= atoi (*argptr
);
2162 val
.line
= default_line
+ val
.line
;
2168 val
.line
= default_line
- val
.line
;
2173 break; /* No need to adjust val.line. */
2176 while (*q
== ' ' || *q
== '\t') q
++;
2182 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2183 values
.sals
[0] = val
;
2186 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2190 /* Arg token is not digits => try it as a variable name
2191 Find the next token (everything up to end or next whitespace). */
2193 if (**argptr
== '$') /* Convenience variable */
2194 p
= skip_quoted (*argptr
+ 1);
2197 p
= skip_quoted (*argptr
);
2199 error ("Unmatched single quote.");
2201 else if (has_parens
)
2207 p
= skip_quoted(*argptr
);
2210 copy
= (char *) alloca (p
- *argptr
+ 1);
2211 memcpy (copy
, *argptr
, p
- *argptr
);
2212 copy
[p
- *argptr
] = '\0';
2214 && (copy
[0] == copy
[p
- *argptr
- 1])
2215 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
2217 copy
[p
- *argptr
- 1] = '\0';
2220 while (*p
== ' ' || *p
== '\t') p
++;
2223 /* See if it's a convenience variable */
2228 int need_canonical
= (s
== 0) ? 1 : 0;
2230 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
2231 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
2232 error ("Convenience variables used in line specs must have integer values.");
2234 val
.symtab
= s
? s
: default_symtab
;
2235 val
.line
= value_as_long (valx
);
2238 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof val
);
2239 values
.sals
[0] = val
;
2243 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2249 /* Look up that token as a variable.
2250 If file specified, use that file's per-file block to start with. */
2252 sym
= lookup_symbol (copy
,
2253 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2254 : get_selected_block ()),
2255 VAR_NAMESPACE
, 0, &sym_symtab
);
2259 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2261 /* Arg is the name of a function */
2262 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2263 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
2266 /* Don't use the SYMBOL_LINE; if used at all it points to
2267 the line containing the parameters or thereabouts, not
2268 the first line of code. */
2270 /* We might need a canonical line spec if it is a static
2274 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2275 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2276 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2277 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2284 error ("\"%s\" is not a function", copy
);
2285 else if (SYMBOL_LINE (sym
) != 0)
2287 /* We know its line number. */
2288 values
.sals
= (struct symtab_and_line
*)
2289 xmalloc (sizeof (struct symtab_and_line
));
2291 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2292 values
.sals
[0].symtab
= sym_symtab
;
2293 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2297 /* This can happen if it is compiled with a compiler which doesn't
2298 put out line numbers for variables. */
2299 /* FIXME: Shouldn't we just set .line and .symtab to zero
2300 and return? For example, "info line foo" could print
2302 error ("Line number not known for symbol \"%s\"", copy
);
2306 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
2307 if (msymbol
!= NULL
)
2311 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2314 val
.pc
+= FUNCTION_START_OFFSET
;
2315 SKIP_PROLOGUE (val
.pc
);
2317 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof (struct symtab_and_line
));
2318 values
.sals
[0] = val
;
2323 if (!have_full_symbols () &&
2324 !have_partial_symbols () && !have_minimal_symbols ())
2325 error (no_symtab_msg
);
2327 error ("Function \"%s\" not defined.", copy
);
2328 return values
; /* for lint */
2331 struct symtabs_and_lines
2332 decode_line_spec (string
, funfirstline
)
2336 struct symtabs_and_lines sals
;
2338 error ("Empty line specification.");
2339 sals
= decode_line_1 (&string
, funfirstline
,
2340 current_source_symtab
, current_source_line
,
2343 error ("Junk at end of line specification: %s", string
);
2347 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2348 operate on (ask user if necessary).
2349 If CANONICAL is non-NULL return a corresponding array of mangled names
2350 as canonical line specs there. */
2352 static struct symtabs_and_lines
2353 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2354 struct symbol
*sym_arr
[];
2359 struct symtabs_and_lines values
, return_values
;
2364 struct cleanup
*old_chain
;
2365 char **canonical_arr
= (char **)NULL
;
2367 values
.sals
= (struct symtab_and_line
*) alloca (nelts
* sizeof(struct symtab_and_line
));
2368 return_values
.sals
= (struct symtab_and_line
*) xmalloc (nelts
* sizeof(struct symtab_and_line
));
2369 old_chain
= make_cleanup (free
, return_values
.sals
);
2373 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2374 make_cleanup (free
, canonical_arr
);
2375 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2376 *canonical
= canonical_arr
;
2380 printf_unfiltered("[0] cancel\n[1] all\n");
2383 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2385 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
2386 printf_unfiltered ("[%d] %s at %s:%d\n",
2388 SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2389 values
.sals
[i
].symtab
->filename
,
2390 values
.sals
[i
].line
);
2393 printf_unfiltered ("?HERE\n");
2397 if ((prompt
= getenv ("PS2")) == NULL
)
2401 printf_unfiltered("%s ",prompt
);
2402 gdb_flush(gdb_stdout
);
2404 args
= command_line_input ((char *) NULL
, 0, "overload-choice");
2406 if (args
== 0 || *args
== 0)
2407 error_no_arg ("one or more choice numbers");
2415 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2416 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2417 error ("Arguments must be choice numbers.");
2422 error ("cancelled");
2427 for (i
= 0; i
< nelts
; i
++)
2429 if (canonical_arr
[i
] == NULL
)
2431 symname
= SYMBOL_NAME (sym_arr
[i
]);
2432 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2436 memcpy (return_values
.sals
, values
.sals
,
2437 (nelts
* sizeof(struct symtab_and_line
)));
2438 return_values
.nelts
= nelts
;
2439 discard_cleanups (old_chain
);
2440 return return_values
;
2443 if (num
> nelts
+ 2)
2445 printf_unfiltered ("No choice number %d.\n", num
);
2450 if (values
.sals
[num
].pc
)
2454 symname
= SYMBOL_NAME (sym_arr
[num
]);
2455 make_cleanup (free
, symname
);
2456 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2458 return_values
.sals
[i
++] = values
.sals
[num
];
2459 values
.sals
[num
].pc
= 0;
2463 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2468 while (*args
== ' ' || *args
== '\t') args
++;
2470 return_values
.nelts
= i
;
2471 discard_cleanups (old_chain
);
2472 return return_values
;
2476 /* Slave routine for sources_info. Force line breaks at ,'s.
2477 NAME is the name to print and *FIRST is nonzero if this is the first
2478 name printed. Set *FIRST to zero. */
2480 output_source_filename (name
, first
)
2484 /* Table of files printed so far. Since a single source file can
2485 result in several partial symbol tables, we need to avoid printing
2486 it more than once. Note: if some of the psymtabs are read in and
2487 some are not, it gets printed both under "Source files for which
2488 symbols have been read" and "Source files for which symbols will
2489 be read in on demand". I consider this a reasonable way to deal
2490 with the situation. I'm not sure whether this can also happen for
2491 symtabs; it doesn't hurt to check. */
2492 static char **tab
= NULL
;
2493 /* Allocated size of tab in elements.
2494 Start with one 256-byte block (when using GNU malloc.c).
2495 24 is the malloc overhead when range checking is in effect. */
2496 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2497 /* Current size of tab in elements. */
2498 static int tab_cur_size
;
2505 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2509 /* Is NAME in tab? */
2510 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2511 if (STREQ (*p
, name
))
2512 /* Yes; don't print it again. */
2514 /* No; add it to tab. */
2515 if (tab_cur_size
== tab_alloc_size
)
2517 tab_alloc_size
*= 2;
2518 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2520 tab
[tab_cur_size
++] = name
;
2528 printf_filtered (", ");
2532 fputs_filtered (name
, gdb_stdout
);
2536 sources_info (ignore
, from_tty
)
2540 register struct symtab
*s
;
2541 register struct partial_symtab
*ps
;
2542 register struct objfile
*objfile
;
2545 if (!have_full_symbols () && !have_partial_symbols ())
2547 error (no_symtab_msg
);
2550 printf_filtered ("Source files for which symbols have been read in:\n\n");
2553 ALL_SYMTABS (objfile
, s
)
2555 output_source_filename (s
-> filename
, &first
);
2557 printf_filtered ("\n\n");
2559 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2562 ALL_PSYMTABS (objfile
, ps
)
2566 output_source_filename (ps
-> filename
, &first
);
2569 printf_filtered ("\n");
2572 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2573 If CLASS is zero, list all symbols except functions, type names, and
2575 If CLASS is 1, list only functions.
2576 If CLASS is 2, list only type names.
2577 If CLASS is 3, list only method names.
2579 BPT is non-zero if we should set a breakpoint at the functions
2583 list_symbols (regexp
, class, bpt
, from_tty
)
2589 register struct symtab
*s
;
2590 register struct partial_symtab
*ps
;
2591 register struct blockvector
*bv
;
2592 struct blockvector
*prev_bv
= 0;
2593 register struct block
*b
;
2595 register struct symbol
*sym
;
2596 struct partial_symbol
*psym
;
2597 struct objfile
*objfile
;
2598 struct minimal_symbol
*msymbol
;
2600 static char *classnames
[]
2601 = {"variable", "function", "type", "method"};
2602 int found_in_file
= 0;
2604 static enum minimal_symbol_type types
[]
2605 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2606 static enum minimal_symbol_type types2
[]
2607 = {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2608 static enum minimal_symbol_type types3
[]
2609 = {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2610 static enum minimal_symbol_type types4
[]
2611 = {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2612 enum minimal_symbol_type ourtype
= types
[class];
2613 enum minimal_symbol_type ourtype2
= types2
[class];
2614 enum minimal_symbol_type ourtype3
= types3
[class];
2615 enum minimal_symbol_type ourtype4
= types4
[class];
2619 /* Make sure spacing is right for C++ operators.
2620 This is just a courtesy to make the matching less sensitive
2621 to how many spaces the user leaves between 'operator'
2622 and <TYPENAME> or <OPERATOR>. */
2624 char *opname
= operator_chars (regexp
, &opend
);
2627 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2628 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2630 /* There should 1 space between 'operator' and 'TYPENAME'. */
2631 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2636 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2637 if (opname
[-1] == ' ')
2640 /* If wrong number of spaces, fix it. */
2643 char *tmp
= (char*) alloca(opend
-opname
+10);
2644 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2649 if (0 != (val
= re_comp (regexp
)))
2650 error ("Invalid regexp (%s): %s", val
, regexp
);
2653 /* Search through the partial symtabs *first* for all symbols
2654 matching the regexp. That way we don't have to reproduce all of
2655 the machinery below. */
2657 ALL_PSYMTABS (objfile
, ps
)
2659 struct partial_symbol
*bound
, *gbound
, *sbound
;
2662 if (ps
->readin
) continue;
2664 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2665 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2668 /* Go through all of the symbols stored in a partial
2669 symtab in one loop. */
2670 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2675 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2677 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2688 /* If it would match (logic taken from loop below)
2689 load the file and go on to the next one */
2690 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (psym
))
2691 && ((class == 0 && SYMBOL_CLASS (psym
) != LOC_TYPEDEF
2692 && SYMBOL_CLASS (psym
) != LOC_BLOCK
)
2693 || (class == 1 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)
2694 || (class == 2 && SYMBOL_CLASS (psym
) == LOC_TYPEDEF
)
2695 || (class == 3 && SYMBOL_CLASS (psym
) == LOC_BLOCK
)))
2697 PSYMTAB_TO_SYMTAB(ps
);
2705 /* Here, we search through the minimal symbol tables for functions
2706 and variables that match, and force their symbols to be read.
2707 This is in particular necessary for demangled variable names,
2708 which are no longer put into the partial symbol tables.
2709 The symbol will then be found during the scan of symtabs below.
2711 For functions, find_pc_symtab should succeed if we have debug info
2712 for the function, for variables we have to call lookup_symbol
2713 to determine if the variable has debug info.
2714 If the lookup fails, set found_misc so that we will rescan to print
2715 any matching symbols without debug info.
2718 if (class == 0 || class == 1)
2720 ALL_MSYMBOLS (objfile
, msymbol
)
2722 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2723 MSYMBOL_TYPE (msymbol
) == ourtype2
||
2724 MSYMBOL_TYPE (msymbol
) == ourtype3
||
2725 MSYMBOL_TYPE (msymbol
) == ourtype4
)
2727 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2729 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2732 || lookup_symbol (SYMBOL_NAME (msymbol
),
2733 (struct block
*) NULL
,
2735 0, (struct symtab
**) NULL
) == NULL
)
2743 /* Printout here so as to get after the "Reading in symbols"
2744 messages which will be generated above. */
2746 printf_filtered (regexp
2747 ? "All %ss matching regular expression \"%s\":\n"
2748 : "All defined %ss:\n",
2752 ALL_SYMTABS (objfile
, s
)
2755 bv
= BLOCKVECTOR (s
);
2756 /* Often many files share a blockvector.
2757 Scan each blockvector only once so that
2758 we don't get every symbol many times.
2759 It happens that the first symtab in the list
2760 for any given blockvector is the main file. */
2762 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2764 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2765 /* Skip the sort if this block is always sorted. */
2766 if (!BLOCK_SHOULD_SORT (b
))
2767 sort_block_syms (b
);
2768 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2771 sym
= BLOCK_SYM (b
, j
);
2772 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2773 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2774 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2775 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2776 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2777 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2778 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2782 /* Set a breakpoint here, if it's a function */
2785 /* There may be more than one function with the
2786 same name but in different files. In order to
2787 set breakpoints on all of them, we must give
2788 both the file name and the function name to
2790 Quoting the symbol name gets rid of problems
2791 with mangled symbol names that contain
2792 CPLUS_MARKER characters. */
2794 (char *) alloca (strlen (s
->filename
)
2795 + strlen (SYMBOL_NAME(sym
))
2797 strcpy (string
, s
->filename
);
2798 strcat (string
, ":'");
2799 strcat (string
, SYMBOL_NAME(sym
));
2800 strcat (string
, "'");
2801 break_command (string
, from_tty
);
2804 else if (!found_in_file
)
2806 fputs_filtered ("\nFile ", gdb_stdout
);
2807 fputs_filtered (s
->filename
, gdb_stdout
);
2808 fputs_filtered (":\n", gdb_stdout
);
2812 if (class != 2 && i
== STATIC_BLOCK
)
2813 printf_filtered ("static ");
2815 /* Typedef that is not a C++ class */
2817 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2818 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2819 /* variable, func, or typedef-that-is-c++-class */
2820 else if (class < 2 ||
2822 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2824 type_print (SYMBOL_TYPE (sym
),
2825 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2826 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2829 printf_filtered (";\n");
2833 # if 0 /* FIXME, why is this zapped out? */
2835 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2837 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2839 sprintf (buf
, " %s::", type_name_no_tag (t
));
2840 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t
, i
),
2841 buf
, name
, gdb_stdout
);
2850 /* If there are no eyes, avoid all contact. I mean, if there are
2851 no debug symbols, then print directly from the msymbol_vector. */
2853 if (found_misc
|| class != 1)
2856 ALL_MSYMBOLS (objfile
, msymbol
)
2858 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2859 MSYMBOL_TYPE (msymbol
) == ourtype2
||
2860 MSYMBOL_TYPE (msymbol
) == ourtype3
||
2861 MSYMBOL_TYPE (msymbol
) == ourtype4
)
2863 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2865 /* Functions: Look up by address. */
2867 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
2869 /* Variables/Absolutes: Look up by name */
2870 if (lookup_symbol (SYMBOL_NAME (msymbol
),
2871 (struct block
*) NULL
, VAR_NAMESPACE
,
2872 0, (struct symtab
**) NULL
) == NULL
)
2876 printf_filtered ("\nNon-debugging symbols:\n");
2879 printf_filtered (" %08lx %s\n",
2880 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
2881 SYMBOL_SOURCE_NAME (msymbol
));
2891 variables_info (regexp
, from_tty
)
2895 list_symbols (regexp
, 0, 0, from_tty
);
2899 functions_info (regexp
, from_tty
)
2903 list_symbols (regexp
, 1, 0, from_tty
);
2907 types_info (regexp
, from_tty
)
2911 list_symbols (regexp
, 2, 0, from_tty
);
2915 /* Tiemann says: "info methods was never implemented." */
2917 methods_info (regexp
)
2920 list_symbols (regexp
, 3, 0, from_tty
);
2924 /* Breakpoint all functions matching regular expression. */
2926 rbreak_command (regexp
, from_tty
)
2930 list_symbols (regexp
, 1, 1, from_tty
);
2934 /* Return Nonzero if block a is lexically nested within block b,
2935 or if a and b have the same pc range.
2936 Return zero otherwise. */
2939 struct block
*a
, *b
;
2943 return BLOCK_START (a
) >= BLOCK_START (b
)
2944 && BLOCK_END (a
) <= BLOCK_END (b
);
2948 /* Helper routine for make_symbol_completion_list. */
2950 static int return_val_size
;
2951 static int return_val_index
;
2952 static char **return_val
;
2954 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2956 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2957 /* Put only the mangled name on the list. */ \
2958 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
2959 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
2960 completion_list_add_name \
2961 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2963 completion_list_add_name \
2964 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2967 /* Test to see if the symbol specified by SYMNAME (which is already
2968 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2969 characters. If so, add it to the current completion list. */
2972 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
2982 /* clip symbols that cannot match */
2984 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
2989 /* Clip any symbol names that we've already considered. (This is a
2990 time optimization) */
2992 for (i
= 0; i
< return_val_index
; ++i
)
2994 if (STREQ (symname
, return_val
[i
]))
3000 /* We have a match for a completion, so add SYMNAME to the current list
3001 of matches. Note that the name is moved to freshly malloc'd space. */
3005 if (word
== sym_text
)
3007 new = xmalloc (strlen (symname
) + 5);
3008 strcpy (new, symname
);
3010 else if (word
> sym_text
)
3012 /* Return some portion of symname. */
3013 new = xmalloc (strlen (symname
) + 5);
3014 strcpy (new, symname
+ (word
- sym_text
));
3018 /* Return some of SYM_TEXT plus symname. */
3019 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3020 strncpy (new, word
, sym_text
- word
);
3021 new[sym_text
- word
] = '\0';
3022 strcat (new, symname
);
3025 /* Recheck for duplicates if we intend to add a modified symbol. */
3026 if (word
!= sym_text
)
3028 for (i
= 0; i
< return_val_index
; ++i
)
3030 if (STREQ (new, return_val
[i
]))
3038 if (return_val_index
+ 3 > return_val_size
)
3040 newsize
= (return_val_size
*= 2) * sizeof (char *);
3041 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3043 return_val
[return_val_index
++] = new;
3044 return_val
[return_val_index
] = NULL
;
3048 /* Return a NULL terminated array of all symbols (regardless of class) which
3049 begin by matching TEXT. If the answer is no symbols, then the return value
3050 is an array which contains only a NULL pointer.
3052 Problem: All of the symbols have to be copied because readline frees them.
3053 I'm not going to worry about this; hopefully there won't be that many. */
3056 make_symbol_completion_list (text
, word
)
3060 register struct symbol
*sym
;
3061 register struct symtab
*s
;
3062 register struct partial_symtab
*ps
;
3063 register struct minimal_symbol
*msymbol
;
3064 register struct objfile
*objfile
;
3065 register struct block
*b
, *surrounding_static_block
= 0;
3067 struct partial_symbol
*psym
;
3068 /* The symbol we are completing on. Points in same buffer as text. */
3070 /* Length of sym_text. */
3073 /* Now look for the symbol we are supposed to complete on.
3074 FIXME: This should be language-specific. */
3078 char *quote_pos
= NULL
;
3080 /* First see if this is a quoted string. */
3082 for (p
= text
; *p
!= '\0'; ++p
)
3084 if (quote_found
!= '\0')
3086 if (*p
== quote_found
)
3087 /* Found close quote. */
3089 else if (*p
== '\\' && p
[1] == quote_found
)
3090 /* A backslash followed by the quote character
3091 doesn't end the string. */
3094 else if (*p
== '\'' || *p
== '"')
3100 if (quote_found
== '\'')
3101 /* A string within single quotes can be a symbol, so complete on it. */
3102 sym_text
= quote_pos
+ 1;
3103 else if (quote_found
== '"')
3104 /* A double-quoted string is never a symbol, nor does it make sense
3105 to complete it any other way. */
3109 /* It is not a quoted string. Break it based on the characters
3110 which are in symbols. */
3113 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3122 sym_text_len
= strlen (sym_text
);
3124 return_val_size
= 100;
3125 return_val_index
= 0;
3126 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3127 return_val
[0] = NULL
;
3129 /* Look through the partial symtabs for all symbols which begin
3130 by matching SYM_TEXT. Add each one that you find to the list. */
3132 ALL_PSYMTABS (objfile
, ps
)
3134 /* If the psymtab's been read in we'll get it when we search
3135 through the blockvector. */
3136 if (ps
->readin
) continue;
3138 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3139 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3140 + ps
->n_global_syms
);
3143 /* If interrupted, then quit. */
3145 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
3148 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3149 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3150 + ps
->n_static_syms
);
3154 COMPLETION_LIST_ADD_SYMBOL (psym
, sym_text
, sym_text_len
, text
, word
);
3158 /* At this point scan through the misc symbol vectors and add each
3159 symbol you find to the list. Eventually we want to ignore
3160 anything that isn't a text symbol (everything else will be
3161 handled by the psymtab code above). */
3163 ALL_MSYMBOLS (objfile
, msymbol
)
3166 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3169 /* Search upwards from currently selected frame (so that we can
3170 complete on local vars. */
3172 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3174 if (!BLOCK_SUPERBLOCK (b
))
3176 surrounding_static_block
= b
; /* For elmin of dups */
3179 /* Also catch fields of types defined in this places which match our
3180 text string. Only complete on types visible from current context. */
3182 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3184 sym
= BLOCK_SYM (b
, i
);
3185 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3186 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3188 struct type
*t
= SYMBOL_TYPE (sym
);
3189 enum type_code c
= TYPE_CODE (t
);
3191 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3193 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3195 if (TYPE_FIELD_NAME (t
, j
))
3197 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3198 sym_text
, sym_text_len
, text
, word
);
3206 /* Go through the symtabs and check the externs and statics for
3207 symbols which match. */
3209 ALL_SYMTABS (objfile
, s
)
3212 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3213 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3215 sym
= BLOCK_SYM (b
, i
);
3216 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3220 ALL_SYMTABS (objfile
, s
)
3223 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3224 /* Don't do this block twice. */
3225 if (b
== surrounding_static_block
) continue;
3226 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3228 sym
= BLOCK_SYM (b
, i
);
3229 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3233 return (return_val
);
3238 _initialize_symtab ()
3240 add_info ("variables", variables_info
,
3241 "All global and static variable names, or those matching REGEXP.");
3242 add_info ("functions", functions_info
,
3243 "All function names, or those matching REGEXP.");
3245 /* FIXME: This command has at least the following problems:
3246 1. It prints builtin types (in a very strange and confusing fashion).
3247 2. It doesn't print right, e.g. with
3248 typedef struct foo *FOO
3249 type_print prints "FOO" when we want to make it (in this situation)
3250 print "struct foo *".
3251 I also think "ptype" or "whatis" is more likely to be useful (but if
3252 there is much disagreement "info types" can be fixed). */
3253 add_info ("types", types_info
,
3254 "All type names, or those matching REGEXP.");
3257 add_info ("methods", methods_info
,
3258 "All method names, or those matching REGEXP::REGEXP.\n\
3259 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3260 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3263 add_info ("sources", sources_info
,
3264 "Source files in the program.");
3266 add_com ("rbreak", no_class
, rbreak_command
,
3267 "Set a breakpoint for all functions matching REGEXP.");
3269 /* Initialize the one built-in type that isn't language dependent... */
3270 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3271 "<unknown type>", (struct objfile
*) NULL
);