1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
34 #include "call-cmds.h"
35 #include "gdb_regex.h"
36 #include "expression.h"
42 #include "filenames.h" /* for FILENAME_CMP */
46 #include "gdb_obstack.h"
49 #include <sys/types.h>
51 #include "gdb_string.h"
56 /* Prototypes for local functions */
58 static void completion_list_add_name (char *, char *, int, char *, char *);
60 static void rbreak_command (char *, int);
62 static void types_info (char *, int);
64 static void functions_info (char *, int);
66 static void variables_info (char *, int);
68 static void sources_info (char *, int);
70 static void output_source_filename (char *, int *);
72 static int find_line_common (struct linetable
*, int, int *);
74 /* This one is used by linespec.c */
76 char *operator_chars (char *p
, char **end
);
78 static struct partial_symbol
*lookup_partial_symbol (struct partial_symtab
*,
82 static struct symbol
*lookup_symbol_aux (const char *name
,
83 const char *mangled_name
,
84 const struct block
*block
,
85 const namespace_enum
namespace,
86 int *is_a_field_of_this
,
87 struct symtab
**symtab
);
90 struct symbol
*lookup_symbol_aux_local (const char *name
,
91 const char *mangled_name
,
92 const struct block
*block
,
93 const namespace_enum
namespace,
94 struct symtab
**symtab
,
95 const struct block
**static_block
);
98 struct symbol
*lookup_symbol_aux_block (const char *name
,
99 const char *mangled_name
,
100 const struct block
*block
,
101 const namespace_enum
namespace,
102 struct symtab
**symtab
);
105 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
107 const char *mangled_name
,
108 const namespace_enum
namespace,
109 struct symtab
**symtab
);
112 struct symbol
*lookup_symbol_aux_psymtabs (int block_index
,
114 const char *mangled_name
,
115 const namespace_enum
namespace,
116 struct symtab
**symtab
);
119 struct symbol
*lookup_symbol_aux_minsyms (const char *name
,
120 const char *mangled_name
,
121 const namespace_enum
namespace,
122 int *is_a_field_of_this
,
123 struct symtab
**symtab
);
125 static struct symbol
*find_active_alias (struct symbol
*sym
, CORE_ADDR addr
);
127 /* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */
128 /* Signals the presence of objects compiled by HP compilers */
129 int hp_som_som_object_present
= 0;
131 static void fixup_section (struct general_symbol_info
*, struct objfile
*);
133 static int file_matches (char *, char **, int);
135 static void print_symbol_info (namespace_enum
,
136 struct symtab
*, struct symbol
*, int, char *);
138 static void print_msymbol_info (struct minimal_symbol
*);
140 static void symtab_symbol_info (char *, namespace_enum
, int);
142 static void overload_list_add_symbol (struct symbol
*sym
, char *oload_name
);
144 void _initialize_symtab (void);
148 /* The single non-language-specific builtin type */
149 struct type
*builtin_type_error
;
151 /* Block in which the most recently searched-for symbol was found.
152 Might be better to make this a parameter to lookup_symbol and
155 const struct block
*block_found
;
157 /* Check for a symtab of a specific name; first in symtabs, then in
158 psymtabs. *If* there is no '/' in the name, a match after a '/'
159 in the symtab filename will also work. */
162 lookup_symtab (const char *name
)
164 register struct symtab
*s
;
165 register struct partial_symtab
*ps
;
166 register struct objfile
*objfile
;
167 char *real_path
= NULL
;
168 char *full_path
= NULL
;
170 /* Here we are interested in canonicalizing an absolute path, not
171 absolutizing a relative path. */
172 if (IS_ABSOLUTE_PATH (name
))
174 full_path
= xfullpath (name
);
175 make_cleanup (xfree
, full_path
);
176 real_path
= gdb_realpath (name
);
177 make_cleanup (xfree
, real_path
);
182 /* First, search for an exact match */
184 ALL_SYMTABS (objfile
, s
)
186 if (FILENAME_CMP (name
, s
->filename
) == 0)
191 /* If the user gave us an absolute path, try to find the file in
192 this symtab and use its absolute path. */
194 if (full_path
!= NULL
)
196 const char *fp
= symtab_to_filename (s
);
197 if (FILENAME_CMP (full_path
, fp
) == 0)
203 if (real_path
!= NULL
)
205 char *rp
= gdb_realpath (symtab_to_filename (s
));
206 make_cleanup (xfree
, rp
);
207 if (FILENAME_CMP (real_path
, rp
) == 0)
214 /* Now, search for a matching tail (only if name doesn't have any dirs) */
216 if (lbasename (name
) == name
)
217 ALL_SYMTABS (objfile
, s
)
219 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
223 /* Same search rules as above apply here, but now we look thru the
226 ps
= lookup_partial_symtab (name
);
231 error ("Internal: readin %s pst for `%s' found when no symtab found.",
234 s
= PSYMTAB_TO_SYMTAB (ps
);
239 /* At this point, we have located the psymtab for this file, but
240 the conversion to a symtab has failed. This usually happens
241 when we are looking up an include file. In this case,
242 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
243 been created. So, we need to run through the symtabs again in
244 order to find the file.
245 XXX - This is a crock, and should be fixed inside of the the
246 symbol parsing routines. */
250 /* Lookup the partial symbol table of a source file named NAME.
251 *If* there is no '/' in the name, a match after a '/'
252 in the psymtab filename will also work. */
254 struct partial_symtab
*
255 lookup_partial_symtab (const char *name
)
257 register struct partial_symtab
*pst
;
258 register struct objfile
*objfile
;
259 char *full_path
= NULL
;
260 char *real_path
= NULL
;
262 /* Here we are interested in canonicalizing an absolute path, not
263 absolutizing a relative path. */
264 if (IS_ABSOLUTE_PATH (name
))
266 full_path
= xfullpath (name
);
267 make_cleanup (xfree
, full_path
);
268 real_path
= gdb_realpath (name
);
269 make_cleanup (xfree
, real_path
);
272 ALL_PSYMTABS (objfile
, pst
)
274 if (FILENAME_CMP (name
, pst
->filename
) == 0)
279 /* If the user gave us an absolute path, try to find the file in
280 this symtab and use its absolute path. */
281 if (full_path
!= NULL
)
283 if (pst
->fullname
== NULL
)
284 source_full_path_of (pst
->filename
, &pst
->fullname
);
285 if (pst
->fullname
!= NULL
286 && FILENAME_CMP (full_path
, pst
->fullname
) == 0)
292 if (real_path
!= NULL
)
295 if (pst
->fullname
== NULL
)
296 source_full_path_of (pst
->filename
, &pst
->fullname
);
297 if (pst
->fullname
!= NULL
)
299 rp
= gdb_realpath (pst
->fullname
);
300 make_cleanup (xfree
, rp
);
302 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
309 /* Now, search for a matching tail (only if name doesn't have any dirs) */
311 if (lbasename (name
) == name
)
312 ALL_PSYMTABS (objfile
, pst
)
314 if (FILENAME_CMP (lbasename (pst
->filename
), name
) == 0)
321 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
322 full method name, which consist of the class name (from T), the unadorned
323 method name from METHOD_ID, and the signature for the specific overload,
324 specified by SIGNATURE_ID. Note that this function is g++ specific. */
327 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
329 int mangled_name_len
;
331 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
332 struct fn_field
*method
= &f
[signature_id
];
333 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
334 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
335 char *newname
= type_name_no_tag (type
);
337 /* Does the form of physname indicate that it is the full mangled name
338 of a constructor (not just the args)? */
339 int is_full_physname_constructor
;
342 int is_destructor
= is_destructor_name (physname
);
343 /* Need a new type prefix. */
344 char *const_prefix
= method
->is_const
? "C" : "";
345 char *volatile_prefix
= method
->is_volatile
? "V" : "";
347 int len
= (newname
== NULL
? 0 : strlen (newname
));
349 /* Nothing to do if physname already contains a fully mangled v3 abi name
350 or an operator name. */
351 if ((physname
[0] == '_' && physname
[1] == 'Z')
352 || is_operator_name (field_name
))
353 return xstrdup (physname
);
355 is_full_physname_constructor
= is_constructor_name (physname
);
358 is_full_physname_constructor
|| (newname
&& STREQ (field_name
, newname
));
361 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
363 if (is_destructor
|| is_full_physname_constructor
)
365 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
366 strcpy (mangled_name
, physname
);
372 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
374 else if (physname
[0] == 't' || physname
[0] == 'Q')
376 /* The physname for template and qualified methods already includes
378 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
384 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
386 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
387 + strlen (buf
) + len
+ strlen (physname
) + 1);
390 mangled_name
= (char *) xmalloc (mangled_name_len
);
392 mangled_name
[0] = '\0';
394 strcpy (mangled_name
, field_name
);
396 strcat (mangled_name
, buf
);
397 /* If the class doesn't have a name, i.e. newname NULL, then we just
398 mangle it using 0 for the length of the class. Thus it gets mangled
399 as something starting with `::' rather than `classname::'. */
401 strcat (mangled_name
, newname
);
403 strcat (mangled_name
, physname
);
404 return (mangled_name
);
408 /* Initialize the language dependent portion of a symbol
409 depending upon the language for the symbol. */
411 symbol_init_language_specific (struct general_symbol_info
*gsymbol
,
412 enum language language
)
414 gsymbol
->language
= language
;
415 if (gsymbol
->language
== language_cplus
416 || gsymbol
->language
== language_java
417 || gsymbol
->language
== language_objc
)
419 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
423 memset (&gsymbol
->language_specific
, 0,
424 sizeof (gsymbol
->language_specific
));
428 /* Functions to initialize a symbol's mangled name. */
430 /* Create the hash table used for demangled names. Each hash entry is
431 a pair of strings; one for the mangled name and one for the demangled
432 name. The entry is hashed via just the mangled name. */
435 create_demangled_names_hash (struct objfile
*objfile
)
437 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
438 The hash table code will round this up to the next prime number.
439 Choosing a much larger table size wastes memory, and saves only about
440 1% in symbol reading. */
442 objfile
->demangled_names_hash
= htab_create_alloc_ex
443 (256, htab_hash_string
, (int (*) (const void *, const void *)) streq
,
444 NULL
, objfile
->md
, xmcalloc
, xmfree
);
447 /* Try to determine the demangled name for a symbol, based on the
448 language of that symbol. If the language is set to language_auto,
449 it will attempt to find any demangling algorithm that works and
450 then set the language appropriately. The returned name is allocated
451 by the demangler and should be xfree'd. */
454 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
457 char *demangled
= NULL
;
459 if (gsymbol
->language
== language_unknown
)
460 gsymbol
->language
= language_auto
;
461 if (gsymbol
->language
== language_cplus
462 || gsymbol
->language
== language_auto
)
465 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
466 if (demangled
!= NULL
)
468 gsymbol
->language
= language_cplus
;
472 if (gsymbol
->language
== language_java
)
475 cplus_demangle (mangled
,
476 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
477 if (demangled
!= NULL
)
479 gsymbol
->language
= language_java
;
486 /* Set both the mangled and demangled (if any) names for GSYMBOL based on
487 NAME and LEN. The hash table corresponding to OBJFILE is used, and the
488 memory comes from that objfile's symbol_obstack. NAME is copied, so the
489 pointer can be discarded after calling this function. */
492 symbol_set_names (struct general_symbol_info
*gsymbol
,
493 const char *name
, int len
, struct objfile
*objfile
)
498 if (objfile
->demangled_names_hash
== NULL
)
499 create_demangled_names_hash (objfile
);
501 /* The stabs reader generally provides names that are not NULL-terminated;
502 most of the other readers don't do this, so we can just use the given
506 char *alloc_name
= alloca (len
+ 1);
507 memcpy (alloc_name
, name
, len
);
509 tmpname
= alloc_name
;
514 slot
= (char **) htab_find_slot (objfile
->demangled_names_hash
, tmpname
, INSERT
);
516 /* If this name is not in the hash table, add it. */
519 char *demangled_name
= symbol_find_demangled_name (gsymbol
, tmpname
);
520 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
522 /* If there is a demangled name, place it right after the mangled name.
523 Otherwise, just place a second zero byte after the end of the mangled
525 *slot
= obstack_alloc (&objfile
->symbol_obstack
,
526 len
+ demangled_len
+ 2);
527 memcpy (*slot
, tmpname
, len
+ 1);
530 memcpy (*slot
+ len
+ 1, demangled_name
, demangled_len
+ 1);
531 xfree (demangled_name
);
534 (*slot
)[len
+ 1] = 0;
537 gsymbol
->name
= *slot
;
538 if ((*slot
)[len
+ 1])
539 gsymbol
->language_specific
.cplus_specific
.demangled_name
542 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
545 /* Initialize the demangled name of GSYMBOL if possible. Any required space
546 to store the name is obtained from the specified obstack. The function
547 symbol_set_names, above, should be used instead where possible for more
548 efficient memory usage. */
551 symbol_init_demangled_name (struct general_symbol_info
*gsymbol
,
552 struct obstack
*obstack
)
554 char *mangled
= gsymbol
->name
;
555 char *demangled
= NULL
;
557 demangled
= symbol_find_demangled_name (gsymbol
, mangled
);
558 if (gsymbol
->language
== language_cplus
559 || gsymbol
->language
== language_java
)
563 gsymbol
->language_specific
.cplus_specific
.demangled_name
564 = obsavestring (demangled
, strlen (demangled
), obstack
);
568 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
572 /* Unknown language; just clean up quietly. */
578 /* Return the demangled name for a symbol based on the language for
579 that symbol. If no demangled name exists, return NULL. */
581 symbol_demangled_name (struct general_symbol_info
*gsymbol
)
583 if (gsymbol
->language
== language_cplus
584 || gsymbol
->language
== language_java
585 || gsymbol
->language
== language_objc
)
586 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
592 /* Initialize the structure fields to zero values. */
594 init_sal (struct symtab_and_line
*sal
)
605 /* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
607 struct partial_symtab
*
608 find_pc_sect_psymtab (CORE_ADDR pc
, asection
*section
)
610 register struct partial_symtab
*pst
;
611 register struct objfile
*objfile
;
612 struct minimal_symbol
*msymbol
;
614 /* If we know that this is not a text address, return failure. This is
615 necessary because we loop based on texthigh and textlow, which do
616 not include the data ranges. */
617 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
619 && (msymbol
->type
== mst_data
620 || msymbol
->type
== mst_bss
621 || msymbol
->type
== mst_abs
622 || msymbol
->type
== mst_file_data
623 || msymbol
->type
== mst_file_bss
))
626 ALL_PSYMTABS (objfile
, pst
)
628 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
630 struct partial_symtab
*tpst
;
632 /* An objfile that has its functions reordered might have
633 many partial symbol tables containing the PC, but
634 we want the partial symbol table that contains the
635 function containing the PC. */
636 if (!(objfile
->flags
& OBJF_REORDERED
) &&
637 section
== 0) /* can't validate section this way */
643 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
645 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
647 struct partial_symbol
*p
;
649 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
651 && SYMBOL_VALUE_ADDRESS (p
)
652 == SYMBOL_VALUE_ADDRESS (msymbol
))
662 /* Find which partial symtab contains PC. Return 0 if none.
663 Backward compatibility, no section */
665 struct partial_symtab
*
666 find_pc_psymtab (CORE_ADDR pc
)
668 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
671 /* Find which partial symbol within a psymtab matches PC and SECTION.
672 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
674 struct partial_symbol
*
675 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
678 struct partial_symbol
*best
= NULL
, *p
, **pp
;
682 psymtab
= find_pc_sect_psymtab (pc
, section
);
686 /* Cope with programs that start at address 0 */
687 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
689 /* Search the global symbols as well as the static symbols, so that
690 find_pc_partial_function doesn't use a minimal symbol and thus
691 cache a bad endaddr. */
692 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
693 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
694 < psymtab
->n_global_syms
);
698 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
699 && SYMBOL_CLASS (p
) == LOC_BLOCK
700 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
701 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
702 || (psymtab
->textlow
== 0
703 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
705 if (section
) /* match on a specific section */
707 fixup_psymbol_section (p
, psymtab
->objfile
);
708 if (SYMBOL_BFD_SECTION (p
) != section
)
711 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
716 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
717 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
718 < psymtab
->n_static_syms
);
722 if (SYMBOL_NAMESPACE (p
) == VAR_NAMESPACE
723 && SYMBOL_CLASS (p
) == LOC_BLOCK
724 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
725 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
726 || (psymtab
->textlow
== 0
727 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
729 if (section
) /* match on a specific section */
731 fixup_psymbol_section (p
, psymtab
->objfile
);
732 if (SYMBOL_BFD_SECTION (p
) != section
)
735 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
743 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
744 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
746 struct partial_symbol
*
747 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
749 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
752 /* Debug symbols usually don't have section information. We need to dig that
753 out of the minimal symbols and stash that in the debug symbol. */
756 fixup_section (struct general_symbol_info
*ginfo
, struct objfile
*objfile
)
758 struct minimal_symbol
*msym
;
759 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
763 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
764 ginfo
->section
= SYMBOL_SECTION (msym
);
769 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
774 if (SYMBOL_BFD_SECTION (sym
))
777 fixup_section (&sym
->ginfo
, objfile
);
782 struct partial_symbol
*
783 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
788 if (SYMBOL_BFD_SECTION (psym
))
791 fixup_section (&psym
->ginfo
, objfile
);
796 /* Find the definition for a specified symbol name NAME
797 in namespace NAMESPACE, visible from lexical block BLOCK.
798 Returns the struct symbol pointer, or zero if no symbol is found.
799 If SYMTAB is non-NULL, store the symbol table in which the
800 symbol was found there, or NULL if not found.
801 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
802 NAME is a field of the current implied argument `this'. If so set
803 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
804 BLOCK_FOUND is set to the block in which NAME is found (in the case of
805 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
807 /* This function has a bunch of loops in it and it would seem to be
808 attractive to put in some QUIT's (though I'm not really sure
809 whether it can run long enough to be really important). But there
810 are a few calls for which it would appear to be bad news to quit
811 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
812 that there is C++ code below which can error(), but that probably
813 doesn't affect these calls since they are looking for a known
814 variable and thus can probably assume it will never hit the C++
818 lookup_symbol (const char *name
, const struct block
*block
,
819 const namespace_enum
namespace, int *is_a_field_of_this
,
820 struct symtab
**symtab
)
822 char *demangled_name
= NULL
;
823 const char *modified_name
= NULL
;
824 const char *mangled_name
= NULL
;
825 int needtofreename
= 0;
826 struct symbol
*returnval
;
828 modified_name
= name
;
830 /* If we are using C++ language, demangle the name before doing a lookup, so
831 we can always binary search. */
832 if (current_language
->la_language
== language_cplus
)
834 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
838 modified_name
= demangled_name
;
843 if (case_sensitivity
== case_sensitive_off
)
849 copy
= (char *) alloca (len
+ 1);
850 for (i
= 0; i
< len
; i
++)
851 copy
[i
] = tolower (name
[i
]);
853 modified_name
= copy
;
856 returnval
= lookup_symbol_aux (modified_name
, mangled_name
, block
,
857 namespace, is_a_field_of_this
, symtab
);
859 xfree (demangled_name
);
864 static struct symbol
*
865 lookup_symbol_aux (const char *name
, const char *mangled_name
,
866 const struct block
*block
, const namespace_enum
namespace,
867 int *is_a_field_of_this
, struct symtab
**symtab
)
870 const struct block
*static_block
;
872 /* Search specified block and its superiors. Don't search
873 STATIC_BLOCK or GLOBAL_BLOCK. */
875 sym
= lookup_symbol_aux_local (name
, mangled_name
, block
, namespace,
876 symtab
, &static_block
);
881 /* NOTE: carlton/2002-11-05: At the time that this code was
882 #ifdeffed out, the value of 'block' was always NULL at this
883 point, hence the bemused comments below. */
885 /* FIXME: this code is never executed--block is always NULL at this
886 point. What is it trying to do, anyway? We already should have
887 checked the STATIC_BLOCK above (it is the superblock of top-level
888 blocks). Why is VAR_NAMESPACE special-cased? */
889 /* Don't need to mess with the psymtabs; if we have a block,
890 that file is read in. If we don't, then we deal later with
891 all the psymtab stuff that needs checking. */
892 /* Note (RT): The following never-executed code looks unnecessary to me also.
893 * If we change the code to use the original (passed-in)
894 * value of 'block', we could cause it to execute, but then what
895 * would it do? The STATIC_BLOCK of the symtab containing the passed-in
896 * 'block' was already searched by the above code. And the STATIC_BLOCK's
897 * of *other* symtabs (those files not containing 'block' lexically)
898 * should not contain 'block' address-wise. So we wouldn't expect this
899 * code to find any 'sym''s that were not found above. I vote for
900 * deleting the following paragraph of code.
902 if (namespace == VAR_NAMESPACE
&& block
!= NULL
)
905 /* Find the right symtab. */
906 ALL_SYMTABS (objfile
, s
)
908 bv
= BLOCKVECTOR (s
);
909 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
910 if (BLOCK_START (b
) <= BLOCK_START (block
)
911 && BLOCK_END (b
) > BLOCK_START (block
))
913 sym
= lookup_block_symbol (b
, name
, mangled_name
, VAR_NAMESPACE
);
919 return fixup_symbol_section (sym
, objfile
);
926 /* C++: If requested to do so by the caller,
927 check to see if NAME is a field of `this'. */
928 if (is_a_field_of_this
)
930 struct value
*v
= value_of_this (0);
932 *is_a_field_of_this
= 0;
933 if (v
&& check_field (v
, name
))
935 *is_a_field_of_this
= 1;
942 /* If there's a static block to search, search it next. */
944 /* NOTE: carlton/2002-12-05: There is a question as to whether or
945 not it would be appropriate to search the current global block
946 here as well. (That's what this code used to do before the
947 is_a_field_of_this check was moved up.) On the one hand, it's
948 redundant with the lookup_symbol_aux_symtabs search that happens
949 next. On the other hand, if decode_line_1 is passed an argument
950 like filename:var, then the user presumably wants 'var' to be
951 searched for in filename. On the third hand, there shouldn't be
952 multiple global variables all of which are named 'var', and it's
953 not like decode_line_1 has ever restricted its search to only
954 global variables in a single filename. All in all, only
955 searching the static block here seems best: it's correct and it's
958 /* NOTE: carlton/2002-12-05: There's also a possible performance
959 issue here: if you usually search for global symbols in the
960 current file, then it would be slightly better to search the
961 current global block before searching all the symtabs. But there
962 are other factors that have a much greater effect on performance
963 than that one, so I don't think we should worry about that for
966 if (static_block
!= NULL
)
968 sym
= lookup_symbol_aux_block (name
, mangled_name
, static_block
,
974 /* Now search all global blocks. Do the symtab's first, then
975 check the psymtab's. If a psymtab indicates the existence
976 of the desired name as a global, then do psymtab-to-symtab
977 conversion on the fly and return the found symbol. */
979 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, mangled_name
,
986 /* Check for the possibility of the symbol being a function or
987 a mangled variable that is stored in one of the minimal symbol tables.
988 Eventually, all global symbols might be resolved in this way. */
990 sym
= lookup_symbol_aux_minsyms (name
, mangled_name
,
991 namespace, is_a_field_of_this
,
999 sym
= lookup_symbol_aux_psymtabs (GLOBAL_BLOCK
, name
, mangled_name
,
1004 /* Now search all static file-level symbols. Not strictly correct,
1005 but more useful than an error. Do the symtabs first, then check
1006 the psymtabs. If a psymtab indicates the existence of the
1007 desired name as a file-level static, then do psymtab-to-symtab
1008 conversion on the fly and return the found symbol. */
1010 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, mangled_name
,
1015 sym
= lookup_symbol_aux_psymtabs (STATIC_BLOCK
, name
, mangled_name
,
1022 /* Check for the possibility of the symbol being a function or
1023 a global variable that is stored in one of the minimal symbol tables.
1024 The "minimal symbol table" is built from linker-supplied info.
1026 RT: I moved this check to last, after the complete search of
1027 the global (p)symtab's and static (p)symtab's. For HP-generated
1028 symbol tables, this check was causing a premature exit from
1029 lookup_symbol with NULL return, and thus messing up symbol lookups
1030 of things like "c::f". It seems to me a check of the minimal
1031 symbol table ought to be a last resort in any case. I'm vaguely
1032 worried about the comment below which talks about FORTRAN routines "foo_"
1033 though... is it saying we need to do the "minsym" check before
1034 the static check in this case?
1038 sym
= lookup_symbol_aux_minsyms (name
, mangled_name
,
1039 namespace, is_a_field_of_this
,
1052 /* Check to see if the symbol is defined in BLOCK or its superiors.
1053 Don't search STATIC_BLOCK or GLOBAL_BLOCK. If we don't find a
1054 match, store the address of STATIC_BLOCK in static_block. */
1056 static struct symbol
*
1057 lookup_symbol_aux_local (const char *name
, const char *mangled_name
,
1058 const struct block
*block
,
1059 const namespace_enum
namespace,
1060 struct symtab
**symtab
,
1061 const struct block
**static_block
)
1065 /* Check if either no block is specified or it's a global block. */
1067 if (block
== NULL
|| BLOCK_SUPERBLOCK (block
) == NULL
)
1069 *static_block
= NULL
;
1073 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block
)) != NULL
)
1075 sym
= lookup_symbol_aux_block (name
, mangled_name
, block
, namespace,
1079 block
= BLOCK_SUPERBLOCK (block
);
1082 /* We've reached the static block. */
1084 *static_block
= block
;
1088 /* Look up a symbol in a block; if found, locate its symtab, fixup the
1089 symbol, and set block_found appropriately. */
1091 static struct symbol
*
1092 lookup_symbol_aux_block (const char *name
, const char *mangled_name
,
1093 const struct block
*block
,
1094 const namespace_enum
namespace,
1095 struct symtab
**symtab
)
1098 struct objfile
*objfile
= NULL
;
1099 struct blockvector
*bv
;
1101 struct symtab
*s
= NULL
;
1103 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1106 block_found
= block
;
1109 /* Search the list of symtabs for one which contains the
1110 address of the start of this block. */
1111 ALL_SYMTABS (objfile
, s
)
1113 bv
= BLOCKVECTOR (s
);
1114 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1115 if (BLOCK_START (b
) <= BLOCK_START (block
)
1116 && BLOCK_END (b
) > BLOCK_START (block
))
1123 return fixup_symbol_section (sym
, objfile
);
1129 /* Check to see if the symbol is defined in one of the symtabs.
1130 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1131 depending on whether or not we want to search global symbols or
1134 static struct symbol
*
1135 lookup_symbol_aux_symtabs (int block_index
,
1136 const char *name
, const char *mangled_name
,
1137 const namespace_enum
namespace,
1138 struct symtab
**symtab
)
1141 struct objfile
*objfile
;
1142 struct blockvector
*bv
;
1143 const struct block
*block
;
1146 ALL_SYMTABS (objfile
, s
)
1148 bv
= BLOCKVECTOR (s
);
1149 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1150 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1153 block_found
= block
;
1156 return fixup_symbol_section (sym
, objfile
);
1163 /* Check to see if the symbol is defined in one of the partial
1164 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1165 STATIC_BLOCK, depending on whether or not we want to search global
1166 symbols or static symbols. */
1168 static struct symbol
*
1169 lookup_symbol_aux_psymtabs (int block_index
, const char *name
,
1170 const char *mangled_name
,
1171 const namespace_enum
namespace,
1172 struct symtab
**symtab
)
1175 struct objfile
*objfile
;
1176 struct blockvector
*bv
;
1177 const struct block
*block
;
1178 struct partial_symtab
*ps
;
1180 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
1182 ALL_PSYMTABS (objfile
, ps
)
1185 && lookup_partial_symbol (ps
, name
, psymtab_index
, namespace))
1187 s
= PSYMTAB_TO_SYMTAB (ps
);
1188 bv
= BLOCKVECTOR (s
);
1189 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1190 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1193 /* This shouldn't be necessary, but as a last resort try
1194 looking in the statics even though the psymtab claimed
1195 the symbol was global, or vice-versa. It's possible
1196 that the psymtab gets it wrong in some cases. */
1198 /* FIXME: carlton/2002-09-30: Should we really do that?
1199 If that happens, isn't it likely to be a GDB error, in
1200 which case we should fix the GDB error rather than
1201 silently dealing with it here? So I'd vote for
1202 removing the check for the symbol in the other
1204 block
= BLOCKVECTOR_BLOCK (bv
,
1205 block_index
== GLOBAL_BLOCK
?
1206 STATIC_BLOCK
: GLOBAL_BLOCK
);
1207 sym
= lookup_block_symbol (block
, name
, mangled_name
, namespace);
1209 error ("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>).",
1210 block_index
== GLOBAL_BLOCK
? "global" : "static",
1211 name
, ps
->filename
, name
, name
);
1215 return fixup_symbol_section (sym
, objfile
);
1222 /* Check for the possibility of the symbol being a function or a
1223 mangled variable that is stored in one of the minimal symbol
1224 tables. Eventually, all global symbols might be resolved in this
1227 /* NOTE: carlton/2002-12-05: At one point, this function was part of
1228 lookup_symbol_aux, and what are now 'return' statements within
1229 lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
1230 sym was NULL. As far as I can tell, this was basically accidental;
1231 it didn't happen every time that msymbol was non-NULL, but only if
1232 some additional conditions held as well, and it caused problems
1233 with HP-generated symbol tables. */
1235 static struct symbol
*
1236 lookup_symbol_aux_minsyms (const char *name
,
1237 const char *mangled_name
,
1238 const namespace_enum
namespace,
1239 int *is_a_field_of_this
,
1240 struct symtab
**symtab
)
1243 struct blockvector
*bv
;
1244 const struct block
*block
;
1245 struct minimal_symbol
*msymbol
;
1248 if (namespace == VAR_NAMESPACE
)
1250 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
1252 if (msymbol
!= NULL
)
1254 /* OK, we found a minimal symbol in spite of not finding any
1255 symbol. There are various possible explanations for
1256 this. One possibility is the symbol exists in code not
1257 compiled -g. Another possibility is that the 'psymtab'
1258 isn't doing its job. A third possibility, related to #2,
1259 is that we were confused by name-mangling. For instance,
1260 maybe the psymtab isn't doing its job because it only
1261 know about demangled names, but we were given a mangled
1264 /* We first use the address in the msymbol to try to locate
1265 the appropriate symtab. Note that find_pc_sect_symtab()
1266 has a side-effect of doing psymtab-to-symtab expansion,
1267 for the found symtab. */
1268 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
1269 SYMBOL_BFD_SECTION (msymbol
));
1272 /* This is a function which has a symtab for its address. */
1273 bv
= BLOCKVECTOR (s
);
1274 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1276 /* This call used to pass `SYMBOL_NAME (msymbol)' as the
1277 `name' argument to lookup_block_symbol. But the name
1278 of a minimal symbol is always mangled, so that seems
1279 to be clearly the wrong thing to pass as the
1282 lookup_block_symbol (block
, name
, mangled_name
, namespace);
1283 /* We kept static functions in minimal symbol table as well as
1284 in static scope. We want to find them in the symbol table. */
1287 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1288 sym
= lookup_block_symbol (block
, name
,
1289 mangled_name
, namespace);
1292 /* NOTE: carlton/2002-12-04: The following comment was
1293 taken from a time when two versions of this function
1294 were part of the body of lookup_symbol_aux: this
1295 comment was taken from the version of the function
1296 that was #ifdef HPUXHPPA, and the comment was right
1297 before the 'return NULL' part of lookup_symbol_aux.
1298 (Hence the "Fall through and return 0" comment.)
1299 Elena did some digging into the situation for
1300 Fortran, and she reports:
1302 "I asked around (thanks to Jeff Knaggs), and I think
1303 the story for Fortran goes like this:
1305 "Apparently, in older Fortrans, '_' was not part of
1306 the user namespace. g77 attached a final '_' to
1307 procedure names as the exported symbols for linkage
1308 (foo_) , but the symbols went in the debug info just
1309 like 'foo'. The rationale behind this is not
1310 completely clear, and maybe it was done to other
1311 symbols as well, not just procedures." */
1313 /* If we get here with sym == 0, the symbol was
1314 found in the minimal symbol table
1315 but not in the symtab.
1316 Fall through and return 0 to use the msymbol
1317 definition of "foo_".
1318 (Note that outer code generally follows up a call
1319 to this routine with a call to lookup_minimal_symbol(),
1320 so a 0 return means we'll just flow into that other routine).
1322 This happens for Fortran "foo_" symbols,
1323 which are "foo" in the symtab.
1325 This can also happen if "asm" is used to make a
1326 regular symbol but not a debugging symbol, e.g.
1327 asm(".globl _main");
1331 if (symtab
!= NULL
&& sym
!= NULL
)
1333 return fixup_symbol_section (sym
, s
->objfile
);
1335 else if (MSYMBOL_TYPE (msymbol
) != mst_text
1336 && MSYMBOL_TYPE (msymbol
) != mst_file_text
1337 && !STREQ (name
, SYMBOL_NAME (msymbol
)))
1339 /* This is a mangled variable, look it up by its
1341 return lookup_symbol_aux (SYMBOL_NAME (msymbol
), mangled_name
,
1342 NULL
, namespace, is_a_field_of_this
,
1351 /* Look, in partial_symtab PST, for symbol NAME. Check the global
1352 symbols if GLOBAL, the static symbols if not */
1354 static struct partial_symbol
*
1355 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
, int global
,
1356 namespace_enum
namespace)
1358 struct partial_symbol
*temp
;
1359 struct partial_symbol
**start
, **psym
;
1360 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
1361 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1362 int do_linear_search
= 1;
1369 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
1370 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1372 if (global
) /* This means we can use a binary search. */
1374 do_linear_search
= 0;
1376 /* Binary search. This search is guaranteed to end with center
1377 pointing at the earliest partial symbol with the correct
1378 name. At that point *all* partial symbols with that name
1379 will be checked against the correct namespace. */
1382 top
= start
+ length
- 1;
1384 while (top
> bottom
)
1386 center
= bottom
+ (top
- bottom
) / 2;
1387 if (!(center
< top
))
1388 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1389 if (!do_linear_search
1390 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1392 do_linear_search
= 1;
1394 if (strcmp (SYMBOL_PRINT_NAME (*center
), name
) >= 0)
1400 bottom
= center
+ 1;
1403 if (!(top
== bottom
))
1404 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1406 /* djb - 2000-06-03 - Use SYMBOL_MATCHES_NAME, not a strcmp, so
1407 we don't have to force a linear search on C++. Probably holds true
1408 for JAVA as well, no way to check.*/
1409 while (top
<= real_top
&& SYMBOL_MATCHES_NAME (*top
,name
))
1411 if (SYMBOL_NAMESPACE (*top
) == namespace)
1419 /* Can't use a binary search or else we found during the binary search that
1420 we should also do a linear search. */
1422 if (do_linear_search
)
1424 for (psym
= start
; psym
< start
+ length
; psym
++)
1426 if (namespace == SYMBOL_NAMESPACE (*psym
))
1428 if (SYMBOL_MATCHES_NAME (*psym
, name
))
1439 /* Look up a type named NAME in the struct_namespace. The type returned
1440 must not be opaque -- i.e., must have at least one field defined
1442 This code was modelled on lookup_symbol -- the parts not relevant to looking
1443 up types were just left out. In particular it's assumed here that types
1444 are available in struct_namespace and only at file-static or global blocks. */
1448 lookup_transparent_type (const char *name
)
1450 register struct symbol
*sym
;
1451 register struct symtab
*s
= NULL
;
1452 register struct partial_symtab
*ps
;
1453 struct blockvector
*bv
;
1454 register struct objfile
*objfile
;
1455 register struct block
*block
;
1457 /* Now search all the global symbols. Do the symtab's first, then
1458 check the psymtab's. If a psymtab indicates the existence
1459 of the desired name as a global, then do psymtab-to-symtab
1460 conversion on the fly and return the found symbol. */
1462 ALL_SYMTABS (objfile
, s
)
1464 bv
= BLOCKVECTOR (s
);
1465 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1466 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1467 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1469 return SYMBOL_TYPE (sym
);
1473 ALL_PSYMTABS (objfile
, ps
)
1475 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 1, STRUCT_NAMESPACE
))
1477 s
= PSYMTAB_TO_SYMTAB (ps
);
1478 bv
= BLOCKVECTOR (s
);
1479 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1480 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1483 /* This shouldn't be necessary, but as a last resort
1484 * try looking in the statics even though the psymtab
1485 * claimed the symbol was global. It's possible that
1486 * the psymtab gets it wrong in some cases.
1488 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1489 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1491 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1492 %s may be an inlined function, or may be a template function\n\
1493 (if a template, try specifying an instantiation: %s<type>).",
1494 name
, ps
->filename
, name
, name
);
1496 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1497 return SYMBOL_TYPE (sym
);
1501 /* Now search the static file-level symbols.
1502 Not strictly correct, but more useful than an error.
1503 Do the symtab's first, then
1504 check the psymtab's. If a psymtab indicates the existence
1505 of the desired name as a file-level static, then do psymtab-to-symtab
1506 conversion on the fly and return the found symbol.
1509 ALL_SYMTABS (objfile
, s
)
1511 bv
= BLOCKVECTOR (s
);
1512 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1513 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1514 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1516 return SYMBOL_TYPE (sym
);
1520 ALL_PSYMTABS (objfile
, ps
)
1522 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, 0, STRUCT_NAMESPACE
))
1524 s
= PSYMTAB_TO_SYMTAB (ps
);
1525 bv
= BLOCKVECTOR (s
);
1526 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1527 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1530 /* This shouldn't be necessary, but as a last resort
1531 * try looking in the globals even though the psymtab
1532 * claimed the symbol was static. It's possible that
1533 * the psymtab gets it wrong in some cases.
1535 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1536 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_NAMESPACE
);
1538 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1539 %s may be an inlined function, or may be a template function\n\
1540 (if a template, try specifying an instantiation: %s<type>).",
1541 name
, ps
->filename
, name
, name
);
1543 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1544 return SYMBOL_TYPE (sym
);
1547 return (struct type
*) 0;
1551 /* Find the psymtab containing main(). */
1552 /* FIXME: What about languages without main() or specially linked
1553 executables that have no main() ? */
1555 struct partial_symtab
*
1556 find_main_psymtab (void)
1558 register struct partial_symtab
*pst
;
1559 register struct objfile
*objfile
;
1561 ALL_PSYMTABS (objfile
, pst
)
1563 if (lookup_partial_symbol (pst
, main_name (), 1, VAR_NAMESPACE
))
1571 /* Search BLOCK for symbol NAME in NAMESPACE.
1573 Note that if NAME is the demangled form of a C++ symbol, we will fail
1574 to find a match during the binary search of the non-encoded names, but
1575 for now we don't worry about the slight inefficiency of looking for
1576 a match we'll never find, since it will go pretty quick. Once the
1577 binary search terminates, we drop through and do a straight linear
1578 search on the symbols. Each symbol which is marked as being a C++
1579 symbol (language_cplus set) has both the encoded and non-encoded names
1582 If MANGLED_NAME is non-NULL, verify that any symbol we find has this
1583 particular mangled name.
1587 lookup_block_symbol (register const struct block
*block
, const char *name
,
1588 const char *mangled_name
,
1589 const namespace_enum
namespace)
1591 register int bot
, top
, inc
;
1592 register struct symbol
*sym
;
1593 register struct symbol
*sym_found
= NULL
;
1594 register int do_linear_search
= 1;
1596 if (BLOCK_HASHTABLE (block
))
1598 unsigned int hash_index
;
1599 hash_index
= msymbol_hash_iw (name
);
1600 hash_index
= hash_index
% BLOCK_BUCKETS (block
);
1601 for (sym
= BLOCK_BUCKET (block
, hash_index
); sym
; sym
= sym
->hash_next
)
1603 if (SYMBOL_NAMESPACE (sym
) == namespace
1605 ? strcmp (SYMBOL_NAME (sym
), mangled_name
) == 0
1606 : SYMBOL_MATCHES_NAME (sym
, name
)))
1612 /* If the blocks's symbols were sorted, start with a binary search. */
1614 if (BLOCK_SHOULD_SORT (block
))
1616 /* Reset the linear search flag so if the binary search fails, we
1617 won't do the linear search once unless we find some reason to
1620 do_linear_search
= 0;
1621 top
= BLOCK_NSYMS (block
);
1624 /* Advance BOT to not far before the first symbol whose name is NAME. */
1628 inc
= (top
- bot
+ 1);
1629 /* No need to keep binary searching for the last few bits worth. */
1634 inc
= (inc
>> 1) + bot
;
1635 sym
= BLOCK_SYM (block
, inc
);
1636 if (!do_linear_search
&& (SYMBOL_LANGUAGE (sym
) == language_java
))
1638 do_linear_search
= 1;
1640 if (SYMBOL_PRINT_NAME (sym
)[0] < name
[0])
1644 else if (SYMBOL_PRINT_NAME (sym
)[0] > name
[0])
1648 else if (strcmp (SYMBOL_PRINT_NAME (sym
), name
) < 0)
1658 /* Now scan forward until we run out of symbols, find one whose
1659 name is greater than NAME, or find one we want. If there is
1660 more than one symbol with the right name and namespace, we
1661 return the first one; I believe it is now impossible for us
1662 to encounter two symbols with the same name and namespace
1663 here, because blocks containing argument symbols are no
1664 longer sorted. The exception is for C++, where multiple functions
1665 (cloned constructors / destructors, in particular) can have
1666 the same demangled name. So if we have a particular
1667 mangled name to match, try to do so. */
1669 top
= BLOCK_NSYMS (block
);
1672 sym
= BLOCK_SYM (block
, bot
);
1673 if (SYMBOL_NAMESPACE (sym
) == namespace
1675 ? strcmp (SYMBOL_NAME (sym
), mangled_name
) == 0
1676 : SYMBOL_MATCHES_NAME (sym
, name
)))
1680 if (SYMBOL_PRINT_NAME (sym
)[0] > name
[0])
1688 /* Here if block isn't sorted, or we fail to find a match during the
1689 binary search above. If during the binary search above, we find a
1690 symbol which is a Java symbol, then we have re-enabled the linear
1691 search flag which was reset when starting the binary search.
1693 This loop is equivalent to the loop above, but hacked greatly for speed.
1695 Note that parameter symbols do not always show up last in the
1696 list; this loop makes sure to take anything else other than
1697 parameter symbols first; it only uses parameter symbols as a
1698 last resort. Note that this only takes up extra computation
1701 if (do_linear_search
)
1703 top
= BLOCK_NSYMS (block
);
1707 sym
= BLOCK_SYM (block
, bot
);
1708 if (SYMBOL_NAMESPACE (sym
) == namespace
1710 ? strcmp (SYMBOL_NAME (sym
), mangled_name
) == 0
1711 : SYMBOL_MATCHES_NAME (sym
, name
)))
1713 /* If SYM has aliases, then use any alias that is active
1714 at the current PC. If no alias is active at the current
1715 PC, then use the main symbol.
1717 ?!? Is checking the current pc correct? Is this routine
1718 ever called to look up a symbol from another context?
1720 FIXME: No, it's not correct. If someone sets a
1721 conditional breakpoint at an address, then the
1722 breakpoint's `struct expression' should refer to the
1723 `struct symbol' appropriate for the breakpoint's
1724 address, which may not be the PC.
1726 Even if it were never called from another context,
1727 it's totally bizarre for lookup_symbol's behavior to
1728 depend on the value of the inferior's current PC. We
1729 should pass in the appropriate PC as well as the
1730 block. The interface to lookup_symbol should change
1731 to require the caller to provide a PC. */
1733 if (SYMBOL_ALIASES (sym
))
1734 sym
= find_active_alias (sym
, read_pc ());
1737 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1738 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1739 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1740 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1741 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1742 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
&&
1743 SYMBOL_CLASS (sym
) != LOC_COMPUTED_ARG
)
1751 return (sym_found
); /* Will be NULL if not found. */
1754 /* Given a main symbol SYM and ADDR, search through the alias
1755 list to determine if an alias is active at ADDR and return
1758 If no alias is active, then return SYM. */
1760 static struct symbol
*
1761 find_active_alias (struct symbol
*sym
, CORE_ADDR addr
)
1763 struct range_list
*r
;
1764 struct alias_list
*aliases
;
1766 /* If we have aliases, check them first. */
1767 aliases
= SYMBOL_ALIASES (sym
);
1771 if (!SYMBOL_RANGES (aliases
->sym
))
1772 return aliases
->sym
;
1773 for (r
= SYMBOL_RANGES (aliases
->sym
); r
; r
= r
->next
)
1775 if (r
->start
<= addr
&& r
->end
> addr
)
1776 return aliases
->sym
;
1778 aliases
= aliases
->next
;
1781 /* Nothing found, return the main symbol. */
1786 /* Find the symtab associated with PC and SECTION. Look through the
1787 psymtabs and read in another symtab if necessary. */
1790 find_pc_sect_symtab (CORE_ADDR pc
, asection
*section
)
1792 register struct block
*b
;
1793 struct blockvector
*bv
;
1794 register struct symtab
*s
= NULL
;
1795 register struct symtab
*best_s
= NULL
;
1796 register struct partial_symtab
*ps
;
1797 register struct objfile
*objfile
;
1798 CORE_ADDR distance
= 0;
1799 struct minimal_symbol
*msymbol
;
1801 /* If we know that this is not a text address, return failure. This is
1802 necessary because we loop based on the block's high and low code
1803 addresses, which do not include the data ranges, and because
1804 we call find_pc_sect_psymtab which has a similar restriction based
1805 on the partial_symtab's texthigh and textlow. */
1806 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1808 && (msymbol
->type
== mst_data
1809 || msymbol
->type
== mst_bss
1810 || msymbol
->type
== mst_abs
1811 || msymbol
->type
== mst_file_data
1812 || msymbol
->type
== mst_file_bss
))
1815 /* Search all symtabs for the one whose file contains our address, and which
1816 is the smallest of all the ones containing the address. This is designed
1817 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1818 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1819 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1821 This happens for native ecoff format, where code from included files
1822 gets its own symtab. The symtab for the included file should have
1823 been read in already via the dependency mechanism.
1824 It might be swifter to create several symtabs with the same name
1825 like xcoff does (I'm not sure).
1827 It also happens for objfiles that have their functions reordered.
1828 For these, the symtab we are looking for is not necessarily read in. */
1830 ALL_SYMTABS (objfile
, s
)
1832 bv
= BLOCKVECTOR (s
);
1833 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1835 if (BLOCK_START (b
) <= pc
1836 && BLOCK_END (b
) > pc
1838 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1840 /* For an objfile that has its functions reordered,
1841 find_pc_psymtab will find the proper partial symbol table
1842 and we simply return its corresponding symtab. */
1843 /* In order to better support objfiles that contain both
1844 stabs and coff debugging info, we continue on if a psymtab
1846 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1848 ps
= find_pc_sect_psymtab (pc
, section
);
1850 return PSYMTAB_TO_SYMTAB (ps
);
1855 struct symbol
*sym
= NULL
;
1857 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1859 fixup_symbol_section (sym
, objfile
);
1860 if (section
== SYMBOL_BFD_SECTION (sym
))
1863 if ((i
>= BLOCK_BUCKETS (b
)) && (sym
== NULL
))
1864 continue; /* no symbol in this symtab matches section */
1866 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1875 ps
= find_pc_sect_psymtab (pc
, section
);
1879 /* Might want to error() here (in case symtab is corrupt and
1880 will cause a core dump), but maybe we can successfully
1881 continue, so let's not. */
1883 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n",
1885 s
= PSYMTAB_TO_SYMTAB (ps
);
1890 /* Find the symtab associated with PC. Look through the psymtabs and
1891 read in another symtab if necessary. Backward compatibility, no section */
1894 find_pc_symtab (CORE_ADDR pc
)
1896 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
1900 /* Find the source file and line number for a given PC value and SECTION.
1901 Return a structure containing a symtab pointer, a line number,
1902 and a pc range for the entire source line.
1903 The value's .pc field is NOT the specified pc.
1904 NOTCURRENT nonzero means, if specified pc is on a line boundary,
1905 use the line that ends there. Otherwise, in that case, the line
1906 that begins there is used. */
1908 /* The big complication here is that a line may start in one file, and end just
1909 before the start of another file. This usually occurs when you #include
1910 code in the middle of a subroutine. To properly find the end of a line's PC
1911 range, we must search all symtabs associated with this compilation unit, and
1912 find the one whose first PC is closer than that of the next line in this
1915 /* If it's worth the effort, we could be using a binary search. */
1917 struct symtab_and_line
1918 find_pc_sect_line (CORE_ADDR pc
, struct sec
*section
, int notcurrent
)
1921 register struct linetable
*l
;
1924 register struct linetable_entry
*item
;
1925 struct symtab_and_line val
;
1926 struct blockvector
*bv
;
1927 struct minimal_symbol
*msymbol
;
1928 struct minimal_symbol
*mfunsym
;
1930 /* Info on best line seen so far, and where it starts, and its file. */
1932 struct linetable_entry
*best
= NULL
;
1933 CORE_ADDR best_end
= 0;
1934 struct symtab
*best_symtab
= 0;
1936 /* Store here the first line number
1937 of a file which contains the line at the smallest pc after PC.
1938 If we don't find a line whose range contains PC,
1939 we will use a line one less than this,
1940 with a range from the start of that file to the first line's pc. */
1941 struct linetable_entry
*alt
= NULL
;
1942 struct symtab
*alt_symtab
= 0;
1944 /* Info on best line seen in this file. */
1946 struct linetable_entry
*prev
;
1948 /* If this pc is not from the current frame,
1949 it is the address of the end of a call instruction.
1950 Quite likely that is the start of the following statement.
1951 But what we want is the statement containing the instruction.
1952 Fudge the pc to make sure we get that. */
1954 init_sal (&val
); /* initialize to zeroes */
1956 /* It's tempting to assume that, if we can't find debugging info for
1957 any function enclosing PC, that we shouldn't search for line
1958 number info, either. However, GAS can emit line number info for
1959 assembly files --- very helpful when debugging hand-written
1960 assembly code. In such a case, we'd have no debug info for the
1961 function, but we would have line info. */
1966 /* elz: added this because this function returned the wrong
1967 information if the pc belongs to a stub (import/export)
1968 to call a shlib function. This stub would be anywhere between
1969 two functions in the target, and the line info was erroneously
1970 taken to be the one of the line before the pc.
1972 /* RT: Further explanation:
1974 * We have stubs (trampolines) inserted between procedures.
1976 * Example: "shr1" exists in a shared library, and a "shr1" stub also
1977 * exists in the main image.
1979 * In the minimal symbol table, we have a bunch of symbols
1980 * sorted by start address. The stubs are marked as "trampoline",
1981 * the others appear as text. E.g.:
1983 * Minimal symbol table for main image
1984 * main: code for main (text symbol)
1985 * shr1: stub (trampoline symbol)
1986 * foo: code for foo (text symbol)
1988 * Minimal symbol table for "shr1" image:
1990 * shr1: code for shr1 (text symbol)
1993 * So the code below is trying to detect if we are in the stub
1994 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
1995 * and if found, do the symbolization from the real-code address
1996 * rather than the stub address.
1998 * Assumptions being made about the minimal symbol table:
1999 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2000 * if we're really in the trampoline. If we're beyond it (say
2001 * we're in "foo" in the above example), it'll have a closer
2002 * symbol (the "foo" text symbol for example) and will not
2003 * return the trampoline.
2004 * 2. lookup_minimal_symbol_text() will find a real text symbol
2005 * corresponding to the trampoline, and whose address will
2006 * be different than the trampoline address. I put in a sanity
2007 * check for the address being the same, to avoid an
2008 * infinite recursion.
2010 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2011 if (msymbol
!= NULL
)
2012 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2014 mfunsym
= lookup_minimal_symbol_text (SYMBOL_NAME (msymbol
), NULL
, NULL
);
2015 if (mfunsym
== NULL
)
2016 /* I eliminated this warning since it is coming out
2017 * in the following situation:
2018 * gdb shmain // test program with shared libraries
2019 * (gdb) break shr1 // function in shared lib
2020 * Warning: In stub for ...
2021 * In the above situation, the shared lib is not loaded yet,
2022 * so of course we can't find the real func/line info,
2023 * but the "break" still works, and the warning is annoying.
2024 * So I commented out the warning. RT */
2025 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_NAME(msymbol)) */ ;
2027 else if (SYMBOL_VALUE (mfunsym
) == SYMBOL_VALUE (msymbol
))
2028 /* Avoid infinite recursion */
2029 /* See above comment about why warning is commented out */
2030 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_NAME(msymbol)) */ ;
2033 return find_pc_line (SYMBOL_VALUE (mfunsym
), 0);
2037 s
= find_pc_sect_symtab (pc
, section
);
2040 /* if no symbol information, return previous pc */
2047 bv
= BLOCKVECTOR (s
);
2049 /* Look at all the symtabs that share this blockvector.
2050 They all have the same apriori range, that we found was right;
2051 but they have different line tables. */
2053 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
2055 /* Find the best line in this symtab. */
2062 /* I think len can be zero if the symtab lacks line numbers
2063 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2064 I'm not sure which, and maybe it depends on the symbol
2070 item
= l
->item
; /* Get first line info */
2072 /* Is this file's first line closer than the first lines of other files?
2073 If so, record this file, and its first line, as best alternate. */
2074 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2080 for (i
= 0; i
< len
; i
++, item
++)
2082 /* Leave prev pointing to the linetable entry for the last line
2083 that started at or before PC. */
2090 /* At this point, prev points at the line whose start addr is <= pc, and
2091 item points at the next line. If we ran off the end of the linetable
2092 (pc >= start of the last line), then prev == item. If pc < start of
2093 the first line, prev will not be set. */
2095 /* Is this file's best line closer than the best in the other files?
2096 If so, record this file, and its best line, as best so far. Don't
2097 save prev if it represents the end of a function (i.e. line number
2098 0) instead of a real line. */
2100 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2105 /* Discard BEST_END if it's before the PC of the current BEST. */
2106 if (best_end
<= best
->pc
)
2110 /* If another line (denoted by ITEM) is in the linetable and its
2111 PC is after BEST's PC, but before the current BEST_END, then
2112 use ITEM's PC as the new best_end. */
2113 if (best
&& i
< len
&& item
->pc
> best
->pc
2114 && (best_end
== 0 || best_end
> item
->pc
))
2115 best_end
= item
->pc
;
2121 { /* If we didn't find any line # info, just
2127 val
.symtab
= alt_symtab
;
2128 val
.line
= alt
->line
- 1;
2130 /* Don't return line 0, that means that we didn't find the line. */
2134 val
.pc
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2138 else if (best
->line
== 0)
2140 /* If our best fit is in a range of PC's for which no line
2141 number info is available (line number is zero) then we didn't
2142 find any valid line information. */
2147 val
.symtab
= best_symtab
;
2148 val
.line
= best
->line
;
2150 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2155 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2157 val
.section
= section
;
2161 /* Backward compatibility (no section) */
2163 struct symtab_and_line
2164 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2168 section
= find_pc_overlay (pc
);
2169 if (pc_in_unmapped_range (pc
, section
))
2170 pc
= overlay_mapped_address (pc
, section
);
2171 return find_pc_sect_line (pc
, section
, notcurrent
);
2174 /* Find line number LINE in any symtab whose name is the same as
2177 If found, return the symtab that contains the linetable in which it was
2178 found, set *INDEX to the index in the linetable of the best entry
2179 found, and set *EXACT_MATCH nonzero if the value returned is an
2182 If not found, return NULL. */
2185 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
2189 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2193 struct linetable
*best_linetable
;
2194 struct symtab
*best_symtab
;
2196 /* First try looking it up in the given symtab. */
2197 best_linetable
= LINETABLE (symtab
);
2198 best_symtab
= symtab
;
2199 best_index
= find_line_common (best_linetable
, line
, &exact
);
2200 if (best_index
< 0 || !exact
)
2202 /* Didn't find an exact match. So we better keep looking for
2203 another symtab with the same name. In the case of xcoff,
2204 multiple csects for one source file (produced by IBM's FORTRAN
2205 compiler) produce multiple symtabs (this is unavoidable
2206 assuming csects can be at arbitrary places in memory and that
2207 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2209 /* BEST is the smallest linenumber > LINE so far seen,
2210 or 0 if none has been seen so far.
2211 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2214 struct objfile
*objfile
;
2217 if (best_index
>= 0)
2218 best
= best_linetable
->item
[best_index
].line
;
2222 ALL_SYMTABS (objfile
, s
)
2224 struct linetable
*l
;
2227 if (!STREQ (symtab
->filename
, s
->filename
))
2230 ind
= find_line_common (l
, line
, &exact
);
2240 if (best
== 0 || l
->item
[ind
].line
< best
)
2242 best
= l
->item
[ind
].line
;
2255 *index
= best_index
;
2257 *exact_match
= exact
;
2262 /* Set the PC value for a given source file and line number and return true.
2263 Returns zero for invalid line number (and sets the PC to 0).
2264 The source file is specified with a struct symtab. */
2267 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2269 struct linetable
*l
;
2276 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2279 l
= LINETABLE (symtab
);
2280 *pc
= l
->item
[ind
].pc
;
2287 /* Find the range of pc values in a line.
2288 Store the starting pc of the line into *STARTPTR
2289 and the ending pc (start of next line) into *ENDPTR.
2290 Returns 1 to indicate success.
2291 Returns 0 if could not find the specified line. */
2294 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2297 CORE_ADDR startaddr
;
2298 struct symtab_and_line found_sal
;
2301 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2304 /* This whole function is based on address. For example, if line 10 has
2305 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2306 "info line *0x123" should say the line goes from 0x100 to 0x200
2307 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2308 This also insures that we never give a range like "starts at 0x134
2309 and ends at 0x12c". */
2311 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2312 if (found_sal
.line
!= sal
.line
)
2314 /* The specified line (sal) has zero bytes. */
2315 *startptr
= found_sal
.pc
;
2316 *endptr
= found_sal
.pc
;
2320 *startptr
= found_sal
.pc
;
2321 *endptr
= found_sal
.end
;
2326 /* Given a line table and a line number, return the index into the line
2327 table for the pc of the nearest line whose number is >= the specified one.
2328 Return -1 if none is found. The value is >= 0 if it is an index.
2330 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2333 find_line_common (register struct linetable
*l
, register int lineno
,
2339 /* BEST is the smallest linenumber > LINENO so far seen,
2340 or 0 if none has been seen so far.
2341 BEST_INDEX identifies the item for it. */
2343 int best_index
= -1;
2352 for (i
= 0; i
< len
; i
++)
2354 register struct linetable_entry
*item
= &(l
->item
[i
]);
2356 if (item
->line
== lineno
)
2358 /* Return the first (lowest address) entry which matches. */
2363 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2370 /* If we got here, we didn't get an exact match. */
2377 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2379 struct symtab_and_line sal
;
2380 sal
= find_pc_line (pc
, 0);
2383 return sal
.symtab
!= 0;
2386 /* Given a function symbol SYM, find the symtab and line for the start
2388 If the argument FUNFIRSTLINE is nonzero, we want the first line
2389 of real code inside the function. */
2391 struct symtab_and_line
2392 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2395 struct symtab_and_line sal
;
2397 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2398 fixup_symbol_section (sym
, NULL
);
2400 { /* skip "first line" of function (which is actually its prologue) */
2401 asection
*section
= SYMBOL_BFD_SECTION (sym
);
2402 /* If function is in an unmapped overlay, use its unmapped LMA
2403 address, so that SKIP_PROLOGUE has something unique to work on */
2404 if (section_is_overlay (section
) &&
2405 !section_is_mapped (section
))
2406 pc
= overlay_unmapped_address (pc
, section
);
2408 pc
+= FUNCTION_START_OFFSET
;
2409 pc
= SKIP_PROLOGUE (pc
);
2411 /* For overlays, map pc back into its mapped VMA range */
2412 pc
= overlay_mapped_address (pc
, section
);
2414 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2416 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2417 /* Convex: no need to suppress code on first line, if any */
2420 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2421 line is still part of the same function. */
2423 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
2424 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2426 /* First pc of next line */
2428 /* Recalculate the line number (might not be N+1). */
2429 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2437 /* If P is of the form "operator[ \t]+..." where `...' is
2438 some legitimate operator text, return a pointer to the
2439 beginning of the substring of the operator text.
2440 Otherwise, return "". */
2442 operator_chars (char *p
, char **end
)
2445 if (strncmp (p
, "operator", 8))
2449 /* Don't get faked out by `operator' being part of a longer
2451 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2454 /* Allow some whitespace between `operator' and the operator symbol. */
2455 while (*p
== ' ' || *p
== '\t')
2458 /* Recognize 'operator TYPENAME'. */
2460 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2462 register char *q
= p
+ 1;
2463 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2472 case '\\': /* regexp quoting */
2475 if (p
[2] == '=') /* 'operator\*=' */
2477 else /* 'operator\*' */
2481 else if (p
[1] == '[')
2484 error ("mismatched quoting on brackets, try 'operator\\[\\]'");
2485 else if (p
[2] == '\\' && p
[3] == ']')
2487 *end
= p
+ 4; /* 'operator\[\]' */
2491 error ("nothing is allowed between '[' and ']'");
2495 /* Gratuitous qoute: skip it and move on. */
2517 if (p
[0] == '-' && p
[1] == '>')
2519 /* Struct pointer member operator 'operator->'. */
2522 *end
= p
+ 3; /* 'operator->*' */
2525 else if (p
[2] == '\\')
2527 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2532 *end
= p
+ 2; /* 'operator->' */
2536 if (p
[1] == '=' || p
[1] == p
[0])
2547 error ("`operator ()' must be specified without whitespace in `()'");
2552 error ("`operator ?:' must be specified without whitespace in `?:'");
2557 error ("`operator []' must be specified without whitespace in `[]'");
2561 error ("`operator %s' not supported", p
);
2570 /* If FILE is not already in the table of files, return zero;
2571 otherwise return non-zero. Optionally add FILE to the table if ADD
2572 is non-zero. If *FIRST is non-zero, forget the old table
2575 filename_seen (const char *file
, int add
, int *first
)
2577 /* Table of files seen so far. */
2578 static const char **tab
= NULL
;
2579 /* Allocated size of tab in elements.
2580 Start with one 256-byte block (when using GNU malloc.c).
2581 24 is the malloc overhead when range checking is in effect. */
2582 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2583 /* Current size of tab in elements. */
2584 static int tab_cur_size
;
2590 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2594 /* Is FILE in tab? */
2595 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2596 if (strcmp (*p
, file
) == 0)
2599 /* No; maybe add it to tab. */
2602 if (tab_cur_size
== tab_alloc_size
)
2604 tab_alloc_size
*= 2;
2605 tab
= (const char **) xrealloc ((char *) tab
,
2606 tab_alloc_size
* sizeof (*tab
));
2608 tab
[tab_cur_size
++] = file
;
2614 /* Slave routine for sources_info. Force line breaks at ,'s.
2615 NAME is the name to print and *FIRST is nonzero if this is the first
2616 name printed. Set *FIRST to zero. */
2618 output_source_filename (char *name
, int *first
)
2620 /* Since a single source file can result in several partial symbol
2621 tables, we need to avoid printing it more than once. Note: if
2622 some of the psymtabs are read in and some are not, it gets
2623 printed both under "Source files for which symbols have been
2624 read" and "Source files for which symbols will be read in on
2625 demand". I consider this a reasonable way to deal with the
2626 situation. I'm not sure whether this can also happen for
2627 symtabs; it doesn't hurt to check. */
2629 /* Was NAME already seen? */
2630 if (filename_seen (name
, 1, first
))
2632 /* Yes; don't print it again. */
2635 /* No; print it and reset *FIRST. */
2642 printf_filtered (", ");
2646 fputs_filtered (name
, gdb_stdout
);
2650 sources_info (char *ignore
, int from_tty
)
2652 register struct symtab
*s
;
2653 register struct partial_symtab
*ps
;
2654 register struct objfile
*objfile
;
2657 if (!have_full_symbols () && !have_partial_symbols ())
2659 error ("No symbol table is loaded. Use the \"file\" command.");
2662 printf_filtered ("Source files for which symbols have been read in:\n\n");
2665 ALL_SYMTABS (objfile
, s
)
2667 output_source_filename (s
->filename
, &first
);
2669 printf_filtered ("\n\n");
2671 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2674 ALL_PSYMTABS (objfile
, ps
)
2678 output_source_filename (ps
->filename
, &first
);
2681 printf_filtered ("\n");
2685 file_matches (char *file
, char *files
[], int nfiles
)
2689 if (file
!= NULL
&& nfiles
!= 0)
2691 for (i
= 0; i
< nfiles
; i
++)
2693 if (strcmp (files
[i
], lbasename (file
)) == 0)
2697 else if (nfiles
== 0)
2702 /* Free any memory associated with a search. */
2704 free_search_symbols (struct symbol_search
*symbols
)
2706 struct symbol_search
*p
;
2707 struct symbol_search
*next
;
2709 for (p
= symbols
; p
!= NULL
; p
= next
)
2717 do_free_search_symbols_cleanup (void *symbols
)
2719 free_search_symbols (symbols
);
2723 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
2725 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
2728 /* Helper function for sort_search_symbols and qsort. Can only
2729 sort symbols, not minimal symbols. */
2731 compare_search_syms (const void *sa
, const void *sb
)
2733 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
2734 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
2736 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
2737 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
2740 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
2741 prevtail where it is, but update its next pointer to point to
2742 the first of the sorted symbols. */
2743 static struct symbol_search
*
2744 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
2746 struct symbol_search
**symbols
, *symp
, *old_next
;
2749 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
2751 symp
= prevtail
->next
;
2752 for (i
= 0; i
< nfound
; i
++)
2757 /* Generally NULL. */
2760 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
2761 compare_search_syms
);
2764 for (i
= 0; i
< nfound
; i
++)
2766 symp
->next
= symbols
[i
];
2769 symp
->next
= old_next
;
2775 /* Search the symbol table for matches to the regular expression REGEXP,
2776 returning the results in *MATCHES.
2778 Only symbols of KIND are searched:
2779 FUNCTIONS_NAMESPACE - search all functions
2780 TYPES_NAMESPACE - search all type names
2781 METHODS_NAMESPACE - search all methods NOT IMPLEMENTED
2782 VARIABLES_NAMESPACE - search all symbols, excluding functions, type names,
2783 and constants (enums)
2785 free_search_symbols should be called when *MATCHES is no longer needed.
2787 The results are sorted locally; each symtab's global and static blocks are
2788 separately alphabetized.
2791 search_symbols (char *regexp
, namespace_enum kind
, int nfiles
, char *files
[],
2792 struct symbol_search
**matches
)
2794 register struct symtab
*s
;
2795 register struct partial_symtab
*ps
;
2796 register struct blockvector
*bv
;
2797 struct blockvector
*prev_bv
= 0;
2798 register struct block
*b
;
2801 register struct symbol
*sym
;
2802 struct partial_symbol
**psym
;
2803 struct objfile
*objfile
;
2804 struct minimal_symbol
*msymbol
;
2807 static enum minimal_symbol_type types
[]
2809 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2810 static enum minimal_symbol_type types2
[]
2812 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2813 static enum minimal_symbol_type types3
[]
2815 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2816 static enum minimal_symbol_type types4
[]
2818 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2819 enum minimal_symbol_type ourtype
;
2820 enum minimal_symbol_type ourtype2
;
2821 enum minimal_symbol_type ourtype3
;
2822 enum minimal_symbol_type ourtype4
;
2823 struct symbol_search
*sr
;
2824 struct symbol_search
*psr
;
2825 struct symbol_search
*tail
;
2826 struct cleanup
*old_chain
= NULL
;
2828 if (kind
< VARIABLES_NAMESPACE
)
2829 error ("must search on specific namespace");
2831 ourtype
= types
[(int) (kind
- VARIABLES_NAMESPACE
)];
2832 ourtype2
= types2
[(int) (kind
- VARIABLES_NAMESPACE
)];
2833 ourtype3
= types3
[(int) (kind
- VARIABLES_NAMESPACE
)];
2834 ourtype4
= types4
[(int) (kind
- VARIABLES_NAMESPACE
)];
2836 sr
= *matches
= NULL
;
2841 /* Make sure spacing is right for C++ operators.
2842 This is just a courtesy to make the matching less sensitive
2843 to how many spaces the user leaves between 'operator'
2844 and <TYPENAME> or <OPERATOR>. */
2846 char *opname
= operator_chars (regexp
, &opend
);
2849 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2850 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
2852 /* There should 1 space between 'operator' and 'TYPENAME'. */
2853 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2858 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2859 if (opname
[-1] == ' ')
2862 /* If wrong number of spaces, fix it. */
2865 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
2866 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
2871 if (0 != (val
= re_comp (regexp
)))
2872 error ("Invalid regexp (%s): %s", val
, regexp
);
2875 /* Search through the partial symtabs *first* for all symbols
2876 matching the regexp. That way we don't have to reproduce all of
2877 the machinery below. */
2879 ALL_PSYMTABS (objfile
, ps
)
2881 struct partial_symbol
**bound
, **gbound
, **sbound
;
2887 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2888 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2891 /* Go through all of the symbols stored in a partial
2892 symtab in one loop. */
2893 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2898 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2900 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
2911 /* If it would match (logic taken from loop below)
2912 load the file and go on to the next one */
2913 if (file_matches (ps
->filename
, files
, nfiles
)
2914 && ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (*psym
))
2915 && ((kind
== VARIABLES_NAMESPACE
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
2916 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
2917 || (kind
== FUNCTIONS_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
2918 || (kind
== TYPES_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
2919 || (kind
== METHODS_NAMESPACE
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
))))
2921 PSYMTAB_TO_SYMTAB (ps
);
2929 /* Here, we search through the minimal symbol tables for functions
2930 and variables that match, and force their symbols to be read.
2931 This is in particular necessary for demangled variable names,
2932 which are no longer put into the partial symbol tables.
2933 The symbol will then be found during the scan of symtabs below.
2935 For functions, find_pc_symtab should succeed if we have debug info
2936 for the function, for variables we have to call lookup_symbol
2937 to determine if the variable has debug info.
2938 If the lookup fails, set found_misc so that we will rescan to print
2939 any matching symbols without debug info.
2942 if (nfiles
== 0 && (kind
== VARIABLES_NAMESPACE
|| kind
== FUNCTIONS_NAMESPACE
))
2944 ALL_MSYMBOLS (objfile
, msymbol
)
2946 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
2947 MSYMBOL_TYPE (msymbol
) == ourtype2
||
2948 MSYMBOL_TYPE (msymbol
) == ourtype3
||
2949 MSYMBOL_TYPE (msymbol
) == ourtype4
)
2951 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
2953 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
2955 /* FIXME: carlton/2003-02-04: Given that the
2956 semantics of lookup_symbol keeps on changing
2957 slightly, it would be a nice idea if we had a
2958 function lookup_symbol_minsym that found the
2959 symbol associated to a given minimal symbol (if
2961 if (kind
== FUNCTIONS_NAMESPACE
2962 || lookup_symbol (SYMBOL_NAME (msymbol
),
2963 (struct block
*) NULL
,
2965 0, (struct symtab
**) NULL
) == NULL
)
2973 ALL_SYMTABS (objfile
, s
)
2975 bv
= BLOCKVECTOR (s
);
2976 /* Often many files share a blockvector.
2977 Scan each blockvector only once so that
2978 we don't get every symbol many times.
2979 It happens that the first symtab in the list
2980 for any given blockvector is the main file. */
2982 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
2984 struct symbol_search
*prevtail
= tail
;
2986 b
= BLOCKVECTOR_BLOCK (bv
, i
);
2987 ALL_BLOCK_SYMBOLS (b
, j
, sym
)
2990 if (file_matches (s
->filename
, files
, nfiles
)
2991 && ((regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (sym
))
2992 && ((kind
== VARIABLES_NAMESPACE
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
2993 && SYMBOL_CLASS (sym
) != LOC_BLOCK
2994 && SYMBOL_CLASS (sym
) != LOC_CONST
)
2995 || (kind
== FUNCTIONS_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2996 || (kind
== TYPES_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
2997 || (kind
== METHODS_NAMESPACE
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
))))
3000 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3004 psr
->msymbol
= NULL
;
3016 if (prevtail
== NULL
)
3018 struct symbol_search dummy
;
3021 tail
= sort_search_symbols (&dummy
, nfound
);
3024 old_chain
= make_cleanup_free_search_symbols (sr
);
3027 tail
= sort_search_symbols (prevtail
, nfound
);
3033 /* If there are no eyes, avoid all contact. I mean, if there are
3034 no debug symbols, then print directly from the msymbol_vector. */
3036 if (found_misc
|| kind
!= FUNCTIONS_NAMESPACE
)
3038 ALL_MSYMBOLS (objfile
, msymbol
)
3040 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3041 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3042 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3043 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3045 if (regexp
== NULL
|| SYMBOL_MATCHES_REGEXP (msymbol
))
3047 /* Functions: Look up by address. */
3048 if (kind
!= FUNCTIONS_NAMESPACE
||
3049 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3051 /* Variables/Absolutes: Look up by name */
3052 if (lookup_symbol (SYMBOL_NAME (msymbol
),
3053 (struct block
*) NULL
, VAR_NAMESPACE
,
3054 0, (struct symtab
**) NULL
) == NULL
)
3057 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3059 psr
->msymbol
= msymbol
;
3066 old_chain
= make_cleanup_free_search_symbols (sr
);
3080 discard_cleanups (old_chain
);
3083 /* Helper function for symtab_symbol_info, this function uses
3084 the data returned from search_symbols() to print information
3085 regarding the match to gdb_stdout.
3088 print_symbol_info (namespace_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3089 int block
, char *last
)
3091 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3093 fputs_filtered ("\nFile ", gdb_stdout
);
3094 fputs_filtered (s
->filename
, gdb_stdout
);
3095 fputs_filtered (":\n", gdb_stdout
);
3098 if (kind
!= TYPES_NAMESPACE
&& block
== STATIC_BLOCK
)
3099 printf_filtered ("static ");
3101 /* Typedef that is not a C++ class */
3102 if (kind
== TYPES_NAMESPACE
3103 && SYMBOL_NAMESPACE (sym
) != STRUCT_NAMESPACE
)
3104 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3105 /* variable, func, or typedef-that-is-c++-class */
3106 else if (kind
< TYPES_NAMESPACE
||
3107 (kind
== TYPES_NAMESPACE
&&
3108 SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
))
3110 type_print (SYMBOL_TYPE (sym
),
3111 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3112 ? "" : SYMBOL_PRINT_NAME (sym
)),
3115 printf_filtered (";\n");
3119 /* This help function for symtab_symbol_info() prints information
3120 for non-debugging symbols to gdb_stdout.
3123 print_msymbol_info (struct minimal_symbol
*msymbol
)
3127 if (TARGET_ADDR_BIT
<= 32)
3128 tmp
= local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3129 & (CORE_ADDR
) 0xffffffff,
3132 tmp
= local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3134 printf_filtered ("%s %s\n",
3135 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3138 /* This is the guts of the commands "info functions", "info types", and
3139 "info variables". It calls search_symbols to find all matches and then
3140 print_[m]symbol_info to print out some useful information about the
3144 symtab_symbol_info (char *regexp
, namespace_enum kind
, int from_tty
)
3146 static char *classnames
[]
3148 {"variable", "function", "type", "method"};
3149 struct symbol_search
*symbols
;
3150 struct symbol_search
*p
;
3151 struct cleanup
*old_chain
;
3152 char *last_filename
= NULL
;
3155 /* must make sure that if we're interrupted, symbols gets freed */
3156 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3157 old_chain
= make_cleanup_free_search_symbols (symbols
);
3159 printf_filtered (regexp
3160 ? "All %ss matching regular expression \"%s\":\n"
3161 : "All defined %ss:\n",
3162 classnames
[(int) (kind
- VARIABLES_NAMESPACE
)], regexp
);
3164 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3168 if (p
->msymbol
!= NULL
)
3172 printf_filtered ("\nNon-debugging symbols:\n");
3175 print_msymbol_info (p
->msymbol
);
3179 print_symbol_info (kind
,
3184 last_filename
= p
->symtab
->filename
;
3188 do_cleanups (old_chain
);
3192 variables_info (char *regexp
, int from_tty
)
3194 symtab_symbol_info (regexp
, VARIABLES_NAMESPACE
, from_tty
);
3198 functions_info (char *regexp
, int from_tty
)
3200 symtab_symbol_info (regexp
, FUNCTIONS_NAMESPACE
, from_tty
);
3205 types_info (char *regexp
, int from_tty
)
3207 symtab_symbol_info (regexp
, TYPES_NAMESPACE
, from_tty
);
3210 /* Breakpoint all functions matching regular expression. */
3213 rbreak_command_wrapper (char *regexp
, int from_tty
)
3215 rbreak_command (regexp
, from_tty
);
3219 rbreak_command (char *regexp
, int from_tty
)
3221 struct symbol_search
*ss
;
3222 struct symbol_search
*p
;
3223 struct cleanup
*old_chain
;
3225 search_symbols (regexp
, FUNCTIONS_NAMESPACE
, 0, (char **) NULL
, &ss
);
3226 old_chain
= make_cleanup_free_search_symbols (ss
);
3228 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3230 if (p
->msymbol
== NULL
)
3232 char *string
= (char *) alloca (strlen (p
->symtab
->filename
)
3233 + strlen (SYMBOL_NAME (p
->symbol
))
3235 strcpy (string
, p
->symtab
->filename
);
3236 strcat (string
, ":'");
3237 strcat (string
, SYMBOL_NAME (p
->symbol
));
3238 strcat (string
, "'");
3239 break_command (string
, from_tty
);
3240 print_symbol_info (FUNCTIONS_NAMESPACE
,
3244 p
->symtab
->filename
);
3248 break_command (SYMBOL_NAME (p
->msymbol
), from_tty
);
3249 printf_filtered ("<function, no debug info> %s;\n",
3250 SYMBOL_PRINT_NAME (p
->msymbol
));
3254 do_cleanups (old_chain
);
3258 /* Helper routine for make_symbol_completion_list. */
3260 static int return_val_size
;
3261 static int return_val_index
;
3262 static char **return_val
;
3264 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3266 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
3267 /* Put only the mangled name on the list. */ \
3268 /* Advantage: "b foo<TAB>" completes to "b foo(int, int)" */ \
3269 /* Disadvantage: "b foo__i<TAB>" doesn't complete. */ \
3270 completion_list_add_name \
3271 (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
3273 completion_list_add_name \
3274 (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
3277 /* Test to see if the symbol specified by SYMNAME (which is already
3278 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3279 characters. If so, add it to the current completion list. */
3282 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3283 char *text
, char *word
)
3288 /* clip symbols that cannot match */
3290 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3295 /* We have a match for a completion, so add SYMNAME to the current list
3296 of matches. Note that the name is moved to freshly malloc'd space. */
3300 if (word
== sym_text
)
3302 new = xmalloc (strlen (symname
) + 5);
3303 strcpy (new, symname
);
3305 else if (word
> sym_text
)
3307 /* Return some portion of symname. */
3308 new = xmalloc (strlen (symname
) + 5);
3309 strcpy (new, symname
+ (word
- sym_text
));
3313 /* Return some of SYM_TEXT plus symname. */
3314 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3315 strncpy (new, word
, sym_text
- word
);
3316 new[sym_text
- word
] = '\0';
3317 strcat (new, symname
);
3320 if (return_val_index
+ 3 > return_val_size
)
3322 newsize
= (return_val_size
*= 2) * sizeof (char *);
3323 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3325 return_val
[return_val_index
++] = new;
3326 return_val
[return_val_index
] = NULL
;
3330 /* Return a NULL terminated array of all symbols (regardless of class)
3331 which begin by matching TEXT. If the answer is no symbols, then
3332 the return value is an array which contains only a NULL pointer.
3334 Problem: All of the symbols have to be copied because readline frees them.
3335 I'm not going to worry about this; hopefully there won't be that many. */
3338 make_symbol_completion_list (char *text
, char *word
)
3340 register struct symbol
*sym
;
3341 register struct symtab
*s
;
3342 register struct partial_symtab
*ps
;
3343 register struct minimal_symbol
*msymbol
;
3344 register struct objfile
*objfile
;
3345 register struct block
*b
, *surrounding_static_block
= 0;
3347 struct partial_symbol
**psym
;
3348 /* The symbol we are completing on. Points in same buffer as text. */
3350 /* Length of sym_text. */
3353 /* Now look for the symbol we are supposed to complete on.
3354 FIXME: This should be language-specific. */
3358 char *quote_pos
= NULL
;
3360 /* First see if this is a quoted string. */
3362 for (p
= text
; *p
!= '\0'; ++p
)
3364 if (quote_found
!= '\0')
3366 if (*p
== quote_found
)
3367 /* Found close quote. */
3369 else if (*p
== '\\' && p
[1] == quote_found
)
3370 /* A backslash followed by the quote character
3371 doesn't end the string. */
3374 else if (*p
== '\'' || *p
== '"')
3380 if (quote_found
== '\'')
3381 /* A string within single quotes can be a symbol, so complete on it. */
3382 sym_text
= quote_pos
+ 1;
3383 else if (quote_found
== '"')
3384 /* A double-quoted string is never a symbol, nor does it make sense
3385 to complete it any other way. */
3387 return_val
= (char **) xmalloc (sizeof (char *));
3388 return_val
[0] = NULL
;
3393 /* It is not a quoted string. Break it based on the characters
3394 which are in symbols. */
3397 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3406 sym_text_len
= strlen (sym_text
);
3408 return_val_size
= 100;
3409 return_val_index
= 0;
3410 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3411 return_val
[0] = NULL
;
3413 /* Look through the partial symtabs for all symbols which begin
3414 by matching SYM_TEXT. Add each one that you find to the list. */
3416 ALL_PSYMTABS (objfile
, ps
)
3418 /* If the psymtab's been read in we'll get it when we search
3419 through the blockvector. */
3423 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3424 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3425 + ps
->n_global_syms
);
3428 /* If interrupted, then quit. */
3430 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3433 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3434 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3435 + ps
->n_static_syms
);
3439 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3443 /* At this point scan through the misc symbol vectors and add each
3444 symbol you find to the list. Eventually we want to ignore
3445 anything that isn't a text symbol (everything else will be
3446 handled by the psymtab code above). */
3448 ALL_MSYMBOLS (objfile
, msymbol
)
3451 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3454 /* Search upwards from currently selected frame (so that we can
3455 complete on local vars. */
3457 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3459 if (!BLOCK_SUPERBLOCK (b
))
3461 surrounding_static_block
= b
; /* For elmin of dups */
3464 /* Also catch fields of types defined in this places which match our
3465 text string. Only complete on types visible from current context. */
3467 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3469 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3470 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3472 struct type
*t
= SYMBOL_TYPE (sym
);
3473 enum type_code c
= TYPE_CODE (t
);
3475 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3477 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3479 if (TYPE_FIELD_NAME (t
, j
))
3481 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3482 sym_text
, sym_text_len
, text
, word
);
3490 /* Go through the symtabs and check the externs and statics for
3491 symbols which match. */
3493 ALL_SYMTABS (objfile
, s
)
3496 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3497 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3499 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3503 ALL_SYMTABS (objfile
, s
)
3506 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3507 /* Don't do this block twice. */
3508 if (b
== surrounding_static_block
)
3510 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3512 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3516 return (return_val
);
3519 /* Like make_symbol_completion_list, but returns a list of symbols
3520 defined in a source file FILE. */
3523 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
3525 register struct symbol
*sym
;
3526 register struct symtab
*s
;
3527 register struct block
*b
;
3529 /* The symbol we are completing on. Points in same buffer as text. */
3531 /* Length of sym_text. */
3534 /* Now look for the symbol we are supposed to complete on.
3535 FIXME: This should be language-specific. */
3539 char *quote_pos
= NULL
;
3541 /* First see if this is a quoted string. */
3543 for (p
= text
; *p
!= '\0'; ++p
)
3545 if (quote_found
!= '\0')
3547 if (*p
== quote_found
)
3548 /* Found close quote. */
3550 else if (*p
== '\\' && p
[1] == quote_found
)
3551 /* A backslash followed by the quote character
3552 doesn't end the string. */
3555 else if (*p
== '\'' || *p
== '"')
3561 if (quote_found
== '\'')
3562 /* A string within single quotes can be a symbol, so complete on it. */
3563 sym_text
= quote_pos
+ 1;
3564 else if (quote_found
== '"')
3565 /* A double-quoted string is never a symbol, nor does it make sense
3566 to complete it any other way. */
3568 return_val
= (char **) xmalloc (sizeof (char *));
3569 return_val
[0] = NULL
;
3574 /* It is not a quoted string. Break it based on the characters
3575 which are in symbols. */
3578 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3587 sym_text_len
= strlen (sym_text
);
3589 return_val_size
= 10;
3590 return_val_index
= 0;
3591 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3592 return_val
[0] = NULL
;
3594 /* Find the symtab for SRCFILE (this loads it if it was not yet read
3596 s
= lookup_symtab (srcfile
);
3599 /* Maybe they typed the file with leading directories, while the
3600 symbol tables record only its basename. */
3601 const char *tail
= lbasename (srcfile
);
3604 s
= lookup_symtab (tail
);
3607 /* If we have no symtab for that file, return an empty list. */
3609 return (return_val
);
3611 /* Go through this symtab and check the externs and statics for
3612 symbols which match. */
3614 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3615 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3617 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3620 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3621 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
3623 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3626 return (return_val
);
3629 /* A helper function for make_source_files_completion_list. It adds
3630 another file name to a list of possible completions, growing the
3631 list as necessary. */
3634 add_filename_to_list (const char *fname
, char *text
, char *word
,
3635 char ***list
, int *list_used
, int *list_alloced
)
3638 size_t fnlen
= strlen (fname
);
3640 if (*list_used
+ 1 >= *list_alloced
)
3643 *list
= (char **) xrealloc ((char *) *list
,
3644 *list_alloced
* sizeof (char *));
3649 /* Return exactly fname. */
3650 new = xmalloc (fnlen
+ 5);
3651 strcpy (new, fname
);
3653 else if (word
> text
)
3655 /* Return some portion of fname. */
3656 new = xmalloc (fnlen
+ 5);
3657 strcpy (new, fname
+ (word
- text
));
3661 /* Return some of TEXT plus fname. */
3662 new = xmalloc (fnlen
+ (text
- word
) + 5);
3663 strncpy (new, word
, text
- word
);
3664 new[text
- word
] = '\0';
3665 strcat (new, fname
);
3667 (*list
)[*list_used
] = new;
3668 (*list
)[++*list_used
] = NULL
;
3672 not_interesting_fname (const char *fname
)
3674 static const char *illegal_aliens
[] = {
3675 "_globals_", /* inserted by coff_symtab_read */
3680 for (i
= 0; illegal_aliens
[i
]; i
++)
3682 if (strcmp (fname
, illegal_aliens
[i
]) == 0)
3688 /* Return a NULL terminated array of all source files whose names
3689 begin with matching TEXT. The file names are looked up in the
3690 symbol tables of this program. If the answer is no matchess, then
3691 the return value is an array which contains only a NULL pointer. */
3694 make_source_files_completion_list (char *text
, char *word
)
3696 register struct symtab
*s
;
3697 register struct partial_symtab
*ps
;
3698 register struct objfile
*objfile
;
3700 int list_alloced
= 1;
3702 size_t text_len
= strlen (text
);
3703 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
3704 const char *base_name
;
3708 if (!have_full_symbols () && !have_partial_symbols ())
3711 ALL_SYMTABS (objfile
, s
)
3713 if (not_interesting_fname (s
->filename
))
3715 if (!filename_seen (s
->filename
, 1, &first
)
3716 #if HAVE_DOS_BASED_FILE_SYSTEM
3717 && strncasecmp (s
->filename
, text
, text_len
) == 0
3719 && strncmp (s
->filename
, text
, text_len
) == 0
3723 /* This file matches for a completion; add it to the current
3725 add_filename_to_list (s
->filename
, text
, word
,
3726 &list
, &list_used
, &list_alloced
);
3730 /* NOTE: We allow the user to type a base name when the
3731 debug info records leading directories, but not the other
3732 way around. This is what subroutines of breakpoint
3733 command do when they parse file names. */
3734 base_name
= lbasename (s
->filename
);
3735 if (base_name
!= s
->filename
3736 && !filename_seen (base_name
, 1, &first
)
3737 #if HAVE_DOS_BASED_FILE_SYSTEM
3738 && strncasecmp (base_name
, text
, text_len
) == 0
3740 && strncmp (base_name
, text
, text_len
) == 0
3743 add_filename_to_list (base_name
, text
, word
,
3744 &list
, &list_used
, &list_alloced
);
3748 ALL_PSYMTABS (objfile
, ps
)
3750 if (not_interesting_fname (ps
->filename
))
3754 if (!filename_seen (ps
->filename
, 1, &first
)
3755 #if HAVE_DOS_BASED_FILE_SYSTEM
3756 && strncasecmp (ps
->filename
, text
, text_len
) == 0
3758 && strncmp (ps
->filename
, text
, text_len
) == 0
3762 /* This file matches for a completion; add it to the
3763 current list of matches. */
3764 add_filename_to_list (ps
->filename
, text
, word
,
3765 &list
, &list_used
, &list_alloced
);
3770 base_name
= lbasename (ps
->filename
);
3771 if (base_name
!= ps
->filename
3772 && !filename_seen (base_name
, 1, &first
)
3773 #if HAVE_DOS_BASED_FILE_SYSTEM
3774 && strncasecmp (base_name
, text
, text_len
) == 0
3776 && strncmp (base_name
, text
, text_len
) == 0
3779 add_filename_to_list (base_name
, text
, word
,
3780 &list
, &list_used
, &list_alloced
);
3788 /* Determine if PC is in the prologue of a function. The prologue is the area
3789 between the first instruction of a function, and the first executable line.
3790 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3792 If non-zero, func_start is where we think the prologue starts, possibly
3793 by previous examination of symbol table information.
3797 in_prologue (CORE_ADDR pc
, CORE_ADDR func_start
)
3799 struct symtab_and_line sal
;
3800 CORE_ADDR func_addr
, func_end
;
3802 /* We have several sources of information we can consult to figure
3804 - Compilers usually emit line number info that marks the prologue
3805 as its own "source line". So the ending address of that "line"
3806 is the end of the prologue. If available, this is the most
3808 - The minimal symbols and partial symbols, which can usually tell
3809 us the starting and ending addresses of a function.
3810 - If we know the function's start address, we can call the
3811 architecture-defined SKIP_PROLOGUE function to analyze the
3812 instruction stream and guess where the prologue ends.
3813 - Our `func_start' argument; if non-zero, this is the caller's
3814 best guess as to the function's entry point. At the time of
3815 this writing, handle_inferior_event doesn't get this right, so
3816 it should be our last resort. */
3818 /* Consult the partial symbol table, to find which function
3820 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3822 CORE_ADDR prologue_end
;
3824 /* We don't even have minsym information, so fall back to using
3825 func_start, if given. */
3827 return 1; /* We *might* be in a prologue. */
3829 prologue_end
= SKIP_PROLOGUE (func_start
);
3831 return func_start
<= pc
&& pc
< prologue_end
;
3834 /* If we have line number information for the function, that's
3835 usually pretty reliable. */
3836 sal
= find_pc_line (func_addr
, 0);
3838 /* Now sal describes the source line at the function's entry point,
3839 which (by convention) is the prologue. The end of that "line",
3840 sal.end, is the end of the prologue.
3842 Note that, for functions whose source code is all on a single
3843 line, the line number information doesn't always end up this way.
3844 So we must verify that our purported end-of-prologue address is
3845 *within* the function, not at its start or end. */
3847 || sal
.end
<= func_addr
3848 || func_end
<= sal
.end
)
3850 /* We don't have any good line number info, so use the minsym
3851 information, together with the architecture-specific prologue
3853 CORE_ADDR prologue_end
= SKIP_PROLOGUE (func_addr
);
3855 return func_addr
<= pc
&& pc
< prologue_end
;
3858 /* We have line number info, and it looks good. */
3859 return func_addr
<= pc
&& pc
< sal
.end
;
3863 /* Begin overload resolution functions */
3866 remove_params (const char *demangled_name
)
3872 if (demangled_name
== NULL
)
3875 /* First find the end of the arg list. */
3876 argp
= strrchr (demangled_name
, ')');
3880 /* Back up to the beginning. */
3883 while (argp
-- > demangled_name
)
3887 else if (*argp
== '(')
3896 internal_error (__FILE__
, __LINE__
,
3897 "bad demangled name %s\n", demangled_name
);
3898 while (argp
[-1] == ' ' && argp
> demangled_name
)
3901 new_name
= xmalloc (argp
- demangled_name
+ 1);
3902 memcpy (new_name
, demangled_name
, argp
- demangled_name
);
3903 new_name
[argp
- demangled_name
] = '\0';
3907 /* Helper routine for make_symbol_completion_list. */
3909 static int sym_return_val_size
;
3910 static int sym_return_val_index
;
3911 static struct symbol
**sym_return_val
;
3913 /* Test to see if the symbol specified by SYMNAME (which is already
3914 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3915 characters. If so, add it to the current completion list. */
3918 overload_list_add_symbol (struct symbol
*sym
, char *oload_name
)
3924 /* If there is no type information, we can't do anything, so skip */
3925 if (SYMBOL_TYPE (sym
) == NULL
)
3928 /* skip any symbols that we've already considered. */
3929 for (i
= 0; i
< sym_return_val_index
; ++i
)
3930 if (!strcmp (SYMBOL_NAME (sym
), SYMBOL_NAME (sym_return_val
[i
])))
3933 /* Get the demangled name without parameters */
3934 sym_name
= remove_params (SYMBOL_DEMANGLED_NAME (sym
));
3938 /* skip symbols that cannot match */
3939 if (strcmp (sym_name
, oload_name
) != 0)
3947 /* We have a match for an overload instance, so add SYM to the current list
3948 * of overload instances */
3949 if (sym_return_val_index
+ 3 > sym_return_val_size
)
3951 newsize
= (sym_return_val_size
*= 2) * sizeof (struct symbol
*);
3952 sym_return_val
= (struct symbol
**) xrealloc ((char *) sym_return_val
, newsize
);
3954 sym_return_val
[sym_return_val_index
++] = sym
;
3955 sym_return_val
[sym_return_val_index
] = NULL
;
3958 /* Return a null-terminated list of pointers to function symbols that
3959 * match name of the supplied symbol FSYM.
3960 * This is used in finding all overloaded instances of a function name.
3961 * This has been modified from make_symbol_completion_list. */
3965 make_symbol_overload_list (struct symbol
*fsym
)
3967 register struct symbol
*sym
;
3968 register struct symtab
*s
;
3969 register struct partial_symtab
*ps
;
3970 register struct objfile
*objfile
;
3971 register struct block
*b
, *surrounding_static_block
= 0;
3973 /* The name we are completing on. */
3974 char *oload_name
= NULL
;
3975 /* Length of name. */
3976 int oload_name_len
= 0;
3978 /* Look for the symbol we are supposed to complete on. */
3980 oload_name
= remove_params (SYMBOL_DEMANGLED_NAME (fsym
));
3983 sym_return_val_size
= 1;
3984 sym_return_val
= (struct symbol
**) xmalloc (2 * sizeof (struct symbol
*));
3985 sym_return_val
[0] = fsym
;
3986 sym_return_val
[1] = NULL
;
3988 return sym_return_val
;
3990 oload_name_len
= strlen (oload_name
);
3992 sym_return_val_size
= 100;
3993 sym_return_val_index
= 0;
3994 sym_return_val
= (struct symbol
**) xmalloc ((sym_return_val_size
+ 1) * sizeof (struct symbol
*));
3995 sym_return_val
[0] = NULL
;
3997 /* Look through the partial symtabs for all symbols which begin
3998 by matching OLOAD_NAME. Make sure we read that symbol table in. */
4000 ALL_PSYMTABS (objfile
, ps
)
4002 struct partial_symbol
**psym
;
4004 /* If the psymtab's been read in we'll get it when we search
4005 through the blockvector. */
4009 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
4010 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
4011 + ps
->n_global_syms
);
4014 /* If interrupted, then quit. */
4016 /* This will cause the symbol table to be read if it has not yet been */
4017 s
= PSYMTAB_TO_SYMTAB (ps
);
4020 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
4021 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
4022 + ps
->n_static_syms
);
4026 /* This will cause the symbol table to be read if it has not yet been */
4027 s
= PSYMTAB_TO_SYMTAB (ps
);
4031 /* Search upwards from currently selected frame (so that we can
4032 complete on local vars. */
4034 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
4036 if (!BLOCK_SUPERBLOCK (b
))
4038 surrounding_static_block
= b
; /* For elimination of dups */
4041 /* Also catch fields of types defined in this places which match our
4042 text string. Only complete on types visible from current context. */
4044 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
4046 overload_list_add_symbol (sym
, oload_name
);
4050 /* Go through the symtabs and check the externs and statics for
4051 symbols which match. */
4053 ALL_SYMTABS (objfile
, s
)
4056 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4057 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
4059 overload_list_add_symbol (sym
, oload_name
);
4063 ALL_SYMTABS (objfile
, s
)
4066 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4067 /* Don't do this block twice. */
4068 if (b
== surrounding_static_block
)
4070 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
4072 overload_list_add_symbol (sym
, oload_name
);
4078 return (sym_return_val
);
4081 /* End of overload resolution functions */
4083 struct symtabs_and_lines
4084 decode_line_spec (char *string
, int funfirstline
)
4086 struct symtabs_and_lines sals
;
4087 struct symtab_and_line cursal
;
4090 error ("Empty line specification.");
4092 /* We use whatever is set as the current source line. We do not try
4093 and get a default or it will recursively call us! */
4094 cursal
= get_current_source_symtab_and_line ();
4096 sals
= decode_line_1 (&string
, funfirstline
,
4097 cursal
.symtab
, cursal
.line
,
4101 error ("Junk at end of line specification: %s", string
);
4106 static char *name_of_main
;
4109 set_main_name (const char *name
)
4111 if (name_of_main
!= NULL
)
4113 xfree (name_of_main
);
4114 name_of_main
= NULL
;
4118 name_of_main
= xstrdup (name
);
4125 if (name_of_main
!= NULL
)
4126 return name_of_main
;
4133 _initialize_symtab (void)
4135 add_info ("variables", variables_info
,
4136 "All global and static variable names, or those matching REGEXP.");
4138 add_com ("whereis", class_info
, variables_info
,
4139 "All global and static variable names, or those matching REGEXP.");
4141 add_info ("functions", functions_info
,
4142 "All function names, or those matching REGEXP.");
4145 /* FIXME: This command has at least the following problems:
4146 1. It prints builtin types (in a very strange and confusing fashion).
4147 2. It doesn't print right, e.g. with
4148 typedef struct foo *FOO
4149 type_print prints "FOO" when we want to make it (in this situation)
4150 print "struct foo *".
4151 I also think "ptype" or "whatis" is more likely to be useful (but if
4152 there is much disagreement "info types" can be fixed). */
4153 add_info ("types", types_info
,
4154 "All type names, or those matching REGEXP.");
4156 add_info ("sources", sources_info
,
4157 "Source files in the program.");
4159 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4160 "Set a breakpoint for all functions matching REGEXP.");
4164 add_com ("lf", class_info
, sources_info
, "Source files in the program");
4165 add_com ("lg", class_info
, variables_info
,
4166 "All global and static variable names, or those matching REGEXP.");
4169 /* Initialize the one built-in type that isn't language dependent... */
4170 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
4171 "<unknown type>", (struct objfile
*) NULL
);