1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1997
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 #include "call-cmds.h"
32 #include "gnu-regex.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, namespace_enum
));
89 static struct symtab
*
90 lookup_symtab_1
PARAMS ((char *));
93 cplusplus_hint
PARAMS ((char *));
97 /* The single non-language-specific builtin type */
98 struct type
*builtin_type_error
;
100 /* Block in which the most recently searched-for symbol was found.
101 Might be better to make this a parameter to lookup_symbol and
104 const struct block
*block_found
;
106 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
108 /* While the C++ support is still in flux, issue a possibly helpful hint on
109 using the new command completion feature on single quoted demangled C++
110 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
113 cplusplus_hint (name
)
116 while (*name
== '\'')
118 printf_filtered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
119 printf_filtered ("(Note leading single quote.)\n");
122 /* Check for a symtab of a specific name; first in symtabs, then in
123 psymtabs. *If* there is no '/' in the name, a match after a '/'
124 in the symtab filename will also work. */
126 static struct symtab
*
127 lookup_symtab_1 (name
)
130 register struct symtab
*s
;
131 register struct partial_symtab
*ps
;
132 register char *slash
;
133 register struct objfile
*objfile
;
137 /* First, search for an exact match */
139 ALL_SYMTABS (objfile
, s
)
140 if (STREQ (name
, s
->filename
))
143 slash
= strchr (name
, '/');
145 /* Now, search for a matching tail (only if name doesn't have any dirs) */
148 ALL_SYMTABS (objfile
, s
)
150 char *p
= s
-> filename
;
151 char *tail
= strrchr (p
, '/');
160 /* Same search rules as above apply here, but now we look thru the
163 ps
= lookup_partial_symtab (name
);
168 error ("Internal: readin %s pst for `%s' found when no symtab found.",
169 ps
-> filename
, name
);
171 s
= PSYMTAB_TO_SYMTAB (ps
);
176 /* At this point, we have located the psymtab for this file, but
177 the conversion to a symtab has failed. This usually happens
178 when we are looking up an include file. In this case,
179 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
180 been created. So, we need to run through the symtabs again in
181 order to find the file.
182 XXX - This is a crock, and should be fixed inside of the the
183 symbol parsing routines. */
187 /* Lookup the symbol table of a source file named NAME. Try a couple
188 of variations if the first lookup doesn't work. */
194 register struct symtab
*s
;
199 s
= lookup_symtab_1 (name
);
203 /* This screws c-exp.y:yylex if there is both a type "tree" and a symtab
206 /* If name not found as specified, see if adding ".c" helps. */
207 /* Why is this? Is it just a user convenience? (If so, it's pretty
208 questionable in the presence of C++, FORTRAN, etc.). It's not in
211 copy
= (char *) alloca (strlen (name
) + 3);
214 s
= lookup_symtab_1 (copy
);
218 /* We didn't find anything; die. */
222 /* Lookup the partial symbol table of a source file named NAME.
223 *If* there is no '/' in the name, a match after a '/'
224 in the psymtab filename will also work. */
226 struct partial_symtab
*
227 lookup_partial_symtab (name
)
230 register struct partial_symtab
*pst
;
231 register struct objfile
*objfile
;
233 ALL_PSYMTABS (objfile
, pst
)
235 if (STREQ (name
, pst
-> filename
))
241 /* Now, search for a matching tail (only if name doesn't have any dirs) */
243 if (!strchr (name
, '/'))
244 ALL_PSYMTABS (objfile
, pst
)
246 char *p
= pst
-> filename
;
247 char *tail
= strrchr (p
, '/');
259 /* Demangle a GDB method stub type.
260 Note that this function is g++ specific. */
263 gdb_mangle_name (type
, i
, j
)
267 int mangled_name_len
;
269 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
270 struct fn_field
*method
= &f
[j
];
271 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
272 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
273 char *newname
= type_name_no_tag (type
);
275 /* Does the form of physname indicate that it is the full mangled name
276 of a constructor (not just the args)? */
277 int is_full_physname_constructor
;
280 int is_destructor
= DESTRUCTOR_PREFIX_P (physname
);
281 /* Need a new type prefix. */
282 char *const_prefix
= method
->is_const
? "C" : "";
283 char *volatile_prefix
= method
->is_volatile
? "V" : "";
285 int len
= (newname
== NULL
? 0 : strlen (newname
));
287 is_full_physname_constructor
=
288 ((physname
[0]=='_' && physname
[1]=='_' &&
289 (isdigit(physname
[2]) || physname
[2]=='Q' || physname
[2]=='t'))
290 || (strncmp(physname
, "__ct", 4) == 0));
293 is_full_physname_constructor
|| (newname
&& STREQ(field_name
, newname
));
296 is_destructor
= (strncmp(physname
, "__dt", 4) == 0);
298 if (is_destructor
|| is_full_physname_constructor
)
300 mangled_name
= (char*) xmalloc(strlen(physname
)+1);
301 strcpy(mangled_name
, physname
);
307 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
309 else if (physname
[0] == 't' || physname
[0] == 'Q')
311 /* The physname for template and qualified methods already includes
313 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
319 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
321 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
326 /* Only needed for GNU-mangled names. ANSI-mangled names
327 work with the normal mechanisms. */
328 if (OPNAME_PREFIX_P (field_name
))
330 const char *opname
= cplus_mangle_opname (field_name
+ 3, 0);
332 error ("No mangling for \"%s\"", field_name
);
333 mangled_name_len
+= strlen (opname
);
334 mangled_name
= (char *)xmalloc (mangled_name_len
);
336 strncpy (mangled_name
, field_name
, 3);
337 mangled_name
[3] = '\0';
338 strcat (mangled_name
, opname
);
342 mangled_name
= (char *)xmalloc (mangled_name_len
);
344 mangled_name
[0] = '\0';
346 strcpy (mangled_name
, field_name
);
348 strcat (mangled_name
, buf
);
349 /* If the class doesn't have a name, i.e. newname NULL, then we just
350 mangle it using 0 for the length of the class. Thus it gets mangled
351 as something starting with `::' rather than `classname::'. */
353 strcat (mangled_name
, newname
);
355 strcat (mangled_name
, physname
);
356 return (mangled_name
);
361 struct partial_symbol
* fixup_psymbol_section
PARAMS ((struct partial_symbol
*,
365 /* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
367 struct partial_symtab
*
368 find_pc_sect_psymtab (pc
, section
)
372 register struct partial_symtab
*pst
;
373 register struct objfile
*objfile
;
375 ALL_PSYMTABS (objfile
, pst
)
377 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
379 struct minimal_symbol
*msymbol
;
380 struct partial_symtab
*tpst
;
382 /* An objfile that has its functions reordered might have
383 many partial symbol tables containing the PC, but
384 we want the partial symbol table that contains the
385 function containing the PC. */
386 if (!(objfile
->flags
& OBJF_REORDERED
) &&
387 section
== 0) /* can't validate section this way */
390 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
394 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
396 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
398 struct partial_symbol
*p
;
400 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
402 && SYMBOL_VALUE_ADDRESS(p
)
403 == SYMBOL_VALUE_ADDRESS (msymbol
))
413 /* Find which partial symtab contains PC. Return 0 if none.
414 Backward compatibility, no section */
416 struct partial_symtab
*
420 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
423 /* Find which partial symbol within a psymtab matches PC and SECTION.
424 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
426 struct partial_symbol
*
427 find_pc_sect_psymbol (psymtab
, pc
, section
)
428 struct partial_symtab
*psymtab
;
432 struct partial_symbol
*best
= NULL
, *p
, **pp
;
436 psymtab
= find_pc_sect_psymtab (pc
, section
);
440 best_pc
= psymtab
->textlow
- 1;
442 /* Search the global symbols as well as the static symbols, so that
443 find_pc_partial_function doesn't use a minimal symbol and thus
444 cache a bad endaddr. */
445 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
446 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
447 < psymtab
->n_global_syms
);
451 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
452 && SYMBOL_CLASS (p
) == LOC_BLOCK
453 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
454 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
456 if (section
) /* match on a specific section */
458 fixup_psymbol_section (p
, psymtab
->objfile
);
459 if (SYMBOL_BFD_SECTION (p
) != section
)
462 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
466 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
467 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
468 < psymtab
->n_static_syms
);
472 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
473 && SYMBOL_CLASS (p
) == LOC_BLOCK
474 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
475 && SYMBOL_VALUE_ADDRESS (p
) > best_pc
)
477 if (section
) /* match on a specific section */
479 fixup_psymbol_section (p
, psymtab
->objfile
);
480 if (SYMBOL_BFD_SECTION (p
) != section
)
483 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
487 if (best_pc
== psymtab
->textlow
- 1)
492 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
493 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
495 struct partial_symbol
*
496 find_pc_psymbol (psymtab
, pc
)
497 struct partial_symtab
*psymtab
;
500 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
503 /* Debug symbols usually don't have section information. We need to dig that
504 out of the minimal symbols and stash that in the debug symbol. */
507 fixup_section (ginfo
, objfile
)
508 struct general_symbol_info
*ginfo
;
509 struct objfile
*objfile
;
511 struct minimal_symbol
*msym
;
512 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
515 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
519 fixup_symbol_section (sym
, objfile
)
521 struct objfile
*objfile
;
523 struct minimal_symbol
*msym
;
528 if (SYMBOL_BFD_SECTION (sym
))
531 fixup_section (&sym
->ginfo
, objfile
);
536 struct partial_symbol
*
537 fixup_psymbol_section (psym
, objfile
)
538 struct partial_symbol
*psym
;
539 struct objfile
*objfile
;
541 struct minimal_symbol
*msym
;
546 if (SYMBOL_BFD_SECTION (psym
))
549 fixup_section (&psym
->ginfo
, objfile
);
554 /* Find the definition for a specified symbol name NAME
555 in namespace NAMESPACE, visible from lexical block BLOCK.
556 Returns the struct symbol pointer, or zero if no symbol is found.
557 If SYMTAB is non-NULL, store the symbol table in which the
558 symbol was found there, or NULL if not found.
559 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
560 NAME is a field of the current implied argument `this'. If so set
561 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
562 BLOCK_FOUND is set to the block in which NAME is found (in the case of
563 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
565 /* This function has a bunch of loops in it and it would seem to be
566 attractive to put in some QUIT's (though I'm not really sure
567 whether it can run long enough to be really important). But there
568 are a few calls for which it would appear to be bad news to quit
569 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c, and
570 nindy_frame_chain_valid in nindy-tdep.c. (Note that there is C++
571 code below which can error(), but that probably doesn't affect
572 these calls since they are looking for a known variable and thus
573 can probably assume it will never hit the C++ code). */
576 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
578 register const struct block
*block
;
579 const namespace_enum
namespace;
580 int *is_a_field_of_this
;
581 struct symtab
**symtab
;
583 register struct symbol
*sym
;
584 register struct symtab
*s
= NULL
;
585 register struct partial_symtab
*ps
;
586 struct blockvector
*bv
;
587 register struct objfile
*objfile
= NULL
;
588 register struct block
*b
;
589 register struct minimal_symbol
*msymbol
;
591 /* Search specified block and its superiors. */
595 sym
= lookup_block_symbol (block
, name
, namespace);
601 /* Search the list of symtabs for one which contains the
602 address of the start of this block. */
603 ALL_SYMTABS (objfile
, s
)
605 bv
= BLOCKVECTOR (s
);
606 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
607 if (BLOCK_START (b
) <= BLOCK_START (block
)
608 && BLOCK_END (b
) > BLOCK_START (block
))
615 return fixup_symbol_section (sym
, objfile
);
617 block
= BLOCK_SUPERBLOCK (block
);
620 /* FIXME: this code is never executed--block is always NULL at this
621 point. What is it trying to do, anyway? We already should have
622 checked the STATIC_BLOCK above (it is the superblock of top-level
623 blocks). Why is VAR_NAMESPACE special-cased? */
624 /* Don't need to mess with the psymtabs; if we have a block,
625 that file is read in. If we don't, then we deal later with
626 all the psymtab stuff that needs checking. */
627 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
630 /* Find the right symtab. */
631 ALL_SYMTABS (objfile
, s
)
633 bv
= BLOCKVECTOR (s
);
634 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
635 if (BLOCK_START (b
) <= BLOCK_START (block
)
636 && BLOCK_END (b
) > BLOCK_START (block
))
638 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
644 return fixup_symbol_section (sym
, objfile
);
651 /* C++: If requested to do so by the caller,
652 check to see if NAME is a field of `this'. */
653 if (is_a_field_of_this
)
655 struct value
*v
= value_of_this (0);
657 *is_a_field_of_this
= 0;
658 if (v
&& check_field (v
, name
))
660 *is_a_field_of_this
= 1;
667 /* Now search all global blocks. Do the symtab's first, then
668 check the psymtab's */
670 ALL_SYMTABS (objfile
, s
)
672 bv
= BLOCKVECTOR (s
);
673 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
674 sym
= lookup_block_symbol (block
, name
, namespace);
680 return fixup_symbol_section (sym
, objfile
);
684 /* Check for the possibility of the symbol being a function or
685 a mangled variable that is stored in one of the minimal symbol tables.
686 Eventually, all global symbols might be resolved in this way. */
688 if (namespace == VAR_NAMESPACE
)
690 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
693 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
694 SYMBOL_BFD_SECTION (msymbol
));
697 /* This is a function which has a symtab for its address. */
698 bv
= BLOCKVECTOR (s
);
699 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
700 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
702 /* We kept static functions in minimal symbol table as well as
703 in static scope. We want to find them in the symbol table. */
705 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
706 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
710 /* sym == 0 if symbol was found in the minimal symbol table
711 but not in the symtab.
712 Return 0 to use the msymbol definition of "foo_".
714 This happens for Fortran "foo_" symbols,
715 which are "foo" in the symtab.
717 This can also happen if "asm" is used to make a
718 regular symbol but not a debugging symbol, e.g.
725 return fixup_symbol_section (sym
, objfile
);
727 else if (MSYMBOL_TYPE (msymbol
) != mst_text
728 && MSYMBOL_TYPE (msymbol
) != mst_file_text
729 && !STREQ (name
, SYMBOL_NAME (msymbol
)))
731 /* This is a mangled variable, look it up by its
733 return lookup_symbol (SYMBOL_NAME (msymbol
), block
,
734 namespace, is_a_field_of_this
, symtab
);
736 /* There are no debug symbols for this file, or we are looking
737 for an unmangled variable.
738 Try to find a matching static symbol below. */
742 ALL_PSYMTABS (objfile
, ps
)
744 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
746 s
= PSYMTAB_TO_SYMTAB(ps
);
747 bv
= BLOCKVECTOR (s
);
748 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
749 sym
= lookup_block_symbol (block
, name
, namespace);
751 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
754 return fixup_symbol_section (sym
, objfile
);
758 /* Now search all per-file blocks.
759 Not strictly correct, but more useful than an error.
760 Do the symtabs first, then check the psymtabs */
762 ALL_SYMTABS (objfile
, s
)
764 bv
= BLOCKVECTOR (s
);
765 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
766 sym
= lookup_block_symbol (block
, name
, namespace);
772 return fixup_symbol_section (sym
, objfile
);
776 ALL_PSYMTABS (objfile
, ps
)
778 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
780 s
= PSYMTAB_TO_SYMTAB(ps
);
781 bv
= BLOCKVECTOR (s
);
782 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
783 sym
= lookup_block_symbol (block
, name
, namespace);
785 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
788 return fixup_symbol_section (sym
, objfile
);
797 /* Look, in partial_symtab PST, for symbol NAME. Check the global
798 symbols if GLOBAL, the static symbols if not */
800 static struct partial_symbol
*
801 lookup_partial_symbol (pst
, name
, global
, namespace)
802 struct partial_symtab
*pst
;
805 namespace_enum
namespace;
807 struct partial_symbol
**start
, **psym
;
808 struct partial_symbol
**top
, **bottom
, **center
;
809 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
810 int do_linear_search
= 1;
818 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
819 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
821 if (global
) /* This means we can use a binary search. */
823 do_linear_search
= 0;
825 /* Binary search. This search is guaranteed to end with center
826 pointing at the earliest partial symbol with the correct
827 name. At that point *all* partial symbols with that name
828 will be checked against the correct namespace. */
831 top
= start
+ length
- 1;
834 center
= bottom
+ (top
- bottom
) / 2;
837 if (!do_linear_search
&& SYMBOL_LANGUAGE (*center
) == language_cplus
)
839 do_linear_search
= 1;
841 if (STRCMP (SYMBOL_NAME (*center
), name
) >= 0)
850 if (!(top
== bottom
))
852 while (STREQ (SYMBOL_NAME (*top
), name
))
854 if (SYMBOL_NAMESPACE (*top
) == namespace)
862 /* Can't use a binary search or else we found during the binary search that
863 we should also do a linear search. */
865 if (do_linear_search
)
867 for (psym
= start
; psym
< start
+ length
; psym
++)
869 if (namespace == SYMBOL_NAMESPACE (*psym
))
871 if (SYMBOL_MATCHES_NAME (*psym
, name
))
882 /* Find the psymtab containing main(). */
883 /* FIXME: What about languages without main() or specially linked
884 executables that have no main() ? */
886 struct partial_symtab
*
889 register struct partial_symtab
*pst
;
890 register struct objfile
*objfile
;
892 ALL_PSYMTABS (objfile
, pst
)
894 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
902 /* Search BLOCK for symbol NAME in NAMESPACE.
904 Note that if NAME is the demangled form of a C++ symbol, we will fail
905 to find a match during the binary search of the non-encoded names, but
906 for now we don't worry about the slight inefficiency of looking for
907 a match we'll never find, since it will go pretty quick. Once the
908 binary search terminates, we drop through and do a straight linear
909 search on the symbols. Each symbol which is marked as being a C++
910 symbol (language_cplus set) has both the encoded and non-encoded names
911 tested for a match. */
914 lookup_block_symbol (block
, name
, namespace)
915 register const struct block
*block
;
917 const namespace_enum
namespace;
919 register int bot
, top
, inc
;
920 register struct symbol
*sym
;
921 register struct symbol
*sym_found
= NULL
;
922 register int do_linear_search
= 1;
924 /* If the blocks's symbols were sorted, start with a binary search. */
926 if (BLOCK_SHOULD_SORT (block
))
928 /* Reset the linear search flag so if the binary search fails, we
929 won't do the linear search once unless we find some reason to
930 do so, such as finding a C++ symbol during the binary search.
931 Note that for C++ modules, ALL the symbols in a block should
932 end up marked as C++ symbols. */
934 do_linear_search
= 0;
935 top
= BLOCK_NSYMS (block
);
938 /* Advance BOT to not far before the first symbol whose name is NAME. */
942 inc
= (top
- bot
+ 1);
943 /* No need to keep binary searching for the last few bits worth. */
948 inc
= (inc
>> 1) + bot
;
949 sym
= BLOCK_SYM (block
, inc
);
950 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
952 do_linear_search
= 1;
954 if (SYMBOL_NAME (sym
)[0] < name
[0])
958 else if (SYMBOL_NAME (sym
)[0] > name
[0])
962 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
972 /* Now scan forward until we run out of symbols, find one whose
973 name is greater than NAME, or find one we want. If there is
974 more than one symbol with the right name and namespace, we
975 return the first one; I believe it is now impossible for us
976 to encounter two symbols with the same name and namespace
977 here, because blocks containing argument symbols are no
980 top
= BLOCK_NSYMS (block
);
983 sym
= BLOCK_SYM (block
, bot
);
984 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
987 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
989 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
1001 /* Here if block isn't sorted, or we fail to find a match during the
1002 binary search above. If during the binary search above, we find a
1003 symbol which is a C++ symbol, then we have re-enabled the linear
1004 search flag which was reset when starting the binary search.
1006 This loop is equivalent to the loop above, but hacked greatly for speed.
1008 Note that parameter symbols do not always show up last in the
1009 list; this loop makes sure to take anything else other than
1010 parameter symbols first; it only uses parameter symbols as a
1011 last resort. Note that this only takes up extra computation
1014 if (do_linear_search
)
1016 top
= BLOCK_NSYMS (block
);
1020 sym
= BLOCK_SYM (block
, bot
);
1021 if (SYMBOL_NAMESPACE (sym
) == namespace &&
1022 SYMBOL_MATCHES_NAME (sym
, name
))
1025 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1026 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1027 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1028 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1029 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1030 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
1038 return (sym_found
); /* Will be NULL if not found. */
1042 /* Return the symbol for the function which contains a specified
1043 lexical block, described by a struct block BL. */
1049 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1050 bl
= BLOCK_SUPERBLOCK (bl
);
1052 return BLOCK_FUNCTION (bl
);
1055 /* Find the symtab associated with PC and SECTION. Look through the
1056 psymtabs and read in another symtab if necessary. */
1059 find_pc_sect_symtab (pc
, section
)
1063 register struct block
*b
;
1064 struct blockvector
*bv
;
1065 register struct symtab
*s
= NULL
;
1066 register struct symtab
*best_s
= NULL
;
1067 register struct partial_symtab
*ps
;
1068 register struct objfile
*objfile
;
1071 /* Search all symtabs for the one whose file contains our address, and which
1072 is the smallest of all the ones containing the address. This is designed
1073 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1074 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1075 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1077 This happens for native ecoff format, where code from included files
1078 gets its own symtab. The symtab for the included file should have
1079 been read in already via the dependency mechanism.
1080 It might be swifter to create several symtabs with the same name
1081 like xcoff does (I'm not sure).
1083 It also happens for objfiles that have their functions reordered.
1084 For these, the symtab we are looking for is not necessarily read in. */
1086 ALL_SYMTABS (objfile
, s
)
1088 bv
= BLOCKVECTOR (s
);
1089 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1090 if (BLOCK_START (b
) <= pc
1091 && BLOCK_END (b
) > pc
1093 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1095 /* For an objfile that has its functions reordered,
1096 find_pc_psymtab will find the proper partial symbol table
1097 and we simply return its corresponding symtab. */
1098 /* In order to better support objfiles that contain both
1099 stabs and coff debugging info, we continue on if a psymtab
1101 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1103 ps
= find_pc_sect_psymtab (pc
, section
);
1105 return PSYMTAB_TO_SYMTAB (ps
);
1111 for (i
= 0; i
< b
->nsyms
; i
++)
1113 fixup_symbol_section (b
->sym
[i
], objfile
);
1114 if (section
== SYMBOL_BFD_SECTION (b
->sym
[i
]))
1118 continue; /* no symbol in this symtab matches section */
1120 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1129 ps
= find_pc_sect_psymtab (pc
, section
);
1133 /* Might want to error() here (in case symtab is corrupt and
1134 will cause a core dump), but maybe we can successfully
1135 continue, so let's not. */
1136 /* FIXME-32x64: assumes pc fits in a long */
1138 (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n",
1139 (unsigned long) pc
);
1140 s
= PSYMTAB_TO_SYMTAB (ps
);
1145 /* Find the symtab associated with PC. Look through the psymtabs and
1146 read in another symtab if necessary. Backward compatibility, no section */
1152 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
1158 /* Find the closest symbol value (of any sort -- function or variable)
1159 for a given address value. Slow but complete. (currently unused,
1160 mainly because it is too slow. We could fix it if each symtab and
1161 psymtab had contained in it the addresses ranges of each of its
1162 sections, which also would be required to make things like "info
1163 line *0x2345" cause psymtabs to be converted to symtabs). */
1166 find_addr_symbol (addr
, symtabp
, symaddrp
)
1168 struct symtab
**symtabp
;
1169 CORE_ADDR
*symaddrp
;
1171 struct symtab
*symtab
, *best_symtab
;
1172 struct objfile
*objfile
;
1173 register int bot
, top
;
1174 register struct symbol
*sym
;
1175 register CORE_ADDR sym_addr
;
1176 struct block
*block
;
1179 /* Info on best symbol seen so far */
1181 register CORE_ADDR best_sym_addr
= 0;
1182 struct symbol
*best_sym
= 0;
1184 /* FIXME -- we should pull in all the psymtabs, too! */
1185 ALL_SYMTABS (objfile
, symtab
)
1187 /* Search the global and static blocks in this symtab for
1188 the closest symbol-address to the desired address. */
1190 for (blocknum
= GLOBAL_BLOCK
; blocknum
<= STATIC_BLOCK
; blocknum
++)
1193 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), blocknum
);
1194 top
= BLOCK_NSYMS (block
);
1195 for (bot
= 0; bot
< top
; bot
++)
1197 sym
= BLOCK_SYM (block
, bot
);
1198 switch (SYMBOL_CLASS (sym
))
1202 sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1206 sym_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1213 if (sym_addr
<= addr
)
1214 if (sym_addr
> best_sym_addr
)
1216 /* Quit if we found an exact match. */
1218 best_sym_addr
= sym_addr
;
1219 best_symtab
= symtab
;
1220 if (sym_addr
== addr
)
1229 *symtabp
= best_symtab
;
1231 *symaddrp
= best_sym_addr
;
1236 /* Find the source file and line number for a given PC value and section.
1237 Return a structure containing a symtab pointer, a line number,
1238 and a pc range for the entire source line.
1239 The value's .pc field is NOT the specified pc.
1240 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1241 use the line that ends there. Otherwise, in that case, the line
1242 that begins there is used. */
1244 /* The big complication here is that a line may start in one file, and end just
1245 before the start of another file. This usually occurs when you #include
1246 code in the middle of a subroutine. To properly find the end of a line's PC
1247 range, we must search all symtabs associated with this compilation unit, and
1248 find the one whose first PC is closer than that of the next line in this
1251 /* If it's worth the effort, we could be using a binary search. */
1253 struct symtab_and_line
1254 find_pc_sect_line (pc
, section
, notcurrent
)
1256 struct sec
*section
;
1260 register struct linetable
*l
;
1263 register struct linetable_entry
*item
;
1264 struct symtab_and_line val
;
1265 struct blockvector
*bv
;
1267 /* Info on best line seen so far, and where it starts, and its file. */
1269 struct linetable_entry
*best
= NULL
;
1270 CORE_ADDR best_end
= 0;
1271 struct symtab
*best_symtab
= 0;
1273 /* Store here the first line number
1274 of a file which contains the line at the smallest pc after PC.
1275 If we don't find a line whose range contains PC,
1276 we will use a line one less than this,
1277 with a range from the start of that file to the first line's pc. */
1278 struct linetable_entry
*alt
= NULL
;
1279 struct symtab
*alt_symtab
= 0;
1281 /* Info on best line seen in this file. */
1283 struct linetable_entry
*prev
;
1285 /* If this pc is not from the current frame,
1286 it is the address of the end of a call instruction.
1287 Quite likely that is the start of the following statement.
1288 But what we want is the statement containing the instruction.
1289 Fudge the pc to make sure we get that. */
1291 INIT_SAL (&val
); /* initialize to zeroes */
1296 s
= find_pc_sect_symtab (pc
, section
);
1303 bv
= BLOCKVECTOR (s
);
1305 /* Look at all the symtabs that share this blockvector.
1306 They all have the same apriori range, that we found was right;
1307 but they have different line tables. */
1309 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1311 /* Find the best line in this symtab. */
1318 /* I think len can be zero if the symtab lacks line numbers
1319 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1320 I'm not sure which, and maybe it depends on the symbol
1326 item
= l
->item
; /* Get first line info */
1328 /* Is this file's first line closer than the first lines of other files?
1329 If so, record this file, and its first line, as best alternate. */
1330 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1336 for (i
= 0; i
< len
; i
++, item
++)
1338 /* Leave prev pointing to the linetable entry for the last line
1339 that started at or before PC. */
1346 /* At this point, prev points at the line whose start addr is <= pc, and
1347 item points at the next line. If we ran off the end of the linetable
1348 (pc >= start of the last line), then prev == item. If pc < start of
1349 the first line, prev will not be set. */
1351 /* Is this file's best line closer than the best in the other files?
1352 If so, record this file, and its best line, as best so far. */
1354 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1358 /* If another line is in the linetable, and its PC is closer
1359 than the best_end we currently have, take it as best_end. */
1360 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1361 best_end
= item
->pc
;
1368 { /* If we didn't find any line # info, just
1374 val
.symtab
= alt_symtab
;
1375 val
.line
= alt
->line
- 1;
1377 /* Don't return line 0, that means that we didn't find the line. */
1378 if (val
.line
== 0) ++val
.line
;
1380 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1386 val
.symtab
= best_symtab
;
1387 val
.line
= best
->line
;
1389 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1394 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1396 val
.section
= section
;
1400 /* Backward compatibility (no section) */
1402 struct symtab_and_line
1403 find_pc_line (pc
, notcurrent
)
1409 section
= find_pc_overlay (pc
);
1410 if (pc_in_unmapped_range (pc
, section
))
1411 pc
= overlay_mapped_address (pc
, section
);
1412 return find_pc_sect_line (pc
, section
, notcurrent
);
1416 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1419 /* Find line number LINE in any symtab whose name is the same as
1422 If found, return 1, set *LINETABLE to the linetable in which it was
1423 found, set *INDEX to the index in the linetable of the best entry
1424 found, and set *EXACT_MATCH nonzero if the value returned is an
1427 If not found, return 0. */
1430 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1431 struct symtab
*symtab
;
1433 struct linetable
**linetable
;
1439 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1443 struct linetable
*best_linetable
;
1445 /* First try looking it up in the given symtab. */
1446 best_linetable
= LINETABLE (symtab
);
1447 best_index
= find_line_common (best_linetable
, line
, &exact
);
1448 if (best_index
< 0 || !exact
)
1450 /* Didn't find an exact match. So we better keep looking for
1451 another symtab with the same name. In the case of xcoff,
1452 multiple csects for one source file (produced by IBM's FORTRAN
1453 compiler) produce multiple symtabs (this is unavoidable
1454 assuming csects can be at arbitrary places in memory and that
1455 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1457 /* BEST is the smallest linenumber > LINE so far seen,
1458 or 0 if none has been seen so far.
1459 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1462 struct objfile
*objfile
;
1465 if (best_index
>= 0)
1466 best
= best_linetable
->item
[best_index
].line
;
1470 ALL_SYMTABS (objfile
, s
)
1472 struct linetable
*l
;
1475 if (!STREQ (symtab
->filename
, s
->filename
))
1478 ind
= find_line_common (l
, line
, &exact
);
1487 if (best
== 0 || l
->item
[ind
].line
< best
)
1489 best
= l
->item
[ind
].line
;
1501 *index
= best_index
;
1503 *linetable
= best_linetable
;
1505 *exact_match
= exact
;
1509 /* Find the PC value for a given source file and line number.
1510 Returns zero for invalid line number.
1511 The source file is specified with a struct symtab. */
1514 find_line_pc (symtab
, line
)
1515 struct symtab
*symtab
;
1518 struct linetable
*l
;
1523 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1524 return l
->item
[ind
].pc
;
1529 /* Find the range of pc values in a line.
1530 Store the starting pc of the line into *STARTPTR
1531 and the ending pc (start of next line) into *ENDPTR.
1532 Returns 1 to indicate success.
1533 Returns 0 if could not find the specified line. */
1536 find_line_pc_range (sal
, startptr
, endptr
)
1537 struct symtab_and_line sal
;
1538 CORE_ADDR
*startptr
, *endptr
;
1540 CORE_ADDR startaddr
;
1541 struct symtab_and_line found_sal
;
1546 startaddr
= find_line_pc (sal
.symtab
, sal
.line
);
1551 /* This whole function is based on address. For example, if line 10 has
1552 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1553 "info line *0x123" should say the line goes from 0x100 to 0x200
1554 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1555 This also insures that we never give a range like "starts at 0x134
1556 and ends at 0x12c". */
1558 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
1559 if (found_sal
.line
!= sal
.line
)
1561 /* The specified line (sal) has zero bytes. */
1562 *startptr
= found_sal
.pc
;
1563 *endptr
= found_sal
.pc
;
1567 *startptr
= found_sal
.pc
;
1568 *endptr
= found_sal
.end
;
1573 /* Given a line table and a line number, return the index into the line
1574 table for the pc of the nearest line whose number is >= the specified one.
1575 Return -1 if none is found. The value is >= 0 if it is an index.
1577 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1580 find_line_common (l
, lineno
, exact_match
)
1581 register struct linetable
*l
;
1582 register int lineno
;
1588 /* BEST is the smallest linenumber > LINENO so far seen,
1589 or 0 if none has been seen so far.
1590 BEST_INDEX identifies the item for it. */
1592 int best_index
= -1;
1601 for (i
= 0; i
< len
; i
++)
1603 register struct linetable_entry
*item
= &(l
->item
[i
]);
1605 if (item
->line
== lineno
)
1607 /* Return the first (lowest address) entry which matches. */
1612 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1619 /* If we got here, we didn't get an exact match. */
1626 find_pc_line_pc_range (pc
, startptr
, endptr
)
1628 CORE_ADDR
*startptr
, *endptr
;
1630 struct symtab_and_line sal
;
1631 sal
= find_pc_line (pc
, 0);
1634 return sal
.symtab
!= 0;
1637 /* Given a function symbol SYM, find the symtab and line for the start
1639 If the argument FUNFIRSTLINE is nonzero, we want the first line
1640 of real code inside the function. */
1642 static struct symtab_and_line
1643 find_function_start_sal
PARAMS ((struct symbol
*sym
, int));
1645 static struct symtab_and_line
1646 find_function_start_sal (sym
, funfirstline
)
1651 struct symtab_and_line sal
;
1653 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1654 fixup_symbol_section (sym
, NULL
);
1656 { /* skip "first line" of function (which is actually its prologue) */
1657 asection
*section
= SYMBOL_BFD_SECTION (sym
);
1658 /* If function is in an unmapped overlay, use its unmapped LMA
1659 address, so that SKIP_PROLOGUE has something unique to work on */
1660 if (section_is_overlay (section
) &&
1661 !section_is_mapped (section
))
1662 pc
= overlay_unmapped_address (pc
, section
);
1664 pc
+= FUNCTION_START_OFFSET
;
1667 /* For overlays, map pc back into its mapped VMA range */
1668 pc
= overlay_mapped_address (pc
, section
);
1670 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
1672 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1673 /* Convex: no need to suppress code on first line, if any */
1676 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1677 line is still part of the same function. */
1679 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
1680 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1682 /* First pc of next line */
1684 /* Recalculate the line number (might not be N+1). */
1685 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
1693 /* If P is of the form "operator[ \t]+..." where `...' is
1694 some legitimate operator text, return a pointer to the
1695 beginning of the substring of the operator text.
1696 Otherwise, return "". */
1698 operator_chars (p
, end
)
1703 if (strncmp (p
, "operator", 8))
1707 /* Don't get faked out by `operator' being part of a longer
1709 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1712 /* Allow some whitespace between `operator' and the operator symbol. */
1713 while (*p
== ' ' || *p
== '\t')
1716 /* Recognize 'operator TYPENAME'. */
1718 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1720 register char *q
= p
+1;
1721 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1746 if (p
[1] == '=' || p
[1] == p
[0])
1757 error ("`operator ()' must be specified without whitespace in `()'");
1762 error ("`operator ?:' must be specified without whitespace in `?:'");
1767 error ("`operator []' must be specified without whitespace in `[]'");
1771 error ("`operator %s' not supported", p
);
1778 /* Return the number of methods described for TYPE, including the
1779 methods from types it derives from. This can't be done in the symbol
1780 reader because the type of the baseclass might still be stubbed
1781 when the definition of the derived class is parsed. */
1783 static int total_number_of_methods
PARAMS ((struct type
*type
));
1786 total_number_of_methods (type
)
1792 CHECK_TYPEDEF (type
);
1793 if (TYPE_CPLUS_SPECIFIC (type
) == NULL
)
1795 count
= TYPE_NFN_FIELDS_TOTAL (type
);
1797 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
1798 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
1803 /* Recursive helper function for decode_line_1.
1804 Look for methods named NAME in type T.
1805 Return number of matches.
1806 Put matches in SYM_ARR, which should have been allocated with
1807 a size of total_number_of_methods (T) * sizeof (struct symbol *).
1808 Note that this function is g++ specific. */
1811 find_methods (t
, name
, sym_arr
)
1814 struct symbol
**sym_arr
;
1818 struct symbol
*sym_class
;
1819 char *class_name
= type_name_no_tag (t
);
1820 /* Ignore this class if it doesn't have a name. This is ugly, but
1821 unless we figure out how to get the physname without the name of
1822 the class, then the loop can't do any good. */
1824 && (sym_class
= lookup_symbol (class_name
,
1825 (struct block
*)NULL
,
1828 (struct symtab
**)NULL
)))
1831 /* FIXME: Shouldn't this just be CHECK_TYPEDEF (t)? */
1832 t
= SYMBOL_TYPE (sym_class
);
1833 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1834 method_counter
>= 0;
1838 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1839 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1840 char dem_opname
[64];
1842 if (strncmp(method_name
, "__", 2)==0 ||
1843 strncmp(method_name
, "op", 2)==0 ||
1844 strncmp(method_name
, "type", 4)==0 )
1846 if (cplus_demangle_opname(method_name
, dem_opname
, DMGL_ANSI
))
1847 method_name
= dem_opname
;
1848 else if (cplus_demangle_opname(method_name
, dem_opname
, 0))
1849 method_name
= dem_opname
;
1851 if (STREQ (name
, method_name
))
1852 /* Find all the fields with that name. */
1853 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1858 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1859 check_stub_method (t
, method_counter
, field_counter
);
1860 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1861 /* Destructor is handled by caller, dont add it to the list */
1862 if (DESTRUCTOR_PREFIX_P (phys_name
))
1865 sym_arr
[i1
] = lookup_symbol (phys_name
,
1866 NULL
, VAR_NAMESPACE
,
1868 (struct symtab
**) NULL
);
1873 fputs_filtered("(Cannot find method ", gdb_stdout
);
1874 fprintf_symbol_filtered (gdb_stdout
, phys_name
,
1876 DMGL_PARAMS
| DMGL_ANSI
);
1877 fputs_filtered(" - possibly inlined.)\n", gdb_stdout
);
1883 /* Only search baseclasses if there is no match yet, since names in
1884 derived classes override those in baseclasses.
1886 FIXME: The above is not true; it is only true of member functions
1887 if they have the same number of arguments (??? - section 13.1 of the
1888 ARM says the function members are not in the same scope but doesn't
1889 really spell out the rules in a way I understand. In any case, if
1890 the number of arguments differ this is a case in which we can overload
1891 rather than hiding without any problem, and gcc 2.4.5 does overload
1892 rather than hiding in this case). */
1896 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1897 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1902 /* Helper function for decode_line_1.
1903 Build a canonical line spec in CANONICAL if it is non-NULL and if
1904 the SAL has a symtab.
1905 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1906 If SYMNAME is NULL the line number from SAL is used and the canonical
1907 line spec is `filename:linenum'. */
1910 build_canonical_line_spec (sal
, symname
, canonical
)
1911 struct symtab_and_line
*sal
;
1915 char **canonical_arr
;
1916 char *canonical_name
;
1918 struct symtab
*s
= sal
->symtab
;
1920 if (s
== (struct symtab
*)NULL
1921 || s
->filename
== (char *)NULL
1922 || canonical
== (char ***)NULL
)
1925 canonical_arr
= (char **) xmalloc (sizeof (char *));
1926 *canonical
= canonical_arr
;
1928 filename
= s
->filename
;
1929 if (symname
!= NULL
)
1931 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1932 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1936 canonical_name
= xmalloc (strlen (filename
) + 30);
1937 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1939 canonical_arr
[0] = canonical_name
;
1942 /* Parse a string that specifies a line number.
1943 Pass the address of a char * variable; that variable will be
1944 advanced over the characters actually parsed.
1948 LINENUM -- that line number in current file. PC returned is 0.
1949 FILE:LINENUM -- that line in that file. PC returned is 0.
1950 FUNCTION -- line number of openbrace of that function.
1951 PC returned is the start of the function.
1952 VARIABLE -- line number of definition of that variable.
1954 FILE:FUNCTION -- likewise, but prefer functions in that file.
1955 *EXPR -- line in which address EXPR appears.
1957 FUNCTION may be an undebuggable function found in minimal symbol table.
1959 If the argument FUNFIRSTLINE is nonzero, we want the first line
1960 of real code inside a function when a function is specified, and it is
1961 not OK to specify a variable or type to get its line number.
1963 DEFAULT_SYMTAB specifies the file to use if none is specified.
1964 It defaults to current_source_symtab.
1965 DEFAULT_LINE specifies the line number to use for relative
1966 line numbers (that start with signs). Defaults to current_source_line.
1967 If CANONICAL is non-NULL, store an array of strings containing the canonical
1968 line specs there if necessary. Currently overloaded member functions and
1969 line numbers or static functions without a filename yield a canonical
1970 line spec. The array and the line spec strings are allocated on the heap,
1971 it is the callers responsibility to free them.
1973 Note that it is possible to return zero for the symtab
1974 if no file is validly specified. Callers must check that.
1975 Also, the line number returned may be invalid. */
1977 /* We allow single quotes in various places. This is a hideous
1978 kludge, which exists because the completer can't yet deal with the
1979 lack of single quotes. FIXME: write a linespec_completer which we
1980 can use as appropriate instead of make_symbol_completion_list. */
1982 struct symtabs_and_lines
1983 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1986 struct symtab
*default_symtab
;
1990 struct symtabs_and_lines values
;
1991 #ifdef HPPA_COMPILER_BUG
1992 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1993 when optimizing this file with target i960-vxworks. I haven't
1994 been able to construct a simple test case. The problem is that
1995 in the second call to SKIP_PROLOGUE below, the compiler somehow
1996 does not realize that the statement val = find_pc_line (...) will
1997 change the values of the fields of val. It extracts the elements
1998 into registers at the top of the block, and does not update the
1999 registers after the call to find_pc_line. You can check this by
2000 inserting a printf at the end of find_pc_line to show what values
2001 it is returning for val.pc and val.end and another printf after
2002 the call to see what values the function actually got (remember,
2003 this is compiling with cc -O, with this patch removed). You can
2004 also examine the assembly listing: search for the second call to
2005 skip_prologue; the LDO statement before the next call to
2006 find_pc_line loads the address of the structure which
2007 find_pc_line will return; if there is a LDW just before the LDO,
2008 which fetches an element of the structure, then the compiler
2011 Setting val to volatile avoids the problem. We must undef
2012 volatile, because the HPPA native compiler does not define
2013 __STDC__, although it does understand volatile, and so volatile
2014 will have been defined away in defs.h. */
2016 volatile struct symtab_and_line val
;
2017 #define volatile /*nothing*/
2019 struct symtab_and_line val
;
2021 register char *p
, *p1
;
2026 register struct symtab
*s
;
2028 register struct symbol
*sym
;
2029 /* The symtab that SYM was found in. */
2030 struct symtab
*sym_symtab
;
2032 register CORE_ADDR pc
;
2033 register struct minimal_symbol
*msymbol
;
2035 struct symbol
*sym_class
;
2037 int is_quoted
, has_parens
;
2038 struct symbol
**sym_arr
;
2040 char *saved_arg
= *argptr
;
2041 extern char *gdb_completer_quote_characters
;
2043 INIT_SAL (&val
); /* initialize to zeroes */
2045 /* Defaults have defaults. */
2047 if (default_symtab
== 0)
2049 default_symtab
= current_source_symtab
;
2050 default_line
= current_source_line
;
2053 /* See if arg is *PC */
2055 if (**argptr
== '*')
2058 pc
= parse_and_eval_address_1 (argptr
);
2059 values
.sals
= (struct symtab_and_line
*)
2060 xmalloc (sizeof (struct symtab_and_line
));
2062 values
.sals
[0] = find_pc_line (pc
, 0);
2063 values
.sals
[0].pc
= pc
;
2067 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
2070 is_quoted
= (**argptr
2071 && strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
2072 has_parens
= ((pp
= strchr (*argptr
, '(')) != NULL
2073 && (pp
= strchr (pp
, ')')) != NULL
);
2075 for (p
= *argptr
; *p
; p
++)
2079 while(++p
&& *p
!= '>');
2082 error ("non-matching '<' and '>' in command");
2085 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
2088 while (p
[0] == ' ' || p
[0] == '\t') p
++;
2090 if ((p
[0] == ':') && !has_parens
)
2094 if (is_quoted
) *argptr
= *argptr
+1;
2097 /* Extract the class name. */
2099 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2100 copy
= (char *) alloca (p
- *argptr
+ 1);
2101 memcpy (copy
, *argptr
, p
- *argptr
);
2102 copy
[p
- *argptr
] = 0;
2104 /* Discard the class name from the arg. */
2106 while (*p
== ' ' || *p
== '\t') p
++;
2109 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
2110 (struct symtab
**)NULL
);
2113 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
2114 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
2115 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
2117 /* Arg token is not digits => try it as a function name
2118 Find the next token(everything up to end or next blank). */
2120 && strchr (gdb_completer_quote_characters
, **argptr
) != NULL
)
2122 p
= skip_quoted(*argptr
);
2123 *argptr
= *argptr
+ 1;
2128 while (*p
&& *p
!=' ' && *p
!='\t' && *p
!=',' && *p
!=':') p
++;
2131 q = operator_chars (*argptr, &q1);
2135 char *tmp = alloca (q1 - q + 1);
2136 memcpy (tmp, q, q1 - q);
2138 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
2142 printf_filtered ("no mangling for \"%s\"\n", tmp);
2143 cplusplus_hint (saved_arg);
2144 return_to_top_level (RETURN_ERROR);
2146 copy = (char*) alloca (3 + strlen(opname));
2147 sprintf (copy, "__%s", opname);
2153 copy
= (char *) alloca (p
- *argptr
+ 1 );
2154 memcpy (copy
, *argptr
, p
- *argptr
);
2155 copy
[p
- *argptr
] = '\0';
2157 && copy
[p
- *argptr
- 1]
2158 && strchr (gdb_completer_quote_characters
,
2159 copy
[p
- *argptr
- 1]) != NULL
)
2160 copy
[p
- *argptr
- 1] = '\0';
2163 /* no line number may be specified */
2164 while (*p
== ' ' || *p
== '\t') p
++;
2168 i1
= 0; /* counter for the symbol array */
2169 sym_arr
= (struct symbol
**) alloca(total_number_of_methods (t
)
2170 * sizeof(struct symbol
*));
2172 if (destructor_name_p (copy
, t
))
2174 /* Destructors are a special case. */
2175 int m_index
, f_index
;
2177 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2179 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, m_index
);
2182 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, f_index
),
2183 NULL
, VAR_NAMESPACE
, (int *) NULL
,
2184 (struct symtab
**)NULL
);
2190 i1
= find_methods (t
, copy
, sym_arr
);
2193 /* There is exactly one field with that name. */
2196 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2198 values
.sals
= (struct symtab_and_line
*)
2199 xmalloc (sizeof (struct symtab_and_line
));
2201 values
.sals
[0] = find_function_start_sal (sym
,
2212 /* There is more than one field with that name
2213 (overloaded). Ask the user which one to use. */
2214 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
2220 if (OPNAME_PREFIX_P (copy
))
2222 tmp
= (char *)alloca (strlen (copy
+3) + 9);
2223 strcpy (tmp
, "operator ");
2224 strcat (tmp
, copy
+3);
2231 ("the class `%s' does not have destructor defined\n",
2232 SYMBOL_SOURCE_NAME(sym_class
));
2235 ("the class %s does not have any method named %s\n",
2236 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
2237 cplusplus_hint (saved_arg
);
2238 return_to_top_level (RETURN_ERROR
);
2244 /* The quotes are important if copy is empty. */
2246 ("can't find class, struct, or union named \"%s\"\n", copy
);
2247 cplusplus_hint (saved_arg
);
2248 return_to_top_level (RETURN_ERROR
);
2254 /* Extract the file name. */
2256 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2257 copy
= (char *) alloca (p
- *argptr
+ 1);
2258 memcpy (copy
, *argptr
, p
- *argptr
);
2259 copy
[p
- *argptr
] = 0;
2261 /* Find that file's data. */
2262 s
= lookup_symtab (copy
);
2265 if (!have_full_symbols () && !have_partial_symbols ())
2266 error (no_symtab_msg
);
2267 error ("No source file named %s.", copy
);
2270 /* Discard the file name from the arg. */
2272 while (*p
== ' ' || *p
== '\t') p
++;
2276 /* S is specified file's symtab, or 0 if no file specified.
2277 arg no longer contains the file name. */
2279 /* Check whether arg is all digits (and sign) */
2282 if (*q
== '-' || *q
== '+') q
++;
2283 while (*q
>= '0' && *q
<= '9')
2286 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
2288 /* We found a token consisting of all digits -- at least one digit. */
2289 enum sign
{none
, plus
, minus
} sign
= none
;
2291 /* We might need a canonical line spec if no file was specified. */
2292 int need_canonical
= (s
== 0) ? 1 : 0;
2294 /* This is where we need to make sure that we have good defaults.
2295 We must guarantee that this section of code is never executed
2296 when we are called with just a function name, since
2297 select_source_symtab calls us with such an argument */
2299 if (s
== 0 && default_symtab
== 0)
2301 select_source_symtab (0);
2302 default_symtab
= current_source_symtab
;
2303 default_line
= current_source_line
;
2306 if (**argptr
== '+')
2307 sign
= plus
, (*argptr
)++;
2308 else if (**argptr
== '-')
2309 sign
= minus
, (*argptr
)++;
2310 val
.line
= atoi (*argptr
);
2317 val
.line
= default_line
+ val
.line
;
2323 val
.line
= default_line
- val
.line
;
2328 break; /* No need to adjust val.line. */
2331 while (*q
== ' ' || *q
== '\t') q
++;
2337 values
.sals
= (struct symtab_and_line
*)
2338 xmalloc (sizeof (struct symtab_and_line
));
2339 values
.sals
[0] = val
;
2342 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2346 /* Arg token is not digits => try it as a variable name
2347 Find the next token (everything up to end or next whitespace). */
2349 if (**argptr
== '$') /* Convenience variable */
2350 p
= skip_quoted (*argptr
+ 1);
2353 p
= skip_quoted (*argptr
);
2355 error ("Unmatched single quote.");
2357 else if (has_parens
)
2363 p
= skip_quoted(*argptr
);
2366 copy
= (char *) alloca (p
- *argptr
+ 1);
2367 memcpy (copy
, *argptr
, p
- *argptr
);
2368 copy
[p
- *argptr
] = '\0';
2371 && copy
[0] == copy
[p
- *argptr
- 1]
2372 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
2374 copy
[p
- *argptr
- 1] = '\0';
2377 while (*p
== ' ' || *p
== '\t') p
++;
2380 /* See if it's a convenience variable */
2385 int need_canonical
= (s
== 0) ? 1 : 0;
2387 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
2388 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
2389 error ("Convenience variables used in line specs must have integer values.");
2391 val
.symtab
= s
? s
: default_symtab
;
2392 val
.line
= value_as_long (valx
);
2395 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof val
);
2396 values
.sals
[0] = val
;
2400 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2406 /* Look up that token as a variable.
2407 If file specified, use that file's per-file block to start with. */
2409 sym
= lookup_symbol (copy
,
2410 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2411 : get_selected_block ()),
2412 VAR_NAMESPACE
, 0, &sym_symtab
);
2416 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2418 /* Arg is the name of a function */
2419 values
.sals
= (struct symtab_and_line
*)
2420 xmalloc (sizeof (struct symtab_and_line
));
2421 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
2424 /* Don't use the SYMBOL_LINE; if used at all it points to
2425 the line containing the parameters or thereabouts, not
2426 the first line of code. */
2428 /* We might need a canonical line spec if it is a static
2432 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2433 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2434 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2435 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2442 error ("\"%s\" is not a function", copy
);
2443 else if (SYMBOL_LINE (sym
) != 0)
2445 /* We know its line number. */
2446 values
.sals
= (struct symtab_and_line
*)
2447 xmalloc (sizeof (struct symtab_and_line
));
2449 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2450 values
.sals
[0].symtab
= sym_symtab
;
2451 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2455 /* This can happen if it is compiled with a compiler which doesn't
2456 put out line numbers for variables. */
2457 /* FIXME: Shouldn't we just set .line and .symtab to zero
2458 and return? For example, "info line foo" could print
2460 error ("Line number not known for symbol \"%s\"", copy
);
2464 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
2465 if (msymbol
!= NULL
)
2467 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2468 val
.section
= SYMBOL_BFD_SECTION (msymbol
);
2471 val
.pc
+= FUNCTION_START_OFFSET
;
2472 SKIP_PROLOGUE (val
.pc
);
2474 values
.sals
= (struct symtab_and_line
*)
2475 xmalloc (sizeof (struct symtab_and_line
));
2476 values
.sals
[0] = val
;
2481 if (!have_full_symbols () &&
2482 !have_partial_symbols () && !have_minimal_symbols ())
2483 error (no_symtab_msg
);
2485 error ("Function \"%s\" not defined.", copy
);
2486 return values
; /* for lint */
2489 struct symtabs_and_lines
2490 decode_line_spec (string
, funfirstline
)
2494 struct symtabs_and_lines sals
;
2496 error ("Empty line specification.");
2497 sals
= decode_line_1 (&string
, funfirstline
,
2498 current_source_symtab
, current_source_line
,
2501 error ("Junk at end of line specification: %s", string
);
2505 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2506 operate on (ask user if necessary).
2507 If CANONICAL is non-NULL return a corresponding array of mangled names
2508 as canonical line specs there. */
2510 static struct symtabs_and_lines
2511 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2512 struct symbol
*sym_arr
[];
2517 struct symtabs_and_lines values
, return_values
;
2522 struct cleanup
*old_chain
;
2523 char **canonical_arr
= (char **)NULL
;
2525 values
.sals
= (struct symtab_and_line
*)
2526 alloca (nelts
* sizeof(struct symtab_and_line
));
2527 return_values
.sals
= (struct symtab_and_line
*)
2528 xmalloc (nelts
* sizeof(struct symtab_and_line
));
2529 old_chain
= make_cleanup (free
, return_values
.sals
);
2533 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2534 make_cleanup (free
, canonical_arr
);
2535 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2536 *canonical
= canonical_arr
;
2540 printf_unfiltered("[0] cancel\n[1] all\n");
2543 INIT_SAL (&return_values
.sals
[i
]); /* initialize to zeroes */
2544 INIT_SAL (&values
.sals
[i
]);
2545 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2547 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
2548 printf_unfiltered ("[%d] %s at %s:%d\n",
2550 SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2551 values
.sals
[i
].symtab
->filename
,
2552 values
.sals
[i
].line
);
2555 printf_unfiltered ("?HERE\n");
2559 if ((prompt
= getenv ("PS2")) == NULL
)
2563 printf_unfiltered("%s ",prompt
);
2564 gdb_flush(gdb_stdout
);
2566 args
= command_line_input ((char *) NULL
, 0, "overload-choice");
2568 if (args
== 0 || *args
== 0)
2569 error_no_arg ("one or more choice numbers");
2577 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2578 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2579 error ("Arguments must be choice numbers.");
2584 error ("cancelled");
2589 for (i
= 0; i
< nelts
; i
++)
2591 if (canonical_arr
[i
] == NULL
)
2593 symname
= SYMBOL_NAME (sym_arr
[i
]);
2594 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2598 memcpy (return_values
.sals
, values
.sals
,
2599 (nelts
* sizeof(struct symtab_and_line
)));
2600 return_values
.nelts
= nelts
;
2601 discard_cleanups (old_chain
);
2602 return return_values
;
2605 if (num
>= nelts
+ 2)
2607 printf_unfiltered ("No choice number %d.\n", num
);
2612 if (values
.sals
[num
].pc
)
2616 symname
= SYMBOL_NAME (sym_arr
[num
]);
2617 make_cleanup (free
, symname
);
2618 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2620 return_values
.sals
[i
++] = values
.sals
[num
];
2621 values
.sals
[num
].pc
= 0;
2625 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2630 while (*args
== ' ' || *args
== '\t') args
++;
2632 return_values
.nelts
= i
;
2633 discard_cleanups (old_chain
);
2634 return return_values
;
2638 /* Slave routine for sources_info. Force line breaks at ,'s.
2639 NAME is the name to print and *FIRST is nonzero if this is the first
2640 name printed. Set *FIRST to zero. */
2642 output_source_filename (name
, first
)
2646 /* Table of files printed so far. Since a single source file can
2647 result in several partial symbol tables, we need to avoid printing
2648 it more than once. Note: if some of the psymtabs are read in and
2649 some are not, it gets printed both under "Source files for which
2650 symbols have been read" and "Source files for which symbols will
2651 be read in on demand". I consider this a reasonable way to deal
2652 with the situation. I'm not sure whether this can also happen for
2653 symtabs; it doesn't hurt to check. */
2654 static char **tab
= NULL
;
2655 /* Allocated size of tab in elements.
2656 Start with one 256-byte block (when using GNU malloc.c).
2657 24 is the malloc overhead when range checking is in effect. */
2658 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2659 /* Current size of tab in elements. */
2660 static int tab_cur_size
;
2667 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2671 /* Is NAME in tab? */
2672 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2673 if (STREQ (*p
, name
))
2674 /* Yes; don't print it again. */
2676 /* No; add it to tab. */
2677 if (tab_cur_size
== tab_alloc_size
)
2679 tab_alloc_size
*= 2;
2680 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2682 tab
[tab_cur_size
++] = name
;
2690 printf_filtered (", ");
2694 fputs_filtered (name
, gdb_stdout
);
2698 sources_info (ignore
, from_tty
)
2702 register struct symtab
*s
;
2703 register struct partial_symtab
*ps
;
2704 register struct objfile
*objfile
;
2707 if (!have_full_symbols () && !have_partial_symbols ())
2709 error (no_symtab_msg
);
2712 printf_filtered ("Source files for which symbols have been read in:\n\n");
2715 ALL_SYMTABS (objfile
, s
)
2717 output_source_filename (s
-> filename
, &first
);
2719 printf_filtered ("\n\n");
2721 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2724 ALL_PSYMTABS (objfile
, ps
)
2728 output_source_filename (ps
-> filename
, &first
);
2731 printf_filtered ("\n");
2734 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2735 If CLASS is zero, list all symbols except functions, type names, and
2737 If CLASS is 1, list only functions.
2738 If CLASS is 2, list only type names.
2739 If CLASS is 3, list only method names.
2741 BPT is non-zero if we should set a breakpoint at the functions
2745 list_symbols (regexp
, class, bpt
, from_tty
)
2751 register struct symtab
*s
;
2752 register struct partial_symtab
*ps
;
2753 register struct blockvector
*bv
;
2754 struct blockvector
*prev_bv
= 0;
2755 register struct block
*b
;
2757 register struct symbol
*sym
;
2758 struct partial_symbol
**psym
;
2759 struct objfile
*objfile
;
2760 struct minimal_symbol
*msymbol
;
2762 static char *classnames
[]
2763 = {"variable", "function", "type", "method"};
2764 int found_in_file
= 0;
2766 static enum minimal_symbol_type types
[]
2767 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2768 static enum minimal_symbol_type types2
[]
2769 = {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2770 static enum minimal_symbol_type types3
[]
2771 = {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2772 static enum minimal_symbol_type types4
[]
2773 = {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2774 enum minimal_symbol_type ourtype
= types
[class];
2775 enum minimal_symbol_type ourtype2
= types2
[class];
2776 enum minimal_symbol_type ourtype3
= types3
[class];
2777 enum minimal_symbol_type ourtype4
= types4
[class];
2781 /* Make sure spacing is right for C++ operators.
2782 This is just a courtesy to make the matching less sensitive
2783 to how many spaces the user leaves between 'operator'
2784 and <TYPENAME> or <OPERATOR>. */
2786 char *opname
= operator_chars (regexp
, &opend
);
2789 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2790 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2792 /* There should 1 space between 'operator' and 'TYPENAME'. */
2793 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2798 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2799 if (opname
[-1] == ' ')
2802 /* If wrong number of spaces, fix it. */
2805 char *tmp
= (char*) alloca(opend
-opname
+10);
2806 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2811 if (0 != (val
= re_comp (regexp
)))
2812 error ("Invalid regexp (%s): %s", val
, regexp
);
2815 /* Search through the partial symtabs *first* for all symbols
2816 matching the regexp. That way we don't have to reproduce all of
2817 the machinery below. */
2819 ALL_PSYMTABS (objfile
, ps
)
2821 struct partial_symbol
**bound
, **gbound
, **sbound
;
2824 if (ps
->readin
) continue;
2826 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2827 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2830 /* Go through all of the symbols stored in a partial
2831 symtab in one loop. */
2832 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2837 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2839 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2850 /* If it would match (logic taken from loop below)
2851 load the file and go on to the next one */
2852 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (*psym
))
2853 && ((class == 0 && SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
2854 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
2855 || (class == 1 && SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
2856 || (class == 2 && SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
2857 || (class == 3 && SYMBOL_CLASS (*psym
) == LOC_BLOCK
)))
2859 PSYMTAB_TO_SYMTAB(ps
);
2867 /* Here, we search through the minimal symbol tables for functions
2868 and variables that match, and force their symbols to be read.
2869 This is in particular necessary for demangled variable names,
2870 which are no longer put into the partial symbol tables.
2871 The symbol will then be found during the scan of symtabs below.
2873 For functions, find_pc_symtab should succeed if we have debug info
2874 for the function, for variables we have to call lookup_symbol
2875 to determine if the variable has debug info.
2876 If the lookup fails, set found_misc so that we will rescan to print
2877 any matching symbols without debug info.
2880 if (class == 0 || class == 1)
2882 ALL_MSYMBOLS (objfile
, msymbol
)
2884 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2885 MSYMBOL_TYPE (msymbol
) == ourtype2
||
2886 MSYMBOL_TYPE (msymbol
) == ourtype3
||
2887 MSYMBOL_TYPE (msymbol
) == ourtype4
)
2889 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2891 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2894 || lookup_symbol (SYMBOL_NAME (msymbol
),
2895 (struct block
*) NULL
,
2897 0, (struct symtab
**) NULL
) == NULL
)
2905 /* Printout here so as to get after the "Reading in symbols"
2906 messages which will be generated above. */
2908 printf_filtered (regexp
2909 ? "All %ss matching regular expression \"%s\":\n"
2910 : "All defined %ss:\n",
2914 ALL_SYMTABS (objfile
, s
)
2917 bv
= BLOCKVECTOR (s
);
2918 /* Often many files share a blockvector.
2919 Scan each blockvector only once so that
2920 we don't get every symbol many times.
2921 It happens that the first symtab in the list
2922 for any given blockvector is the main file. */
2924 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2926 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2927 /* Skip the sort if this block is always sorted. */
2928 if (!BLOCK_SHOULD_SORT (b
))
2929 sort_block_syms (b
);
2930 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2933 sym
= BLOCK_SYM (b
, j
);
2934 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2935 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2936 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2937 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2938 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2939 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2940 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2944 /* Set a breakpoint here, if it's a function */
2947 /* There may be more than one function with the
2948 same name but in different files. In order to
2949 set breakpoints on all of them, we must give
2950 both the file name and the function name to
2952 Quoting the symbol name gets rid of problems
2953 with mangled symbol names that contain
2954 CPLUS_MARKER characters. */
2956 (char *) alloca (strlen (s
->filename
)
2957 + strlen (SYMBOL_NAME(sym
))
2959 strcpy (string
, s
->filename
);
2960 strcat (string
, ":'");
2961 strcat (string
, SYMBOL_NAME(sym
));
2962 strcat (string
, "'");
2963 break_command (string
, from_tty
);
2966 else if (!found_in_file
)
2968 fputs_filtered ("\nFile ", gdb_stdout
);
2969 fputs_filtered (s
->filename
, gdb_stdout
);
2970 fputs_filtered (":\n", gdb_stdout
);
2974 if (class != 2 && i
== STATIC_BLOCK
)
2975 printf_filtered ("static ");
2977 /* Typedef that is not a C++ class */
2979 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2980 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2981 /* variable, func, or typedef-that-is-c++-class */
2982 else if (class < 2 ||
2984 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2986 type_print (SYMBOL_TYPE (sym
),
2987 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2988 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2991 printf_filtered (";\n");
2996 /* Tiemann says: "info methods was never implemented." */
2997 char *demangled_name
;
2998 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
3000 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
3002 if (TYPE_FN_FIELD_STUB (t
, i
))
3003 check_stub_method (TYPE_DOMAIN_TYPE (type
), j
, i
);
3005 cplus_demangle (TYPE_FN_FIELD_PHYSNAME (t
, i
),
3006 DMGL_ANSI
| DMGL_PARAMS
);
3007 if (demangled_name
== NULL
)
3008 fprintf_filtered (stream
, "<badly mangled name %s>",
3009 TYPE_FN_FIELD_PHYSNAME (t
, i
));
3012 fputs_filtered (demangled_name
, stream
);
3013 free (demangled_name
);
3023 /* If there are no eyes, avoid all contact. I mean, if there are
3024 no debug symbols, then print directly from the msymbol_vector. */
3026 if (found_misc
|| class != 1)
3029 ALL_MSYMBOLS (objfile
, msymbol
)
3031 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3032 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3033 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3034 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3036 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
3038 /* Functions: Look up by address. */
3040 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3042 /* Variables/Absolutes: Look up by name */
3043 if (lookup_symbol (SYMBOL_NAME (msymbol
),
3044 (struct block
*) NULL
, VAR_NAMESPACE
,
3045 0, (struct symtab
**) NULL
) == NULL
)
3049 break_command (SYMBOL_NAME (msymbol
), from_tty
);
3050 printf_filtered ("<function, no debug info> %s;\n",
3051 SYMBOL_SOURCE_NAME (msymbol
));
3056 printf_filtered ("\nNon-debugging symbols:\n");
3059 printf_filtered (" %08lx %s\n",
3060 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
3061 SYMBOL_SOURCE_NAME (msymbol
));
3071 variables_info (regexp
, from_tty
)
3075 list_symbols (regexp
, 0, 0, from_tty
);
3079 functions_info (regexp
, from_tty
)
3083 list_symbols (regexp
, 1, 0, from_tty
);
3087 types_info (regexp
, from_tty
)
3091 list_symbols (regexp
, 2, 0, from_tty
);
3095 /* Tiemann says: "info methods was never implemented." */
3097 methods_info (regexp
)
3100 list_symbols (regexp
, 3, 0, from_tty
);
3104 /* Breakpoint all functions matching regular expression. */
3106 rbreak_command (regexp
, from_tty
)
3110 list_symbols (regexp
, 1, 1, from_tty
);
3114 /* Return Nonzero if block a is lexically nested within block b,
3115 or if a and b have the same pc range.
3116 Return zero otherwise. */
3119 struct block
*a
, *b
;
3123 return BLOCK_START (a
) >= BLOCK_START (b
)
3124 && BLOCK_END (a
) <= BLOCK_END (b
);
3128 /* Helper routine for make_symbol_completion_list. */
3130 static int return_val_size
;
3131 static int return_val_index
;
3132 static char **return_val
;
3134 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3136 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
3137 /* Put only the mangled name on the list. */ \
3138 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
3139 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
3140 completion_list_add_name \
3141 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
3143 completion_list_add_name \
3144 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
3147 /* Test to see if the symbol specified by SYMNAME (which is already
3148 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3149 characters. If so, add it to the current completion list. */
3152 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
3162 /* clip symbols that cannot match */
3164 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3169 /* Clip any symbol names that we've already considered. (This is a
3170 time optimization) */
3172 for (i
= 0; i
< return_val_index
; ++i
)
3174 if (STREQ (symname
, return_val
[i
]))
3180 /* We have a match for a completion, so add SYMNAME to the current list
3181 of matches. Note that the name is moved to freshly malloc'd space. */
3185 if (word
== sym_text
)
3187 new = xmalloc (strlen (symname
) + 5);
3188 strcpy (new, symname
);
3190 else if (word
> sym_text
)
3192 /* Return some portion of symname. */
3193 new = xmalloc (strlen (symname
) + 5);
3194 strcpy (new, symname
+ (word
- sym_text
));
3198 /* Return some of SYM_TEXT plus symname. */
3199 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3200 strncpy (new, word
, sym_text
- word
);
3201 new[sym_text
- word
] = '\0';
3202 strcat (new, symname
);
3205 /* Recheck for duplicates if we intend to add a modified symbol. */
3206 if (word
!= sym_text
)
3208 for (i
= 0; i
< return_val_index
; ++i
)
3210 if (STREQ (new, return_val
[i
]))
3218 if (return_val_index
+ 3 > return_val_size
)
3220 newsize
= (return_val_size
*= 2) * sizeof (char *);
3221 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3223 return_val
[return_val_index
++] = new;
3224 return_val
[return_val_index
] = NULL
;
3228 /* Return a NULL terminated array of all symbols (regardless of class) which
3229 begin by matching TEXT. If the answer is no symbols, then the return value
3230 is an array which contains only a NULL pointer.
3232 Problem: All of the symbols have to be copied because readline frees them.
3233 I'm not going to worry about this; hopefully there won't be that many. */
3236 make_symbol_completion_list (text
, word
)
3240 register struct symbol
*sym
;
3241 register struct symtab
*s
;
3242 register struct partial_symtab
*ps
;
3243 register struct minimal_symbol
*msymbol
;
3244 register struct objfile
*objfile
;
3245 register struct block
*b
, *surrounding_static_block
= 0;
3247 struct partial_symbol
**psym
;
3248 /* The symbol we are completing on. Points in same buffer as text. */
3250 /* Length of sym_text. */
3253 /* Now look for the symbol we are supposed to complete on.
3254 FIXME: This should be language-specific. */
3258 char *quote_pos
= NULL
;
3260 /* First see if this is a quoted string. */
3262 for (p
= text
; *p
!= '\0'; ++p
)
3264 if (quote_found
!= '\0')
3266 if (*p
== quote_found
)
3267 /* Found close quote. */
3269 else if (*p
== '\\' && p
[1] == quote_found
)
3270 /* A backslash followed by the quote character
3271 doesn't end the string. */
3274 else if (*p
== '\'' || *p
== '"')
3280 if (quote_found
== '\'')
3281 /* A string within single quotes can be a symbol, so complete on it. */
3282 sym_text
= quote_pos
+ 1;
3283 else if (quote_found
== '"')
3284 /* A double-quoted string is never a symbol, nor does it make sense
3285 to complete it any other way. */
3289 /* It is not a quoted string. Break it based on the characters
3290 which are in symbols. */
3293 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3302 sym_text_len
= strlen (sym_text
);
3304 return_val_size
= 100;
3305 return_val_index
= 0;
3306 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3307 return_val
[0] = NULL
;
3309 /* Look through the partial symtabs for all symbols which begin
3310 by matching SYM_TEXT. Add each one that you find to the list. */
3312 ALL_PSYMTABS (objfile
, ps
)
3314 /* If the psymtab's been read in we'll get it when we search
3315 through the blockvector. */
3316 if (ps
->readin
) continue;
3318 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3319 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3320 + ps
->n_global_syms
);
3323 /* If interrupted, then quit. */
3325 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3328 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3329 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3330 + ps
->n_static_syms
);
3334 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3338 /* At this point scan through the misc symbol vectors and add each
3339 symbol you find to the list. Eventually we want to ignore
3340 anything that isn't a text symbol (everything else will be
3341 handled by the psymtab code above). */
3343 ALL_MSYMBOLS (objfile
, msymbol
)
3346 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3349 /* Search upwards from currently selected frame (so that we can
3350 complete on local vars. */
3352 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3354 if (!BLOCK_SUPERBLOCK (b
))
3356 surrounding_static_block
= b
; /* For elmin of dups */
3359 /* Also catch fields of types defined in this places which match our
3360 text string. Only complete on types visible from current context. */
3362 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3364 sym
= BLOCK_SYM (b
, i
);
3365 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3366 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3368 struct type
*t
= SYMBOL_TYPE (sym
);
3369 enum type_code c
= TYPE_CODE (t
);
3371 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3373 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3375 if (TYPE_FIELD_NAME (t
, j
))
3377 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3378 sym_text
, sym_text_len
, text
, word
);
3386 /* Go through the symtabs and check the externs and statics for
3387 symbols which match. */
3389 ALL_SYMTABS (objfile
, s
)
3392 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3393 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3395 sym
= BLOCK_SYM (b
, i
);
3396 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3400 ALL_SYMTABS (objfile
, s
)
3403 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3404 /* Don't do this block twice. */
3405 if (b
== surrounding_static_block
) continue;
3406 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3408 sym
= BLOCK_SYM (b
, i
);
3409 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3413 return (return_val
);
3416 /* Determine if PC is in the prologue of a function. The prologue is the area
3417 between the first instruction of a function, and the first executable line.
3418 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3420 If non-zero, func_start is where we think the prologue starts, possibly
3421 by previous examination of symbol table information.
3425 in_prologue (pc
, func_start
)
3427 CORE_ADDR func_start
;
3429 struct symtab_and_line sal
;
3430 CORE_ADDR func_addr
, func_end
;
3432 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3433 goto nosyms
; /* Might be in prologue */
3435 sal
= find_pc_line (func_addr
, 0);
3440 if (sal
.end
> func_addr
3441 && sal
.end
<= func_end
) /* Is prologue in function? */
3442 return pc
< sal
.end
; /* Yes, is pc in prologue? */
3444 /* The line after the prologue seems to be outside the function. In this
3445 case, tell the caller to find the prologue the hard way. */
3449 /* Come here when symtabs don't contain line # info. In this case, it is
3450 likely that the user has stepped into a library function w/o symbols, or
3451 is doing a stepi/nexti through code without symbols. */
3455 /* If func_start is zero (meaning unknown) then we don't know whether pc is
3456 in the prologue or not. I.E. it might be. */
3458 if (!func_start
) return 1;
3460 /* We need to call the target-specific prologue skipping functions with the
3461 function's start address because PC may be pointing at an instruction that
3462 could be mistakenly considered part of the prologue. */
3464 SKIP_PROLOGUE (func_start
);
3466 return pc
< func_start
;
3471 _initialize_symtab ()
3473 add_info ("variables", variables_info
,
3474 "All global and static variable names, or those matching REGEXP.");
3475 add_info ("functions", functions_info
,
3476 "All function names, or those matching REGEXP.");
3478 /* FIXME: This command has at least the following problems:
3479 1. It prints builtin types (in a very strange and confusing fashion).
3480 2. It doesn't print right, e.g. with
3481 typedef struct foo *FOO
3482 type_print prints "FOO" when we want to make it (in this situation)
3483 print "struct foo *".
3484 I also think "ptype" or "whatis" is more likely to be useful (but if
3485 there is much disagreement "info types" can be fixed). */
3486 add_info ("types", types_info
,
3487 "All type names, or those matching REGEXP.");
3490 add_info ("methods", methods_info
,
3491 "All method names, or those matching REGEXP::REGEXP.\n\
3492 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3493 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3496 add_info ("sources", sources_info
,
3497 "Source files in the program.");
3499 add_com ("rbreak", no_class
, rbreak_command
,
3500 "Set a breakpoint for all functions matching REGEXP.");
3502 /* Initialize the one built-in type that isn't language dependent... */
3503 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3504 "<unknown type>", (struct objfile
*) NULL
);