1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
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., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
34 #include "call-cmds.h"
35 #include "gdb_regex.h"
36 #include "expression.h"
42 #include "filenames.h" /* for FILENAME_CMP */
43 #include "objc-lang.h"
48 #include "gdb_obstack.h"
50 #include "dictionary.h"
52 #include <sys/types.h>
54 #include "gdb_string.h"
59 #include "gdb_assert.h"
61 /* Prototypes for local functions */
63 static void completion_list_add_name (char *, char *, int, char *, char *);
65 static void rbreak_command (char *, int);
67 static void types_info (char *, int);
69 static void functions_info (char *, int);
71 static void variables_info (char *, int);
73 static void sources_info (char *, int);
75 static void output_source_filename (const char *, int *);
77 static int find_line_common (struct linetable
*, int, int *);
79 /* This one is used by linespec.c */
81 char *operator_chars (char *p
, char **end
);
83 static struct symbol
*lookup_symbol_aux (const char *name
,
84 const char *linkage_name
,
85 const struct block
*block
,
86 const domain_enum domain
,
87 int *is_a_field_of_this
,
88 struct symtab
**symtab
);
91 struct symbol
*lookup_symbol_aux_local (const char *name
,
92 const char *linkage_name
,
93 const struct block
*block
,
94 const domain_enum domain
,
95 struct symtab
**symtab
);
98 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
100 const char *linkage_name
,
101 const domain_enum domain
,
102 struct symtab
**symtab
);
105 struct symbol
*lookup_symbol_aux_psymtabs (int block_index
,
107 const char *linkage_name
,
108 const domain_enum domain
,
109 struct symtab
**symtab
);
113 struct symbol
*lookup_symbol_aux_minsyms (const char *name
,
114 const char *linkage_name
,
115 const domain_enum domain
,
116 int *is_a_field_of_this
,
117 struct symtab
**symtab
);
120 /* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c.
121 Signals the presence of objects compiled by HP compilers. */
122 int deprecated_hp_som_som_object_present
= 0;
124 static void fixup_section (struct general_symbol_info
*, struct objfile
*);
126 static int file_matches (char *, char **, int);
128 static void print_symbol_info (domain_enum
,
129 struct symtab
*, struct symbol
*, int, char *);
131 static void print_msymbol_info (struct minimal_symbol
*);
133 static void symtab_symbol_info (char *, domain_enum
, int);
135 void _initialize_symtab (void);
139 /* The single non-language-specific builtin type */
140 struct type
*builtin_type_error
;
142 /* Block in which the most recently searched-for symbol was found.
143 Might be better to make this a parameter to lookup_symbol and
146 const struct block
*block_found
;
148 /* Check for a symtab of a specific name; first in symtabs, then in
149 psymtabs. *If* there is no '/' in the name, a match after a '/'
150 in the symtab filename will also work. */
153 lookup_symtab (const char *name
)
156 struct partial_symtab
*ps
;
157 struct objfile
*objfile
;
158 char *real_path
= NULL
;
159 char *full_path
= NULL
;
161 /* Here we are interested in canonicalizing an absolute path, not
162 absolutizing a relative path. */
163 if (IS_ABSOLUTE_PATH (name
))
165 full_path
= xfullpath (name
);
166 make_cleanup (xfree
, full_path
);
167 real_path
= gdb_realpath (name
);
168 make_cleanup (xfree
, real_path
);
173 /* First, search for an exact match */
175 ALL_SYMTABS (objfile
, s
)
177 if (FILENAME_CMP (name
, s
->filename
) == 0)
182 /* If the user gave us an absolute path, try to find the file in
183 this symtab and use its absolute path. */
185 if (full_path
!= NULL
)
187 const char *fp
= symtab_to_fullname (s
);
188 if (fp
!= NULL
&& FILENAME_CMP (full_path
, fp
) == 0)
194 if (real_path
!= NULL
)
196 char *fullname
= symtab_to_fullname (s
);
197 if (fullname
!= NULL
)
199 char *rp
= gdb_realpath (fullname
);
200 make_cleanup (xfree
, rp
);
201 if (FILENAME_CMP (real_path
, rp
) == 0)
209 /* Now, search for a matching tail (only if name doesn't have any dirs) */
211 if (lbasename (name
) == name
)
212 ALL_SYMTABS (objfile
, s
)
214 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
218 /* Same search rules as above apply here, but now we look thru the
221 ps
= lookup_partial_symtab (name
);
226 error (_("Internal: readin %s pst for `%s' found when no symtab found."),
229 s
= PSYMTAB_TO_SYMTAB (ps
);
234 /* At this point, we have located the psymtab for this file, but
235 the conversion to a symtab has failed. This usually happens
236 when we are looking up an include file. In this case,
237 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
238 been created. So, we need to run through the symtabs again in
239 order to find the file.
240 XXX - This is a crock, and should be fixed inside of the the
241 symbol parsing routines. */
245 /* Lookup the partial symbol table of a source file named NAME.
246 *If* there is no '/' in the name, a match after a '/'
247 in the psymtab filename will also work. */
249 struct partial_symtab
*
250 lookup_partial_symtab (const char *name
)
252 struct partial_symtab
*pst
;
253 struct objfile
*objfile
;
254 char *full_path
= NULL
;
255 char *real_path
= NULL
;
257 /* Here we are interested in canonicalizing an absolute path, not
258 absolutizing a relative path. */
259 if (IS_ABSOLUTE_PATH (name
))
261 full_path
= xfullpath (name
);
262 make_cleanup (xfree
, full_path
);
263 real_path
= gdb_realpath (name
);
264 make_cleanup (xfree
, real_path
);
267 ALL_PSYMTABS (objfile
, pst
)
269 if (FILENAME_CMP (name
, pst
->filename
) == 0)
274 /* If the user gave us an absolute path, try to find the file in
275 this symtab and use its absolute path. */
276 if (full_path
!= NULL
)
278 psymtab_to_fullname (pst
);
279 if (pst
->fullname
!= NULL
280 && FILENAME_CMP (full_path
, pst
->fullname
) == 0)
286 if (real_path
!= NULL
)
289 psymtab_to_fullname (pst
);
290 if (pst
->fullname
!= NULL
)
292 rp
= gdb_realpath (pst
->fullname
);
293 make_cleanup (xfree
, rp
);
295 if (rp
!= NULL
&& FILENAME_CMP (real_path
, rp
) == 0)
302 /* Now, search for a matching tail (only if name doesn't have any dirs) */
304 if (lbasename (name
) == name
)
305 ALL_PSYMTABS (objfile
, pst
)
307 if (FILENAME_CMP (lbasename (pst
->filename
), name
) == 0)
314 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
315 full method name, which consist of the class name (from T), the unadorned
316 method name from METHOD_ID, and the signature for the specific overload,
317 specified by SIGNATURE_ID. Note that this function is g++ specific. */
320 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
322 int mangled_name_len
;
324 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
325 struct fn_field
*method
= &f
[signature_id
];
326 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
327 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
328 char *newname
= type_name_no_tag (type
);
330 /* Does the form of physname indicate that it is the full mangled name
331 of a constructor (not just the args)? */
332 int is_full_physname_constructor
;
335 int is_destructor
= is_destructor_name (physname
);
336 /* Need a new type prefix. */
337 char *const_prefix
= method
->is_const
? "C" : "";
338 char *volatile_prefix
= method
->is_volatile
? "V" : "";
340 int len
= (newname
== NULL
? 0 : strlen (newname
));
342 /* Nothing to do if physname already contains a fully mangled v3 abi name
343 or an operator name. */
344 if ((physname
[0] == '_' && physname
[1] == 'Z')
345 || is_operator_name (field_name
))
346 return xstrdup (physname
);
348 is_full_physname_constructor
= is_constructor_name (physname
);
351 is_full_physname_constructor
|| (newname
&& strcmp (field_name
, newname
) == 0);
354 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
356 if (is_destructor
|| is_full_physname_constructor
)
358 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
359 strcpy (mangled_name
, physname
);
365 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
367 else if (physname
[0] == 't' || physname
[0] == 'Q')
369 /* The physname for template and qualified methods already includes
371 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
377 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
379 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
380 + strlen (buf
) + len
+ strlen (physname
) + 1);
383 mangled_name
= (char *) xmalloc (mangled_name_len
);
385 mangled_name
[0] = '\0';
387 strcpy (mangled_name
, field_name
);
389 strcat (mangled_name
, buf
);
390 /* If the class doesn't have a name, i.e. newname NULL, then we just
391 mangle it using 0 for the length of the class. Thus it gets mangled
392 as something starting with `::' rather than `classname::'. */
394 strcat (mangled_name
, newname
);
396 strcat (mangled_name
, physname
);
397 return (mangled_name
);
401 /* Initialize the language dependent portion of a symbol
402 depending upon the language for the symbol. */
404 symbol_init_language_specific (struct general_symbol_info
*gsymbol
,
405 enum language language
)
407 gsymbol
->language
= language
;
408 if (gsymbol
->language
== language_cplus
409 || gsymbol
->language
== language_java
410 || gsymbol
->language
== language_objc
)
412 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
416 memset (&gsymbol
->language_specific
, 0,
417 sizeof (gsymbol
->language_specific
));
421 /* Functions to initialize a symbol's mangled name. */
423 /* Create the hash table used for demangled names. Each hash entry is
424 a pair of strings; one for the mangled name and one for the demangled
425 name. The entry is hashed via just the mangled name. */
428 create_demangled_names_hash (struct objfile
*objfile
)
430 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
431 The hash table code will round this up to the next prime number.
432 Choosing a much larger table size wastes memory, and saves only about
433 1% in symbol reading. */
435 objfile
->demangled_names_hash
= htab_create_alloc
436 (256, htab_hash_string
, (int (*) (const void *, const void *)) streq
,
437 NULL
, xcalloc
, xfree
);
440 /* Try to determine the demangled name for a symbol, based on the
441 language of that symbol. If the language is set to language_auto,
442 it will attempt to find any demangling algorithm that works and
443 then set the language appropriately. The returned name is allocated
444 by the demangler and should be xfree'd. */
447 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
450 char *demangled
= NULL
;
452 if (gsymbol
->language
== language_unknown
)
453 gsymbol
->language
= language_auto
;
455 if (gsymbol
->language
== language_objc
456 || gsymbol
->language
== language_auto
)
459 objc_demangle (mangled
, 0);
460 if (demangled
!= NULL
)
462 gsymbol
->language
= language_objc
;
466 if (gsymbol
->language
== language_cplus
467 || gsymbol
->language
== language_auto
)
470 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
471 if (demangled
!= NULL
)
473 gsymbol
->language
= language_cplus
;
477 if (gsymbol
->language
== language_java
)
480 cplus_demangle (mangled
,
481 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
482 if (demangled
!= NULL
)
484 gsymbol
->language
= language_java
;
491 /* Set both the mangled and demangled (if any) names for GSYMBOL based
492 on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
493 is used, and the memory comes from that objfile's objfile_obstack.
494 LINKAGE_NAME is copied, so the pointer can be discarded after
495 calling this function. */
497 /* We have to be careful when dealing with Java names: when we run
498 into a Java minimal symbol, we don't know it's a Java symbol, so it
499 gets demangled as a C++ name. This is unfortunate, but there's not
500 much we can do about it: but when demangling partial symbols and
501 regular symbols, we'd better not reuse the wrong demangled name.
502 (See PR gdb/1039.) We solve this by putting a distinctive prefix
503 on Java names when storing them in the hash table. */
505 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
506 don't mind the Java prefix so much: different languages have
507 different demangling requirements, so it's only natural that we
508 need to keep language data around in our demangling cache. But
509 it's not good that the minimal symbol has the wrong demangled name.
510 Unfortunately, I can't think of any easy solution to that
513 #define JAVA_PREFIX "##JAVA$$"
514 #define JAVA_PREFIX_LEN 8
517 symbol_set_names (struct general_symbol_info
*gsymbol
,
518 const char *linkage_name
, int len
, struct objfile
*objfile
)
521 /* A 0-terminated copy of the linkage name. */
522 const char *linkage_name_copy
;
523 /* A copy of the linkage name that might have a special Java prefix
524 added to it, for use when looking names up in the hash table. */
525 const char *lookup_name
;
526 /* The length of lookup_name. */
529 if (objfile
->demangled_names_hash
== NULL
)
530 create_demangled_names_hash (objfile
);
532 /* The stabs reader generally provides names that are not
533 NUL-terminated; most of the other readers don't do this, so we
534 can just use the given copy, unless we're in the Java case. */
535 if (gsymbol
->language
== language_java
)
538 lookup_len
= len
+ JAVA_PREFIX_LEN
;
540 alloc_name
= alloca (lookup_len
+ 1);
541 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
542 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
543 alloc_name
[lookup_len
] = '\0';
545 lookup_name
= alloc_name
;
546 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
548 else if (linkage_name
[len
] != '\0')
553 alloc_name
= alloca (lookup_len
+ 1);
554 memcpy (alloc_name
, linkage_name
, len
);
555 alloc_name
[lookup_len
] = '\0';
557 lookup_name
= alloc_name
;
558 linkage_name_copy
= alloc_name
;
563 lookup_name
= linkage_name
;
564 linkage_name_copy
= linkage_name
;
567 slot
= (char **) htab_find_slot (objfile
->demangled_names_hash
,
568 lookup_name
, INSERT
);
570 /* If this name is not in the hash table, add it. */
573 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
575 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
577 /* If there is a demangled name, place it right after the mangled name.
578 Otherwise, just place a second zero byte after the end of the mangled
580 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
581 lookup_len
+ demangled_len
+ 2);
582 memcpy (*slot
, lookup_name
, lookup_len
+ 1);
583 if (demangled_name
!= NULL
)
585 memcpy (*slot
+ lookup_len
+ 1, demangled_name
, demangled_len
+ 1);
586 xfree (demangled_name
);
589 (*slot
)[lookup_len
+ 1] = '\0';
592 gsymbol
->name
= *slot
+ lookup_len
- len
;
593 if ((*slot
)[lookup_len
+ 1] != '\0')
594 gsymbol
->language_specific
.cplus_specific
.demangled_name
595 = &(*slot
)[lookup_len
+ 1];
597 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
600 /* Initialize the demangled name of GSYMBOL if possible. Any required space
601 to store the name is obtained from the specified obstack. The function
602 symbol_set_names, above, should be used instead where possible for more
603 efficient memory usage. */
606 symbol_init_demangled_name (struct general_symbol_info
*gsymbol
,
607 struct obstack
*obstack
)
609 char *mangled
= gsymbol
->name
;
610 char *demangled
= NULL
;
612 demangled
= symbol_find_demangled_name (gsymbol
, mangled
);
613 if (gsymbol
->language
== language_cplus
614 || gsymbol
->language
== language_java
615 || gsymbol
->language
== language_objc
)
619 gsymbol
->language_specific
.cplus_specific
.demangled_name
620 = obsavestring (demangled
, strlen (demangled
), obstack
);
624 gsymbol
->language_specific
.cplus_specific
.demangled_name
= NULL
;
628 /* Unknown language; just clean up quietly. */
634 /* Return the source code name of a symbol. In languages where
635 demangling is necessary, this is the demangled name. */
638 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
640 switch (gsymbol
->language
)
645 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
646 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
649 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
650 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
652 return ada_decode_symbol (gsymbol
);
657 return gsymbol
->name
;
660 /* Return the demangled name for a symbol based on the language for
661 that symbol. If no demangled name exists, return NULL. */
663 symbol_demangled_name (struct general_symbol_info
*gsymbol
)
665 switch (gsymbol
->language
)
670 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
671 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
674 if (gsymbol
->language_specific
.cplus_specific
.demangled_name
!= NULL
)
675 return gsymbol
->language_specific
.cplus_specific
.demangled_name
;
677 return ada_decode_symbol (gsymbol
);
685 /* Return the search name of a symbol---generally the demangled or
686 linkage name of the symbol, depending on how it will be searched for.
687 If there is no distinct demangled name, then returns the same value
688 (same pointer) as SYMBOL_LINKAGE_NAME. */
690 symbol_search_name (const struct general_symbol_info
*gsymbol
)
692 if (gsymbol
->language
== language_ada
)
693 return gsymbol
->name
;
695 return symbol_natural_name (gsymbol
);
698 /* Initialize the structure fields to zero values. */
700 init_sal (struct symtab_and_line
*sal
)
710 /* Return 1 if the two sections are the same, or if they could
711 plausibly be copies of each other, one in an original object
712 file and another in a separated debug file. */
715 matching_bfd_sections (asection
*first
, asection
*second
)
719 /* If they're the same section, then they match. */
723 /* If either is NULL, give up. */
724 if (first
== NULL
|| second
== NULL
)
727 /* This doesn't apply to absolute symbols. */
728 if (first
->owner
== NULL
|| second
->owner
== NULL
)
731 /* If they're in the same object file, they must be different sections. */
732 if (first
->owner
== second
->owner
)
735 /* Check whether the two sections are potentially corresponding. They must
736 have the same size, address, and name. We can't compare section indexes,
737 which would be more reliable, because some sections may have been
739 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
742 /* In-memory addresses may start at a different offset, relativize them. */
743 if (bfd_get_section_vma (first
->owner
, first
)
744 - bfd_get_start_address (first
->owner
)
745 != bfd_get_section_vma (second
->owner
, second
)
746 - bfd_get_start_address (second
->owner
))
749 if (bfd_get_section_name (first
->owner
, first
) == NULL
750 || bfd_get_section_name (second
->owner
, second
) == NULL
751 || strcmp (bfd_get_section_name (first
->owner
, first
),
752 bfd_get_section_name (second
->owner
, second
)) != 0)
755 /* Otherwise check that they are in corresponding objfiles. */
758 if (obj
->obfd
== first
->owner
)
760 gdb_assert (obj
!= NULL
);
762 if (obj
->separate_debug_objfile
!= NULL
763 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
765 if (obj
->separate_debug_objfile_backlink
!= NULL
766 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
772 /* Find which partial symtab contains PC and SECTION. Return 0 if
773 none. We return the psymtab that contains a symbol whose address
774 exactly matches PC, or, if we cannot find an exact match, the
775 psymtab that contains a symbol whose address is closest to PC. */
776 struct partial_symtab
*
777 find_pc_sect_psymtab (CORE_ADDR pc
, asection
*section
)
779 struct partial_symtab
*pst
;
780 struct objfile
*objfile
;
781 struct minimal_symbol
*msymbol
;
783 /* If we know that this is not a text address, return failure. This is
784 necessary because we loop based on texthigh and textlow, which do
785 not include the data ranges. */
786 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
788 && (msymbol
->type
== mst_data
789 || msymbol
->type
== mst_bss
790 || msymbol
->type
== mst_abs
791 || msymbol
->type
== mst_file_data
792 || msymbol
->type
== mst_file_bss
))
795 ALL_PSYMTABS (objfile
, pst
)
797 if (pc
>= pst
->textlow
&& pc
< pst
->texthigh
)
799 struct partial_symtab
*tpst
;
800 struct partial_symtab
*best_pst
= pst
;
801 CORE_ADDR best_addr
= pst
->textlow
;
803 /* An objfile that has its functions reordered might have
804 many partial symbol tables containing the PC, but
805 we want the partial symbol table that contains the
806 function containing the PC. */
807 if (!(objfile
->flags
& OBJF_REORDERED
) &&
808 section
== 0) /* can't validate section this way */
814 /* The code range of partial symtabs sometimes overlap, so, in
815 the loop below, we need to check all partial symtabs and
816 find the one that fits better for the given PC address. We
817 select the partial symtab that contains a symbol whose
818 address is closest to the PC address. By closest we mean
819 that find_pc_sect_symbol returns the symbol with address
820 that is closest and still less than the given PC. */
821 for (tpst
= pst
; tpst
!= NULL
; tpst
= tpst
->next
)
823 if (pc
>= tpst
->textlow
&& pc
< tpst
->texthigh
)
825 struct partial_symbol
*p
;
828 /* NOTE: This assumes that every psymbol has a
829 corresponding msymbol, which is not necessarily
830 true; the debug info might be much richer than the
831 object's symbol table. */
832 p
= find_pc_sect_psymbol (tpst
, pc
, section
);
834 && SYMBOL_VALUE_ADDRESS (p
)
835 == SYMBOL_VALUE_ADDRESS (msymbol
))
838 /* Also accept the textlow value of a psymtab as a
839 "symbol", to provide some support for partial
840 symbol tables with line information but no debug
841 symbols (e.g. those produced by an assembler). */
843 this_addr
= SYMBOL_VALUE_ADDRESS (p
);
845 this_addr
= tpst
->textlow
;
847 /* Check whether it is closer than our current
848 BEST_ADDR. Since this symbol address is
849 necessarily lower or equal to PC, the symbol closer
850 to PC is the symbol which address is the highest.
851 This way we return the psymtab which contains such
852 best match symbol. This can help in cases where the
853 symbol information/debuginfo is not complete, like
854 for instance on IRIX6 with gcc, where no debug info
855 is emitted for statics. (See also the nodebug.exp
857 if (this_addr
> best_addr
)
859 best_addr
= this_addr
;
870 /* Find which partial symtab contains PC. Return 0 if none.
871 Backward compatibility, no section */
873 struct partial_symtab
*
874 find_pc_psymtab (CORE_ADDR pc
)
876 return find_pc_sect_psymtab (pc
, find_pc_mapped_section (pc
));
879 /* Find which partial symbol within a psymtab matches PC and SECTION.
880 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
882 struct partial_symbol
*
883 find_pc_sect_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
,
886 struct partial_symbol
*best
= NULL
, *p
, **pp
;
890 psymtab
= find_pc_sect_psymtab (pc
, section
);
894 /* Cope with programs that start at address 0 */
895 best_pc
= (psymtab
->textlow
!= 0) ? psymtab
->textlow
- 1 : 0;
897 /* Search the global symbols as well as the static symbols, so that
898 find_pc_partial_function doesn't use a minimal symbol and thus
899 cache a bad endaddr. */
900 for (pp
= psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
;
901 (pp
- (psymtab
->objfile
->global_psymbols
.list
+ psymtab
->globals_offset
)
902 < psymtab
->n_global_syms
);
906 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
907 && SYMBOL_CLASS (p
) == LOC_BLOCK
908 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
909 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
910 || (psymtab
->textlow
== 0
911 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
913 if (section
) /* match on a specific section */
915 fixup_psymbol_section (p
, psymtab
->objfile
);
916 if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p
), section
))
919 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
924 for (pp
= psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
;
925 (pp
- (psymtab
->objfile
->static_psymbols
.list
+ psymtab
->statics_offset
)
926 < psymtab
->n_static_syms
);
930 if (SYMBOL_DOMAIN (p
) == VAR_DOMAIN
931 && SYMBOL_CLASS (p
) == LOC_BLOCK
932 && pc
>= SYMBOL_VALUE_ADDRESS (p
)
933 && (SYMBOL_VALUE_ADDRESS (p
) > best_pc
934 || (psymtab
->textlow
== 0
935 && best_pc
== 0 && SYMBOL_VALUE_ADDRESS (p
) == 0)))
937 if (section
) /* match on a specific section */
939 fixup_psymbol_section (p
, psymtab
->objfile
);
940 if (!matching_bfd_sections (SYMBOL_BFD_SECTION (p
), section
))
943 best_pc
= SYMBOL_VALUE_ADDRESS (p
);
951 /* Find which partial symbol within a psymtab matches PC. Return 0 if none.
952 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
954 struct partial_symbol
*
955 find_pc_psymbol (struct partial_symtab
*psymtab
, CORE_ADDR pc
)
957 return find_pc_sect_psymbol (psymtab
, pc
, find_pc_mapped_section (pc
));
960 /* Debug symbols usually don't have section information. We need to dig that
961 out of the minimal symbols and stash that in the debug symbol. */
964 fixup_section (struct general_symbol_info
*ginfo
, struct objfile
*objfile
)
966 struct minimal_symbol
*msym
;
967 msym
= lookup_minimal_symbol (ginfo
->name
, NULL
, objfile
);
971 ginfo
->bfd_section
= SYMBOL_BFD_SECTION (msym
);
972 ginfo
->section
= SYMBOL_SECTION (msym
);
976 /* Static, function-local variables do appear in the linker
977 (minimal) symbols, but are frequently given names that won't
978 be found via lookup_minimal_symbol(). E.g., it has been
979 observed in frv-uclinux (ELF) executables that a static,
980 function-local variable named "foo" might appear in the
981 linker symbols as "foo.6" or "foo.3". Thus, there is no
982 point in attempting to extend the lookup-by-name mechanism to
983 handle this case due to the fact that there can be multiple
986 So, instead, search the section table when lookup by name has
987 failed. The ``addr'' and ``endaddr'' fields may have already
988 been relocated. If so, the relocation offset (i.e. the
989 ANOFFSET value) needs to be subtracted from these values when
990 performing the comparison. We unconditionally subtract it,
991 because, when no relocation has been performed, the ANOFFSET
992 value will simply be zero.
994 The address of the symbol whose section we're fixing up HAS
995 NOT BEEN adjusted (relocated) yet. It can't have been since
996 the section isn't yet known and knowing the section is
997 necessary in order to add the correct relocation value. In
998 other words, we wouldn't even be in this function (attempting
999 to compute the section) if it were already known.
1001 Note that it is possible to search the minimal symbols
1002 (subtracting the relocation value if necessary) to find the
1003 matching minimal symbol, but this is overkill and much less
1004 efficient. It is not necessary to find the matching minimal
1005 symbol, only its section.
1007 Note that this technique (of doing a section table search)
1008 can fail when unrelocated section addresses overlap. For
1009 this reason, we still attempt a lookup by name prior to doing
1010 a search of the section table. */
1013 struct obj_section
*s
;
1015 addr
= ginfo
->value
.address
;
1017 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1019 int idx
= s
->the_bfd_section
->index
;
1020 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1022 if (s
->addr
- offset
<= addr
&& addr
< s
->endaddr
- offset
)
1024 ginfo
->bfd_section
= s
->the_bfd_section
;
1025 ginfo
->section
= idx
;
1033 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1038 if (SYMBOL_BFD_SECTION (sym
))
1041 fixup_section (&sym
->ginfo
, objfile
);
1046 struct partial_symbol
*
1047 fixup_psymbol_section (struct partial_symbol
*psym
, struct objfile
*objfile
)
1052 if (SYMBOL_BFD_SECTION (psym
))
1055 fixup_section (&psym
->ginfo
, objfile
);
1060 /* Find the definition for a specified symbol name NAME
1061 in domain DOMAIN, visible from lexical block BLOCK.
1062 Returns the struct symbol pointer, or zero if no symbol is found.
1063 If SYMTAB is non-NULL, store the symbol table in which the
1064 symbol was found there, or NULL if not found.
1065 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1066 NAME is a field of the current implied argument `this'. If so set
1067 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1068 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1069 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1071 /* This function has a bunch of loops in it and it would seem to be
1072 attractive to put in some QUIT's (though I'm not really sure
1073 whether it can run long enough to be really important). But there
1074 are a few calls for which it would appear to be bad news to quit
1075 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
1076 that there is C++ code below which can error(), but that probably
1077 doesn't affect these calls since they are looking for a known
1078 variable and thus can probably assume it will never hit the C++
1082 lookup_symbol (const char *name
, const struct block
*block
,
1083 const domain_enum domain
, int *is_a_field_of_this
,
1084 struct symtab
**symtab
)
1086 char *demangled_name
= NULL
;
1087 const char *modified_name
= NULL
;
1088 const char *mangled_name
= NULL
;
1089 int needtofreename
= 0;
1090 struct symbol
*returnval
;
1092 modified_name
= name
;
1094 /* If we are using C++ or Java, demangle the name before doing a lookup, so
1095 we can always binary search. */
1096 if (current_language
->la_language
== language_cplus
)
1098 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1101 mangled_name
= name
;
1102 modified_name
= demangled_name
;
1106 else if (current_language
->la_language
== language_java
)
1108 demangled_name
= cplus_demangle (name
,
1109 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1112 mangled_name
= name
;
1113 modified_name
= demangled_name
;
1118 if (case_sensitivity
== case_sensitive_off
)
1123 len
= strlen (name
);
1124 copy
= (char *) alloca (len
+ 1);
1125 for (i
= 0; i
< len
; i
++)
1126 copy
[i
] = tolower (name
[i
]);
1128 modified_name
= copy
;
1131 returnval
= lookup_symbol_aux (modified_name
, mangled_name
, block
,
1132 domain
, is_a_field_of_this
, symtab
);
1134 xfree (demangled_name
);
1139 /* Behave like lookup_symbol_aux except that NAME is the natural name
1140 of the symbol that we're looking for and, if LINKAGE_NAME is
1141 non-NULL, ensure that the symbol's linkage name matches as
1144 static struct symbol
*
1145 lookup_symbol_aux (const char *name
, const char *linkage_name
,
1146 const struct block
*block
, const domain_enum domain
,
1147 int *is_a_field_of_this
, struct symtab
**symtab
)
1151 /* Make sure we do something sensible with is_a_field_of_this, since
1152 the callers that set this parameter to some non-null value will
1153 certainly use it later and expect it to be either 0 or 1.
1154 If we don't set it, the contents of is_a_field_of_this are
1156 if (is_a_field_of_this
!= NULL
)
1157 *is_a_field_of_this
= 0;
1159 /* Search specified block and its superiors. Don't search
1160 STATIC_BLOCK or GLOBAL_BLOCK. */
1162 sym
= lookup_symbol_aux_local (name
, linkage_name
, block
, domain
,
1167 /* If requested to do so by the caller and if appropriate for the
1168 current language, check to see if NAME is a field of `this'. */
1170 if (current_language
->la_value_of_this
!= NULL
1171 && is_a_field_of_this
!= NULL
)
1173 struct value
*v
= current_language
->la_value_of_this (0);
1175 if (v
&& check_field (v
, name
))
1177 *is_a_field_of_this
= 1;
1184 /* Now do whatever is appropriate for the current language to look
1185 up static and global variables. */
1187 sym
= current_language
->la_lookup_symbol_nonlocal (name
, linkage_name
,
1193 /* Now search all static file-level symbols. Not strictly correct,
1194 but more useful than an error. Do the symtabs first, then check
1195 the psymtabs. If a psymtab indicates the existence of the
1196 desired name as a file-level static, then do psymtab-to-symtab
1197 conversion on the fly and return the found symbol. */
1199 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, linkage_name
,
1204 sym
= lookup_symbol_aux_psymtabs (STATIC_BLOCK
, name
, linkage_name
,
1214 /* Check to see if the symbol is defined in BLOCK or its superiors.
1215 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1217 static struct symbol
*
1218 lookup_symbol_aux_local (const char *name
, const char *linkage_name
,
1219 const struct block
*block
,
1220 const domain_enum domain
,
1221 struct symtab
**symtab
)
1224 const struct block
*static_block
= block_static_block (block
);
1226 /* Check if either no block is specified or it's a global block. */
1228 if (static_block
== NULL
)
1231 while (block
!= static_block
)
1233 sym
= lookup_symbol_aux_block (name
, linkage_name
, block
, domain
,
1237 block
= BLOCK_SUPERBLOCK (block
);
1240 /* We've reached the static block without finding a result. */
1245 /* Look up a symbol in a block; if found, locate its symtab, fixup the
1246 symbol, and set block_found appropriately. */
1249 lookup_symbol_aux_block (const char *name
, const char *linkage_name
,
1250 const struct block
*block
,
1251 const domain_enum domain
,
1252 struct symtab
**symtab
)
1255 struct objfile
*objfile
= NULL
;
1256 struct blockvector
*bv
;
1258 struct symtab
*s
= NULL
;
1260 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1263 block_found
= block
;
1266 /* Search the list of symtabs for one which contains the
1267 address of the start of this block. */
1268 ALL_SYMTABS (objfile
, s
)
1270 bv
= BLOCKVECTOR (s
);
1271 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1272 if (BLOCK_START (b
) <= BLOCK_START (block
)
1273 && BLOCK_END (b
) > BLOCK_START (block
))
1280 return fixup_symbol_section (sym
, objfile
);
1286 /* Check to see if the symbol is defined in one of the symtabs.
1287 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1288 depending on whether or not we want to search global symbols or
1291 static struct symbol
*
1292 lookup_symbol_aux_symtabs (int block_index
,
1293 const char *name
, const char *linkage_name
,
1294 const domain_enum domain
,
1295 struct symtab
**symtab
)
1298 struct objfile
*objfile
;
1299 struct blockvector
*bv
;
1300 const struct block
*block
;
1303 ALL_SYMTABS (objfile
, s
)
1305 bv
= BLOCKVECTOR (s
);
1306 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1307 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1310 block_found
= block
;
1313 return fixup_symbol_section (sym
, objfile
);
1320 /* Check to see if the symbol is defined in one of the partial
1321 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or
1322 STATIC_BLOCK, depending on whether or not we want to search global
1323 symbols or static symbols. */
1325 static struct symbol
*
1326 lookup_symbol_aux_psymtabs (int block_index
, const char *name
,
1327 const char *linkage_name
,
1328 const domain_enum domain
,
1329 struct symtab
**symtab
)
1332 struct objfile
*objfile
;
1333 struct blockvector
*bv
;
1334 const struct block
*block
;
1335 struct partial_symtab
*ps
;
1337 const int psymtab_index
= (block_index
== GLOBAL_BLOCK
? 1 : 0);
1339 ALL_PSYMTABS (objfile
, ps
)
1342 && lookup_partial_symbol (ps
, name
, linkage_name
,
1343 psymtab_index
, domain
))
1345 s
= PSYMTAB_TO_SYMTAB (ps
);
1346 bv
= BLOCKVECTOR (s
);
1347 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1348 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1351 /* This shouldn't be necessary, but as a last resort try
1352 looking in the statics even though the psymtab claimed
1353 the symbol was global, or vice-versa. It's possible
1354 that the psymtab gets it wrong in some cases. */
1356 /* FIXME: carlton/2002-09-30: Should we really do that?
1357 If that happens, isn't it likely to be a GDB error, in
1358 which case we should fix the GDB error rather than
1359 silently dealing with it here? So I'd vote for
1360 removing the check for the symbol in the other
1362 block
= BLOCKVECTOR_BLOCK (bv
,
1363 block_index
== GLOBAL_BLOCK
?
1364 STATIC_BLOCK
: GLOBAL_BLOCK
);
1365 sym
= lookup_block_symbol (block
, name
, linkage_name
, domain
);
1367 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>)."),
1368 block_index
== GLOBAL_BLOCK
? "global" : "static",
1369 name
, ps
->filename
, name
, name
);
1373 return fixup_symbol_section (sym
, objfile
);
1381 /* Check for the possibility of the symbol being a function or a
1382 mangled variable that is stored in one of the minimal symbol
1383 tables. Eventually, all global symbols might be resolved in this
1386 /* NOTE: carlton/2002-12-05: At one point, this function was part of
1387 lookup_symbol_aux, and what are now 'return' statements within
1388 lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
1389 sym was NULL. As far as I can tell, this was basically accidental;
1390 it didn't happen every time that msymbol was non-NULL, but only if
1391 some additional conditions held as well, and it caused problems
1392 with HP-generated symbol tables. */
1394 /* NOTE: carlton/2003-05-14: This function was once used as part of
1395 lookup_symbol. It is currently unnecessary for correctness
1396 reasons, however, and using it doesn't seem to be any faster than
1397 using lookup_symbol_aux_psymtabs, so I'm commenting it out. */
1399 static struct symbol
*
1400 lookup_symbol_aux_minsyms (const char *name
,
1401 const char *linkage_name
,
1402 const domain_enum domain
,
1403 int *is_a_field_of_this
,
1404 struct symtab
**symtab
)
1407 struct blockvector
*bv
;
1408 const struct block
*block
;
1409 struct minimal_symbol
*msymbol
;
1412 if (domain
== VAR_DOMAIN
)
1414 msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
1416 if (msymbol
!= NULL
)
1418 /* OK, we found a minimal symbol in spite of not finding any
1419 symbol. There are various possible explanations for
1420 this. One possibility is the symbol exists in code not
1421 compiled -g. Another possibility is that the 'psymtab'
1422 isn't doing its job. A third possibility, related to #2,
1423 is that we were confused by name-mangling. For instance,
1424 maybe the psymtab isn't doing its job because it only
1425 know about demangled names, but we were given a mangled
1428 /* We first use the address in the msymbol to try to locate
1429 the appropriate symtab. Note that find_pc_sect_symtab()
1430 has a side-effect of doing psymtab-to-symtab expansion,
1431 for the found symtab. */
1432 s
= find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol
),
1433 SYMBOL_BFD_SECTION (msymbol
));
1436 /* This is a function which has a symtab for its address. */
1437 bv
= BLOCKVECTOR (s
);
1438 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1440 /* This call used to pass `SYMBOL_LINKAGE_NAME (msymbol)' as the
1441 `name' argument to lookup_block_symbol. But the name
1442 of a minimal symbol is always mangled, so that seems
1443 to be clearly the wrong thing to pass as the
1446 lookup_block_symbol (block
, name
, linkage_name
, domain
);
1447 /* We kept static functions in minimal symbol table as well as
1448 in static scope. We want to find them in the symbol table. */
1451 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1452 sym
= lookup_block_symbol (block
, name
,
1453 linkage_name
, domain
);
1456 /* NOTE: carlton/2002-12-04: The following comment was
1457 taken from a time when two versions of this function
1458 were part of the body of lookup_symbol_aux: this
1459 comment was taken from the version of the function
1460 that was #ifdef HPUXHPPA, and the comment was right
1461 before the 'return NULL' part of lookup_symbol_aux.
1462 (Hence the "Fall through and return 0" comment.)
1463 Elena did some digging into the situation for
1464 Fortran, and she reports:
1466 "I asked around (thanks to Jeff Knaggs), and I think
1467 the story for Fortran goes like this:
1469 "Apparently, in older Fortrans, '_' was not part of
1470 the user namespace. g77 attached a final '_' to
1471 procedure names as the exported symbols for linkage
1472 (foo_) , but the symbols went in the debug info just
1473 like 'foo'. The rationale behind this is not
1474 completely clear, and maybe it was done to other
1475 symbols as well, not just procedures." */
1477 /* If we get here with sym == 0, the symbol was
1478 found in the minimal symbol table
1479 but not in the symtab.
1480 Fall through and return 0 to use the msymbol
1481 definition of "foo_".
1482 (Note that outer code generally follows up a call
1483 to this routine with a call to lookup_minimal_symbol(),
1484 so a 0 return means we'll just flow into that other routine).
1486 This happens for Fortran "foo_" symbols,
1487 which are "foo" in the symtab.
1489 This can also happen if "asm" is used to make a
1490 regular symbol but not a debugging symbol, e.g.
1491 asm(".globl _main");
1495 if (symtab
!= NULL
&& sym
!= NULL
)
1497 return fixup_symbol_section (sym
, s
->objfile
);
1506 /* A default version of lookup_symbol_nonlocal for use by languages
1507 that can't think of anything better to do. This implements the C
1511 basic_lookup_symbol_nonlocal (const char *name
,
1512 const char *linkage_name
,
1513 const struct block
*block
,
1514 const domain_enum domain
,
1515 struct symtab
**symtab
)
1519 /* NOTE: carlton/2003-05-19: The comments below were written when
1520 this (or what turned into this) was part of lookup_symbol_aux;
1521 I'm much less worried about these questions now, since these
1522 decisions have turned out well, but I leave these comments here
1525 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1526 not it would be appropriate to search the current global block
1527 here as well. (That's what this code used to do before the
1528 is_a_field_of_this check was moved up.) On the one hand, it's
1529 redundant with the lookup_symbol_aux_symtabs search that happens
1530 next. On the other hand, if decode_line_1 is passed an argument
1531 like filename:var, then the user presumably wants 'var' to be
1532 searched for in filename. On the third hand, there shouldn't be
1533 multiple global variables all of which are named 'var', and it's
1534 not like decode_line_1 has ever restricted its search to only
1535 global variables in a single filename. All in all, only
1536 searching the static block here seems best: it's correct and it's
1539 /* NOTE: carlton/2002-12-05: There's also a possible performance
1540 issue here: if you usually search for global symbols in the
1541 current file, then it would be slightly better to search the
1542 current global block before searching all the symtabs. But there
1543 are other factors that have a much greater effect on performance
1544 than that one, so I don't think we should worry about that for
1547 sym
= lookup_symbol_static (name
, linkage_name
, block
, domain
, symtab
);
1551 return lookup_symbol_global (name
, linkage_name
, domain
, symtab
);
1554 /* Lookup a symbol in the static block associated to BLOCK, if there
1555 is one; do nothing if BLOCK is NULL or a global block. */
1558 lookup_symbol_static (const char *name
,
1559 const char *linkage_name
,
1560 const struct block
*block
,
1561 const domain_enum domain
,
1562 struct symtab
**symtab
)
1564 const struct block
*static_block
= block_static_block (block
);
1566 if (static_block
!= NULL
)
1567 return lookup_symbol_aux_block (name
, linkage_name
, static_block
,
1573 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1577 lookup_symbol_global (const char *name
,
1578 const char *linkage_name
,
1579 const domain_enum domain
,
1580 struct symtab
**symtab
)
1584 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, linkage_name
,
1589 return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK
, name
, linkage_name
,
1593 /* Look, in partial_symtab PST, for symbol whose natural name is NAME.
1594 If LINKAGE_NAME is non-NULL, check in addition that the symbol's
1595 linkage name matches it. Check the global symbols if GLOBAL, the
1596 static symbols if not */
1598 struct partial_symbol
*
1599 lookup_partial_symbol (struct partial_symtab
*pst
, const char *name
,
1600 const char *linkage_name
, int global
,
1603 struct partial_symbol
*temp
;
1604 struct partial_symbol
**start
, **psym
;
1605 struct partial_symbol
**top
, **real_top
, **bottom
, **center
;
1606 int length
= (global
? pst
->n_global_syms
: pst
->n_static_syms
);
1607 int do_linear_search
= 1;
1614 pst
->objfile
->global_psymbols
.list
+ pst
->globals_offset
:
1615 pst
->objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1617 if (global
) /* This means we can use a binary search. */
1619 do_linear_search
= 0;
1621 /* Binary search. This search is guaranteed to end with center
1622 pointing at the earliest partial symbol whose name might be
1623 correct. At that point *all* partial symbols with an
1624 appropriate name will be checked against the correct
1628 top
= start
+ length
- 1;
1630 while (top
> bottom
)
1632 center
= bottom
+ (top
- bottom
) / 2;
1633 if (!(center
< top
))
1634 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1635 if (!do_linear_search
1636 && (SYMBOL_LANGUAGE (*center
) == language_java
))
1638 do_linear_search
= 1;
1640 if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center
), name
) >= 0)
1646 bottom
= center
+ 1;
1649 if (!(top
== bottom
))
1650 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1652 while (top
<= real_top
1653 && (linkage_name
!= NULL
1654 ? strcmp (SYMBOL_LINKAGE_NAME (*top
), linkage_name
) == 0
1655 : SYMBOL_MATCHES_SEARCH_NAME (*top
,name
)))
1657 if (SYMBOL_DOMAIN (*top
) == domain
)
1665 /* Can't use a binary search or else we found during the binary search that
1666 we should also do a linear search. */
1668 if (do_linear_search
)
1670 for (psym
= start
; psym
< start
+ length
; psym
++)
1672 if (domain
== SYMBOL_DOMAIN (*psym
))
1674 if (linkage_name
!= NULL
1675 ? strcmp (SYMBOL_LINKAGE_NAME (*psym
), linkage_name
) == 0
1676 : SYMBOL_MATCHES_SEARCH_NAME (*psym
, name
))
1687 /* Look up a type named NAME in the struct_domain. The type returned
1688 must not be opaque -- i.e., must have at least one field
1692 lookup_transparent_type (const char *name
)
1694 return current_language
->la_lookup_transparent_type (name
);
1697 /* The standard implementation of lookup_transparent_type. This code
1698 was modeled on lookup_symbol -- the parts not relevant to looking
1699 up types were just left out. In particular it's assumed here that
1700 types are available in struct_domain and only at file-static or
1704 basic_lookup_transparent_type (const char *name
)
1707 struct symtab
*s
= NULL
;
1708 struct partial_symtab
*ps
;
1709 struct blockvector
*bv
;
1710 struct objfile
*objfile
;
1711 struct block
*block
;
1713 /* Now search all the global symbols. Do the symtab's first, then
1714 check the psymtab's. If a psymtab indicates the existence
1715 of the desired name as a global, then do psymtab-to-symtab
1716 conversion on the fly and return the found symbol. */
1718 ALL_SYMTABS (objfile
, s
)
1720 bv
= BLOCKVECTOR (s
);
1721 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1722 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1723 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1725 return SYMBOL_TYPE (sym
);
1729 ALL_PSYMTABS (objfile
, ps
)
1731 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
,
1734 s
= PSYMTAB_TO_SYMTAB (ps
);
1735 bv
= BLOCKVECTOR (s
);
1736 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1737 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1740 /* This shouldn't be necessary, but as a last resort
1741 * try looking in the statics even though the psymtab
1742 * claimed the symbol was global. It's possible that
1743 * the psymtab gets it wrong in some cases.
1745 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1746 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1748 error (_("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1749 %s may be an inlined function, or may be a template function\n\
1750 (if a template, try specifying an instantiation: %s<type>)."),
1751 name
, ps
->filename
, name
, name
);
1753 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1754 return SYMBOL_TYPE (sym
);
1758 /* Now search the static file-level symbols.
1759 Not strictly correct, but more useful than an error.
1760 Do the symtab's first, then
1761 check the psymtab's. If a psymtab indicates the existence
1762 of the desired name as a file-level static, then do psymtab-to-symtab
1763 conversion on the fly and return the found symbol.
1766 ALL_SYMTABS (objfile
, s
)
1768 bv
= BLOCKVECTOR (s
);
1769 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1770 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1771 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1773 return SYMBOL_TYPE (sym
);
1777 ALL_PSYMTABS (objfile
, ps
)
1779 if (!ps
->readin
&& lookup_partial_symbol (ps
, name
, NULL
, 0, STRUCT_DOMAIN
))
1781 s
= PSYMTAB_TO_SYMTAB (ps
);
1782 bv
= BLOCKVECTOR (s
);
1783 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1784 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1787 /* This shouldn't be necessary, but as a last resort
1788 * try looking in the globals even though the psymtab
1789 * claimed the symbol was static. It's possible that
1790 * the psymtab gets it wrong in some cases.
1792 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1793 sym
= lookup_block_symbol (block
, name
, NULL
, STRUCT_DOMAIN
);
1795 error (_("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
1796 %s may be an inlined function, or may be a template function\n\
1797 (if a template, try specifying an instantiation: %s<type>)."),
1798 name
, ps
->filename
, name
, name
);
1800 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1801 return SYMBOL_TYPE (sym
);
1804 return (struct type
*) 0;
1808 /* Find the psymtab containing main(). */
1809 /* FIXME: What about languages without main() or specially linked
1810 executables that have no main() ? */
1812 struct partial_symtab
*
1813 find_main_psymtab (void)
1815 struct partial_symtab
*pst
;
1816 struct objfile
*objfile
;
1818 ALL_PSYMTABS (objfile
, pst
)
1820 if (lookup_partial_symbol (pst
, main_name (), NULL
, 1, VAR_DOMAIN
))
1828 /* Search BLOCK for symbol NAME in DOMAIN.
1830 Note that if NAME is the demangled form of a C++ symbol, we will fail
1831 to find a match during the binary search of the non-encoded names, but
1832 for now we don't worry about the slight inefficiency of looking for
1833 a match we'll never find, since it will go pretty quick. Once the
1834 binary search terminates, we drop through and do a straight linear
1835 search on the symbols. Each symbol which is marked as being a ObjC/C++
1836 symbol (language_cplus or language_objc set) has both the encoded and
1837 non-encoded names tested for a match.
1839 If LINKAGE_NAME is non-NULL, verify that any symbol we find has this
1840 particular mangled name.
1844 lookup_block_symbol (const struct block
*block
, const char *name
,
1845 const char *linkage_name
,
1846 const domain_enum domain
)
1848 struct dict_iterator iter
;
1851 if (!BLOCK_FUNCTION (block
))
1853 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1855 sym
= dict_iter_name_next (name
, &iter
))
1857 if (SYMBOL_DOMAIN (sym
) == domain
1858 && (linkage_name
!= NULL
1859 ? strcmp (SYMBOL_LINKAGE_NAME (sym
), linkage_name
) == 0 : 1))
1866 /* Note that parameter symbols do not always show up last in the
1867 list; this loop makes sure to take anything else other than
1868 parameter symbols first; it only uses parameter symbols as a
1869 last resort. Note that this only takes up extra computation
1872 struct symbol
*sym_found
= NULL
;
1874 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1876 sym
= dict_iter_name_next (name
, &iter
))
1878 if (SYMBOL_DOMAIN (sym
) == domain
1879 && (linkage_name
!= NULL
1880 ? strcmp (SYMBOL_LINKAGE_NAME (sym
), linkage_name
) == 0 : 1))
1883 if (SYMBOL_CLASS (sym
) != LOC_ARG
&&
1884 SYMBOL_CLASS (sym
) != LOC_LOCAL_ARG
&&
1885 SYMBOL_CLASS (sym
) != LOC_REF_ARG
&&
1886 SYMBOL_CLASS (sym
) != LOC_REGPARM
&&
1887 SYMBOL_CLASS (sym
) != LOC_REGPARM_ADDR
&&
1888 SYMBOL_CLASS (sym
) != LOC_BASEREG_ARG
&&
1889 SYMBOL_CLASS (sym
) != LOC_COMPUTED_ARG
)
1895 return (sym_found
); /* Will be NULL if not found. */
1899 /* Find the symtab associated with PC and SECTION. Look through the
1900 psymtabs and read in another symtab if necessary. */
1903 find_pc_sect_symtab (CORE_ADDR pc
, asection
*section
)
1906 struct blockvector
*bv
;
1907 struct symtab
*s
= NULL
;
1908 struct symtab
*best_s
= NULL
;
1909 struct partial_symtab
*ps
;
1910 struct objfile
*objfile
;
1911 CORE_ADDR distance
= 0;
1912 struct minimal_symbol
*msymbol
;
1914 /* If we know that this is not a text address, return failure. This is
1915 necessary because we loop based on the block's high and low code
1916 addresses, which do not include the data ranges, and because
1917 we call find_pc_sect_psymtab which has a similar restriction based
1918 on the partial_symtab's texthigh and textlow. */
1919 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1921 && (msymbol
->type
== mst_data
1922 || msymbol
->type
== mst_bss
1923 || msymbol
->type
== mst_abs
1924 || msymbol
->type
== mst_file_data
1925 || msymbol
->type
== mst_file_bss
))
1928 /* Search all symtabs for the one whose file contains our address, and which
1929 is the smallest of all the ones containing the address. This is designed
1930 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1931 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1932 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1934 This happens for native ecoff format, where code from included files
1935 gets its own symtab. The symtab for the included file should have
1936 been read in already via the dependency mechanism.
1937 It might be swifter to create several symtabs with the same name
1938 like xcoff does (I'm not sure).
1940 It also happens for objfiles that have their functions reordered.
1941 For these, the symtab we are looking for is not necessarily read in. */
1943 ALL_SYMTABS (objfile
, s
)
1945 bv
= BLOCKVECTOR (s
);
1946 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1948 if (BLOCK_START (b
) <= pc
1949 && BLOCK_END (b
) > pc
1951 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1953 /* For an objfile that has its functions reordered,
1954 find_pc_psymtab will find the proper partial symbol table
1955 and we simply return its corresponding symtab. */
1956 /* In order to better support objfiles that contain both
1957 stabs and coff debugging info, we continue on if a psymtab
1959 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->psymtabs
)
1961 ps
= find_pc_sect_psymtab (pc
, section
);
1963 return PSYMTAB_TO_SYMTAB (ps
);
1967 struct dict_iterator iter
;
1968 struct symbol
*sym
= NULL
;
1970 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1972 fixup_symbol_section (sym
, objfile
);
1973 if (matching_bfd_sections (SYMBOL_BFD_SECTION (sym
), section
))
1977 continue; /* no symbol in this symtab matches section */
1979 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1988 ps
= find_pc_sect_psymtab (pc
, section
);
1992 /* Might want to error() here (in case symtab is corrupt and
1993 will cause a core dump), but maybe we can successfully
1994 continue, so let's not. */
1996 (Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n"),
1998 s
= PSYMTAB_TO_SYMTAB (ps
);
2003 /* Find the symtab associated with PC. Look through the psymtabs and
2004 read in another symtab if necessary. Backward compatibility, no section */
2007 find_pc_symtab (CORE_ADDR pc
)
2009 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
2013 /* Find the source file and line number for a given PC value and SECTION.
2014 Return a structure containing a symtab pointer, a line number,
2015 and a pc range for the entire source line.
2016 The value's .pc field is NOT the specified pc.
2017 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2018 use the line that ends there. Otherwise, in that case, the line
2019 that begins there is used. */
2021 /* The big complication here is that a line may start in one file, and end just
2022 before the start of another file. This usually occurs when you #include
2023 code in the middle of a subroutine. To properly find the end of a line's PC
2024 range, we must search all symtabs associated with this compilation unit, and
2025 find the one whose first PC is closer than that of the next line in this
2028 /* If it's worth the effort, we could be using a binary search. */
2030 struct symtab_and_line
2031 find_pc_sect_line (CORE_ADDR pc
, struct bfd_section
*section
, int notcurrent
)
2034 struct linetable
*l
;
2037 struct linetable_entry
*item
;
2038 struct symtab_and_line val
;
2039 struct blockvector
*bv
;
2040 struct minimal_symbol
*msymbol
;
2041 struct minimal_symbol
*mfunsym
;
2043 /* Info on best line seen so far, and where it starts, and its file. */
2045 struct linetable_entry
*best
= NULL
;
2046 CORE_ADDR best_end
= 0;
2047 struct symtab
*best_symtab
= 0;
2049 /* Store here the first line number
2050 of a file which contains the line at the smallest pc after PC.
2051 If we don't find a line whose range contains PC,
2052 we will use a line one less than this,
2053 with a range from the start of that file to the first line's pc. */
2054 struct linetable_entry
*alt
= NULL
;
2055 struct symtab
*alt_symtab
= 0;
2057 /* Info on best line seen in this file. */
2059 struct linetable_entry
*prev
;
2061 /* If this pc is not from the current frame,
2062 it is the address of the end of a call instruction.
2063 Quite likely that is the start of the following statement.
2064 But what we want is the statement containing the instruction.
2065 Fudge the pc to make sure we get that. */
2067 init_sal (&val
); /* initialize to zeroes */
2069 /* It's tempting to assume that, if we can't find debugging info for
2070 any function enclosing PC, that we shouldn't search for line
2071 number info, either. However, GAS can emit line number info for
2072 assembly files --- very helpful when debugging hand-written
2073 assembly code. In such a case, we'd have no debug info for the
2074 function, but we would have line info. */
2079 /* elz: added this because this function returned the wrong
2080 information if the pc belongs to a stub (import/export)
2081 to call a shlib function. This stub would be anywhere between
2082 two functions in the target, and the line info was erroneously
2083 taken to be the one of the line before the pc.
2085 /* RT: Further explanation:
2087 * We have stubs (trampolines) inserted between procedures.
2089 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2090 * exists in the main image.
2092 * In the minimal symbol table, we have a bunch of symbols
2093 * sorted by start address. The stubs are marked as "trampoline",
2094 * the others appear as text. E.g.:
2096 * Minimal symbol table for main image
2097 * main: code for main (text symbol)
2098 * shr1: stub (trampoline symbol)
2099 * foo: code for foo (text symbol)
2101 * Minimal symbol table for "shr1" image:
2103 * shr1: code for shr1 (text symbol)
2106 * So the code below is trying to detect if we are in the stub
2107 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2108 * and if found, do the symbolization from the real-code address
2109 * rather than the stub address.
2111 * Assumptions being made about the minimal symbol table:
2112 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2113 * if we're really in the trampoline. If we're beyond it (say
2114 * we're in "foo" in the above example), it'll have a closer
2115 * symbol (the "foo" text symbol for example) and will not
2116 * return the trampoline.
2117 * 2. lookup_minimal_symbol_text() will find a real text symbol
2118 * corresponding to the trampoline, and whose address will
2119 * be different than the trampoline address. I put in a sanity
2120 * check for the address being the same, to avoid an
2121 * infinite recursion.
2123 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2124 if (msymbol
!= NULL
)
2125 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2127 mfunsym
= lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol
),
2129 if (mfunsym
== NULL
)
2130 /* I eliminated this warning since it is coming out
2131 * in the following situation:
2132 * gdb shmain // test program with shared libraries
2133 * (gdb) break shr1 // function in shared lib
2134 * Warning: In stub for ...
2135 * In the above situation, the shared lib is not loaded yet,
2136 * so of course we can't find the real func/line info,
2137 * but the "break" still works, and the warning is annoying.
2138 * So I commented out the warning. RT */
2139 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2141 else if (SYMBOL_VALUE (mfunsym
) == SYMBOL_VALUE (msymbol
))
2142 /* Avoid infinite recursion */
2143 /* See above comment about why warning is commented out */
2144 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ;
2147 return find_pc_line (SYMBOL_VALUE (mfunsym
), 0);
2151 s
= find_pc_sect_symtab (pc
, section
);
2154 /* if no symbol information, return previous pc */
2161 bv
= BLOCKVECTOR (s
);
2163 /* Look at all the symtabs that share this blockvector.
2164 They all have the same apriori range, that we found was right;
2165 but they have different line tables. */
2167 for (; s
&& BLOCKVECTOR (s
) == bv
; s
= s
->next
)
2169 /* Find the best line in this symtab. */
2176 /* I think len can be zero if the symtab lacks line numbers
2177 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2178 I'm not sure which, and maybe it depends on the symbol
2184 item
= l
->item
; /* Get first line info */
2186 /* Is this file's first line closer than the first lines of other files?
2187 If so, record this file, and its first line, as best alternate. */
2188 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2194 for (i
= 0; i
< len
; i
++, item
++)
2196 /* Leave prev pointing to the linetable entry for the last line
2197 that started at or before PC. */
2204 /* At this point, prev points at the line whose start addr is <= pc, and
2205 item points at the next line. If we ran off the end of the linetable
2206 (pc >= start of the last line), then prev == item. If pc < start of
2207 the first line, prev will not be set. */
2209 /* Is this file's best line closer than the best in the other files?
2210 If so, record this file, and its best line, as best so far. Don't
2211 save prev if it represents the end of a function (i.e. line number
2212 0) instead of a real line. */
2214 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2219 /* Discard BEST_END if it's before the PC of the current BEST. */
2220 if (best_end
<= best
->pc
)
2224 /* If another line (denoted by ITEM) is in the linetable and its
2225 PC is after BEST's PC, but before the current BEST_END, then
2226 use ITEM's PC as the new best_end. */
2227 if (best
&& i
< len
&& item
->pc
> best
->pc
2228 && (best_end
== 0 || best_end
> item
->pc
))
2229 best_end
= item
->pc
;
2234 /* If we didn't find any line number info, just return zeros.
2235 We used to return alt->line - 1 here, but that could be
2236 anywhere; if we don't have line number info for this PC,
2237 don't make some up. */
2240 else if (best
->line
== 0)
2242 /* If our best fit is in a range of PC's for which no line
2243 number info is available (line number is zero) then we didn't
2244 find any valid line information. */
2249 val
.symtab
= best_symtab
;
2250 val
.line
= best
->line
;
2252 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2257 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2259 val
.section
= section
;
2263 /* Backward compatibility (no section) */
2265 struct symtab_and_line
2266 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2270 section
= find_pc_overlay (pc
);
2271 if (pc_in_unmapped_range (pc
, section
))
2272 pc
= overlay_mapped_address (pc
, section
);
2273 return find_pc_sect_line (pc
, section
, notcurrent
);
2276 /* Find line number LINE in any symtab whose name is the same as
2279 If found, return the symtab that contains the linetable in which it was
2280 found, set *INDEX to the index in the linetable of the best entry
2281 found, and set *EXACT_MATCH nonzero if the value returned is an
2284 If not found, return NULL. */
2287 find_line_symtab (struct symtab
*symtab
, int line
, int *index
, int *exact_match
)
2291 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2295 struct linetable
*best_linetable
;
2296 struct symtab
*best_symtab
;
2298 /* First try looking it up in the given symtab. */
2299 best_linetable
= LINETABLE (symtab
);
2300 best_symtab
= symtab
;
2301 best_index
= find_line_common (best_linetable
, line
, &exact
);
2302 if (best_index
< 0 || !exact
)
2304 /* Didn't find an exact match. So we better keep looking for
2305 another symtab with the same name. In the case of xcoff,
2306 multiple csects for one source file (produced by IBM's FORTRAN
2307 compiler) produce multiple symtabs (this is unavoidable
2308 assuming csects can be at arbitrary places in memory and that
2309 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2311 /* BEST is the smallest linenumber > LINE so far seen,
2312 or 0 if none has been seen so far.
2313 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2316 struct objfile
*objfile
;
2319 if (best_index
>= 0)
2320 best
= best_linetable
->item
[best_index
].line
;
2324 ALL_SYMTABS (objfile
, s
)
2326 struct linetable
*l
;
2329 if (strcmp (symtab
->filename
, s
->filename
) != 0)
2332 ind
= find_line_common (l
, line
, &exact
);
2342 if (best
== 0 || l
->item
[ind
].line
< best
)
2344 best
= l
->item
[ind
].line
;
2357 *index
= best_index
;
2359 *exact_match
= exact
;
2364 /* Set the PC value for a given source file and line number and return true.
2365 Returns zero for invalid line number (and sets the PC to 0).
2366 The source file is specified with a struct symtab. */
2369 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2371 struct linetable
*l
;
2378 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2381 l
= LINETABLE (symtab
);
2382 *pc
= l
->item
[ind
].pc
;
2389 /* Find the range of pc values in a line.
2390 Store the starting pc of the line into *STARTPTR
2391 and the ending pc (start of next line) into *ENDPTR.
2392 Returns 1 to indicate success.
2393 Returns 0 if could not find the specified line. */
2396 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2399 CORE_ADDR startaddr
;
2400 struct symtab_and_line found_sal
;
2403 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2406 /* This whole function is based on address. For example, if line 10 has
2407 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2408 "info line *0x123" should say the line goes from 0x100 to 0x200
2409 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2410 This also insures that we never give a range like "starts at 0x134
2411 and ends at 0x12c". */
2413 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2414 if (found_sal
.line
!= sal
.line
)
2416 /* The specified line (sal) has zero bytes. */
2417 *startptr
= found_sal
.pc
;
2418 *endptr
= found_sal
.pc
;
2422 *startptr
= found_sal
.pc
;
2423 *endptr
= found_sal
.end
;
2428 /* Given a line table and a line number, return the index into the line
2429 table for the pc of the nearest line whose number is >= the specified one.
2430 Return -1 if none is found. The value is >= 0 if it is an index.
2432 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2435 find_line_common (struct linetable
*l
, int lineno
,
2441 /* BEST is the smallest linenumber > LINENO so far seen,
2442 or 0 if none has been seen so far.
2443 BEST_INDEX identifies the item for it. */
2445 int best_index
= -1;
2454 for (i
= 0; i
< len
; i
++)
2456 struct linetable_entry
*item
= &(l
->item
[i
]);
2458 if (item
->line
== lineno
)
2460 /* Return the first (lowest address) entry which matches. */
2465 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2472 /* If we got here, we didn't get an exact match. */
2479 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2481 struct symtab_and_line sal
;
2482 sal
= find_pc_line (pc
, 0);
2485 return sal
.symtab
!= 0;
2488 /* Given a function symbol SYM, find the symtab and line for the start
2490 If the argument FUNFIRSTLINE is nonzero, we want the first line
2491 of real code inside the function. */
2493 struct symtab_and_line
2494 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2497 struct symtab_and_line sal
;
2499 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2500 fixup_symbol_section (sym
, NULL
);
2502 { /* skip "first line" of function (which is actually its prologue) */
2503 asection
*section
= SYMBOL_BFD_SECTION (sym
);
2504 /* If function is in an unmapped overlay, use its unmapped LMA
2505 address, so that SKIP_PROLOGUE has something unique to work on */
2506 if (section_is_overlay (section
) &&
2507 !section_is_mapped (section
))
2508 pc
= overlay_unmapped_address (pc
, section
);
2510 pc
+= DEPRECATED_FUNCTION_START_OFFSET
;
2511 pc
= SKIP_PROLOGUE (pc
);
2513 /* For overlays, map pc back into its mapped VMA range */
2514 pc
= overlay_mapped_address (pc
, section
);
2516 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2518 /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2519 line is still part of the same function. */
2521 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= sal
.end
2522 && sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2524 /* First pc of next line */
2526 /* Recalculate the line number (might not be N+1). */
2527 sal
= find_pc_sect_line (pc
, SYMBOL_BFD_SECTION (sym
), 0);
2534 /* If P is of the form "operator[ \t]+..." where `...' is
2535 some legitimate operator text, return a pointer to the
2536 beginning of the substring of the operator text.
2537 Otherwise, return "". */
2539 operator_chars (char *p
, char **end
)
2542 if (strncmp (p
, "operator", 8))
2546 /* Don't get faked out by `operator' being part of a longer
2548 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2551 /* Allow some whitespace between `operator' and the operator symbol. */
2552 while (*p
== ' ' || *p
== '\t')
2555 /* Recognize 'operator TYPENAME'. */
2557 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2560 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2569 case '\\': /* regexp quoting */
2572 if (p
[2] == '=') /* 'operator\*=' */
2574 else /* 'operator\*' */
2578 else if (p
[1] == '[')
2581 error (_("mismatched quoting on brackets, try 'operator\\[\\]'"));
2582 else if (p
[2] == '\\' && p
[3] == ']')
2584 *end
= p
+ 4; /* 'operator\[\]' */
2588 error (_("nothing is allowed between '[' and ']'"));
2592 /* Gratuitous qoute: skip it and move on. */
2614 if (p
[0] == '-' && p
[1] == '>')
2616 /* Struct pointer member operator 'operator->'. */
2619 *end
= p
+ 3; /* 'operator->*' */
2622 else if (p
[2] == '\\')
2624 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2629 *end
= p
+ 2; /* 'operator->' */
2633 if (p
[1] == '=' || p
[1] == p
[0])
2644 error (_("`operator ()' must be specified without whitespace in `()'"));
2649 error (_("`operator ?:' must be specified without whitespace in `?:'"));
2654 error (_("`operator []' must be specified without whitespace in `[]'"));
2658 error (_("`operator %s' not supported"), p
);
2667 /* If FILE is not already in the table of files, return zero;
2668 otherwise return non-zero. Optionally add FILE to the table if ADD
2669 is non-zero. If *FIRST is non-zero, forget the old table
2672 filename_seen (const char *file
, int add
, int *first
)
2674 /* Table of files seen so far. */
2675 static const char **tab
= NULL
;
2676 /* Allocated size of tab in elements.
2677 Start with one 256-byte block (when using GNU malloc.c).
2678 24 is the malloc overhead when range checking is in effect. */
2679 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2680 /* Current size of tab in elements. */
2681 static int tab_cur_size
;
2687 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2691 /* Is FILE in tab? */
2692 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2693 if (strcmp (*p
, file
) == 0)
2696 /* No; maybe add it to tab. */
2699 if (tab_cur_size
== tab_alloc_size
)
2701 tab_alloc_size
*= 2;
2702 tab
= (const char **) xrealloc ((char *) tab
,
2703 tab_alloc_size
* sizeof (*tab
));
2705 tab
[tab_cur_size
++] = file
;
2711 /* Slave routine for sources_info. Force line breaks at ,'s.
2712 NAME is the name to print and *FIRST is nonzero if this is the first
2713 name printed. Set *FIRST to zero. */
2715 output_source_filename (const char *name
, int *first
)
2717 /* Since a single source file can result in several partial symbol
2718 tables, we need to avoid printing it more than once. Note: if
2719 some of the psymtabs are read in and some are not, it gets
2720 printed both under "Source files for which symbols have been
2721 read" and "Source files for which symbols will be read in on
2722 demand". I consider this a reasonable way to deal with the
2723 situation. I'm not sure whether this can also happen for
2724 symtabs; it doesn't hurt to check. */
2726 /* Was NAME already seen? */
2727 if (filename_seen (name
, 1, first
))
2729 /* Yes; don't print it again. */
2732 /* No; print it and reset *FIRST. */
2739 printf_filtered (", ");
2743 fputs_filtered (name
, gdb_stdout
);
2747 sources_info (char *ignore
, int from_tty
)
2750 struct partial_symtab
*ps
;
2751 struct objfile
*objfile
;
2754 if (!have_full_symbols () && !have_partial_symbols ())
2756 error (_("No symbol table is loaded. Use the \"file\" command."));
2759 printf_filtered ("Source files for which symbols have been read in:\n\n");
2762 ALL_SYMTABS (objfile
, s
)
2764 const char *fullname
= symtab_to_fullname (s
);
2765 output_source_filename (fullname
? fullname
: s
->filename
, &first
);
2767 printf_filtered ("\n\n");
2769 printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2772 ALL_PSYMTABS (objfile
, ps
)
2776 const char *fullname
= psymtab_to_fullname (ps
);
2777 output_source_filename (fullname
? fullname
: ps
->filename
, &first
);
2780 printf_filtered ("\n");
2784 file_matches (char *file
, char *files
[], int nfiles
)
2788 if (file
!= NULL
&& nfiles
!= 0)
2790 for (i
= 0; i
< nfiles
; i
++)
2792 if (strcmp (files
[i
], lbasename (file
)) == 0)
2796 else if (nfiles
== 0)
2801 /* Free any memory associated with a search. */
2803 free_search_symbols (struct symbol_search
*symbols
)
2805 struct symbol_search
*p
;
2806 struct symbol_search
*next
;
2808 for (p
= symbols
; p
!= NULL
; p
= next
)
2816 do_free_search_symbols_cleanup (void *symbols
)
2818 free_search_symbols (symbols
);
2822 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
2824 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
2827 /* Helper function for sort_search_symbols and qsort. Can only
2828 sort symbols, not minimal symbols. */
2830 compare_search_syms (const void *sa
, const void *sb
)
2832 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
2833 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
2835 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
2836 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
2839 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
2840 prevtail where it is, but update its next pointer to point to
2841 the first of the sorted symbols. */
2842 static struct symbol_search
*
2843 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
2845 struct symbol_search
**symbols
, *symp
, *old_next
;
2848 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
2850 symp
= prevtail
->next
;
2851 for (i
= 0; i
< nfound
; i
++)
2856 /* Generally NULL. */
2859 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
2860 compare_search_syms
);
2863 for (i
= 0; i
< nfound
; i
++)
2865 symp
->next
= symbols
[i
];
2868 symp
->next
= old_next
;
2874 /* Search the symbol table for matches to the regular expression REGEXP,
2875 returning the results in *MATCHES.
2877 Only symbols of KIND are searched:
2878 FUNCTIONS_DOMAIN - search all functions
2879 TYPES_DOMAIN - search all type names
2880 METHODS_DOMAIN - search all methods NOT IMPLEMENTED
2881 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
2882 and constants (enums)
2884 free_search_symbols should be called when *MATCHES is no longer needed.
2886 The results are sorted locally; each symtab's global and static blocks are
2887 separately alphabetized.
2890 search_symbols (char *regexp
, domain_enum kind
, int nfiles
, char *files
[],
2891 struct symbol_search
**matches
)
2894 struct partial_symtab
*ps
;
2895 struct blockvector
*bv
;
2896 struct blockvector
*prev_bv
= 0;
2899 struct dict_iterator iter
;
2901 struct partial_symbol
**psym
;
2902 struct objfile
*objfile
;
2903 struct minimal_symbol
*msymbol
;
2906 static enum minimal_symbol_type types
[]
2908 {mst_data
, mst_text
, mst_abs
, mst_unknown
};
2909 static enum minimal_symbol_type types2
[]
2911 {mst_bss
, mst_file_text
, mst_abs
, mst_unknown
};
2912 static enum minimal_symbol_type types3
[]
2914 {mst_file_data
, mst_solib_trampoline
, mst_abs
, mst_unknown
};
2915 static enum minimal_symbol_type types4
[]
2917 {mst_file_bss
, mst_text
, mst_abs
, mst_unknown
};
2918 enum minimal_symbol_type ourtype
;
2919 enum minimal_symbol_type ourtype2
;
2920 enum minimal_symbol_type ourtype3
;
2921 enum minimal_symbol_type ourtype4
;
2922 struct symbol_search
*sr
;
2923 struct symbol_search
*psr
;
2924 struct symbol_search
*tail
;
2925 struct cleanup
*old_chain
= NULL
;
2927 if (kind
< VARIABLES_DOMAIN
)
2928 error (_("must search on specific domain"));
2930 ourtype
= types
[(int) (kind
- VARIABLES_DOMAIN
)];
2931 ourtype2
= types2
[(int) (kind
- VARIABLES_DOMAIN
)];
2932 ourtype3
= types3
[(int) (kind
- VARIABLES_DOMAIN
)];
2933 ourtype4
= types4
[(int) (kind
- VARIABLES_DOMAIN
)];
2935 sr
= *matches
= NULL
;
2940 /* Make sure spacing is right for C++ operators.
2941 This is just a courtesy to make the matching less sensitive
2942 to how many spaces the user leaves between 'operator'
2943 and <TYPENAME> or <OPERATOR>. */
2945 char *opname
= operator_chars (regexp
, &opend
);
2948 int fix
= -1; /* -1 means ok; otherwise number of spaces needed. */
2949 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
2951 /* There should 1 space between 'operator' and 'TYPENAME'. */
2952 if (opname
[-1] != ' ' || opname
[-2] == ' ')
2957 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2958 if (opname
[-1] == ' ')
2961 /* If wrong number of spaces, fix it. */
2964 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
2965 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
2970 if (0 != (val
= re_comp (regexp
)))
2971 error (_("Invalid regexp (%s): %s"), val
, regexp
);
2974 /* Search through the partial symtabs *first* for all symbols
2975 matching the regexp. That way we don't have to reproduce all of
2976 the machinery below. */
2978 ALL_PSYMTABS (objfile
, ps
)
2980 struct partial_symbol
**bound
, **gbound
, **sbound
;
2986 gbound
= objfile
->global_psymbols
.list
+ ps
->globals_offset
+ ps
->n_global_syms
;
2987 sbound
= objfile
->static_psymbols
.list
+ ps
->statics_offset
+ ps
->n_static_syms
;
2990 /* Go through all of the symbols stored in a partial
2991 symtab in one loop. */
2992 psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
2997 if (bound
== gbound
&& ps
->n_static_syms
!= 0)
2999 psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3010 /* If it would match (logic taken from loop below)
3011 load the file and go on to the next one */
3012 if (file_matches (ps
->filename
, files
, nfiles
)
3014 || re_exec (SYMBOL_NATURAL_NAME (*psym
)) != 0)
3015 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (*psym
) != LOC_TYPEDEF
3016 && SYMBOL_CLASS (*psym
) != LOC_BLOCK
)
3017 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
)
3018 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_TYPEDEF
)
3019 || (kind
== METHODS_DOMAIN
&& SYMBOL_CLASS (*psym
) == LOC_BLOCK
))))
3021 PSYMTAB_TO_SYMTAB (ps
);
3029 /* Here, we search through the minimal symbol tables for functions
3030 and variables that match, and force their symbols to be read.
3031 This is in particular necessary for demangled variable names,
3032 which are no longer put into the partial symbol tables.
3033 The symbol will then be found during the scan of symtabs below.
3035 For functions, find_pc_symtab should succeed if we have debug info
3036 for the function, for variables we have to call lookup_symbol
3037 to determine if the variable has debug info.
3038 If the lookup fails, set found_misc so that we will rescan to print
3039 any matching symbols without debug info.
3042 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3044 ALL_MSYMBOLS (objfile
, msymbol
)
3046 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3047 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3048 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3049 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3052 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3054 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
3056 /* FIXME: carlton/2003-02-04: Given that the
3057 semantics of lookup_symbol keeps on changing
3058 slightly, it would be a nice idea if we had a
3059 function lookup_symbol_minsym that found the
3060 symbol associated to a given minimal symbol (if
3062 if (kind
== FUNCTIONS_DOMAIN
3063 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3064 (struct block
*) NULL
,
3066 0, (struct symtab
**) NULL
) == NULL
)
3074 ALL_SYMTABS (objfile
, s
)
3076 bv
= BLOCKVECTOR (s
);
3077 /* Often many files share a blockvector.
3078 Scan each blockvector only once so that
3079 we don't get every symbol many times.
3080 It happens that the first symtab in the list
3081 for any given blockvector is the main file. */
3083 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3085 struct symbol_search
*prevtail
= tail
;
3087 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3088 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3091 if (file_matches (s
->filename
, files
, nfiles
)
3093 || re_exec (SYMBOL_NATURAL_NAME (sym
)) != 0)
3094 && ((kind
== VARIABLES_DOMAIN
&& SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3095 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3096 && SYMBOL_CLASS (sym
) != LOC_CONST
)
3097 || (kind
== FUNCTIONS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3098 || (kind
== TYPES_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3099 || (kind
== METHODS_DOMAIN
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
))))
3102 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3106 psr
->msymbol
= NULL
;
3118 if (prevtail
== NULL
)
3120 struct symbol_search dummy
;
3123 tail
= sort_search_symbols (&dummy
, nfound
);
3126 old_chain
= make_cleanup_free_search_symbols (sr
);
3129 tail
= sort_search_symbols (prevtail
, nfound
);
3135 /* If there are no eyes, avoid all contact. I mean, if there are
3136 no debug symbols, then print directly from the msymbol_vector. */
3138 if (found_misc
|| kind
!= FUNCTIONS_DOMAIN
)
3140 ALL_MSYMBOLS (objfile
, msymbol
)
3142 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3143 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3144 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3145 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3148 || re_exec (SYMBOL_NATURAL_NAME (msymbol
)) != 0)
3150 /* Functions: Look up by address. */
3151 if (kind
!= FUNCTIONS_DOMAIN
||
3152 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3154 /* Variables/Absolutes: Look up by name */
3155 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3156 (struct block
*) NULL
, VAR_DOMAIN
,
3157 0, (struct symtab
**) NULL
) == NULL
)
3160 psr
= (struct symbol_search
*) xmalloc (sizeof (struct symbol_search
));
3162 psr
->msymbol
= msymbol
;
3169 old_chain
= make_cleanup_free_search_symbols (sr
);
3183 discard_cleanups (old_chain
);
3186 /* Helper function for symtab_symbol_info, this function uses
3187 the data returned from search_symbols() to print information
3188 regarding the match to gdb_stdout.
3191 print_symbol_info (domain_enum kind
, struct symtab
*s
, struct symbol
*sym
,
3192 int block
, char *last
)
3194 if (last
== NULL
|| strcmp (last
, s
->filename
) != 0)
3196 fputs_filtered ("\nFile ", gdb_stdout
);
3197 fputs_filtered (s
->filename
, gdb_stdout
);
3198 fputs_filtered (":\n", gdb_stdout
);
3201 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3202 printf_filtered ("static ");
3204 /* Typedef that is not a C++ class */
3205 if (kind
== TYPES_DOMAIN
3206 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3207 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3208 /* variable, func, or typedef-that-is-c++-class */
3209 else if (kind
< TYPES_DOMAIN
||
3210 (kind
== TYPES_DOMAIN
&&
3211 SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3213 type_print (SYMBOL_TYPE (sym
),
3214 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3215 ? "" : SYMBOL_PRINT_NAME (sym
)),
3218 printf_filtered (";\n");
3222 /* This help function for symtab_symbol_info() prints information
3223 for non-debugging symbols to gdb_stdout.
3226 print_msymbol_info (struct minimal_symbol
*msymbol
)
3230 if (TARGET_ADDR_BIT
<= 32)
3231 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3232 & (CORE_ADDR
) 0xffffffff,
3235 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3237 printf_filtered ("%s %s\n",
3238 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3241 /* This is the guts of the commands "info functions", "info types", and
3242 "info variables". It calls search_symbols to find all matches and then
3243 print_[m]symbol_info to print out some useful information about the
3247 symtab_symbol_info (char *regexp
, domain_enum kind
, int from_tty
)
3249 static char *classnames
[]
3251 {"variable", "function", "type", "method"};
3252 struct symbol_search
*symbols
;
3253 struct symbol_search
*p
;
3254 struct cleanup
*old_chain
;
3255 char *last_filename
= NULL
;
3258 /* must make sure that if we're interrupted, symbols gets freed */
3259 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3260 old_chain
= make_cleanup_free_search_symbols (symbols
);
3262 printf_filtered (regexp
3263 ? "All %ss matching regular expression \"%s\":\n"
3264 : "All defined %ss:\n",
3265 classnames
[(int) (kind
- VARIABLES_DOMAIN
)], regexp
);
3267 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3271 if (p
->msymbol
!= NULL
)
3275 printf_filtered ("\nNon-debugging symbols:\n");
3278 print_msymbol_info (p
->msymbol
);
3282 print_symbol_info (kind
,
3287 last_filename
= p
->symtab
->filename
;
3291 do_cleanups (old_chain
);
3295 variables_info (char *regexp
, int from_tty
)
3297 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3301 functions_info (char *regexp
, int from_tty
)
3303 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3308 types_info (char *regexp
, int from_tty
)
3310 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3313 /* Breakpoint all functions matching regular expression. */
3316 rbreak_command_wrapper (char *regexp
, int from_tty
)
3318 rbreak_command (regexp
, from_tty
);
3322 rbreak_command (char *regexp
, int from_tty
)
3324 struct symbol_search
*ss
;
3325 struct symbol_search
*p
;
3326 struct cleanup
*old_chain
;
3328 search_symbols (regexp
, FUNCTIONS_DOMAIN
, 0, (char **) NULL
, &ss
);
3329 old_chain
= make_cleanup_free_search_symbols (ss
);
3331 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3333 if (p
->msymbol
== NULL
)
3335 char *string
= alloca (strlen (p
->symtab
->filename
)
3336 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
3338 strcpy (string
, p
->symtab
->filename
);
3339 strcat (string
, ":'");
3340 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
3341 strcat (string
, "'");
3342 break_command (string
, from_tty
);
3343 print_symbol_info (FUNCTIONS_DOMAIN
,
3347 p
->symtab
->filename
);
3351 break_command (SYMBOL_LINKAGE_NAME (p
->msymbol
), from_tty
);
3352 printf_filtered ("<function, no debug info> %s;\n",
3353 SYMBOL_PRINT_NAME (p
->msymbol
));
3357 do_cleanups (old_chain
);
3361 /* Helper routine for make_symbol_completion_list. */
3363 static int return_val_size
;
3364 static int return_val_index
;
3365 static char **return_val
;
3367 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3368 completion_list_add_name \
3369 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3371 /* Test to see if the symbol specified by SYMNAME (which is already
3372 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3373 characters. If so, add it to the current completion list. */
3376 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3377 char *text
, char *word
)
3382 /* clip symbols that cannot match */
3384 if (strncmp (symname
, sym_text
, sym_text_len
) != 0)
3389 /* We have a match for a completion, so add SYMNAME to the current list
3390 of matches. Note that the name is moved to freshly malloc'd space. */
3394 if (word
== sym_text
)
3396 new = xmalloc (strlen (symname
) + 5);
3397 strcpy (new, symname
);
3399 else if (word
> sym_text
)
3401 /* Return some portion of symname. */
3402 new = xmalloc (strlen (symname
) + 5);
3403 strcpy (new, symname
+ (word
- sym_text
));
3407 /* Return some of SYM_TEXT plus symname. */
3408 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3409 strncpy (new, word
, sym_text
- word
);
3410 new[sym_text
- word
] = '\0';
3411 strcat (new, symname
);
3414 if (return_val_index
+ 3 > return_val_size
)
3416 newsize
= (return_val_size
*= 2) * sizeof (char *);
3417 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3419 return_val
[return_val_index
++] = new;
3420 return_val
[return_val_index
] = NULL
;
3424 /* ObjC: In case we are completing on a selector, look as the msymbol
3425 again and feed all the selectors into the mill. */
3428 completion_list_objc_symbol (struct minimal_symbol
*msymbol
, char *sym_text
,
3429 int sym_text_len
, char *text
, char *word
)
3431 static char *tmp
= NULL
;
3432 static unsigned int tmplen
= 0;
3434 char *method
, *category
, *selector
;
3437 method
= SYMBOL_NATURAL_NAME (msymbol
);
3439 /* Is it a method? */
3440 if ((method
[0] != '-') && (method
[0] != '+'))
3443 if (sym_text
[0] == '[')
3444 /* Complete on shortened method method. */
3445 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
3447 while ((strlen (method
) + 1) >= tmplen
)
3453 tmp
= xrealloc (tmp
, tmplen
);
3455 selector
= strchr (method
, ' ');
3456 if (selector
!= NULL
)
3459 category
= strchr (method
, '(');
3461 if ((category
!= NULL
) && (selector
!= NULL
))
3463 memcpy (tmp
, method
, (category
- method
));
3464 tmp
[category
- method
] = ' ';
3465 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
3466 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3467 if (sym_text
[0] == '[')
3468 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
3471 if (selector
!= NULL
)
3473 /* Complete on selector only. */
3474 strcpy (tmp
, selector
);
3475 tmp2
= strchr (tmp
, ']');
3479 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3483 /* Break the non-quoted text based on the characters which are in
3484 symbols. FIXME: This should probably be language-specific. */
3487 language_search_unquoted_string (char *text
, char *p
)
3489 for (; p
> text
; --p
)
3491 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3495 if ((current_language
->la_language
== language_objc
))
3497 if (p
[-1] == ':') /* might be part of a method name */
3499 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
3500 p
-= 2; /* beginning of a method name */
3501 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
3502 { /* might be part of a method name */
3505 /* Seeing a ' ' or a '(' is not conclusive evidence
3506 that we are in the middle of a method name. However,
3507 finding "-[" or "+[" should be pretty un-ambiguous.
3508 Unfortunately we have to find it now to decide. */
3511 if (isalnum (t
[-1]) || t
[-1] == '_' ||
3512 t
[-1] == ' ' || t
[-1] == ':' ||
3513 t
[-1] == '(' || t
[-1] == ')')
3518 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
3519 p
= t
- 2; /* method name detected */
3520 /* else we leave with p unchanged */
3530 /* Return a NULL terminated array of all symbols (regardless of class)
3531 which begin by matching TEXT. If the answer is no symbols, then
3532 the return value is an array which contains only a NULL pointer.
3534 Problem: All of the symbols have to be copied because readline frees them.
3535 I'm not going to worry about this; hopefully there won't be that many. */
3538 make_symbol_completion_list (char *text
, char *word
)
3542 struct partial_symtab
*ps
;
3543 struct minimal_symbol
*msymbol
;
3544 struct objfile
*objfile
;
3545 struct block
*b
, *surrounding_static_block
= 0;
3546 struct dict_iterator iter
;
3548 struct partial_symbol
**psym
;
3549 /* The symbol we are completing on. Points in same buffer as text. */
3551 /* Length of sym_text. */
3554 /* Now look for the symbol we are supposed to complete on.
3555 FIXME: This should be language-specific. */
3559 char *quote_pos
= NULL
;
3561 /* First see if this is a quoted string. */
3563 for (p
= text
; *p
!= '\0'; ++p
)
3565 if (quote_found
!= '\0')
3567 if (*p
== quote_found
)
3568 /* Found close quote. */
3570 else if (*p
== '\\' && p
[1] == quote_found
)
3571 /* A backslash followed by the quote character
3572 doesn't end the string. */
3575 else if (*p
== '\'' || *p
== '"')
3581 if (quote_found
== '\'')
3582 /* A string within single quotes can be a symbol, so complete on it. */
3583 sym_text
= quote_pos
+ 1;
3584 else if (quote_found
== '"')
3585 /* A double-quoted string is never a symbol, nor does it make sense
3586 to complete it any other way. */
3588 return_val
= (char **) xmalloc (sizeof (char *));
3589 return_val
[0] = NULL
;
3594 /* It is not a quoted string. Break it based on the characters
3595 which are in symbols. */
3598 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3607 sym_text_len
= strlen (sym_text
);
3609 return_val_size
= 100;
3610 return_val_index
= 0;
3611 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3612 return_val
[0] = NULL
;
3614 /* Look through the partial symtabs for all symbols which begin
3615 by matching SYM_TEXT. Add each one that you find to the list. */
3617 ALL_PSYMTABS (objfile
, ps
)
3619 /* If the psymtab's been read in we'll get it when we search
3620 through the blockvector. */
3624 for (psym
= objfile
->global_psymbols
.list
+ ps
->globals_offset
;
3625 psym
< (objfile
->global_psymbols
.list
+ ps
->globals_offset
3626 + ps
->n_global_syms
);
3629 /* If interrupted, then quit. */
3631 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3634 for (psym
= objfile
->static_psymbols
.list
+ ps
->statics_offset
;
3635 psym
< (objfile
->static_psymbols
.list
+ ps
->statics_offset
3636 + ps
->n_static_syms
);
3640 COMPLETION_LIST_ADD_SYMBOL (*psym
, sym_text
, sym_text_len
, text
, word
);
3644 /* At this point scan through the misc symbol vectors and add each
3645 symbol you find to the list. Eventually we want to ignore
3646 anything that isn't a text symbol (everything else will be
3647 handled by the psymtab code above). */
3649 ALL_MSYMBOLS (objfile
, msymbol
)
3652 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
3654 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
, word
);
3657 /* Search upwards from currently selected frame (so that we can
3658 complete on local vars. */
3660 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
3662 if (!BLOCK_SUPERBLOCK (b
))
3664 surrounding_static_block
= b
; /* For elmin of dups */
3667 /* Also catch fields of types defined in this places which match our
3668 text string. Only complete on types visible from current context. */
3670 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3673 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3674 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3676 struct type
*t
= SYMBOL_TYPE (sym
);
3677 enum type_code c
= TYPE_CODE (t
);
3679 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3681 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3683 if (TYPE_FIELD_NAME (t
, j
))
3685 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3686 sym_text
, sym_text_len
, text
, word
);
3694 /* Go through the symtabs and check the externs and statics for
3695 symbols which match. */
3697 ALL_SYMTABS (objfile
, s
)
3700 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3701 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3703 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3707 ALL_SYMTABS (objfile
, s
)
3710 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3711 /* Don't do this block twice. */
3712 if (b
== surrounding_static_block
)
3714 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3716 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3720 return (return_val
);
3723 /* Like make_symbol_completion_list, but returns a list of symbols
3724 defined in a source file FILE. */
3727 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
3732 struct dict_iterator iter
;
3733 /* The symbol we are completing on. Points in same buffer as text. */
3735 /* Length of sym_text. */
3738 /* Now look for the symbol we are supposed to complete on.
3739 FIXME: This should be language-specific. */
3743 char *quote_pos
= NULL
;
3745 /* First see if this is a quoted string. */
3747 for (p
= text
; *p
!= '\0'; ++p
)
3749 if (quote_found
!= '\0')
3751 if (*p
== quote_found
)
3752 /* Found close quote. */
3754 else if (*p
== '\\' && p
[1] == quote_found
)
3755 /* A backslash followed by the quote character
3756 doesn't end the string. */
3759 else if (*p
== '\'' || *p
== '"')
3765 if (quote_found
== '\'')
3766 /* A string within single quotes can be a symbol, so complete on it. */
3767 sym_text
= quote_pos
+ 1;
3768 else if (quote_found
== '"')
3769 /* A double-quoted string is never a symbol, nor does it make sense
3770 to complete it any other way. */
3772 return_val
= (char **) xmalloc (sizeof (char *));
3773 return_val
[0] = NULL
;
3778 /* Not a quoted string. */
3779 sym_text
= language_search_unquoted_string (text
, p
);
3783 sym_text_len
= strlen (sym_text
);
3785 return_val_size
= 10;
3786 return_val_index
= 0;
3787 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
3788 return_val
[0] = NULL
;
3790 /* Find the symtab for SRCFILE (this loads it if it was not yet read
3792 s
= lookup_symtab (srcfile
);
3795 /* Maybe they typed the file with leading directories, while the
3796 symbol tables record only its basename. */
3797 const char *tail
= lbasename (srcfile
);
3800 s
= lookup_symtab (tail
);
3803 /* If we have no symtab for that file, return an empty list. */
3805 return (return_val
);
3807 /* Go through this symtab and check the externs and statics for
3808 symbols which match. */
3810 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
3811 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3813 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3816 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
3817 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3819 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
3822 return (return_val
);
3825 /* A helper function for make_source_files_completion_list. It adds
3826 another file name to a list of possible completions, growing the
3827 list as necessary. */
3830 add_filename_to_list (const char *fname
, char *text
, char *word
,
3831 char ***list
, int *list_used
, int *list_alloced
)
3834 size_t fnlen
= strlen (fname
);
3836 if (*list_used
+ 1 >= *list_alloced
)
3839 *list
= (char **) xrealloc ((char *) *list
,
3840 *list_alloced
* sizeof (char *));
3845 /* Return exactly fname. */
3846 new = xmalloc (fnlen
+ 5);
3847 strcpy (new, fname
);
3849 else if (word
> text
)
3851 /* Return some portion of fname. */
3852 new = xmalloc (fnlen
+ 5);
3853 strcpy (new, fname
+ (word
- text
));
3857 /* Return some of TEXT plus fname. */
3858 new = xmalloc (fnlen
+ (text
- word
) + 5);
3859 strncpy (new, word
, text
- word
);
3860 new[text
- word
] = '\0';
3861 strcat (new, fname
);
3863 (*list
)[*list_used
] = new;
3864 (*list
)[++*list_used
] = NULL
;
3868 not_interesting_fname (const char *fname
)
3870 static const char *illegal_aliens
[] = {
3871 "_globals_", /* inserted by coff_symtab_read */
3876 for (i
= 0; illegal_aliens
[i
]; i
++)
3878 if (strcmp (fname
, illegal_aliens
[i
]) == 0)
3884 /* Return a NULL terminated array of all source files whose names
3885 begin with matching TEXT. The file names are looked up in the
3886 symbol tables of this program. If the answer is no matchess, then
3887 the return value is an array which contains only a NULL pointer. */
3890 make_source_files_completion_list (char *text
, char *word
)
3893 struct partial_symtab
*ps
;
3894 struct objfile
*objfile
;
3896 int list_alloced
= 1;
3898 size_t text_len
= strlen (text
);
3899 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
3900 const char *base_name
;
3904 if (!have_full_symbols () && !have_partial_symbols ())
3907 ALL_SYMTABS (objfile
, s
)
3909 if (not_interesting_fname (s
->filename
))
3911 if (!filename_seen (s
->filename
, 1, &first
)
3912 #if HAVE_DOS_BASED_FILE_SYSTEM
3913 && strncasecmp (s
->filename
, text
, text_len
) == 0
3915 && strncmp (s
->filename
, text
, text_len
) == 0
3919 /* This file matches for a completion; add it to the current
3921 add_filename_to_list (s
->filename
, text
, word
,
3922 &list
, &list_used
, &list_alloced
);
3926 /* NOTE: We allow the user to type a base name when the
3927 debug info records leading directories, but not the other
3928 way around. This is what subroutines of breakpoint
3929 command do when they parse file names. */
3930 base_name
= lbasename (s
->filename
);
3931 if (base_name
!= s
->filename
3932 && !filename_seen (base_name
, 1, &first
)
3933 #if HAVE_DOS_BASED_FILE_SYSTEM
3934 && strncasecmp (base_name
, text
, text_len
) == 0
3936 && strncmp (base_name
, text
, text_len
) == 0
3939 add_filename_to_list (base_name
, text
, word
,
3940 &list
, &list_used
, &list_alloced
);
3944 ALL_PSYMTABS (objfile
, ps
)
3946 if (not_interesting_fname (ps
->filename
))
3950 if (!filename_seen (ps
->filename
, 1, &first
)
3951 #if HAVE_DOS_BASED_FILE_SYSTEM
3952 && strncasecmp (ps
->filename
, text
, text_len
) == 0
3954 && strncmp (ps
->filename
, text
, text_len
) == 0
3958 /* This file matches for a completion; add it to the
3959 current list of matches. */
3960 add_filename_to_list (ps
->filename
, text
, word
,
3961 &list
, &list_used
, &list_alloced
);
3966 base_name
= lbasename (ps
->filename
);
3967 if (base_name
!= ps
->filename
3968 && !filename_seen (base_name
, 1, &first
)
3969 #if HAVE_DOS_BASED_FILE_SYSTEM
3970 && strncasecmp (base_name
, text
, text_len
) == 0
3972 && strncmp (base_name
, text
, text_len
) == 0
3975 add_filename_to_list (base_name
, text
, word
,
3976 &list
, &list_used
, &list_alloced
);
3984 /* Determine if PC is in the prologue of a function. The prologue is the area
3985 between the first instruction of a function, and the first executable line.
3986 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
3988 If non-zero, func_start is where we think the prologue starts, possibly
3989 by previous examination of symbol table information.
3993 in_prologue (CORE_ADDR pc
, CORE_ADDR func_start
)
3995 struct symtab_and_line sal
;
3996 CORE_ADDR func_addr
, func_end
;
3998 /* We have several sources of information we can consult to figure
4000 - Compilers usually emit line number info that marks the prologue
4001 as its own "source line". So the ending address of that "line"
4002 is the end of the prologue. If available, this is the most
4004 - The minimal symbols and partial symbols, which can usually tell
4005 us the starting and ending addresses of a function.
4006 - If we know the function's start address, we can call the
4007 architecture-defined SKIP_PROLOGUE function to analyze the
4008 instruction stream and guess where the prologue ends.
4009 - Our `func_start' argument; if non-zero, this is the caller's
4010 best guess as to the function's entry point. At the time of
4011 this writing, handle_inferior_event doesn't get this right, so
4012 it should be our last resort. */
4014 /* Consult the partial symbol table, to find which function
4016 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
4018 CORE_ADDR prologue_end
;
4020 /* We don't even have minsym information, so fall back to using
4021 func_start, if given. */
4023 return 1; /* We *might* be in a prologue. */
4025 prologue_end
= SKIP_PROLOGUE (func_start
);
4027 return func_start
<= pc
&& pc
< prologue_end
;
4030 /* If we have line number information for the function, that's
4031 usually pretty reliable. */
4032 sal
= find_pc_line (func_addr
, 0);
4034 /* Now sal describes the source line at the function's entry point,
4035 which (by convention) is the prologue. The end of that "line",
4036 sal.end, is the end of the prologue.
4038 Note that, for functions whose source code is all on a single
4039 line, the line number information doesn't always end up this way.
4040 So we must verify that our purported end-of-prologue address is
4041 *within* the function, not at its start or end. */
4043 || sal
.end
<= func_addr
4044 || func_end
<= sal
.end
)
4046 /* We don't have any good line number info, so use the minsym
4047 information, together with the architecture-specific prologue
4049 CORE_ADDR prologue_end
= SKIP_PROLOGUE (func_addr
);
4051 return func_addr
<= pc
&& pc
< prologue_end
;
4054 /* We have line number info, and it looks good. */
4055 return func_addr
<= pc
&& pc
< sal
.end
;
4058 /* Given PC at the function's start address, attempt to find the
4059 prologue end using SAL information. Return zero if the skip fails.
4061 A non-optimized prologue traditionally has one SAL for the function
4062 and a second for the function body. A single line function has
4063 them both pointing at the same line.
4065 An optimized prologue is similar but the prologue may contain
4066 instructions (SALs) from the instruction body. Need to skip those
4067 while not getting into the function body.
4069 The functions end point and an increasing SAL line are used as
4070 indicators of the prologue's endpoint.
4072 This code is based on the function refine_prologue_limit (versions
4073 found in both ia64 and ppc). */
4076 skip_prologue_using_sal (CORE_ADDR func_addr
)
4078 struct symtab_and_line prologue_sal
;
4082 /* Get an initial range for the function. */
4083 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
4084 start_pc
+= DEPRECATED_FUNCTION_START_OFFSET
;
4086 prologue_sal
= find_pc_line (start_pc
, 0);
4087 if (prologue_sal
.line
!= 0)
4089 /* If there is only one sal that covers the entire function,
4090 then it is probably a single line function, like
4092 if (prologue_sal
.end
== end_pc
)
4094 while (prologue_sal
.end
< end_pc
)
4096 struct symtab_and_line sal
;
4098 sal
= find_pc_line (prologue_sal
.end
, 0);
4101 /* Assume that a consecutive SAL for the same (or larger)
4102 line mark the prologue -> body transition. */
4103 if (sal
.line
>= prologue_sal
.line
)
4105 /* The case in which compiler's optimizer/scheduler has
4106 moved instructions into the prologue. We look ahead in
4107 the function looking for address ranges whose
4108 corresponding line number is less the first one that we
4109 found for the function. This is more conservative then
4110 refine_prologue_limit which scans a large number of SALs
4111 looking for any in the prologue */
4115 return prologue_sal
.end
;
4118 struct symtabs_and_lines
4119 decode_line_spec (char *string
, int funfirstline
)
4121 struct symtabs_and_lines sals
;
4122 struct symtab_and_line cursal
;
4125 error (_("Empty line specification."));
4127 /* We use whatever is set as the current source line. We do not try
4128 and get a default or it will recursively call us! */
4129 cursal
= get_current_source_symtab_and_line ();
4131 sals
= decode_line_1 (&string
, funfirstline
,
4132 cursal
.symtab
, cursal
.line
,
4133 (char ***) NULL
, NULL
);
4136 error (_("Junk at end of line specification: %s"), string
);
4141 static char *name_of_main
;
4144 set_main_name (const char *name
)
4146 if (name_of_main
!= NULL
)
4148 xfree (name_of_main
);
4149 name_of_main
= NULL
;
4153 name_of_main
= xstrdup (name
);
4157 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4161 find_main_name (void)
4163 char *new_main_name
;
4165 /* Try to see if the main procedure is in Ada. */
4166 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4167 be to add a new method in the language vector, and call this
4168 method for each language until one of them returns a non-empty
4169 name. This would allow us to remove this hard-coded call to
4170 an Ada function. It is not clear that this is a better approach
4171 at this point, because all methods need to be written in a way
4172 such that false positives never be returned. For instance, it is
4173 important that a method does not return a wrong name for the main
4174 procedure if the main procedure is actually written in a different
4175 language. It is easy to guaranty this with Ada, since we use a
4176 special symbol generated only when the main in Ada to find the name
4177 of the main procedure. It is difficult however to see how this can
4178 be guarantied for languages such as C, for instance. This suggests
4179 that order of call for these methods becomes important, which means
4180 a more complicated approach. */
4181 new_main_name
= ada_main_name ();
4182 if (new_main_name
!= NULL
)
4184 set_main_name (new_main_name
);
4188 /* The languages above didn't identify the name of the main procedure.
4189 Fallback to "main". */
4190 set_main_name ("main");
4196 if (name_of_main
== NULL
)
4199 return name_of_main
;
4202 /* Handle ``executable_changed'' events for the symtab module. */
4205 symtab_observer_executable_changed (void *unused
)
4207 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
4208 set_main_name (NULL
);
4212 _initialize_symtab (void)
4214 add_info ("variables", variables_info
, _("\
4215 All global and static variable names, or those matching REGEXP."));
4217 add_com ("whereis", class_info
, variables_info
, _("\
4218 All global and static variable names, or those matching REGEXP."));
4220 add_info ("functions", functions_info
,
4221 _("All function names, or those matching REGEXP."));
4224 /* FIXME: This command has at least the following problems:
4225 1. It prints builtin types (in a very strange and confusing fashion).
4226 2. It doesn't print right, e.g. with
4227 typedef struct foo *FOO
4228 type_print prints "FOO" when we want to make it (in this situation)
4229 print "struct foo *".
4230 I also think "ptype" or "whatis" is more likely to be useful (but if
4231 there is much disagreement "info types" can be fixed). */
4232 add_info ("types", types_info
,
4233 _("All type names, or those matching REGEXP."));
4235 add_info ("sources", sources_info
,
4236 _("Source files in the program."));
4238 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4239 _("Set a breakpoint for all functions matching REGEXP."));
4243 add_com ("lf", class_info
, sources_info
,
4244 _("Source files in the program"));
4245 add_com ("lg", class_info
, variables_info
, _("\
4246 All global and static variable names, or those matching REGEXP."));
4249 /* Initialize the one built-in type that isn't language dependent... */
4250 builtin_type_error
= init_type (TYPE_CODE_ERROR
, 0, 0,
4251 "<unknown type>", (struct objfile
*) NULL
);
4253 observer_attach_executable_changed (symtab_observer_executable_changed
);