1 /* Symbol table lookup for the GNU debugger, GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
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,
20 Boston, MA 02111-1307, USA. */
32 #include "call-cmds.h"
33 #include "gdb_regex.h"
34 #include "expression.h"
41 #include <sys/types.h>
43 #include "gdb_string.h"
47 /* Prototype for one function in parser-defs.h,
48 instead of including that entire file. */
50 extern char *find_template_name_end (char *);
52 /* Prototypes for local functions */
54 static int find_methods (struct type
*, char *, struct symbol
**);
56 static void completion_list_add_name (char *, char *, int, char *, char *);
58 static void build_canonical_line_spec (struct symtab_and_line
*,
61 static struct symtabs_and_lines
decode_line_2 (struct symbol
*[],
64 static void rbreak_command (char *, int);
66 static void types_info (char *, int);
68 static void functions_info (char *, int);
70 static void variables_info (char *, int);
72 static void sources_info (char *, int);
74 static void output_source_filename (char *, int *);
76 char *operator_chars (char *, char **);
78 static int find_line_common (struct linetable
*, int, int *);
80 static struct partial_symbol
*lookup_partial_symbol (struct partial_symtab
*,
84 static struct symtab
*lookup_symtab_1 (char *);
86 static struct symbol
*lookup_symbol_aux (const char *name
, const
87 struct block
*block
, const
88 namespace_enum
namespace, int
89 *is_a_field_of_this
, struct
93 static void cplusplus_hint (char *);
95 static struct symbol
*find_active_alias (struct symbol
*sym
, CORE_ADDR addr
);
97 /* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */
98 /* Signals the presence of objects compiled by HP compilers */
99 int hp_som_som_object_present
= 0;
101 static void fixup_section (struct general_symbol_info
*, struct objfile
*);
103 static int file_matches (char *, char **, int);
105 static void print_symbol_info (namespace_enum
,
106 struct symtab
*, struct symbol
*, int, char *);
108 static void print_msymbol_info (struct minimal_symbol
*);
110 static void symtab_symbol_info (char *, namespace_enum
, int);
112 static void overload_list_add_symbol (struct symbol
*sym
, char *oload_name
);
114 void _initialize_symtab (void);
118 /* The single non-language-specific builtin type */
119 struct type
*builtin_type_error
;
121 /* Block in which the most recently searched-for symbol was found.
122 Might be better to make this a parameter to lookup_symbol and
125 const struct block
*block_found
;
127 char no_symtab_msg
[] = "No symbol table is loaded. Use the \"file\" command.";
129 /* While the C++ support is still in flux, issue a possibly helpful hint on
130 using the new command completion feature on single quoted demangled C++
131 symbols. Remove when loose ends are cleaned up. FIXME -fnf */
134 cplusplus_hint (char *name
)
136 while (*name
== '\'')
138 printf_filtered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name
, name
);
139 printf_filtered ("(Note leading single quote.)\n");
142 /* Check for a symtab of a specific name; first in symtabs, then in
143 psymtabs. *If* there is no '/' in the name, a match after a '/'
144 in the symtab filename will also work. */
146 static struct symtab
*
147 lookup_symtab_1 (char *name
)
149 register struct symtab
*s
;
150 register struct partial_symtab
*ps
;
151 register char *slash
;
152 register struct objfile
*objfile
;
156 /* First, search for an exact match */
158 ALL_SYMTABS (objfile
, s
)
159 if (STREQ (name
, s
->filename
))
162 slash
= strchr (name
, '/');
164 /* Now, search for a matching tail (only if name doesn't have any dirs) */
167 ALL_SYMTABS (objfile
, s
)
169 char *p
= s
->filename
;
170 char *tail
= strrchr (p
, '/');
179 /* Same search rules as above apply here, but now we look thru the
182 ps
= lookup_partial_symtab (name
);
187 error ("Internal: readin %s pst for `%s' found when no symtab found.",
190 s
= PSYMTAB_TO_SYMTAB (ps
);
195 /* At this point, we have located the psymtab for this file, but
196 the conversion to a symtab has failed. This usually happens
197 when we are looking up an include file. In this case,
198 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
199 been created. So, we need to run through the symtabs again in
200 order to find the file.
201 XXX - This is a crock, and should be fixed inside of the the
202 symbol parsing routines. */
206 /* Lookup the symbol table of a source file named NAME. Try a couple
207 of variations if the first lookup doesn't work. */
210 lookup_symtab (char *name
)
212 register struct symtab
*s
;
217 s
= lookup_symtab_1 (name
);
222 /* This screws c-exp.y:yylex if there is both a type "tree" and a symtab
225 /* If name not found as specified, see if adding ".c" helps. */
226 /* Why is this? Is it just a user convenience? (If so, it's pretty
227 questionable in the presence of C++, FORTRAN, etc.). It's not in
230 copy
= (char *) alloca (strlen (name
) + 3);
233 s
= lookup_symtab_1 (copy
);
238 /* We didn't find anything; die. */
242 /* Lookup the partial symbol table of a source file named NAME.
243 *If* there is no '/' in the name, a match after a '/'
244 in the psymtab filename will also work. */
246 struct partial_symtab
*
247 lookup_partial_symtab (char *name
)
249 register struct partial_symtab
*pst
;
250 register struct objfile
*objfile
;
252 ALL_PSYMTABS (objfile
, pst
)
254 if (STREQ (name
, pst
->filename
))
260 /* Now, search for a matching tail (only if name doesn't have any dirs) */
262 if (!strchr (name
, '/'))
263 ALL_PSYMTABS (objfile
, pst
)
265 char *p
= pst
->filename
;
266 char *tail
= strrchr (p
, '/');
278 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
279 full method name, which consist of the class name (from T), the unadorned
280 method name from METHOD_ID, and the signature for the specific overload,
281 specified by SIGNATURE_ID. Note that this function is g++ specific. */
284 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
286 int mangled_name_len
;
288 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
289 struct fn_field
*method
= &f
[signature_id
];
290 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
291 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
292 char *newname
= type_name_no_tag (type
);
294 /* Does the form of physname indicate that it is the full mangled name
295 of a constructor (not just the args)? */
296 int is_full_physname_constructor
;
299 int is_destructor
= DESTRUCTOR_PREFIX_P (physname
);
300 /* Need a new type prefix. */
301 char *const_prefix
= method
->is_const
? "C" : "";
302 char *volatile_prefix
= method
->is_volatile
? "V" : "";
304 int len
= (newname
== NULL
? 0 : strlen (newname
));
306 if (OPNAME_PREFIX_P (field_name
))
307 return xstrdup (physname
);
309 is_full_physname_constructor
=
310 ((physname
[0] == '_' && physname
[1] == '_' &&
311 (isdigit (physname
[2]) || physname
[2] == 'Q' || physname
[2] == 't'))
312 || (strncmp (physname
, "__ct", 4) == 0));
315 is_full_physname_constructor
|| (newname
&& STREQ (field_name
, newname
));
318 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
320 if (is_destructor
|| is_full_physname_constructor
)
322 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
323 strcpy (mangled_name
, physname
);
329 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
331 else if (physname
[0] == 't' || physname
[0] == 'Q')
333 /* The physname for template and qualified methods already includes
335 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
341 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
343 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
344 + strlen (buf
) + len
+ strlen (physname
) + 1);
347 mangled_name
= (char *) xmalloc (mangled_name_len
);
349 mangled_name
[0] = '\0';
351 strcpy (mangled_name
, field_name
);
353 strcat (mangled_name
, buf
);
354 /* If the class doesn't have a name, i.e. newname NULL, then we just
355 mangle it using 0 for the length of the class. Thus it gets mangled
356 as something starting with `::' rather than `classname::'. */
358 strcat (mangled_name
, newname
);
360 strcat (mangled_name
, physname
);
361 return (mangled_name
);
366 /* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
368 struct partial_symtab
*
369 find_pc_sect_psymtab (CORE_ADDR pc
, asection
*section
)
371 register struct partial_symtab
*pst
;
372 register struct objfile
*objfile
;
374 ALL_PSYMTABS (objfile
, pst
)
376 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
378 struct minimal_symbol
*msymbol
;
379 struct partial_symtab
*tpst
;
381 /* An objfile that has its functions reordered might have
382 many partial symbol tables containing the PC, but
383 we want the partial symbol table that contains the
384 function containing the PC. */
385 if (!(objfile
->flags
& OBJF_REORDERED
) &&
386 section
== 0) /* can't validate section this way */
389 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
393 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
395 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
397 struct partial_symbol
*p
;
399 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
401 && SYMBOL_VALUE_ADDRESS (p
)
402 == SYMBOL_VALUE_ADDRESS (msymbol
))
412 /* Find which partial symtab contains PC. Return 0 if none.
413 Backward compatibility, no section */
415 struct partial_symtab
*
416 find_pc_psymtab (CORE_ADDR pc
)
418 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
421 /* Find which partial symbol within a psymtab matches PC and SECTION.
422 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
424 struct partial_symbol
*
425 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
428 struct partial_symbol
*best
= NULL
, *p
, **pp
;
432 psymtab
= find_pc_sect_psymtab (pc
, section
);
436 /* Cope with programs that start at address 0 */
437 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
439 /* Search the global symbols as well as the static symbols, so that
440 find_pc_partial_function doesn't use a minimal symbol and thus
441 cache a bad endaddr. */
442 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
443 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
444 < psymtab
->n_global_syms
);
448 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
449 && SYMBOL_CLASS (p
) == LOC_BLOCK
450 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
451 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
452 || (psymtab
->textlow
== 0
453 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
455 if (section
) /* match on a specific section */
457 fixup_psymbol_section (p
, psymtab
->objfile
);
458 if (SYMBOL_BFD_SECTION (p
) != section
)
461 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
476 || (psymtab
->textlow
== 0
477 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
479 if (section
) /* match on a specific section */
481 fixup_psymbol_section (p
, psymtab
->objfile
);
482 if (SYMBOL_BFD_SECTION (p
) != section
)
485 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
493 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
494 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
496 struct partial_symbol
*
497 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
499 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
502 /* Debug symbols usually don't have section information. We need to dig that
503 out of the minimal symbols and stash that in the debug symbol. */
506 fixup_section (struct general_symbol_info
*ginfo
, struct objfile
*objfile
)
508 struct minimal_symbol
*msym
;
509 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
513 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
514 ginfo
->section
= SYMBOL_SECTION (msym
);
519 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
524 if (SYMBOL_BFD_SECTION (sym
))
527 fixup_section (&sym
->ginfo
, objfile
);
532 struct partial_symbol
*
533 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
538 if (SYMBOL_BFD_SECTION (psym
))
541 fixup_section (&psym
->ginfo
, objfile
);
546 /* Find the definition for a specified symbol name NAME
547 in namespace NAMESPACE, visible from lexical block BLOCK.
548 Returns the struct symbol pointer, or zero if no symbol is found.
549 If SYMTAB is non-NULL, store the symbol table in which the
550 symbol was found there, or NULL if not found.
551 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
552 NAME is a field of the current implied argument `this'. If so set
553 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
554 BLOCK_FOUND is set to the block in which NAME is found (in the case of
555 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
557 /* This function has a bunch of loops in it and it would seem to be
558 attractive to put in some QUIT's (though I'm not really sure
559 whether it can run long enough to be really important). But there
560 are a few calls for which it would appear to be bad news to quit
561 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c, and
562 nindy_frame_chain_valid in nindy-tdep.c. (Note that there is C++
563 code below which can error(), but that probably doesn't affect
564 these calls since they are looking for a known variable and thus
565 can probably assume it will never hit the C++ code). */
568 lookup_symbol (const char *name
, const struct block
*block
,
569 const namespace_enum
namespace, int *is_a_field_of_this
,
570 struct symtab
**symtab
)
572 char *modified_name
= NULL
;
573 char *modified_name2
= NULL
;
574 int needtofreename
= 0;
575 struct symbol
*returnval
;
577 if (case_sensitivity
== case_sensitive_off
)
583 copy
= (char *) alloca (len
+ 1);
584 for (i
= 0; i
< len
; i
++)
585 copy
[i
] = tolower (name
[i
]);
587 modified_name
= copy
;
590 modified_name
= (char *) name
;
592 /* If we are using C++ language, demangle the name before doing a lookup, so
593 we can always binary search. */
594 if (current_language
->la_language
== language_cplus
)
596 modified_name2
= cplus_demangle (modified_name
, DMGL_ANSI
| DMGL_PARAMS
);
599 modified_name
= modified_name2
;
604 returnval
= lookup_symbol_aux (modified_name
, block
, namespace,
605 is_a_field_of_this
, symtab
);
607 free (modified_name2
);
612 static struct symbol
*
613 lookup_symbol_aux (const char *name
, const struct block
*block
,
614 const namespace_enum
namespace, int *is_a_field_of_this
,
615 struct symtab
**symtab
)
617 register struct symbol
*sym
;
618 register struct symtab
*s
= NULL
;
619 register struct partial_symtab
*ps
;
620 register struct blockvector
*bv
;
621 register struct objfile
*objfile
= NULL
;
622 register struct block
*b
;
623 register struct minimal_symbol
*msymbol
;
626 /* Search specified block and its superiors. */
630 sym
= lookup_block_symbol (block
, name
, namespace);
636 /* Search the list of symtabs for one which contains the
637 address of the start of this block. */
638 ALL_SYMTABS (objfile
, s
)
640 bv
= BLOCKVECTOR (s
);
641 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
642 if (BLOCK_START (b
) <= BLOCK_START (block
)
643 && BLOCK_END (b
) > BLOCK_START (block
))
650 return fixup_symbol_section (sym
, objfile
);
652 block
= BLOCK_SUPERBLOCK (block
);
655 /* FIXME: this code is never executed--block is always NULL at this
656 point. What is it trying to do, anyway? We already should have
657 checked the STATIC_BLOCK above (it is the superblock of top-level
658 blocks). Why is VAR_NAMESPACE special-cased? */
659 /* Don't need to mess with the psymtabs; if we have a block,
660 that file is read in. If we don't, then we deal later with
661 all the psymtab stuff that needs checking. */
662 /* Note (RT): The following never-executed code looks unnecessary to me also.
663 * If we change the code to use the original (passed-in)
664 * value of 'block', we could cause it to execute, but then what
665 * would it do? The STATIC_BLOCK of the symtab containing the passed-in
666 * 'block' was already searched by the above code. And the STATIC_BLOCK's
667 * of *other* symtabs (those files not containing 'block' lexically)
668 * should not contain 'block' address-wise. So we wouldn't expect this
669 * code to find any 'sym''s that were not found above. I vote for
670 * deleting the following paragraph of code.
672 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
675 /* Find the right symtab. */
676 ALL_SYMTABS (objfile
, s
)
678 bv
= BLOCKVECTOR (s
);
679 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
680 if (BLOCK_START (b
) <= BLOCK_START (block
)
681 && BLOCK_END (b
) > BLOCK_START (block
))
683 sym
= lookup_block_symbol (b
, name
, VAR_NAMESPACE
);
689 return fixup_symbol_section (sym
, objfile
);
696 /* C++: If requested to do so by the caller,
697 check to see if NAME is a field of `this'. */
698 if (is_a_field_of_this
)
700 struct value
*v
= value_of_this (0);
702 *is_a_field_of_this
= 0;
703 if (v
&& check_field (v
, name
))
705 *is_a_field_of_this
= 1;
712 /* Now search all global blocks. Do the symtab's first, then
713 check the psymtab's. If a psymtab indicates the existence
714 of the desired name as a global, then do psymtab-to-symtab
715 conversion on the fly and return the found symbol. */
717 ALL_SYMTABS (objfile
, s
)
719 bv
= BLOCKVECTOR (s
);
720 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
721 sym
= lookup_block_symbol (block
, name
, namespace);
727 return fixup_symbol_section (sym
, objfile
);
733 /* Check for the possibility of the symbol being a function or
734 a mangled variable that is stored in one of the minimal symbol tables.
735 Eventually, all global symbols might be resolved in this way. */
737 if (namespace == VAR_NAMESPACE
)
739 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
742 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
743 SYMBOL_BFD_SECTION (msymbol
));
746 /* This is a function which has a symtab for its address. */
747 bv
= BLOCKVECTOR (s
);
748 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
749 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
751 /* We kept static functions in minimal symbol table as well as
752 in static scope. We want to find them in the symbol table. */
755 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
756 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
760 /* sym == 0 if symbol was found in the minimal symbol table
761 but not in the symtab.
762 Return 0 to use the msymbol definition of "foo_".
764 This happens for Fortran "foo_" symbols,
765 which are "foo" in the symtab.
767 This can also happen if "asm" is used to make a
768 regular symbol but not a debugging symbol, e.g.
775 return fixup_symbol_section (sym
, objfile
);
777 else if (MSYMBOL_TYPE (msymbol
) != mst_text
778 && MSYMBOL_TYPE (msymbol
) != mst_file_text
779 && !STREQ (name
, SYMBOL_NAME (msymbol
)))
781 /* This is a mangled variable, look it up by its
783 return lookup_symbol (SYMBOL_NAME (msymbol
), block
,
784 namespace, is_a_field_of_this
, symtab
);
786 /* There are no debug symbols for this file, or we are looking
787 for an unmangled variable.
788 Try to find a matching static symbol below. */
794 ALL_PSYMTABS (objfile
, ps
)
796 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, namespace))
798 s
= PSYMTAB_TO_SYMTAB (ps
);
799 bv
= BLOCKVECTOR (s
);
800 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
801 sym
= lookup_block_symbol (block
, name
, namespace);
804 /* This shouldn't be necessary, but as a last resort
805 * try looking in the statics even though the psymtab
806 * claimed the symbol was global. It's possible that
807 * the psymtab gets it wrong in some cases.
809 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
810 sym
= lookup_block_symbol (block
, name
, namespace);
812 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
813 %s may be an inlined function, or may be a template function\n\
814 (if a template, try specifying an instantiation: %s<type>).",
815 name
, ps
->filename
, name
, name
);
819 return fixup_symbol_section (sym
, objfile
);
823 /* Now search all static file-level symbols.
824 Not strictly correct, but more useful than an error.
825 Do the symtabs first, then check the psymtabs.
826 If a psymtab indicates the existence
827 of the desired name as a file-level static, then do psymtab-to-symtab
828 conversion on the fly and return the found symbol. */
830 ALL_SYMTABS (objfile
, s
)
832 bv
= BLOCKVECTOR (s
);
833 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
834 sym
= lookup_block_symbol (block
, name
, namespace);
840 return fixup_symbol_section (sym
, objfile
);
844 ALL_PSYMTABS (objfile
, ps
)
846 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, namespace))
848 s
= PSYMTAB_TO_SYMTAB (ps
);
849 bv
= BLOCKVECTOR (s
);
850 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
851 sym
= lookup_block_symbol (block
, name
, namespace);
854 /* This shouldn't be necessary, but as a last resort
855 * try looking in the globals even though the psymtab
856 * claimed the symbol was static. It's possible that
857 * the psymtab gets it wrong in some cases.
859 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
860 sym
= lookup_block_symbol (block
, name
, namespace);
862 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
863 %s may be an inlined function, or may be a template function\n\
864 (if a template, try specifying an instantiation: %s<type>).",
865 name
, ps
->filename
, name
, name
);
869 return fixup_symbol_section (sym
, objfile
);
875 /* Check for the possibility of the symbol being a function or
876 a global variable that is stored in one of the minimal symbol tables.
877 The "minimal symbol table" is built from linker-supplied info.
879 RT: I moved this check to last, after the complete search of
880 the global (p)symtab's and static (p)symtab's. For HP-generated
881 symbol tables, this check was causing a premature exit from
882 lookup_symbol with NULL return, and thus messing up symbol lookups
883 of things like "c::f". It seems to me a check of the minimal
884 symbol table ought to be a last resort in any case. I'm vaguely
885 worried about the comment below which talks about FORTRAN routines "foo_"
886 though... is it saying we need to do the "minsym" check before
887 the static check in this case?
890 if (namespace == VAR_NAMESPACE
)
892 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
895 /* OK, we found a minimal symbol in spite of not
896 * finding any symbol. There are various possible
897 * explanations for this. One possibility is the symbol
898 * exists in code not compiled -g. Another possibility
899 * is that the 'psymtab' isn't doing its job.
900 * A third possibility, related to #2, is that we were confused
901 * by name-mangling. For instance, maybe the psymtab isn't
902 * doing its job because it only know about demangled
903 * names, but we were given a mangled name...
906 /* We first use the address in the msymbol to try to
907 * locate the appropriate symtab. Note that find_pc_symtab()
908 * has a side-effect of doing psymtab-to-symtab expansion,
909 * for the found symtab.
911 s
= find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
));
914 bv
= BLOCKVECTOR (s
);
915 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
916 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
918 /* We kept static functions in minimal symbol table as well as
919 in static scope. We want to find them in the symbol table. */
922 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
923 sym
= lookup_block_symbol (block
, SYMBOL_NAME (msymbol
),
926 /* If we found one, return it */
934 /* If we get here with sym == 0, the symbol was
935 found in the minimal symbol table
936 but not in the symtab.
937 Fall through and return 0 to use the msymbol
938 definition of "foo_".
939 (Note that outer code generally follows up a call
940 to this routine with a call to lookup_minimal_symbol(),
941 so a 0 return means we'll just flow into that other routine).
943 This happens for Fortran "foo_" symbols,
944 which are "foo" in the symtab.
946 This can also happen if "asm" is used to make a
947 regular symbol but not a debugging symbol, e.g.
953 /* If the lookup-by-address fails, try repeating the
954 * entire lookup process with the symbol name from
955 * the msymbol (if different from the original symbol name).
957 else if (MSYMBOL_TYPE (msymbol
) != mst_text
958 && MSYMBOL_TYPE (msymbol
) != mst_file_text
959 && !STREQ (name
, SYMBOL_NAME (msymbol
)))
961 return lookup_symbol (SYMBOL_NAME (msymbol
), block
,
962 namespace, is_a_field_of_this
, symtab
);
974 /* Look, in partial_symtab PST, for symbol NAME. Check the global
975 symbols if GLOBAL, the static symbols if not */
977 static struct partial_symbol
*
978 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
, int global
,
979 namespace_enum
namespace)
981 struct partial_symbol
*temp
;
982 struct partial_symbol
**start
, **psym
;
983 struct partial_symbol
**top
, **bottom
, **center
;
984 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
985 int do_linear_search
= 1;
992 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
993 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
995 if (global
) /* This means we can use a binary search. */
997 do_linear_search
= 0;
999 /* Binary search. This search is guaranteed to end with center
1000 pointing at the earliest partial symbol with the correct
1001 name. At that point *all* partial symbols with that name
1002 will be checked against the correct namespace. */
1005 top
= start
+ length
- 1;
1006 while (top
> bottom
)
1008 center
= bottom
+ (top
- bottom
) / 2;
1009 if (!(center
< top
))
1011 if (!do_linear_search
1012 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1014 do_linear_search
= 1;
1016 if (STRCMP (SYMBOL_SOURCE_NAME (*center
), name
) >= 0)
1022 bottom
= center
+ 1;
1025 if (!(top
== bottom
))
1028 /* djb - 2000-06-03 - Use SYMBOL_MATCHES_NAME, not a strcmp, so
1029 we don't have to force a linear search on C++. Probably holds true
1030 for JAVA as well, no way to check.*/
1031 while (SYMBOL_MATCHES_NAME (*top
,name
))
1033 if (SYMBOL_NAMESPACE (*top
) == namespace)
1041 /* Can't use a binary search or else we found during the binary search that
1042 we should also do a linear search. */
1044 if (do_linear_search
)
1046 for (psym
= start
; psym
< start
+ length
; psym
++)
1048 if (namespace == SYMBOL_NAMESPACE (*psym
))
1050 if (SYMBOL_MATCHES_NAME (*psym
, name
))
1061 /* Look up a type named NAME in the struct_namespace. The type returned
1062 must not be opaque -- i.e., must have at least one field defined
1064 This code was modelled on lookup_symbol -- the parts not relevant to looking
1065 up types were just left out. In particular it's assumed here that types
1066 are available in struct_namespace and only at file-static or global blocks. */
1070 lookup_transparent_type (const char *name
)
1072 register struct symbol
*sym
;
1073 register struct symtab
*s
= NULL
;
1074 register struct partial_symtab
*ps
;
1075 struct blockvector
*bv
;
1076 register struct objfile
*objfile
;
1077 register struct block
*block
;
1079 /* Now search all the global symbols. Do the symtab's first, then
1080 check the psymtab's. If a psymtab indicates the existence
1081 of the desired name as a global, then do psymtab-to-symtab
1082 conversion on the fly and return the found symbol. */
1084 ALL_SYMTABS (objfile
, s
)
1086 bv
= BLOCKVECTOR (s
);
1087 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1088 sym
= lookup_block_symbol (block
, name
, STRUCT_NAMESPACE
);
1089 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1091 return SYMBOL_TYPE (sym
);
1095 ALL_PSYMTABS (objfile
, ps
)
1097 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, STRUCT_NAMESPACE
))
1099 s
= PSYMTAB_TO_SYMTAB (ps
);
1100 bv
= BLOCKVECTOR (s
);
1101 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1102 sym
= lookup_block_symbol (block
, name
, STRUCT_NAMESPACE
);
1105 /* This shouldn't be necessary, but as a last resort
1106 * try looking in the statics even though the psymtab
1107 * claimed the symbol was global. It's possible that
1108 * the psymtab gets it wrong in some cases.
1110 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1111 sym
= lookup_block_symbol (block
, name
, STRUCT_NAMESPACE
);
1113 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1114 %s may be an inlined function, or may be a template function\n\
1115 (if a template, try specifying an instantiation: %s<type>).",
1116 name
, ps
->filename
, name
, name
);
1118 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1119 return SYMBOL_TYPE (sym
);
1123 /* Now search the static file-level symbols.
1124 Not strictly correct, but more useful than an error.
1125 Do the symtab's first, then
1126 check the psymtab's. If a psymtab indicates the existence
1127 of the desired name as a file-level static, then do psymtab-to-symtab
1128 conversion on the fly and return the found symbol.
1131 ALL_SYMTABS (objfile
, s
)
1133 bv
= BLOCKVECTOR (s
);
1134 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1135 sym
= lookup_block_symbol (block
, name
, STRUCT_NAMESPACE
);
1136 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1138 return SYMBOL_TYPE (sym
);
1142 ALL_PSYMTABS (objfile
, ps
)
1144 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, STRUCT_NAMESPACE
))
1146 s
= PSYMTAB_TO_SYMTAB (ps
);
1147 bv
= BLOCKVECTOR (s
);
1148 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1149 sym
= lookup_block_symbol (block
, name
, STRUCT_NAMESPACE
);
1152 /* This shouldn't be necessary, but as a last resort
1153 * try looking in the globals even though the psymtab
1154 * claimed the symbol was static. It's possible that
1155 * the psymtab gets it wrong in some cases.
1157 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1158 sym
= lookup_block_symbol (block
, name
, STRUCT_NAMESPACE
);
1160 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1161 %s may be an inlined function, or may be a template function\n\
1162 (if a template, try specifying an instantiation: %s<type>).",
1163 name
, ps
->filename
, name
, name
);
1165 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1166 return SYMBOL_TYPE (sym
);
1169 return (struct type
*) 0;
1173 /* Find the psymtab containing main(). */
1174 /* FIXME: What about languages without main() or specially linked
1175 executables that have no main() ? */
1177 struct partial_symtab
*
1178 find_main_psymtab (void)
1180 register struct partial_symtab
*pst
;
1181 register struct objfile
*objfile
;
1183 ALL_PSYMTABS (objfile
, pst
)
1185 if (lookup_partial_symbol (pst
, "main", 1, VAR_NAMESPACE
))
1193 /* Search BLOCK for symbol NAME in NAMESPACE.
1195 Note that if NAME is the demangled form of a C++ symbol, we will fail
1196 to find a match during the binary search of the non-encoded names, but
1197 for now we don't worry about the slight inefficiency of looking for
1198 a match we'll never find, since it will go pretty quick. Once the
1199 binary search terminates, we drop through and do a straight linear
1200 search on the symbols. Each symbol which is marked as being a C++
1201 symbol (language_cplus set) has both the encoded and non-encoded names
1202 tested for a match. */
1205 lookup_block_symbol (register const struct block
*block
, const char *name
,
1206 const namespace_enum
namespace)
1208 register int bot
, top
, inc
;
1209 register struct symbol
*sym
;
1210 register struct symbol
*sym_found
= NULL
;
1211 register int do_linear_search
= 1;
1213 /* If the blocks's symbols were sorted, start with a binary search. */
1215 if (BLOCK_SHOULD_SORT (block
))
1217 /* Reset the linear search flag so if the binary search fails, we
1218 won't do the linear search once unless we find some reason to
1221 do_linear_search
= 0;
1222 top
= BLOCK_NSYMS (block
);
1225 /* Advance BOT to not far before the first symbol whose name is NAME. */
1229 inc
= (top
- bot
+ 1);
1230 /* No need to keep binary searching for the last few bits worth. */
1235 inc
= (inc
>> 1) + bot
;
1236 sym
= BLOCK_SYM (block
, inc
);
1237 if (!do_linear_search
&& (SYMBOL_LANGUAGE (sym
) == language_java
))
1239 do_linear_search
= 1;
1241 if (SYMBOL_SOURCE_NAME (sym
)[0] < name
[0])
1245 else if (SYMBOL_SOURCE_NAME (sym
)[0] > name
[0])
1249 else if (STRCMP (SYMBOL_SOURCE_NAME (sym
), name
) < 0)
1259 /* Now scan forward until we run out of symbols, find one whose
1260 name is greater than NAME, or find one we want. If there is
1261 more than one symbol with the right name and namespace, we
1262 return the first one; I believe it is now impossible for us
1263 to encounter two symbols with the same name and namespace
1264 here, because blocks containing argument symbols are no
1267 top
= BLOCK_NSYMS (block
);
1270 sym
= BLOCK_SYM (block
, bot
);
1271 if (SYMBOL_MATCHES_NAME (sym
, name
))
1277 /* Here if block isn't sorted, or we fail to find a match during the
1278 binary search above. If during the binary search above, we find a
1279 symbol which is a C++ symbol, then we have re-enabled the linear
1280 search flag which was reset when starting the binary search.
1282 This loop is equivalent to the loop above, but hacked greatly for speed.
1284 Note that parameter symbols do not always show up last in the
1285 list; this loop makes sure to take anything else other than
1286 parameter symbols first; it only uses parameter symbols as a
1287 last resort. Note that this only takes up extra computation
1290 if (do_linear_search
)
1292 top
= BLOCK_NSYMS (block
);
1296 sym
= BLOCK_SYM (block
, bot
);
1297 if (SYMBOL_NAMESPACE (sym
) == namespace &&
1298 SYMBOL_MATCHES_NAME (sym
, name
))
1300 /* If SYM has aliases, then use any alias that is active
1301 at the current PC. If no alias is active at the current
1302 PC, then use the main symbol.
1304 ?!? Is checking the current pc correct? Is this routine
1305 ever called to look up a symbol from another context?
1307 FIXME: No, it's not correct. If someone sets a
1308 conditional breakpoint at an address, then the
1309 breakpoint's `struct expression' should refer to the
1310 `struct symbol' appropriate for the breakpoint's
1311 address, which may not be the PC.
1313 Even if it were never called from another context,
1314 it's totally bizarre for lookup_symbol's behavior to
1315 depend on the value of the inferior's current PC. We
1316 should pass in the appropriate PC as well as the
1317 block. The interface to lookup_symbol should change
1318 to require the caller to provide a PC. */
1320 if (SYMBOL_ALIASES (sym
))
1321 sym
= find_active_alias (sym
, read_pc ());
1324 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1325 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1326 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1327 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1328 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1329 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
)
1337 return (sym_found
); /* Will be NULL if not found. */
1340 /* Given a main symbol SYM and ADDR, search through the alias
1341 list to determine if an alias is active at ADDR and return
1344 If no alias is active, then return SYM. */
1346 static struct symbol
*
1347 find_active_alias (struct symbol
*sym
, CORE_ADDR addr
)
1349 struct range_list
*r
;
1350 struct alias_list
*aliases
;
1352 /* If we have aliases, check them first. */
1353 aliases
= SYMBOL_ALIASES (sym
);
1357 if (!SYMBOL_RANGES (aliases
->sym
))
1358 return aliases
->sym
;
1359 for (r
= SYMBOL_RANGES (aliases
->sym
); r
; r
= r
->next
)
1361 if (r
->start
<= addr
&& r
->end
> addr
)
1362 return aliases
->sym
;
1364 aliases
= aliases
->next
;
1367 /* Nothing found, return the main symbol. */
1372 /* Return the symbol for the function which contains a specified
1373 lexical block, described by a struct block BL. */
1376 block_function (struct block
*bl
)
1378 while (BLOCK_FUNCTION (bl
) == 0 && BLOCK_SUPERBLOCK (bl
) != 0)
1379 bl
= BLOCK_SUPERBLOCK (bl
);
1381 return BLOCK_FUNCTION (bl
);
1384 /* Find the symtab associated with PC and SECTION. Look through the
1385 psymtabs and read in another symtab if necessary. */
1388 find_pc_sect_symtab (CORE_ADDR pc
, asection
*section
)
1390 register struct block
*b
;
1391 struct blockvector
*bv
;
1392 register struct symtab
*s
= NULL
;
1393 register struct symtab
*best_s
= NULL
;
1394 register struct partial_symtab
*ps
;
1395 register struct objfile
*objfile
;
1396 CORE_ADDR distance
= 0;
1398 /* Search all symtabs for the one whose file contains our address, and which
1399 is the smallest of all the ones containing the address. This is designed
1400 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1401 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1402 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1404 This happens for native ecoff format, where code from included files
1405 gets its own symtab. The symtab for the included file should have
1406 been read in already via the dependency mechanism.
1407 It might be swifter to create several symtabs with the same name
1408 like xcoff does (I'm not sure).
1410 It also happens for objfiles that have their functions reordered.
1411 For these, the symtab we are looking for is not necessarily read in. */
1413 ALL_SYMTABS (objfile
, s
)
1415 bv
= BLOCKVECTOR (s
);
1416 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1418 if (BLOCK_START (b
) <= pc
1419 && BLOCK_END (b
) > pc
1421 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1423 /* For an objfile that has its functions reordered,
1424 find_pc_psymtab will find the proper partial symbol table
1425 and we simply return its corresponding symtab. */
1426 /* In order to better support objfiles that contain both
1427 stabs and coff debugging info, we continue on if a psymtab
1429 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1431 ps
= find_pc_sect_psymtab (pc
, section
);
1433 return PSYMTAB_TO_SYMTAB (ps
);
1439 for (i
= 0; i
< b
->nsyms
; i
++)
1441 fixup_symbol_section (b
->sym
[i
], objfile
);
1442 if (section
== SYMBOL_BFD_SECTION (b
->sym
[i
]))
1446 continue; /* no symbol in this symtab matches section */
1448 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1457 ps
= find_pc_sect_psymtab (pc
, section
);
1461 /* Might want to error() here (in case symtab is corrupt and
1462 will cause a core dump), but maybe we can successfully
1463 continue, so let's not. */
1465 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
1467 s
= PSYMTAB_TO_SYMTAB (ps
);
1472 /* Find the symtab associated with PC. Look through the psymtabs and
1473 read in another symtab if necessary. Backward compatibility, no section */
1476 find_pc_symtab (CORE_ADDR pc
)
1478 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
1484 /* Find the closest symbol value (of any sort -- function or variable)
1485 for a given address value. Slow but complete. (currently unused,
1486 mainly because it is too slow. We could fix it if each symtab and
1487 psymtab had contained in it the addresses ranges of each of its
1488 sections, which also would be required to make things like "info
1489 line *0x2345" cause psymtabs to be converted to symtabs). */
1492 find_addr_symbol (CORE_ADDR addr
, struct symtab
**symtabp
, CORE_ADDR
*symaddrp
)
1494 struct symtab
*symtab
, *best_symtab
;
1495 struct objfile
*objfile
;
1496 register int bot
, top
;
1497 register struct symbol
*sym
;
1498 register CORE_ADDR sym_addr
;
1499 struct block
*block
;
1502 /* Info on best symbol seen so far */
1504 register CORE_ADDR best_sym_addr
= 0;
1505 struct symbol
*best_sym
= 0;
1507 /* FIXME -- we should pull in all the psymtabs, too! */
1508 ALL_SYMTABS (objfile
, symtab
)
1510 /* Search the global and static blocks in this symtab for
1511 the closest symbol-address to the desired address. */
1513 for (blocknum
= GLOBAL_BLOCK
; blocknum
<= STATIC_BLOCK
; blocknum
++)
1516 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), blocknum
);
1517 top
= BLOCK_NSYMS (block
);
1518 for (bot
= 0; bot
< top
; bot
++)
1520 sym
= BLOCK_SYM (block
, bot
);
1521 switch (SYMBOL_CLASS (sym
))
1525 sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1529 sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1530 /* An indirect symbol really lives at *sym_addr,
1531 * so an indirection needs to be done.
1532 * However, I am leaving this commented out because it's
1533 * expensive, and it's possible that symbolization
1534 * could be done without an active process (in
1535 * case this read_memory will fail). RT
1536 sym_addr = read_memory_unsigned_integer
1537 (sym_addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1542 sym_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1549 if (sym_addr
<= addr
)
1550 if (sym_addr
> best_sym_addr
)
1552 /* Quit if we found an exact match. */
1554 best_sym_addr
= sym_addr
;
1555 best_symtab
= symtab
;
1556 if (sym_addr
== addr
)
1565 *symtabp
= best_symtab
;
1567 *symaddrp
= best_sym_addr
;
1572 /* Find the source file and line number for a given PC value and SECTION.
1573 Return a structure containing a symtab pointer, a line number,
1574 and a pc range for the entire source line.
1575 The value's .pc field is NOT the specified pc.
1576 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1577 use the line that ends there. Otherwise, in that case, the line
1578 that begins there is used. */
1580 /* The big complication here is that a line may start in one file, and end just
1581 before the start of another file. This usually occurs when you #include
1582 code in the middle of a subroutine. To properly find the end of a line's PC
1583 range, we must search all symtabs associated with this compilation unit, and
1584 find the one whose first PC is closer than that of the next line in this
1587 /* If it's worth the effort, we could be using a binary search. */
1589 struct symtab_and_line
1590 find_pc_sect_line (CORE_ADDR pc
, struct sec
*section
, int notcurrent
)
1593 register struct linetable
*l
;
1596 register struct linetable_entry
*item
;
1597 struct symtab_and_line val
;
1598 struct blockvector
*bv
;
1599 struct minimal_symbol
*msymbol
;
1600 struct minimal_symbol
*mfunsym
;
1602 /* Info on best line seen so far, and where it starts, and its file. */
1604 struct linetable_entry
*best
= NULL
;
1605 CORE_ADDR best_end
= 0;
1606 struct symtab
*best_symtab
= 0;
1608 /* Store here the first line number
1609 of a file which contains the line at the smallest pc after PC.
1610 If we don't find a line whose range contains PC,
1611 we will use a line one less than this,
1612 with a range from the start of that file to the first line's pc. */
1613 struct linetable_entry
*alt
= NULL
;
1614 struct symtab
*alt_symtab
= 0;
1616 /* Info on best line seen in this file. */
1618 struct linetable_entry
*prev
;
1620 /* If this pc is not from the current frame,
1621 it is the address of the end of a call instruction.
1622 Quite likely that is the start of the following statement.
1623 But what we want is the statement containing the instruction.
1624 Fudge the pc to make sure we get that. */
1626 INIT_SAL (&val
); /* initialize to zeroes */
1631 /* elz: added this because this function returned the wrong
1632 information if the pc belongs to a stub (import/export)
1633 to call a shlib function. This stub would be anywhere between
1634 two functions in the target, and the line info was erroneously
1635 taken to be the one of the line before the pc.
1637 /* RT: Further explanation:
1639 * We have stubs (trampolines) inserted between procedures.
1641 * Example: "shr1" exists in a shared library, and a "shr1" stub also
1642 * exists in the main image.
1644 * In the minimal symbol table, we have a bunch of symbols
1645 * sorted by start address. The stubs are marked as "trampoline",
1646 * the others appear as text. E.g.:
1648 * Minimal symbol table for main image
1649 * main: code for main (text symbol)
1650 * shr1: stub (trampoline symbol)
1651 * foo: code for foo (text symbol)
1653 * Minimal symbol table for "shr1" image:
1655 * shr1: code for shr1 (text symbol)
1658 * So the code below is trying to detect if we are in the stub
1659 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
1660 * and if found, do the symbolization from the real-code address
1661 * rather than the stub address.
1663 * Assumptions being made about the minimal symbol table:
1664 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
1665 * if we're really in the trampoline. If we're beyond it (say
1666 * we're in "foo" in the above example), it'll have a closer
1667 * symbol (the "foo" text symbol for example) and will not
1668 * return the trampoline.
1669 * 2. lookup_minimal_symbol_text() will find a real text symbol
1670 * corresponding to the trampoline, and whose address will
1671 * be different than the trampoline address. I put in a sanity
1672 * check for the address being the same, to avoid an
1673 * infinite recursion.
1675 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1676 if (msymbol
!= NULL
)
1677 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
1679 mfunsym
= lookup_minimal_symbol_text (SYMBOL_NAME (msymbol
), NULL
, NULL
);
1680 if (mfunsym
== NULL
)
1681 /* I eliminated this warning since it is coming out
1682 * in the following situation:
1683 * gdb shmain // test program with shared libraries
1684 * (gdb) break shr1 // function in shared lib
1685 * Warning: In stub for ...
1686 * In the above situation, the shared lib is not loaded yet,
1687 * so of course we can't find the real func/line info,
1688 * but the "break" still works, and the warning is annoying.
1689 * So I commented out the warning. RT */
1690 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_NAME(msymbol)) */ ;
1692 else if (SYMBOL_VALUE (mfunsym
) == SYMBOL_VALUE (msymbol
))
1693 /* Avoid infinite recursion */
1694 /* See above comment about why warning is commented out */
1695 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_NAME(msymbol)) */ ;
1698 return find_pc_line (SYMBOL_VALUE (mfunsym
), 0);
1702 s
= find_pc_sect_symtab (pc
, section
);
1705 /* if no symbol information, return previous pc */
1712 bv
= BLOCKVECTOR (s
);
1714 /* Look at all the symtabs that share this blockvector.
1715 They all have the same apriori range, that we found was right;
1716 but they have different line tables. */
1718 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
1720 /* Find the best line in this symtab. */
1727 /* I think len can be zero if the symtab lacks line numbers
1728 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
1729 I'm not sure which, and maybe it depends on the symbol
1735 item
= l
->item
; /* Get first line info */
1737 /* Is this file's first line closer than the first lines of other files?
1738 If so, record this file, and its first line, as best alternate. */
1739 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
1745 for (i
= 0; i
< len
; i
++, item
++)
1747 /* Leave prev pointing to the linetable entry for the last line
1748 that started at or before PC. */
1755 /* At this point, prev points at the line whose start addr is <= pc, and
1756 item points at the next line. If we ran off the end of the linetable
1757 (pc >= start of the last line), then prev == item. If pc < start of
1758 the first line, prev will not be set. */
1760 /* Is this file's best line closer than the best in the other files?
1761 If so, record this file, and its best line, as best so far. */
1763 if (prev
&& (!best
|| prev
->pc
> best
->pc
))
1767 /* If another line is in the linetable, and its PC is closer
1768 than the best_end we currently have, take it as best_end. */
1769 if (i
< len
&& (best_end
== 0 || best_end
> item
->pc
))
1770 best_end
= item
->pc
;
1777 { /* If we didn't find any line # info, just
1783 val
.symtab
= alt_symtab
;
1784 val
.line
= alt
->line
- 1;
1786 /* Don't return line 0, that means that we didn't find the line. */
1790 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1796 val
.symtab
= best_symtab
;
1797 val
.line
= best
->line
;
1799 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
1804 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
1806 val
.section
= section
;
1810 /* Backward compatibility (no section) */
1812 struct symtab_and_line
1813 find_pc_line (CORE_ADDR pc
, int notcurrent
)
1817 section
= find_pc_overlay (pc
);
1818 if (pc_in_unmapped_range (pc
, section
))
1819 pc
= overlay_mapped_address (pc
, section
);
1820 return find_pc_sect_line (pc
, section
, notcurrent
);
1824 static struct symtab
*find_line_symtab (struct symtab
*, int, int *, int *);
1826 /* Find line number LINE in any symtab whose name is the same as
1829 If found, return the symtab that contains the linetable in which it was
1830 found, set *INDEX to the index in the linetable of the best entry
1831 found, and set *EXACT_MATCH nonzero if the value returned is an
1834 If not found, return NULL. */
1836 static struct symtab
*
1837 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
1841 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1845 struct linetable
*best_linetable
;
1846 struct symtab
*best_symtab
;
1848 /* First try looking it up in the given symtab. */
1849 best_linetable
= LINETABLE (symtab
);
1850 best_symtab
= symtab
;
1851 best_index
= find_line_common (best_linetable
, line
, &exact
);
1852 if (best_index
< 0 || !exact
)
1854 /* Didn't find an exact match. So we better keep looking for
1855 another symtab with the same name. In the case of xcoff,
1856 multiple csects for one source file (produced by IBM's FORTRAN
1857 compiler) produce multiple symtabs (this is unavoidable
1858 assuming csects can be at arbitrary places in memory and that
1859 the GLOBAL_BLOCK of a symtab has a begin and end address). */
1861 /* BEST is the smallest linenumber > LINE so far seen,
1862 or 0 if none has been seen so far.
1863 BEST_INDEX and BEST_LINETABLE identify the item for it. */
1866 struct objfile
*objfile
;
1869 if (best_index
>= 0)
1870 best
= best_linetable
->item
[best_index
].line
;
1874 ALL_SYMTABS (objfile
, s
)
1876 struct linetable
*l
;
1879 if (!STREQ (symtab
->filename
, s
->filename
))
1882 ind
= find_line_common (l
, line
, &exact
);
1892 if (best
== 0 || l
->item
[ind
].line
< best
)
1894 best
= l
->item
[ind
].line
;
1907 *index
= best_index
;
1909 *exact_match
= exact
;
1914 /* Set the PC value for a given source file and line number and return true.
1915 Returns zero for invalid line number (and sets the PC to 0).
1916 The source file is specified with a struct symtab. */
1919 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
1921 struct linetable
*l
;
1928 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
1931 l
= LINETABLE (symtab
);
1932 *pc
= l
->item
[ind
].pc
;
1939 /* Find the range of pc values in a line.
1940 Store the starting pc of the line into *STARTPTR
1941 and the ending pc (start of next line) into *ENDPTR.
1942 Returns 1 to indicate success.
1943 Returns 0 if could not find the specified line. */
1946 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
1949 CORE_ADDR startaddr
;
1950 struct symtab_and_line found_sal
;
1953 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
1956 /* This whole function is based on address. For example, if line 10 has
1957 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1958 "info line *0x123" should say the line goes from 0x100 to 0x200
1959 and "info line *0x355" should say the line goes from 0x300 to 0x400.
1960 This also insures that we never give a range like "starts at 0x134
1961 and ends at 0x12c". */
1963 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
1964 if (found_sal
.line
!= sal
.line
)
1966 /* The specified line (sal) has zero bytes. */
1967 *startptr
= found_sal
.pc
;
1968 *endptr
= found_sal
.pc
;
1972 *startptr
= found_sal
.pc
;
1973 *endptr
= found_sal
.end
;
1978 /* Given a line table and a line number, return the index into the line
1979 table for the pc of the nearest line whose number is >= the specified one.
1980 Return -1 if none is found. The value is >= 0 if it is an index.
1982 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
1985 find_line_common (register struct linetable
*l
, register int lineno
,
1991 /* BEST is the smallest linenumber > LINENO so far seen,
1992 or 0 if none has been seen so far.
1993 BEST_INDEX identifies the item for it. */
1995 int best_index
= -1;
2004 for (i
= 0; i
< len
; i
++)
2006 register struct linetable_entry
*item
= &(l
->item
[i
]);
2008 if (item
->line
== lineno
)
2010 /* Return the first (lowest address) entry which matches. */
2015 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2022 /* If we got here, we didn't get an exact match. */
2029 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2031 struct symtab_and_line sal
;
2032 sal
= find_pc_line (pc
, 0);
2035 return sal
.symtab
!= 0;
2038 /* Given a function symbol SYM, find the symtab and line for the start
2040 If the argument FUNFIRSTLINE is nonzero, we want the first line
2041 of real code inside the function. */
2043 static struct symtab_and_line
2044 find_function_start_sal (struct symbol
*sym
, int);
2046 static struct symtab_and_line
2047 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2050 struct symtab_and_line sal
;
2052 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2053 fixup_symbol_section (sym
, NULL
);
2055 { /* skip "first line" of function (which is actually its prologue) */
2056 asection
*section
= SYMBOL_BFD_SECTION (sym
);
2057 /* If function is in an unmapped overlay, use its unmapped LMA
2058 address, so that SKIP_PROLOGUE has something unique to work on */
2059 if (section_is_overlay (section
) &&
2060 !section_is_mapped (section
))
2061 pc
= overlay_unmapped_address (pc
, section
);
2063 pc
+= FUNCTION_START_OFFSET
;
2064 pc
= SKIP_PROLOGUE (pc
);
2066 /* For overlays, map pc back into its mapped VMA range */
2067 pc
= overlay_mapped_address (pc
, section
);
2069 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2071 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2072 /* Convex: no need to suppress code on first line, if any */
2075 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2076 line is still part of the same function. */
2078 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
2079 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2081 /* First pc of next line */
2083 /* Recalculate the line number (might not be N+1). */
2084 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2092 /* If P is of the form "operator[ \t]+..." where `...' is
2093 some legitimate operator text, return a pointer to the
2094 beginning of the substring of the operator text.
2095 Otherwise, return "". */
2097 operator_chars (char *p
, char **end
)
2100 if (strncmp (p
, "operator", 8))
2104 /* Don't get faked out by `operator' being part of a longer
2106 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2109 /* Allow some whitespace between `operator' and the operator symbol. */
2110 while (*p
== ' ' || *p
== '\t')
2113 /* Recognize 'operator TYPENAME'. */
2115 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2117 register char *q
= p
+ 1;
2118 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2143 if (p
[1] == '=' || p
[1] == p
[0])
2154 error ("`operator ()' must be specified without whitespace in `()'");
2159 error ("`operator ?:' must be specified without whitespace in `?:'");
2164 error ("`operator []' must be specified without whitespace in `[]'");
2168 error ("`operator %s' not supported", p
);
2175 /* Return the number of methods described for TYPE, including the
2176 methods from types it derives from. This can't be done in the symbol
2177 reader because the type of the baseclass might still be stubbed
2178 when the definition of the derived class is parsed. */
2180 static int total_number_of_methods (struct type
*type
);
2183 total_number_of_methods (struct type
*type
)
2188 CHECK_TYPEDEF (type
);
2189 if (TYPE_CPLUS_SPECIFIC (type
) == NULL
)
2191 count
= TYPE_NFN_FIELDS_TOTAL (type
);
2193 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2194 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
2199 /* Recursive helper function for decode_line_1.
2200 Look for methods named NAME in type T.
2201 Return number of matches.
2202 Put matches in SYM_ARR, which should have been allocated with
2203 a size of total_number_of_methods (T) * sizeof (struct symbol *).
2204 Note that this function is g++ specific. */
2207 find_methods (struct type
*t
, char *name
, struct symbol
**sym_arr
)
2211 struct symbol
*sym_class
;
2212 char *class_name
= type_name_no_tag (t
);
2214 /* Ignore this class if it doesn't have a name. This is ugly, but
2215 unless we figure out how to get the physname without the name of
2216 the class, then the loop can't do any good. */
2218 && (sym_class
= lookup_symbol (class_name
,
2219 (struct block
*) NULL
,
2222 (struct symtab
**) NULL
)))
2226 /* FIXME: Shouldn't this just be CHECK_TYPEDEF (t)? */
2227 t
= SYMBOL_TYPE (sym_class
);
2229 /* Loop over each method name. At this level, all overloads of a name
2230 are counted as a single name. There is an inner loop which loops over
2233 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
2234 method_counter
>= 0;
2238 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
2239 char dem_opname
[64];
2241 if (strncmp (method_name
, "__", 2) == 0 ||
2242 strncmp (method_name
, "op", 2) == 0 ||
2243 strncmp (method_name
, "type", 4) == 0)
2245 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
2246 method_name
= dem_opname
;
2247 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
2248 method_name
= dem_opname
;
2251 if (STREQ (name
, method_name
))
2252 /* Find all the overloaded methods with that name. */
2253 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
2260 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
2262 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
2266 tmp_name
= gdb_mangle_name (t
,
2269 phys_name
= alloca (strlen (tmp_name
) + 1);
2270 strcpy (phys_name
, tmp_name
);
2274 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
2276 /* Destructor is handled by caller, dont add it to the list */
2277 if (DESTRUCTOR_PREFIX_P (phys_name
))
2280 sym_arr
[i1
] = lookup_symbol (phys_name
,
2281 NULL
, VAR_NAMESPACE
,
2283 (struct symtab
**) NULL
);
2288 /* This error message gets printed, but the method
2289 still seems to be found
2290 fputs_filtered("(Cannot find method ", gdb_stdout);
2291 fprintf_symbol_filtered (gdb_stdout, phys_name,
2293 DMGL_PARAMS | DMGL_ANSI);
2294 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
2301 /* Only search baseclasses if there is no match yet, since names in
2302 derived classes override those in baseclasses.
2304 FIXME: The above is not true; it is only true of member functions
2305 if they have the same number of arguments (??? - section 13.1 of the
2306 ARM says the function members are not in the same scope but doesn't
2307 really spell out the rules in a way I understand. In any case, if
2308 the number of arguments differ this is a case in which we can overload
2309 rather than hiding without any problem, and gcc 2.4.5 does overload
2310 rather than hiding in this case). */
2313 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
2314 i1
+= find_methods (TYPE_BASECLASS (t
, ibase
), name
, sym_arr
+ i1
);
2319 /* Helper function for decode_line_1.
2320 Build a canonical line spec in CANONICAL if it is non-NULL and if
2321 the SAL has a symtab.
2322 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
2323 If SYMNAME is NULL the line number from SAL is used and the canonical
2324 line spec is `filename:linenum'. */
2327 build_canonical_line_spec (struct symtab_and_line
*sal
, char *symname
,
2330 char **canonical_arr
;
2331 char *canonical_name
;
2333 struct symtab
*s
= sal
->symtab
;
2335 if (s
== (struct symtab
*) NULL
2336 || s
->filename
== (char *) NULL
2337 || canonical
== (char ***) NULL
)
2340 canonical_arr
= (char **) xmalloc (sizeof (char *));
2341 *canonical
= canonical_arr
;
2343 filename
= s
->filename
;
2344 if (symname
!= NULL
)
2346 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
2347 sprintf (canonical_name
, "%s:%s", filename
, symname
);
2351 canonical_name
= xmalloc (strlen (filename
) + 30);
2352 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
2354 canonical_arr
[0] = canonical_name
;
2359 /* Find an instance of the character C in the string S that is outside
2360 of all parenthesis pairs, single-quoted strings, and double-quoted
2363 find_toplevel_char (char *s
, char c
)
2365 int quoted
= 0; /* zero if we're not in quotes;
2366 '"' if we're in a double-quoted string;
2367 '\'' if we're in a single-quoted string. */
2368 int depth
= 0; /* number of unclosed parens we've seen */
2371 for (scan
= s
; *scan
; scan
++)
2375 if (*scan
== quoted
)
2377 else if (*scan
== '\\' && *(scan
+ 1))
2380 else if (*scan
== c
&& ! quoted
&& depth
== 0)
2382 else if (*scan
== '"' || *scan
== '\'')
2384 else if (*scan
== '(')
2386 else if (*scan
== ')' && depth
> 0)
2394 /* Parse a string that specifies a line number.
2395 Pass the address of a char * variable; that variable will be
2396 advanced over the characters actually parsed.
2400 LINENUM -- that line number in current file. PC returned is 0.
2401 FILE:LINENUM -- that line in that file. PC returned is 0.
2402 FUNCTION -- line number of openbrace of that function.
2403 PC returned is the start of the function.
2404 VARIABLE -- line number of definition of that variable.
2406 FILE:FUNCTION -- likewise, but prefer functions in that file.
2407 *EXPR -- line in which address EXPR appears.
2409 This may all be followed by an "if EXPR", which we ignore.
2411 FUNCTION may be an undebuggable function found in minimal symbol table.
2413 If the argument FUNFIRSTLINE is nonzero, we want the first line
2414 of real code inside a function when a function is specified, and it is
2415 not OK to specify a variable or type to get its line number.
2417 DEFAULT_SYMTAB specifies the file to use if none is specified.
2418 It defaults to current_source_symtab.
2419 DEFAULT_LINE specifies the line number to use for relative
2420 line numbers (that start with signs). Defaults to current_source_line.
2421 If CANONICAL is non-NULL, store an array of strings containing the canonical
2422 line specs there if necessary. Currently overloaded member functions and
2423 line numbers or static functions without a filename yield a canonical
2424 line spec. The array and the line spec strings are allocated on the heap,
2425 it is the callers responsibility to free them.
2427 Note that it is possible to return zero for the symtab
2428 if no file is validly specified. Callers must check that.
2429 Also, the line number returned may be invalid. */
2431 /* We allow single quotes in various places. This is a hideous
2432 kludge, which exists because the completer can't yet deal with the
2433 lack of single quotes. FIXME: write a linespec_completer which we
2434 can use as appropriate instead of make_symbol_completion_list. */
2436 struct symtabs_and_lines
2437 decode_line_1 (char **argptr
, int funfirstline
, struct symtab
*default_symtab
,
2438 int default_line
, char ***canonical
)
2440 struct symtabs_and_lines values
;
2441 #ifdef HPPA_COMPILER_BUG
2442 /* FIXME: The native HP 9000/700 compiler has a bug which appears
2443 when optimizing this file with target i960-vxworks. I haven't
2444 been able to construct a simple test case. The problem is that
2445 in the second call to SKIP_PROLOGUE below, the compiler somehow
2446 does not realize that the statement val = find_pc_line (...) will
2447 change the values of the fields of val. It extracts the elements
2448 into registers at the top of the block, and does not update the
2449 registers after the call to find_pc_line. You can check this by
2450 inserting a printf at the end of find_pc_line to show what values
2451 it is returning for val.pc and val.end and another printf after
2452 the call to see what values the function actually got (remember,
2453 this is compiling with cc -O, with this patch removed). You can
2454 also examine the assembly listing: search for the second call to
2455 skip_prologue; the LDO statement before the next call to
2456 find_pc_line loads the address of the structure which
2457 find_pc_line will return; if there is a LDW just before the LDO,
2458 which fetches an element of the structure, then the compiler
2461 Setting val to volatile avoids the problem. We must undef
2462 volatile, because the HPPA native compiler does not define
2463 __STDC__, although it does understand volatile, and so volatile
2464 will have been defined away in defs.h. */
2466 volatile struct symtab_and_line val
;
2467 #define volatile /*nothing */
2469 struct symtab_and_line val
;
2471 register char *p
, *p1
;
2472 char *q
, *pp
, *ii
, *p2
;
2476 register struct symtab
*s
;
2478 register struct symbol
*sym
;
2479 /* The symtab that SYM was found in. */
2480 struct symtab
*sym_symtab
;
2482 register CORE_ADDR pc
;
2483 register struct minimal_symbol
*msymbol
;
2485 struct symbol
*sym_class
;
2488 int is_quote_enclosed
;
2492 struct symbol
**sym_arr
;
2494 char *saved_arg
= *argptr
;
2495 extern char *gdb_completer_quote_characters
;
2497 INIT_SAL (&val
); /* initialize to zeroes */
2499 /* Defaults have defaults. */
2501 if (default_symtab
== 0)
2503 default_symtab
= current_source_symtab
;
2504 default_line
= current_source_line
;
2507 /* See if arg is *PC */
2509 if (**argptr
== '*')
2512 pc
= parse_and_eval_address_1 (argptr
);
2514 values
.sals
= (struct symtab_and_line
*)
2515 xmalloc (sizeof (struct symtab_and_line
));
2518 values
.sals
[0] = find_pc_line (pc
, 0);
2519 values
.sals
[0].pc
= pc
;
2520 values
.sals
[0].section
= find_pc_overlay (pc
);
2525 /* 'has_if' is for the syntax:
2526 * (gdb) break foo if (a==b)
2528 if ((ii
= strstr (*argptr
, " if ")) != NULL
||
2529 (ii
= strstr (*argptr
, "\tif ")) != NULL
||
2530 (ii
= strstr (*argptr
, " if\t")) != NULL
||
2531 (ii
= strstr (*argptr
, "\tif\t")) != NULL
||
2532 (ii
= strstr (*argptr
, " if(")) != NULL
||
2533 (ii
= strstr (*argptr
, "\tif( ")) != NULL
)
2535 /* Temporarily zap out "if (condition)" to not
2536 * confuse the parenthesis-checking code below.
2537 * This is undone below. Do not change ii!!
2544 /* Set various flags.
2545 * 'has_parens' is important for overload checking, where
2546 * we allow things like:
2547 * (gdb) break c::f(int)
2550 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
2552 is_quoted
= (**argptr
2553 && strchr (gdb_completer_quote_characters
, **argptr
) != NULL
);
2555 has_parens
= ((pp
= strchr (*argptr
, '(')) != NULL
2556 && (pp
= strrchr (pp
, ')')) != NULL
);
2558 /* Now that we're safely past the has_parens check,
2559 * put back " if (condition)" so outer layers can see it
2564 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
2565 and we must isolate the first half. Outer layers will call again later
2566 for the second half.
2568 Don't count commas that appear in argument lists of overloaded
2569 functions, or in quoted strings. It's stupid to go to this much
2570 trouble when the rest of the function is such an obvious roach hotel. */
2571 ii
= find_toplevel_char (*argptr
, ',');
2572 has_comma
= (ii
!= 0);
2574 /* Temporarily zap out second half to not
2575 * confuse the code below.
2576 * This is undone below. Do not change ii!!
2583 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
2584 /* May also be CLASS::MEMBER, or NAMESPACE::NAME */
2585 /* Look for ':', but ignore inside of <> */
2591 is_quote_enclosed
= 1;
2595 is_quote_enclosed
= 0;
2600 char *temp_end
= find_template_name_end (p
);
2602 error ("malformed template specification in command");
2605 /* Check for the end of the first half of the linespec. End of line,
2606 a tab, a double colon or the last single colon, or a space. But
2607 if enclosed in double quotes we do not break on enclosed spaces */
2611 && ((p
[1] == ':') || (strchr (p
+ 1, ':') == NULL
)))
2612 || ((p
[0] == ' ') && !is_quote_enclosed
))
2614 if (p
[0] == '.' && strchr (p
, ':') == NULL
) /* Java qualified method. */
2616 /* Find the *last* '.', since the others are package qualifiers. */
2617 for (p1
= p
; *p1
; p1
++)
2625 while (p
[0] == ' ' || p
[0] == '\t')
2628 /* if the closing double quote was left at the end, remove it */
2629 if (is_quote_enclosed
)
2631 char *closing_quote
= strchr (p
, '"');
2632 if (closing_quote
&& closing_quote
[1] == '\0')
2633 *closing_quote
= '\0';
2636 /* Now that we've safely parsed the first half,
2637 * put back ',' so outer layers can see it
2642 if ((p
[0] == ':' || p
[0] == '.') && !has_parens
)
2647 *argptr
= *argptr
+ 1;
2648 if (p
[0] == '.' || p
[1] == ':')
2650 char *saved_arg2
= *argptr
;
2652 /* First check for "global" namespace specification,
2653 of the form "::foo". If found, skip over the colons
2654 and jump to normal symbol processing */
2656 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
2659 /* We have what looks like a class or namespace
2660 scope specification (A::B), possibly with many
2661 levels of namespaces or classes (A::B::C::D).
2663 Some versions of the HP ANSI C++ compiler (as also possibly
2664 other compilers) generate class/function/member names with
2665 embedded double-colons if they are inside namespaces. To
2666 handle this, we loop a few times, considering larger and
2667 larger prefixes of the string as though they were single
2668 symbols. So, if the initially supplied string is
2669 A::B::C::D::foo, we have to look up "A", then "A::B",
2670 then "A::B::C", then "A::B::C::D", and finally
2671 "A::B::C::D::foo" as single, monolithic symbols, because
2672 A, B, C or D may be namespaces.
2674 Note that namespaces can nest only inside other
2675 namespaces, and not inside classes. So we need only
2676 consider *prefixes* of the string; there is no need to look up
2677 "B::C" separately as a symbol in the previous example. */
2679 p2
= p
; /* save for restart */
2682 /* Extract the class name. */
2684 while (p
!= *argptr
&& p
[-1] == ' ')
2686 copy
= (char *) alloca (p
- *argptr
+ 1);
2687 memcpy (copy
, *argptr
, p
- *argptr
);
2688 copy
[p
- *argptr
] = 0;
2690 /* Discard the class name from the arg. */
2691 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
2692 while (*p
== ' ' || *p
== '\t')
2696 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
2697 (struct symtab
**) NULL
);
2700 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
2701 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
2702 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
2704 /* Arg token is not digits => try it as a function name
2705 Find the next token(everything up to end or next blank). */
2707 && strchr (gdb_completer_quote_characters
, **argptr
) != NULL
)
2709 p
= skip_quoted (*argptr
);
2710 *argptr
= *argptr
+ 1;
2715 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':')
2719 q = operator_chars (*argptr, &q1);
2723 char *tmp = alloca (q1 - q + 1);
2724 memcpy (tmp, q, q1 - q);
2726 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
2730 printf_filtered ("no mangling for \"%s\"\n", tmp);
2731 cplusplus_hint (saved_arg);
2732 return_to_top_level (RETURN_ERROR);
2734 copy = (char*) alloca (3 + strlen(opname));
2735 sprintf (copy, "__%s", opname);
2741 copy
= (char *) alloca (p
- *argptr
+ 1);
2742 memcpy (copy
, *argptr
, p
- *argptr
);
2743 copy
[p
- *argptr
] = '\0';
2745 && copy
[p
- *argptr
- 1]
2746 && strchr (gdb_completer_quote_characters
,
2747 copy
[p
- *argptr
- 1]) != NULL
)
2748 copy
[p
- *argptr
- 1] = '\0';
2751 /* no line number may be specified */
2752 while (*p
== ' ' || *p
== '\t')
2757 i1
= 0; /* counter for the symbol array */
2758 sym_arr
= (struct symbol
**) alloca (total_number_of_methods (t
)
2759 * sizeof (struct symbol
*));
2761 if (destructor_name_p (copy
, t
))
2763 /* Destructors are a special case. */
2764 int m_index
, f_index
;
2766 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2768 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, m_index
);
2771 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, f_index
),
2772 NULL
, VAR_NAMESPACE
, (int *) NULL
,
2773 (struct symtab
**) NULL
);
2779 i1
= find_methods (t
, copy
, sym_arr
);
2782 /* There is exactly one field with that name. */
2785 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2787 values
.sals
= (struct symtab_and_line
*)
2788 xmalloc (sizeof (struct symtab_and_line
));
2790 values
.sals
[0] = find_function_start_sal (sym
,
2801 /* There is more than one field with that name
2802 (overloaded). Ask the user which one to use. */
2803 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
2809 if (OPNAME_PREFIX_P (copy
))
2811 tmp
= (char *) alloca (strlen (copy
+ 3) + 9);
2812 strcpy (tmp
, "operator ");
2813 strcat (tmp
, copy
+ 3);
2820 ("the class `%s' does not have destructor defined\n",
2821 SYMBOL_SOURCE_NAME (sym_class
));
2824 ("the class %s does not have any method named %s\n",
2825 SYMBOL_SOURCE_NAME (sym_class
), tmp
);
2826 cplusplus_hint (saved_arg
);
2827 return_to_top_level (RETURN_ERROR
);
2831 /* Move pointer up to next possible class/namespace token */
2832 p
= p2
+ 1; /* restart with old value +1 */
2833 /* Move pointer ahead to next double-colon */
2834 while (*p
&& (p
[0] != ' ') && (p
[0] != '\t') && (p
[0] != '\''))
2838 temp_end
= find_template_name_end (p
);
2840 error ("malformed template specification in command");
2843 else if ((p
[0] == ':') && (p
[1] == ':'))
2844 break; /* found double-colon */
2850 break; /* out of the while (1) */
2852 p2
= p
; /* save restart for next time around */
2853 *argptr
= saved_arg2
; /* restore argptr */
2856 /* Last chance attempt -- check entire name as a symbol */
2857 /* Use "copy" in preparation for jumping out of this block,
2858 to be consistent with usage following the jump target */
2859 copy
= (char *) alloca (p
- saved_arg2
+ 1);
2860 memcpy (copy
, saved_arg2
, p
- saved_arg2
);
2861 /* Note: if is_quoted should be true, we snuff out quote here anyway */
2862 copy
[p
- saved_arg2
] = '\000';
2863 /* Set argptr to skip over the name */
2864 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
2865 /* Look up entire name */
2866 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
2867 s
= (struct symtab
*) 0;
2868 /* Prepare to jump: restore the " if (condition)" so outer layers see it */
2869 /* Symbol was found --> jump to normal symbol processing.
2870 Code following "symbol_found" expects "copy" to have the
2871 symbol name, "sym" to have the symbol pointer, "s" to be
2872 a specified file's symtab, and sym_symtab to be the symbol's
2874 /* By jumping there we avoid falling through the FILE:LINE and
2875 FILE:FUNC processing stuff below */
2879 /* Couldn't find any interpretation as classes/namespaces, so give up */
2881 /* The quotes are important if copy is empty. */
2883 ("Can't find member of namespace, class, struct, or union named \"%s\"\n", copy
);
2884 cplusplus_hint (saved_arg
);
2885 return_to_top_level (RETURN_ERROR
);
2890 /* Extract the file name. */
2892 while (p
!= *argptr
&& p
[-1] == ' ')
2894 if ((*p
== '"') && is_quote_enclosed
)
2896 copy
= (char *) alloca (p
- *argptr
+ 1);
2897 if ((**argptr
== '"') && is_quote_enclosed
)
2899 memcpy (copy
, *argptr
+ 1, p
- *argptr
- 1);
2900 /* It may have the ending quote right after the file name */
2901 if (copy
[p
- *argptr
- 2] == '"')
2902 copy
[p
- *argptr
- 2] = 0;
2904 copy
[p
- *argptr
- 1] = 0;
2908 memcpy (copy
, *argptr
, p
- *argptr
);
2909 copy
[p
- *argptr
] = 0;
2912 /* Find that file's data. */
2913 s
= lookup_symtab (copy
);
2916 if (!have_full_symbols () && !have_partial_symbols ())
2917 error (no_symtab_msg
);
2918 error ("No source file named %s.", copy
);
2921 /* Discard the file name from the arg. */
2923 while (*p
== ' ' || *p
== '\t')
2928 /* No one really seems to know why this was added. It certainly
2929 breaks the command line, though, whenever the passed
2930 name is of the form ClassName::Method. This bit of code
2931 singles out the class name, and if funfirstline is set (for
2932 example, you are setting a breakpoint at this function),
2933 you get an error. This did not occur with earlier
2934 verions, so I am ifdef'ing this out. 3/29/99 */
2937 /* Check if what we have till now is a symbol name */
2939 /* We may be looking at a template instantiation such
2940 as "foo<int>". Check here whether we know about it,
2941 instead of falling through to the code below which
2942 handles ordinary function names, because that code
2943 doesn't like seeing '<' and '>' in a name -- the
2944 skip_quoted call doesn't go past them. So see if we
2945 can figure it out right now. */
2947 copy
= (char *) alloca (p
- *argptr
+ 1);
2948 memcpy (copy
, *argptr
, p
- *argptr
);
2949 copy
[p
- *argptr
] = '\000';
2950 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
2953 /* Yes, we have a symbol; jump to symbol processing */
2954 /* Code after symbol_found expects S, SYM_SYMTAB, SYM,
2955 and COPY to be set correctly */
2956 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
2957 s
= (struct symtab
*) 0;
2960 /* Otherwise fall out from here and go to file/line spec
2965 /* S is specified file's symtab, or 0 if no file specified.
2966 arg no longer contains the file name. */
2968 /* Check whether arg is all digits (and sign) */
2971 if (*q
== '-' || *q
== '+')
2973 while (*q
>= '0' && *q
<= '9')
2976 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
2978 /* We found a token consisting of all digits -- at least one digit. */
2985 /* We might need a canonical line spec if no file was specified. */
2986 int need_canonical
= (s
== 0) ? 1 : 0;
2988 /* This is where we need to make sure that we have good defaults.
2989 We must guarantee that this section of code is never executed
2990 when we are called with just a function name, since
2991 select_source_symtab calls us with such an argument */
2993 if (s
== 0 && default_symtab
== 0)
2995 select_source_symtab (0);
2996 default_symtab
= current_source_symtab
;
2997 default_line
= current_source_line
;
3000 if (**argptr
== '+')
3001 sign
= plus
, (*argptr
)++;
3002 else if (**argptr
== '-')
3003 sign
= minus
, (*argptr
)++;
3004 val
.line
= atoi (*argptr
);
3011 val
.line
= default_line
+ val
.line
;
3017 val
.line
= default_line
- val
.line
;
3022 break; /* No need to adjust val.line. */
3025 while (*q
== ' ' || *q
== '\t')
3031 /* It is possible that this source file has more than one symtab,
3032 and that the new line number specification has moved us from the
3033 default (in s) to a new one. */
3034 val
.symtab
= find_line_symtab (s
, val
.line
, NULL
, NULL
);
3035 if (val
.symtab
== 0)
3039 values
.sals
= (struct symtab_and_line
*)
3040 xmalloc (sizeof (struct symtab_and_line
));
3041 values
.sals
[0] = val
;
3044 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
3048 /* Arg token is not digits => try it as a variable name
3049 Find the next token (everything up to end or next whitespace). */
3051 if (**argptr
== '$') /* May be a convenience variable */
3052 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1)); /* One or two $ chars possible */
3055 p
= skip_quoted (*argptr
);
3057 error ("Unmatched single quote.");
3059 else if (has_parens
)
3065 p
= skip_quoted (*argptr
);
3068 if (is_quote_enclosed
&& **argptr
== '"')
3071 copy
= (char *) alloca (p
- *argptr
+ 1);
3072 memcpy (copy
, *argptr
, p
- *argptr
);
3073 copy
[p
- *argptr
] = '\0';
3076 && copy
[0] == copy
[p
- *argptr
- 1]
3077 && strchr (gdb_completer_quote_characters
, copy
[0]) != NULL
)
3079 copy
[p
- *argptr
- 1] = '\0';
3082 while (*p
== ' ' || *p
== '\t')
3086 /* If it starts with $: may be a legitimate variable or routine name
3087 (e.g. HP-UX millicode routines such as $$dyncall), or it may
3088 be history value, or it may be a convenience variable */
3094 int need_canonical
= 0;
3096 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
3097 while (*p
>= '0' && *p
<= '9')
3099 if (!*p
) /* reached end of token without hitting non-digit */
3101 /* We have a value history reference */
3102 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
3103 valx
= access_value_history ((copy
[1] == '$') ? -index
: index
);
3104 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
3105 error ("History values used in line specs must have integer values.");
3109 /* Not all digits -- may be user variable/function or a
3110 convenience variable */
3112 /* Look up entire name as a symbol first */
3113 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
3114 s
= (struct symtab
*) 0;
3116 /* Symbol was found --> jump to normal symbol processing.
3117 Code following "symbol_found" expects "copy" to have the
3118 symbol name, "sym" to have the symbol pointer, "s" to be
3119 a specified file's symtab, and sym_symtab to be the symbol's
3124 /* If symbol was not found, look in minimal symbol tables */
3125 msymbol
= lookup_minimal_symbol (copy
, 0, 0);
3126 /* Min symbol was found --> jump to minsym processing. */
3128 goto minimal_symbol_found
;
3130 /* Not a user variable or function -- must be convenience variable */
3131 need_canonical
= (s
== 0) ? 1 : 0;
3132 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
3133 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
3134 error ("Convenience variables used in line specs must have integer values.");
3137 /* Either history value or convenience value from above, in valx */
3138 val
.symtab
= s
? s
: default_symtab
;
3139 val
.line
= value_as_long (valx
);
3142 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof val
);
3143 values
.sals
[0] = val
;
3147 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
3153 /* Look up that token as a variable.
3154 If file specified, use that file's per-file block to start with. */
3156 sym
= lookup_symbol (copy
,
3157 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
3158 : get_selected_block ()),
3159 VAR_NAMESPACE
, 0, &sym_symtab
);
3161 symbol_found
: /* We also jump here from inside the C++ class/namespace
3162 code on finding a symbol of the form "A::B::C" */
3166 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3168 /* Arg is the name of a function */
3169 values
.sals
= (struct symtab_and_line
*)
3170 xmalloc (sizeof (struct symtab_and_line
));
3171 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
3174 /* Don't use the SYMBOL_LINE; if used at all it points to
3175 the line containing the parameters or thereabouts, not
3176 the first line of code. */
3178 /* We might need a canonical line spec if it is a static
3182 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
3183 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
3184 if (lookup_block_symbol (b
, copy
, VAR_NAMESPACE
) != NULL
)
3185 build_canonical_line_spec (values
.sals
, copy
, canonical
);
3192 error ("\"%s\" is not a function", copy
);
3193 else if (SYMBOL_LINE (sym
) != 0)
3195 /* We know its line number. */
3196 values
.sals
= (struct symtab_and_line
*)
3197 xmalloc (sizeof (struct symtab_and_line
));
3199 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
3200 values
.sals
[0].symtab
= sym_symtab
;
3201 values
.sals
[0].line
= SYMBOL_LINE (sym
);
3205 /* This can happen if it is compiled with a compiler which doesn't
3206 put out line numbers for variables. */
3207 /* FIXME: Shouldn't we just set .line and .symtab to zero
3208 and return? For example, "info line foo" could print
3210 error ("Line number not known for symbol \"%s\"", copy
);
3214 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
3216 minimal_symbol_found
: /* We also jump here from the case for variables
3217 that begin with '$' */
3219 if (msymbol
!= NULL
)
3221 values
.sals
= (struct symtab_and_line
*)
3222 xmalloc (sizeof (struct symtab_and_line
));
3223 values
.sals
[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
3224 (struct sec
*) 0, 0);
3225 values
.sals
[0].section
= SYMBOL_BFD_SECTION (msymbol
);
3228 values
.sals
[0].pc
+= FUNCTION_START_OFFSET
;
3229 values
.sals
[0].pc
= SKIP_PROLOGUE (values
.sals
[0].pc
);
3235 if (!have_full_symbols () &&
3236 !have_partial_symbols () && !have_minimal_symbols ())
3237 error (no_symtab_msg
);
3239 error ("Function \"%s\" not defined.", copy
);
3240 return values
; /* for lint */
3243 struct symtabs_and_lines
3244 decode_line_spec (char *string
, int funfirstline
)
3246 struct symtabs_and_lines sals
;
3248 error ("Empty line specification.");
3249 sals
= decode_line_1 (&string
, funfirstline
,
3250 current_source_symtab
, current_source_line
,
3253 error ("Junk at end of line specification: %s", string
);
3257 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
3258 operate on (ask user if necessary).
3259 If CANONICAL is non-NULL return a corresponding array of mangled names
3260 as canonical line specs there. */
3262 static struct symtabs_and_lines
3263 decode_line_2 (sym_arr
, nelts
, funfirstline
, canonical
)
3264 struct symbol
*sym_arr
[];
3269 struct symtabs_and_lines values
, return_values
;
3274 struct cleanup
*old_chain
;
3275 char **canonical_arr
= (char **) NULL
;
3277 values
.sals
= (struct symtab_and_line
*)
3278 alloca (nelts
* sizeof (struct symtab_and_line
));
3279 return_values
.sals
= (struct symtab_and_line
*)
3280 xmalloc (nelts
* sizeof (struct symtab_and_line
));
3281 old_chain
= make_cleanup (free
, return_values
.sals
);
3285 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
3286 make_cleanup (free
, canonical_arr
);
3287 memset (canonical_arr
, 0, nelts
* sizeof (char *));
3288 *canonical
= canonical_arr
;
3292 printf_unfiltered ("[0] cancel\n[1] all\n");
3295 INIT_SAL (&return_values
.sals
[i
]); /* initialize to zeroes */
3296 INIT_SAL (&values
.sals
[i
]);
3297 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
3299 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
3300 printf_unfiltered ("[%d] %s at %s:%d\n",
3302 SYMBOL_SOURCE_NAME (sym_arr
[i
]),
3303 values
.sals
[i
].symtab
->filename
,
3304 values
.sals
[i
].line
);
3307 printf_unfiltered ("?HERE\n");
3311 if ((prompt
= getenv ("PS2")) == NULL
)
3315 args
= command_line_input (prompt
, 0, "overload-choice");
3317 if (args
== 0 || *args
== 0)
3318 error_no_arg ("one or more choice numbers");
3326 while (*arg1
>= '0' && *arg1
<= '9')
3328 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
3329 error ("Arguments must be choice numbers.");
3334 error ("cancelled");
3339 for (i
= 0; i
< nelts
; i
++)
3341 if (canonical_arr
[i
] == NULL
)
3343 symname
= SYMBOL_NAME (sym_arr
[i
]);
3344 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
3348 memcpy (return_values
.sals
, values
.sals
,
3349 (nelts
* sizeof (struct symtab_and_line
)));
3350 return_values
.nelts
= nelts
;
3351 discard_cleanups (old_chain
);
3352 return return_values
;
3355 if (num
>= nelts
+ 2)
3357 printf_unfiltered ("No choice number %d.\n", num
);
3362 if (values
.sals
[num
].pc
)
3366 symname
= SYMBOL_NAME (sym_arr
[num
]);
3367 make_cleanup (free
, symname
);
3368 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
3370 return_values
.sals
[i
++] = values
.sals
[num
];
3371 values
.sals
[num
].pc
= 0;
3375 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
3380 while (*args
== ' ' || *args
== '\t')
3383 return_values
.nelts
= i
;
3384 discard_cleanups (old_chain
);
3385 return return_values
;
3389 /* Slave routine for sources_info. Force line breaks at ,'s.
3390 NAME is the name to print and *FIRST is nonzero if this is the first
3391 name printed. Set *FIRST to zero. */
3393 output_source_filename (char *name
, int *first
)
3395 /* Table of files printed so far. Since a single source file can
3396 result in several partial symbol tables, we need to avoid printing
3397 it more than once. Note: if some of the psymtabs are read in and
3398 some are not, it gets printed both under "Source files for which
3399 symbols have been read" and "Source files for which symbols will
3400 be read in on demand". I consider this a reasonable way to deal
3401 with the situation. I'm not sure whether this can also happen for
3402 symtabs; it doesn't hurt to check. */
3403 static char **tab
= NULL
;
3404 /* Allocated size of tab in elements.
3405 Start with one 256-byte block (when using GNU malloc.c).
3406 24 is the malloc overhead when range checking is in effect. */
3407 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
3408 /* Current size of tab in elements. */
3409 static int tab_cur_size
;
3416 tab
= (char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
3420 /* Is NAME in tab? */
3421 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
3422 if (STREQ (*p
, name
))
3423 /* Yes; don't print it again. */
3425 /* No; add it to tab. */
3426 if (tab_cur_size
== tab_alloc_size
)
3428 tab_alloc_size
*= 2;
3429 tab
= (char **) xrealloc ((char *) tab
, tab_alloc_size
* sizeof (*tab
));
3431 tab
[tab_cur_size
++] = name
;
3439 printf_filtered (", ");
3443 fputs_filtered (name
, gdb_stdout
);
3447 sources_info (char *ignore
, int from_tty
)
3449 register struct symtab
*s
;
3450 register struct partial_symtab
*ps
;
3451 register struct objfile
*objfile
;
3454 if (!have_full_symbols () && !have_partial_symbols ())
3456 error (no_symtab_msg
);
3459 printf_filtered ("Source files for which symbols have been read in:\n\n");
3462 ALL_SYMTABS (objfile
, s
)
3464 output_source_filename (s
->filename
, &first
);
3466 printf_filtered ("\n\n");
3468 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
3471 ALL_PSYMTABS (objfile
, ps
)
3475 output_source_filename (ps
->filename
, &first
);
3478 printf_filtered ("\n");
3482 file_matches (file
, files
, nfiles
)
3489 if (file
!= NULL
&& nfiles
!= 0)
3491 for (i
= 0; i
< nfiles
; i
++)
3493 if (strcmp (files
[i
], basename (file
)) == 0)
3497 else if (nfiles
== 0)
3502 /* Free any memory associated with a search. */
3504 free_search_symbols (struct symbol_search
*symbols
)
3506 struct symbol_search
*p
;
3507 struct symbol_search
*next
;
3509 for (p
= symbols
; p
!= NULL
; p
= next
)
3517 do_free_search_symbols_cleanup (void *symbols
)
3519 free_search_symbols (symbols
);
3523 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
3525 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
3529 /* Search the symbol table for matches to the regular expression REGEXP,
3530 returning the results in *MATCHES.
3532 Only symbols of KIND are searched:
3533 FUNCTIONS_NAMESPACE - search all functions
3534 TYPES_NAMESPACE - search all type names
3535 METHODS_NAMESPACE - search all methods NOT IMPLEMENTED
3536 VARIABLES_NAMESPACE - search all symbols, excluding functions, type names,
3537 and constants (enums)
3539 free_search_symbols should be called when *MATCHES is no longer needed.
3542 search_symbols (regexp
, kind
, nfiles
, files
, matches
)
3544 namespace_enum kind
;
3547 struct symbol_search
**matches
;
3550 register struct symtab
*s
;
3551 register struct partial_symtab
*ps
;
3552 register struct blockvector
*bv
;
3553 struct blockvector
*prev_bv
= 0;
3554 register struct block
*b
;
3557 register struct symbol
*sym
;
3558 struct partial_symbol
**psym
;
3559 struct objfile
*objfile
;
3560 struct minimal_symbol
*msymbol
;
3563 static enum minimal_symbol_type types
[]
3565 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
3566 static enum minimal_symbol_type types2
[]
3568 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
3569 static enum minimal_symbol_type types3
[]
3571 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
3572 static enum minimal_symbol_type types4
[]
3574 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
3575 enum minimal_symbol_type ourtype
;
3576 enum minimal_symbol_type ourtype2
;
3577 enum minimal_symbol_type ourtype3
;
3578 enum minimal_symbol_type ourtype4
;
3579 struct symbol_search
*sr
;
3580 struct symbol_search
*psr
;
3581 struct symbol_search
*tail
;
3582 struct cleanup
*old_chain
= NULL
;
3584 if (kind
< LABEL_NAMESPACE
)
3585 error ("must search on specific namespace");
3587 ourtype
= types
[(int) (kind
- VARIABLES_NAMESPACE
)];
3588 ourtype2
= types2
[(int) (kind
- VARIABLES_NAMESPACE
)];
3589 ourtype3
= types3
[(int) (kind
- VARIABLES_NAMESPACE
)];
3590 ourtype4
= types4
[(int) (kind
- VARIABLES_NAMESPACE
)];
3592 sr
= *matches
= NULL
;
3597 /* Make sure spacing is right for C++ operators.
3598 This is just a courtesy to make the matching less sensitive
3599 to how many spaces the user leaves between 'operator'
3600 and <TYPENAME> or <OPERATOR>. */
3602 char *opname
= operator_chars (regexp
, &opend
);
3605 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
3606 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
3608 /* There should 1 space between 'operator' and 'TYPENAME'. */
3609 if (opname
[-1] != ' ' || opname
[-2] == ' ')
3614 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3615 if (opname
[-1] == ' ')
3618 /* If wrong number of spaces, fix it. */
3621 char *tmp
= (char *) alloca (opend
- opname
+ 10);
3622 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3627 if (0 != (val
= re_comp (regexp
)))
3628 error ("Invalid regexp (%s): %s", val
, regexp
);
3631 /* Search through the partial symtabs *first* for all symbols
3632 matching the regexp. That way we don't have to reproduce all of
3633 the machinery below. */
3635 ALL_PSYMTABS (objfile
, ps
)
3637 struct partial_symbol
**bound
, **gbound
, **sbound
;
3643 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
3644 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
3647 /* Go through all of the symbols stored in a partial
3648 symtab in one loop. */
3649 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3654 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
3656 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3667 /* If it would match (logic taken from loop below)
3668 load the file and go on to the next one */
3669 if (file_matches (ps
->filename
, files
, nfiles
)
3670 && ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (*psym
))
3671 && ((kind
== VARIABLES_NAMESPACE
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
3672 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
3673 || (kind
== FUNCTIONS_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
3674 || (kind
== TYPES_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
3675 || (kind
== METHODS_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
))))
3677 PSYMTAB_TO_SYMTAB (ps
);
3685 /* Here, we search through the minimal symbol tables for functions
3686 and variables that match, and force their symbols to be read.
3687 This is in particular necessary for demangled variable names,
3688 which are no longer put into the partial symbol tables.
3689 The symbol will then be found during the scan of symtabs below.
3691 For functions, find_pc_symtab should succeed if we have debug info
3692 for the function, for variables we have to call lookup_symbol
3693 to determine if the variable has debug info.
3694 If the lookup fails, set found_misc so that we will rescan to print
3695 any matching symbols without debug info.
3698 if (nfiles
== 0 && (kind
== VARIABLES_NAMESPACE
|| kind
== FUNCTIONS_NAMESPACE
))
3700 ALL_MSYMBOLS (objfile
, msymbol
)
3702 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3703 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3704 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3705 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3707 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
3709 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
3711 if (kind
== FUNCTIONS_NAMESPACE
3712 || lookup_symbol (SYMBOL_NAME (msymbol
),
3713 (struct block
*) NULL
,
3715 0, (struct symtab
**) NULL
) == NULL
)
3723 ALL_SYMTABS (objfile
, s
)
3725 bv
= BLOCKVECTOR (s
);
3726 /* Often many files share a blockvector.
3727 Scan each blockvector only once so that
3728 we don't get every symbol many times.
3729 It happens that the first symtab in the list
3730 for any given blockvector is the main file. */
3732 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3734 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3735 /* Skip the sort if this block is always sorted. */
3736 if (!BLOCK_SHOULD_SORT (b
))
3737 sort_block_syms (b
);
3738 for (j
= 0; j
< BLOCK_NSYMS (b
); j
++)
3741 sym
= BLOCK_SYM (b
, j
);
3742 if (file_matches (s
->filename
, files
, nfiles
)
3743 && ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
3744 && ((kind
== VARIABLES_NAMESPACE
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3745 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3746 && SYMBOL_CLASS (sym
) != LOC_CONST
)
3747 || (kind
== FUNCTIONS_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3748 || (kind
== TYPES_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3749 || (kind
== METHODS_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
))))
3752 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3756 psr
->msymbol
= NULL
;
3761 old_chain
= make_cleanup_free_search_symbols (sr
);
3772 /* If there are no eyes, avoid all contact. I mean, if there are
3773 no debug symbols, then print directly from the msymbol_vector. */
3775 if (found_misc
|| kind
!= FUNCTIONS_NAMESPACE
)
3777 ALL_MSYMBOLS (objfile
, msymbol
)
3779 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3780 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3781 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3782 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3784 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
3786 /* Functions: Look up by address. */
3787 if (kind
!= FUNCTIONS_NAMESPACE
||
3788 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3790 /* Variables/Absolutes: Look up by name */
3791 if (lookup_symbol (SYMBOL_NAME (msymbol
),
3792 (struct block
*) NULL
, VAR_NAMESPACE
,
3793 0, (struct symtab
**) NULL
) == NULL
)
3796 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3798 psr
->msymbol
= msymbol
;
3805 old_chain
= make_cleanup_free_search_symbols (sr
);
3819 discard_cleanups (old_chain
);
3822 /* Helper function for symtab_symbol_info, this function uses
3823 the data returned from search_symbols() to print information
3824 regarding the match to gdb_stdout.
3827 print_symbol_info (namespace_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3828 int block
, char *last
)
3830 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3832 fputs_filtered ("\nFile ", gdb_stdout
);
3833 fputs_filtered (s
->filename
, gdb_stdout
);
3834 fputs_filtered (":\n", gdb_stdout
);
3837 if (kind
!= TYPES_NAMESPACE
&& block
== STATIC_BLOCK
)
3838 printf_filtered ("static ");
3840 /* Typedef that is not a C++ class */
3841 if (kind
== TYPES_NAMESPACE
3842 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
3843 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3844 /* variable, func, or typedef-that-is-c++-class */
3845 else if (kind
< TYPES_NAMESPACE
||
3846 (kind
== TYPES_NAMESPACE
&&
3847 SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
))
3849 type_print (SYMBOL_TYPE (sym
),
3850 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3851 ? "" : SYMBOL_SOURCE_NAME (sym
)),
3854 printf_filtered (";\n");
3859 /* Tiemann says: "info methods was never implemented." */
3860 char *demangled_name
;
3861 c_type_print_base (TYPE_FN_FIELD_TYPE (t
, block
),
3863 c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (t
, block
),
3865 if (TYPE_FN_FIELD_STUB (t
, block
))
3866 check_stub_method (TYPE_DOMAIN_TYPE (type
), j
, block
);
3868 cplus_demangle (TYPE_FN_FIELD_PHYSNAME (t
, block
),
3869 DMGL_ANSI
| DMGL_PARAMS
);
3870 if (demangled_name
== NULL
)
3871 fprintf_filtered (stream
, "<badly mangled name %s>",
3872 TYPE_FN_FIELD_PHYSNAME (t
, block
));
3875 fputs_filtered (demangled_name
, stream
);
3876 free (demangled_name
);
3882 /* This help function for symtab_symbol_info() prints information
3883 for non-debugging symbols to gdb_stdout.
3886 print_msymbol_info (struct minimal_symbol
*msymbol
)
3888 printf_filtered (" %08lx %s\n",
3889 (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol
),
3890 SYMBOL_SOURCE_NAME (msymbol
));
3893 /* This is the guts of the commands "info functions", "info types", and
3894 "info variables". It calls search_symbols to find all matches and then
3895 print_[m]symbol_info to print out some useful information about the
3899 symtab_symbol_info (char *regexp
, namespace_enum kind
, int from_tty
)
3901 static char *classnames
[]
3903 {"variable", "function", "type", "method"};
3904 struct symbol_search
*symbols
;
3905 struct symbol_search
*p
;
3906 struct cleanup
*old_chain
;
3907 char *last_filename
= NULL
;
3910 /* must make sure that if we're interrupted, symbols gets freed */
3911 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3912 old_chain
= make_cleanup_free_search_symbols (symbols
);
3914 printf_filtered (regexp
3915 ? "All %ss matching regular expression \"%s\":\n"
3916 : "All defined %ss:\n",
3917 classnames
[(int) (kind
- VARIABLES_NAMESPACE
)], regexp
);
3919 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3923 if (p
->msymbol
!= NULL
)
3927 printf_filtered ("\nNon-debugging symbols:\n");
3930 print_msymbol_info (p
->msymbol
);
3934 print_symbol_info (kind
,
3939 last_filename
= p
->symtab
->filename
;
3943 do_cleanups (old_chain
);
3947 variables_info (char *regexp
, int from_tty
)
3949 symtab_symbol_info (regexp
, VARIABLES_NAMESPACE
, from_tty
);
3953 functions_info (char *regexp
, int from_tty
)
3955 symtab_symbol_info (regexp
, FUNCTIONS_NAMESPACE
, from_tty
);
3960 types_info (char *regexp
, int from_tty
)
3962 symtab_symbol_info (regexp
, TYPES_NAMESPACE
, from_tty
);
3966 /* Tiemann says: "info methods was never implemented." */
3968 methods_info (char *regexp
)
3970 symtab_symbol_info (regexp
, METHODS_NAMESPACE
, 0, from_tty
);
3974 /* Breakpoint all functions matching regular expression. */
3977 rbreak_command_wrapper (char *regexp
, int from_tty
)
3979 rbreak_command (regexp
, from_tty
);
3983 rbreak_command (char *regexp
, int from_tty
)
3985 struct symbol_search
*ss
;
3986 struct symbol_search
*p
;
3987 struct cleanup
*old_chain
;
3989 search_symbols (regexp
, FUNCTIONS_NAMESPACE
, 0, (char **) NULL
, &ss
);
3990 old_chain
= make_cleanup_free_search_symbols (ss
);
3992 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3994 if (p
->msymbol
== NULL
)
3996 char *string
= (char *) alloca (strlen (p
->symtab
->filename
)
3997 + strlen (SYMBOL_NAME (p
->symbol
))
3999 strcpy (string
, p
->symtab
->filename
);
4000 strcat (string
, ":'");
4001 strcat (string
, SYMBOL_NAME (p
->symbol
));
4002 strcat (string
, "'");
4003 break_command (string
, from_tty
);
4004 print_symbol_info (FUNCTIONS_NAMESPACE
,
4008 p
->symtab
->filename
);
4012 break_command (SYMBOL_NAME (p
->msymbol
), from_tty
);
4013 printf_filtered ("<function, no debug info> %s;\n",
4014 SYMBOL_SOURCE_NAME (p
->msymbol
));
4018 do_cleanups (old_chain
);
4022 /* Return Nonzero if block a is lexically nested within block b,
4023 or if a and b have the same pc range.
4024 Return zero otherwise. */
4026 contained_in (struct block
*a
, struct block
*b
)
4030 return BLOCK_START (a
) >= BLOCK_START (b
)
4031 && BLOCK_END (a
) <= BLOCK_END (b
);
4035 /* Helper routine for make_symbol_completion_list. */
4037 static int return_val_size
;
4038 static int return_val_index
;
4039 static char **return_val
;
4041 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4043 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
4044 /* Put only the mangled name on the list. */ \
4045 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
4046 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
4047 completion_list_add_name \
4048 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
4050 completion_list_add_name \
4051 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
4054 /* Test to see if the symbol specified by SYMNAME (which is already
4055 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4056 characters. If so, add it to the current completion list. */
4059 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
4060 char *text
, char *word
)
4065 /* clip symbols that cannot match */
4067 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
4072 /* Clip any symbol names that we've already considered. (This is a
4073 time optimization) */
4075 for (i
= 0; i
< return_val_index
; ++i
)
4077 if (STREQ (symname
, return_val
[i
]))
4083 /* We have a match for a completion, so add SYMNAME to the current list
4084 of matches. Note that the name is moved to freshly malloc'd space. */
4088 if (word
== sym_text
)
4090 new = xmalloc (strlen (symname
) + 5);
4091 strcpy (new, symname
);
4093 else if (word
> sym_text
)
4095 /* Return some portion of symname. */
4096 new = xmalloc (strlen (symname
) + 5);
4097 strcpy (new, symname
+ (word
- sym_text
));
4101 /* Return some of SYM_TEXT plus symname. */
4102 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
4103 strncpy (new, word
, sym_text
- word
);
4104 new[sym_text
- word
] = '\0';
4105 strcat (new, symname
);
4108 /* Recheck for duplicates if we intend to add a modified symbol. */
4109 if (word
!= sym_text
)
4111 for (i
= 0; i
< return_val_index
; ++i
)
4113 if (STREQ (new, return_val
[i
]))
4121 if (return_val_index
+ 3 > return_val_size
)
4123 newsize
= (return_val_size
*= 2) * sizeof (char *);
4124 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
4126 return_val
[return_val_index
++] = new;
4127 return_val
[return_val_index
] = NULL
;
4131 /* Return a NULL terminated array of all symbols (regardless of class) which
4132 begin by matching TEXT. If the answer is no symbols, then the return value
4133 is an array which contains only a NULL pointer.
4135 Problem: All of the symbols have to be copied because readline frees them.
4136 I'm not going to worry about this; hopefully there won't be that many. */
4139 make_symbol_completion_list (char *text
, char *word
)
4141 register struct symbol
*sym
;
4142 register struct symtab
*s
;
4143 register struct partial_symtab
*ps
;
4144 register struct minimal_symbol
*msymbol
;
4145 register struct objfile
*objfile
;
4146 register struct block
*b
, *surrounding_static_block
= 0;
4148 struct partial_symbol
**psym
;
4149 /* The symbol we are completing on. Points in same buffer as text. */
4151 /* Length of sym_text. */
4154 /* Now look for the symbol we are supposed to complete on.
4155 FIXME: This should be language-specific. */
4159 char *quote_pos
= NULL
;
4161 /* First see if this is a quoted string. */
4163 for (p
= text
; *p
!= '\0'; ++p
)
4165 if (quote_found
!= '\0')
4167 if (*p
== quote_found
)
4168 /* Found close quote. */
4170 else if (*p
== '\\' && p
[1] == quote_found
)
4171 /* A backslash followed by the quote character
4172 doesn't end the string. */
4175 else if (*p
== '\'' || *p
== '"')
4181 if (quote_found
== '\'')
4182 /* A string within single quotes can be a symbol, so complete on it. */
4183 sym_text
= quote_pos
+ 1;
4184 else if (quote_found
== '"')
4185 /* A double-quoted string is never a symbol, nor does it make sense
4186 to complete it any other way. */
4190 /* It is not a quoted string. Break it based on the characters
4191 which are in symbols. */
4194 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
4203 sym_text_len
= strlen (sym_text
);
4205 return_val_size
= 100;
4206 return_val_index
= 0;
4207 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
4208 return_val
[0] = NULL
;
4210 /* Look through the partial symtabs for all symbols which begin
4211 by matching SYM_TEXT. Add each one that you find to the list. */
4213 ALL_PSYMTABS (objfile
, ps
)
4215 /* If the psymtab's been read in we'll get it when we search
4216 through the blockvector. */
4220 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
4221 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
4222 + ps
->n_global_syms
);
4225 /* If interrupted, then quit. */
4227 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
4230 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
4231 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
4232 + ps
->n_static_syms
);
4236 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
4240 /* At this point scan through the misc symbol vectors and add each
4241 symbol you find to the list. Eventually we want to ignore
4242 anything that isn't a text symbol (everything else will be
4243 handled by the psymtab code above). */
4245 ALL_MSYMBOLS (objfile
, msymbol
)
4248 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
4251 /* Search upwards from currently selected frame (so that we can
4252 complete on local vars. */
4254 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
4256 if (!BLOCK_SUPERBLOCK (b
))
4258 surrounding_static_block
= b
; /* For elmin of dups */
4261 /* Also catch fields of types defined in this places which match our
4262 text string. Only complete on types visible from current context. */
4264 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
4266 sym
= BLOCK_SYM (b
, i
);
4267 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4268 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
4270 struct type
*t
= SYMBOL_TYPE (sym
);
4271 enum type_code c
= TYPE_CODE (t
);
4273 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
4275 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
4277 if (TYPE_FIELD_NAME (t
, j
))
4279 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
4280 sym_text
, sym_text_len
, text
, word
);
4288 /* Go through the symtabs and check the externs and statics for
4289 symbols which match. */
4291 ALL_SYMTABS (objfile
, s
)
4294 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4295 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
4297 sym
= BLOCK_SYM (b
, i
);
4298 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4302 ALL_SYMTABS (objfile
, s
)
4305 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4306 /* Don't do this block twice. */
4307 if (b
== surrounding_static_block
)
4309 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
4311 sym
= BLOCK_SYM (b
, i
);
4312 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4316 return (return_val
);
4319 /* Determine if PC is in the prologue of a function. The prologue is the area
4320 between the first instruction of a function, and the first executable line.
4321 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4323 If non-zero, func_start is where we think the prologue starts, possibly
4324 by previous examination of symbol table information.
4328 in_prologue (CORE_ADDR pc
, CORE_ADDR func_start
)
4330 struct symtab_and_line sal
;
4331 CORE_ADDR func_addr
, func_end
;
4333 /* We have several sources of information we can consult to figure
4335 - Compilers usually emit line number info that marks the prologue
4336 as its own "source line". So the ending address of that "line"
4337 is the end of the prologue. If available, this is the most
4339 - The minimal symbols and partial symbols, which can usually tell
4340 us the starting and ending addresses of a function.
4341 - If we know the function's start address, we can call the
4342 architecture-defined SKIP_PROLOGUE function to analyze the
4343 instruction stream and guess where the prologue ends.
4344 - Our `func_start' argument; if non-zero, this is the caller's
4345 best guess as to the function's entry point. At the time of
4346 this writing, handle_inferior_event doesn't get this right, so
4347 it should be our last resort. */
4349 /* Consult the partial symbol table, to find which function
4351 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
4353 CORE_ADDR prologue_end
;
4355 /* We don't even have minsym information, so fall back to using
4356 func_start, if given. */
4358 return 1; /* We *might* be in a prologue. */
4360 prologue_end
= SKIP_PROLOGUE (func_start
);
4362 return func_start
<= pc
&& pc
< prologue_end
;
4365 /* If we have line number information for the function, that's
4366 usually pretty reliable. */
4367 sal
= find_pc_line (func_addr
, 0);
4369 /* Now sal describes the source line at the function's entry point,
4370 which (by convention) is the prologue. The end of that "line",
4371 sal.end, is the end of the prologue.
4373 Note that, for functions whose source code is all on a single
4374 line, the line number information doesn't always end up this way.
4375 So we must verify that our purported end-of-prologue address is
4376 *within* the function, not at its start or end. */
4378 || sal
.end
<= func_addr
4379 || func_end
<= sal
.end
)
4381 /* We don't have any good line number info, so use the minsym
4382 information, together with the architecture-specific prologue
4384 CORE_ADDR prologue_end
= SKIP_PROLOGUE (func_addr
);
4386 return func_addr
<= pc
&& pc
< prologue_end
;
4389 /* We have line number info, and it looks good. */
4390 return func_addr
<= pc
&& pc
< sal
.end
;
4394 /* Begin overload resolution functions */
4395 /* Helper routine for make_symbol_completion_list. */
4397 static int sym_return_val_size
;
4398 static int sym_return_val_index
;
4399 static struct symbol
**sym_return_val
;
4401 /* Test to see if the symbol specified by SYMNAME (which is already
4402 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4403 characters. If so, add it to the current completion list. */
4406 overload_list_add_symbol (struct symbol
*sym
, char *oload_name
)
4411 /* Get the demangled name without parameters */
4412 char *sym_name
= cplus_demangle (SYMBOL_NAME (sym
), DMGL_ARM
| DMGL_ANSI
);
4415 sym_name
= (char *) xmalloc (strlen (SYMBOL_NAME (sym
)) + 1);
4416 strcpy (sym_name
, SYMBOL_NAME (sym
));
4419 /* skip symbols that cannot match */
4420 if (strcmp (sym_name
, oload_name
) != 0)
4426 /* If there is no type information, we can't do anything, so skip */
4427 if (SYMBOL_TYPE (sym
) == NULL
)
4430 /* skip any symbols that we've already considered. */
4431 for (i
= 0; i
< sym_return_val_index
; ++i
)
4432 if (!strcmp (SYMBOL_NAME (sym
), SYMBOL_NAME (sym_return_val
[i
])))
4435 /* We have a match for an overload instance, so add SYM to the current list
4436 * of overload instances */
4437 if (sym_return_val_index
+ 3 > sym_return_val_size
)
4439 newsize
= (sym_return_val_size
*= 2) * sizeof (struct symbol
*);
4440 sym_return_val
= (struct symbol
**) xrealloc ((char *) sym_return_val
, newsize
);
4442 sym_return_val
[sym_return_val_index
++] = sym
;
4443 sym_return_val
[sym_return_val_index
] = NULL
;
4448 /* Return a null-terminated list of pointers to function symbols that
4449 * match name of the supplied symbol FSYM.
4450 * This is used in finding all overloaded instances of a function name.
4451 * This has been modified from make_symbol_completion_list. */
4455 make_symbol_overload_list (struct symbol
*fsym
)
4457 register struct symbol
*sym
;
4458 register struct symtab
*s
;
4459 register struct partial_symtab
*ps
;
4460 register struct objfile
*objfile
;
4461 register struct block
*b
, *surrounding_static_block
= 0;
4463 /* The name we are completing on. */
4464 char *oload_name
= NULL
;
4465 /* Length of name. */
4466 int oload_name_len
= 0;
4468 /* Look for the symbol we are supposed to complete on.
4469 * FIXME: This should be language-specific. */
4471 oload_name
= cplus_demangle (SYMBOL_NAME (fsym
), DMGL_ARM
| DMGL_ANSI
);
4474 oload_name
= (char *) xmalloc (strlen (SYMBOL_NAME (fsym
)) + 1);
4475 strcpy (oload_name
, SYMBOL_NAME (fsym
));
4477 oload_name_len
= strlen (oload_name
);
4479 sym_return_val_size
= 100;
4480 sym_return_val_index
= 0;
4481 sym_return_val
= (struct symbol
**) xmalloc ((sym_return_val_size
+ 1) * sizeof (struct symbol
*));
4482 sym_return_val
[0] = NULL
;
4484 /* Look through the partial symtabs for all symbols which begin
4485 by matching OLOAD_NAME. Make sure we read that symbol table in. */
4487 ALL_PSYMTABS (objfile
, ps
)
4489 struct partial_symbol
**psym
;
4491 /* If the psymtab's been read in we'll get it when we search
4492 through the blockvector. */
4496 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
4497 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
4498 + ps
->n_global_syms
);
4501 /* If interrupted, then quit. */
4503 /* This will cause the symbol table to be read if it has not yet been */
4504 s
= PSYMTAB_TO_SYMTAB (ps
);
4507 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
4508 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
4509 + ps
->n_static_syms
);
4513 /* This will cause the symbol table to be read if it has not yet been */
4514 s
= PSYMTAB_TO_SYMTAB (ps
);
4518 /* Search upwards from currently selected frame (so that we can
4519 complete on local vars. */
4521 for (b
= get_selected_block (); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
4523 if (!BLOCK_SUPERBLOCK (b
))
4525 surrounding_static_block
= b
; /* For elimination of dups */
4528 /* Also catch fields of types defined in this places which match our
4529 text string. Only complete on types visible from current context. */
4531 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
4533 sym
= BLOCK_SYM (b
, i
);
4534 overload_list_add_symbol (sym
, oload_name
);
4538 /* Go through the symtabs and check the externs and statics for
4539 symbols which match. */
4541 ALL_SYMTABS (objfile
, s
)
4544 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4545 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
4547 sym
= BLOCK_SYM (b
, i
);
4548 overload_list_add_symbol (sym
, oload_name
);
4552 ALL_SYMTABS (objfile
, s
)
4555 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4556 /* Don't do this block twice. */
4557 if (b
== surrounding_static_block
)
4559 for (i
= 0; i
< BLOCK_NSYMS (b
); i
++)
4561 sym
= BLOCK_SYM (b
, i
);
4562 overload_list_add_symbol (sym
, oload_name
);
4568 return (sym_return_val
);
4571 /* End of overload resolution functions */
4575 _initialize_symtab (void)
4577 add_info ("variables", variables_info
,
4578 "All global and static variable names, or those matching REGEXP.");
4580 add_com ("whereis", class_info
, variables_info
,
4581 "All global and static variable names, or those matching REGEXP.");
4583 add_info ("functions", functions_info
,
4584 "All function names, or those matching REGEXP.");
4587 /* FIXME: This command has at least the following problems:
4588 1. It prints builtin types (in a very strange and confusing fashion).
4589 2. It doesn't print right, e.g. with
4590 typedef struct foo *FOO
4591 type_print prints "FOO" when we want to make it (in this situation)
4592 print "struct foo *".
4593 I also think "ptype" or "whatis" is more likely to be useful (but if
4594 there is much disagreement "info types" can be fixed). */
4595 add_info ("types", types_info
,
4596 "All type names, or those matching REGEXP.");
4599 add_info ("methods", methods_info
,
4600 "All method names, or those matching REGEXP::REGEXP.\n\
4601 If the class qualifier is omitted, it is assumed to be the current scope.\n\
4602 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
4605 add_info ("sources", sources_info
,
4606 "Source files in the program.");
4608 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4609 "Set a breakpoint for all functions matching REGEXP.");
4613 add_com ("lf", class_info
, sources_info
, "Source files in the program");
4614 add_com ("lg", class_info
, variables_info
,
4615 "All global and static variable names, or those matching REGEXP.");
4618 /* Initialize the one built-in type that isn't language dependent... */
4619 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
4620 "<unknown type>", (struct objfile
*) NULL
);