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
;
526 if (SYMBOL_BFD_SECTION (sym
))
529 fixup_section (&sym
->ginfo
, objfile
);
534 struct partial_symbol
*
535 fixup_psymbol_section (psym
, objfile
)
536 struct partial_symbol
*psym
;
537 struct objfile
*objfile
;
542 if (SYMBOL_BFD_SECTION (psym
))
545 fixup_section (&psym
->ginfo
, objfile
);
550 /* Find the definition for a specified symbol name NAME
551 in namespace NAMESPACE, visible from lexical block BLOCK.
552 Returns the struct symbol pointer, or zero if no symbol is found.
553 If SYMTAB is non-NULL, store the symbol table in which the
554 symbol was found there, or NULL if not found.
555 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
556 NAME is a field of the current implied argument `this'. If so set
557 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
558 BLOCK_FOUND is set to the block in which NAME is found (in the case of
559 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
561 /* This function has a bunch of loops in it and it would seem to be
562 attractive to put in some QUIT's (though I'm not really sure
563 whether it can run long enough to be really important). But there
564 are a few calls for which it would appear to be bad news to quit
565 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c, and
566 nindy_frame_chain_valid in nindy-tdep.c. (Note that there is C++
567 code below which can error(), but that probably doesn't affect
568 these calls since they are looking for a known variable and thus
569 can probably assume it will never hit the C++ code). */
572 lookup_symbol (name
, block
, namespace, is_a_field_of_this
, symtab
)
574 register const struct block
*block
;
575 const namespace_enum
namespace;
576 int *is_a_field_of_this
;
577 struct symtab
**symtab
;
579 register struct symbol
*sym
;
580 register struct symtab
*s
= NULL
;
581 register struct partial_symtab
*ps
;
582 struct blockvector
*bv
;
583 register struct objfile
*objfile
= NULL
;
584 register struct block
*b
;
585 register struct minimal_symbol
*msymbol
;
587 /* Search specified block and its superiors. */
591 sym
= lookup_block_symbol (block
, name
, namespace);
597 /* Search the list of symtabs for one which contains the
598 address of the start of this block. */
599 ALL_SYMTABS (objfile
, s
)
601 bv
= BLOCKVECTOR (s
);
602 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
603 if (BLOCK_START (b
) <= BLOCK_START (block
)
604 && BLOCK_END (b
) > BLOCK_START (block
))
611 return fixup_symbol_section (sym
, objfile
);
613 block
= BLOCK_SUPERBLOCK (block
);
616 /* FIXME: this code is never executed--block is always NULL at this
617 point. What is it trying to do, anyway? We already should have
618 checked the STATIC_BLOCK above (it is the superblock of top-level
619 blocks). Why is VAR_NAMESPACE special-cased? */
620 /* Don't need to mess with the psymtabs; if we have a block,
621 that file is read in. If we don't, then we deal later with
622 all the psymtab stuff that needs checking. */
623 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
626 /* Find the right symtab. */
627 ALL_SYMTABS (objfile
, s
)
629 bv
= BLOCKVECTOR (s
);
630 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
631 if (BLOCK_START (b
) <= BLOCK_START (block
)
632 && BLOCK_END (b
) > BLOCK_START (block
))
634 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
640 return fixup_symbol_section (sym
, objfile
);
647 /* C++: If requested to do so by the caller,
648 check to see if NAME is a field of `this'. */
649 if (is_a_field_of_this
)
651 struct value
*v
= value_of_this (0);
653 *is_a_field_of_this
= 0;
654 if (v
&& check_field (v
, name
))
656 *is_a_field_of_this
= 1;
663 /* Now search all global blocks. Do the symtab's first, then
664 check the psymtab's */
666 ALL_SYMTABS (objfile
, s
)
668 bv
= BLOCKVECTOR (s
);
669 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
670 sym
= lookup_block_symbol (block
, name
, namespace);
676 return fixup_symbol_section (sym
, objfile
);
680 /* Check for the possibility of the symbol being a function or
681 a mangled variable that is stored in one of the minimal symbol tables.
682 Eventually, all global symbols might be resolved in this way. */
684 if (namespace == VAR_NAMESPACE
)
686 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
689 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
690 SYMBOL_BFD_SECTION (msymbol
));
693 /* This is a function which has a symtab for its address. */
694 bv
= BLOCKVECTOR (s
);
695 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
696 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
698 /* We kept static functions in minimal symbol table as well as
699 in static scope. We want to find them in the symbol table. */
701 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
702 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
706 /* sym == 0 if symbol was found in the minimal symbol table
707 but not in the symtab.
708 Return 0 to use the msymbol definition of "foo_".
710 This happens for Fortran "foo_" symbols,
711 which are "foo" in the symtab.
713 This can also happen if "asm" is used to make a
714 regular symbol but not a debugging symbol, e.g.
721 return fixup_symbol_section (sym
, objfile
);
723 else if (MSYMBOL_TYPE (msymbol
) != mst_text
724 && MSYMBOL_TYPE (msymbol
) != mst_file_text
725 && !STREQ (name
, SYMBOL_NAME (msymbol
)))
727 /* This is a mangled variable, look it up by its
729 return lookup_symbol (SYMBOL_NAME (msymbol
), block
,
730 namespace, is_a_field_of_this
, symtab
);
732 /* There are no debug symbols for this file, or we are looking
733 for an unmangled variable.
734 Try to find a matching static symbol below. */
738 ALL_PSYMTABS (objfile
, ps
)
740 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
742 s
= PSYMTAB_TO_SYMTAB(ps
);
743 bv
= BLOCKVECTOR (s
);
744 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
745 sym
= lookup_block_symbol (block
, name
, namespace);
747 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
750 return fixup_symbol_section (sym
, objfile
);
754 /* Now search all per-file blocks.
755 Not strictly correct, but more useful than an error.
756 Do the symtabs first, then check the psymtabs */
758 ALL_SYMTABS (objfile
, s
)
760 bv
= BLOCKVECTOR (s
);
761 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
762 sym
= lookup_block_symbol (block
, name
, namespace);
768 return fixup_symbol_section (sym
, objfile
);
772 ALL_PSYMTABS (objfile
, ps
)
774 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
776 s
= PSYMTAB_TO_SYMTAB(ps
);
777 bv
= BLOCKVECTOR (s
);
778 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
779 sym
= lookup_block_symbol (block
, name
, namespace);
781 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name
, ps
->filename
);
784 return fixup_symbol_section (sym
, objfile
);
793 /* Look, in partial_symtab PST, for symbol NAME. Check the global
794 symbols if GLOBAL, the static symbols if not */
796 static struct partial_symbol
*
797 lookup_partial_symbol (pst
, name
, global
, namespace)
798 struct partial_symtab
*pst
;
801 namespace_enum
namespace;
803 struct partial_symbol
**start
, **psym
;
804 struct partial_symbol
**top
, **bottom
, **center
;
805 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
806 int do_linear_search
= 1;
814 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
815 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
817 if (global
) /* This means we can use a binary search. */
819 do_linear_search
= 0;
821 /* Binary search. This search is guaranteed to end with center
822 pointing at the earliest partial symbol with the correct
823 name. At that point *all* partial symbols with that name
824 will be checked against the correct namespace. */
827 top
= start
+ length
- 1;
830 center
= bottom
+ (top
- bottom
) / 2;
833 if (!do_linear_search
&& SYMBOL_LANGUAGE (*center
) == language_cplus
)
835 do_linear_search
= 1;
837 if (STRCMP (SYMBOL_NAME (*center
), name
) >= 0)
846 if (!(top
== bottom
))
848 while (STREQ (SYMBOL_NAME (*top
), name
))
850 if (SYMBOL_NAMESPACE (*top
) == namespace)
858 /* Can't use a binary search or else we found during the binary search that
859 we should also do a linear search. */
861 if (do_linear_search
)
863 for (psym
= start
; psym
< start
+ length
; psym
++)
865 if (namespace == SYMBOL_NAMESPACE (*psym
))
867 if (SYMBOL_MATCHES_NAME (*psym
, name
))
878 /* Find the psymtab containing main(). */
879 /* FIXME: What about languages without main() or specially linked
880 executables that have no main() ? */
882 struct partial_symtab
*
885 register struct partial_symtab
*pst
;
886 register struct objfile
*objfile
;
888 ALL_PSYMTABS (objfile
, pst
)
890 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
898 /* Search BLOCK for symbol NAME in NAMESPACE.
900 Note that if NAME is the demangled form of a C++ symbol, we will fail
901 to find a match during the binary search of the non-encoded names, but
902 for now we don't worry about the slight inefficiency of looking for
903 a match we'll never find, since it will go pretty quick. Once the
904 binary search terminates, we drop through and do a straight linear
905 search on the symbols. Each symbol which is marked as being a C++
906 symbol (language_cplus set) has both the encoded and non-encoded names
907 tested for a match. */
910 lookup_block_symbol (block
, name
, namespace)
911 register const struct block
*block
;
913 const namespace_enum
namespace;
915 register int bot
, top
, inc
;
916 register struct symbol
*sym
;
917 register struct symbol
*sym_found
= NULL
;
918 register int do_linear_search
= 1;
920 /* If the blocks's symbols were sorted, start with a binary search. */
922 if (BLOCK_SHOULD_SORT (block
))
924 /* Reset the linear search flag so if the binary search fails, we
925 won't do the linear search once unless we find some reason to
926 do so, such as finding a C++ symbol during the binary search.
927 Note that for C++ modules, ALL the symbols in a block should
928 end up marked as C++ symbols. */
930 do_linear_search
= 0;
931 top
= BLOCK_NSYMS (block
);
934 /* Advance BOT to not far before the first symbol whose name is NAME. */
938 inc
= (top
- bot
+ 1);
939 /* No need to keep binary searching for the last few bits worth. */
944 inc
= (inc
>> 1) + bot
;
945 sym
= BLOCK_SYM (block
, inc
);
946 if (!do_linear_search
&& SYMBOL_LANGUAGE (sym
) == language_cplus
)
948 do_linear_search
= 1;
950 if (SYMBOL_NAME (sym
)[0] < name
[0])
954 else if (SYMBOL_NAME (sym
)[0] > name
[0])
958 else if (STRCMP (SYMBOL_NAME (sym
), name
) < 0)
968 /* Now scan forward until we run out of symbols, find one whose
969 name is greater than NAME, or find one we want. If there is
970 more than one symbol with the right name and namespace, we
971 return the first one; I believe it is now impossible for us
972 to encounter two symbols with the same name and namespace
973 here, because blocks containing argument symbols are no
976 top
= BLOCK_NSYMS (block
);
979 sym
= BLOCK_SYM (block
, bot
);
980 inc
= SYMBOL_NAME (sym
)[0] - name
[0];
983 inc
= STRCMP (SYMBOL_NAME (sym
), name
);
985 if (inc
== 0 && SYMBOL_NAMESPACE (sym
) == namespace)
997 /* Here if block isn't sorted, or we fail to find a match during the
998 binary search above. If during the binary search above, we find a
999 symbol which is a C++ symbol, then we have re-enabled the linear
1000 search flag which was reset when starting the binary search.
1002 This loop is equivalent to the loop above, but hacked greatly for speed.
1004 Note that parameter symbols do not always show up last in the
1005 list; this loop makes sure to take anything else other than
1006 parameter symbols first; it only uses parameter symbols as a
1007 last resort. Note that this only takes up extra computation
1010 if (do_linear_search
)
1012 top
= BLOCK_NSYMS (block
);
1016 sym
= BLOCK_SYM (block
, bot
);
1017 if (SYMBOL_NAMESPACE (sym
) == namespace &&
1018 SYMBOL_MATCHES_NAME (sym
, name
))
1021 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1022 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1023 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1024 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1025 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1026 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
1034 return (sym_found
); /* Will be NULL if not found. */
1038 /* Return the symbol for the function which contains a specified
1039 lexical block, described by a struct block BL. */
1045 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1046 bl
= BLOCK_SUPERBLOCK (bl
);
1048 return BLOCK_FUNCTION (bl
);
1051 /* Find the symtab associated with PC and SECTION. Look through the
1052 psymtabs and read in another symtab if necessary. */
1055 find_pc_sect_symtab (pc
, section
)
1059 register struct block
*b
;
1060 struct blockvector
*bv
;
1061 register struct symtab
*s
= NULL
;
1062 register struct symtab
*best_s
= NULL
;
1063 register struct partial_symtab
*ps
;
1064 register struct objfile
*objfile
;
1065 CORE_ADDR distance
= 0;
1067 /* Search all symtabs for the one whose file contains our address, and which
1068 is the smallest of all the ones containing the address. This is designed
1069 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1070 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1071 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1073 This happens for native ecoff format, where code from included files
1074 gets its own symtab. The symtab for the included file should have
1075 been read in already via the dependency mechanism.
1076 It might be swifter to create several symtabs with the same name
1077 like xcoff does (I'm not sure).
1079 It also happens for objfiles that have their functions reordered.
1080 For these, the symtab we are looking for is not necessarily read in. */
1082 ALL_SYMTABS (objfile
, s
)
1084 bv
= BLOCKVECTOR (s
);
1085 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1086 if (BLOCK_START (b
) <= pc
1087 && BLOCK_END (b
) > pc
1089 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1091 /* For an objfile that has its functions reordered,
1092 find_pc_psymtab will find the proper partial symbol table
1093 and we simply return its corresponding symtab. */
1094 /* In order to better support objfiles that contain both
1095 stabs and coff debugging info, we continue on if a psymtab
1097 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1099 ps
= find_pc_sect_psymtab (pc
, section
);
1101 return PSYMTAB_TO_SYMTAB (ps
);
1107 for (i
= 0; i
< b
->nsyms
; i
++)
1109 fixup_symbol_section (b
->sym
[i
], objfile
);
1110 if (section
== SYMBOL_BFD_SECTION (b
->sym
[i
]))
1114 continue; /* no symbol in this symtab matches section */
1116 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1125 ps
= find_pc_sect_psymtab (pc
, section
);
1129 /* Might want to error() here (in case symtab is corrupt and
1130 will cause a core dump), but maybe we can successfully
1131 continue, so let's not. */
1132 /* FIXME-32x64: assumes pc fits in a long */
1134 (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n",
1135 (unsigned long) pc
);
1136 s
= PSYMTAB_TO_SYMTAB (ps
);
1141 /* Find the symtab associated with PC. Look through the psymtabs and
1142 read in another symtab if necessary. Backward compatibility, no section */
1148 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
1154 /* Find the closest symbol value (of any sort -- function or variable)
1155 for a given address value. Slow but complete. (currently unused,
1156 mainly because it is too slow. We could fix it if each symtab and
1157 psymtab had contained in it the addresses ranges of each of its
1158 sections, which also would be required to make things like "info
1159 line *0x2345" cause psymtabs to be converted to symtabs). */
1162 find_addr_symbol (addr
, symtabp
, symaddrp
)
1164 struct symtab
**symtabp
;
1165 CORE_ADDR
*symaddrp
;
1167 struct symtab
*symtab
, *best_symtab
;
1168 struct objfile
*objfile
;
1169 register int bot
, top
;
1170 register struct symbol
*sym
;
1171 register CORE_ADDR sym_addr
;
1172 struct block
*block
;
1175 /* Info on best symbol seen so far */
1177 register CORE_ADDR best_sym_addr
= 0;
1178 struct symbol
*best_sym
= 0;
1180 /* FIXME -- we should pull in all the psymtabs, too! */
1181 ALL_SYMTABS (objfile
, symtab
)
1183 /* Search the global and static blocks in this symtab for
1184 the closest symbol-address to the desired address. */
1186 for (blocknum
= GLOBAL_BLOCK
; blocknum
<= STATIC_BLOCK
; blocknum
++)
1189 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), blocknum
);
1190 top
= BLOCK_NSYMS (block
);
1191 for (bot
= 0; bot
< top
; bot
++)
1193 sym
= BLOCK_SYM (block
, bot
);
1194 switch (SYMBOL_CLASS (sym
))
1198 sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1202 sym_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1209 if (sym_addr
<= addr
)
1210 if (sym_addr
> best_sym_addr
)
1212 /* Quit if we found an exact match. */
1214 best_sym_addr
= sym_addr
;
1215 best_symtab
= symtab
;
1216 if (sym_addr
== addr
)
1225 *symtabp
= best_symtab
;
1227 *symaddrp
= best_sym_addr
;
1232 /* Find the source file and line number for a given PC value and section.
1233 Return a structure containing a symtab pointer, a line number,
1234 and a pc range for the entire source line.
1235 The value's .pc field is NOT the specified pc.
1236 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1237 use the line that ends there. Otherwise, in that case, the line
1238 that begins there is used. */
1240 /* The big complication here is that a line may start in one file, and end just
1241 before the start of another file. This usually occurs when you #include
1242 code in the middle of a subroutine. To properly find the end of a line's PC
1243 range, we must search all symtabs associated with this compilation unit, and
1244 find the one whose first PC is closer than that of the next line in this
1247 /* If it's worth the effort, we could be using a binary search. */
1249 struct symtab_and_line
1250 find_pc_sect_line (pc
, section
, notcurrent
)
1252 struct sec
*section
;
1256 register struct linetable
*l
;
1259 register struct linetable_entry
*item
;
1260 struct symtab_and_line val
;
1261 struct blockvector
*bv
;
1263 /* Info on best line seen so far, and where it starts, and its file. */
1265 struct linetable_entry
*best
= NULL
;
1266 CORE_ADDR best_end
= 0;
1267 struct symtab
*best_symtab
= 0;
1269 /* Store here the first line number
1270 of a file which contains the line at the smallest pc after PC.
1271 If we don't find a line whose range contains PC,
1272 we will use a line one less than this,
1273 with a range from the start of that file to the first line's pc. */
1274 struct linetable_entry
*alt
= NULL
;
1275 struct symtab
*alt_symtab
= 0;
1277 /* Info on best line seen in this file. */
1279 struct linetable_entry
*prev
;
1281 /* If this pc is not from the current frame,
1282 it is the address of the end of a call instruction.
1283 Quite likely that is the start of the following statement.
1284 But what we want is the statement containing the instruction.
1285 Fudge the pc to make sure we get that. */
1287 INIT_SAL (&val
); /* initialize to zeroes */
1292 s
= find_pc_sect_symtab (pc
, section
);
1299 bv
= BLOCKVECTOR (s
);
1301 /* Look at all the symtabs that share this blockvector.
1302 They all have the same apriori range, that we found was right;
1303 but they have different line tables. */
1305 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1307 /* Find the best line in this symtab. */
1314 /* I think len can be zero if the symtab lacks line numbers
1315 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1316 I'm not sure which, and maybe it depends on the symbol
1322 item
= l
->item
; /* Get first line info */
1324 /* Is this file's first line closer than the first lines of other files?
1325 If so, record this file, and its first line, as best alternate. */
1326 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1332 for (i
= 0; i
< len
; i
++, item
++)
1334 /* Leave prev pointing to the linetable entry for the last line
1335 that started at or before PC. */
1342 /* At this point, prev points at the line whose start addr is <= pc, and
1343 item points at the next line. If we ran off the end of the linetable
1344 (pc >= start of the last line), then prev == item. If pc < start of
1345 the first line, prev will not be set. */
1347 /* Is this file's best line closer than the best in the other files?
1348 If so, record this file, and its best line, as best so far. */
1350 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1354 /* If another line is in the linetable, and its PC is closer
1355 than the best_end we currently have, take it as best_end. */
1356 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1357 best_end
= item
->pc
;
1364 { /* If we didn't find any line # info, just
1370 val
.symtab
= alt_symtab
;
1371 val
.line
= alt
->line
- 1;
1373 /* Don't return line 0, that means that we didn't find the line. */
1374 if (val
.line
== 0) ++val
.line
;
1376 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1382 val
.symtab
= best_symtab
;
1383 val
.line
= best
->line
;
1385 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1390 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1392 val
.section
= section
;
1396 /* Backward compatibility (no section) */
1398 struct symtab_and_line
1399 find_pc_line (pc
, notcurrent
)
1405 section
= find_pc_overlay (pc
);
1406 if (pc_in_unmapped_range (pc
, section
))
1407 pc
= overlay_mapped_address (pc
, section
);
1408 return find_pc_sect_line (pc
, section
, notcurrent
);
1412 static int find_line_symtab
PARAMS ((struct symtab
*, int, struct linetable
**,
1415 /* Find line number LINE in any symtab whose name is the same as
1418 If found, return 1, set *LINETABLE to the linetable in which it was
1419 found, set *INDEX to the index in the linetable of the best entry
1420 found, and set *EXACT_MATCH nonzero if the value returned is an
1423 If not found, return 0. */
1426 find_line_symtab (symtab
, line
, linetable
, index
, exact_match
)
1427 struct symtab
*symtab
;
1429 struct linetable
**linetable
;
1435 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1439 struct linetable
*best_linetable
;
1441 /* First try looking it up in the given symtab. */
1442 best_linetable
= LINETABLE (symtab
);
1443 best_index
= find_line_common (best_linetable
, line
, &exact
);
1444 if (best_index
< 0 || !exact
)
1446 /* Didn't find an exact match. So we better keep looking for
1447 another symtab with the same name. In the case of xcoff,
1448 multiple csects for one source file (produced by IBM's FORTRAN
1449 compiler) produce multiple symtabs (this is unavoidable
1450 assuming csects can be at arbitrary places in memory and that
1451 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1453 /* BEST is the smallest linenumber > LINE so far seen,
1454 or 0 if none has been seen so far.
1455 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1458 struct objfile
*objfile
;
1461 if (best_index
>= 0)
1462 best
= best_linetable
->item
[best_index
].line
;
1466 ALL_SYMTABS (objfile
, s
)
1468 struct linetable
*l
;
1471 if (!STREQ (symtab
->filename
, s
->filename
))
1474 ind
= find_line_common (l
, line
, &exact
);
1483 if (best
== 0 || l
->item
[ind
].line
< best
)
1485 best
= l
->item
[ind
].line
;
1497 *index
= best_index
;
1499 *linetable
= best_linetable
;
1501 *exact_match
= exact
;
1505 /* Find the PC value for a given source file and line number.
1506 Returns zero for invalid line number.
1507 The source file is specified with a struct symtab. */
1510 find_line_pc (symtab
, line
)
1511 struct symtab
*symtab
;
1514 struct linetable
*l
;
1519 if (find_line_symtab (symtab
, line
, &l
, &ind
, NULL
))
1520 return l
->item
[ind
].pc
;
1525 /* Find the range of pc values in a line.
1526 Store the starting pc of the line into *STARTPTR
1527 and the ending pc (start of next line) into *ENDPTR.
1528 Returns 1 to indicate success.
1529 Returns 0 if could not find the specified line. */
1532 find_line_pc_range (sal
, startptr
, endptr
)
1533 struct symtab_and_line sal
;
1534 CORE_ADDR
*startptr
, *endptr
;
1536 CORE_ADDR startaddr
;
1537 struct symtab_and_line found_sal
;
1542 startaddr
= find_line_pc (sal
.symtab
, sal
.line
);
1547 /* This whole function is based on address. For example, if line 10 has
1548 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1549 "info line *0x123" should say the line goes from 0x100 to 0x200
1550 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1551 This also insures that we never give a range like "starts at 0x134
1552 and ends at 0x12c". */
1554 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
1555 if (found_sal
.line
!= sal
.line
)
1557 /* The specified line (sal) has zero bytes. */
1558 *startptr
= found_sal
.pc
;
1559 *endptr
= found_sal
.pc
;
1563 *startptr
= found_sal
.pc
;
1564 *endptr
= found_sal
.end
;
1569 /* Given a line table and a line number, return the index into the line
1570 table for the pc of the nearest line whose number is >= the specified one.
1571 Return -1 if none is found. The value is >= 0 if it is an index.
1573 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1576 find_line_common (l
, lineno
, exact_match
)
1577 register struct linetable
*l
;
1578 register int lineno
;
1584 /* BEST is the smallest linenumber > LINENO so far seen,
1585 or 0 if none has been seen so far.
1586 BEST_INDEX identifies the item for it. */
1588 int best_index
= -1;
1597 for (i
= 0; i
< len
; i
++)
1599 register struct linetable_entry
*item
= &(l
->item
[i
]);
1601 if (item
->line
== lineno
)
1603 /* Return the first (lowest address) entry which matches. */
1608 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
1615 /* If we got here, we didn't get an exact match. */
1622 find_pc_line_pc_range (pc
, startptr
, endptr
)
1624 CORE_ADDR
*startptr
, *endptr
;
1626 struct symtab_and_line sal
;
1627 sal
= find_pc_line (pc
, 0);
1630 return sal
.symtab
!= 0;
1633 /* Given a function symbol SYM, find the symtab and line for the start
1635 If the argument FUNFIRSTLINE is nonzero, we want the first line
1636 of real code inside the function. */
1638 static struct symtab_and_line
1639 find_function_start_sal
PARAMS ((struct symbol
*sym
, int));
1641 static struct symtab_and_line
1642 find_function_start_sal (sym
, funfirstline
)
1647 struct symtab_and_line sal
;
1649 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1650 fixup_symbol_section (sym
, NULL
);
1652 { /* skip "first line" of function (which is actually its prologue) */
1653 asection
*section
= SYMBOL_BFD_SECTION (sym
);
1654 /* If function is in an unmapped overlay, use its unmapped LMA
1655 address, so that SKIP_PROLOGUE has something unique to work on */
1656 if (section_is_overlay (section
) &&
1657 !section_is_mapped (section
))
1658 pc
= overlay_unmapped_address (pc
, section
);
1660 pc
+= FUNCTION_START_OFFSET
;
1663 /* For overlays, map pc back into its mapped VMA range */
1664 pc
= overlay_mapped_address (pc
, section
);
1666 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
1668 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
1669 /* Convex: no need to suppress code on first line, if any */
1672 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
1673 line is still part of the same function. */
1675 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
1676 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
1678 /* First pc of next line */
1680 /* Recalculate the line number (might not be N+1). */
1681 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
1689 /* If P is of the form "operator[ \t]+..." where `...' is
1690 some legitimate operator text, return a pointer to the
1691 beginning of the substring of the operator text.
1692 Otherwise, return "". */
1694 operator_chars (p
, end
)
1699 if (strncmp (p
, "operator", 8))
1703 /* Don't get faked out by `operator' being part of a longer
1705 if (isalpha(*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
1708 /* Allow some whitespace between `operator' and the operator symbol. */
1709 while (*p
== ' ' || *p
== '\t')
1712 /* Recognize 'operator TYPENAME'. */
1714 if (isalpha(*p
) || *p
== '_' || *p
== '$')
1716 register char *q
= p
+1;
1717 while (isalnum(*q
) || *q
== '_' || *q
== '$')
1742 if (p
[1] == '=' || p
[1] == p
[0])
1753 error ("`operator ()' must be specified without whitespace in `()'");
1758 error ("`operator ?:' must be specified without whitespace in `?:'");
1763 error ("`operator []' must be specified without whitespace in `[]'");
1767 error ("`operator %s' not supported", p
);
1774 /* Return the number of methods described for TYPE, including the
1775 methods from types it derives from. This can't be done in the symbol
1776 reader because the type of the baseclass might still be stubbed
1777 when the definition of the derived class is parsed. */
1779 static int total_number_of_methods
PARAMS ((struct type
*type
));
1782 total_number_of_methods (type
)
1788 CHECK_TYPEDEF (type
);
1789 if (TYPE_CPLUS_SPECIFIC (type
) == NULL
)
1791 count
= TYPE_NFN_FIELDS_TOTAL (type
);
1793 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
1794 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
1799 /* Recursive helper function for decode_line_1.
1800 Look for methods named NAME in type T.
1801 Return number of matches.
1802 Put matches in SYM_ARR, which should have been allocated with
1803 a size of total_number_of_methods (T) * sizeof (struct symbol *).
1804 Note that this function is g++ specific. */
1807 find_methods (t
, name
, sym_arr
)
1810 struct symbol
**sym_arr
;
1814 struct symbol
*sym_class
;
1815 char *class_name
= type_name_no_tag (t
);
1816 /* Ignore this class if it doesn't have a name. This is ugly, but
1817 unless we figure out how to get the physname without the name of
1818 the class, then the loop can't do any good. */
1820 && (sym_class
= lookup_symbol (class_name
,
1821 (struct block
*)NULL
,
1824 (struct symtab
**)NULL
)))
1827 /* FIXME: Shouldn't this just be CHECK_TYPEDEF (t)? */
1828 t
= SYMBOL_TYPE (sym_class
);
1829 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
1830 method_counter
>= 0;
1834 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
1835 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
1836 char dem_opname
[64];
1838 if (strncmp(method_name
, "__", 2)==0 ||
1839 strncmp(method_name
, "op", 2)==0 ||
1840 strncmp(method_name
, "type", 4)==0 )
1842 if (cplus_demangle_opname(method_name
, dem_opname
, DMGL_ANSI
))
1843 method_name
= dem_opname
;
1844 else if (cplus_demangle_opname(method_name
, dem_opname
, 0))
1845 method_name
= dem_opname
;
1847 if (STREQ (name
, method_name
))
1848 /* Find all the fields with that name. */
1849 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
1854 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
1855 check_stub_method (t
, method_counter
, field_counter
);
1856 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
1857 /* Destructor is handled by caller, dont add it to the list */
1858 if (DESTRUCTOR_PREFIX_P (phys_name
))
1861 sym_arr
[i1
] = lookup_symbol (phys_name
,
1862 NULL
, VAR_NAMESPACE
,
1864 (struct symtab
**) NULL
);
1869 fputs_filtered("(Cannot find method ", gdb_stdout
);
1870 fprintf_symbol_filtered (gdb_stdout
, phys_name
,
1872 DMGL_PARAMS
| DMGL_ANSI
);
1873 fputs_filtered(" - possibly inlined.)\n", gdb_stdout
);
1879 /* Only search baseclasses if there is no match yet, since names in
1880 derived classes override those in baseclasses.
1882 FIXME: The above is not true; it is only true of member functions
1883 if they have the same number of arguments (??? - section 13.1 of the
1884 ARM says the function members are not in the same scope but doesn't
1885 really spell out the rules in a way I understand. In any case, if
1886 the number of arguments differ this is a case in which we can overload
1887 rather than hiding without any problem, and gcc 2.4.5 does overload
1888 rather than hiding in this case). */
1892 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
1893 i1
+= find_methods(TYPE_BASECLASS(t
, ibase
), name
,
1898 /* Helper function for decode_line_1.
1899 Build a canonical line spec in CANONICAL if it is non-NULL and if
1900 the SAL has a symtab.
1901 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1902 If SYMNAME is NULL the line number from SAL is used and the canonical
1903 line spec is `filename:linenum'. */
1906 build_canonical_line_spec (sal
, symname
, canonical
)
1907 struct symtab_and_line
*sal
;
1911 char **canonical_arr
;
1912 char *canonical_name
;
1914 struct symtab
*s
= sal
->symtab
;
1916 if (s
== (struct symtab
*)NULL
1917 || s
->filename
== (char *)NULL
1918 || canonical
== (char ***)NULL
)
1921 canonical_arr
= (char **) xmalloc (sizeof (char *));
1922 *canonical
= canonical_arr
;
1924 filename
= s
->filename
;
1925 if (symname
!= NULL
)
1927 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
1928 sprintf (canonical_name
, "%s:%s", filename
, symname
);
1932 canonical_name
= xmalloc (strlen (filename
) + 30);
1933 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
1935 canonical_arr
[0] = canonical_name
;
1938 /* Parse a string that specifies a line number.
1939 Pass the address of a char * variable; that variable will be
1940 advanced over the characters actually parsed.
1944 LINENUM -- that line number in current file. PC returned is 0.
1945 FILE:LINENUM -- that line in that file. PC returned is 0.
1946 FUNCTION -- line number of openbrace of that function.
1947 PC returned is the start of the function.
1948 VARIABLE -- line number of definition of that variable.
1950 FILE:FUNCTION -- likewise, but prefer functions in that file.
1951 *EXPR -- line in which address EXPR appears.
1953 FUNCTION may be an undebuggable function found in minimal symbol table.
1955 If the argument FUNFIRSTLINE is nonzero, we want the first line
1956 of real code inside a function when a function is specified, and it is
1957 not OK to specify a variable or type to get its line number.
1959 DEFAULT_SYMTAB specifies the file to use if none is specified.
1960 It defaults to current_source_symtab.
1961 DEFAULT_LINE specifies the line number to use for relative
1962 line numbers (that start with signs). Defaults to current_source_line.
1963 If CANONICAL is non-NULL, store an array of strings containing the canonical
1964 line specs there if necessary. Currently overloaded member functions and
1965 line numbers or static functions without a filename yield a canonical
1966 line spec. The array and the line spec strings are allocated on the heap,
1967 it is the callers responsibility to free them.
1969 Note that it is possible to return zero for the symtab
1970 if no file is validly specified. Callers must check that.
1971 Also, the line number returned may be invalid. */
1973 /* We allow single quotes in various places. This is a hideous
1974 kludge, which exists because the completer can't yet deal with the
1975 lack of single quotes. FIXME: write a linespec_completer which we
1976 can use as appropriate instead of make_symbol_completion_list. */
1978 struct symtabs_and_lines
1979 decode_line_1 (argptr
, funfirstline
, default_symtab
, default_line
, canonical
)
1982 struct symtab
*default_symtab
;
1986 struct symtabs_and_lines values
;
1987 #ifdef HPPA_COMPILER_BUG
1988 /* FIXME: The native HP 9000/700 compiler has a bug which appears
1989 when optimizing this file with target i960-vxworks. I haven't
1990 been able to construct a simple test case. The problem is that
1991 in the second call to SKIP_PROLOGUE below, the compiler somehow
1992 does not realize that the statement val = find_pc_line (...) will
1993 change the values of the fields of val. It extracts the elements
1994 into registers at the top of the block, and does not update the
1995 registers after the call to find_pc_line. You can check this by
1996 inserting a printf at the end of find_pc_line to show what values
1997 it is returning for val.pc and val.end and another printf after
1998 the call to see what values the function actually got (remember,
1999 this is compiling with cc -O, with this patch removed). You can
2000 also examine the assembly listing: search for the second call to
2001 skip_prologue; the LDO statement before the next call to
2002 find_pc_line loads the address of the structure which
2003 find_pc_line will return; if there is a LDW just before the LDO,
2004 which fetches an element of the structure, then the compiler
2007 Setting val to volatile avoids the problem. We must undef
2008 volatile, because the HPPA native compiler does not define
2009 __STDC__, although it does understand volatile, and so volatile
2010 will have been defined away in defs.h. */
2012 volatile struct symtab_and_line val
;
2013 #define volatile /*nothing*/
2015 struct symtab_and_line val
;
2017 register char *p
, *p1
;
2022 register struct symtab
*s
;
2024 register struct symbol
*sym
;
2025 /* The symtab that SYM was found in. */
2026 struct symtab
*sym_symtab
;
2028 register CORE_ADDR pc
;
2029 register struct minimal_symbol
*msymbol
;
2031 struct symbol
*sym_class
;
2033 int is_quoted
, has_parens
;
2034 struct symbol
**sym_arr
;
2036 char *saved_arg
= *argptr
;
2037 extern char *gdb_completer_quote_characters
;
2039 INIT_SAL (&val
); /* initialize to zeroes */
2041 /* Defaults have defaults. */
2043 if (default_symtab
== 0)
2045 default_symtab
= current_source_symtab
;
2046 default_line
= current_source_line
;
2049 /* See if arg is *PC */
2051 if (**argptr
== '*')
2054 pc
= parse_and_eval_address_1 (argptr
);
2055 values
.sals
= (struct symtab_and_line
*)
2056 xmalloc (sizeof (struct symtab_and_line
));
2058 values
.sals
[0] = find_pc_line (pc
, 0);
2059 values
.sals
[0].pc
= pc
;
2063 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
2066 is_quoted
= (**argptr
2067 && strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
2068 has_parens
= ((pp
= strchr (*argptr
, '(')) != NULL
2069 && (pp
= strchr (pp
, ')')) != NULL
);
2071 for (p
= *argptr
; *p
; p
++)
2075 while(++p
&& *p
!= '>');
2078 error ("non-matching '<' and '>' in command");
2081 if (p
[0] == ':' || p
[0] == ' ' || p
[0] == '\t')
2084 while (p
[0] == ' ' || p
[0] == '\t') p
++;
2086 if ((p
[0] == ':') && !has_parens
)
2090 if (is_quoted
) *argptr
= *argptr
+1;
2093 /* Extract the class name. */
2095 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2096 copy
= (char *) alloca (p
- *argptr
+ 1);
2097 memcpy (copy
, *argptr
, p
- *argptr
);
2098 copy
[p
- *argptr
] = 0;
2100 /* Discard the class name from the arg. */
2102 while (*p
== ' ' || *p
== '\t') p
++;
2105 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
2106 (struct symtab
**)NULL
);
2109 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
2110 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
2111 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
2113 /* Arg token is not digits => try it as a function name
2114 Find the next token(everything up to end or next blank). */
2116 && strchr (gdb_completer_quote_characters
, **argptr
) != NULL
)
2118 p
= skip_quoted(*argptr
);
2119 *argptr
= *argptr
+ 1;
2124 while (*p
&& *p
!=' ' && *p
!='\t' && *p
!=',' && *p
!=':') p
++;
2127 q = operator_chars (*argptr, &q1);
2131 char *tmp = alloca (q1 - q + 1);
2132 memcpy (tmp, q, q1 - q);
2134 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
2138 printf_filtered ("no mangling for \"%s\"\n", tmp);
2139 cplusplus_hint (saved_arg);
2140 return_to_top_level (RETURN_ERROR);
2142 copy = (char*) alloca (3 + strlen(opname));
2143 sprintf (copy, "__%s", opname);
2149 copy
= (char *) alloca (p
- *argptr
+ 1 );
2150 memcpy (copy
, *argptr
, p
- *argptr
);
2151 copy
[p
- *argptr
] = '\0';
2153 && copy
[p
- *argptr
- 1]
2154 && strchr (gdb_completer_quote_characters
,
2155 copy
[p
- *argptr
- 1]) != NULL
)
2156 copy
[p
- *argptr
- 1] = '\0';
2159 /* no line number may be specified */
2160 while (*p
== ' ' || *p
== '\t') p
++;
2164 i1
= 0; /* counter for the symbol array */
2165 sym_arr
= (struct symbol
**) alloca(total_number_of_methods (t
)
2166 * sizeof(struct symbol
*));
2168 if (destructor_name_p (copy
, t
))
2170 /* Destructors are a special case. */
2171 int m_index
, f_index
;
2173 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2175 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, m_index
);
2178 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, f_index
),
2179 NULL
, VAR_NAMESPACE
, (int *) NULL
,
2180 (struct symtab
**)NULL
);
2186 i1
= find_methods (t
, copy
, sym_arr
);
2189 /* There is exactly one field with that name. */
2192 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2194 values
.sals
= (struct symtab_and_line
*)
2195 xmalloc (sizeof (struct symtab_and_line
));
2197 values
.sals
[0] = find_function_start_sal (sym
,
2208 /* There is more than one field with that name
2209 (overloaded). Ask the user which one to use. */
2210 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
2216 if (OPNAME_PREFIX_P (copy
))
2218 tmp
= (char *)alloca (strlen (copy
+3) + 9);
2219 strcpy (tmp
, "operator ");
2220 strcat (tmp
, copy
+3);
2227 ("the class `%s' does not have destructor defined\n",
2228 SYMBOL_SOURCE_NAME(sym_class
));
2231 ("the class %s does not have any method named %s\n",
2232 SYMBOL_SOURCE_NAME(sym_class
), tmp
);
2233 cplusplus_hint (saved_arg
);
2234 return_to_top_level (RETURN_ERROR
);
2240 /* The quotes are important if copy is empty. */
2242 ("can't find class, struct, or union named \"%s\"\n", copy
);
2243 cplusplus_hint (saved_arg
);
2244 return_to_top_level (RETURN_ERROR
);
2250 /* Extract the file name. */
2252 while (p
!= *argptr
&& p
[-1] == ' ') --p
;
2253 copy
= (char *) alloca (p
- *argptr
+ 1);
2254 memcpy (copy
, *argptr
, p
- *argptr
);
2255 copy
[p
- *argptr
] = 0;
2257 /* Find that file's data. */
2258 s
= lookup_symtab (copy
);
2261 if (!have_full_symbols () && !have_partial_symbols ())
2262 error (no_symtab_msg
);
2263 error ("No source file named %s.", copy
);
2266 /* Discard the file name from the arg. */
2268 while (*p
== ' ' || *p
== '\t') p
++;
2272 /* S is specified file's symtab, or 0 if no file specified.
2273 arg no longer contains the file name. */
2275 /* Check whether arg is all digits (and sign) */
2278 if (*q
== '-' || *q
== '+') q
++;
2279 while (*q
>= '0' && *q
<= '9')
2282 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
2284 /* We found a token consisting of all digits -- at least one digit. */
2285 enum sign
{none
, plus
, minus
} sign
= none
;
2287 /* We might need a canonical line spec if no file was specified. */
2288 int need_canonical
= (s
== 0) ? 1 : 0;
2290 /* This is where we need to make sure that we have good defaults.
2291 We must guarantee that this section of code is never executed
2292 when we are called with just a function name, since
2293 select_source_symtab calls us with such an argument */
2295 if (s
== 0 && default_symtab
== 0)
2297 select_source_symtab (0);
2298 default_symtab
= current_source_symtab
;
2299 default_line
= current_source_line
;
2302 if (**argptr
== '+')
2303 sign
= plus
, (*argptr
)++;
2304 else if (**argptr
== '-')
2305 sign
= minus
, (*argptr
)++;
2306 val
.line
= atoi (*argptr
);
2313 val
.line
= default_line
+ val
.line
;
2319 val
.line
= default_line
- val
.line
;
2324 break; /* No need to adjust val.line. */
2327 while (*q
== ' ' || *q
== '\t') q
++;
2333 values
.sals
= (struct symtab_and_line
*)
2334 xmalloc (sizeof (struct symtab_and_line
));
2335 values
.sals
[0] = val
;
2338 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2342 /* Arg token is not digits => try it as a variable name
2343 Find the next token (everything up to end or next whitespace). */
2345 if (**argptr
== '$') /* Convenience variable */
2346 p
= skip_quoted (*argptr
+ 1);
2349 p
= skip_quoted (*argptr
);
2351 error ("Unmatched single quote.");
2353 else if (has_parens
)
2359 p
= skip_quoted(*argptr
);
2362 copy
= (char *) alloca (p
- *argptr
+ 1);
2363 memcpy (copy
, *argptr
, p
- *argptr
);
2364 copy
[p
- *argptr
] = '\0';
2367 && copy
[0] == copy
[p
- *argptr
- 1]
2368 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
2370 copy
[p
- *argptr
- 1] = '\0';
2373 while (*p
== ' ' || *p
== '\t') p
++;
2376 /* See if it's a convenience variable */
2381 int need_canonical
= (s
== 0) ? 1 : 0;
2383 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
2384 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
2385 error ("Convenience variables used in line specs must have integer values.");
2387 val
.symtab
= s
? s
: default_symtab
;
2388 val
.line
= value_as_long (valx
);
2391 values
.sals
= (struct symtab_and_line
*)xmalloc (sizeof val
);
2392 values
.sals
[0] = val
;
2396 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
2402 /* Look up that token as a variable.
2403 If file specified, use that file's per-file block to start with. */
2405 sym
= lookup_symbol (copy
,
2406 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
2407 : get_selected_block ()),
2408 VAR_NAMESPACE
, 0, &sym_symtab
);
2412 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2414 /* Arg is the name of a function */
2415 values
.sals
= (struct symtab_and_line
*)
2416 xmalloc (sizeof (struct symtab_and_line
));
2417 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
2420 /* Don't use the SYMBOL_LINE; if used at all it points to
2421 the line containing the parameters or thereabouts, not
2422 the first line of code. */
2424 /* We might need a canonical line spec if it is a static
2428 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
2429 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2430 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
2431 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2438 error ("\"%s\" is not a function", copy
);
2439 else if (SYMBOL_LINE (sym
) != 0)
2441 /* We know its line number. */
2442 values
.sals
= (struct symtab_and_line
*)
2443 xmalloc (sizeof (struct symtab_and_line
));
2445 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2446 values
.sals
[0].symtab
= sym_symtab
;
2447 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2451 /* This can happen if it is compiled with a compiler which doesn't
2452 put out line numbers for variables. */
2453 /* FIXME: Shouldn't we just set .line and .symtab to zero
2454 and return? For example, "info line foo" could print
2456 error ("Line number not known for symbol \"%s\"", copy
);
2460 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
2461 if (msymbol
!= NULL
)
2463 val
.pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2464 val
.section
= SYMBOL_BFD_SECTION (msymbol
);
2467 val
.pc
+= FUNCTION_START_OFFSET
;
2468 SKIP_PROLOGUE (val
.pc
);
2470 values
.sals
= (struct symtab_and_line
*)
2471 xmalloc (sizeof (struct symtab_and_line
));
2472 values
.sals
[0] = val
;
2477 if (!have_full_symbols () &&
2478 !have_partial_symbols () && !have_minimal_symbols ())
2479 error (no_symtab_msg
);
2481 error ("Function \"%s\" not defined.", copy
);
2482 return values
; /* for lint */
2485 struct symtabs_and_lines
2486 decode_line_spec (string
, funfirstline
)
2490 struct symtabs_and_lines sals
;
2492 error ("Empty line specification.");
2493 sals
= decode_line_1 (&string
, funfirstline
,
2494 current_source_symtab
, current_source_line
,
2497 error ("Junk at end of line specification: %s", string
);
2501 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2502 operate on (ask user if necessary).
2503 If CANONICAL is non-NULL return a corresponding array of mangled names
2504 as canonical line specs there. */
2506 static struct symtabs_and_lines
2507 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
2508 struct symbol
*sym_arr
[];
2513 struct symtabs_and_lines values
, return_values
;
2518 struct cleanup
*old_chain
;
2519 char **canonical_arr
= (char **)NULL
;
2521 values
.sals
= (struct symtab_and_line
*)
2522 alloca (nelts
* sizeof(struct symtab_and_line
));
2523 return_values
.sals
= (struct symtab_and_line
*)
2524 xmalloc (nelts
* sizeof(struct symtab_and_line
));
2525 old_chain
= make_cleanup (free
, return_values
.sals
);
2529 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
2530 make_cleanup (free
, canonical_arr
);
2531 memset (canonical_arr
, 0, nelts
* sizeof (char *));
2532 *canonical
= canonical_arr
;
2536 printf_unfiltered("[0] cancel\n[1] all\n");
2539 INIT_SAL (&return_values
.sals
[i
]); /* initialize to zeroes */
2540 INIT_SAL (&values
.sals
[i
]);
2541 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
2543 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
2544 printf_unfiltered ("[%d] %s at %s:%d\n",
2546 SYMBOL_SOURCE_NAME (sym_arr
[i
]),
2547 values
.sals
[i
].symtab
->filename
,
2548 values
.sals
[i
].line
);
2551 printf_unfiltered ("?HERE\n");
2555 if ((prompt
= getenv ("PS2")) == NULL
)
2559 printf_unfiltered("%s ",prompt
);
2560 gdb_flush(gdb_stdout
);
2562 args
= command_line_input ((char *) NULL
, 0, "overload-choice");
2564 if (args
== 0 || *args
== 0)
2565 error_no_arg ("one or more choice numbers");
2573 while (*arg1
>= '0' && *arg1
<= '9') arg1
++;
2574 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
2575 error ("Arguments must be choice numbers.");
2580 error ("cancelled");
2585 for (i
= 0; i
< nelts
; i
++)
2587 if (canonical_arr
[i
] == NULL
)
2589 symname
= SYMBOL_NAME (sym_arr
[i
]);
2590 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2594 memcpy (return_values
.sals
, values
.sals
,
2595 (nelts
* sizeof(struct symtab_and_line
)));
2596 return_values
.nelts
= nelts
;
2597 discard_cleanups (old_chain
);
2598 return return_values
;
2601 if (num
>= nelts
+ 2)
2603 printf_unfiltered ("No choice number %d.\n", num
);
2608 if (values
.sals
[num
].pc
)
2612 symname
= SYMBOL_NAME (sym_arr
[num
]);
2613 make_cleanup (free
, symname
);
2614 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
2616 return_values
.sals
[i
++] = values
.sals
[num
];
2617 values
.sals
[num
].pc
= 0;
2621 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
2626 while (*args
== ' ' || *args
== '\t') args
++;
2628 return_values
.nelts
= i
;
2629 discard_cleanups (old_chain
);
2630 return return_values
;
2634 /* Slave routine for sources_info. Force line breaks at ,'s.
2635 NAME is the name to print and *FIRST is nonzero if this is the first
2636 name printed. Set *FIRST to zero. */
2638 output_source_filename (name
, first
)
2642 /* Table of files printed so far. Since a single source file can
2643 result in several partial symbol tables, we need to avoid printing
2644 it more than once. Note: if some of the psymtabs are read in and
2645 some are not, it gets printed both under "Source files for which
2646 symbols have been read" and "Source files for which symbols will
2647 be read in on demand". I consider this a reasonable way to deal
2648 with the situation. I'm not sure whether this can also happen for
2649 symtabs; it doesn't hurt to check. */
2650 static char **tab
= NULL
;
2651 /* Allocated size of tab in elements.
2652 Start with one 256-byte block (when using GNU malloc.c).
2653 24 is the malloc overhead when range checking is in effect. */
2654 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2655 /* Current size of tab in elements. */
2656 static int tab_cur_size
;
2663 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2667 /* Is NAME in tab? */
2668 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2669 if (STREQ (*p
, name
))
2670 /* Yes; don't print it again. */
2672 /* No; add it to tab. */
2673 if (tab_cur_size
== tab_alloc_size
)
2675 tab_alloc_size
*= 2;
2676 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
2678 tab
[tab_cur_size
++] = name
;
2686 printf_filtered (", ");
2690 fputs_filtered (name
, gdb_stdout
);
2694 sources_info (ignore
, from_tty
)
2698 register struct symtab
*s
;
2699 register struct partial_symtab
*ps
;
2700 register struct objfile
*objfile
;
2703 if (!have_full_symbols () && !have_partial_symbols ())
2705 error (no_symtab_msg
);
2708 printf_filtered ("Source files for which symbols have been read in:\n\n");
2711 ALL_SYMTABS (objfile
, s
)
2713 output_source_filename (s
-> filename
, &first
);
2715 printf_filtered ("\n\n");
2717 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2720 ALL_PSYMTABS (objfile
, ps
)
2724 output_source_filename (ps
-> filename
, &first
);
2727 printf_filtered ("\n");
2730 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2731 If CLASS is zero, list all symbols except functions, type names, and
2733 If CLASS is 1, list only functions.
2734 If CLASS is 2, list only type names.
2735 If CLASS is 3, list only method names.
2737 BPT is non-zero if we should set a breakpoint at the functions
2741 list_symbols (regexp
, class, bpt
, from_tty
)
2747 register struct symtab
*s
;
2748 register struct partial_symtab
*ps
;
2749 register struct blockvector
*bv
;
2750 struct blockvector
*prev_bv
= 0;
2751 register struct block
*b
;
2753 register struct symbol
*sym
;
2754 struct partial_symbol
**psym
;
2755 struct objfile
*objfile
;
2756 struct minimal_symbol
*msymbol
;
2758 static char *classnames
[]
2759 = {"variable", "function", "type", "method"};
2760 int found_in_file
= 0;
2762 static enum minimal_symbol_type types
[]
2763 = {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2764 static enum minimal_symbol_type types2
[]
2765 = {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2766 static enum minimal_symbol_type types3
[]
2767 = {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2768 static enum minimal_symbol_type types4
[]
2769 = {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2770 enum minimal_symbol_type ourtype
= types
[class];
2771 enum minimal_symbol_type ourtype2
= types2
[class];
2772 enum minimal_symbol_type ourtype3
= types3
[class];
2773 enum minimal_symbol_type ourtype4
= types4
[class];
2777 /* Make sure spacing is right for C++ operators.
2778 This is just a courtesy to make the matching less sensitive
2779 to how many spaces the user leaves between 'operator'
2780 and <TYPENAME> or <OPERATOR>. */
2782 char *opname
= operator_chars (regexp
, &opend
);
2785 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2786 if (isalpha(*opname
) || *opname
== '_' || *opname
== '$')
2788 /* There should 1 space between 'operator' and 'TYPENAME'. */
2789 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2794 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2795 if (opname
[-1] == ' ')
2798 /* If wrong number of spaces, fix it. */
2801 char *tmp
= (char*) alloca(opend
-opname
+10);
2802 sprintf(tmp
, "operator%.*s%s", fix
, " ", opname
);
2807 if (0 != (val
= re_comp (regexp
)))
2808 error ("Invalid regexp (%s): %s", val
, regexp
);
2811 /* Search through the partial symtabs *first* for all symbols
2812 matching the regexp. That way we don't have to reproduce all of
2813 the machinery below. */
2815 ALL_PSYMTABS (objfile
, ps
)
2817 struct partial_symbol
**bound
, **gbound
, **sbound
;
2820 if (ps
->readin
) continue;
2822 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2823 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2826 /* Go through all of the symbols stored in a partial
2827 symtab in one loop. */
2828 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2833 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2835 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2846 /* If it would match (logic taken from loop below)
2847 load the file and go on to the next one */
2848 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (*psym
))
2849 && ((class == 0 && SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
2850 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
2851 || (class == 1 && SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
2852 || (class == 2 && SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
2853 || (class == 3 && SYMBOL_CLASS (*psym
) == LOC_BLOCK
)))
2855 PSYMTAB_TO_SYMTAB(ps
);
2863 /* Here, we search through the minimal symbol tables for functions
2864 and variables that match, and force their symbols to be read.
2865 This is in particular necessary for demangled variable names,
2866 which are no longer put into the partial symbol tables.
2867 The symbol will then be found during the scan of symtabs below.
2869 For functions, find_pc_symtab should succeed if we have debug info
2870 for the function, for variables we have to call lookup_symbol
2871 to determine if the variable has debug info.
2872 If the lookup fails, set found_misc so that we will rescan to print
2873 any matching symbols without debug info.
2876 if (class == 0 || class == 1)
2878 ALL_MSYMBOLS (objfile
, msymbol
)
2880 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2881 MSYMBOL_TYPE (msymbol
) == ourtype2
||
2882 MSYMBOL_TYPE (msymbol
) == ourtype3
||
2883 MSYMBOL_TYPE (msymbol
) == ourtype4
)
2885 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2887 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2890 || lookup_symbol (SYMBOL_NAME (msymbol
),
2891 (struct block
*) NULL
,
2893 0, (struct symtab
**) NULL
) == NULL
)
2901 /* Printout here so as to get after the "Reading in symbols"
2902 messages which will be generated above. */
2904 printf_filtered (regexp
2905 ? "All %ss matching regular expression \"%s\":\n"
2906 : "All defined %ss:\n",
2910 ALL_SYMTABS (objfile
, s
)
2913 bv
= BLOCKVECTOR (s
);
2914 /* Often many files share a blockvector.
2915 Scan each blockvector only once so that
2916 we don't get every symbol many times.
2917 It happens that the first symtab in the list
2918 for any given blockvector is the main file. */
2920 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2922 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2923 /* Skip the sort if this block is always sorted. */
2924 if (!BLOCK_SHOULD_SORT (b
))
2925 sort_block_syms (b
);
2926 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
2929 sym
= BLOCK_SYM (b
, j
);
2930 if ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2931 && ((class == 0 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2932 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2933 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2934 || (class == 1 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2935 || (class == 2 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2936 || (class == 3 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)))
2940 /* Set a breakpoint here, if it's a function */
2943 /* There may be more than one function with the
2944 same name but in different files. In order to
2945 set breakpoints on all of them, we must give
2946 both the file name and the function name to
2948 Quoting the symbol name gets rid of problems
2949 with mangled symbol names that contain
2950 CPLUS_MARKER characters. */
2952 (char *) alloca (strlen (s
->filename
)
2953 + strlen (SYMBOL_NAME(sym
))
2955 strcpy (string
, s
->filename
);
2956 strcat (string
, ":'");
2957 strcat (string
, SYMBOL_NAME(sym
));
2958 strcat (string
, "'");
2959 break_command (string
, from_tty
);
2962 else if (!found_in_file
)
2964 fputs_filtered ("\nFile ", gdb_stdout
);
2965 fputs_filtered (s
->filename
, gdb_stdout
);
2966 fputs_filtered (":\n", gdb_stdout
);
2970 if (class != 2 && i
== STATIC_BLOCK
)
2971 printf_filtered ("static ");
2973 /* Typedef that is not a C++ class */
2975 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
2976 c_typedef_print (SYMBOL_TYPE(sym
), sym
, gdb_stdout
);
2977 /* variable, func, or typedef-that-is-c++-class */
2978 else if (class < 2 ||
2980 SYMBOL_NAMESPACE(sym
) == STRUCT_NAMESPACE
))
2982 type_print (SYMBOL_TYPE (sym
),
2983 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2984 ? "" : SYMBOL_SOURCE_NAME (sym
)),
2987 printf_filtered (";\n");
2992 /* Tiemann says: "info methods was never implemented." */
2993 char *demangled_name
;
2994 c_type_print_base (TYPE_FN_FIELD_TYPE(t
, i
),
2996 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t
, i
),
2998 if (TYPE_FN_FIELD_STUB (t
, i
))
2999 check_stub_method (TYPE_DOMAIN_TYPE (type
), j
, i
);
3001 cplus_demangle (TYPE_FN_FIELD_PHYSNAME (t
, i
),
3002 DMGL_ANSI
| DMGL_PARAMS
);
3003 if (demangled_name
== NULL
)
3004 fprintf_filtered (stream
, "<badly mangled name %s>",
3005 TYPE_FN_FIELD_PHYSNAME (t
, i
));
3008 fputs_filtered (demangled_name
, stream
);
3009 free (demangled_name
);
3019 /* If there are no eyes, avoid all contact. I mean, if there are
3020 no debug symbols, then print directly from the msymbol_vector. */
3022 if (found_misc
|| class != 1)
3025 ALL_MSYMBOLS (objfile
, msymbol
)
3027 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3028 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3029 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3030 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3032 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
3034 /* Functions: Look up by address. */
3036 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3038 /* Variables/Absolutes: Look up by name */
3039 if (lookup_symbol (SYMBOL_NAME (msymbol
),
3040 (struct block
*) NULL
, VAR_NAMESPACE
,
3041 0, (struct symtab
**) NULL
) == NULL
)
3045 break_command (SYMBOL_NAME (msymbol
), from_tty
);
3046 printf_filtered ("<function, no debug info> %s;\n",
3047 SYMBOL_SOURCE_NAME (msymbol
));
3052 printf_filtered ("\nNon-debugging symbols:\n");
3055 printf_filtered (" %08lx %s\n",
3056 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
3057 SYMBOL_SOURCE_NAME (msymbol
));
3067 variables_info (regexp
, from_tty
)
3071 list_symbols (regexp
, 0, 0, from_tty
);
3075 functions_info (regexp
, from_tty
)
3079 list_symbols (regexp
, 1, 0, from_tty
);
3083 types_info (regexp
, from_tty
)
3087 list_symbols (regexp
, 2, 0, from_tty
);
3091 /* Tiemann says: "info methods was never implemented." */
3093 methods_info (regexp
)
3096 list_symbols (regexp
, 3, 0, from_tty
);
3100 /* Breakpoint all functions matching regular expression. */
3102 rbreak_command (regexp
, from_tty
)
3106 list_symbols (regexp
, 1, 1, from_tty
);
3110 /* Return Nonzero if block a is lexically nested within block b,
3111 or if a and b have the same pc range.
3112 Return zero otherwise. */
3115 struct block
*a
, *b
;
3119 return BLOCK_START (a
) >= BLOCK_START (b
)
3120 && BLOCK_END (a
) <= BLOCK_END (b
);
3124 /* Helper routine for make_symbol_completion_list. */
3126 static int return_val_size
;
3127 static int return_val_index
;
3128 static char **return_val
;
3130 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3132 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
3133 /* Put only the mangled name on the list. */ \
3134 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
3135 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
3136 completion_list_add_name \
3137 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
3139 completion_list_add_name \
3140 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
3143 /* Test to see if the symbol specified by SYMNAME (which is already
3144 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3145 characters. If so, add it to the current completion list. */
3148 completion_list_add_name (symname
, sym_text
, sym_text_len
, text
, word
)
3158 /* clip symbols that cannot match */
3160 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3165 /* Clip any symbol names that we've already considered. (This is a
3166 time optimization) */
3168 for (i
= 0; i
< return_val_index
; ++i
)
3170 if (STREQ (symname
, return_val
[i
]))
3176 /* We have a match for a completion, so add SYMNAME to the current list
3177 of matches. Note that the name is moved to freshly malloc'd space. */
3181 if (word
== sym_text
)
3183 new = xmalloc (strlen (symname
) + 5);
3184 strcpy (new, symname
);
3186 else if (word
> sym_text
)
3188 /* Return some portion of symname. */
3189 new = xmalloc (strlen (symname
) + 5);
3190 strcpy (new, symname
+ (word
- sym_text
));
3194 /* Return some of SYM_TEXT plus symname. */
3195 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3196 strncpy (new, word
, sym_text
- word
);
3197 new[sym_text
- word
] = '\0';
3198 strcat (new, symname
);
3201 /* Recheck for duplicates if we intend to add a modified symbol. */
3202 if (word
!= sym_text
)
3204 for (i
= 0; i
< return_val_index
; ++i
)
3206 if (STREQ (new, return_val
[i
]))
3214 if (return_val_index
+ 3 > return_val_size
)
3216 newsize
= (return_val_size
*= 2) * sizeof (char *);
3217 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3219 return_val
[return_val_index
++] = new;
3220 return_val
[return_val_index
] = NULL
;
3224 /* Return a NULL terminated array of all symbols (regardless of class) which
3225 begin by matching TEXT. If the answer is no symbols, then the return value
3226 is an array which contains only a NULL pointer.
3228 Problem: All of the symbols have to be copied because readline frees them.
3229 I'm not going to worry about this; hopefully there won't be that many. */
3232 make_symbol_completion_list (text
, word
)
3236 register struct symbol
*sym
;
3237 register struct symtab
*s
;
3238 register struct partial_symtab
*ps
;
3239 register struct minimal_symbol
*msymbol
;
3240 register struct objfile
*objfile
;
3241 register struct block
*b
, *surrounding_static_block
= 0;
3243 struct partial_symbol
**psym
;
3244 /* The symbol we are completing on. Points in same buffer as text. */
3246 /* Length of sym_text. */
3249 /* Now look for the symbol we are supposed to complete on.
3250 FIXME: This should be language-specific. */
3254 char *quote_pos
= NULL
;
3256 /* First see if this is a quoted string. */
3258 for (p
= text
; *p
!= '\0'; ++p
)
3260 if (quote_found
!= '\0')
3262 if (*p
== quote_found
)
3263 /* Found close quote. */
3265 else if (*p
== '\\' && p
[1] == quote_found
)
3266 /* A backslash followed by the quote character
3267 doesn't end the string. */
3270 else if (*p
== '\'' || *p
== '"')
3276 if (quote_found
== '\'')
3277 /* A string within single quotes can be a symbol, so complete on it. */
3278 sym_text
= quote_pos
+ 1;
3279 else if (quote_found
== '"')
3280 /* A double-quoted string is never a symbol, nor does it make sense
3281 to complete it any other way. */
3285 /* It is not a quoted string. Break it based on the characters
3286 which are in symbols. */
3289 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3298 sym_text_len
= strlen (sym_text
);
3300 return_val_size
= 100;
3301 return_val_index
= 0;
3302 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3303 return_val
[0] = NULL
;
3305 /* Look through the partial symtabs for all symbols which begin
3306 by matching SYM_TEXT. Add each one that you find to the list. */
3308 ALL_PSYMTABS (objfile
, ps
)
3310 /* If the psymtab's been read in we'll get it when we search
3311 through the blockvector. */
3312 if (ps
->readin
) continue;
3314 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3315 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3316 + ps
->n_global_syms
);
3319 /* If interrupted, then quit. */
3321 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3324 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3325 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3326 + ps
->n_static_syms
);
3330 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3334 /* At this point scan through the misc symbol vectors and add each
3335 symbol you find to the list. Eventually we want to ignore
3336 anything that isn't a text symbol (everything else will be
3337 handled by the psymtab code above). */
3339 ALL_MSYMBOLS (objfile
, msymbol
)
3342 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3345 /* Search upwards from currently selected frame (so that we can
3346 complete on local vars. */
3348 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3350 if (!BLOCK_SUPERBLOCK (b
))
3352 surrounding_static_block
= b
; /* For elmin of dups */
3355 /* Also catch fields of types defined in this places which match our
3356 text string. Only complete on types visible from current context. */
3358 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3360 sym
= BLOCK_SYM (b
, i
);
3361 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3362 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3364 struct type
*t
= SYMBOL_TYPE (sym
);
3365 enum type_code c
= TYPE_CODE (t
);
3367 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3369 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3371 if (TYPE_FIELD_NAME (t
, j
))
3373 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3374 sym_text
, sym_text_len
, text
, word
);
3382 /* Go through the symtabs and check the externs and statics for
3383 symbols which match. */
3385 ALL_SYMTABS (objfile
, s
)
3388 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3389 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3391 sym
= BLOCK_SYM (b
, i
);
3392 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3396 ALL_SYMTABS (objfile
, s
)
3399 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3400 /* Don't do this block twice. */
3401 if (b
== surrounding_static_block
) continue;
3402 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
3404 sym
= BLOCK_SYM (b
, i
);
3405 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3409 return (return_val
);
3412 /* Determine if PC is in the prologue of a function. The prologue is the area
3413 between the first instruction of a function, and the first executable line.
3414 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3416 If non-zero, func_start is where we think the prologue starts, possibly
3417 by previous examination of symbol table information.
3421 in_prologue (pc
, func_start
)
3423 CORE_ADDR func_start
;
3425 struct symtab_and_line sal
;
3426 CORE_ADDR func_addr
, func_end
;
3428 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3429 goto nosyms
; /* Might be in prologue */
3431 sal
= find_pc_line (func_addr
, 0);
3436 if (sal
.end
> func_addr
3437 && sal
.end
<= func_end
) /* Is prologue in function? */
3438 return pc
< sal
.end
; /* Yes, is pc in prologue? */
3440 /* The line after the prologue seems to be outside the function. In this
3441 case, tell the caller to find the prologue the hard way. */
3445 /* Come here when symtabs don't contain line # info. In this case, it is
3446 likely that the user has stepped into a library function w/o symbols, or
3447 is doing a stepi/nexti through code without symbols. */
3451 /* If func_start is zero (meaning unknown) then we don't know whether pc is
3452 in the prologue or not. I.E. it might be. */
3454 if (!func_start
) return 1;
3456 /* We need to call the target-specific prologue skipping functions with the
3457 function's start address because PC may be pointing at an instruction that
3458 could be mistakenly considered part of the prologue. */
3460 SKIP_PROLOGUE (func_start
);
3462 return pc
< func_start
;
3467 _initialize_symtab ()
3469 add_info ("variables", variables_info
,
3470 "All global and static variable names, or those matching REGEXP.");
3471 add_info ("functions", functions_info
,
3472 "All function names, or those matching REGEXP.");
3474 /* FIXME: This command has at least the following problems:
3475 1. It prints builtin types (in a very strange and confusing fashion).
3476 2. It doesn't print right, e.g. with
3477 typedef struct foo *FOO
3478 type_print prints "FOO" when we want to make it (in this situation)
3479 print "struct foo *".
3480 I also think "ptype" or "whatis" is more likely to be useful (but if
3481 there is much disagreement "info types" can be fixed). */
3482 add_info ("types", types_info
,
3483 "All type names, or those matching REGEXP.");
3486 add_info ("methods", methods_info
,
3487 "All method names, or those matching REGEXP::REGEXP.\n\
3488 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3489 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3492 add_info ("sources", sources_info
,
3493 "Source files in the program.");
3495 add_com ("rbreak", no_class
, rbreak_command
,
3496 "Set a breakpoint for all functions matching REGEXP.");
3498 /* Initialize the one built-in type that isn't language dependent... */
3499 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
3500 "<unknown type>", (struct objfile
*) NULL
);