1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdb_regex.h"
31 #include "expression.h"
36 #include "filenames.h" /* for FILENAME_CMP */
37 #include "objc-lang.h"
43 #include "cli/cli-utils.h"
47 #include "gdb_obstack.h"
49 #include "dictionary.h"
51 #include <sys/types.h>
53 #include "gdb_string.h"
57 #include "cp-support.h"
59 #include "gdb_assert.h"
62 #include "macroscope.h"
65 #include "parser-defs.h"
67 /* Prototypes for local functions */
69 static void rbreak_command (char *, int);
71 static void types_info (char *, int);
73 static void functions_info (char *, int);
75 static void variables_info (char *, int);
77 static void sources_info (char *, int);
79 static int find_line_common (struct linetable
*, int, int *, int);
81 static struct symbol
*lookup_symbol_aux (const char *name
,
82 const struct block
*block
,
83 const domain_enum domain
,
84 enum language language
,
85 struct field_of_this_result
*is_a_field_of_this
);
88 struct symbol
*lookup_symbol_aux_local (const char *name
,
89 const struct block
*block
,
90 const domain_enum domain
,
91 enum language language
);
94 struct symbol
*lookup_symbol_aux_symtabs (int block_index
,
96 const domain_enum domain
);
99 struct symbol
*lookup_symbol_aux_quick (struct objfile
*objfile
,
102 const domain_enum domain
);
104 static void print_msymbol_info (struct minimal_symbol
*);
106 void _initialize_symtab (void);
110 /* When non-zero, print debugging messages related to symtab creation. */
111 int symtab_create_debug
= 0;
113 /* Non-zero if a file may be known by two different basenames.
114 This is the uncommon case, and significantly slows down gdb.
115 Default set to "off" to not slow down the common case. */
116 int basenames_may_differ
= 0;
118 /* Allow the user to configure the debugger behavior with respect
119 to multiple-choice menus when more than one symbol matches during
122 const char multiple_symbols_ask
[] = "ask";
123 const char multiple_symbols_all
[] = "all";
124 const char multiple_symbols_cancel
[] = "cancel";
125 static const char *const multiple_symbols_modes
[] =
127 multiple_symbols_ask
,
128 multiple_symbols_all
,
129 multiple_symbols_cancel
,
132 static const char *multiple_symbols_mode
= multiple_symbols_all
;
134 /* Read-only accessor to AUTO_SELECT_MODE. */
137 multiple_symbols_select_mode (void)
139 return multiple_symbols_mode
;
142 /* Block in which the most recently searched-for symbol was found.
143 Might be better to make this a parameter to lookup_symbol and
146 const struct block
*block_found
;
148 /* See whether FILENAME matches SEARCH_NAME using the rule that we
149 advertise to the user. (The manual's description of linespecs
150 describes what we advertise). Returns true if they match, false
154 compare_filenames_for_search (const char *filename
, const char *search_name
)
156 int len
= strlen (filename
);
157 size_t search_len
= strlen (search_name
);
159 if (len
< search_len
)
162 /* The tail of FILENAME must match. */
163 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
166 /* Either the names must completely match, or the character
167 preceding the trailing SEARCH_NAME segment of FILENAME must be a
170 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
171 cannot match FILENAME "/path//dir/file.c" - as user has requested
172 absolute path. The sama applies for "c:\file.c" possibly
173 incorrectly hypothetically matching "d:\dir\c:\file.c".
175 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
176 compatible with SEARCH_NAME "file.c". In such case a compiler had
177 to put the "c:file.c" name into debug info. Such compatibility
178 works only on GDB built for DOS host. */
179 return (len
== search_len
180 || (!IS_ABSOLUTE_PATH (search_name
)
181 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
182 || (HAS_DRIVE_SPEC (filename
)
183 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
186 /* Check for a symtab of a specific name by searching some symtabs.
187 This is a helper function for callbacks of iterate_over_symtabs.
189 If NAME is not absolute, then REAL_PATH is NULL
190 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
192 The return value, NAME, REAL_PATH, CALLBACK, and DATA
193 are identical to the `map_symtabs_matching_filename' method of
194 quick_symbol_functions.
196 FIRST and AFTER_LAST indicate the range of symtabs to search.
197 AFTER_LAST is one past the last symtab to search; NULL means to
198 search until the end of the list. */
201 iterate_over_some_symtabs (const char *name
,
202 const char *real_path
,
203 int (*callback
) (struct symtab
*symtab
,
206 struct symtab
*first
,
207 struct symtab
*after_last
)
209 struct symtab
*s
= NULL
;
210 const char* base_name
= lbasename (name
);
212 for (s
= first
; s
!= NULL
&& s
!= after_last
; s
= s
->next
)
214 if (compare_filenames_for_search (s
->filename
, name
))
216 if (callback (s
, data
))
221 /* Before we invoke realpath, which can get expensive when many
222 files are involved, do a quick comparison of the basenames. */
223 if (! basenames_may_differ
224 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
227 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
229 if (callback (s
, data
))
234 /* If the user gave us an absolute path, try to find the file in
235 this symtab and use its absolute path. */
236 if (real_path
!= NULL
)
238 const char *fullname
= symtab_to_fullname (s
);
240 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
241 gdb_assert (IS_ABSOLUTE_PATH (name
));
242 if (FILENAME_CMP (real_path
, fullname
) == 0)
244 if (callback (s
, data
))
254 /* Check for a symtab of a specific name; first in symtabs, then in
255 psymtabs. *If* there is no '/' in the name, a match after a '/'
256 in the symtab filename will also work.
258 Calls CALLBACK with each symtab that is found and with the supplied
259 DATA. If CALLBACK returns true, the search stops. */
262 iterate_over_symtabs (const char *name
,
263 int (*callback
) (struct symtab
*symtab
,
267 struct objfile
*objfile
;
268 char *real_path
= NULL
;
269 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
271 /* Here we are interested in canonicalizing an absolute path, not
272 absolutizing a relative path. */
273 if (IS_ABSOLUTE_PATH (name
))
275 real_path
= gdb_realpath (name
);
276 make_cleanup (xfree
, real_path
);
277 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
280 ALL_OBJFILES (objfile
)
282 if (iterate_over_some_symtabs (name
, real_path
, callback
, data
,
283 objfile
->symtabs
, NULL
))
285 do_cleanups (cleanups
);
290 /* Same search rules as above apply here, but now we look thru the
293 ALL_OBJFILES (objfile
)
296 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
302 do_cleanups (cleanups
);
307 do_cleanups (cleanups
);
310 /* The callback function used by lookup_symtab. */
313 lookup_symtab_callback (struct symtab
*symtab
, void *data
)
315 struct symtab
**result_ptr
= data
;
317 *result_ptr
= symtab
;
321 /* A wrapper for iterate_over_symtabs that returns the first matching
325 lookup_symtab (const char *name
)
327 struct symtab
*result
= NULL
;
329 iterate_over_symtabs (name
, lookup_symtab_callback
, &result
);
334 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
335 full method name, which consist of the class name (from T), the unadorned
336 method name from METHOD_ID, and the signature for the specific overload,
337 specified by SIGNATURE_ID. Note that this function is g++ specific. */
340 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
342 int mangled_name_len
;
344 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
345 struct fn_field
*method
= &f
[signature_id
];
346 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
347 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
348 const char *newname
= type_name_no_tag (type
);
350 /* Does the form of physname indicate that it is the full mangled name
351 of a constructor (not just the args)? */
352 int is_full_physname_constructor
;
355 int is_destructor
= is_destructor_name (physname
);
356 /* Need a new type prefix. */
357 char *const_prefix
= method
->is_const
? "C" : "";
358 char *volatile_prefix
= method
->is_volatile
? "V" : "";
360 int len
= (newname
== NULL
? 0 : strlen (newname
));
362 /* Nothing to do if physname already contains a fully mangled v3 abi name
363 or an operator name. */
364 if ((physname
[0] == '_' && physname
[1] == 'Z')
365 || is_operator_name (field_name
))
366 return xstrdup (physname
);
368 is_full_physname_constructor
= is_constructor_name (physname
);
370 is_constructor
= is_full_physname_constructor
371 || (newname
&& strcmp (field_name
, newname
) == 0);
374 is_destructor
= (strncmp (physname
, "__dt", 4) == 0);
376 if (is_destructor
|| is_full_physname_constructor
)
378 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
379 strcpy (mangled_name
, physname
);
385 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
387 else if (physname
[0] == 't' || physname
[0] == 'Q')
389 /* The physname for template and qualified methods already includes
391 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
397 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
398 volatile_prefix
, len
);
400 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
401 + strlen (buf
) + len
+ strlen (physname
) + 1);
403 mangled_name
= (char *) xmalloc (mangled_name_len
);
405 mangled_name
[0] = '\0';
407 strcpy (mangled_name
, field_name
);
409 strcat (mangled_name
, buf
);
410 /* If the class doesn't have a name, i.e. newname NULL, then we just
411 mangle it using 0 for the length of the class. Thus it gets mangled
412 as something starting with `::' rather than `classname::'. */
414 strcat (mangled_name
, newname
);
416 strcat (mangled_name
, physname
);
417 return (mangled_name
);
420 /* Initialize the cplus_specific structure. 'cplus_specific' should
421 only be allocated for use with cplus symbols. */
424 symbol_init_cplus_specific (struct general_symbol_info
*gsymbol
,
425 struct obstack
*obstack
)
427 /* A language_specific structure should not have been previously
429 gdb_assert (gsymbol
->language_specific
.cplus_specific
== NULL
);
430 gdb_assert (obstack
!= NULL
);
432 gsymbol
->language_specific
.cplus_specific
=
433 OBSTACK_ZALLOC (obstack
, struct cplus_specific
);
436 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
437 correctly allocated. For C++ symbols a cplus_specific struct is
438 allocated so OBJFILE must not be NULL. If this is a non C++ symbol
439 OBJFILE can be NULL. */
442 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
444 struct obstack
*obstack
)
446 if (gsymbol
->language
== language_cplus
)
448 if (gsymbol
->language_specific
.cplus_specific
== NULL
)
449 symbol_init_cplus_specific (gsymbol
, obstack
);
451 gsymbol
->language_specific
.cplus_specific
->demangled_name
= name
;
453 else if (gsymbol
->language
== language_ada
)
457 gsymbol
->ada_mangled
= 0;
458 gsymbol
->language_specific
.obstack
= obstack
;
462 gsymbol
->ada_mangled
= 1;
463 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
467 gsymbol
->language_specific
.mangled_lang
.demangled_name
= name
;
470 /* Return the demangled name of GSYMBOL. */
473 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
475 if (gsymbol
->language
== language_cplus
)
477 if (gsymbol
->language_specific
.cplus_specific
!= NULL
)
478 return gsymbol
->language_specific
.cplus_specific
->demangled_name
;
482 else if (gsymbol
->language
== language_ada
)
484 if (!gsymbol
->ada_mangled
)
489 return gsymbol
->language_specific
.mangled_lang
.demangled_name
;
493 /* Initialize the language dependent portion of a symbol
494 depending upon the language for the symbol. */
497 symbol_set_language (struct general_symbol_info
*gsymbol
,
498 enum language language
,
499 struct obstack
*obstack
)
501 gsymbol
->language
= language
;
502 if (gsymbol
->language
== language_d
503 || gsymbol
->language
== language_go
504 || gsymbol
->language
== language_java
505 || gsymbol
->language
== language_objc
506 || gsymbol
->language
== language_fortran
)
508 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
510 else if (gsymbol
->language
== language_ada
)
512 gdb_assert (gsymbol
->ada_mangled
== 0);
513 gsymbol
->language_specific
.obstack
= obstack
;
515 else if (gsymbol
->language
== language_cplus
)
516 gsymbol
->language_specific
.cplus_specific
= NULL
;
519 memset (&gsymbol
->language_specific
, 0,
520 sizeof (gsymbol
->language_specific
));
524 /* Functions to initialize a symbol's mangled name. */
526 /* Objects of this type are stored in the demangled name hash table. */
527 struct demangled_name_entry
533 /* Hash function for the demangled name hash. */
536 hash_demangled_name_entry (const void *data
)
538 const struct demangled_name_entry
*e
= data
;
540 return htab_hash_string (e
->mangled
);
543 /* Equality function for the demangled name hash. */
546 eq_demangled_name_entry (const void *a
, const void *b
)
548 const struct demangled_name_entry
*da
= a
;
549 const struct demangled_name_entry
*db
= b
;
551 return strcmp (da
->mangled
, db
->mangled
) == 0;
554 /* Create the hash table used for demangled names. Each hash entry is
555 a pair of strings; one for the mangled name and one for the demangled
556 name. The entry is hashed via just the mangled name. */
559 create_demangled_names_hash (struct objfile
*objfile
)
561 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
562 The hash table code will round this up to the next prime number.
563 Choosing a much larger table size wastes memory, and saves only about
564 1% in symbol reading. */
566 objfile
->demangled_names_hash
= htab_create_alloc
567 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
568 NULL
, xcalloc
, xfree
);
571 /* Try to determine the demangled name for a symbol, based on the
572 language of that symbol. If the language is set to language_auto,
573 it will attempt to find any demangling algorithm that works and
574 then set the language appropriately. The returned name is allocated
575 by the demangler and should be xfree'd. */
578 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
581 char *demangled
= NULL
;
583 if (gsymbol
->language
== language_unknown
)
584 gsymbol
->language
= language_auto
;
586 if (gsymbol
->language
== language_objc
587 || gsymbol
->language
== language_auto
)
590 objc_demangle (mangled
, 0);
591 if (demangled
!= NULL
)
593 gsymbol
->language
= language_objc
;
597 if (gsymbol
->language
== language_cplus
598 || gsymbol
->language
== language_auto
)
601 gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
602 if (demangled
!= NULL
)
604 gsymbol
->language
= language_cplus
;
608 if (gsymbol
->language
== language_java
)
611 gdb_demangle (mangled
,
612 DMGL_PARAMS
| DMGL_ANSI
| DMGL_JAVA
);
613 if (demangled
!= NULL
)
615 gsymbol
->language
= language_java
;
619 if (gsymbol
->language
== language_d
620 || gsymbol
->language
== language_auto
)
622 demangled
= d_demangle(mangled
, 0);
623 if (demangled
!= NULL
)
625 gsymbol
->language
= language_d
;
629 /* FIXME(dje): Continually adding languages here is clumsy.
630 Better to just call la_demangle if !auto, and if auto then call
631 a utility routine that tries successive languages in turn and reports
632 which one it finds. I realize the la_demangle options may be different
633 for different languages but there's already a FIXME for that. */
634 if (gsymbol
->language
== language_go
635 || gsymbol
->language
== language_auto
)
637 demangled
= go_demangle (mangled
, 0);
638 if (demangled
!= NULL
)
640 gsymbol
->language
= language_go
;
645 /* We could support `gsymbol->language == language_fortran' here to provide
646 module namespaces also for inferiors with only minimal symbol table (ELF
647 symbols). Just the mangling standard is not standardized across compilers
648 and there is no DW_AT_producer available for inferiors with only the ELF
649 symbols to check the mangling kind. */
653 /* Set both the mangled and demangled (if any) names for GSYMBOL based
654 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
655 objfile's obstack; but if COPY_NAME is 0 and if NAME is
656 NUL-terminated, then this function assumes that NAME is already
657 correctly saved (either permanently or with a lifetime tied to the
658 objfile), and it will not be copied.
660 The hash table corresponding to OBJFILE is used, and the memory
661 comes from that objfile's objfile_obstack. LINKAGE_NAME is copied,
662 so the pointer can be discarded after calling this function. */
664 /* We have to be careful when dealing with Java names: when we run
665 into a Java minimal symbol, we don't know it's a Java symbol, so it
666 gets demangled as a C++ name. This is unfortunate, but there's not
667 much we can do about it: but when demangling partial symbols and
668 regular symbols, we'd better not reuse the wrong demangled name.
669 (See PR gdb/1039.) We solve this by putting a distinctive prefix
670 on Java names when storing them in the hash table. */
672 /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
673 don't mind the Java prefix so much: different languages have
674 different demangling requirements, so it's only natural that we
675 need to keep language data around in our demangling cache. But
676 it's not good that the minimal symbol has the wrong demangled name.
677 Unfortunately, I can't think of any easy solution to that
680 #define JAVA_PREFIX "##JAVA$$"
681 #define JAVA_PREFIX_LEN 8
684 symbol_set_names (struct general_symbol_info
*gsymbol
,
685 const char *linkage_name
, int len
, int copy_name
,
686 struct objfile
*objfile
)
688 struct demangled_name_entry
**slot
;
689 /* A 0-terminated copy of the linkage name. */
690 const char *linkage_name_copy
;
691 /* A copy of the linkage name that might have a special Java prefix
692 added to it, for use when looking names up in the hash table. */
693 const char *lookup_name
;
694 /* The length of lookup_name. */
696 struct demangled_name_entry entry
;
698 if (gsymbol
->language
== language_ada
)
700 /* In Ada, we do the symbol lookups using the mangled name, so
701 we can save some space by not storing the demangled name.
703 As a side note, we have also observed some overlap between
704 the C++ mangling and Ada mangling, similarly to what has
705 been observed with Java. Because we don't store the demangled
706 name with the symbol, we don't need to use the same trick
709 gsymbol
->name
= linkage_name
;
712 char *name
= obstack_alloc (&objfile
->objfile_obstack
, len
+ 1);
714 memcpy (name
, linkage_name
, len
);
716 gsymbol
->name
= name
;
718 symbol_set_demangled_name (gsymbol
, NULL
, &objfile
->objfile_obstack
);
723 if (objfile
->demangled_names_hash
== NULL
)
724 create_demangled_names_hash (objfile
);
726 /* The stabs reader generally provides names that are not
727 NUL-terminated; most of the other readers don't do this, so we
728 can just use the given copy, unless we're in the Java case. */
729 if (gsymbol
->language
== language_java
)
733 lookup_len
= len
+ JAVA_PREFIX_LEN
;
734 alloc_name
= alloca (lookup_len
+ 1);
735 memcpy (alloc_name
, JAVA_PREFIX
, JAVA_PREFIX_LEN
);
736 memcpy (alloc_name
+ JAVA_PREFIX_LEN
, linkage_name
, len
);
737 alloc_name
[lookup_len
] = '\0';
739 lookup_name
= alloc_name
;
740 linkage_name_copy
= alloc_name
+ JAVA_PREFIX_LEN
;
742 else if (linkage_name
[len
] != '\0')
747 alloc_name
= alloca (lookup_len
+ 1);
748 memcpy (alloc_name
, linkage_name
, len
);
749 alloc_name
[lookup_len
] = '\0';
751 lookup_name
= alloc_name
;
752 linkage_name_copy
= alloc_name
;
757 lookup_name
= linkage_name
;
758 linkage_name_copy
= linkage_name
;
761 entry
.mangled
= lookup_name
;
762 slot
= ((struct demangled_name_entry
**)
763 htab_find_slot (objfile
->demangled_names_hash
,
766 /* If this name is not in the hash table, add it. */
768 /* A C version of the symbol may have already snuck into the table.
769 This happens to, e.g., main.init (__go_init_main). Cope. */
770 || (gsymbol
->language
== language_go
771 && (*slot
)->demangled
[0] == '\0'))
773 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
775 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
777 /* Suppose we have demangled_name==NULL, copy_name==0, and
778 lookup_name==linkage_name. In this case, we already have the
779 mangled name saved, and we don't have a demangled name. So,
780 you might think we could save a little space by not recording
781 this in the hash table at all.
783 It turns out that it is actually important to still save such
784 an entry in the hash table, because storing this name gives
785 us better bcache hit rates for partial symbols. */
786 if (!copy_name
&& lookup_name
== linkage_name
)
788 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
789 offsetof (struct demangled_name_entry
,
791 + demangled_len
+ 1);
792 (*slot
)->mangled
= lookup_name
;
798 /* If we must copy the mangled name, put it directly after
799 the demangled name so we can have a single
801 *slot
= obstack_alloc (&objfile
->objfile_obstack
,
802 offsetof (struct demangled_name_entry
,
804 + lookup_len
+ demangled_len
+ 2);
805 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
806 strcpy (mangled_ptr
, lookup_name
);
807 (*slot
)->mangled
= mangled_ptr
;
810 if (demangled_name
!= NULL
)
812 strcpy ((*slot
)->demangled
, demangled_name
);
813 xfree (demangled_name
);
816 (*slot
)->demangled
[0] = '\0';
819 gsymbol
->name
= (*slot
)->mangled
+ lookup_len
- len
;
820 if ((*slot
)->demangled
[0] != '\0')
821 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
822 &objfile
->objfile_obstack
);
824 symbol_set_demangled_name (gsymbol
, NULL
, &objfile
->objfile_obstack
);
827 /* Return the source code name of a symbol. In languages where
828 demangling is necessary, this is the demangled name. */
831 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
833 switch (gsymbol
->language
)
840 case language_fortran
:
841 if (symbol_get_demangled_name (gsymbol
) != NULL
)
842 return symbol_get_demangled_name (gsymbol
);
845 return ada_decode_symbol (gsymbol
);
849 return gsymbol
->name
;
852 /* Return the demangled name for a symbol based on the language for
853 that symbol. If no demangled name exists, return NULL. */
856 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
858 const char *dem_name
= NULL
;
860 switch (gsymbol
->language
)
867 case language_fortran
:
868 dem_name
= symbol_get_demangled_name (gsymbol
);
871 dem_name
= ada_decode_symbol (gsymbol
);
879 /* Return the search name of a symbol---generally the demangled or
880 linkage name of the symbol, depending on how it will be searched for.
881 If there is no distinct demangled name, then returns the same value
882 (same pointer) as SYMBOL_LINKAGE_NAME. */
885 symbol_search_name (const struct general_symbol_info
*gsymbol
)
887 if (gsymbol
->language
== language_ada
)
888 return gsymbol
->name
;
890 return symbol_natural_name (gsymbol
);
893 /* Initialize the structure fields to zero values. */
896 init_sal (struct symtab_and_line
*sal
)
904 sal
->explicit_pc
= 0;
905 sal
->explicit_line
= 0;
910 /* Return 1 if the two sections are the same, or if they could
911 plausibly be copies of each other, one in an original object
912 file and another in a separated debug file. */
915 matching_obj_sections (struct obj_section
*obj_first
,
916 struct obj_section
*obj_second
)
918 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
919 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
922 /* If they're the same section, then they match. */
926 /* If either is NULL, give up. */
927 if (first
== NULL
|| second
== NULL
)
930 /* This doesn't apply to absolute symbols. */
931 if (first
->owner
== NULL
|| second
->owner
== NULL
)
934 /* If they're in the same object file, they must be different sections. */
935 if (first
->owner
== second
->owner
)
938 /* Check whether the two sections are potentially corresponding. They must
939 have the same size, address, and name. We can't compare section indexes,
940 which would be more reliable, because some sections may have been
942 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
945 /* In-memory addresses may start at a different offset, relativize them. */
946 if (bfd_get_section_vma (first
->owner
, first
)
947 - bfd_get_start_address (first
->owner
)
948 != bfd_get_section_vma (second
->owner
, second
)
949 - bfd_get_start_address (second
->owner
))
952 if (bfd_get_section_name (first
->owner
, first
) == NULL
953 || bfd_get_section_name (second
->owner
, second
) == NULL
954 || strcmp (bfd_get_section_name (first
->owner
, first
),
955 bfd_get_section_name (second
->owner
, second
)) != 0)
958 /* Otherwise check that they are in corresponding objfiles. */
961 if (obj
->obfd
== first
->owner
)
963 gdb_assert (obj
!= NULL
);
965 if (obj
->separate_debug_objfile
!= NULL
966 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
968 if (obj
->separate_debug_objfile_backlink
!= NULL
969 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
976 find_pc_sect_symtab_via_partial (CORE_ADDR pc
, struct obj_section
*section
)
978 struct objfile
*objfile
;
979 struct minimal_symbol
*msymbol
;
981 /* If we know that this is not a text address, return failure. This is
982 necessary because we loop based on texthigh and textlow, which do
983 not include the data ranges. */
984 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
;
986 && (MSYMBOL_TYPE (msymbol
) == mst_data
987 || MSYMBOL_TYPE (msymbol
) == mst_bss
988 || MSYMBOL_TYPE (msymbol
) == mst_abs
989 || MSYMBOL_TYPE (msymbol
) == mst_file_data
990 || MSYMBOL_TYPE (msymbol
) == mst_file_bss
))
993 ALL_OBJFILES (objfile
)
995 struct symtab
*result
= NULL
;
998 result
= objfile
->sf
->qf
->find_pc_sect_symtab (objfile
, msymbol
,
1007 /* Debug symbols usually don't have section information. We need to dig that
1008 out of the minimal symbols and stash that in the debug symbol. */
1011 fixup_section (struct general_symbol_info
*ginfo
,
1012 CORE_ADDR addr
, struct objfile
*objfile
)
1014 struct minimal_symbol
*msym
;
1016 /* First, check whether a minimal symbol with the same name exists
1017 and points to the same address. The address check is required
1018 e.g. on PowerPC64, where the minimal symbol for a function will
1019 point to the function descriptor, while the debug symbol will
1020 point to the actual function code. */
1021 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1023 ginfo
->section
= SYMBOL_SECTION (msym
);
1026 /* Static, function-local variables do appear in the linker
1027 (minimal) symbols, but are frequently given names that won't
1028 be found via lookup_minimal_symbol(). E.g., it has been
1029 observed in frv-uclinux (ELF) executables that a static,
1030 function-local variable named "foo" might appear in the
1031 linker symbols as "foo.6" or "foo.3". Thus, there is no
1032 point in attempting to extend the lookup-by-name mechanism to
1033 handle this case due to the fact that there can be multiple
1036 So, instead, search the section table when lookup by name has
1037 failed. The ``addr'' and ``endaddr'' fields may have already
1038 been relocated. If so, the relocation offset (i.e. the
1039 ANOFFSET value) needs to be subtracted from these values when
1040 performing the comparison. We unconditionally subtract it,
1041 because, when no relocation has been performed, the ANOFFSET
1042 value will simply be zero.
1044 The address of the symbol whose section we're fixing up HAS
1045 NOT BEEN adjusted (relocated) yet. It can't have been since
1046 the section isn't yet known and knowing the section is
1047 necessary in order to add the correct relocation value. In
1048 other words, we wouldn't even be in this function (attempting
1049 to compute the section) if it were already known.
1051 Note that it is possible to search the minimal symbols
1052 (subtracting the relocation value if necessary) to find the
1053 matching minimal symbol, but this is overkill and much less
1054 efficient. It is not necessary to find the matching minimal
1055 symbol, only its section.
1057 Note that this technique (of doing a section table search)
1058 can fail when unrelocated section addresses overlap. For
1059 this reason, we still attempt a lookup by name prior to doing
1060 a search of the section table. */
1062 struct obj_section
*s
;
1065 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1067 int idx
= s
- objfile
->sections
;
1068 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1073 if (obj_section_addr (s
) - offset
<= addr
1074 && addr
< obj_section_endaddr (s
) - offset
)
1076 ginfo
->section
= idx
;
1081 /* If we didn't find the section, assume it is in the first
1082 section. If there is no allocated section, then it hardly
1083 matters what we pick, so just pick zero. */
1087 ginfo
->section
= fallback
;
1092 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1099 /* We either have an OBJFILE, or we can get at it from the sym's
1100 symtab. Anything else is a bug. */
1101 gdb_assert (objfile
|| SYMBOL_SYMTAB (sym
));
1103 if (objfile
== NULL
)
1104 objfile
= SYMBOL_SYMTAB (sym
)->objfile
;
1106 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1109 /* We should have an objfile by now. */
1110 gdb_assert (objfile
);
1112 switch (SYMBOL_CLASS (sym
))
1116 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1119 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1123 /* Nothing else will be listed in the minsyms -- no use looking
1128 fixup_section (&sym
->ginfo
, addr
, objfile
);
1133 /* Compute the demangled form of NAME as used by the various symbol
1134 lookup functions. The result is stored in *RESULT_NAME. Returns a
1135 cleanup which can be used to clean up the result.
1137 For Ada, this function just sets *RESULT_NAME to NAME, unmodified.
1138 Normally, Ada symbol lookups are performed using the encoded name
1139 rather than the demangled name, and so it might seem to make sense
1140 for this function to return an encoded version of NAME.
1141 Unfortunately, we cannot do this, because this function is used in
1142 circumstances where it is not appropriate to try to encode NAME.
1143 For instance, when displaying the frame info, we demangle the name
1144 of each parameter, and then perform a symbol lookup inside our
1145 function using that demangled name. In Ada, certain functions
1146 have internally-generated parameters whose name contain uppercase
1147 characters. Encoding those name would result in those uppercase
1148 characters to become lowercase, and thus cause the symbol lookup
1152 demangle_for_lookup (const char *name
, enum language lang
,
1153 const char **result_name
)
1155 char *demangled_name
= NULL
;
1156 const char *modified_name
= NULL
;
1157 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, 0);
1159 modified_name
= name
;
1161 /* If we are using C++, D, Go, or Java, demangle the name before doing a
1162 lookup, so we can always binary search. */
1163 if (lang
== language_cplus
)
1165 demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1168 modified_name
= demangled_name
;
1169 make_cleanup (xfree
, demangled_name
);
1173 /* If we were given a non-mangled name, canonicalize it
1174 according to the language (so far only for C++). */
1175 demangled_name
= cp_canonicalize_string (name
);
1178 modified_name
= demangled_name
;
1179 make_cleanup (xfree
, demangled_name
);
1183 else if (lang
== language_java
)
1185 demangled_name
= gdb_demangle (name
,
1186 DMGL_ANSI
| DMGL_PARAMS
| DMGL_JAVA
);
1189 modified_name
= demangled_name
;
1190 make_cleanup (xfree
, demangled_name
);
1193 else if (lang
== language_d
)
1195 demangled_name
= d_demangle (name
, 0);
1198 modified_name
= demangled_name
;
1199 make_cleanup (xfree
, demangled_name
);
1202 else if (lang
== language_go
)
1204 demangled_name
= go_demangle (name
, 0);
1207 modified_name
= demangled_name
;
1208 make_cleanup (xfree
, demangled_name
);
1212 *result_name
= modified_name
;
1216 /* Find the definition for a specified symbol name NAME
1217 in domain DOMAIN, visible from lexical block BLOCK.
1218 Returns the struct symbol pointer, or zero if no symbol is found.
1219 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
1220 NAME is a field of the current implied argument `this'. If so set
1221 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
1222 BLOCK_FOUND is set to the block in which NAME is found (in the case of
1223 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
1225 /* This function (or rather its subordinates) have a bunch of loops and
1226 it would seem to be attractive to put in some QUIT's (though I'm not really
1227 sure whether it can run long enough to be really important). But there
1228 are a few calls for which it would appear to be bad news to quit
1229 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1230 that there is C++ code below which can error(), but that probably
1231 doesn't affect these calls since they are looking for a known
1232 variable and thus can probably assume it will never hit the C++
1236 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1237 const domain_enum domain
, enum language lang
,
1238 struct field_of_this_result
*is_a_field_of_this
)
1240 const char *modified_name
;
1241 struct symbol
*returnval
;
1242 struct cleanup
*cleanup
= demangle_for_lookup (name
, lang
, &modified_name
);
1244 returnval
= lookup_symbol_aux (modified_name
, block
, domain
, lang
,
1245 is_a_field_of_this
);
1246 do_cleanups (cleanup
);
1251 /* Behave like lookup_symbol_in_language, but performed with the
1252 current language. */
1255 lookup_symbol (const char *name
, const struct block
*block
,
1257 struct field_of_this_result
*is_a_field_of_this
)
1259 return lookup_symbol_in_language (name
, block
, domain
,
1260 current_language
->la_language
,
1261 is_a_field_of_this
);
1264 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1265 found, or NULL if not found. */
1268 lookup_language_this (const struct language_defn
*lang
,
1269 const struct block
*block
)
1271 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1278 sym
= lookup_block_symbol (block
, lang
->la_name_of_this
, VAR_DOMAIN
);
1281 block_found
= block
;
1284 if (BLOCK_FUNCTION (block
))
1286 block
= BLOCK_SUPERBLOCK (block
);
1292 /* Given TYPE, a structure/union,
1293 return 1 if the component named NAME from the ultimate target
1294 structure/union is defined, otherwise, return 0. */
1297 check_field (struct type
*type
, const char *name
,
1298 struct field_of_this_result
*is_a_field_of_this
)
1302 /* The type may be a stub. */
1303 CHECK_TYPEDEF (type
);
1305 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1307 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1309 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1311 is_a_field_of_this
->type
= type
;
1312 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1317 /* C++: If it was not found as a data field, then try to return it
1318 as a pointer to a method. */
1320 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1322 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1324 is_a_field_of_this
->type
= type
;
1325 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1330 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1331 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
1337 /* Behave like lookup_symbol except that NAME is the natural name
1338 (e.g., demangled name) of the symbol that we're looking for. */
1340 static struct symbol
*
1341 lookup_symbol_aux (const char *name
, const struct block
*block
,
1342 const domain_enum domain
, enum language language
,
1343 struct field_of_this_result
*is_a_field_of_this
)
1346 const struct language_defn
*langdef
;
1348 /* Make sure we do something sensible with is_a_field_of_this, since
1349 the callers that set this parameter to some non-null value will
1350 certainly use it later. If we don't set it, the contents of
1351 is_a_field_of_this are undefined. */
1352 if (is_a_field_of_this
!= NULL
)
1353 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
1355 /* Search specified block and its superiors. Don't search
1356 STATIC_BLOCK or GLOBAL_BLOCK. */
1358 sym
= lookup_symbol_aux_local (name
, block
, domain
, language
);
1362 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1363 check to see if NAME is a field of `this'. */
1365 langdef
= language_def (language
);
1367 /* Don't do this check if we are searching for a struct. It will
1368 not be found by check_field, but will be found by other
1370 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
1372 struct symbol
*sym
= lookup_language_this (langdef
, block
);
1376 struct type
*t
= sym
->type
;
1378 /* I'm not really sure that type of this can ever
1379 be typedefed; just be safe. */
1381 if (TYPE_CODE (t
) == TYPE_CODE_PTR
1382 || TYPE_CODE (t
) == TYPE_CODE_REF
)
1383 t
= TYPE_TARGET_TYPE (t
);
1385 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1386 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1387 error (_("Internal error: `%s' is not an aggregate"),
1388 langdef
->la_name_of_this
);
1390 if (check_field (t
, name
, is_a_field_of_this
))
1395 /* Now do whatever is appropriate for LANGUAGE to look
1396 up static and global variables. */
1398 sym
= langdef
->la_lookup_symbol_nonlocal (name
, block
, domain
);
1402 /* Now search all static file-level symbols. Not strictly correct,
1403 but more useful than an error. */
1405 return lookup_static_symbol_aux (name
, domain
);
1408 /* Search all static file-level symbols for NAME from DOMAIN. Do the symtabs
1409 first, then check the psymtabs. If a psymtab indicates the existence of the
1410 desired name as a file-level static, then do psymtab-to-symtab conversion on
1411 the fly and return the found symbol. */
1414 lookup_static_symbol_aux (const char *name
, const domain_enum domain
)
1416 struct objfile
*objfile
;
1419 sym
= lookup_symbol_aux_symtabs (STATIC_BLOCK
, name
, domain
);
1423 ALL_OBJFILES (objfile
)
1425 sym
= lookup_symbol_aux_quick (objfile
, STATIC_BLOCK
, name
, domain
);
1433 /* Check to see if the symbol is defined in BLOCK or its superiors.
1434 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
1436 static struct symbol
*
1437 lookup_symbol_aux_local (const char *name
, const struct block
*block
,
1438 const domain_enum domain
,
1439 enum language language
)
1442 const struct block
*static_block
= block_static_block (block
);
1443 const char *scope
= block_scope (block
);
1445 /* Check if either no block is specified or it's a global block. */
1447 if (static_block
== NULL
)
1450 while (block
!= static_block
)
1452 sym
= lookup_symbol_aux_block (name
, block
, domain
);
1456 if (language
== language_cplus
|| language
== language_fortran
)
1458 sym
= cp_lookup_symbol_imports_or_template (scope
, name
, block
,
1464 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
1466 block
= BLOCK_SUPERBLOCK (block
);
1469 /* We've reached the edge of the function without finding a result. */
1474 /* Look up OBJFILE to BLOCK. */
1477 lookup_objfile_from_block (const struct block
*block
)
1479 struct objfile
*obj
;
1485 block
= block_global_block (block
);
1486 /* Go through SYMTABS. */
1487 ALL_SYMTABS (obj
, s
)
1488 if (block
== BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
))
1490 if (obj
->separate_debug_objfile_backlink
)
1491 obj
= obj
->separate_debug_objfile_backlink
;
1499 /* Look up a symbol in a block; if found, fixup the symbol, and set
1500 block_found appropriately. */
1503 lookup_symbol_aux_block (const char *name
, const struct block
*block
,
1504 const domain_enum domain
)
1508 sym
= lookup_block_symbol (block
, name
, domain
);
1511 block_found
= block
;
1512 return fixup_symbol_section (sym
, NULL
);
1518 /* Check all global symbols in OBJFILE in symtabs and
1522 lookup_global_symbol_from_objfile (const struct objfile
*main_objfile
,
1524 const domain_enum domain
)
1526 const struct objfile
*objfile
;
1528 struct blockvector
*bv
;
1529 const struct block
*block
;
1532 for (objfile
= main_objfile
;
1534 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
1536 /* Go through symtabs. */
1537 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
1539 bv
= BLOCKVECTOR (s
);
1540 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1541 sym
= lookup_block_symbol (block
, name
, domain
);
1544 block_found
= block
;
1545 return fixup_symbol_section (sym
, (struct objfile
*)objfile
);
1549 sym
= lookup_symbol_aux_quick ((struct objfile
*) objfile
, GLOBAL_BLOCK
,
1558 /* Check to see if the symbol is defined in one of the OBJFILE's
1559 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
1560 depending on whether or not we want to search global symbols or
1563 static struct symbol
*
1564 lookup_symbol_aux_objfile (struct objfile
*objfile
, int block_index
,
1565 const char *name
, const domain_enum domain
)
1567 struct symbol
*sym
= NULL
;
1568 struct blockvector
*bv
;
1569 const struct block
*block
;
1572 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
1574 bv
= BLOCKVECTOR (s
);
1575 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
1576 sym
= lookup_block_symbol (block
, name
, domain
);
1579 block_found
= block
;
1580 return fixup_symbol_section (sym
, objfile
);
1587 /* Same as lookup_symbol_aux_objfile, except that it searches all
1588 objfiles. Return the first match found. */
1590 static struct symbol
*
1591 lookup_symbol_aux_symtabs (int block_index
, const char *name
,
1592 const domain_enum domain
)
1595 struct objfile
*objfile
;
1597 ALL_OBJFILES (objfile
)
1599 sym
= lookup_symbol_aux_objfile (objfile
, block_index
, name
, domain
);
1607 /* Wrapper around lookup_symbol_aux_objfile for search_symbols.
1608 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
1609 and all related objfiles. */
1611 static struct symbol
*
1612 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
1613 const char *linkage_name
,
1616 enum language lang
= current_language
->la_language
;
1617 const char *modified_name
;
1618 struct cleanup
*cleanup
= demangle_for_lookup (linkage_name
, lang
,
1620 struct objfile
*main_objfile
, *cur_objfile
;
1622 if (objfile
->separate_debug_objfile_backlink
)
1623 main_objfile
= objfile
->separate_debug_objfile_backlink
;
1625 main_objfile
= objfile
;
1627 for (cur_objfile
= main_objfile
;
1629 cur_objfile
= objfile_separate_debug_iterate (main_objfile
, cur_objfile
))
1633 sym
= lookup_symbol_aux_objfile (cur_objfile
, GLOBAL_BLOCK
,
1634 modified_name
, domain
);
1636 sym
= lookup_symbol_aux_objfile (cur_objfile
, STATIC_BLOCK
,
1637 modified_name
, domain
);
1640 do_cleanups (cleanup
);
1645 do_cleanups (cleanup
);
1649 /* A helper function that throws an exception when a symbol was found
1650 in a psymtab but not in a symtab. */
1652 static void ATTRIBUTE_NORETURN
1653 error_in_psymtab_expansion (int kind
, const char *name
, struct symtab
*symtab
)
1656 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
1657 %s may be an inlined function, or may be a template function\n \
1658 (if a template, try specifying an instantiation: %s<type>)."),
1659 kind
== GLOBAL_BLOCK
? "global" : "static",
1660 name
, symtab_to_filename_for_display (symtab
), name
, name
);
1663 /* A helper function for lookup_symbol_aux that interfaces with the
1664 "quick" symbol table functions. */
1666 static struct symbol
*
1667 lookup_symbol_aux_quick (struct objfile
*objfile
, int kind
,
1668 const char *name
, const domain_enum domain
)
1670 struct symtab
*symtab
;
1671 struct blockvector
*bv
;
1672 const struct block
*block
;
1677 symtab
= objfile
->sf
->qf
->lookup_symbol (objfile
, kind
, name
, domain
);
1681 bv
= BLOCKVECTOR (symtab
);
1682 block
= BLOCKVECTOR_BLOCK (bv
, kind
);
1683 sym
= lookup_block_symbol (block
, name
, domain
);
1685 error_in_psymtab_expansion (kind
, name
, symtab
);
1686 return fixup_symbol_section (sym
, objfile
);
1689 /* A default version of lookup_symbol_nonlocal for use by languages
1690 that can't think of anything better to do. This implements the C
1694 basic_lookup_symbol_nonlocal (const char *name
,
1695 const struct block
*block
,
1696 const domain_enum domain
)
1700 /* NOTE: carlton/2003-05-19: The comments below were written when
1701 this (or what turned into this) was part of lookup_symbol_aux;
1702 I'm much less worried about these questions now, since these
1703 decisions have turned out well, but I leave these comments here
1706 /* NOTE: carlton/2002-12-05: There is a question as to whether or
1707 not it would be appropriate to search the current global block
1708 here as well. (That's what this code used to do before the
1709 is_a_field_of_this check was moved up.) On the one hand, it's
1710 redundant with the lookup_symbol_aux_symtabs search that happens
1711 next. On the other hand, if decode_line_1 is passed an argument
1712 like filename:var, then the user presumably wants 'var' to be
1713 searched for in filename. On the third hand, there shouldn't be
1714 multiple global variables all of which are named 'var', and it's
1715 not like decode_line_1 has ever restricted its search to only
1716 global variables in a single filename. All in all, only
1717 searching the static block here seems best: it's correct and it's
1720 /* NOTE: carlton/2002-12-05: There's also a possible performance
1721 issue here: if you usually search for global symbols in the
1722 current file, then it would be slightly better to search the
1723 current global block before searching all the symtabs. But there
1724 are other factors that have a much greater effect on performance
1725 than that one, so I don't think we should worry about that for
1728 sym
= lookup_symbol_static (name
, block
, domain
);
1732 return lookup_symbol_global (name
, block
, domain
);
1735 /* Lookup a symbol in the static block associated to BLOCK, if there
1736 is one; do nothing if BLOCK is NULL or a global block. */
1739 lookup_symbol_static (const char *name
,
1740 const struct block
*block
,
1741 const domain_enum domain
)
1743 const struct block
*static_block
= block_static_block (block
);
1745 if (static_block
!= NULL
)
1746 return lookup_symbol_aux_block (name
, static_block
, domain
);
1751 /* Private data to be used with lookup_symbol_global_iterator_cb. */
1753 struct global_sym_lookup_data
1755 /* The name of the symbol we are searching for. */
1758 /* The domain to use for our search. */
1761 /* The field where the callback should store the symbol if found.
1762 It should be initialized to NULL before the search is started. */
1763 struct symbol
*result
;
1766 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
1767 It searches by name for a symbol in the GLOBAL_BLOCK of the given
1768 OBJFILE. The arguments for the search are passed via CB_DATA,
1769 which in reality is a pointer to struct global_sym_lookup_data. */
1772 lookup_symbol_global_iterator_cb (struct objfile
*objfile
,
1775 struct global_sym_lookup_data
*data
=
1776 (struct global_sym_lookup_data
*) cb_data
;
1778 gdb_assert (data
->result
== NULL
);
1780 data
->result
= lookup_symbol_aux_objfile (objfile
, GLOBAL_BLOCK
,
1781 data
->name
, data
->domain
);
1782 if (data
->result
== NULL
)
1783 data
->result
= lookup_symbol_aux_quick (objfile
, GLOBAL_BLOCK
,
1784 data
->name
, data
->domain
);
1786 /* If we found a match, tell the iterator to stop. Otherwise,
1788 return (data
->result
!= NULL
);
1791 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1795 lookup_symbol_global (const char *name
,
1796 const struct block
*block
,
1797 const domain_enum domain
)
1799 struct symbol
*sym
= NULL
;
1800 struct objfile
*objfile
= NULL
;
1801 struct global_sym_lookup_data lookup_data
;
1803 /* Call library-specific lookup procedure. */
1804 objfile
= lookup_objfile_from_block (block
);
1805 if (objfile
!= NULL
)
1806 sym
= solib_global_lookup (objfile
, name
, domain
);
1810 memset (&lookup_data
, 0, sizeof (lookup_data
));
1811 lookup_data
.name
= name
;
1812 lookup_data
.domain
= domain
;
1813 gdbarch_iterate_over_objfiles_in_search_order
1814 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
1815 lookup_symbol_global_iterator_cb
, &lookup_data
, objfile
);
1817 return lookup_data
.result
;
1821 symbol_matches_domain (enum language symbol_language
,
1822 domain_enum symbol_domain
,
1825 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
1826 A Java class declaration also defines a typedef for the class.
1827 Similarly, any Ada type declaration implicitly defines a typedef. */
1828 if (symbol_language
== language_cplus
1829 || symbol_language
== language_d
1830 || symbol_language
== language_java
1831 || symbol_language
== language_ada
)
1833 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
1834 && symbol_domain
== STRUCT_DOMAIN
)
1837 /* For all other languages, strict match is required. */
1838 return (symbol_domain
== domain
);
1841 /* Look up a type named NAME in the struct_domain. The type returned
1842 must not be opaque -- i.e., must have at least one field
1846 lookup_transparent_type (const char *name
)
1848 return current_language
->la_lookup_transparent_type (name
);
1851 /* A helper for basic_lookup_transparent_type that interfaces with the
1852 "quick" symbol table functions. */
1854 static struct type
*
1855 basic_lookup_transparent_type_quick (struct objfile
*objfile
, int kind
,
1858 struct symtab
*symtab
;
1859 struct blockvector
*bv
;
1860 struct block
*block
;
1865 symtab
= objfile
->sf
->qf
->lookup_symbol (objfile
, kind
, name
, STRUCT_DOMAIN
);
1869 bv
= BLOCKVECTOR (symtab
);
1870 block
= BLOCKVECTOR_BLOCK (bv
, kind
);
1871 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1873 error_in_psymtab_expansion (kind
, name
, symtab
);
1875 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1876 return SYMBOL_TYPE (sym
);
1881 /* The standard implementation of lookup_transparent_type. This code
1882 was modeled on lookup_symbol -- the parts not relevant to looking
1883 up types were just left out. In particular it's assumed here that
1884 types are available in struct_domain and only at file-static or
1888 basic_lookup_transparent_type (const char *name
)
1891 struct symtab
*s
= NULL
;
1892 struct blockvector
*bv
;
1893 struct objfile
*objfile
;
1894 struct block
*block
;
1897 /* Now search all the global symbols. Do the symtab's first, then
1898 check the psymtab's. If a psymtab indicates the existence
1899 of the desired name as a global, then do psymtab-to-symtab
1900 conversion on the fly and return the found symbol. */
1902 ALL_OBJFILES (objfile
)
1904 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
1906 bv
= BLOCKVECTOR (s
);
1907 block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1908 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1909 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1911 return SYMBOL_TYPE (sym
);
1916 ALL_OBJFILES (objfile
)
1918 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
1923 /* Now search the static file-level symbols.
1924 Not strictly correct, but more useful than an error.
1925 Do the symtab's first, then
1926 check the psymtab's. If a psymtab indicates the existence
1927 of the desired name as a file-level static, then do psymtab-to-symtab
1928 conversion on the fly and return the found symbol. */
1930 ALL_OBJFILES (objfile
)
1932 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
1934 bv
= BLOCKVECTOR (s
);
1935 block
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1936 sym
= lookup_block_symbol (block
, name
, STRUCT_DOMAIN
);
1937 if (sym
&& !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
1939 return SYMBOL_TYPE (sym
);
1944 ALL_OBJFILES (objfile
)
1946 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
1951 return (struct type
*) 0;
1954 /* Find the name of the file containing main(). */
1955 /* FIXME: What about languages without main() or specially linked
1956 executables that have no main() ? */
1959 find_main_filename (void)
1961 struct objfile
*objfile
;
1962 char *name
= main_name ();
1964 ALL_OBJFILES (objfile
)
1970 result
= objfile
->sf
->qf
->find_symbol_file (objfile
, name
);
1977 /* Search BLOCK for symbol NAME in DOMAIN.
1979 Note that if NAME is the demangled form of a C++ symbol, we will fail
1980 to find a match during the binary search of the non-encoded names, but
1981 for now we don't worry about the slight inefficiency of looking for
1982 a match we'll never find, since it will go pretty quick. Once the
1983 binary search terminates, we drop through and do a straight linear
1984 search on the symbols. Each symbol which is marked as being a ObjC/C++
1985 symbol (language_cplus or language_objc set) has both the encoded and
1986 non-encoded names tested for a match. */
1989 lookup_block_symbol (const struct block
*block
, const char *name
,
1990 const domain_enum domain
)
1992 struct block_iterator iter
;
1995 if (!BLOCK_FUNCTION (block
))
1997 for (sym
= block_iter_name_first (block
, name
, &iter
);
1999 sym
= block_iter_name_next (name
, &iter
))
2001 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2002 SYMBOL_DOMAIN (sym
), domain
))
2009 /* Note that parameter symbols do not always show up last in the
2010 list; this loop makes sure to take anything else other than
2011 parameter symbols first; it only uses parameter symbols as a
2012 last resort. Note that this only takes up extra computation
2015 struct symbol
*sym_found
= NULL
;
2017 for (sym
= block_iter_name_first (block
, name
, &iter
);
2019 sym
= block_iter_name_next (name
, &iter
))
2021 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2022 SYMBOL_DOMAIN (sym
), domain
))
2025 if (!SYMBOL_IS_ARGUMENT (sym
))
2031 return (sym_found
); /* Will be NULL if not found. */
2035 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2037 For each symbol that matches, CALLBACK is called. The symbol and
2038 DATA are passed to the callback.
2040 If CALLBACK returns zero, the iteration ends. Otherwise, the
2041 search continues. */
2044 iterate_over_symbols (const struct block
*block
, const char *name
,
2045 const domain_enum domain
,
2046 symbol_found_callback_ftype
*callback
,
2049 struct block_iterator iter
;
2052 for (sym
= block_iter_name_first (block
, name
, &iter
);
2054 sym
= block_iter_name_next (name
, &iter
))
2056 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2057 SYMBOL_DOMAIN (sym
), domain
))
2059 if (!callback (sym
, data
))
2065 /* Find the symtab associated with PC and SECTION. Look through the
2066 psymtabs and read in another symtab if necessary. */
2069 find_pc_sect_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2072 struct blockvector
*bv
;
2073 struct symtab
*s
= NULL
;
2074 struct symtab
*best_s
= NULL
;
2075 struct objfile
*objfile
;
2076 CORE_ADDR distance
= 0;
2077 struct minimal_symbol
*msymbol
;
2079 /* If we know that this is not a text address, return failure. This is
2080 necessary because we loop based on the block's high and low code
2081 addresses, which do not include the data ranges, and because
2082 we call find_pc_sect_psymtab which has a similar restriction based
2083 on the partial_symtab's texthigh and textlow. */
2084 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
;
2086 && (MSYMBOL_TYPE (msymbol
) == mst_data
2087 || MSYMBOL_TYPE (msymbol
) == mst_bss
2088 || MSYMBOL_TYPE (msymbol
) == mst_abs
2089 || MSYMBOL_TYPE (msymbol
) == mst_file_data
2090 || MSYMBOL_TYPE (msymbol
) == mst_file_bss
))
2093 /* Search all symtabs for the one whose file contains our address, and which
2094 is the smallest of all the ones containing the address. This is designed
2095 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2096 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2097 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2099 This happens for native ecoff format, where code from included files
2100 gets its own symtab. The symtab for the included file should have
2101 been read in already via the dependency mechanism.
2102 It might be swifter to create several symtabs with the same name
2103 like xcoff does (I'm not sure).
2105 It also happens for objfiles that have their functions reordered.
2106 For these, the symtab we are looking for is not necessarily read in. */
2108 ALL_PRIMARY_SYMTABS (objfile
, s
)
2110 bv
= BLOCKVECTOR (s
);
2111 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2113 if (BLOCK_START (b
) <= pc
2114 && BLOCK_END (b
) > pc
2116 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2118 /* For an objfile that has its functions reordered,
2119 find_pc_psymtab will find the proper partial symbol table
2120 and we simply return its corresponding symtab. */
2121 /* In order to better support objfiles that contain both
2122 stabs and coff debugging info, we continue on if a psymtab
2124 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->sf
)
2126 struct symtab
*result
;
2129 = objfile
->sf
->qf
->find_pc_sect_symtab (objfile
,
2138 struct block_iterator iter
;
2139 struct symbol
*sym
= NULL
;
2141 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2143 fixup_symbol_section (sym
, objfile
);
2144 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, sym
),
2149 continue; /* No symbol in this symtab matches
2152 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2160 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2162 ALL_OBJFILES (objfile
)
2164 struct symtab
*result
;
2168 result
= objfile
->sf
->qf
->find_pc_sect_symtab (objfile
,
2179 /* Find the symtab associated with PC. Look through the psymtabs and read
2180 in another symtab if necessary. Backward compatibility, no section. */
2183 find_pc_symtab (CORE_ADDR pc
)
2185 return find_pc_sect_symtab (pc
, find_pc_mapped_section (pc
));
2189 /* Find the source file and line number for a given PC value and SECTION.
2190 Return a structure containing a symtab pointer, a line number,
2191 and a pc range for the entire source line.
2192 The value's .pc field is NOT the specified pc.
2193 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2194 use the line that ends there. Otherwise, in that case, the line
2195 that begins there is used. */
2197 /* The big complication here is that a line may start in one file, and end just
2198 before the start of another file. This usually occurs when you #include
2199 code in the middle of a subroutine. To properly find the end of a line's PC
2200 range, we must search all symtabs associated with this compilation unit, and
2201 find the one whose first PC is closer than that of the next line in this
2204 /* If it's worth the effort, we could be using a binary search. */
2206 struct symtab_and_line
2207 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
2210 struct linetable
*l
;
2213 struct linetable_entry
*item
;
2214 struct symtab_and_line val
;
2215 struct blockvector
*bv
;
2216 struct bound_minimal_symbol msymbol
;
2217 struct minimal_symbol
*mfunsym
;
2218 struct objfile
*objfile
;
2220 /* Info on best line seen so far, and where it starts, and its file. */
2222 struct linetable_entry
*best
= NULL
;
2223 CORE_ADDR best_end
= 0;
2224 struct symtab
*best_symtab
= 0;
2226 /* Store here the first line number
2227 of a file which contains the line at the smallest pc after PC.
2228 If we don't find a line whose range contains PC,
2229 we will use a line one less than this,
2230 with a range from the start of that file to the first line's pc. */
2231 struct linetable_entry
*alt
= NULL
;
2233 /* Info on best line seen in this file. */
2235 struct linetable_entry
*prev
;
2237 /* If this pc is not from the current frame,
2238 it is the address of the end of a call instruction.
2239 Quite likely that is the start of the following statement.
2240 But what we want is the statement containing the instruction.
2241 Fudge the pc to make sure we get that. */
2243 init_sal (&val
); /* initialize to zeroes */
2245 val
.pspace
= current_program_space
;
2247 /* It's tempting to assume that, if we can't find debugging info for
2248 any function enclosing PC, that we shouldn't search for line
2249 number info, either. However, GAS can emit line number info for
2250 assembly files --- very helpful when debugging hand-written
2251 assembly code. In such a case, we'd have no debug info for the
2252 function, but we would have line info. */
2257 /* elz: added this because this function returned the wrong
2258 information if the pc belongs to a stub (import/export)
2259 to call a shlib function. This stub would be anywhere between
2260 two functions in the target, and the line info was erroneously
2261 taken to be the one of the line before the pc. */
2263 /* RT: Further explanation:
2265 * We have stubs (trampolines) inserted between procedures.
2267 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2268 * exists in the main image.
2270 * In the minimal symbol table, we have a bunch of symbols
2271 * sorted by start address. The stubs are marked as "trampoline",
2272 * the others appear as text. E.g.:
2274 * Minimal symbol table for main image
2275 * main: code for main (text symbol)
2276 * shr1: stub (trampoline symbol)
2277 * foo: code for foo (text symbol)
2279 * Minimal symbol table for "shr1" image:
2281 * shr1: code for shr1 (text symbol)
2284 * So the code below is trying to detect if we are in the stub
2285 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2286 * and if found, do the symbolization from the real-code address
2287 * rather than the stub address.
2289 * Assumptions being made about the minimal symbol table:
2290 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
2291 * if we're really in the trampoline.s If we're beyond it (say
2292 * we're in "foo" in the above example), it'll have a closer
2293 * symbol (the "foo" text symbol for example) and will not
2294 * return the trampoline.
2295 * 2. lookup_minimal_symbol_text() will find a real text symbol
2296 * corresponding to the trampoline, and whose address will
2297 * be different than the trampoline address. I put in a sanity
2298 * check for the address being the same, to avoid an
2299 * infinite recursion.
2301 msymbol
= lookup_minimal_symbol_by_pc (pc
);
2302 if (msymbol
.minsym
!= NULL
)
2303 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
2306 = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol
.minsym
),
2308 if (mfunsym
== NULL
)
2309 /* I eliminated this warning since it is coming out
2310 * in the following situation:
2311 * gdb shmain // test program with shared libraries
2312 * (gdb) break shr1 // function in shared lib
2313 * Warning: In stub for ...
2314 * In the above situation, the shared lib is not loaded yet,
2315 * so of course we can't find the real func/line info,
2316 * but the "break" still works, and the warning is annoying.
2317 * So I commented out the warning. RT */
2318 /* warning ("In stub for %s; unable to find real function/line info",
2319 SYMBOL_LINKAGE_NAME (msymbol)); */
2322 else if (SYMBOL_VALUE_ADDRESS (mfunsym
)
2323 == SYMBOL_VALUE_ADDRESS (msymbol
.minsym
))
2324 /* Avoid infinite recursion */
2325 /* See above comment about why warning is commented out. */
2326 /* warning ("In stub for %s; unable to find real function/line info",
2327 SYMBOL_LINKAGE_NAME (msymbol)); */
2331 return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym
), 0);
2335 s
= find_pc_sect_symtab (pc
, section
);
2338 /* If no symbol information, return previous pc. */
2345 bv
= BLOCKVECTOR (s
);
2346 objfile
= s
->objfile
;
2348 /* Look at all the symtabs that share this blockvector.
2349 They all have the same apriori range, that we found was right;
2350 but they have different line tables. */
2352 ALL_OBJFILE_SYMTABS (objfile
, s
)
2354 if (BLOCKVECTOR (s
) != bv
)
2357 /* Find the best line in this symtab. */
2364 /* I think len can be zero if the symtab lacks line numbers
2365 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
2366 I'm not sure which, and maybe it depends on the symbol
2372 item
= l
->item
; /* Get first line info. */
2374 /* Is this file's first line closer than the first lines of other files?
2375 If so, record this file, and its first line, as best alternate. */
2376 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
2379 for (i
= 0; i
< len
; i
++, item
++)
2381 /* Leave prev pointing to the linetable entry for the last line
2382 that started at or before PC. */
2389 /* At this point, prev points at the line whose start addr is <= pc, and
2390 item points at the next line. If we ran off the end of the linetable
2391 (pc >= start of the last line), then prev == item. If pc < start of
2392 the first line, prev will not be set. */
2394 /* Is this file's best line closer than the best in the other files?
2395 If so, record this file, and its best line, as best so far. Don't
2396 save prev if it represents the end of a function (i.e. line number
2397 0) instead of a real line. */
2399 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
2404 /* Discard BEST_END if it's before the PC of the current BEST. */
2405 if (best_end
<= best
->pc
)
2409 /* If another line (denoted by ITEM) is in the linetable and its
2410 PC is after BEST's PC, but before the current BEST_END, then
2411 use ITEM's PC as the new best_end. */
2412 if (best
&& i
< len
&& item
->pc
> best
->pc
2413 && (best_end
== 0 || best_end
> item
->pc
))
2414 best_end
= item
->pc
;
2419 /* If we didn't find any line number info, just return zeros.
2420 We used to return alt->line - 1 here, but that could be
2421 anywhere; if we don't have line number info for this PC,
2422 don't make some up. */
2425 else if (best
->line
== 0)
2427 /* If our best fit is in a range of PC's for which no line
2428 number info is available (line number is zero) then we didn't
2429 find any valid line information. */
2434 val
.symtab
= best_symtab
;
2435 val
.line
= best
->line
;
2437 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
2442 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
2444 val
.section
= section
;
2448 /* Backward compatibility (no section). */
2450 struct symtab_and_line
2451 find_pc_line (CORE_ADDR pc
, int notcurrent
)
2453 struct obj_section
*section
;
2455 section
= find_pc_overlay (pc
);
2456 if (pc_in_unmapped_range (pc
, section
))
2457 pc
= overlay_mapped_address (pc
, section
);
2458 return find_pc_sect_line (pc
, section
, notcurrent
);
2461 /* Find line number LINE in any symtab whose name is the same as
2464 If found, return the symtab that contains the linetable in which it was
2465 found, set *INDEX to the index in the linetable of the best entry
2466 found, and set *EXACT_MATCH nonzero if the value returned is an
2469 If not found, return NULL. */
2472 find_line_symtab (struct symtab
*symtab
, int line
,
2473 int *index
, int *exact_match
)
2475 int exact
= 0; /* Initialized here to avoid a compiler warning. */
2477 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
2481 struct linetable
*best_linetable
;
2482 struct symtab
*best_symtab
;
2484 /* First try looking it up in the given symtab. */
2485 best_linetable
= LINETABLE (symtab
);
2486 best_symtab
= symtab
;
2487 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
2488 if (best_index
< 0 || !exact
)
2490 /* Didn't find an exact match. So we better keep looking for
2491 another symtab with the same name. In the case of xcoff,
2492 multiple csects for one source file (produced by IBM's FORTRAN
2493 compiler) produce multiple symtabs (this is unavoidable
2494 assuming csects can be at arbitrary places in memory and that
2495 the GLOBAL_BLOCK of a symtab has a begin and end address). */
2497 /* BEST is the smallest linenumber > LINE so far seen,
2498 or 0 if none has been seen so far.
2499 BEST_INDEX and BEST_LINETABLE identify the item for it. */
2502 struct objfile
*objfile
;
2505 if (best_index
>= 0)
2506 best
= best_linetable
->item
[best_index
].line
;
2510 ALL_OBJFILES (objfile
)
2513 objfile
->sf
->qf
->expand_symtabs_with_fullname (objfile
,
2514 symtab_to_fullname (symtab
));
2517 ALL_SYMTABS (objfile
, s
)
2519 struct linetable
*l
;
2522 if (FILENAME_CMP (symtab
->filename
, s
->filename
) != 0)
2524 if (FILENAME_CMP (symtab_to_fullname (symtab
),
2525 symtab_to_fullname (s
)) != 0)
2528 ind
= find_line_common (l
, line
, &exact
, 0);
2538 if (best
== 0 || l
->item
[ind
].line
< best
)
2540 best
= l
->item
[ind
].line
;
2553 *index
= best_index
;
2555 *exact_match
= exact
;
2560 /* Given SYMTAB, returns all the PCs function in the symtab that
2561 exactly match LINE. Returns NULL if there are no exact matches,
2562 but updates BEST_ITEM in this case. */
2565 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
2566 struct linetable_entry
**best_item
)
2569 VEC (CORE_ADDR
) *result
= NULL
;
2571 /* First, collect all the PCs that are at this line. */
2577 idx
= find_line_common (LINETABLE (symtab
), line
, &was_exact
, start
);
2583 struct linetable_entry
*item
= &LINETABLE (symtab
)->item
[idx
];
2585 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
2591 VEC_safe_push (CORE_ADDR
, result
, LINETABLE (symtab
)->item
[idx
].pc
);
2599 /* Set the PC value for a given source file and line number and return true.
2600 Returns zero for invalid line number (and sets the PC to 0).
2601 The source file is specified with a struct symtab. */
2604 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
2606 struct linetable
*l
;
2613 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
2616 l
= LINETABLE (symtab
);
2617 *pc
= l
->item
[ind
].pc
;
2624 /* Find the range of pc values in a line.
2625 Store the starting pc of the line into *STARTPTR
2626 and the ending pc (start of next line) into *ENDPTR.
2627 Returns 1 to indicate success.
2628 Returns 0 if could not find the specified line. */
2631 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
2634 CORE_ADDR startaddr
;
2635 struct symtab_and_line found_sal
;
2638 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
2641 /* This whole function is based on address. For example, if line 10 has
2642 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
2643 "info line *0x123" should say the line goes from 0x100 to 0x200
2644 and "info line *0x355" should say the line goes from 0x300 to 0x400.
2645 This also insures that we never give a range like "starts at 0x134
2646 and ends at 0x12c". */
2648 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
2649 if (found_sal
.line
!= sal
.line
)
2651 /* The specified line (sal) has zero bytes. */
2652 *startptr
= found_sal
.pc
;
2653 *endptr
= found_sal
.pc
;
2657 *startptr
= found_sal
.pc
;
2658 *endptr
= found_sal
.end
;
2663 /* Given a line table and a line number, return the index into the line
2664 table for the pc of the nearest line whose number is >= the specified one.
2665 Return -1 if none is found. The value is >= 0 if it is an index.
2666 START is the index at which to start searching the line table.
2668 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
2671 find_line_common (struct linetable
*l
, int lineno
,
2672 int *exact_match
, int start
)
2677 /* BEST is the smallest linenumber > LINENO so far seen,
2678 or 0 if none has been seen so far.
2679 BEST_INDEX identifies the item for it. */
2681 int best_index
= -1;
2692 for (i
= start
; i
< len
; i
++)
2694 struct linetable_entry
*item
= &(l
->item
[i
]);
2696 if (item
->line
== lineno
)
2698 /* Return the first (lowest address) entry which matches. */
2703 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
2710 /* If we got here, we didn't get an exact match. */
2715 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
2717 struct symtab_and_line sal
;
2719 sal
= find_pc_line (pc
, 0);
2722 return sal
.symtab
!= 0;
2725 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
2726 address for that function that has an entry in SYMTAB's line info
2727 table. If such an entry cannot be found, return FUNC_ADDR
2731 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
2733 CORE_ADDR func_start
, func_end
;
2734 struct linetable
*l
;
2737 /* Give up if this symbol has no lineinfo table. */
2738 l
= LINETABLE (symtab
);
2742 /* Get the range for the function's PC values, or give up if we
2743 cannot, for some reason. */
2744 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
2747 /* Linetable entries are ordered by PC values, see the commentary in
2748 symtab.h where `struct linetable' is defined. Thus, the first
2749 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
2750 address we are looking for. */
2751 for (i
= 0; i
< l
->nitems
; i
++)
2753 struct linetable_entry
*item
= &(l
->item
[i
]);
2755 /* Don't use line numbers of zero, they mark special entries in
2756 the table. See the commentary on symtab.h before the
2757 definition of struct linetable. */
2758 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
2765 /* Given a function symbol SYM, find the symtab and line for the start
2767 If the argument FUNFIRSTLINE is nonzero, we want the first line
2768 of real code inside the function. */
2770 struct symtab_and_line
2771 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
2773 struct symtab_and_line sal
;
2775 fixup_symbol_section (sym
, NULL
);
2776 sal
= find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2777 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
), 0);
2779 /* We always should have a line for the function start address.
2780 If we don't, something is odd. Create a plain SAL refering
2781 just the PC and hope that skip_prologue_sal (if requested)
2782 can find a line number for after the prologue. */
2783 if (sal
.pc
< BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)))
2786 sal
.pspace
= current_program_space
;
2787 sal
.pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2788 sal
.section
= SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
);
2792 skip_prologue_sal (&sal
);
2797 /* Adjust SAL to the first instruction past the function prologue.
2798 If the PC was explicitly specified, the SAL is not changed.
2799 If the line number was explicitly specified, at most the SAL's PC
2800 is updated. If SAL is already past the prologue, then do nothing. */
2803 skip_prologue_sal (struct symtab_and_line
*sal
)
2806 struct symtab_and_line start_sal
;
2807 struct cleanup
*old_chain
;
2808 CORE_ADDR pc
, saved_pc
;
2809 struct obj_section
*section
;
2811 struct objfile
*objfile
;
2812 struct gdbarch
*gdbarch
;
2813 struct block
*b
, *function_block
;
2814 int force_skip
, skip
;
2816 /* Do not change the SAL if PC was specified explicitly. */
2817 if (sal
->explicit_pc
)
2820 old_chain
= save_current_space_and_thread ();
2821 switch_to_program_space_and_thread (sal
->pspace
);
2823 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
2826 fixup_symbol_section (sym
, NULL
);
2828 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
2829 section
= SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym
), sym
);
2830 name
= SYMBOL_LINKAGE_NAME (sym
);
2831 objfile
= SYMBOL_SYMTAB (sym
)->objfile
;
2835 struct minimal_symbol
*msymbol
2836 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
).minsym
;
2838 if (msymbol
== NULL
)
2840 do_cleanups (old_chain
);
2844 objfile
= msymbol_objfile (msymbol
);
2845 pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
2846 section
= SYMBOL_OBJ_SECTION (objfile
, msymbol
);
2847 name
= SYMBOL_LINKAGE_NAME (msymbol
);
2850 gdbarch
= get_objfile_arch (objfile
);
2852 /* Process the prologue in two passes. In the first pass try to skip the
2853 prologue (SKIP is true) and verify there is a real need for it (indicated
2854 by FORCE_SKIP). If no such reason was found run a second pass where the
2855 prologue is not skipped (SKIP is false). */
2860 /* Be conservative - allow direct PC (without skipping prologue) only if we
2861 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
2862 have to be set by the caller so we use SYM instead. */
2863 if (sym
&& SYMBOL_SYMTAB (sym
)->locations_valid
)
2871 /* If the function is in an unmapped overlay, use its unmapped LMA address,
2872 so that gdbarch_skip_prologue has something unique to work on. */
2873 if (section_is_overlay (section
) && !section_is_mapped (section
))
2874 pc
= overlay_unmapped_address (pc
, section
);
2876 /* Skip "first line" of function (which is actually its prologue). */
2877 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
2879 pc
= gdbarch_skip_prologue (gdbarch
, pc
);
2881 /* For overlays, map pc back into its mapped VMA range. */
2882 pc
= overlay_mapped_address (pc
, section
);
2884 /* Calculate line number. */
2885 start_sal
= find_pc_sect_line (pc
, section
, 0);
2887 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
2888 line is still part of the same function. */
2889 if (skip
&& start_sal
.pc
!= pc
2890 && (sym
? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
2891 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
2892 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
2893 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
2895 /* First pc of next line */
2897 /* Recalculate the line number (might not be N+1). */
2898 start_sal
= find_pc_sect_line (pc
, section
, 0);
2901 /* On targets with executable formats that don't have a concept of
2902 constructors (ELF with .init has, PE doesn't), gcc emits a call
2903 to `__main' in `main' between the prologue and before user
2905 if (gdbarch_skip_main_prologue_p (gdbarch
)
2906 && name
&& strcmp_iw (name
, "main") == 0)
2908 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
2909 /* Recalculate the line number (might not be N+1). */
2910 start_sal
= find_pc_sect_line (pc
, section
, 0);
2914 while (!force_skip
&& skip
--);
2916 /* If we still don't have a valid source line, try to find the first
2917 PC in the lineinfo table that belongs to the same function. This
2918 happens with COFF debug info, which does not seem to have an
2919 entry in lineinfo table for the code after the prologue which has
2920 no direct relation to source. For example, this was found to be
2921 the case with the DJGPP target using "gcc -gcoff" when the
2922 compiler inserted code after the prologue to make sure the stack
2924 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
2926 pc
= skip_prologue_using_lineinfo (pc
, SYMBOL_SYMTAB (sym
));
2927 /* Recalculate the line number. */
2928 start_sal
= find_pc_sect_line (pc
, section
, 0);
2931 do_cleanups (old_chain
);
2933 /* If we're already past the prologue, leave SAL unchanged. Otherwise
2934 forward SAL to the end of the prologue. */
2939 sal
->section
= section
;
2941 /* Unless the explicit_line flag was set, update the SAL line
2942 and symtab to correspond to the modified PC location. */
2943 if (sal
->explicit_line
)
2946 sal
->symtab
= start_sal
.symtab
;
2947 sal
->line
= start_sal
.line
;
2948 sal
->end
= start_sal
.end
;
2950 /* Check if we are now inside an inlined function. If we can,
2951 use the call site of the function instead. */
2952 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
2953 function_block
= NULL
;
2956 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
2958 else if (BLOCK_FUNCTION (b
) != NULL
)
2960 b
= BLOCK_SUPERBLOCK (b
);
2962 if (function_block
!= NULL
2963 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
2965 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
2966 sal
->symtab
= SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block
));
2970 /* If P is of the form "operator[ \t]+..." where `...' is
2971 some legitimate operator text, return a pointer to the
2972 beginning of the substring of the operator text.
2973 Otherwise, return "". */
2976 operator_chars (char *p
, char **end
)
2979 if (strncmp (p
, "operator", 8))
2983 /* Don't get faked out by `operator' being part of a longer
2985 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
2988 /* Allow some whitespace between `operator' and the operator symbol. */
2989 while (*p
== ' ' || *p
== '\t')
2992 /* Recognize 'operator TYPENAME'. */
2994 if (isalpha (*p
) || *p
== '_' || *p
== '$')
2998 while (isalnum (*q
) || *q
== '_' || *q
== '$')
3007 case '\\': /* regexp quoting */
3010 if (p
[2] == '=') /* 'operator\*=' */
3012 else /* 'operator\*' */
3016 else if (p
[1] == '[')
3019 error (_("mismatched quoting on brackets, "
3020 "try 'operator\\[\\]'"));
3021 else if (p
[2] == '\\' && p
[3] == ']')
3023 *end
= p
+ 4; /* 'operator\[\]' */
3027 error (_("nothing is allowed between '[' and ']'"));
3031 /* Gratuitous qoute: skip it and move on. */
3053 if (p
[0] == '-' && p
[1] == '>')
3055 /* Struct pointer member operator 'operator->'. */
3058 *end
= p
+ 3; /* 'operator->*' */
3061 else if (p
[2] == '\\')
3063 *end
= p
+ 4; /* Hopefully 'operator->\*' */
3068 *end
= p
+ 2; /* 'operator->' */
3072 if (p
[1] == '=' || p
[1] == p
[0])
3083 error (_("`operator ()' must be specified "
3084 "without whitespace in `()'"));
3089 error (_("`operator ?:' must be specified "
3090 "without whitespace in `?:'"));
3095 error (_("`operator []' must be specified "
3096 "without whitespace in `[]'"));
3100 error (_("`operator %s' not supported"), p
);
3109 /* Cache to watch for file names already seen by filename_seen. */
3111 struct filename_seen_cache
3113 /* Table of files seen so far. */
3115 /* Initial size of the table. It automagically grows from here. */
3116 #define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
3119 /* filename_seen_cache constructor. */
3121 static struct filename_seen_cache
*
3122 create_filename_seen_cache (void)
3124 struct filename_seen_cache
*cache
;
3126 cache
= XNEW (struct filename_seen_cache
);
3127 cache
->tab
= htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE
,
3128 filename_hash
, filename_eq
,
3129 NULL
, xcalloc
, xfree
);
3134 /* Empty the cache, but do not delete it. */
3137 clear_filename_seen_cache (struct filename_seen_cache
*cache
)
3139 htab_empty (cache
->tab
);
3142 /* filename_seen_cache destructor.
3143 This takes a void * argument as it is generally used as a cleanup. */
3146 delete_filename_seen_cache (void *ptr
)
3148 struct filename_seen_cache
*cache
= ptr
;
3150 htab_delete (cache
->tab
);
3154 /* If FILE is not already in the table of files in CACHE, return zero;
3155 otherwise return non-zero. Optionally add FILE to the table if ADD
3158 NOTE: We don't manage space for FILE, we assume FILE lives as long
3159 as the caller needs. */
3162 filename_seen (struct filename_seen_cache
*cache
, const char *file
, int add
)
3166 /* Is FILE in tab? */
3167 slot
= htab_find_slot (cache
->tab
, file
, add
? INSERT
: NO_INSERT
);
3171 /* No; maybe add it to tab. */
3173 *slot
= (char *) file
;
3178 /* Data structure to maintain printing state for output_source_filename. */
3180 struct output_source_filename_data
3182 /* Cache of what we've seen so far. */
3183 struct filename_seen_cache
*filename_seen_cache
;
3185 /* Flag of whether we're printing the first one. */
3189 /* Slave routine for sources_info. Force line breaks at ,'s.
3190 NAME is the name to print.
3191 DATA contains the state for printing and watching for duplicates. */
3194 output_source_filename (const char *name
,
3195 struct output_source_filename_data
*data
)
3197 /* Since a single source file can result in several partial symbol
3198 tables, we need to avoid printing it more than once. Note: if
3199 some of the psymtabs are read in and some are not, it gets
3200 printed both under "Source files for which symbols have been
3201 read" and "Source files for which symbols will be read in on
3202 demand". I consider this a reasonable way to deal with the
3203 situation. I'm not sure whether this can also happen for
3204 symtabs; it doesn't hurt to check. */
3206 /* Was NAME already seen? */
3207 if (filename_seen (data
->filename_seen_cache
, name
, 1))
3209 /* Yes; don't print it again. */
3213 /* No; print it and reset *FIRST. */
3215 printf_filtered (", ");
3219 fputs_filtered (name
, gdb_stdout
);
3222 /* A callback for map_partial_symbol_filenames. */
3225 output_partial_symbol_filename (const char *filename
, const char *fullname
,
3228 output_source_filename (fullname
? fullname
: filename
, data
);
3232 sources_info (char *ignore
, int from_tty
)
3235 struct objfile
*objfile
;
3236 struct output_source_filename_data data
;
3237 struct cleanup
*cleanups
;
3239 if (!have_full_symbols () && !have_partial_symbols ())
3241 error (_("No symbol table is loaded. Use the \"file\" command."));
3244 data
.filename_seen_cache
= create_filename_seen_cache ();
3245 cleanups
= make_cleanup (delete_filename_seen_cache
,
3246 data
.filename_seen_cache
);
3248 printf_filtered ("Source files for which symbols have been read in:\n\n");
3251 ALL_SYMTABS (objfile
, s
)
3253 const char *fullname
= symtab_to_fullname (s
);
3255 output_source_filename (fullname
, &data
);
3257 printf_filtered ("\n\n");
3259 printf_filtered ("Source files for which symbols "
3260 "will be read in on demand:\n\n");
3262 clear_filename_seen_cache (data
.filename_seen_cache
);
3264 map_partial_symbol_filenames (output_partial_symbol_filename
, &data
,
3265 1 /*need_fullname*/);
3266 printf_filtered ("\n");
3268 do_cleanups (cleanups
);
3271 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
3272 non-zero compare only lbasename of FILES. */
3275 file_matches (const char *file
, char *files
[], int nfiles
, int basenames
)
3279 if (file
!= NULL
&& nfiles
!= 0)
3281 for (i
= 0; i
< nfiles
; i
++)
3283 if (compare_filenames_for_search (file
, (basenames
3284 ? lbasename (files
[i
])
3289 else if (nfiles
== 0)
3294 /* Free any memory associated with a search. */
3297 free_search_symbols (struct symbol_search
*symbols
)
3299 struct symbol_search
*p
;
3300 struct symbol_search
*next
;
3302 for (p
= symbols
; p
!= NULL
; p
= next
)
3310 do_free_search_symbols_cleanup (void *symbolsp
)
3312 struct symbol_search
*symbols
= *(struct symbol_search
**) symbolsp
;
3314 free_search_symbols (symbols
);
3318 make_cleanup_free_search_symbols (struct symbol_search
**symbolsp
)
3320 return make_cleanup (do_free_search_symbols_cleanup
, symbolsp
);
3323 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
3324 sort symbols, not minimal symbols. */
3327 compare_search_syms (const void *sa
, const void *sb
)
3329 struct symbol_search
*sym_a
= *(struct symbol_search
**) sa
;
3330 struct symbol_search
*sym_b
= *(struct symbol_search
**) sb
;
3333 c
= strcmp (sym_a
->symtab
->filename
, sym_b
->symtab
->filename
);
3337 if (sym_a
->block
!= sym_b
->block
)
3338 return sym_a
->block
- sym_b
->block
;
3340 return strcmp (SYMBOL_PRINT_NAME (sym_a
->symbol
),
3341 SYMBOL_PRINT_NAME (sym_b
->symbol
));
3344 /* Helper function for sort_search_symbols_remove_dups.
3345 Return TRUE if symbols A, B are equal. */
3348 search_symbols_equal (const struct symbol_search
*a
,
3349 const struct symbol_search
*b
)
3351 return (strcmp (a
->symtab
->filename
, b
->symtab
->filename
) == 0
3352 && a
->block
== b
->block
3353 && strcmp (SYMBOL_PRINT_NAME (a
->symbol
),
3354 SYMBOL_PRINT_NAME (b
->symbol
)) == 0);
3357 /* Sort the NFOUND symbols in list FOUND and remove duplicates.
3358 The duplicates are freed, and the new list is returned in
3359 *NEW_HEAD, *NEW_TAIL. */
3362 sort_search_symbols_remove_dups (struct symbol_search
*found
, int nfound
,
3363 struct symbol_search
**new_head
,
3364 struct symbol_search
**new_tail
)
3366 struct symbol_search
**symbols
, *symp
, *old_next
;
3369 gdb_assert (found
!= NULL
&& nfound
> 0);
3371 /* Build an array out of the list so we can easily sort them. */
3372 symbols
= (struct symbol_search
**) xmalloc (sizeof (struct symbol_search
*)
3375 for (i
= 0; i
< nfound
; i
++)
3377 gdb_assert (symp
!= NULL
);
3378 gdb_assert (symp
->block
>= 0 && symp
->block
<= 1);
3382 gdb_assert (symp
== NULL
);
3384 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
3385 compare_search_syms
);
3387 /* Collapse out the dups. */
3388 for (i
= 1, j
= 1; i
< nfound
; ++i
)
3390 if (! search_symbols_equal (symbols
[j
- 1], symbols
[i
]))
3391 symbols
[j
++] = symbols
[i
];
3396 symbols
[j
- 1]->next
= NULL
;
3398 /* Rebuild the linked list. */
3399 for (i
= 0; i
< nunique
- 1; i
++)
3400 symbols
[i
]->next
= symbols
[i
+ 1];
3401 symbols
[nunique
- 1]->next
= NULL
;
3403 *new_head
= symbols
[0];
3404 *new_tail
= symbols
[nunique
- 1];
3408 /* An object of this type is passed as the user_data to the
3409 expand_symtabs_matching method. */
3410 struct search_symbols_data
3415 /* It is true if PREG contains valid data, false otherwise. */
3416 unsigned preg_p
: 1;
3420 /* A callback for expand_symtabs_matching. */
3423 search_symbols_file_matches (const char *filename
, void *user_data
,
3426 struct search_symbols_data
*data
= user_data
;
3428 return file_matches (filename
, data
->files
, data
->nfiles
, basenames
);
3431 /* A callback for expand_symtabs_matching. */
3434 search_symbols_name_matches (const char *symname
, void *user_data
)
3436 struct search_symbols_data
*data
= user_data
;
3438 return !data
->preg_p
|| regexec (&data
->preg
, symname
, 0, NULL
, 0) == 0;
3441 /* Search the symbol table for matches to the regular expression REGEXP,
3442 returning the results in *MATCHES.
3444 Only symbols of KIND are searched:
3445 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
3446 and constants (enums)
3447 FUNCTIONS_DOMAIN - search all functions
3448 TYPES_DOMAIN - search all type names
3449 ALL_DOMAIN - an internal error for this function
3451 free_search_symbols should be called when *MATCHES is no longer needed.
3453 Within each file the results are sorted locally; each symtab's global and
3454 static blocks are separately alphabetized.
3455 Duplicate entries are removed. */
3458 search_symbols (char *regexp
, enum search_domain kind
,
3459 int nfiles
, char *files
[],
3460 struct symbol_search
**matches
)
3463 struct blockvector
*bv
;
3466 struct block_iterator iter
;
3468 struct objfile
*objfile
;
3469 struct minimal_symbol
*msymbol
;
3471 static const enum minimal_symbol_type types
[]
3472 = {mst_data
, mst_text
, mst_abs
};
3473 static const enum minimal_symbol_type types2
[]
3474 = {mst_bss
, mst_file_text
, mst_abs
};
3475 static const enum minimal_symbol_type types3
[]
3476 = {mst_file_data
, mst_solib_trampoline
, mst_abs
};
3477 static const enum minimal_symbol_type types4
[]
3478 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_abs
};
3479 enum minimal_symbol_type ourtype
;
3480 enum minimal_symbol_type ourtype2
;
3481 enum minimal_symbol_type ourtype3
;
3482 enum minimal_symbol_type ourtype4
;
3483 struct symbol_search
*found
;
3484 struct symbol_search
*tail
;
3485 struct search_symbols_data datum
;
3488 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
3489 CLEANUP_CHAIN is freed only in the case of an error. */
3490 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
3491 struct cleanup
*retval_chain
;
3493 gdb_assert (kind
<= TYPES_DOMAIN
);
3495 ourtype
= types
[kind
];
3496 ourtype2
= types2
[kind
];
3497 ourtype3
= types3
[kind
];
3498 ourtype4
= types4
[kind
];
3505 /* Make sure spacing is right for C++ operators.
3506 This is just a courtesy to make the matching less sensitive
3507 to how many spaces the user leaves between 'operator'
3508 and <TYPENAME> or <OPERATOR>. */
3510 char *opname
= operator_chars (regexp
, &opend
);
3515 int fix
= -1; /* -1 means ok; otherwise number of
3518 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
3520 /* There should 1 space between 'operator' and 'TYPENAME'. */
3521 if (opname
[-1] != ' ' || opname
[-2] == ' ')
3526 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
3527 if (opname
[-1] == ' ')
3530 /* If wrong number of spaces, fix it. */
3533 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
3535 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
3540 errcode
= regcomp (&datum
.preg
, regexp
,
3541 REG_NOSUB
| (case_sensitivity
== case_sensitive_off
3545 char *err
= get_regcomp_error (errcode
, &datum
.preg
);
3547 make_cleanup (xfree
, err
);
3548 error (_("Invalid regexp (%s): %s"), err
, regexp
);
3551 make_regfree_cleanup (&datum
.preg
);
3554 /* Search through the partial symtabs *first* for all symbols
3555 matching the regexp. That way we don't have to reproduce all of
3556 the machinery below. */
3558 datum
.nfiles
= nfiles
;
3559 datum
.files
= files
;
3560 ALL_OBJFILES (objfile
)
3563 objfile
->sf
->qf
->expand_symtabs_matching (objfile
,
3566 : search_symbols_file_matches
),
3567 search_symbols_name_matches
,
3572 /* Here, we search through the minimal symbol tables for functions
3573 and variables that match, and force their symbols to be read.
3574 This is in particular necessary for demangled variable names,
3575 which are no longer put into the partial symbol tables.
3576 The symbol will then be found during the scan of symtabs below.
3578 For functions, find_pc_symtab should succeed if we have debug info
3579 for the function, for variables we have to call
3580 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
3582 If the lookup fails, set found_misc so that we will rescan to print
3583 any matching symbols without debug info.
3584 We only search the objfile the msymbol came from, we no longer search
3585 all objfiles. In large programs (1000s of shared libs) searching all
3586 objfiles is not worth the pain. */
3588 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
3590 ALL_MSYMBOLS (objfile
, msymbol
)
3594 if (msymbol
->created_by_gdb
)
3597 if (MSYMBOL_TYPE (msymbol
) == ourtype
3598 || MSYMBOL_TYPE (msymbol
) == ourtype2
3599 || MSYMBOL_TYPE (msymbol
) == ourtype3
3600 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
3603 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (msymbol
), 0,
3606 /* Note: An important side-effect of these lookup functions
3607 is to expand the symbol table if msymbol is found, for the
3608 benefit of the next loop on ALL_PRIMARY_SYMTABS. */
3609 if (kind
== FUNCTIONS_DOMAIN
3610 ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)) == NULL
3611 : (lookup_symbol_in_objfile_from_linkage_name
3612 (objfile
, SYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
3623 retval_chain
= make_cleanup_free_search_symbols (&found
);
3625 ALL_PRIMARY_SYMTABS (objfile
, s
)
3627 bv
= BLOCKVECTOR (s
);
3628 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
3630 b
= BLOCKVECTOR_BLOCK (bv
, i
);
3631 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3633 struct symtab
*real_symtab
= SYMBOL_SYMTAB (sym
);
3637 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
3638 a substring of symtab_to_fullname as it may contain "./" etc. */
3639 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
3640 || ((basenames_may_differ
3641 || file_matches (lbasename (real_symtab
->filename
),
3643 && file_matches (symtab_to_fullname (real_symtab
),
3646 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (sym
), 0,
3648 && ((kind
== VARIABLES_DOMAIN
3649 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
3650 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
3651 && SYMBOL_CLASS (sym
) != LOC_BLOCK
3652 /* LOC_CONST can be used for more than just enums,
3653 e.g., c++ static const members.
3654 We only want to skip enums here. */
3655 && !(SYMBOL_CLASS (sym
) == LOC_CONST
3656 && TYPE_CODE (SYMBOL_TYPE (sym
))
3658 || (kind
== FUNCTIONS_DOMAIN
3659 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3660 || (kind
== TYPES_DOMAIN
3661 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
3664 struct symbol_search
*psr
= (struct symbol_search
*)
3665 xmalloc (sizeof (struct symbol_search
));
3667 psr
->symtab
= real_symtab
;
3669 psr
->msymbol
= NULL
;
3684 sort_search_symbols_remove_dups (found
, nfound
, &found
, &tail
);
3685 /* Note: nfound is no longer useful beyond this point. */
3688 /* If there are no eyes, avoid all contact. I mean, if there are
3689 no debug symbols, then print directly from the msymbol_vector. */
3691 if (found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
3693 ALL_MSYMBOLS (objfile
, msymbol
)
3697 if (msymbol
->created_by_gdb
)
3700 if (MSYMBOL_TYPE (msymbol
) == ourtype
3701 || MSYMBOL_TYPE (msymbol
) == ourtype2
3702 || MSYMBOL_TYPE (msymbol
) == ourtype3
3703 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
3706 || regexec (&datum
.preg
, SYMBOL_NATURAL_NAME (msymbol
), 0,
3709 /* For functions we can do a quick check of whether the
3710 symbol might be found via find_pc_symtab. */
3711 if (kind
!= FUNCTIONS_DOMAIN
3712 || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol
)) == NULL
)
3714 if (lookup_symbol_in_objfile_from_linkage_name
3715 (objfile
, SYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
3719 struct symbol_search
*psr
= (struct symbol_search
*)
3720 xmalloc (sizeof (struct symbol_search
));
3722 psr
->msymbol
= msymbol
;
3738 discard_cleanups (retval_chain
);
3739 do_cleanups (old_chain
);
3743 /* Helper function for symtab_symbol_info, this function uses
3744 the data returned from search_symbols() to print information
3745 regarding the match to gdb_stdout. */
3748 print_symbol_info (enum search_domain kind
,
3749 struct symtab
*s
, struct symbol
*sym
,
3750 int block
, const char *last
)
3752 const char *s_filename
= symtab_to_filename_for_display (s
);
3754 if (last
== NULL
|| filename_cmp (last
, s_filename
) != 0)
3756 fputs_filtered ("\nFile ", gdb_stdout
);
3757 fputs_filtered (s_filename
, gdb_stdout
);
3758 fputs_filtered (":\n", gdb_stdout
);
3761 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
3762 printf_filtered ("static ");
3764 /* Typedef that is not a C++ class. */
3765 if (kind
== TYPES_DOMAIN
3766 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
3767 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
3768 /* variable, func, or typedef-that-is-c++-class. */
3769 else if (kind
< TYPES_DOMAIN
3770 || (kind
== TYPES_DOMAIN
3771 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
3773 type_print (SYMBOL_TYPE (sym
),
3774 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3775 ? "" : SYMBOL_PRINT_NAME (sym
)),
3778 printf_filtered (";\n");
3782 /* This help function for symtab_symbol_info() prints information
3783 for non-debugging symbols to gdb_stdout. */
3786 print_msymbol_info (struct minimal_symbol
*msymbol
)
3788 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol_objfile (msymbol
));
3791 if (gdbarch_addr_bit (gdbarch
) <= 32)
3792 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
)
3793 & (CORE_ADDR
) 0xffffffff,
3796 tmp
= hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol
),
3798 printf_filtered ("%s %s\n",
3799 tmp
, SYMBOL_PRINT_NAME (msymbol
));
3802 /* This is the guts of the commands "info functions", "info types", and
3803 "info variables". It calls search_symbols to find all matches and then
3804 print_[m]symbol_info to print out some useful information about the
3808 symtab_symbol_info (char *regexp
, enum search_domain kind
, int from_tty
)
3810 static const char * const classnames
[] =
3811 {"variable", "function", "type"};
3812 struct symbol_search
*symbols
;
3813 struct symbol_search
*p
;
3814 struct cleanup
*old_chain
;
3815 const char *last_filename
= NULL
;
3818 gdb_assert (kind
<= TYPES_DOMAIN
);
3820 /* Must make sure that if we're interrupted, symbols gets freed. */
3821 search_symbols (regexp
, kind
, 0, (char **) NULL
, &symbols
);
3822 old_chain
= make_cleanup_free_search_symbols (&symbols
);
3825 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
3826 classnames
[kind
], regexp
);
3828 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
3830 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
3834 if (p
->msymbol
!= NULL
)
3838 printf_filtered (_("\nNon-debugging symbols:\n"));
3841 print_msymbol_info (p
->msymbol
);
3845 print_symbol_info (kind
,
3850 last_filename
= symtab_to_filename_for_display (p
->symtab
);
3854 do_cleanups (old_chain
);
3858 variables_info (char *regexp
, int from_tty
)
3860 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
3864 functions_info (char *regexp
, int from_tty
)
3866 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
3871 types_info (char *regexp
, int from_tty
)
3873 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
3876 /* Breakpoint all functions matching regular expression. */
3879 rbreak_command_wrapper (char *regexp
, int from_tty
)
3881 rbreak_command (regexp
, from_tty
);
3884 /* A cleanup function that calls end_rbreak_breakpoints. */
3887 do_end_rbreak_breakpoints (void *ignore
)
3889 end_rbreak_breakpoints ();
3893 rbreak_command (char *regexp
, int from_tty
)
3895 struct symbol_search
*ss
;
3896 struct symbol_search
*p
;
3897 struct cleanup
*old_chain
;
3898 char *string
= NULL
;
3900 char **files
= NULL
, *file_name
;
3905 char *colon
= strchr (regexp
, ':');
3907 if (colon
&& *(colon
+ 1) != ':')
3911 colon_index
= colon
- regexp
;
3912 file_name
= alloca (colon_index
+ 1);
3913 memcpy (file_name
, regexp
, colon_index
);
3914 file_name
[colon_index
--] = 0;
3915 while (isspace (file_name
[colon_index
]))
3916 file_name
[colon_index
--] = 0;
3919 regexp
= skip_spaces (colon
+ 1);
3923 search_symbols (regexp
, FUNCTIONS_DOMAIN
, nfiles
, files
, &ss
);
3924 old_chain
= make_cleanup_free_search_symbols (&ss
);
3925 make_cleanup (free_current_contents
, &string
);
3927 start_rbreak_breakpoints ();
3928 make_cleanup (do_end_rbreak_breakpoints
, NULL
);
3929 for (p
= ss
; p
!= NULL
; p
= p
->next
)
3931 if (p
->msymbol
== NULL
)
3933 const char *fullname
= symtab_to_fullname (p
->symtab
);
3935 int newlen
= (strlen (fullname
)
3936 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
3941 string
= xrealloc (string
, newlen
);
3944 strcpy (string
, fullname
);
3945 strcat (string
, ":'");
3946 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
3947 strcat (string
, "'");
3948 break_command (string
, from_tty
);
3949 print_symbol_info (FUNCTIONS_DOMAIN
,
3953 symtab_to_filename_for_display (p
->symtab
));
3957 int newlen
= (strlen (SYMBOL_LINKAGE_NAME (p
->msymbol
)) + 3);
3961 string
= xrealloc (string
, newlen
);
3964 strcpy (string
, "'");
3965 strcat (string
, SYMBOL_LINKAGE_NAME (p
->msymbol
));
3966 strcat (string
, "'");
3968 break_command (string
, from_tty
);
3969 printf_filtered ("<function, no debug info> %s;\n",
3970 SYMBOL_PRINT_NAME (p
->msymbol
));
3974 do_cleanups (old_chain
);
3978 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
3980 Either sym_text[sym_text_len] != '(' and then we search for any
3981 symbol starting with SYM_TEXT text.
3983 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
3984 be terminated at that point. Partial symbol tables do not have parameters
3988 compare_symbol_name (const char *name
, const char *sym_text
, int sym_text_len
)
3990 int (*ncmp
) (const char *, const char *, size_t);
3992 ncmp
= (case_sensitivity
== case_sensitive_on
? strncmp
: strncasecmp
);
3994 if (ncmp (name
, sym_text
, sym_text_len
) != 0)
3997 if (sym_text
[sym_text_len
] == '(')
3999 /* User searches for `name(someth...'. Require NAME to be terminated.
4000 Normally psymtabs and gdbindex have no parameter types so '\0' will be
4001 present but accept even parameters presence. In this case this
4002 function is in fact strcmp_iw but whitespace skipping is not supported
4003 for tab completion. */
4005 if (name
[sym_text_len
] != '\0' && name
[sym_text_len
] != '(')
4012 /* Free any memory associated with a completion list. */
4015 free_completion_list (VEC (char_ptr
) **list_ptr
)
4020 for (i
= 0; VEC_iterate (char_ptr
, *list_ptr
, i
, p
); ++i
)
4022 VEC_free (char_ptr
, *list_ptr
);
4025 /* Callback for make_cleanup. */
4028 do_free_completion_list (void *list
)
4030 free_completion_list (list
);
4033 /* Helper routine for make_symbol_completion_list. */
4035 static VEC (char_ptr
) *return_val
;
4037 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
4038 completion_list_add_name \
4039 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
4041 /* Test to see if the symbol specified by SYMNAME (which is already
4042 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4043 characters. If so, add it to the current completion list. */
4046 completion_list_add_name (const char *symname
,
4047 const char *sym_text
, int sym_text_len
,
4048 const char *text
, const char *word
)
4050 /* Clip symbols that cannot match. */
4051 if (!compare_symbol_name (symname
, sym_text
, sym_text_len
))
4054 /* We have a match for a completion, so add SYMNAME to the current list
4055 of matches. Note that the name is moved to freshly malloc'd space. */
4060 if (word
== sym_text
)
4062 new = xmalloc (strlen (symname
) + 5);
4063 strcpy (new, symname
);
4065 else if (word
> sym_text
)
4067 /* Return some portion of symname. */
4068 new = xmalloc (strlen (symname
) + 5);
4069 strcpy (new, symname
+ (word
- sym_text
));
4073 /* Return some of SYM_TEXT plus symname. */
4074 new = xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
4075 strncpy (new, word
, sym_text
- word
);
4076 new[sym_text
- word
] = '\0';
4077 strcat (new, symname
);
4080 VEC_safe_push (char_ptr
, return_val
, new);
4084 /* ObjC: In case we are completing on a selector, look as the msymbol
4085 again and feed all the selectors into the mill. */
4088 completion_list_objc_symbol (struct minimal_symbol
*msymbol
,
4089 const char *sym_text
, int sym_text_len
,
4090 const char *text
, const char *word
)
4092 static char *tmp
= NULL
;
4093 static unsigned int tmplen
= 0;
4095 const char *method
, *category
, *selector
;
4098 method
= SYMBOL_NATURAL_NAME (msymbol
);
4100 /* Is it a method? */
4101 if ((method
[0] != '-') && (method
[0] != '+'))
4104 if (sym_text
[0] == '[')
4105 /* Complete on shortened method method. */
4106 completion_list_add_name (method
+ 1, sym_text
, sym_text_len
, text
, word
);
4108 while ((strlen (method
) + 1) >= tmplen
)
4114 tmp
= xrealloc (tmp
, tmplen
);
4116 selector
= strchr (method
, ' ');
4117 if (selector
!= NULL
)
4120 category
= strchr (method
, '(');
4122 if ((category
!= NULL
) && (selector
!= NULL
))
4124 memcpy (tmp
, method
, (category
- method
));
4125 tmp
[category
- method
] = ' ';
4126 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
4127 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
4128 if (sym_text
[0] == '[')
4129 completion_list_add_name (tmp
+ 1, sym_text
, sym_text_len
, text
, word
);
4132 if (selector
!= NULL
)
4134 /* Complete on selector only. */
4135 strcpy (tmp
, selector
);
4136 tmp2
= strchr (tmp
, ']');
4140 completion_list_add_name (tmp
, sym_text
, sym_text_len
, text
, word
);
4144 /* Break the non-quoted text based on the characters which are in
4145 symbols. FIXME: This should probably be language-specific. */
4148 language_search_unquoted_string (const char *text
, const char *p
)
4150 for (; p
> text
; --p
)
4152 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
4156 if ((current_language
->la_language
== language_objc
))
4158 if (p
[-1] == ':') /* Might be part of a method name. */
4160 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
4161 p
-= 2; /* Beginning of a method name. */
4162 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
4163 { /* Might be part of a method name. */
4166 /* Seeing a ' ' or a '(' is not conclusive evidence
4167 that we are in the middle of a method name. However,
4168 finding "-[" or "+[" should be pretty un-ambiguous.
4169 Unfortunately we have to find it now to decide. */
4172 if (isalnum (t
[-1]) || t
[-1] == '_' ||
4173 t
[-1] == ' ' || t
[-1] == ':' ||
4174 t
[-1] == '(' || t
[-1] == ')')
4179 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
4180 p
= t
- 2; /* Method name detected. */
4181 /* Else we leave with p unchanged. */
4191 completion_list_add_fields (struct symbol
*sym
, const char *sym_text
,
4192 int sym_text_len
, const char *text
,
4195 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
4197 struct type
*t
= SYMBOL_TYPE (sym
);
4198 enum type_code c
= TYPE_CODE (t
);
4201 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
4202 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
4203 if (TYPE_FIELD_NAME (t
, j
))
4204 completion_list_add_name (TYPE_FIELD_NAME (t
, j
),
4205 sym_text
, sym_text_len
, text
, word
);
4209 /* Type of the user_data argument passed to add_macro_name or
4210 expand_partial_symbol_name. The contents are simply whatever is
4211 needed by completion_list_add_name. */
4212 struct add_name_data
4214 const char *sym_text
;
4220 /* A callback used with macro_for_each and macro_for_each_in_scope.
4221 This adds a macro's name to the current completion list. */
4224 add_macro_name (const char *name
, const struct macro_definition
*ignore
,
4225 struct macro_source_file
*ignore2
, int ignore3
,
4228 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
4230 completion_list_add_name ((char *) name
,
4231 datum
->sym_text
, datum
->sym_text_len
,
4232 datum
->text
, datum
->word
);
4235 /* A callback for expand_partial_symbol_names. */
4238 expand_partial_symbol_name (const char *name
, void *user_data
)
4240 struct add_name_data
*datum
= (struct add_name_data
*) user_data
;
4242 return compare_symbol_name (name
, datum
->sym_text
, datum
->sym_text_len
);
4246 default_make_symbol_completion_list_break_on (const char *text
,
4248 const char *break_on
,
4249 enum type_code code
)
4251 /* Problem: All of the symbols have to be copied because readline
4252 frees them. I'm not going to worry about this; hopefully there
4253 won't be that many. */
4257 struct minimal_symbol
*msymbol
;
4258 struct objfile
*objfile
;
4260 const struct block
*surrounding_static_block
, *surrounding_global_block
;
4261 struct block_iterator iter
;
4262 /* The symbol we are completing on. Points in same buffer as text. */
4263 const char *sym_text
;
4264 /* Length of sym_text. */
4266 struct add_name_data datum
;
4267 struct cleanup
*back_to
;
4269 /* Now look for the symbol we are supposed to complete on. */
4273 const char *quote_pos
= NULL
;
4275 /* First see if this is a quoted string. */
4277 for (p
= text
; *p
!= '\0'; ++p
)
4279 if (quote_found
!= '\0')
4281 if (*p
== quote_found
)
4282 /* Found close quote. */
4284 else if (*p
== '\\' && p
[1] == quote_found
)
4285 /* A backslash followed by the quote character
4286 doesn't end the string. */
4289 else if (*p
== '\'' || *p
== '"')
4295 if (quote_found
== '\'')
4296 /* A string within single quotes can be a symbol, so complete on it. */
4297 sym_text
= quote_pos
+ 1;
4298 else if (quote_found
== '"')
4299 /* A double-quoted string is never a symbol, nor does it make sense
4300 to complete it any other way. */
4306 /* It is not a quoted string. Break it based on the characters
4307 which are in symbols. */
4310 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
4311 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
4320 sym_text_len
= strlen (sym_text
);
4322 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
4324 if (current_language
->la_language
== language_cplus
4325 || current_language
->la_language
== language_java
4326 || current_language
->la_language
== language_fortran
)
4328 /* These languages may have parameters entered by user but they are never
4329 present in the partial symbol tables. */
4331 const char *cs
= memchr (sym_text
, '(', sym_text_len
);
4334 sym_text_len
= cs
- sym_text
;
4336 gdb_assert (sym_text
[sym_text_len
] == '\0' || sym_text
[sym_text_len
] == '(');
4339 back_to
= make_cleanup (do_free_completion_list
, &return_val
);
4341 datum
.sym_text
= sym_text
;
4342 datum
.sym_text_len
= sym_text_len
;
4346 /* Look through the partial symtabs for all symbols which begin
4347 by matching SYM_TEXT. Expand all CUs that you find to the list.
4348 The real names will get added by COMPLETION_LIST_ADD_SYMBOL below. */
4349 expand_partial_symbol_names (expand_partial_symbol_name
, &datum
);
4351 /* At this point scan through the misc symbol vectors and add each
4352 symbol you find to the list. Eventually we want to ignore
4353 anything that isn't a text symbol (everything else will be
4354 handled by the psymtab code above). */
4356 if (code
== TYPE_CODE_UNDEF
)
4358 ALL_MSYMBOLS (objfile
, msymbol
)
4361 COMPLETION_LIST_ADD_SYMBOL (msymbol
, sym_text
, sym_text_len
, text
,
4364 completion_list_objc_symbol (msymbol
, sym_text
, sym_text_len
, text
,
4369 /* Search upwards from currently selected frame (so that we can
4370 complete on local vars). Also catch fields of types defined in
4371 this places which match our text string. Only complete on types
4372 visible from current context. */
4374 b
= get_selected_block (0);
4375 surrounding_static_block
= block_static_block (b
);
4376 surrounding_global_block
= block_global_block (b
);
4377 if (surrounding_static_block
!= NULL
)
4378 while (b
!= surrounding_static_block
)
4382 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4384 if (code
== TYPE_CODE_UNDEF
)
4386 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4388 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
,
4391 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4392 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
4393 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
,
4397 /* Stop when we encounter an enclosing function. Do not stop for
4398 non-inlined functions - the locals of the enclosing function
4399 are in scope for a nested function. */
4400 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
4402 b
= BLOCK_SUPERBLOCK (b
);
4405 /* Add fields from the file's types; symbols will be added below. */
4407 if (code
== TYPE_CODE_UNDEF
)
4409 if (surrounding_static_block
!= NULL
)
4410 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
4411 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4413 if (surrounding_global_block
!= NULL
)
4414 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
4415 completion_list_add_fields (sym
, sym_text
, sym_text_len
, text
, word
);
4418 /* Go through the symtabs and check the externs and statics for
4419 symbols which match. */
4421 ALL_PRIMARY_SYMTABS (objfile
, s
)
4424 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4425 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4427 if (code
== TYPE_CODE_UNDEF
4428 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4429 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4430 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4434 ALL_PRIMARY_SYMTABS (objfile
, s
)
4437 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4438 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4440 if (code
== TYPE_CODE_UNDEF
4441 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4442 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4443 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4447 /* Skip macros if we are completing a struct tag -- arguable but
4448 usually what is expected. */
4449 if (current_language
->la_macro_expansion
== macro_expansion_c
4450 && code
== TYPE_CODE_UNDEF
)
4452 struct macro_scope
*scope
;
4454 /* Add any macros visible in the default scope. Note that this
4455 may yield the occasional wrong result, because an expression
4456 might be evaluated in a scope other than the default. For
4457 example, if the user types "break file:line if <TAB>", the
4458 resulting expression will be evaluated at "file:line" -- but
4459 at there does not seem to be a way to detect this at
4461 scope
= default_macro_scope ();
4464 macro_for_each_in_scope (scope
->file
, scope
->line
,
4465 add_macro_name
, &datum
);
4469 /* User-defined macros are always visible. */
4470 macro_for_each (macro_user_macros
, add_macro_name
, &datum
);
4473 discard_cleanups (back_to
);
4474 return (return_val
);
4478 default_make_symbol_completion_list (const char *text
, const char *word
,
4479 enum type_code code
)
4481 return default_make_symbol_completion_list_break_on (text
, word
, "", code
);
4484 /* Return a vector of all symbols (regardless of class) which begin by
4485 matching TEXT. If the answer is no symbols, then the return value
4489 make_symbol_completion_list (const char *text
, const char *word
)
4491 return current_language
->la_make_symbol_completion_list (text
, word
,
4495 /* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
4496 symbols whose type code is CODE. */
4499 make_symbol_completion_type (const char *text
, const char *word
,
4500 enum type_code code
)
4502 gdb_assert (code
== TYPE_CODE_UNION
4503 || code
== TYPE_CODE_STRUCT
4504 || code
== TYPE_CODE_CLASS
4505 || code
== TYPE_CODE_ENUM
);
4506 return current_language
->la_make_symbol_completion_list (text
, word
, code
);
4509 /* Like make_symbol_completion_list, but suitable for use as a
4510 completion function. */
4513 make_symbol_completion_list_fn (struct cmd_list_element
*ignore
,
4514 const char *text
, const char *word
)
4516 return make_symbol_completion_list (text
, word
);
4519 /* Like make_symbol_completion_list, but returns a list of symbols
4520 defined in a source file FILE. */
4523 make_file_symbol_completion_list (const char *text
, const char *word
,
4524 const char *srcfile
)
4529 struct block_iterator iter
;
4530 /* The symbol we are completing on. Points in same buffer as text. */
4531 const char *sym_text
;
4532 /* Length of sym_text. */
4535 /* Now look for the symbol we are supposed to complete on.
4536 FIXME: This should be language-specific. */
4540 const char *quote_pos
= NULL
;
4542 /* First see if this is a quoted string. */
4544 for (p
= text
; *p
!= '\0'; ++p
)
4546 if (quote_found
!= '\0')
4548 if (*p
== quote_found
)
4549 /* Found close quote. */
4551 else if (*p
== '\\' && p
[1] == quote_found
)
4552 /* A backslash followed by the quote character
4553 doesn't end the string. */
4556 else if (*p
== '\'' || *p
== '"')
4562 if (quote_found
== '\'')
4563 /* A string within single quotes can be a symbol, so complete on it. */
4564 sym_text
= quote_pos
+ 1;
4565 else if (quote_found
== '"')
4566 /* A double-quoted string is never a symbol, nor does it make sense
4567 to complete it any other way. */
4573 /* Not a quoted string. */
4574 sym_text
= language_search_unquoted_string (text
, p
);
4578 sym_text_len
= strlen (sym_text
);
4582 /* Find the symtab for SRCFILE (this loads it if it was not yet read
4584 s
= lookup_symtab (srcfile
);
4587 /* Maybe they typed the file with leading directories, while the
4588 symbol tables record only its basename. */
4589 const char *tail
= lbasename (srcfile
);
4592 s
= lookup_symtab (tail
);
4595 /* If we have no symtab for that file, return an empty list. */
4597 return (return_val
);
4599 /* Go through this symtab and check the externs and statics for
4600 symbols which match. */
4602 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
4603 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4605 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4608 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
4609 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4611 COMPLETION_LIST_ADD_SYMBOL (sym
, sym_text
, sym_text_len
, text
, word
);
4614 return (return_val
);
4617 /* A helper function for make_source_files_completion_list. It adds
4618 another file name to a list of possible completions, growing the
4619 list as necessary. */
4622 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
4623 VEC (char_ptr
) **list
)
4626 size_t fnlen
= strlen (fname
);
4630 /* Return exactly fname. */
4631 new = xmalloc (fnlen
+ 5);
4632 strcpy (new, fname
);
4634 else if (word
> text
)
4636 /* Return some portion of fname. */
4637 new = xmalloc (fnlen
+ 5);
4638 strcpy (new, fname
+ (word
- text
));
4642 /* Return some of TEXT plus fname. */
4643 new = xmalloc (fnlen
+ (text
- word
) + 5);
4644 strncpy (new, word
, text
- word
);
4645 new[text
- word
] = '\0';
4646 strcat (new, fname
);
4648 VEC_safe_push (char_ptr
, *list
, new);
4652 not_interesting_fname (const char *fname
)
4654 static const char *illegal_aliens
[] = {
4655 "_globals_", /* inserted by coff_symtab_read */
4660 for (i
= 0; illegal_aliens
[i
]; i
++)
4662 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
4668 /* An object of this type is passed as the user_data argument to
4669 map_partial_symbol_filenames. */
4670 struct add_partial_filename_data
4672 struct filename_seen_cache
*filename_seen_cache
;
4676 VEC (char_ptr
) **list
;
4679 /* A callback for map_partial_symbol_filenames. */
4682 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
4685 struct add_partial_filename_data
*data
= user_data
;
4687 if (not_interesting_fname (filename
))
4689 if (!filename_seen (data
->filename_seen_cache
, filename
, 1)
4690 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
4692 /* This file matches for a completion; add it to the
4693 current list of matches. */
4694 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
4698 const char *base_name
= lbasename (filename
);
4700 if (base_name
!= filename
4701 && !filename_seen (data
->filename_seen_cache
, base_name
, 1)
4702 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
4703 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
4707 /* Return a vector of all source files whose names begin with matching
4708 TEXT. The file names are looked up in the symbol tables of this
4709 program. If the answer is no matchess, then the return value is
4713 make_source_files_completion_list (const char *text
, const char *word
)
4716 struct objfile
*objfile
;
4717 size_t text_len
= strlen (text
);
4718 VEC (char_ptr
) *list
= NULL
;
4719 const char *base_name
;
4720 struct add_partial_filename_data datum
;
4721 struct filename_seen_cache
*filename_seen_cache
;
4722 struct cleanup
*back_to
, *cache_cleanup
;
4724 if (!have_full_symbols () && !have_partial_symbols ())
4727 back_to
= make_cleanup (do_free_completion_list
, &list
);
4729 filename_seen_cache
= create_filename_seen_cache ();
4730 cache_cleanup
= make_cleanup (delete_filename_seen_cache
,
4731 filename_seen_cache
);
4733 ALL_SYMTABS (objfile
, s
)
4735 if (not_interesting_fname (s
->filename
))
4737 if (!filename_seen (filename_seen_cache
, s
->filename
, 1)
4738 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
4740 /* This file matches for a completion; add it to the current
4742 add_filename_to_list (s
->filename
, text
, word
, &list
);
4746 /* NOTE: We allow the user to type a base name when the
4747 debug info records leading directories, but not the other
4748 way around. This is what subroutines of breakpoint
4749 command do when they parse file names. */
4750 base_name
= lbasename (s
->filename
);
4751 if (base_name
!= s
->filename
4752 && !filename_seen (filename_seen_cache
, base_name
, 1)
4753 && filename_ncmp (base_name
, text
, text_len
) == 0)
4754 add_filename_to_list (base_name
, text
, word
, &list
);
4758 datum
.filename_seen_cache
= filename_seen_cache
;
4761 datum
.text_len
= text_len
;
4763 map_partial_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
4764 0 /*need_fullname*/);
4766 do_cleanups (cache_cleanup
);
4767 discard_cleanups (back_to
);
4772 /* Determine if PC is in the prologue of a function. The prologue is the area
4773 between the first instruction of a function, and the first executable line.
4774 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
4776 If non-zero, func_start is where we think the prologue starts, possibly
4777 by previous examination of symbol table information. */
4780 in_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR func_start
)
4782 struct symtab_and_line sal
;
4783 CORE_ADDR func_addr
, func_end
;
4785 /* We have several sources of information we can consult to figure
4787 - Compilers usually emit line number info that marks the prologue
4788 as its own "source line". So the ending address of that "line"
4789 is the end of the prologue. If available, this is the most
4791 - The minimal symbols and partial symbols, which can usually tell
4792 us the starting and ending addresses of a function.
4793 - If we know the function's start address, we can call the
4794 architecture-defined gdbarch_skip_prologue function to analyze the
4795 instruction stream and guess where the prologue ends.
4796 - Our `func_start' argument; if non-zero, this is the caller's
4797 best guess as to the function's entry point. At the time of
4798 this writing, handle_inferior_event doesn't get this right, so
4799 it should be our last resort. */
4801 /* Consult the partial symbol table, to find which function
4803 if (! find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
4805 CORE_ADDR prologue_end
;
4807 /* We don't even have minsym information, so fall back to using
4808 func_start, if given. */
4810 return 1; /* We *might* be in a prologue. */
4812 prologue_end
= gdbarch_skip_prologue (gdbarch
, func_start
);
4814 return func_start
<= pc
&& pc
< prologue_end
;
4817 /* If we have line number information for the function, that's
4818 usually pretty reliable. */
4819 sal
= find_pc_line (func_addr
, 0);
4821 /* Now sal describes the source line at the function's entry point,
4822 which (by convention) is the prologue. The end of that "line",
4823 sal.end, is the end of the prologue.
4825 Note that, for functions whose source code is all on a single
4826 line, the line number information doesn't always end up this way.
4827 So we must verify that our purported end-of-prologue address is
4828 *within* the function, not at its start or end. */
4830 || sal
.end
<= func_addr
4831 || func_end
<= sal
.end
)
4833 /* We don't have any good line number info, so use the minsym
4834 information, together with the architecture-specific prologue
4836 CORE_ADDR prologue_end
= gdbarch_skip_prologue (gdbarch
, func_addr
);
4838 return func_addr
<= pc
&& pc
< prologue_end
;
4841 /* We have line number info, and it looks good. */
4842 return func_addr
<= pc
&& pc
< sal
.end
;
4845 /* Given PC at the function's start address, attempt to find the
4846 prologue end using SAL information. Return zero if the skip fails.
4848 A non-optimized prologue traditionally has one SAL for the function
4849 and a second for the function body. A single line function has
4850 them both pointing at the same line.
4852 An optimized prologue is similar but the prologue may contain
4853 instructions (SALs) from the instruction body. Need to skip those
4854 while not getting into the function body.
4856 The functions end point and an increasing SAL line are used as
4857 indicators of the prologue's endpoint.
4859 This code is based on the function refine_prologue_limit
4863 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
4865 struct symtab_and_line prologue_sal
;
4870 /* Get an initial range for the function. */
4871 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
4872 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
4874 prologue_sal
= find_pc_line (start_pc
, 0);
4875 if (prologue_sal
.line
!= 0)
4877 /* For languages other than assembly, treat two consecutive line
4878 entries at the same address as a zero-instruction prologue.
4879 The GNU assembler emits separate line notes for each instruction
4880 in a multi-instruction macro, but compilers generally will not
4882 if (prologue_sal
.symtab
->language
!= language_asm
)
4884 struct linetable
*linetable
= LINETABLE (prologue_sal
.symtab
);
4887 /* Skip any earlier lines, and any end-of-sequence marker
4888 from a previous function. */
4889 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
4890 || linetable
->item
[idx
].line
== 0)
4893 if (idx
+1 < linetable
->nitems
4894 && linetable
->item
[idx
+1].line
!= 0
4895 && linetable
->item
[idx
+1].pc
== start_pc
)
4899 /* If there is only one sal that covers the entire function,
4900 then it is probably a single line function, like
4902 if (prologue_sal
.end
>= end_pc
)
4905 while (prologue_sal
.end
< end_pc
)
4907 struct symtab_and_line sal
;
4909 sal
= find_pc_line (prologue_sal
.end
, 0);
4912 /* Assume that a consecutive SAL for the same (or larger)
4913 line mark the prologue -> body transition. */
4914 if (sal
.line
>= prologue_sal
.line
)
4916 /* Likewise if we are in a different symtab altogether
4917 (e.g. within a file included via #include). */
4918 if (sal
.symtab
!= prologue_sal
.symtab
)
4921 /* The line number is smaller. Check that it's from the
4922 same function, not something inlined. If it's inlined,
4923 then there is no point comparing the line numbers. */
4924 bl
= block_for_pc (prologue_sal
.end
);
4927 if (block_inlined_p (bl
))
4929 if (BLOCK_FUNCTION (bl
))
4934 bl
= BLOCK_SUPERBLOCK (bl
);
4939 /* The case in which compiler's optimizer/scheduler has
4940 moved instructions into the prologue. We look ahead in
4941 the function looking for address ranges whose
4942 corresponding line number is less the first one that we
4943 found for the function. This is more conservative then
4944 refine_prologue_limit which scans a large number of SALs
4945 looking for any in the prologue. */
4950 if (prologue_sal
.end
< end_pc
)
4951 /* Return the end of this line, or zero if we could not find a
4953 return prologue_sal
.end
;
4955 /* Don't return END_PC, which is past the end of the function. */
4956 return prologue_sal
.pc
;
4960 static char *name_of_main
;
4961 enum language language_of_main
= language_unknown
;
4964 set_main_name (const char *name
)
4966 if (name_of_main
!= NULL
)
4968 xfree (name_of_main
);
4969 name_of_main
= NULL
;
4970 language_of_main
= language_unknown
;
4974 name_of_main
= xstrdup (name
);
4975 language_of_main
= language_unknown
;
4979 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
4983 find_main_name (void)
4985 const char *new_main_name
;
4987 /* Try to see if the main procedure is in Ada. */
4988 /* FIXME: brobecker/2005-03-07: Another way of doing this would
4989 be to add a new method in the language vector, and call this
4990 method for each language until one of them returns a non-empty
4991 name. This would allow us to remove this hard-coded call to
4992 an Ada function. It is not clear that this is a better approach
4993 at this point, because all methods need to be written in a way
4994 such that false positives never be returned. For instance, it is
4995 important that a method does not return a wrong name for the main
4996 procedure if the main procedure is actually written in a different
4997 language. It is easy to guaranty this with Ada, since we use a
4998 special symbol generated only when the main in Ada to find the name
4999 of the main procedure. It is difficult however to see how this can
5000 be guarantied for languages such as C, for instance. This suggests
5001 that order of call for these methods becomes important, which means
5002 a more complicated approach. */
5003 new_main_name
= ada_main_name ();
5004 if (new_main_name
!= NULL
)
5006 set_main_name (new_main_name
);
5010 new_main_name
= go_main_name ();
5011 if (new_main_name
!= NULL
)
5013 set_main_name (new_main_name
);
5017 new_main_name
= pascal_main_name ();
5018 if (new_main_name
!= NULL
)
5020 set_main_name (new_main_name
);
5024 /* The languages above didn't identify the name of the main procedure.
5025 Fallback to "main". */
5026 set_main_name ("main");
5032 if (name_of_main
== NULL
)
5035 return name_of_main
;
5038 /* Handle ``executable_changed'' events for the symtab module. */
5041 symtab_observer_executable_changed (void)
5043 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5044 set_main_name (NULL
);
5047 /* Return 1 if the supplied producer string matches the ARM RealView
5048 compiler (armcc). */
5051 producer_is_realview (const char *producer
)
5053 static const char *const arm_idents
[] = {
5054 "ARM C Compiler, ADS",
5055 "Thumb C Compiler, ADS",
5056 "ARM C++ Compiler, ADS",
5057 "Thumb C++ Compiler, ADS",
5058 "ARM/Thumb C/C++ Compiler, RVCT",
5059 "ARM C/C++ Compiler, RVCT"
5063 if (producer
== NULL
)
5066 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
5067 if (strncmp (producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
5075 /* The next index to hand out in response to a registration request. */
5077 static int next_aclass_value
= LOC_FINAL_VALUE
;
5079 /* The maximum number of "aclass" registrations we support. This is
5080 constant for convenience. */
5081 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5083 /* The objects representing the various "aclass" values. The elements
5084 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5085 elements are those registered at gdb initialization time. */
5087 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
5089 /* The globally visible pointer. This is separate from 'symbol_impl'
5090 so that it can be const. */
5092 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
5094 /* Make sure we saved enough room in struct symbol. */
5096 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
5098 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5099 is the ops vector associated with this index. This returns the new
5100 index, which should be used as the aclass_index field for symbols
5104 register_symbol_computed_impl (enum address_class aclass
,
5105 const struct symbol_computed_ops
*ops
)
5107 int result
= next_aclass_value
++;
5109 gdb_assert (aclass
== LOC_COMPUTED
);
5110 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5111 symbol_impl
[result
].aclass
= aclass
;
5112 symbol_impl
[result
].ops_computed
= ops
;
5114 /* Sanity check OPS. */
5115 gdb_assert (ops
!= NULL
);
5116 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
5117 gdb_assert (ops
->describe_location
!= NULL
);
5118 gdb_assert (ops
->read_needs_frame
!= NULL
);
5119 gdb_assert (ops
->read_variable
!= NULL
);
5124 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5125 OPS is the ops vector associated with this index. This returns the
5126 new index, which should be used as the aclass_index field for symbols
5130 register_symbol_block_impl (enum address_class aclass
,
5131 const struct symbol_block_ops
*ops
)
5133 int result
= next_aclass_value
++;
5135 gdb_assert (aclass
== LOC_BLOCK
);
5136 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5137 symbol_impl
[result
].aclass
= aclass
;
5138 symbol_impl
[result
].ops_block
= ops
;
5140 /* Sanity check OPS. */
5141 gdb_assert (ops
!= NULL
);
5142 gdb_assert (ops
->find_frame_base_location
!= NULL
);
5147 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5148 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5149 this index. This returns the new index, which should be used as
5150 the aclass_index field for symbols of this type. */
5153 register_symbol_register_impl (enum address_class aclass
,
5154 const struct symbol_register_ops
*ops
)
5156 int result
= next_aclass_value
++;
5158 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
5159 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5160 symbol_impl
[result
].aclass
= aclass
;
5161 symbol_impl
[result
].ops_register
= ops
;
5166 /* Initialize elements of 'symbol_impl' for the constants in enum
5170 initialize_ordinary_address_classes (void)
5174 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
5175 symbol_impl
[i
].aclass
= i
;
5180 /* Initialize the symbol SYM. */
5183 initialize_symbol (struct symbol
*sym
)
5185 memset (sym
, 0, sizeof (*sym
));
5186 SYMBOL_SECTION (sym
) = -1;
5189 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5193 allocate_symbol (struct objfile
*objfile
)
5195 struct symbol
*result
;
5197 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
5198 SYMBOL_SECTION (result
) = -1;
5203 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5206 struct template_symbol
*
5207 allocate_template_symbol (struct objfile
*objfile
)
5209 struct template_symbol
*result
;
5211 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
5212 SYMBOL_SECTION (&result
->base
) = -1;
5220 _initialize_symtab (void)
5222 initialize_ordinary_address_classes ();
5224 add_info ("variables", variables_info
, _("\
5225 All global and static variable names, or those matching REGEXP."));
5227 add_com ("whereis", class_info
, variables_info
, _("\
5228 All global and static variable names, or those matching REGEXP."));
5230 add_info ("functions", functions_info
,
5231 _("All function names, or those matching REGEXP."));
5233 /* FIXME: This command has at least the following problems:
5234 1. It prints builtin types (in a very strange and confusing fashion).
5235 2. It doesn't print right, e.g. with
5236 typedef struct foo *FOO
5237 type_print prints "FOO" when we want to make it (in this situation)
5238 print "struct foo *".
5239 I also think "ptype" or "whatis" is more likely to be useful (but if
5240 there is much disagreement "info types" can be fixed). */
5241 add_info ("types", types_info
,
5242 _("All type names, or those matching REGEXP."));
5244 add_info ("sources", sources_info
,
5245 _("Source files in the program."));
5247 add_com ("rbreak", class_breakpoint
, rbreak_command
,
5248 _("Set a breakpoint for all functions matching REGEXP."));
5252 add_com ("lf", class_info
, sources_info
,
5253 _("Source files in the program"));
5254 add_com ("lg", class_info
, variables_info
, _("\
5255 All global and static variable names, or those matching REGEXP."));
5258 add_setshow_enum_cmd ("multiple-symbols", no_class
,
5259 multiple_symbols_modes
, &multiple_symbols_mode
,
5261 Set the debugger behavior when more than one symbol are possible matches\n\
5262 in an expression."), _("\
5263 Show how the debugger handles ambiguities in expressions."), _("\
5264 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5265 NULL
, NULL
, &setlist
, &showlist
);
5267 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
5268 &basenames_may_differ
, _("\
5269 Set whether a source file may have multiple base names."), _("\
5270 Show whether a source file may have multiple base names."), _("\
5271 (A \"base name\" is the name of a file with the directory part removed.\n\
5272 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5273 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5274 before comparing them. Canonicalization is an expensive operation,\n\
5275 but it allows the same file be known by more than one base name.\n\
5276 If not set (the default), all source files are assumed to have just\n\
5277 one base name, and gdb will do file name comparisons more efficiently."),
5279 &setlist
, &showlist
);
5281 add_setshow_boolean_cmd ("symtab-create", no_class
, &symtab_create_debug
,
5282 _("Set debugging of symbol table creation."),
5283 _("Show debugging of symbol table creation."), _("\
5284 When enabled, debugging messages are printed when building symbol tables."),
5287 &setdebuglist
, &showdebuglist
);
5289 observer_attach_executable_changed (symtab_observer_executable_changed
);