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, 2008, 2009,
5 2010, 2011 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 3 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, see <http://www.gnu.org/licenses/>. */
32 #include "call-cmds.h"
33 #include "gdb_regex.h"
34 #include "expression.h"
40 #include "filenames.h" /* for FILENAME_CMP */
41 #include "objc-lang.h"
49 #include "gdb_obstack.h"
51 #include "dictionary.h"
53 #include <sys/types.h>
55 #include "gdb_string.h"
59 #include "cp-support.h"
61 #include "gdb_assert.h"
64 #include "macroscope.h"
68 /* Prototypes for local functions */
70 static void completion_list_add_name (char *, char *, int, char *, char *);
72 static void rbreak_command (char *, int);
74 static void types_info (char *, int);
76 static void functions_info (char *, int);
78 static void variables_info (char *, int);
80 static void sources_info (char *, int);
82 static void output_source_filename (const char *, int *);
84 static int find_line_common (struct linetable
*, int, int *, int);
86 static struct symbol
*lookup_symbol_aux (const char *name
,
87 const struct block
*block
,
88 const domain_enum domain
,
89 enum language language
,
90 int *is_a_field_of_this
);
93 struct symbol
*lookup_symbol_aux_local (const char *name
,
94 const struct block
*block
,
95 const domain_enum domain
,
96 enum language language
);
99 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
101 const domain_enum domain
);
104 struct symbol
*lookup_symbol_aux_quick (struct objfile
*objfile
,
107 const domain_enum domain
);
109 static void print_msymbol_info (struct minimal_symbol
*);
111 void _initialize_symtab (void);
115 /* Non-zero if a file may be known by two different basenames.
116 This is the uncommon case, and significantly slows down gdb.
117 Default set to "off" to not slow down the common case. */
118 int basenames_may_differ
= 0;
120 /* Allow the user to configure the debugger behavior with respect
121 to multiple-choice menus when more than one symbol matches during
124 const char multiple_symbols_ask
[] = "ask";
125 const char multiple_symbols_all
[] = "all";
126 const char multiple_symbols_cancel
[] = "cancel";
127 static const char *multiple_symbols_modes
[] =
129 multiple_symbols_ask
,
130 multiple_symbols_all
,
131 multiple_symbols_cancel
,
134 static const char *multiple_symbols_mode
= multiple_symbols_all
;
136 /* Read-only accessor to AUTO_SELECT_MODE. */
139 multiple_symbols_select_mode (void)
141 return multiple_symbols_mode
;
144 /* Block in which the most recently searched-for symbol was found.
145 Might be better to make this a parameter to lookup_symbol and
148 const struct block
*block_found
;
150 /* Check for a symtab of a specific name by searching some symtabs.
151 This is a helper function for callbacks of iterate_over_symtabs.
153 The return value, NAME, FULL_PATH, REAL_PATH, CALLBACK, and DATA
154 are identical to the `map_symtabs_matching_filename' method of
155 quick_symbol_functions.
157 FIRST and AFTER_LAST indicate the range of symtabs to search.
158 AFTER_LAST is one past the last symtab to search; NULL means to
159 search until the end of the list. */
162 iterate_over_some_symtabs (const char *name
,
163 const char *full_path
,
164 const char *real_path
,
165 int (*callback
) (struct symtab
*symtab
,
168 struct symtab
*first
,
169 struct symtab
*after_last
)
171 struct symtab
*s
= NULL
;
172 struct cleanup
*cleanup
;
173 const char* base_name
= lbasename (name
);
175 for (s
= first
; s
!= NULL
&& s
!= after_last
; s
= s
->next
)
177 if (FILENAME_CMP (name
, s
->filename
) == 0)
179 if (callback (s
, data
))
183 /* Before we invoke realpath, which can get expensive when many
184 files are involved, do a quick comparison of the basenames. */
185 if (! basenames_may_differ
186 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
189 /* If the user gave us an absolute path, try to find the file in
190 this symtab and use its absolute path. */
192 if (full_path
!= NULL
)
194 const char *fp
= symtab_to_fullname (s
);
196 if (fp
!= NULL
&& FILENAME_CMP (full_path
, fp
) == 0)
198 if (callback (s
, data
))
203 if (real_path
!= NULL
)
205 char *fullname
= symtab_to_fullname (s
);
207 if (fullname
!= NULL
)
209 char *rp
= gdb_realpath (fullname
);
211 make_cleanup (xfree
, rp
);
212 if (FILENAME_CMP (real_path
, rp
) == 0)
214 if (callback (s
, data
))
221 /* Now, search for a matching tail (only if name doesn't have any dirs). */
223 if (lbasename (name
) == name
)
225 for (s
= first
; s
!= NULL
&& s
!= after_last
; s
= s
->next
)
227 if (FILENAME_CMP (lbasename (s
->filename
), name
) == 0)
229 if (callback (s
, data
))
238 /* Check for a symtab of a specific name; first in symtabs, then in
239 psymtabs. *If* there is no '/' in the name, a match after a '/'
240 in the symtab filename will also work.
242 Calls CALLBACK with each symtab that is found and with the supplied
243 DATA. If CALLBACK returns true, the search stops. */
246 iterate_over_symtabs (const char *name
,
247 int (*callback
) (struct symtab
*symtab
,
251 struct symtab
*s
= NULL
;
252 struct objfile
*objfile
;
253 char *real_path
= NULL
;
254 char *full_path
= NULL
;
255 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, 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_OBJFILES (objfile
)
269 if (iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
270 objfile
->symtabs
, NULL
))
272 do_cleanups (cleanups
);
277 /* Same search rules as above apply here, but now we look thru the
280 ALL_OBJFILES (objfile
)
283 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
290 do_cleanups (cleanups
);
295 do_cleanups (cleanups
);
298 /* The callback function used by lookup_symtab. */
301 lookup_symtab_callback (struct symtab
*symtab
, void *data
)
303 struct symtab
**result_ptr
= data
;
305 *result_ptr
= symtab
;
309 /* A wrapper for iterate_over_symtabs that returns the first matching
313 lookup_symtab (const char *name
)
315 struct symtab
*result
= NULL
;
317 iterate_over_symtabs (name
, lookup_symtab_callback
, &result
);
322 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
323 full method name, which consist of the class name (from T), the unadorned
324 method name from METHOD_ID, and the signature for the specific overload,
325 specified by SIGNATURE_ID. Note that this function is g++ specific. */
328 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
330 int mangled_name_len
;
332 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
333 struct fn_field
*method
= &f
[signature_id
];
334 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
335 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
336 char *newname
= type_name_no_tag (type
);
338 /* Does the form of physname indicate that it is the full mangled name
339 of a constructor (not just the args)? */
340 int is_full_physname_constructor
;
343 int is_destructor
= is_destructor_name (physname
);
344 /* Need a new type prefix. */
345 char *const_prefix
= method
->is_const
? "C" : "";
346 char *volatile_prefix
= method
->is_volatile
? "V" : "";
348 int len
= (newname
== NULL
? 0 : strlen (newname
));
350 /* Nothing to do if physname already contains a fully mangled v3 abi name
351 or an operator name. */
352 if ((physname
[0] == '_' && physname
[1] == 'Z')
353 || is_operator_name (field_name
))
354 return xstrdup (physname
);
356 is_full_physname_constructor
= is_constructor_name (physname
);
358 is_constructor
= is_full_physname_constructor
359 || (newname
&& strcmp (field_name
, newname
) == 0);
362 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
364 if (is_destructor
|| is_full_physname_constructor
)
366 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
367 strcpy (mangled_name
, physname
);
373 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
375 else if (physname
[0] == 't' || physname
[0] == 'Q')
377 /* The physname for template and qualified methods already includes
379 sprintf (buf
, "__%s%s", const_prefix
, volatile_prefix
);
385 sprintf (buf
, "__%s%s%d", const_prefix
, volatile_prefix
, len
);
387 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
388 + strlen (buf
) + len
+ strlen (physname
) + 1);
390 mangled_name
= (char *) xmalloc (mangled_name_len
);
392 mangled_name
[0] = '\0';
394 strcpy (mangled_name
, field_name
);
396 strcat (mangled_name
, buf
);
397 /* If the class doesn't have a name, i.e. newname NULL, then we just
398 mangle it using 0 for the length of the class. Thus it gets mangled
399 as something starting with `::' rather than `classname::'. */
401 strcat (mangled_name
, newname
);
403 strcat (mangled_name
, physname
);
404 return (mangled_name
);
407 /* Initialize the cplus_specific structure. 'cplus_specific' should
408 only be allocated for use with cplus symbols. */
411 symbol_init_cplus_specific (struct general_symbol_info
*gsymbol
,
412 struct objfile
*objfile
)
414 /* A language_specific structure should not have been previously
416 gdb_assert (gsymbol
->language_specific
.cplus_specific
== NULL
);
417 gdb_assert (objfile
!= NULL
);
419 gsymbol
->language_specific
.cplus_specific
=
420 OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct cplus_specific
);
423 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
424 correctly allocated. For C++ symbols a cplus_specific struct is
425 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
426 OBJFILE can be NULL. */
428 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
430 struct objfile
*objfile
)
432 if (gsymbol
->language
== language_cplus
)
434 if (gsymbol
->language_specific
.cplus_specific
== NULL
)
435 symbol_init_cplus_specific (gsymbol
, objfile
);
437 gsymbol
->language_specific
.cplus_specific
->demangled_name
= name
;
440 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
443 /* Return the demangled name of GSYMBOL. */
445 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
447 if (gsymbol
->language
== language_cplus
)
449 if (gsymbol
->language_specific
.cplus_specific
!= NULL
)
450 return gsymbol
->language_specific
.cplus_specific
->demangled_name
;
455 return gsymbol
->language_specific
.mangled_lang
.demangled_name
;
459 /* Initialize the language dependent portion of a symbol
460 depending upon the language for the symbol. */
462 symbol_set_language (struct general_symbol_info
*gsymbol
,
463 enum language language
)
465 gsymbol
->language
= language
;
466 if (gsymbol
->language
== language_d
467 || gsymbol
->language
== language_java
468 || gsymbol
->language
== language_objc
469 || gsymbol
->language
== language_fortran
)
471 symbol_set_demangled_name (gsymbol
, NULL
, NULL
);
473 else if (gsymbol
->language
== language_cplus
)
474 gsymbol
->language_specific
.cplus_specific
= NULL
;
477 memset (&gsymbol
->language_specific
, 0,
478 sizeof (gsymbol
->language_specific
));
482 /* Functions to initialize a symbol's mangled name. */
484 /* Objects of this type are stored in the demangled name hash table. */
485 struct demangled_name_entry
491 /* Hash function for the demangled name hash. */
493 hash_demangled_name_entry (const void *data
)
495 const struct demangled_name_entry
*e
= data
;
497 return htab_hash_string (e
->mangled
);
500 /* Equality function for the demangled name hash. */
502 eq_demangled_name_entry (const void *a
, const void *b
)
504 const struct demangled_name_entry
*da
= a
;
505 const struct demangled_name_entry
*db
= b
;
507 return strcmp (da
->mangled
, db
->mangled
) == 0;
510 /* Create the hash table used for demangled names. Each hash entry is
511 a pair of strings; one for the mangled name and one for the demangled
512 name. The entry is hashed via just the mangled name. */
515 create_demangled_names_hash (struct objfile
*objfile
)
517 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
518 The hash table code will round this up to the next prime number.
519 Choosing a much larger table size wastes memory, and saves only about
520 1% in symbol reading. */
522 objfile
->demangled_names_hash
= htab_create_alloc
523 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
524 NULL
, xcalloc
, xfree
);
527 /* Try to determine the demangled name for a symbol, based on the
528 language of that symbol. If the language is set to language_auto,
529 it will attempt to find any demangling algorithm that works and
530 then set the language appropriately. The returned name is allocated
531 by the demangler and should be xfree'd. */
534 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
537 char *demangled
= NULL
;
539 if (gsymbol
->language
== language_unknown
)
540 gsymbol
->language
= language_auto
;
542 if (gsymbol
->language
== language_objc
543 || gsymbol
->language
== language_auto
)
546 objc_demangle (mangled
, 0);
547 if (demangled
!= NULL
)
549 gsymbol
->language
= language_objc
;
553 if (gsymbol
->language
== language_cplus
554 || gsymbol
->language
== language_auto
)
557 cplus_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
558 if (demangled
!= NULL
)
560 gsymbol
->language
= language_cplus
;
564 if (gsymbol
->language
== language_java
)
567 cplus_demangle (mangled
,
568 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
569 if (demangled
!= NULL
)
571 gsymbol
->language
= language_java
;
575 if (gsymbol
->language
== language_d
576 || gsymbol
->language
== language_auto
)
578 demangled
= d_demangle(mangled
, 0);
579 if (demangled
!= NULL
)
581 gsymbol
->language
= language_d
;
585 /* We could support `gsymbol->language == language_fortran' here to provide
586 module namespaces also for inferiors with only minimal symbol table (ELF
587 symbols). Just the mangling standard is not standardized across compilers
588 and there is no DW_AT_producer available for inferiors with only the ELF
589 symbols to check the mangling kind. */
593 /* Set both the mangled and demangled (if any) names for GSYMBOL based
594 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
595 objfile's obstack; but if COPY_NAME is 0 and if NAME is
596 NUL-terminated, then this function assumes that NAME is already
597 correctly saved (either permanently or with a lifetime tied to the
598 objfile), and it will not be copied.
600 The hash table corresponding to OBJFILE is used, and the memory
601 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
602 so the pointer can be discarded after calling this function. */
604 /* We have to be careful when dealing with Java names: when we run
605 into a Java minimal symbol, we don't know it's a Java symbol, so it
606 gets demangled as a C++ name. This is unfortunate, but there's not
607 much we can do about it: but when demangling partial symbols and
608 regular symbols, we'd better not reuse the wrong demangled name.
609 (See PR gdb/1039.) We solve this by putting a distinctive prefix
610 on Java names when storing them in the hash table. */
612 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
613 don't mind the Java prefix so much: different languages have
614 different demangling requirements, so it's only natural that we
615 need to keep language data around in our demangling cache. But
616 it's not good that the minimal symbol has the wrong demangled name.
617 Unfortunately, I can't think of any easy solution to that
620 #define JAVA_PREFIX "##JAVA$$"
621 #define JAVA_PREFIX_LEN 8
624 symbol_set_names (struct general_symbol_info
*gsymbol
,
625 const char *linkage_name
, int len
, int copy_name
,
626 struct objfile
*objfile
)
628 struct demangled_name_entry
**slot
;
629 /* A 0-terminated copy of the linkage name. */
630 const char *linkage_name_copy
;
631 /* A copy of the linkage name that might have a special Java prefix
632 added to it, for use when looking names up in the hash table. */
633 const char *lookup_name
;
634 /* The length of lookup_name. */
636 struct demangled_name_entry entry
;
638 if (gsymbol
->language
== language_ada
)
640 /* In Ada, we do the symbol lookups using the mangled name, so
641 we can save some space by not storing the demangled name.
643 As a side note, we have also observed some overlap between
644 the C++ mangling and Ada mangling, similarly to what has
645 been observed with Java. Because we don't store the demangled
646 name with the symbol, we don't need to use the same trick
649 gsymbol
->name
= (char *) linkage_name
;
652 gsymbol
->name
= obstack_alloc (&objfile
->objfile_obstack
, len
+ 1);
653 memcpy (gsymbol
->name
, linkage_name
, len
);
654 gsymbol
->name
[len
] = '\0';
656 symbol_set_demangled_name (gsymbol
, NULL
, NULL
);
661 if (objfile
->demangled_names_hash
== NULL
)
662 create_demangled_names_hash (objfile
);
664 /* The stabs reader generally provides names that are not
665 NUL-terminated; most of the other readers don't do this, so we
666 can just use the given copy, unless we're in the Java case. */
667 if (gsymbol
->language
== language_java
)
671 lookup_len
= len
+ JAVA_PREFIX_LEN
;
672 alloc_name
= alloca (lookup_len
+ 1);
673 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
674 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
675 alloc_name
[lookup_len
] = '\0';
677 lookup_name
= alloc_name
;
678 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
680 else if (linkage_name
[len
] != '\0')
685 alloc_name
= alloca (lookup_len
+ 1);
686 memcpy (alloc_name
, linkage_name
, len
);
687 alloc_name
[lookup_len
] = '\0';
689 lookup_name
= alloc_name
;
690 linkage_name_copy
= alloc_name
;
695 lookup_name
= linkage_name
;
696 linkage_name_copy
= linkage_name
;
699 entry
.mangled
= (char *) lookup_name
;
700 slot
= ((struct demangled_name_entry
**)
701 htab_find_slot (objfile
->demangled_names_hash
,
704 /* If this name is not in the hash table, add it. */
707 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
709 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
711 /* Suppose we have demangled_name==NULL, copy_name==0, and
712 lookup_name==linkage_name. In this case, we already have the
713 mangled name saved, and we don't have a demangled name. So,
714 you might think we could save a little space by not recording
715 this in the hash table at all.
717 It turns out that it is actually important to still save such
718 an entry in the hash table, because storing this name gives
719 us better bcache hit rates for partial symbols. */
720 if (!copy_name
&& lookup_name
== linkage_name
)
722 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
723 offsetof (struct demangled_name_entry
,
725 + demangled_len
+ 1);
726 (*slot
)->mangled
= (char *) lookup_name
;
730 /* If we must copy the mangled name, put it directly after
731 the demangled name so we can have a single
733 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
734 offsetof (struct demangled_name_entry
,
736 + lookup_len
+ demangled_len
+ 2);
737 (*slot
)->mangled
= &((*slot
)->demangled
[demangled_len
+ 1]);
738 strcpy ((*slot
)->mangled
, lookup_name
);
741 if (demangled_name
!= NULL
)
743 strcpy ((*slot
)->demangled
, demangled_name
);
744 xfree (demangled_name
);
747 (*slot
)->demangled
[0] = '\0';
750 gsymbol
->name
= (*slot
)->mangled
+ lookup_len
- len
;
751 if ((*slot
)->demangled
[0] != '\0')
752 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
, objfile
);
754 symbol_set_demangled_name (gsymbol
, NULL
, objfile
);
757 /* Return the source code name of a symbol. In languages where
758 demangling is necessary, this is the demangled name. */
761 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
763 switch (gsymbol
->language
)
769 case language_fortran
:
770 if (symbol_get_demangled_name (gsymbol
) != NULL
)
771 return symbol_get_demangled_name (gsymbol
);
774 if (symbol_get_demangled_name (gsymbol
) != NULL
)
775 return symbol_get_demangled_name (gsymbol
);
777 return ada_decode_symbol (gsymbol
);
782 return gsymbol
->name
;
785 /* Return the demangled name for a symbol based on the language for
786 that symbol. If no demangled name exists, return NULL. */
788 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
790 switch (gsymbol
->language
)
796 case language_fortran
:
797 if (symbol_get_demangled_name (gsymbol
) != NULL
)
798 return symbol_get_demangled_name (gsymbol
);
801 if (symbol_get_demangled_name (gsymbol
) != NULL
)
802 return symbol_get_demangled_name (gsymbol
);
804 return ada_decode_symbol (gsymbol
);
812 /* Return the search name of a symbol---generally the demangled or
813 linkage name of the symbol, depending on how it will be searched for.
814 If there is no distinct demangled name, then returns the same value
815 (same pointer) as SYMBOL_LINKAGE_NAME. */
817 symbol_search_name (const struct general_symbol_info
*gsymbol
)
819 if (gsymbol
->language
== language_ada
)
820 return gsymbol
->name
;
822 return symbol_natural_name (gsymbol
);
825 /* Initialize the structure fields to zero values. */
827 init_sal (struct symtab_and_line
*sal
)
835 sal
->explicit_pc
= 0;
836 sal
->explicit_line
= 0;
840 /* Return 1 if the two sections are the same, or if they could
841 plausibly be copies of each other, one in an original object
842 file and another in a separated debug file. */
845 matching_obj_sections (struct obj_section
*obj_first
,
846 struct obj_section
*obj_second
)
848 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
849 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
852 /* If they're the same section, then they match. */
856 /* If either is NULL, give up. */
857 if (first
== NULL
|| second
== NULL
)
860 /* This doesn't apply to absolute symbols. */
861 if (first
->owner
== NULL
|| second
->owner
== NULL
)
864 /* If they're in the same object file, they must be different sections. */
865 if (first
->owner
== second
->owner
)
868 /* Check whether the two sections are potentially corresponding. They must
869 have the same size, address, and name. We can't compare section indexes,
870 which would be more reliable, because some sections may have been
872 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
875 /* In-memory addresses may start at a different offset, relativize them. */
876 if (bfd_get_section_vma (first
->owner
, first
)
877 - bfd_get_start_address (first
->owner
)
878 != bfd_get_section_vma (second
->owner
, second
)
879 - bfd_get_start_address (second
->owner
))
882 if (bfd_get_section_name (first
->owner
, first
) == NULL
883 || bfd_get_section_name (second
->owner
, second
) == NULL
884 || strcmp (bfd_get_section_name (first
->owner
, first
),
885 bfd_get_section_name (second
->owner
, second
)) != 0)
888 /* Otherwise check that they are in corresponding objfiles. */
891 if (obj
->obfd
== first
->owner
)
893 gdb_assert (obj
!= NULL
);
895 if (obj
->separate_debug_objfile
!= NULL
896 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
898 if (obj
->separate_debug_objfile_backlink
!= NULL
899 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
906 find_pc_sect_symtab_via_partial (CORE_ADDR pc
, struct obj_section
*section
)
908 struct objfile
*objfile
;
909 struct minimal_symbol
*msymbol
;
911 /* If we know that this is not a text address, return failure. This is
912 necessary because we loop based on texthigh and textlow, which do
913 not include the data ranges. */
914 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
916 && (MSYMBOL_TYPE (msymbol
) == mst_data
917 || MSYMBOL_TYPE (msymbol
) == mst_bss
918 || MSYMBOL_TYPE (msymbol
) == mst_abs
919 || MSYMBOL_TYPE (msymbol
) == mst_file_data
920 || MSYMBOL_TYPE (msymbol
) == mst_file_bss
))
923 ALL_OBJFILES (objfile
)
925 struct symtab
*result
= NULL
;
928 result
= objfile
->sf
->qf
->find_pc_sect_symtab (objfile
, msymbol
,
937 /* Debug symbols usually don't have section information. We need to dig that
938 out of the minimal symbols and stash that in the debug symbol. */
941 fixup_section (struct general_symbol_info
*ginfo
,
942 CORE_ADDR addr
, struct objfile
*objfile
)
944 struct minimal_symbol
*msym
;
946 /* First, check whether a minimal symbol with the same name exists
947 and points to the same address. The address check is required
948 e.g. on PowerPC64, where the minimal symbol for a function will
949 point to the function descriptor, while the debug symbol will
950 point to the actual function code. */
951 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
954 ginfo
->obj_section
= SYMBOL_OBJ_SECTION (msym
);
955 ginfo
->section
= SYMBOL_SECTION (msym
);
959 /* Static, function-local variables do appear in the linker
960 (minimal) symbols, but are frequently given names that won't
961 be found via lookup_minimal_symbol(). E.g., it has been
962 observed in frv-uclinux (ELF) executables that a static,
963 function-local variable named "foo" might appear in the
964 linker symbols as "foo.6" or "foo.3". Thus, there is no
965 point in attempting to extend the lookup-by-name mechanism to
966 handle this case due to the fact that there can be multiple
969 So, instead, search the section table when lookup by name has
970 failed. The ``addr'' and ``endaddr'' fields may have already
971 been relocated. If so, the relocation offset (i.e. the
972 ANOFFSET value) needs to be subtracted from these values when
973 performing the comparison. We unconditionally subtract it,
974 because, when no relocation has been performed, the ANOFFSET
975 value will simply be zero.
977 The address of the symbol whose section we're fixing up HAS
978 NOT BEEN adjusted (relocated) yet. It can't have been since
979 the section isn't yet known and knowing the section is
980 necessary in order to add the correct relocation value. In
981 other words, we wouldn't even be in this function (attempting
982 to compute the section) if it were already known.
984 Note that it is possible to search the minimal symbols
985 (subtracting the relocation value if necessary) to find the
986 matching minimal symbol, but this is overkill and much less
987 efficient. It is not necessary to find the matching minimal
988 symbol, only its section.
990 Note that this technique (of doing a section table search)
991 can fail when unrelocated section addresses overlap. For
992 this reason, we still attempt a lookup by name prior to doing
993 a search of the section table. */
995 struct obj_section
*s
;
997 ALL_OBJFILE_OSECTIONS (objfile
, s
)
999 int idx
= s
->the_bfd_section
->index
;
1000 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1002 if (obj_section_addr (s
) - offset
<= addr
1003 && addr
< obj_section_endaddr (s
) - offset
)
1005 ginfo
->obj_section
= s
;
1006 ginfo
->section
= idx
;
1014 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1021 if (SYMBOL_OBJ_SECTION (sym
))
1024 /* We either have an OBJFILE, or we can get at it from the sym's
1025 symtab. Anything else is a bug. */
1026 gdb_assert (objfile
|| SYMBOL_SYMTAB (sym
));
1028 if (objfile
== NULL
)
1029 objfile
= SYMBOL_SYMTAB (sym
)->objfile
;
1031 /* We should have an objfile by now. */
1032 gdb_assert (objfile
);
1034 switch (SYMBOL_CLASS (sym
))
1038 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1041 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1045 /* Nothing else will be listed in the minsyms -- no use looking
1050 fixup_section (&sym
->ginfo
, addr
, objfile
);
1055 /* Compute the demangled form of NAME as used by the various symbol
1056 lookup functions. The result is stored in *RESULT_NAME. Returns a
1057 cleanup which can be used to clean up the result.
1059 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1060 Normally, Ada symbol lookups are performed using the encoded name
1061 rather than the demangled name, and so it might seem to make sense
1062 for this function to return an encoded version of NAME.
1063 Unfortunately, we cannot do this, because this function is used in
1064 circumstances where it is not appropriate to try to encode NAME.
1065 For instance, when displaying the frame info, we demangle the name
1066 of each parameter, and then perform a symbol lookup inside our
1067 function using that demangled name. In Ada, certain functions
1068 have internally-generated parameters whose name contain uppercase
1069 characters. Encoding those name would result in those uppercase
1070 characters to become lowercase, and thus cause the symbol lookup
1074 demangle_for_lookup (const char *name
, enum language lang
,
1075 const char **result_name
)
1077 char *demangled_name
= NULL
;
1078 const char *modified_name
= NULL
;
1079 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, 0);
1081 modified_name
= name
;
1083 /* If we are using C++, D, or Java, demangle the name before doing a
1084 lookup, so we can always binary search. */
1085 if (lang
== language_cplus
)
1087 demangled_name
= cplus_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1090 modified_name
= demangled_name
;
1091 make_cleanup (xfree
, demangled_name
);
1095 /* If we were given a non-mangled name, canonicalize it
1096 according to the language (so far only for C++). */
1097 demangled_name
= cp_canonicalize_string (name
);
1100 modified_name
= demangled_name
;
1101 make_cleanup (xfree
, demangled_name
);
1105 else if (lang
== language_java
)
1107 demangled_name
= cplus_demangle (name
,
1108 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1111 modified_name
= demangled_name
;
1112 make_cleanup (xfree
, demangled_name
);
1115 else if (lang
== language_d
)
1117 demangled_name
= d_demangle (name
, 0);
1120 modified_name
= demangled_name
;
1121 make_cleanup (xfree
, demangled_name
);
1125 *result_name
= modified_name
;
1129 /* Find the definition for a specified symbol name NAME
1130 in domain DOMAIN, visible from lexical block BLOCK.
1131 Returns the struct symbol pointer, or zero if no symbol is found.
1132 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1133 NAME is a field of the current implied argument `this'. If so set
1134 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1135 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1136 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1138 /* This function has a bunch of loops in it and it would seem to be
1139 attractive to put in some QUIT's (though I'm not really sure
1140 whether it can run long enough to be really important). But there
1141 are a few calls for which it would appear to be bad news to quit
1142 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note
1143 that there is C++ code below which can error(), but that probably
1144 doesn't affect these calls since they are looking for a known
1145 variable and thus can probably assume it will never hit the C++
1149 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1150 const domain_enum domain
, enum language lang
,
1151 int *is_a_field_of_this
)
1153 const char *modified_name
;
1154 struct symbol
*returnval
;
1155 struct cleanup
*cleanup
= demangle_for_lookup (name
, lang
, &modified_name
);
1157 returnval
= lookup_symbol_aux (modified_name
, block
, domain
, lang
,
1158 is_a_field_of_this
);
1159 do_cleanups (cleanup
);
1164 /* Behave like lookup_symbol_in_language, but performed with the
1165 current language. */
1168 lookup_symbol (const char *name
, const struct block
*block
,
1169 domain_enum domain
, int *is_a_field_of_this
)
1171 return lookup_symbol_in_language (name
, block
, domain
,
1172 current_language
->la_language
,
1173 is_a_field_of_this
);
1176 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1177 found, or NULL if not found. */
1180 lookup_language_this (const struct language_defn
*lang
,
1181 const struct block
*block
)
1183 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1190 sym
= lookup_block_symbol (block
, lang
->la_name_of_this
, VAR_DOMAIN
);
1193 if (BLOCK_FUNCTION (block
))
1195 block
= BLOCK_SUPERBLOCK (block
);
1201 /* Behave like lookup_symbol except that NAME is the natural name
1202 of the symbol that we're looking for and, if LINKAGE_NAME is
1203 non-NULL, ensure that the symbol's linkage name matches as
1206 static struct symbol
*
1207 lookup_symbol_aux (const char *name
, const struct block
*block
,
1208 const domain_enum domain
, enum language language
,
1209 int *is_a_field_of_this
)
1212 const struct language_defn
*langdef
;
1214 /* Make sure we do something sensible with is_a_field_of_this, since
1215 the callers that set this parameter to some non-null value will
1216 certainly use it later and expect it to be either 0 or 1.
1217 If we don't set it, the contents of is_a_field_of_this are
1219 if (is_a_field_of_this
!= NULL
)
1220 *is_a_field_of_this
= 0;
1222 /* Search specified block and its superiors. Don't search
1223 STATIC_BLOCK or GLOBAL_BLOCK. */
1225 sym
= lookup_symbol_aux_local (name
, block
, domain
, language
);
1229 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1230 check to see if NAME is a field of `this'. */
1232 langdef
= language_def (language
);
1234 if (is_a_field_of_this
!= NULL
)
1236 struct symbol
*sym
= lookup_language_this (langdef
, block
);
1240 struct type
*t
= sym
->type
;
1242 /* I'm not really sure that type of this can ever
1243 be typedefed; just be safe. */
1245 if (TYPE_CODE (t
) == TYPE_CODE_PTR
1246 || TYPE_CODE (t
) == TYPE_CODE_REF
)
1247 t
= TYPE_TARGET_TYPE (t
);
1249 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1250 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1251 error (_("Internal error: `%s' is not an aggregate"),
1252 langdef
->la_name_of_this
);
1254 if (check_field (t
, name
))
1256 *is_a_field_of_this
= 1;
1262 /* Now do whatever is appropriate for LANGUAGE to look
1263 up static and global variables. */
1265 sym
= langdef
->la_lookup_symbol_nonlocal (name
, block
, domain
);
1269 /* Now search all static file-level symbols. Not strictly correct,
1270 but more useful than an error. */
1272 return lookup_static_symbol_aux (name
, domain
);
1275 /* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1276 first, then check the psymtabs. If a psymtab indicates the existence of the
1277 desired name as a file-level static, then do psymtab-to-symtab conversion on
1278 the fly and return the found symbol. */
1281 lookup_static_symbol_aux (const char *name
, const domain_enum domain
)
1283 struct objfile
*objfile
;
1286 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, domain
);
1290 ALL_OBJFILES (objfile
)
1292 sym
= lookup_symbol_aux_quick (objfile
, STATIC_BLOCK
, name
, domain
);
1300 /* Check to see if the symbol is defined in BLOCK or its superiors.
1301 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1303 static struct symbol
*
1304 lookup_symbol_aux_local (const char *name
, const struct block
*block
,
1305 const domain_enum domain
,
1306 enum language language
)
1309 const struct block
*static_block
= block_static_block (block
);
1310 const char *scope
= block_scope (block
);
1312 /* Check if either no block is specified or it's a global block. */
1314 if (static_block
== NULL
)
1317 while (block
!= static_block
)
1319 sym
= lookup_symbol_aux_block (name
, block
, domain
);
1323 if (language
== language_cplus
|| language
== language_fortran
)
1325 sym
= cp_lookup_symbol_imports_or_template (scope
, name
, block
,
1331 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
1333 block
= BLOCK_SUPERBLOCK (block
);
1336 /* We've reached the edge of the function without finding a result. */
1341 /* Look up OBJFILE to BLOCK. */
1344 lookup_objfile_from_block (const struct block
*block
)
1346 struct objfile
*obj
;
1352 block
= block_global_block (block
);
1353 /* Go through SYMTABS. */
1354 ALL_SYMTABS (obj
, s
)
1355 if (block
== BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
))
1357 if (obj
->separate_debug_objfile_backlink
)
1358 obj
= obj
->separate_debug_objfile_backlink
;
1366 /* Look up a symbol in a block; if found, fixup the symbol, and set
1367 block_found appropriately. */
1370 lookup_symbol_aux_block (const char *name
, const struct block
*block
,
1371 const domain_enum domain
)
1375 sym
= lookup_block_symbol (block
, name
, domain
);
1378 block_found
= block
;
1379 return fixup_symbol_section (sym
, NULL
);
1385 /* Check all global symbols in OBJFILE in symtabs and
1389 lookup_global_symbol_from_objfile (const struct objfile
*main_objfile
,
1391 const domain_enum domain
)
1393 const struct objfile
*objfile
;
1395 struct blockvector
*bv
;
1396 const struct block
*block
;
1399 for (objfile
= main_objfile
;
1401 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
1403 /* Go through symtabs. */
1404 ALL_OBJFILE_SYMTABS (objfile
, s
)
1406 bv
= BLOCKVECTOR (s
);
1407 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1408 sym
= lookup_block_symbol (block
, name
, domain
);
1411 block_found
= block
;
1412 return fixup_symbol_section (sym
, (struct objfile
*)objfile
);
1416 sym
= lookup_symbol_aux_quick ((struct objfile
*) objfile
, GLOBAL_BLOCK
,
1425 /* Check to see if the symbol is defined in one of the symtabs.
1426 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1427 depending on whether or not we want to search global symbols or
1430 static struct symbol
*
1431 lookup_symbol_aux_symtabs (int block_index
, const char *name
,
1432 const domain_enum domain
)
1435 struct objfile
*objfile
;
1436 struct blockvector
*bv
;
1437 const struct block
*block
;
1440 ALL_OBJFILES (objfile
)
1443 objfile
->sf
->qf
->pre_expand_symtabs_matching (objfile
,
1447 ALL_OBJFILE_SYMTABS (objfile
, s
)
1450 bv
= BLOCKVECTOR (s
);
1451 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1452 sym
= lookup_block_symbol (block
, name
, domain
);
1455 block_found
= block
;
1456 return fixup_symbol_section (sym
, objfile
);
1464 /* A helper function for lookup_symbol_aux that interfaces with the
1465 "quick" symbol table functions. */
1467 static struct symbol
*
1468 lookup_symbol_aux_quick (struct objfile
*objfile
, int kind
,
1469 const char *name
, const domain_enum domain
)
1471 struct symtab
*symtab
;
1472 struct blockvector
*bv
;
1473 const struct block
*block
;
1478 symtab
= objfile
->sf
->qf
->lookup_symbol (objfile
, kind
, name
, domain
);
1482 bv
= BLOCKVECTOR (symtab
);
1483 block
= BLOCKVECTOR_BLOCK (bv
, kind
);
1484 sym
= lookup_block_symbol (block
, name
, domain
);
1487 /* This shouldn't be necessary, but as a last resort try
1488 looking in the statics even though the psymtab claimed
1489 the symbol was global, or vice-versa. It's possible
1490 that the psymtab gets it wrong in some cases. */
1492 /* FIXME: carlton/2002-09-30: Should we really do that?
1493 If that happens, isn't it likely to be a GDB error, in
1494 which case we should fix the GDB error rather than
1495 silently dealing with it here? So I'd vote for
1496 removing the check for the symbol in the other
1498 block
= BLOCKVECTOR_BLOCK (bv
,
1499 kind
== GLOBAL_BLOCK
?
1500 STATIC_BLOCK
: GLOBAL_BLOCK
);
1501 sym
= lookup_block_symbol (block
, name
, domain
);
1504 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1505 %s may be an inlined function, or may be a template function\n\
1506 (if a template, try specifying an instantiation: %s<type>)."),
1507 kind
== GLOBAL_BLOCK
? "global" : "static",
1508 name
, symtab
->filename
, name
, name
);
1510 return fixup_symbol_section (sym
, objfile
);
1513 /* A default version of lookup_symbol_nonlocal for use by languages
1514 that can't think of anything better to do. This implements the C
1518 basic_lookup_symbol_nonlocal (const char *name
,
1519 const struct block
*block
,
1520 const domain_enum domain
)
1524 /* NOTE: carlton/2003-05-19: The comments below were written when
1525 this (or what turned into this) was part of lookup_symbol_aux;
1526 I'm much less worried about these questions now, since these
1527 decisions have turned out well, but I leave these comments here
1530 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1531 not it would be appropriate to search the current global block
1532 here as well. (That's what this code used to do before the
1533 is_a_field_of_this check was moved up.) On the one hand, it's
1534 redundant with the lookup_symbol_aux_symtabs search that happens
1535 next. On the other hand, if decode_line_1 is passed an argument
1536 like filename:var, then the user presumably wants 'var' to be
1537 searched for in filename. On the third hand, there shouldn't be
1538 multiple global variables all of which are named 'var', and it's
1539 not like decode_line_1 has ever restricted its search to only
1540 global variables in a single filename. All in all, only
1541 searching the static block here seems best: it's correct and it's
1544 /* NOTE: carlton/2002-12-05: There's also a possible performance
1545 issue here: if you usually search for global symbols in the
1546 current file, then it would be slightly better to search the
1547 current global block before searching all the symtabs. But there
1548 are other factors that have a much greater effect on performance
1549 than that one, so I don't think we should worry about that for
1552 sym
= lookup_symbol_static (name
, block
, domain
);
1556 return lookup_symbol_global (name
, block
, domain
);
1559 /* Lookup a symbol in the static block associated to BLOCK, if there
1560 is one; do nothing if BLOCK is NULL or a global block. */
1563 lookup_symbol_static (const char *name
,
1564 const struct block
*block
,
1565 const domain_enum domain
)
1567 const struct block
*static_block
= block_static_block (block
);
1569 if (static_block
!= NULL
)
1570 return lookup_symbol_aux_block (name
, static_block
, domain
);
1575 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1579 lookup_symbol_global (const char *name
,
1580 const struct block
*block
,
1581 const domain_enum domain
)
1583 struct symbol
*sym
= NULL
;
1584 struct objfile
*objfile
= NULL
;
1586 /* Call library-specific lookup procedure. */
1587 objfile
= lookup_objfile_from_block (block
);
1588 if (objfile
!= NULL
)
1589 sym
= solib_global_lookup (objfile
, name
, domain
);
1593 sym
= lookup_symbol_aux_symtabs (GLOBAL_BLOCK
, name
, domain
);
1597 ALL_OBJFILES (objfile
)
1599 sym
= lookup_symbol_aux_quick (objfile
, GLOBAL_BLOCK
, name
, domain
);
1608 symbol_matches_domain (enum language symbol_language
,
1609 domain_enum symbol_domain
,
1612 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1613 A Java class declaration also defines a typedef for the class.
1614 Similarly, any Ada type declaration implicitly defines a typedef. */
1615 if (symbol_language
== language_cplus
1616 || symbol_language
== language_d
1617 || symbol_language
== language_java
1618 || symbol_language
== language_ada
)
1620 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
1621 && symbol_domain
== STRUCT_DOMAIN
)
1624 /* For all other languages, strict match is required. */
1625 return (symbol_domain
== domain
);
1628 /* Look up a type named NAME in the struct_domain. The type returned
1629 must not be opaque -- i.e., must have at least one field
1633 lookup_transparent_type (const char *name
)
1635 return current_language
->la_lookup_transparent_type (name
);
1638 /* A helper for basic_lookup_transparent_type that interfaces with the
1639 "quick" symbol table functions. */
1641 static struct type
*
1642 basic_lookup_transparent_type_quick (struct objfile
*objfile
, int kind
,
1645 struct symtab
*symtab
;
1646 struct blockvector
*bv
;
1647 struct block
*block
;
1652 symtab
= objfile
->sf
->qf
->lookup_symbol (objfile
, kind
, name
, STRUCT_DOMAIN
);
1656 bv
= BLOCKVECTOR (symtab
);
1657 block
= BLOCKVECTOR_BLOCK (bv
, kind
);
1658 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1661 int other_kind
= kind
== GLOBAL_BLOCK
? STATIC_BLOCK
: GLOBAL_BLOCK
;
1663 /* This shouldn't be necessary, but as a last resort
1664 * try looking in the 'other kind' even though the psymtab
1665 * claimed the symbol was one thing. It's possible that
1666 * the psymtab gets it wrong in some cases.
1668 block
= BLOCKVECTOR_BLOCK (bv
, other_kind
);
1669 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1671 /* FIXME; error is wrong in one case. */
1673 Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
1674 %s may be an inlined function, or may be a template function\n\
1675 (if a template, try specifying an instantiation: %s<type>)."),
1676 name
, symtab
->filename
, name
, name
);
1678 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1679 return SYMBOL_TYPE (sym
);
1684 /* The standard implementation of lookup_transparent_type. This code
1685 was modeled on lookup_symbol -- the parts not relevant to looking
1686 up types were just left out. In particular it's assumed here that
1687 types are available in struct_domain and only at file-static or
1691 basic_lookup_transparent_type (const char *name
)
1694 struct symtab
*s
= NULL
;
1695 struct blockvector
*bv
;
1696 struct objfile
*objfile
;
1697 struct block
*block
;
1700 /* Now search all the global symbols. Do the symtab's first, then
1701 check the psymtab's. If a psymtab indicates the existence
1702 of the desired name as a global, then do psymtab-to-symtab
1703 conversion on the fly and return the found symbol. */
1705 ALL_OBJFILES (objfile
)
1708 objfile
->sf
->qf
->pre_expand_symtabs_matching (objfile
,
1710 name
, STRUCT_DOMAIN
);
1712 ALL_OBJFILE_SYMTABS (objfile
, s
)
1715 bv
= BLOCKVECTOR (s
);
1716 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1717 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1718 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1720 return SYMBOL_TYPE (sym
);
1725 ALL_OBJFILES (objfile
)
1727 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
1732 /* Now search the static file-level symbols.
1733 Not strictly correct, but more useful than an error.
1734 Do the symtab's first, then
1735 check the psymtab's. If a psymtab indicates the existence
1736 of the desired name as a file-level static, then do psymtab-to-symtab
1737 conversion on the fly and return the found symbol. */
1739 ALL_OBJFILES (objfile
)
1742 objfile
->sf
->qf
->pre_expand_symtabs_matching (objfile
, STATIC_BLOCK
,
1743 name
, STRUCT_DOMAIN
);
1745 ALL_OBJFILE_SYMTABS (objfile
, s
)
1747 bv
= BLOCKVECTOR (s
);
1748 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1749 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1750 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1752 return SYMBOL_TYPE (sym
);
1757 ALL_OBJFILES (objfile
)
1759 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
1764 return (struct type
*) 0;
1768 /* Find the name of the file containing main(). */
1769 /* FIXME: What about languages without main() or specially linked
1770 executables that have no main() ? */
1773 find_main_filename (void)
1775 struct objfile
*objfile
;
1776 char *name
= main_name ();
1778 ALL_OBJFILES (objfile
)
1784 result
= objfile
->sf
->qf
->find_symbol_file (objfile
, name
);
1791 /* Search BLOCK for symbol NAME in DOMAIN.
1793 Note that if NAME is the demangled form of a C++ symbol, we will fail
1794 to find a match during the binary search of the non-encoded names, but
1795 for now we don't worry about the slight inefficiency of looking for
1796 a match we'll never find, since it will go pretty quick. Once the
1797 binary search terminates, we drop through and do a straight linear
1798 search on the symbols. Each symbol which is marked as being a ObjC/C++
1799 symbol (language_cplus or language_objc set) has both the encoded and
1800 non-encoded names tested for a match. */
1803 lookup_block_symbol (const struct block
*block
, const char *name
,
1804 const domain_enum domain
)
1806 struct dict_iterator iter
;
1809 if (!BLOCK_FUNCTION (block
))
1811 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1813 sym
= dict_iter_name_next (name
, &iter
))
1815 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1816 SYMBOL_DOMAIN (sym
), domain
))
1823 /* Note that parameter symbols do not always show up last in the
1824 list; this loop makes sure to take anything else other than
1825 parameter symbols first; it only uses parameter symbols as a
1826 last resort. Note that this only takes up extra computation
1829 struct symbol
*sym_found
= NULL
;
1831 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1833 sym
= dict_iter_name_next (name
, &iter
))
1835 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1836 SYMBOL_DOMAIN (sym
), domain
))
1839 if (!SYMBOL_IS_ARGUMENT (sym
))
1845 return (sym_found
); /* Will be NULL if not found. */
1849 /* Iterate over the symbols named NAME, matching DOMAIN, starting with
1852 For each symbol that matches, CALLBACK is called. The symbol and
1853 DATA are passed to the callback.
1855 If CALLBACK returns zero, the iteration ends. Otherwise, the
1856 search continues. This function iterates upward through blocks.
1857 When the outermost block has been finished, the function
1861 iterate_over_symbols (const struct block
*block
, const char *name
,
1862 const domain_enum domain
,
1863 int (*callback
) (struct symbol
*, void *),
1868 struct dict_iterator iter
;
1871 for (sym
= dict_iter_name_first (BLOCK_DICT (block
), name
, &iter
);
1873 sym
= dict_iter_name_next (name
, &iter
))
1875 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1876 SYMBOL_DOMAIN (sym
), domain
))
1878 if (!callback (sym
, data
))
1883 block
= BLOCK_SUPERBLOCK (block
);
1887 /* Find the symtab associated with PC and SECTION. Look through the
1888 psymtabs and read in another symtab if necessary. */
1891 find_pc_sect_symtab (CORE_ADDR pc
, struct obj_section
*section
)
1894 struct blockvector
*bv
;
1895 struct symtab
*s
= NULL
;
1896 struct symtab
*best_s
= NULL
;
1897 struct objfile
*objfile
;
1898 struct program_space
*pspace
;
1899 CORE_ADDR distance
= 0;
1900 struct minimal_symbol
*msymbol
;
1902 pspace
= current_program_space
;
1904 /* If we know that this is not a text address, return failure. This is
1905 necessary because we loop based on the block's high and low code
1906 addresses, which do not include the data ranges, and because
1907 we call find_pc_sect_psymtab which has a similar restriction based
1908 on the partial_symtab's texthigh and textlow. */
1909 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1911 && (MSYMBOL_TYPE (msymbol
) == mst_data
1912 || MSYMBOL_TYPE (msymbol
) == mst_bss
1913 || MSYMBOL_TYPE (msymbol
) == mst_abs
1914 || MSYMBOL_TYPE (msymbol
) == mst_file_data
1915 || MSYMBOL_TYPE (msymbol
) == mst_file_bss
))
1918 /* Search all symtabs for the one whose file contains our address, and which
1919 is the smallest of all the ones containing the address. This is designed
1920 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
1921 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
1922 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
1924 This happens for native ecoff format, where code from included files
1925 gets its own symtab. The symtab for the included file should have
1926 been read in already via the dependency mechanism.
1927 It might be swifter to create several symtabs with the same name
1928 like xcoff does (I'm not sure).
1930 It also happens for objfiles that have their functions reordered.
1931 For these, the symtab we are looking for is not necessarily read in. */
1933 ALL_PRIMARY_SYMTABS (objfile
, s
)
1935 bv
= BLOCKVECTOR (s
);
1936 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1938 if (BLOCK_START (b
) <= pc
1939 && BLOCK_END (b
) > pc
1941 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
1943 /* For an objfile that has its functions reordered,
1944 find_pc_psymtab will find the proper partial symbol table
1945 and we simply return its corresponding symtab. */
1946 /* In order to better support objfiles that contain both
1947 stabs and coff debugging info, we continue on if a psymtab
1949 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->sf
)
1951 struct symtab
*result
;
1954 = objfile
->sf
->qf
->find_pc_sect_symtab (objfile
,
1963 struct dict_iterator iter
;
1964 struct symbol
*sym
= NULL
;
1966 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1968 fixup_symbol_section (sym
, objfile
);
1969 if (matching_obj_sections (SYMBOL_OBJ_SECTION (sym
), section
))
1973 continue; /* No symbol in this symtab matches
1976 distance
= BLOCK_END (b
) - BLOCK_START (b
);
1984 ALL_OBJFILES (objfile
)
1986 struct symtab
*result
;
1990 result
= objfile
->sf
->qf
->find_pc_sect_symtab (objfile
,
2001 /* Find the symtab associated with PC. Look through the psymtabs and read
2002 in another symtab if necessary. Backward compatibility, no section. */
2005 find_pc_symtab (CORE_ADDR pc
)
2007 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
2011 /* Find the source file and line number for a given PC value and SECTION.
2012 Return a structure containing a symtab pointer, a line number,
2013 and a pc range for the entire source line.
2014 The value's .pc field is NOT the specified pc.
2015 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2016 use the line that ends there. Otherwise, in that case, the line
2017 that begins there is used. */
2019 /* The big complication here is that a line may start in one file, and end just
2020 before the start of another file. This usually occurs when you #include
2021 code in the middle of a subroutine. To properly find the end of a line's PC
2022 range, we must search all symtabs associated with this compilation unit, and
2023 find the one whose first PC is closer than that of the next line in this
2026 /* If it's worth the effort, we could be using a binary search. */
2028 struct symtab_and_line
2029 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
2032 struct linetable
*l
;
2035 struct linetable_entry
*item
;
2036 struct symtab_and_line val
;
2037 struct blockvector
*bv
;
2038 struct minimal_symbol
*msymbol
;
2039 struct minimal_symbol
*mfunsym
;
2040 struct objfile
*objfile
;
2042 /* Info on best line seen so far, and where it starts, and its file. */
2044 struct linetable_entry
*best
= NULL
;
2045 CORE_ADDR best_end
= 0;
2046 struct symtab
*best_symtab
= 0;
2048 /* Store here the first line number
2049 of a file which contains the line at the smallest pc after PC.
2050 If we don't find a line whose range contains PC,
2051 we will use a line one less than this,
2052 with a range from the start of that file to the first line's pc. */
2053 struct linetable_entry
*alt
= NULL
;
2054 struct symtab
*alt_symtab
= 0;
2056 /* Info on best line seen in this file. */
2058 struct linetable_entry
*prev
;
2060 /* If this pc is not from the current frame,
2061 it is the address of the end of a call instruction.
2062 Quite likely that is the start of the following statement.
2063 But what we want is the statement containing the instruction.
2064 Fudge the pc to make sure we get that. */
2066 init_sal (&val
); /* initialize to zeroes */
2068 val
.pspace
= current_program_space
;
2070 /* It's tempting to assume that, if we can't find debugging info for
2071 any function enclosing PC, that we shouldn't search for line
2072 number info, either. However, GAS can emit line number info for
2073 assembly files --- very helpful when debugging hand-written
2074 assembly code. In such a case, we'd have no debug info for the
2075 function, but we would have line info. */
2080 /* elz: added this because this function returned the wrong
2081 information if the pc belongs to a stub (import/export)
2082 to call a shlib function. This stub would be anywhere between
2083 two functions in the target, and the line info was erroneously
2084 taken to be the one of the line before the pc. */
2086 /* RT: Further explanation:
2088 * We have stubs (trampolines) inserted between procedures.
2090 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2091 * exists in the main image.
2093 * In the minimal symbol table, we have a bunch of symbols
2094 * sorted by start address. The stubs are marked as "trampoline",
2095 * the others appear as text. E.g.:
2097 * Minimal symbol table for main image
2098 * main: code for main (text symbol)
2099 * shr1: stub (trampoline symbol)
2100 * foo: code for foo (text symbol)
2102 * Minimal symbol table for "shr1" image:
2104 * shr1: code for shr1 (text symbol)
2107 * So the code below is trying to detect if we are in the stub
2108 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2109 * and if found, do the symbolization from the real-code address
2110 * rather than the stub address.
2112 * Assumptions being made about the minimal symbol table:
2113 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2114 * if we're really in the trampoline.s If we're beyond it (say
2115 * we're in "foo" in the above example), it'll have a closer
2116 * symbol (the "foo" text symbol for example) and will not
2117 * return the trampoline.
2118 * 2. lookup_minimal_symbol_text() will find a real text symbol
2119 * corresponding to the trampoline, and whose address will
2120 * be different than the trampoline address. I put in a sanity
2121 * check for the address being the same, to avoid an
2122 * infinite recursion.
2124 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2125 if (msymbol
!= NULL
)
2126 if (MSYMBOL_TYPE (msymbol
) == mst_solib_trampoline
)
2128 mfunsym
= lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol
),
2130 if (mfunsym
== NULL
)
2131 /* I eliminated this warning since it is coming out
2132 * in the following situation:
2133 * gdb shmain // test program with shared libraries
2134 * (gdb) break shr1 // function in shared lib
2135 * Warning: In stub for ...
2136 * In the above situation, the shared lib is not loaded yet,
2137 * so of course we can't find the real func/line info,
2138 * but the "break" still works, and the warning is annoying.
2139 * So I commented out the warning. RT */
2140 /* warning ("In stub for %s; unable to find real function/line info",
2141 SYMBOL_LINKAGE_NAME (msymbol)); */
2144 else if (SYMBOL_VALUE_ADDRESS (mfunsym
)
2145 == SYMBOL_VALUE_ADDRESS (msymbol
))
2146 /* Avoid infinite recursion */
2147 /* See above comment about why warning is commented out. */
2148 /* warning ("In stub for %s; unable to find real function/line info",
2149 SYMBOL_LINKAGE_NAME (msymbol)); */
2153 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym
), 0);
2157 s
= find_pc_sect_symtab (pc
, section
);
2160 /* If no symbol information, return previous pc. */
2167 bv
= BLOCKVECTOR (s
);
2168 objfile
= s
->objfile
;
2170 /* Look at all the symtabs that share this blockvector.
2171 They all have the same apriori range, that we found was right;
2172 but they have different line tables. */
2174 ALL_OBJFILE_SYMTABS (objfile
, s
)
2176 if (BLOCKVECTOR (s
) != bv
)
2179 /* Find the best line in this symtab. */
2186 /* I think len can be zero if the symtab lacks line numbers
2187 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2188 I'm not sure which, and maybe it depends on the symbol
2194 item
= l
->item
; /* Get first line info. */
2196 /* Is this file's first line closer than the first lines of other files?
2197 If so, record this file, and its first line, as best alternate. */
2198 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2204 for (i
= 0; i
< len
; i
++, item
++)
2206 /* Leave prev pointing to the linetable entry for the last line
2207 that started at or before PC. */
2214 /* At this point, prev points at the line whose start addr is <= pc, and
2215 item points at the next line. If we ran off the end of the linetable
2216 (pc >= start of the last line), then prev == item. If pc < start of
2217 the first line, prev will not be set. */
2219 /* Is this file's best line closer than the best in the other files?
2220 If so, record this file, and its best line, as best so far. Don't
2221 save prev if it represents the end of a function (i.e. line number
2222 0) instead of a real line. */
2224 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2229 /* Discard BEST_END if it's before the PC of the current BEST. */
2230 if (best_end
<= best
->pc
)
2234 /* If another line (denoted by ITEM) is in the linetable and its
2235 PC is after BEST's PC, but before the current BEST_END, then
2236 use ITEM's PC as the new best_end. */
2237 if (best
&& i
< len
&& item
->pc
> best
->pc
2238 && (best_end
== 0 || best_end
> item
->pc
))
2239 best_end
= item
->pc
;
2244 /* If we didn't find any line number info, just return zeros.
2245 We used to return alt->line - 1 here, but that could be
2246 anywhere; if we don't have line number info for this PC,
2247 don't make some up. */
2250 else if (best
->line
== 0)
2252 /* If our best fit is in a range of PC's for which no line
2253 number info is available (line number is zero) then we didn't
2254 find any valid line information. */
2259 val
.symtab
= best_symtab
;
2260 val
.line
= best
->line
;
2262 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2267 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2269 val
.section
= section
;
2273 /* Backward compatibility (no section). */
2275 struct symtab_and_line
2276 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2278 struct obj_section
*section
;
2280 section
= find_pc_overlay (pc
);
2281 if (pc_in_unmapped_range (pc
, section
))
2282 pc
= overlay_mapped_address (pc
, section
);
2283 return find_pc_sect_line (pc
, section
, notcurrent
);
2286 /* Find line number LINE in any symtab whose name is the same as
2289 If found, return the symtab that contains the linetable in which it was
2290 found, set *INDEX to the index in the linetable of the best entry
2291 found, and set *EXACT_MATCH nonzero if the value returned is an
2294 If not found, return NULL. */
2297 find_line_symtab (struct symtab
*symtab
, int line
,
2298 int *index
, int *exact_match
)
2300 int exact
= 0; /* Initialized here to avoid a compiler warning. */
2302 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2306 struct linetable
*best_linetable
;
2307 struct symtab
*best_symtab
;
2309 /* First try looking it up in the given symtab. */
2310 best_linetable
= LINETABLE (symtab
);
2311 best_symtab
= symtab
;
2312 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
2313 if (best_index
< 0 || !exact
)
2315 /* Didn't find an exact match. So we better keep looking for
2316 another symtab with the same name. In the case of xcoff,
2317 multiple csects for one source file (produced by IBM's FORTRAN
2318 compiler) produce multiple symtabs (this is unavoidable
2319 assuming csects can be at arbitrary places in memory and that
2320 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2322 /* BEST is the smallest linenumber > LINE so far seen,
2323 or 0 if none has been seen so far.
2324 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2327 struct objfile
*objfile
;
2330 if (best_index
>= 0)
2331 best
= best_linetable
->item
[best_index
].line
;
2335 ALL_OBJFILES (objfile
)
2338 objfile
->sf
->qf
->expand_symtabs_with_filename (objfile
,
2342 /* Get symbol full file name if possible. */
2343 symtab_to_fullname (symtab
);
2345 ALL_SYMTABS (objfile
, s
)
2347 struct linetable
*l
;
2350 if (FILENAME_CMP (symtab
->filename
, s
->filename
) != 0)
2352 if (symtab
->fullname
!= NULL
2353 && symtab_to_fullname (s
) != NULL
2354 && FILENAME_CMP (symtab
->fullname
, s
->fullname
) != 0)
2357 ind
= find_line_common (l
, line
, &exact
, 0);
2367 if (best
== 0 || l
->item
[ind
].line
< best
)
2369 best
= l
->item
[ind
].line
;
2382 *index
= best_index
;
2384 *exact_match
= exact
;
2389 /* Given SYMTAB, returns all the PCs function in the symtab that
2390 exactly match LINE. Returns NULL if there are no exact matches,
2391 but updates BEST_ITEM in this case. */
2394 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
2395 struct linetable_entry
**best_item
)
2398 struct symbol
*previous_function
= NULL
;
2399 VEC (CORE_ADDR
) *result
= NULL
;
2401 /* First, collect all the PCs that are at this line. */
2407 idx
= find_line_common (LINETABLE (symtab
), line
, &was_exact
, start
);
2413 struct linetable_entry
*item
= &LINETABLE (symtab
)->item
[idx
];
2415 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
2421 VEC_safe_push (CORE_ADDR
, result
, LINETABLE (symtab
)->item
[idx
].pc
);
2429 /* Set the PC value for a given source file and line number and return true.
2430 Returns zero for invalid line number (and sets the PC to 0).
2431 The source file is specified with a struct symtab. */
2434 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2436 struct linetable
*l
;
2443 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2446 l
= LINETABLE (symtab
);
2447 *pc
= l
->item
[ind
].pc
;
2454 /* Find the range of pc values in a line.
2455 Store the starting pc of the line into *STARTPTR
2456 and the ending pc (start of next line) into *ENDPTR.
2457 Returns 1 to indicate success.
2458 Returns 0 if could not find the specified line. */
2461 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2464 CORE_ADDR startaddr
;
2465 struct symtab_and_line found_sal
;
2468 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2471 /* This whole function is based on address. For example, if line 10 has
2472 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2473 "info line *0x123" should say the line goes from 0x100 to 0x200
2474 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2475 This also insures that we never give a range like "starts at 0x134
2476 and ends at 0x12c". */
2478 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2479 if (found_sal
.line
!= sal
.line
)
2481 /* The specified line (sal) has zero bytes. */
2482 *startptr
= found_sal
.pc
;
2483 *endptr
= found_sal
.pc
;
2487 *startptr
= found_sal
.pc
;
2488 *endptr
= found_sal
.end
;
2493 /* Given a line table and a line number, return the index into the line
2494 table for the pc of the nearest line whose number is >= the specified one.
2495 Return -1 if none is found. The value is >= 0 if it is an index.
2496 START is the index at which to start searching the line table.
2498 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2501 find_line_common (struct linetable
*l
, int lineno
,
2502 int *exact_match
, int start
)
2507 /* BEST is the smallest linenumber > LINENO so far seen,
2508 or 0 if none has been seen so far.
2509 BEST_INDEX identifies the item for it. */
2511 int best_index
= -1;
2522 for (i
= start
; i
< len
; i
++)
2524 struct linetable_entry
*item
= &(l
->item
[i
]);
2526 if (item
->line
== lineno
)
2528 /* Return the first (lowest address) entry which matches. */
2533 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2540 /* If we got here, we didn't get an exact match. */
2545 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2547 struct symtab_and_line sal
;
2549 sal
= find_pc_line (pc
, 0);
2552 return sal
.symtab
!= 0;
2555 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2556 address for that function that has an entry in SYMTAB's line info
2557 table. If such an entry cannot be found, return FUNC_ADDR
2560 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
2562 CORE_ADDR func_start
, func_end
;
2563 struct linetable
*l
;
2566 /* Give up if this symbol has no lineinfo table. */
2567 l
= LINETABLE (symtab
);
2571 /* Get the range for the function's PC values, or give up if we
2572 cannot, for some reason. */
2573 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
2576 /* Linetable entries are ordered by PC values, see the commentary in
2577 symtab.h where `struct linetable' is defined. Thus, the first
2578 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2579 address we are looking for. */
2580 for (i
= 0; i
< l
->nitems
; i
++)
2582 struct linetable_entry
*item
= &(l
->item
[i
]);
2584 /* Don't use line numbers of zero, they mark special entries in
2585 the table. See the commentary on symtab.h before the
2586 definition of struct linetable. */
2587 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
2594 /* Given a function symbol SYM, find the symtab and line for the start
2596 If the argument FUNFIRSTLINE is nonzero, we want the first line
2597 of real code inside the function. */
2599 struct symtab_and_line
2600 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2602 struct symtab_and_line sal
;
2604 fixup_symbol_section (sym
, NULL
);
2605 sal
= find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2606 SYMBOL_OBJ_SECTION (sym
), 0);
2608 /* We always should have a line for the function start address.
2609 If we don't, something is odd. Create a plain SAL refering
2610 just the PC and hope that skip_prologue_sal (if requested)
2611 can find a line number for after the prologue. */
2612 if (sal
.pc
< BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)))
2615 sal
.pspace
= current_program_space
;
2616 sal
.pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2617 sal
.section
= SYMBOL_OBJ_SECTION (sym
);
2621 skip_prologue_sal (&sal
);
2626 /* Adjust SAL to the first instruction past the function prologue.
2627 If the PC was explicitly specified, the SAL is not changed.
2628 If the line number was explicitly specified, at most the SAL's PC
2629 is updated. If SAL is already past the prologue, then do nothing. */
2631 skip_prologue_sal (struct symtab_and_line
*sal
)
2634 struct symtab_and_line start_sal
;
2635 struct cleanup
*old_chain
;
2636 CORE_ADDR pc
, saved_pc
;
2637 struct obj_section
*section
;
2639 struct objfile
*objfile
;
2640 struct gdbarch
*gdbarch
;
2641 struct block
*b
, *function_block
;
2642 int force_skip
, skip
;
2644 /* Do not change the SAL is PC was specified explicitly. */
2645 if (sal
->explicit_pc
)
2648 old_chain
= save_current_space_and_thread ();
2649 switch_to_program_space_and_thread (sal
->pspace
);
2651 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
2654 fixup_symbol_section (sym
, NULL
);
2656 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2657 section
= SYMBOL_OBJ_SECTION (sym
);
2658 name
= SYMBOL_LINKAGE_NAME (sym
);
2659 objfile
= SYMBOL_SYMTAB (sym
)->objfile
;
2663 struct minimal_symbol
*msymbol
2664 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
2666 if (msymbol
== NULL
)
2668 do_cleanups (old_chain
);
2672 pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2673 section
= SYMBOL_OBJ_SECTION (msymbol
);
2674 name
= SYMBOL_LINKAGE_NAME (msymbol
);
2675 objfile
= msymbol_objfile (msymbol
);
2678 gdbarch
= get_objfile_arch (objfile
);
2680 /* Process the prologue in two passes. In the first pass try to skip the
2681 prologue (SKIP is true) and verify there is a real need for it (indicated
2682 by FORCE_SKIP). If no such reason was found run a second pass where the
2683 prologue is not skipped (SKIP is false). */
2688 /* Be conservative - allow direct PC (without skipping prologue) only if we
2689 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2690 have to be set by the caller so we use SYM instead. */
2691 if (sym
&& SYMBOL_SYMTAB (sym
)->locations_valid
)
2699 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2700 so that gdbarch_skip_prologue has something unique to work on. */
2701 if (section_is_overlay (section
) && !section_is_mapped (section
))
2702 pc
= overlay_unmapped_address (pc
, section
);
2704 /* Skip "first line" of function (which is actually its prologue). */
2705 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2707 pc
= gdbarch_skip_prologue (gdbarch
, pc
);
2709 /* For overlays, map pc back into its mapped VMA range. */
2710 pc
= overlay_mapped_address (pc
, section
);
2712 /* Calculate line number. */
2713 start_sal
= find_pc_sect_line (pc
, section
, 0);
2715 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2716 line is still part of the same function. */
2717 if (skip
&& start_sal
.pc
!= pc
2718 && (sym
? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
2719 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2720 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
)
2721 == lookup_minimal_symbol_by_pc_section (pc
, section
))))
2723 /* First pc of next line */
2725 /* Recalculate the line number (might not be N+1). */
2726 start_sal
= find_pc_sect_line (pc
, section
, 0);
2729 /* On targets with executable formats that don't have a concept of
2730 constructors (ELF with .init has, PE doesn't), gcc emits a call
2731 to `__main' in `main' between the prologue and before user
2733 if (gdbarch_skip_main_prologue_p (gdbarch
)
2734 && name
&& strcmp (name
, "main") == 0)
2736 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
2737 /* Recalculate the line number (might not be N+1). */
2738 start_sal
= find_pc_sect_line (pc
, section
, 0);
2742 while (!force_skip
&& skip
--);
2744 /* If we still don't have a valid source line, try to find the first
2745 PC in the lineinfo table that belongs to the same function. This
2746 happens with COFF debug info, which does not seem to have an
2747 entry in lineinfo table for the code after the prologue which has
2748 no direct relation to source. For example, this was found to be
2749 the case with the DJGPP target using "gcc -gcoff" when the
2750 compiler inserted code after the prologue to make sure the stack
2752 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
2754 pc
= skip_prologue_using_lineinfo (pc
, SYMBOL_SYMTAB (sym
));
2755 /* Recalculate the line number. */
2756 start_sal
= find_pc_sect_line (pc
, section
, 0);
2759 do_cleanups (old_chain
);
2761 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2762 forward SAL to the end of the prologue. */
2767 sal
->section
= section
;
2769 /* Unless the explicit_line flag was set, update the SAL line
2770 and symtab to correspond to the modified PC location. */
2771 if (sal
->explicit_line
)
2774 sal
->symtab
= start_sal
.symtab
;
2775 sal
->line
= start_sal
.line
;
2776 sal
->end
= start_sal
.end
;
2778 /* Check if we are now inside an inlined function. If we can,
2779 use the call site of the function instead. */
2780 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
2781 function_block
= NULL
;
2784 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
2786 else if (BLOCK_FUNCTION (b
) != NULL
)
2788 b
= BLOCK_SUPERBLOCK (b
);
2790 if (function_block
!= NULL
2791 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
2793 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
2794 sal
->symtab
= SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block
));
2798 /* If P is of the form "operator[ \t]+..." where `...' is
2799 some legitimate operator text, return a pointer to the
2800 beginning of the substring of the operator text.
2801 Otherwise, return "". */
2803 operator_chars (char *p
, char **end
)
2806 if (strncmp (p
, "operator", 8))
2810 /* Don't get faked out by `operator' being part of a longer
2812 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2815 /* Allow some whitespace between `operator' and the operator symbol. */
2816 while (*p
== ' ' || *p
== '\t')
2819 /* Recognize 'operator TYPENAME'. */
2821 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2825 while (isalnum (*q
) || *q
== '_' || *q
== '$')
2834 case '\\': /* regexp quoting */
2837 if (p
[2] == '=') /* 'operator\*=' */
2839 else /* 'operator\*' */
2843 else if (p
[1] == '[')
2846 error (_("mismatched quoting on brackets, "
2847 "try 'operator\\[\\]'"));
2848 else if (p
[2] == '\\' && p
[3] == ']')
2850 *end
= p
+ 4; /* 'operator\[\]' */
2854 error (_("nothing is allowed between '[' and ']'"));
2858 /* Gratuitous qoute: skip it and move on. */
2880 if (p
[0] == '-' && p
[1] == '>')
2882 /* Struct pointer member operator 'operator->'. */
2885 *end
= p
+ 3; /* 'operator->*' */
2888 else if (p
[2] == '\\')
2890 *end
= p
+ 4; /* Hopefully 'operator->\*' */
2895 *end
= p
+ 2; /* 'operator->' */
2899 if (p
[1] == '=' || p
[1] == p
[0])
2910 error (_("`operator ()' must be specified "
2911 "without whitespace in `()'"));
2916 error (_("`operator ?:' must be specified "
2917 "without whitespace in `?:'"));
2922 error (_("`operator []' must be specified "
2923 "without whitespace in `[]'"));
2927 error (_("`operator %s' not supported"), p
);
2936 /* If FILE is not already in the table of files, return zero;
2937 otherwise return non-zero. Optionally add FILE to the table if ADD
2938 is non-zero. If *FIRST is non-zero, forget the old table
2941 filename_seen (const char *file
, int add
, int *first
)
2943 /* Table of files seen so far. */
2944 static const char **tab
= NULL
;
2945 /* Allocated size of tab in elements.
2946 Start with one 256-byte block (when using GNU malloc.c).
2947 24 is the malloc overhead when range checking is in effect. */
2948 static int tab_alloc_size
= (256 - 24) / sizeof (char *);
2949 /* Current size of tab in elements. */
2950 static int tab_cur_size
;
2956 tab
= (const char **) xmalloc (tab_alloc_size
* sizeof (*tab
));
2960 /* Is FILE in tab? */
2961 for (p
= tab
; p
< tab
+ tab_cur_size
; p
++)
2962 if (filename_cmp (*p
, file
) == 0)
2965 /* No; maybe add it to tab. */
2968 if (tab_cur_size
== tab_alloc_size
)
2970 tab_alloc_size
*= 2;
2971 tab
= (const char **) xrealloc ((char *) tab
,
2972 tab_alloc_size
* sizeof (*tab
));
2974 tab
[tab_cur_size
++] = file
;
2980 /* Slave routine for sources_info. Force line breaks at ,'s.
2981 NAME is the name to print and *FIRST is nonzero if this is the first
2982 name printed. Set *FIRST to zero. */
2984 output_source_filename (const char *name
, int *first
)
2986 /* Since a single source file can result in several partial symbol
2987 tables, we need to avoid printing it more than once. Note: if
2988 some of the psymtabs are read in and some are not, it gets
2989 printed both under "Source files for which symbols have been
2990 read" and "Source files for which symbols will be read in on
2991 demand". I consider this a reasonable way to deal with the
2992 situation. I'm not sure whether this can also happen for
2993 symtabs; it doesn't hurt to check. */
2995 /* Was NAME already seen? */
2996 if (filename_seen (name
, 1, first
))
2998 /* Yes; don't print it again. */
3001 /* No; print it and reset *FIRST. */
3008 printf_filtered (", ");
3012 fputs_filtered (name
, gdb_stdout
);
3015 /* A callback for map_partial_symbol_filenames. */
3017 output_partial_symbol_filename (const char *filename
, const char *fullname
,
3020 output_source_filename (fullname
? fullname
: filename
, data
);
3024 sources_info (char *ignore
, int from_tty
)
3027 struct objfile
*objfile
;
3030 if (!have_full_symbols () && !have_partial_symbols ())
3032 error (_("No symbol table is loaded. Use the \"file\" command."));
3035 printf_filtered ("Source files for which symbols have been read in:\n\n");
3038 ALL_SYMTABS (objfile
, s
)
3040 const char *fullname
= symtab_to_fullname (s
);
3042 output_source_filename (fullname
? fullname
: s
->filename
, &first
);
3044 printf_filtered ("\n\n");
3046 printf_filtered ("Source files for which symbols "
3047 "will be read in on demand:\n\n");
3050 map_partial_symbol_filenames (output_partial_symbol_filename
, &first
,
3051 1 /*need_fullname*/);
3052 printf_filtered ("\n");
3056 file_matches (const char *file
, char *files
[], int nfiles
)
3060 if (file
!= NULL
&& nfiles
!= 0)
3062 for (i
= 0; i
< nfiles
; i
++)
3064 if (filename_cmp (files
[i
], lbasename (file
)) == 0)
3068 else if (nfiles
== 0)
3073 /* Free any memory associated with a search. */
3075 free_search_symbols (struct symbol_search
*symbols
)
3077 struct symbol_search
*p
;
3078 struct symbol_search
*next
;
3080 for (p
= symbols
; p
!= NULL
; p
= next
)
3088 do_free_search_symbols_cleanup (void *symbols
)
3090 free_search_symbols (symbols
);
3094 make_cleanup_free_search_symbols (struct symbol_search
*symbols
)
3096 return make_cleanup (do_free_search_symbols_cleanup
, symbols
);
3099 /* Helper function for sort_search_symbols and qsort. Can only
3100 sort symbols, not minimal symbols. */
3102 compare_search_syms (const void *sa
, const void *sb
)
3104 struct symbol_search
**sym_a
= (struct symbol_search
**) sa
;
3105 struct symbol_search
**sym_b
= (struct symbol_search
**) sb
;
3107 return strcmp (SYMBOL_PRINT_NAME ((*sym_a
)->symbol
),
3108 SYMBOL_PRINT_NAME ((*sym_b
)->symbol
));
3111 /* Sort the ``nfound'' symbols in the list after prevtail. Leave
3112 prevtail where it is, but update its next pointer to point to
3113 the first of the sorted symbols. */
3114 static struct symbol_search
*
3115 sort_search_symbols (struct symbol_search
*prevtail
, int nfound
)
3117 struct symbol_search
**symbols
, *symp
, *old_next
;
3120 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
3122 symp
= prevtail
->next
;
3123 for (i
= 0; i
< nfound
; i
++)
3128 /* Generally NULL. */
3131 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
3132 compare_search_syms
);
3135 for (i
= 0; i
< nfound
; i
++)
3137 symp
->next
= symbols
[i
];
3140 symp
->next
= old_next
;
3146 /* An object of this type is passed as the user_data to the
3147 expand_symtabs_matching method. */
3148 struct search_symbols_data
3153 /* It is true if PREG contains valid data, false otherwise. */
3154 unsigned preg_p
: 1;
3158 /* A callback for expand_symtabs_matching. */
3160 search_symbols_file_matches (const char *filename
, void *user_data
)
3162 struct search_symbols_data
*data
= user_data
;
3164 return file_matches (filename
, data
->files
, data
->nfiles
);
3167 /* A callback for expand_symtabs_matching. */
3169 search_symbols_name_matches (const struct language_defn
*language
,
3170 const char *symname
, void *user_data
)
3172 struct search_symbols_data
*data
= user_data
;
3174 return !data
->preg_p
|| regexec (&data
->preg
, symname
, 0, NULL
, 0) == 0;
3177 /* Search the symbol table for matches to the regular expression REGEXP,
3178 returning the results in *MATCHES.
3180 Only symbols of KIND are searched:
3181 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3182 and constants (enums)
3183 FUNCTIONS_DOMAIN - search all functions
3184 TYPES_DOMAIN - search all type names
3185 ALL_DOMAIN - an internal error for this function
3187 free_search_symbols should be called when *MATCHES is no longer needed.
3189 The results are sorted locally; each symtab's global and static blocks are
3190 separately alphabetized. */
3193 search_symbols (char *regexp
, enum search_domain kind
,
3194 int nfiles
, char *files
[],
3195 struct symbol_search
**matches
)
3198 struct blockvector
*bv
;
3201 struct dict_iterator iter
;
3203 struct objfile
*objfile
;
3204 struct minimal_symbol
*msymbol
;
3207 static const enum minimal_symbol_type types
[]
3208 = {mst_data
, mst_text
, mst_abs
};
3209 static const enum minimal_symbol_type types2
[]
3210 = {mst_bss
, mst_file_text
, mst_abs
};
3211 static const enum minimal_symbol_type types3
[]
3212 = {mst_file_data
, mst_solib_trampoline
, mst_abs
};
3213 static const enum minimal_symbol_type types4
[]
3214 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_abs
};
3215 enum minimal_symbol_type ourtype
;
3216 enum minimal_symbol_type ourtype2
;
3217 enum minimal_symbol_type ourtype3
;
3218 enum minimal_symbol_type ourtype4
;
3219 struct symbol_search
*sr
;
3220 struct symbol_search
*psr
;
3221 struct symbol_search
*tail
;
3222 struct search_symbols_data datum
;
3224 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3225 CLEANUP_CHAIN is freed only in the case of an error. */
3226 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3227 struct cleanup
*retval_chain
;
3229 gdb_assert (kind
<= TYPES_DOMAIN
);
3231 ourtype
= types
[kind
];
3232 ourtype2
= types2
[kind
];
3233 ourtype3
= types3
[kind
];
3234 ourtype4
= types4
[kind
];
3236 sr
= *matches
= NULL
;
3242 /* Make sure spacing is right for C++ operators.
3243 This is just a courtesy to make the matching less sensitive
3244 to how many spaces the user leaves between 'operator'
3245 and <TYPENAME> or <OPERATOR>. */
3247 char *opname
= operator_chars (regexp
, &opend
);
3252 int fix
= -1; /* -1 means ok; otherwise number of
3255 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
3257 /* There should 1 space between 'operator' and 'TYPENAME'. */
3258 if (opname
[-1] != ' ' || opname
[-2] == ' ')
3263 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3264 if (opname
[-1] == ' ')
3267 /* If wrong number of spaces, fix it. */
3270 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
3272 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3277 errcode
= regcomp (&datum
.preg
, regexp
,
3278 REG_NOSUB
| (case_sensitivity
== case_sensitive_off
3282 char *err
= get_regcomp_error (errcode
, &datum
.preg
);
3284 make_cleanup (xfree
, err
);
3285 error (_("Invalid regexp (%s): %s"), err
, regexp
);
3288 make_regfree_cleanup (&datum
.preg
);
3291 /* Search through the partial symtabs *first* for all symbols
3292 matching the regexp. That way we don't have to reproduce all of
3293 the machinery below. */
3295 datum
.nfiles
= nfiles
;
3296 datum
.files
= files
;
3297 ALL_OBJFILES (objfile
)
3300 objfile
->sf
->qf
->expand_symtabs_matching (objfile
,
3301 search_symbols_file_matches
,
3302 search_symbols_name_matches
,
3307 retval_chain
= old_chain
;
3309 /* Here, we search through the minimal symbol tables for functions
3310 and variables that match, and force their symbols to be read.
3311 This is in particular necessary for demangled variable names,
3312 which are no longer put into the partial symbol tables.
3313 The symbol will then be found during the scan of symtabs below.
3315 For functions, find_pc_symtab should succeed if we have debug info
3316 for the function, for variables we have to call lookup_symbol
3317 to determine if the variable has debug info.
3318 If the lookup fails, set found_misc so that we will rescan to print
3319 any matching symbols without debug info. */
3321 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3323 ALL_MSYMBOLS (objfile
, msymbol
)
3327 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3328 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3329 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3330 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3333 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (msymbol
), 0,
3336 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)))
3338 /* FIXME: carlton/2003-02-04: Given that the
3339 semantics of lookup_symbol keeps on changing
3340 slightly, it would be a nice idea if we had a
3341 function lookup_symbol_minsym that found the
3342 symbol associated to a given minimal symbol (if
3344 if (kind
== FUNCTIONS_DOMAIN
3345 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3346 (struct block
*) NULL
,
3356 ALL_PRIMARY_SYMTABS (objfile
, s
)
3358 bv
= BLOCKVECTOR (s
);
3359 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3361 struct symbol_search
*prevtail
= tail
;
3364 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3365 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3367 struct symtab
*real_symtab
= SYMBOL_SYMTAB (sym
);
3371 if (file_matches (real_symtab
->filename
, files
, nfiles
)
3373 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (sym
), 0,
3375 && ((kind
== VARIABLES_DOMAIN
3376 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3377 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
3378 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3379 /* LOC_CONST can be used for more than just enums,
3380 e.g., c++ static const members.
3381 We only want to skip enums here. */
3382 && !(SYMBOL_CLASS (sym
) == LOC_CONST
3383 && TYPE_CODE (SYMBOL_TYPE (sym
))
3385 || (kind
== FUNCTIONS_DOMAIN
3386 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3387 || (kind
== TYPES_DOMAIN
3388 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
3391 psr
= (struct symbol_search
*)
3392 xmalloc (sizeof (struct symbol_search
));
3394 psr
->symtab
= real_symtab
;
3396 psr
->msymbol
= NULL
;
3408 if (prevtail
== NULL
)
3410 struct symbol_search dummy
;
3413 tail
= sort_search_symbols (&dummy
, nfound
);
3416 make_cleanup_free_search_symbols (sr
);
3419 tail
= sort_search_symbols (prevtail
, nfound
);
3424 /* If there are no eyes, avoid all contact. I mean, if there are
3425 no debug symbols, then print directly from the msymbol_vector. */
3427 if (found_misc
|| kind
!= FUNCTIONS_DOMAIN
)
3429 ALL_MSYMBOLS (objfile
, msymbol
)
3433 if (MSYMBOL_TYPE (msymbol
) == ourtype
||
3434 MSYMBOL_TYPE (msymbol
) == ourtype2
||
3435 MSYMBOL_TYPE (msymbol
) == ourtype3
||
3436 MSYMBOL_TYPE (msymbol
) == ourtype4
)
3439 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (msymbol
), 0,
3442 /* Functions: Look up by address. */
3443 if (kind
!= FUNCTIONS_DOMAIN
||
3444 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
))))
3446 /* Variables/Absolutes: Look up by name. */
3447 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol
),
3448 (struct block
*) NULL
, VAR_DOMAIN
, 0)
3452 psr
= (struct symbol_search
*)
3453 xmalloc (sizeof (struct symbol_search
));
3455 psr
->msymbol
= msymbol
;
3462 make_cleanup_free_search_symbols (sr
);
3474 discard_cleanups (retval_chain
);
3475 do_cleanups (old_chain
);
3479 /* Helper function for symtab_symbol_info, this function uses
3480 the data returned from search_symbols() to print information
3481 regarding the match to gdb_stdout. */
3484 print_symbol_info (enum search_domain kind
,
3485 struct symtab
*s
, struct symbol
*sym
,
3486 int block
, char *last
)
3488 if (last
== NULL
|| filename_cmp (last
, s
->filename
) != 0)
3490 fputs_filtered ("\nFile ", gdb_stdout
);
3491 fputs_filtered (s
->filename
, gdb_stdout
);
3492 fputs_filtered (":\n", gdb_stdout
);
3495 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3496 printf_filtered ("static ");
3498 /* Typedef that is not a C++ class. */
3499 if (kind
== TYPES_DOMAIN
3500 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3501 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3502 /* variable, func, or typedef-that-is-c++-class. */
3503 else if (kind
< TYPES_DOMAIN
||
3504 (kind
== TYPES_DOMAIN
&&
3505 SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3507 type_print (SYMBOL_TYPE (sym
),
3508 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3509 ? "" : SYMBOL_PRINT_NAME (sym
)),
3512 printf_filtered (";\n");
3516 /* This help function for symtab_symbol_info() prints information
3517 for non-debugging symbols to gdb_stdout. */
3520 print_msymbol_info (struct minimal_symbol
*msymbol
)
3522 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol_objfile (msymbol
));
3525 if (gdbarch_addr_bit (gdbarch
) <= 32)
3526 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3527 & (CORE_ADDR
) 0xffffffff,
3530 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3532 printf_filtered ("%s %s\n",
3533 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3536 /* This is the guts of the commands "info functions", "info types", and
3537 "info variables". It calls search_symbols to find all matches and then
3538 print_[m]symbol_info to print out some useful information about the
3542 symtab_symbol_info (char *regexp
, enum search_domain kind
, int from_tty
)
3544 static const char * const classnames
[] =
3545 {"variable", "function", "type"};
3546 struct symbol_search
*symbols
;
3547 struct symbol_search
*p
;
3548 struct cleanup
*old_chain
;
3549 char *last_filename
= NULL
;
3552 gdb_assert (kind
<= TYPES_DOMAIN
);
3554 /* Must make sure that if we're interrupted, symbols gets freed. */
3555 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3556 old_chain
= make_cleanup_free_search_symbols (symbols
);
3558 printf_filtered (regexp
3559 ? "All %ss matching regular expression \"%s\":\n"
3560 : "All defined %ss:\n",
3561 classnames
[kind
], regexp
);
3563 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3567 if (p
->msymbol
!= NULL
)
3571 printf_filtered ("\nNon-debugging symbols:\n");
3574 print_msymbol_info (p
->msymbol
);
3578 print_symbol_info (kind
,
3583 last_filename
= p
->symtab
->filename
;
3587 do_cleanups (old_chain
);
3591 variables_info (char *regexp
, int from_tty
)
3593 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3597 functions_info (char *regexp
, int from_tty
)
3599 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3604 types_info (char *regexp
, int from_tty
)
3606 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3609 /* Breakpoint all functions matching regular expression. */
3612 rbreak_command_wrapper (char *regexp
, int from_tty
)
3614 rbreak_command (regexp
, from_tty
);
3617 /* A cleanup function that calls end_rbreak_breakpoints. */
3620 do_end_rbreak_breakpoints (void *ignore
)
3622 end_rbreak_breakpoints ();
3626 rbreak_command (char *regexp
, int from_tty
)
3628 struct symbol_search
*ss
;
3629 struct symbol_search
*p
;
3630 struct cleanup
*old_chain
;
3631 char *string
= NULL
;
3633 char **files
= NULL
, *file_name
;
3638 char *colon
= strchr (regexp
, ':');
3640 if (colon
&& *(colon
+ 1) != ':')
3644 colon_index
= colon
- regexp
;
3645 file_name
= alloca (colon_index
+ 1);
3646 memcpy (file_name
, regexp
, colon_index
);
3647 file_name
[colon_index
--] = 0;
3648 while (isspace (file_name
[colon_index
]))
3649 file_name
[colon_index
--] = 0;
3653 while (isspace (*regexp
)) regexp
++;
3657 search_symbols (regexp
, FUNCTIONS_DOMAIN
, nfiles
, files
, &ss
);
3658 old_chain
= make_cleanup_free_search_symbols (ss
);
3659 make_cleanup (free_current_contents
, &string
);
3661 start_rbreak_breakpoints ();
3662 make_cleanup (do_end_rbreak_breakpoints
, NULL
);
3663 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3665 if (p
->msymbol
== NULL
)
3667 int newlen
= (strlen (p
->symtab
->filename
)
3668 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
3673 string
= xrealloc (string
, newlen
);
3676 strcpy (string
, p
->symtab
->filename
);
3677 strcat (string
, ":'");
3678 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
3679 strcat (string
, "'");
3680 break_command (string
, from_tty
);
3681 print_symbol_info (FUNCTIONS_DOMAIN
,
3685 p
->symtab
->filename
);
3689 int newlen
= (strlen (SYMBOL_LINKAGE_NAME (p
->msymbol
)) + 3);
3693 string
= xrealloc (string
, newlen
);
3696 strcpy (string
, "'");
3697 strcat (string
, SYMBOL_LINKAGE_NAME (p
->msymbol
));
3698 strcat (string
, "'");
3700 break_command (string
, from_tty
);
3701 printf_filtered ("<function, no debug info> %s;\n",
3702 SYMBOL_PRINT_NAME (p
->msymbol
));
3706 do_cleanups (old_chain
);
3710 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3712 Either sym_text[sym_text_len] != '(' and then we search for any
3713 symbol starting with SYM_TEXT text.
3715 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3716 be terminated at that point. Partial symbol tables do not have parameters
3720 compare_symbol_name (const char *name
, const char *sym_text
, int sym_text_len
)
3722 int (*ncmp
) (const char *, const char *, size_t);
3724 ncmp
= (case_sensitivity
== case_sensitive_on
? strncmp
: strncasecmp
);
3726 if (ncmp (name
, sym_text
, sym_text_len
) != 0)
3729 if (sym_text
[sym_text_len
] == '(')
3731 /* User searches for `name(someth...'. Require NAME to be terminated.
3732 Normally psymtabs and gdbindex have no parameter types so '\0' will be
3733 present but accept even parameters presence. In this case this
3734 function is in fact strcmp_iw but whitespace skipping is not supported
3735 for tab completion. */
3737 if (name
[sym_text_len
] != '\0' && name
[sym_text_len
] != '(')
3744 /* Free any memory associated with a completion list. */
3747 free_completion_list (char ***list_ptr
)
3750 char **list
= *list_ptr
;
3752 while (list
[i
] != NULL
)
3760 /* Callback for make_cleanup. */
3763 do_free_completion_list (void *list
)
3765 free_completion_list (list
);
3768 /* Helper routine for make_symbol_completion_list. */
3770 static int return_val_size
;
3771 static int return_val_index
;
3772 static char **return_val
;
3774 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
3775 completion_list_add_name \
3776 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
3778 /* Test to see if the symbol specified by SYMNAME (which is already
3779 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
3780 characters. If so, add it to the current completion list. */
3783 completion_list_add_name (char *symname
, char *sym_text
, int sym_text_len
,
3784 char *text
, char *word
)
3788 /* Clip symbols that cannot match. */
3789 if (!compare_symbol_name (symname
, sym_text
, sym_text_len
))
3792 /* We have a match for a completion, so add SYMNAME to the current list
3793 of matches. Note that the name is moved to freshly malloc'd space. */
3798 if (word
== sym_text
)
3800 new = xmalloc (strlen (symname
) + 5);
3801 strcpy (new, symname
);
3803 else if (word
> sym_text
)
3805 /* Return some portion of symname. */
3806 new = xmalloc (strlen (symname
) + 5);
3807 strcpy (new, symname
+ (word
- sym_text
));
3811 /* Return some of SYM_TEXT plus symname. */
3812 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
3813 strncpy (new, word
, sym_text
- word
);
3814 new[sym_text
- word
] = '\0';
3815 strcat (new, symname
);
3818 if (return_val_index
+ 3 > return_val_size
)
3820 newsize
= (return_val_size
*= 2) * sizeof (char *);
3821 return_val
= (char **) xrealloc ((char *) return_val
, newsize
);
3823 return_val
[return_val_index
++] = new;
3824 return_val
[return_val_index
] = NULL
;
3828 /* ObjC: In case we are completing on a selector, look as the msymbol
3829 again and feed all the selectors into the mill. */
3832 completion_list_objc_symbol (struct minimal_symbol
*msymbol
, char *sym_text
,
3833 int sym_text_len
, char *text
, char *word
)
3835 static char *tmp
= NULL
;
3836 static unsigned int tmplen
= 0;
3838 char *method
, *category
, *selector
;
3841 method
= SYMBOL_NATURAL_NAME (msymbol
);
3843 /* Is it a method? */
3844 if ((method
[0] != '-') && (method
[0] != '+'))
3847 if (sym_text
[0] == '[')
3848 /* Complete on shortened method method. */
3849 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
3851 while ((strlen (method
) + 1) >= tmplen
)
3857 tmp
= xrealloc (tmp
, tmplen
);
3859 selector
= strchr (method
, ' ');
3860 if (selector
!= NULL
)
3863 category
= strchr (method
, '(');
3865 if ((category
!= NULL
) && (selector
!= NULL
))
3867 memcpy (tmp
, method
, (category
- method
));
3868 tmp
[category
- method
] = ' ';
3869 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
3870 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3871 if (sym_text
[0] == '[')
3872 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
3875 if (selector
!= NULL
)
3877 /* Complete on selector only. */
3878 strcpy (tmp
, selector
);
3879 tmp2
= strchr (tmp
, ']');
3883 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
3887 /* Break the non-quoted text based on the characters which are in
3888 symbols. FIXME: This should probably be language-specific. */
3891 language_search_unquoted_string (char *text
, char *p
)
3893 for (; p
> text
; --p
)
3895 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
3899 if ((current_language
->la_language
== language_objc
))
3901 if (p
[-1] == ':') /* Might be part of a method name. */
3903 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
3904 p
-= 2; /* Beginning of a method name. */
3905 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
3906 { /* Might be part of a method name. */
3909 /* Seeing a ' ' or a '(' is not conclusive evidence
3910 that we are in the middle of a method name. However,
3911 finding "-[" or "+[" should be pretty un-ambiguous.
3912 Unfortunately we have to find it now to decide. */
3915 if (isalnum (t
[-1]) || t
[-1] == '_' ||
3916 t
[-1] == ' ' || t
[-1] == ':' ||
3917 t
[-1] == '(' || t
[-1] == ')')
3922 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
3923 p
= t
- 2; /* Method name detected. */
3924 /* Else we leave with p unchanged. */
3934 completion_list_add_fields (struct symbol
*sym
, char *sym_text
,
3935 int sym_text_len
, char *text
, char *word
)
3937 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
3939 struct type
*t
= SYMBOL_TYPE (sym
);
3940 enum type_code c
= TYPE_CODE (t
);
3943 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
3944 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
3945 if (TYPE_FIELD_NAME (t
, j
))
3946 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
3947 sym_text
, sym_text_len
, text
, word
);
3951 /* Type of the user_data argument passed to add_macro_name or
3952 expand_partial_symbol_name. The contents are simply whatever is
3953 needed by completion_list_add_name. */
3954 struct add_name_data
3962 /* A callback used with macro_for_each and macro_for_each_in_scope.
3963 This adds a macro's name to the current completion list. */
3965 add_macro_name (const char *name
, const struct macro_definition
*ignore
,
3966 struct macro_source_file
*ignore2
, int ignore3
,
3969 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
3971 completion_list_add_name ((char *) name
,
3972 datum
->sym_text
, datum
->sym_text_len
,
3973 datum
->text
, datum
->word
);
3976 /* A callback for expand_partial_symbol_names. */
3978 expand_partial_symbol_name (const struct language_defn
*language
,
3979 const char *name
, void *user_data
)
3981 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
3983 return compare_symbol_name (name
, datum
->sym_text
, datum
->sym_text_len
);
3987 default_make_symbol_completion_list_break_on (char *text
, char *word
,
3988 const char *break_on
)
3990 /* Problem: All of the symbols have to be copied because readline
3991 frees them. I'm not going to worry about this; hopefully there
3992 won't be that many. */
3996 struct minimal_symbol
*msymbol
;
3997 struct objfile
*objfile
;
3999 const struct block
*surrounding_static_block
, *surrounding_global_block
;
4000 struct dict_iterator iter
;
4001 /* The symbol we are completing on. Points in same buffer as text. */
4003 /* Length of sym_text. */
4005 struct add_name_data datum
;
4006 struct cleanup
*back_to
;
4008 /* Now look for the symbol we are supposed to complete on. */
4012 char *quote_pos
= NULL
;
4014 /* First see if this is a quoted string. */
4016 for (p
= text
; *p
!= '\0'; ++p
)
4018 if (quote_found
!= '\0')
4020 if (*p
== quote_found
)
4021 /* Found close quote. */
4023 else if (*p
== '\\' && p
[1] == quote_found
)
4024 /* A backslash followed by the quote character
4025 doesn't end the string. */
4028 else if (*p
== '\'' || *p
== '"')
4034 if (quote_found
== '\'')
4035 /* A string within single quotes can be a symbol, so complete on it. */
4036 sym_text
= quote_pos
+ 1;
4037 else if (quote_found
== '"')
4038 /* A double-quoted string is never a symbol, nor does it make sense
4039 to complete it any other way. */
4041 return_val
= (char **) xmalloc (sizeof (char *));
4042 return_val
[0] = NULL
;
4047 /* It is not a quoted string. Break it based on the characters
4048 which are in symbols. */
4051 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
4052 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
4061 sym_text_len
= strlen (sym_text
);
4063 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4065 if (current_language
->la_language
== language_cplus
4066 || current_language
->la_language
== language_java
4067 || current_language
->la_language
== language_fortran
)
4069 /* These languages may have parameters entered by user but they are never
4070 present in the partial symbol tables. */
4072 const char *cs
= memchr (sym_text
, '(', sym_text_len
);
4075 sym_text_len
= cs
- sym_text
;
4077 gdb_assert (sym_text
[sym_text_len
] == '\0' || sym_text
[sym_text_len
] == '(');
4079 return_val_size
= 100;
4080 return_val_index
= 0;
4081 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
4082 return_val
[0] = NULL
;
4083 back_to
= make_cleanup (do_free_completion_list
, &return_val
);
4085 datum
.sym_text
= sym_text
;
4086 datum
.sym_text_len
= sym_text_len
;
4090 /* Look through the partial symtabs for all symbols which begin
4091 by matching SYM_TEXT. Expand all CUs that you find to the list.
4092 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4093 expand_partial_symbol_names (expand_partial_symbol_name
, &datum
);
4095 /* At this point scan through the misc symbol vectors and add each
4096 symbol you find to the list. Eventually we want to ignore
4097 anything that isn't a text symbol (everything else will be
4098 handled by the psymtab code above). */
4100 ALL_MSYMBOLS (objfile
, msymbol
)
4103 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
, word
);
4105 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
, word
);
4108 /* Search upwards from currently selected frame (so that we can
4109 complete on local vars). Also catch fields of types defined in
4110 this places which match our text string. Only complete on types
4111 visible from current context. */
4113 b
= get_selected_block (0);
4114 surrounding_static_block
= block_static_block (b
);
4115 surrounding_global_block
= block_global_block (b
);
4116 if (surrounding_static_block
!= NULL
)
4117 while (b
!= surrounding_static_block
)
4121 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4123 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4125 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
,
4129 /* Stop when we encounter an enclosing function. Do not stop for
4130 non-inlined functions - the locals of the enclosing function
4131 are in scope for a nested function. */
4132 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
4134 b
= BLOCK_SUPERBLOCK (b
);
4137 /* Add fields from the file's types; symbols will be added below. */
4139 if (surrounding_static_block
!= NULL
)
4140 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
4141 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4143 if (surrounding_global_block
!= NULL
)
4144 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
4145 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4147 /* Go through the symtabs and check the externs and statics for
4148 symbols which match. */
4150 ALL_PRIMARY_SYMTABS (objfile
, s
)
4153 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4154 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4156 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4160 ALL_PRIMARY_SYMTABS (objfile
, s
)
4163 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4164 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4166 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4170 if (current_language
->la_macro_expansion
== macro_expansion_c
)
4172 struct macro_scope
*scope
;
4174 /* Add any macros visible in the default scope. Note that this
4175 may yield the occasional wrong result, because an expression
4176 might be evaluated in a scope other than the default. For
4177 example, if the user types "break file:line if <TAB>", the
4178 resulting expression will be evaluated at "file:line" -- but
4179 at there does not seem to be a way to detect this at
4181 scope
= default_macro_scope ();
4184 macro_for_each_in_scope (scope
->file
, scope
->line
,
4185 add_macro_name
, &datum
);
4189 /* User-defined macros are always visible. */
4190 macro_for_each (macro_user_macros
, add_macro_name
, &datum
);
4193 discard_cleanups (back_to
);
4194 return (return_val
);
4198 default_make_symbol_completion_list (char *text
, char *word
)
4200 return default_make_symbol_completion_list_break_on (text
, word
, "");
4203 /* Return a NULL terminated array of all symbols (regardless of class)
4204 which begin by matching TEXT. If the answer is no symbols, then
4205 the return value is an array which contains only a NULL pointer. */
4208 make_symbol_completion_list (char *text
, char *word
)
4210 return current_language
->la_make_symbol_completion_list (text
, word
);
4213 /* Like make_symbol_completion_list, but suitable for use as a
4214 completion function. */
4217 make_symbol_completion_list_fn (struct cmd_list_element
*ignore
,
4218 char *text
, char *word
)
4220 return make_symbol_completion_list (text
, word
);
4223 /* Like make_symbol_completion_list, but returns a list of symbols
4224 defined in a source file FILE. */
4227 make_file_symbol_completion_list (char *text
, char *word
, char *srcfile
)
4232 struct dict_iterator iter
;
4233 /* The symbol we are completing on. Points in same buffer as text. */
4235 /* Length of sym_text. */
4238 /* Now look for the symbol we are supposed to complete on.
4239 FIXME: This should be language-specific. */
4243 char *quote_pos
= NULL
;
4245 /* First see if this is a quoted string. */
4247 for (p
= text
; *p
!= '\0'; ++p
)
4249 if (quote_found
!= '\0')
4251 if (*p
== quote_found
)
4252 /* Found close quote. */
4254 else if (*p
== '\\' && p
[1] == quote_found
)
4255 /* A backslash followed by the quote character
4256 doesn't end the string. */
4259 else if (*p
== '\'' || *p
== '"')
4265 if (quote_found
== '\'')
4266 /* A string within single quotes can be a symbol, so complete on it. */
4267 sym_text
= quote_pos
+ 1;
4268 else if (quote_found
== '"')
4269 /* A double-quoted string is never a symbol, nor does it make sense
4270 to complete it any other way. */
4272 return_val
= (char **) xmalloc (sizeof (char *));
4273 return_val
[0] = NULL
;
4278 /* Not a quoted string. */
4279 sym_text
= language_search_unquoted_string (text
, p
);
4283 sym_text_len
= strlen (sym_text
);
4285 return_val_size
= 10;
4286 return_val_index
= 0;
4287 return_val
= (char **) xmalloc ((return_val_size
+ 1) * sizeof (char *));
4288 return_val
[0] = NULL
;
4290 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4292 s
= lookup_symtab (srcfile
);
4295 /* Maybe they typed the file with leading directories, while the
4296 symbol tables record only its basename. */
4297 const char *tail
= lbasename (srcfile
);
4300 s
= lookup_symtab (tail
);
4303 /* If we have no symtab for that file, return an empty list. */
4305 return (return_val
);
4307 /* Go through this symtab and check the externs and statics for
4308 symbols which match. */
4310 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4311 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4313 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4316 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4317 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4319 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4322 return (return_val
);
4325 /* A helper function for make_source_files_completion_list. It adds
4326 another file name to a list of possible completions, growing the
4327 list as necessary. */
4330 add_filename_to_list (const char *fname
, char *text
, char *word
,
4331 char ***list
, int *list_used
, int *list_alloced
)
4334 size_t fnlen
= strlen (fname
);
4336 if (*list_used
+ 1 >= *list_alloced
)
4339 *list
= (char **) xrealloc ((char *) *list
,
4340 *list_alloced
* sizeof (char *));
4345 /* Return exactly fname. */
4346 new = xmalloc (fnlen
+ 5);
4347 strcpy (new, fname
);
4349 else if (word
> text
)
4351 /* Return some portion of fname. */
4352 new = xmalloc (fnlen
+ 5);
4353 strcpy (new, fname
+ (word
- text
));
4357 /* Return some of TEXT plus fname. */
4358 new = xmalloc (fnlen
+ (text
- word
) + 5);
4359 strncpy (new, word
, text
- word
);
4360 new[text
- word
] = '\0';
4361 strcat (new, fname
);
4363 (*list
)[*list_used
] = new;
4364 (*list
)[++*list_used
] = NULL
;
4368 not_interesting_fname (const char *fname
)
4370 static const char *illegal_aliens
[] = {
4371 "_globals_", /* inserted by coff_symtab_read */
4376 for (i
= 0; illegal_aliens
[i
]; i
++)
4378 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
4384 /* An object of this type is passed as the user_data argument to
4385 map_partial_symbol_filenames. */
4386 struct add_partial_filename_data
4397 /* A callback for map_partial_symbol_filenames. */
4399 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
4402 struct add_partial_filename_data
*data
= user_data
;
4404 if (not_interesting_fname (filename
))
4406 if (!filename_seen (filename
, 1, data
->first
)
4407 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
4409 /* This file matches for a completion; add it to the
4410 current list of matches. */
4411 add_filename_to_list (filename
, data
->text
, data
->word
,
4412 data
->list
, data
->list_used
, data
->list_alloced
);
4416 const char *base_name
= lbasename (filename
);
4418 if (base_name
!= filename
4419 && !filename_seen (base_name
, 1, data
->first
)
4420 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
4421 add_filename_to_list (base_name
, data
->text
, data
->word
,
4422 data
->list
, data
->list_used
, data
->list_alloced
);
4426 /* Return a NULL terminated array of all source files whose names
4427 begin with matching TEXT. The file names are looked up in the
4428 symbol tables of this program. If the answer is no matchess, then
4429 the return value is an array which contains only a NULL pointer. */
4432 make_source_files_completion_list (char *text
, char *word
)
4435 struct objfile
*objfile
;
4437 int list_alloced
= 1;
4439 size_t text_len
= strlen (text
);
4440 char **list
= (char **) xmalloc (list_alloced
* sizeof (char *));
4441 const char *base_name
;
4442 struct add_partial_filename_data datum
;
4443 struct cleanup
*back_to
;
4447 if (!have_full_symbols () && !have_partial_symbols ())
4450 back_to
= make_cleanup (do_free_completion_list
, &list
);
4452 ALL_SYMTABS (objfile
, s
)
4454 if (not_interesting_fname (s
->filename
))
4456 if (!filename_seen (s
->filename
, 1, &first
)
4457 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
4459 /* This file matches for a completion; add it to the current
4461 add_filename_to_list (s
->filename
, text
, word
,
4462 &list
, &list_used
, &list_alloced
);
4466 /* NOTE: We allow the user to type a base name when the
4467 debug info records leading directories, but not the other
4468 way around. This is what subroutines of breakpoint
4469 command do when they parse file names. */
4470 base_name
= lbasename (s
->filename
);
4471 if (base_name
!= s
->filename
4472 && !filename_seen (base_name
, 1, &first
)
4473 && filename_ncmp (base_name
, text
, text_len
) == 0)
4474 add_filename_to_list (base_name
, text
, word
,
4475 &list
, &list_used
, &list_alloced
);
4479 datum
.first
= &first
;
4482 datum
.text_len
= text_len
;
4484 datum
.list_used
= &list_used
;
4485 datum
.list_alloced
= &list_alloced
;
4486 map_partial_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
4487 0 /*need_fullname*/);
4488 discard_cleanups (back_to
);
4493 /* Determine if PC is in the prologue of a function. The prologue is the area
4494 between the first instruction of a function, and the first executable line.
4495 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4497 If non-zero, func_start is where we think the prologue starts, possibly
4498 by previous examination of symbol table information. */
4501 in_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR func_start
)
4503 struct symtab_and_line sal
;
4504 CORE_ADDR func_addr
, func_end
;
4506 /* We have several sources of information we can consult to figure
4508 - Compilers usually emit line number info that marks the prologue
4509 as its own "source line". So the ending address of that "line"
4510 is the end of the prologue. If available, this is the most
4512 - The minimal symbols and partial symbols, which can usually tell
4513 us the starting and ending addresses of a function.
4514 - If we know the function's start address, we can call the
4515 architecture-defined gdbarch_skip_prologue function to analyze the
4516 instruction stream and guess where the prologue ends.
4517 - Our `func_start' argument; if non-zero, this is the caller's
4518 best guess as to the function's entry point. At the time of
4519 this writing, handle_inferior_event doesn't get this right, so
4520 it should be our last resort. */
4522 /* Consult the partial symbol table, to find which function
4524 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
4526 CORE_ADDR prologue_end
;
4528 /* We don't even have minsym information, so fall back to using
4529 func_start, if given. */
4531 return 1; /* We *might* be in a prologue. */
4533 prologue_end
= gdbarch_skip_prologue (gdbarch
, func_start
);
4535 return func_start
<= pc
&& pc
< prologue_end
;
4538 /* If we have line number information for the function, that's
4539 usually pretty reliable. */
4540 sal
= find_pc_line (func_addr
, 0);
4542 /* Now sal describes the source line at the function's entry point,
4543 which (by convention) is the prologue. The end of that "line",
4544 sal.end, is the end of the prologue.
4546 Note that, for functions whose source code is all on a single
4547 line, the line number information doesn't always end up this way.
4548 So we must verify that our purported end-of-prologue address is
4549 *within* the function, not at its start or end. */
4551 || sal
.end
<= func_addr
4552 || func_end
<= sal
.end
)
4554 /* We don't have any good line number info, so use the minsym
4555 information, together with the architecture-specific prologue
4557 CORE_ADDR prologue_end
= gdbarch_skip_prologue (gdbarch
, func_addr
);
4559 return func_addr
<= pc
&& pc
< prologue_end
;
4562 /* We have line number info, and it looks good. */
4563 return func_addr
<= pc
&& pc
< sal
.end
;
4566 /* Given PC at the function's start address, attempt to find the
4567 prologue end using SAL information. Return zero if the skip fails.
4569 A non-optimized prologue traditionally has one SAL for the function
4570 and a second for the function body. A single line function has
4571 them both pointing at the same line.
4573 An optimized prologue is similar but the prologue may contain
4574 instructions (SALs) from the instruction body. Need to skip those
4575 while not getting into the function body.
4577 The functions end point and an increasing SAL line are used as
4578 indicators of the prologue's endpoint.
4580 This code is based on the function refine_prologue_limit
4584 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
4586 struct symtab_and_line prologue_sal
;
4591 /* Get an initial range for the function. */
4592 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
4593 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
4595 prologue_sal
= find_pc_line (start_pc
, 0);
4596 if (prologue_sal
.line
!= 0)
4598 /* For languages other than assembly, treat two consecutive line
4599 entries at the same address as a zero-instruction prologue.
4600 The GNU assembler emits separate line notes for each instruction
4601 in a multi-instruction macro, but compilers generally will not
4603 if (prologue_sal
.symtab
->language
!= language_asm
)
4605 struct linetable
*linetable
= LINETABLE (prologue_sal
.symtab
);
4608 /* Skip any earlier lines, and any end-of-sequence marker
4609 from a previous function. */
4610 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
4611 || linetable
->item
[idx
].line
== 0)
4614 if (idx
+1 < linetable
->nitems
4615 && linetable
->item
[idx
+1].line
!= 0
4616 && linetable
->item
[idx
+1].pc
== start_pc
)
4620 /* If there is only one sal that covers the entire function,
4621 then it is probably a single line function, like
4623 if (prologue_sal
.end
>= end_pc
)
4626 while (prologue_sal
.end
< end_pc
)
4628 struct symtab_and_line sal
;
4630 sal
= find_pc_line (prologue_sal
.end
, 0);
4633 /* Assume that a consecutive SAL for the same (or larger)
4634 line mark the prologue -> body transition. */
4635 if (sal
.line
>= prologue_sal
.line
)
4638 /* The line number is smaller. Check that it's from the
4639 same function, not something inlined. If it's inlined,
4640 then there is no point comparing the line numbers. */
4641 bl
= block_for_pc (prologue_sal
.end
);
4644 if (block_inlined_p (bl
))
4646 if (BLOCK_FUNCTION (bl
))
4651 bl
= BLOCK_SUPERBLOCK (bl
);
4656 /* The case in which compiler's optimizer/scheduler has
4657 moved instructions into the prologue. We look ahead in
4658 the function looking for address ranges whose
4659 corresponding line number is less the first one that we
4660 found for the function. This is more conservative then
4661 refine_prologue_limit which scans a large number of SALs
4662 looking for any in the prologue. */
4667 if (prologue_sal
.end
< end_pc
)
4668 /* Return the end of this line, or zero if we could not find a
4670 return prologue_sal
.end
;
4672 /* Don't return END_PC, which is past the end of the function. */
4673 return prologue_sal
.pc
;
4676 struct symtabs_and_lines
4677 decode_line_spec (char *string
, int flags
)
4679 struct symtabs_and_lines sals
;
4680 struct symtab_and_line cursal
;
4683 error (_("Empty line specification."));
4685 /* We use whatever is set as the current source line. We do not try
4686 and get a default or it will recursively call us! */
4687 cursal
= get_current_source_symtab_and_line ();
4689 sals
= decode_line_1 (&string
, flags
,
4690 cursal
.symtab
, cursal
.line
);
4693 error (_("Junk at end of line specification: %s"), string
);
4698 static char *name_of_main
;
4699 enum language language_of_main
= language_unknown
;
4702 set_main_name (const char *name
)
4704 if (name_of_main
!= NULL
)
4706 xfree (name_of_main
);
4707 name_of_main
= NULL
;
4708 language_of_main
= language_unknown
;
4712 name_of_main
= xstrdup (name
);
4713 language_of_main
= language_unknown
;
4717 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4721 find_main_name (void)
4723 const char *new_main_name
;
4725 /* Try to see if the main procedure is in Ada. */
4726 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4727 be to add a new method in the language vector, and call this
4728 method for each language until one of them returns a non-empty
4729 name. This would allow us to remove this hard-coded call to
4730 an Ada function. It is not clear that this is a better approach
4731 at this point, because all methods need to be written in a way
4732 such that false positives never be returned. For instance, it is
4733 important that a method does not return a wrong name for the main
4734 procedure if the main procedure is actually written in a different
4735 language. It is easy to guaranty this with Ada, since we use a
4736 special symbol generated only when the main in Ada to find the name
4737 of the main procedure. It is difficult however to see how this can
4738 be guarantied for languages such as C, for instance. This suggests
4739 that order of call for these methods becomes important, which means
4740 a more complicated approach. */
4741 new_main_name
= ada_main_name ();
4742 if (new_main_name
!= NULL
)
4744 set_main_name (new_main_name
);
4748 new_main_name
= pascal_main_name ();
4749 if (new_main_name
!= NULL
)
4751 set_main_name (new_main_name
);
4755 /* The languages above didn't identify the name of the main procedure.
4756 Fallback to "main". */
4757 set_main_name ("main");
4763 if (name_of_main
== NULL
)
4766 return name_of_main
;
4769 /* Handle ``executable_changed'' events for the symtab module. */
4772 symtab_observer_executable_changed (void)
4774 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
4775 set_main_name (NULL
);
4778 /* Return 1 if the supplied producer string matches the ARM RealView
4779 compiler (armcc). */
4782 producer_is_realview (const char *producer
)
4784 static const char *const arm_idents
[] = {
4785 "ARM C Compiler, ADS",
4786 "Thumb C Compiler, ADS",
4787 "ARM C++ Compiler, ADS",
4788 "Thumb C++ Compiler, ADS",
4789 "ARM/Thumb C/C++ Compiler, RVCT",
4790 "ARM C/C++ Compiler, RVCT"
4794 if (producer
== NULL
)
4797 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
4798 if (strncmp (producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
4805 _initialize_symtab (void)
4807 add_info ("variables", variables_info
, _("\
4808 All global and static variable names, or those matching REGEXP."));
4810 add_com ("whereis", class_info
, variables_info
, _("\
4811 All global and static variable names, or those matching REGEXP."));
4813 add_info ("functions", functions_info
,
4814 _("All function names, or those matching REGEXP."));
4816 /* FIXME: This command has at least the following problems:
4817 1. It prints builtin types (in a very strange and confusing fashion).
4818 2. It doesn't print right, e.g. with
4819 typedef struct foo *FOO
4820 type_print prints "FOO" when we want to make it (in this situation)
4821 print "struct foo *".
4822 I also think "ptype" or "whatis" is more likely to be useful (but if
4823 there is much disagreement "info types" can be fixed). */
4824 add_info ("types", types_info
,
4825 _("All type names, or those matching REGEXP."));
4827 add_info ("sources", sources_info
,
4828 _("Source files in the program."));
4830 add_com ("rbreak", class_breakpoint
, rbreak_command
,
4831 _("Set a breakpoint for all functions matching REGEXP."));
4835 add_com ("lf", class_info
, sources_info
,
4836 _("Source files in the program"));
4837 add_com ("lg", class_info
, variables_info
, _("\
4838 All global and static variable names, or those matching REGEXP."));
4841 add_setshow_enum_cmd ("multiple-symbols", no_class
,
4842 multiple_symbols_modes
, &multiple_symbols_mode
,
4844 Set the debugger behavior when more than one symbol are possible matches\n\
4845 in an expression."), _("\
4846 Show how the debugger handles ambiguities in expressions."), _("\
4847 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
4848 NULL
, NULL
, &setlist
, &showlist
);
4850 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
4851 &basenames_may_differ
, _("\
4852 Set whether a source file may have multiple base names."), _("\
4853 Show whether a source file may have multiple base names."), _("\
4854 (A \"base name\" is the name of a file with the directory part removed.\n\
4855 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
4856 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
4857 before comparing them. Canonicalization is an expensive operation,\n\
4858 but it allows the same file be known by more than one base name.\n\
4859 If not set (the default), all source files are assumed to have just\n\
4860 one base name, and gdb will do file name comparisons more efficiently."),
4862 &setlist
, &showlist
);
4864 observer_attach_executable_changed (symtab_observer_executable_changed
);