1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2017 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>
56 #include "cp-support.h"
60 #include "macroscope.h"
62 #include "parser-defs.h"
63 #include "completer.h"
64 #include "progspace-and-thread.h"
65 #include "common/gdb_optional.h"
66 #include "filename-seen-cache.h"
67 #include "arch-utils.h"
69 /* Forward declarations for local functions. */
71 static void rbreak_command (char *, int);
73 static int find_line_common (struct linetable
*, int, int *, int);
75 static struct block_symbol
76 lookup_symbol_aux (const char *name
,
77 const struct block
*block
,
78 const domain_enum domain
,
79 enum language language
,
80 struct field_of_this_result
*);
83 struct block_symbol
lookup_local_symbol (const char *name
,
84 const struct block
*block
,
85 const domain_enum domain
,
86 enum language language
);
88 static struct block_symbol
89 lookup_symbol_in_objfile (struct objfile
*objfile
, int block_index
,
90 const char *name
, const domain_enum domain
);
93 const struct block_symbol null_block_symbol
= { NULL
, NULL
};
95 extern initialize_file_ftype _initialize_symtab
;
97 /* Program space key for finding name and language of "main". */
99 static const struct program_space_data
*main_progspace_key
;
101 /* Type of the data stored on the program space. */
105 /* Name of "main". */
109 /* Language of "main". */
111 enum language language_of_main
;
114 /* Program space key for finding its symbol cache. */
116 static const struct program_space_data
*symbol_cache_key
;
118 /* The default symbol cache size.
119 There is no extra cpu cost for large N (except when flushing the cache,
120 which is rare). The value here is just a first attempt. A better default
121 value may be higher or lower. A prime number can make up for a bad hash
122 computation, so that's why the number is what it is. */
123 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
125 /* The maximum symbol cache size.
126 There's no method to the decision of what value to use here, other than
127 there's no point in allowing a user typo to make gdb consume all memory. */
128 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
130 /* symbol_cache_lookup returns this if a previous lookup failed to find the
131 symbol in any objfile. */
132 #define SYMBOL_LOOKUP_FAILED \
133 ((struct block_symbol) {(struct symbol *) 1, NULL})
134 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
136 /* Recording lookups that don't find the symbol is just as important, if not
137 more so, than recording found symbols. */
139 enum symbol_cache_slot_state
142 SYMBOL_SLOT_NOT_FOUND
,
146 struct symbol_cache_slot
148 enum symbol_cache_slot_state state
;
150 /* The objfile that was current when the symbol was looked up.
151 This is only needed for global blocks, but for simplicity's sake
152 we allocate the space for both. If data shows the extra space used
153 for static blocks is a problem, we can split things up then.
155 Global blocks need cache lookup to include the objfile context because
156 we need to account for gdbarch_iterate_over_objfiles_in_search_order
157 which can traverse objfiles in, effectively, any order, depending on
158 the current objfile, thus affecting which symbol is found. Normally,
159 only the current objfile is searched first, and then the rest are
160 searched in recorded order; but putting cache lookup inside
161 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
162 Instead we just make the current objfile part of the context of
163 cache lookup. This means we can record the same symbol multiple times,
164 each with a different "current objfile" that was in effect when the
165 lookup was saved in the cache, but cache space is pretty cheap. */
166 const struct objfile
*objfile_context
;
170 struct block_symbol found
;
179 /* Symbols don't specify global vs static block.
180 So keep them in separate caches. */
182 struct block_symbol_cache
186 unsigned int collisions
;
188 /* SYMBOLS is a variable length array of this size.
189 One can imagine that in general one cache (global/static) should be a
190 fraction of the size of the other, but there's no data at the moment
191 on which to decide. */
194 struct symbol_cache_slot symbols
[1];
199 Searching for symbols in the static and global blocks over multiple objfiles
200 again and again can be slow, as can searching very big objfiles. This is a
201 simple cache to improve symbol lookup performance, which is critical to
202 overall gdb performance.
204 Symbols are hashed on the name, its domain, and block.
205 They are also hashed on their objfile for objfile-specific lookups. */
209 struct block_symbol_cache
*global_symbols
;
210 struct block_symbol_cache
*static_symbols
;
213 /* When non-zero, print debugging messages related to symtab creation. */
214 unsigned int symtab_create_debug
= 0;
216 /* When non-zero, print debugging messages related to symbol lookup. */
217 unsigned int symbol_lookup_debug
= 0;
219 /* The size of the cache is staged here. */
220 static unsigned int new_symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
222 /* The current value of the symbol cache size.
223 This is saved so that if the user enters a value too big we can restore
224 the original value from here. */
225 static unsigned int symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
227 /* Non-zero if a file may be known by two different basenames.
228 This is the uncommon case, and significantly slows down gdb.
229 Default set to "off" to not slow down the common case. */
230 int basenames_may_differ
= 0;
232 /* Allow the user to configure the debugger behavior with respect
233 to multiple-choice menus when more than one symbol matches during
236 const char multiple_symbols_ask
[] = "ask";
237 const char multiple_symbols_all
[] = "all";
238 const char multiple_symbols_cancel
[] = "cancel";
239 static const char *const multiple_symbols_modes
[] =
241 multiple_symbols_ask
,
242 multiple_symbols_all
,
243 multiple_symbols_cancel
,
246 static const char *multiple_symbols_mode
= multiple_symbols_all
;
248 /* Read-only accessor to AUTO_SELECT_MODE. */
251 multiple_symbols_select_mode (void)
253 return multiple_symbols_mode
;
256 /* Return the name of a domain_enum. */
259 domain_name (domain_enum e
)
263 case UNDEF_DOMAIN
: return "UNDEF_DOMAIN";
264 case VAR_DOMAIN
: return "VAR_DOMAIN";
265 case STRUCT_DOMAIN
: return "STRUCT_DOMAIN";
266 case MODULE_DOMAIN
: return "MODULE_DOMAIN";
267 case LABEL_DOMAIN
: return "LABEL_DOMAIN";
268 case COMMON_BLOCK_DOMAIN
: return "COMMON_BLOCK_DOMAIN";
269 default: gdb_assert_not_reached ("bad domain_enum");
273 /* Return the name of a search_domain . */
276 search_domain_name (enum search_domain e
)
280 case VARIABLES_DOMAIN
: return "VARIABLES_DOMAIN";
281 case FUNCTIONS_DOMAIN
: return "FUNCTIONS_DOMAIN";
282 case TYPES_DOMAIN
: return "TYPES_DOMAIN";
283 case ALL_DOMAIN
: return "ALL_DOMAIN";
284 default: gdb_assert_not_reached ("bad search_domain");
291 compunit_primary_filetab (const struct compunit_symtab
*cust
)
293 gdb_assert (COMPUNIT_FILETABS (cust
) != NULL
);
295 /* The primary file symtab is the first one in the list. */
296 return COMPUNIT_FILETABS (cust
);
302 compunit_language (const struct compunit_symtab
*cust
)
304 struct symtab
*symtab
= compunit_primary_filetab (cust
);
306 /* The language of the compunit symtab is the language of its primary
308 return SYMTAB_LANGUAGE (symtab
);
311 /* See whether FILENAME matches SEARCH_NAME using the rule that we
312 advertise to the user. (The manual's description of linespecs
313 describes what we advertise). Returns true if they match, false
317 compare_filenames_for_search (const char *filename
, const char *search_name
)
319 int len
= strlen (filename
);
320 size_t search_len
= strlen (search_name
);
322 if (len
< search_len
)
325 /* The tail of FILENAME must match. */
326 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
329 /* Either the names must completely match, or the character
330 preceding the trailing SEARCH_NAME segment of FILENAME must be a
333 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
334 cannot match FILENAME "/path//dir/file.c" - as user has requested
335 absolute path. The sama applies for "c:\file.c" possibly
336 incorrectly hypothetically matching "d:\dir\c:\file.c".
338 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
339 compatible with SEARCH_NAME "file.c". In such case a compiler had
340 to put the "c:file.c" name into debug info. Such compatibility
341 works only on GDB built for DOS host. */
342 return (len
== search_len
343 || (!IS_ABSOLUTE_PATH (search_name
)
344 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
345 || (HAS_DRIVE_SPEC (filename
)
346 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
349 /* Same as compare_filenames_for_search, but for glob-style patterns.
350 Heads up on the order of the arguments. They match the order of
351 compare_filenames_for_search, but it's the opposite of the order of
352 arguments to gdb_filename_fnmatch. */
355 compare_glob_filenames_for_search (const char *filename
,
356 const char *search_name
)
358 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
359 all /s have to be explicitly specified. */
360 int file_path_elements
= count_path_elements (filename
);
361 int search_path_elements
= count_path_elements (search_name
);
363 if (search_path_elements
> file_path_elements
)
366 if (IS_ABSOLUTE_PATH (search_name
))
368 return (search_path_elements
== file_path_elements
369 && gdb_filename_fnmatch (search_name
, filename
,
370 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0);
374 const char *file_to_compare
375 = strip_leading_path_elements (filename
,
376 file_path_elements
- search_path_elements
);
378 return gdb_filename_fnmatch (search_name
, file_to_compare
,
379 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0;
383 /* Check for a symtab of a specific name by searching some symtabs.
384 This is a helper function for callbacks of iterate_over_symtabs.
386 If NAME is not absolute, then REAL_PATH is NULL
387 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
389 The return value, NAME, REAL_PATH and CALLBACK are identical to the
390 `map_symtabs_matching_filename' method of quick_symbol_functions.
392 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
393 Each symtab within the specified compunit symtab is also searched.
394 AFTER_LAST is one past the last compunit symtab to search; NULL means to
395 search until the end of the list. */
398 iterate_over_some_symtabs (const char *name
,
399 const char *real_path
,
400 struct compunit_symtab
*first
,
401 struct compunit_symtab
*after_last
,
402 gdb::function_view
<bool (symtab
*)> callback
)
404 struct compunit_symtab
*cust
;
406 const char* base_name
= lbasename (name
);
408 for (cust
= first
; cust
!= NULL
&& cust
!= after_last
; cust
= cust
->next
)
410 ALL_COMPUNIT_FILETABS (cust
, s
)
412 if (compare_filenames_for_search (s
->filename
, name
))
419 /* Before we invoke realpath, which can get expensive when many
420 files are involved, do a quick comparison of the basenames. */
421 if (! basenames_may_differ
422 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
425 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
432 /* If the user gave us an absolute path, try to find the file in
433 this symtab and use its absolute path. */
434 if (real_path
!= NULL
)
436 const char *fullname
= symtab_to_fullname (s
);
438 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
439 gdb_assert (IS_ABSOLUTE_PATH (name
));
440 if (FILENAME_CMP (real_path
, fullname
) == 0)
453 /* Check for a symtab of a specific name; first in symtabs, then in
454 psymtabs. *If* there is no '/' in the name, a match after a '/'
455 in the symtab filename will also work.
457 Calls CALLBACK with each symtab that is found. If CALLBACK returns
458 true, the search stops. */
461 iterate_over_symtabs (const char *name
,
462 gdb::function_view
<bool (symtab
*)> callback
)
464 struct objfile
*objfile
;
465 gdb::unique_xmalloc_ptr
<char> real_path
;
467 /* Here we are interested in canonicalizing an absolute path, not
468 absolutizing a relative path. */
469 if (IS_ABSOLUTE_PATH (name
))
471 real_path
= gdb_realpath (name
);
472 gdb_assert (IS_ABSOLUTE_PATH (real_path
.get ()));
475 ALL_OBJFILES (objfile
)
477 if (iterate_over_some_symtabs (name
, real_path
.get (),
478 objfile
->compunit_symtabs
, NULL
,
483 /* Same search rules as above apply here, but now we look thru the
486 ALL_OBJFILES (objfile
)
489 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
497 /* A wrapper for iterate_over_symtabs that returns the first matching
501 lookup_symtab (const char *name
)
503 struct symtab
*result
= NULL
;
505 iterate_over_symtabs (name
, [&] (symtab
*symtab
)
515 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
516 full method name, which consist of the class name (from T), the unadorned
517 method name from METHOD_ID, and the signature for the specific overload,
518 specified by SIGNATURE_ID. Note that this function is g++ specific. */
521 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
523 int mangled_name_len
;
525 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
526 struct fn_field
*method
= &f
[signature_id
];
527 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
528 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
529 const char *newname
= type_name_no_tag (type
);
531 /* Does the form of physname indicate that it is the full mangled name
532 of a constructor (not just the args)? */
533 int is_full_physname_constructor
;
536 int is_destructor
= is_destructor_name (physname
);
537 /* Need a new type prefix. */
538 const char *const_prefix
= method
->is_const
? "C" : "";
539 const char *volatile_prefix
= method
->is_volatile
? "V" : "";
541 int len
= (newname
== NULL
? 0 : strlen (newname
));
543 /* Nothing to do if physname already contains a fully mangled v3 abi name
544 or an operator name. */
545 if ((physname
[0] == '_' && physname
[1] == 'Z')
546 || is_operator_name (field_name
))
547 return xstrdup (physname
);
549 is_full_physname_constructor
= is_constructor_name (physname
);
551 is_constructor
= is_full_physname_constructor
552 || (newname
&& strcmp (field_name
, newname
) == 0);
555 is_destructor
= (startswith (physname
, "__dt"));
557 if (is_destructor
|| is_full_physname_constructor
)
559 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
560 strcpy (mangled_name
, physname
);
566 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
568 else if (physname
[0] == 't' || physname
[0] == 'Q')
570 /* The physname for template and qualified methods already includes
572 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
578 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
579 volatile_prefix
, len
);
581 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
582 + strlen (buf
) + len
+ strlen (physname
) + 1);
584 mangled_name
= (char *) xmalloc (mangled_name_len
);
586 mangled_name
[0] = '\0';
588 strcpy (mangled_name
, field_name
);
590 strcat (mangled_name
, buf
);
591 /* If the class doesn't have a name, i.e. newname NULL, then we just
592 mangle it using 0 for the length of the class. Thus it gets mangled
593 as something starting with `::' rather than `classname::'. */
595 strcat (mangled_name
, newname
);
597 strcat (mangled_name
, physname
);
598 return (mangled_name
);
601 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
602 correctly allocated. */
605 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
607 struct obstack
*obstack
)
609 if (gsymbol
->language
== language_ada
)
613 gsymbol
->ada_mangled
= 0;
614 gsymbol
->language_specific
.obstack
= obstack
;
618 gsymbol
->ada_mangled
= 1;
619 gsymbol
->language_specific
.demangled_name
= name
;
623 gsymbol
->language_specific
.demangled_name
= name
;
626 /* Return the demangled name of GSYMBOL. */
629 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
631 if (gsymbol
->language
== language_ada
)
633 if (!gsymbol
->ada_mangled
)
638 return gsymbol
->language_specific
.demangled_name
;
642 /* Initialize the language dependent portion of a symbol
643 depending upon the language for the symbol. */
646 symbol_set_language (struct general_symbol_info
*gsymbol
,
647 enum language language
,
648 struct obstack
*obstack
)
650 gsymbol
->language
= language
;
651 if (gsymbol
->language
== language_cplus
652 || gsymbol
->language
== language_d
653 || gsymbol
->language
== language_go
654 || gsymbol
->language
== language_objc
655 || gsymbol
->language
== language_fortran
)
657 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
659 else if (gsymbol
->language
== language_ada
)
661 gdb_assert (gsymbol
->ada_mangled
== 0);
662 gsymbol
->language_specific
.obstack
= obstack
;
666 memset (&gsymbol
->language_specific
, 0,
667 sizeof (gsymbol
->language_specific
));
671 /* Functions to initialize a symbol's mangled name. */
673 /* Objects of this type are stored in the demangled name hash table. */
674 struct demangled_name_entry
680 /* Hash function for the demangled name hash. */
683 hash_demangled_name_entry (const void *data
)
685 const struct demangled_name_entry
*e
686 = (const struct demangled_name_entry
*) data
;
688 return htab_hash_string (e
->mangled
);
691 /* Equality function for the demangled name hash. */
694 eq_demangled_name_entry (const void *a
, const void *b
)
696 const struct demangled_name_entry
*da
697 = (const struct demangled_name_entry
*) a
;
698 const struct demangled_name_entry
*db
699 = (const struct demangled_name_entry
*) b
;
701 return strcmp (da
->mangled
, db
->mangled
) == 0;
704 /* Create the hash table used for demangled names. Each hash entry is
705 a pair of strings; one for the mangled name and one for the demangled
706 name. The entry is hashed via just the mangled name. */
709 create_demangled_names_hash (struct objfile
*objfile
)
711 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
712 The hash table code will round this up to the next prime number.
713 Choosing a much larger table size wastes memory, and saves only about
714 1% in symbol reading. */
716 objfile
->per_bfd
->demangled_names_hash
= htab_create_alloc
717 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
718 NULL
, xcalloc
, xfree
);
721 /* Try to determine the demangled name for a symbol, based on the
722 language of that symbol. If the language is set to language_auto,
723 it will attempt to find any demangling algorithm that works and
724 then set the language appropriately. The returned name is allocated
725 by the demangler and should be xfree'd. */
728 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
731 char *demangled
= NULL
;
735 if (gsymbol
->language
== language_unknown
)
736 gsymbol
->language
= language_auto
;
738 if (gsymbol
->language
!= language_auto
)
740 const struct language_defn
*lang
= language_def (gsymbol
->language
);
742 language_sniff_from_mangled_name (lang
, mangled
, &demangled
);
746 for (i
= language_unknown
; i
< nr_languages
; ++i
)
748 enum language l
= (enum language
) i
;
749 const struct language_defn
*lang
= language_def (l
);
751 if (language_sniff_from_mangled_name (lang
, mangled
, &demangled
))
753 gsymbol
->language
= l
;
761 /* Set both the mangled and demangled (if any) names for GSYMBOL based
762 on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the
763 objfile's obstack; but if COPY_NAME is 0 and if NAME is
764 NUL-terminated, then this function assumes that NAME is already
765 correctly saved (either permanently or with a lifetime tied to the
766 objfile), and it will not be copied.
768 The hash table corresponding to OBJFILE is used, and the memory
769 comes from the per-BFD storage_obstack. LINKAGE_NAME is copied,
770 so the pointer can be discarded after calling this function. */
773 symbol_set_names (struct general_symbol_info
*gsymbol
,
774 const char *linkage_name
, int len
, int copy_name
,
775 struct objfile
*objfile
)
777 struct demangled_name_entry
**slot
;
778 /* A 0-terminated copy of the linkage name. */
779 const char *linkage_name_copy
;
780 struct demangled_name_entry entry
;
781 struct objfile_per_bfd_storage
*per_bfd
= objfile
->per_bfd
;
783 if (gsymbol
->language
== language_ada
)
785 /* In Ada, we do the symbol lookups using the mangled name, so
786 we can save some space by not storing the demangled name. */
788 gsymbol
->name
= linkage_name
;
791 char *name
= (char *) obstack_alloc (&per_bfd
->storage_obstack
,
794 memcpy (name
, linkage_name
, len
);
796 gsymbol
->name
= name
;
798 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
803 if (per_bfd
->demangled_names_hash
== NULL
)
804 create_demangled_names_hash (objfile
);
806 if (linkage_name
[len
] != '\0')
810 alloc_name
= (char *) alloca (len
+ 1);
811 memcpy (alloc_name
, linkage_name
, len
);
812 alloc_name
[len
] = '\0';
814 linkage_name_copy
= alloc_name
;
817 linkage_name_copy
= linkage_name
;
819 entry
.mangled
= linkage_name_copy
;
820 slot
= ((struct demangled_name_entry
**)
821 htab_find_slot (per_bfd
->demangled_names_hash
,
824 /* If this name is not in the hash table, add it. */
826 /* A C version of the symbol may have already snuck into the table.
827 This happens to, e.g., main.init (__go_init_main). Cope. */
828 || (gsymbol
->language
== language_go
829 && (*slot
)->demangled
[0] == '\0'))
831 char *demangled_name
= symbol_find_demangled_name (gsymbol
,
833 int demangled_len
= demangled_name
? strlen (demangled_name
) : 0;
835 /* Suppose we have demangled_name==NULL, copy_name==0, and
836 linkage_name_copy==linkage_name. In this case, we already have the
837 mangled name saved, and we don't have a demangled name. So,
838 you might think we could save a little space by not recording
839 this in the hash table at all.
841 It turns out that it is actually important to still save such
842 an entry in the hash table, because storing this name gives
843 us better bcache hit rates for partial symbols. */
844 if (!copy_name
&& linkage_name_copy
== linkage_name
)
847 = ((struct demangled_name_entry
*)
848 obstack_alloc (&per_bfd
->storage_obstack
,
849 offsetof (struct demangled_name_entry
, demangled
)
850 + demangled_len
+ 1));
851 (*slot
)->mangled
= linkage_name
;
857 /* If we must copy the mangled name, put it directly after
858 the demangled name so we can have a single
861 = ((struct demangled_name_entry
*)
862 obstack_alloc (&per_bfd
->storage_obstack
,
863 offsetof (struct demangled_name_entry
, demangled
)
864 + len
+ demangled_len
+ 2));
865 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
866 strcpy (mangled_ptr
, linkage_name_copy
);
867 (*slot
)->mangled
= mangled_ptr
;
870 if (demangled_name
!= NULL
)
872 strcpy ((*slot
)->demangled
, demangled_name
);
873 xfree (demangled_name
);
876 (*slot
)->demangled
[0] = '\0';
879 gsymbol
->name
= (*slot
)->mangled
;
880 if ((*slot
)->demangled
[0] != '\0')
881 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
882 &per_bfd
->storage_obstack
);
884 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
887 /* Return the source code name of a symbol. In languages where
888 demangling is necessary, this is the demangled name. */
891 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
893 switch (gsymbol
->language
)
899 case language_fortran
:
900 if (symbol_get_demangled_name (gsymbol
) != NULL
)
901 return symbol_get_demangled_name (gsymbol
);
904 return ada_decode_symbol (gsymbol
);
908 return gsymbol
->name
;
911 /* Return the demangled name for a symbol based on the language for
912 that symbol. If no demangled name exists, return NULL. */
915 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
917 const char *dem_name
= NULL
;
919 switch (gsymbol
->language
)
925 case language_fortran
:
926 dem_name
= symbol_get_demangled_name (gsymbol
);
929 dem_name
= ada_decode_symbol (gsymbol
);
937 /* Return the search name of a symbol---generally the demangled or
938 linkage name of the symbol, depending on how it will be searched for.
939 If there is no distinct demangled name, then returns the same value
940 (same pointer) as SYMBOL_LINKAGE_NAME. */
943 symbol_search_name (const struct general_symbol_info
*gsymbol
)
945 if (gsymbol
->language
== language_ada
)
946 return gsymbol
->name
;
948 return symbol_natural_name (gsymbol
);
952 /* Return 1 if the two sections are the same, or if they could
953 plausibly be copies of each other, one in an original object
954 file and another in a separated debug file. */
957 matching_obj_sections (struct obj_section
*obj_first
,
958 struct obj_section
*obj_second
)
960 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
961 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
964 /* If they're the same section, then they match. */
968 /* If either is NULL, give up. */
969 if (first
== NULL
|| second
== NULL
)
972 /* This doesn't apply to absolute symbols. */
973 if (first
->owner
== NULL
|| second
->owner
== NULL
)
976 /* If they're in the same object file, they must be different sections. */
977 if (first
->owner
== second
->owner
)
980 /* Check whether the two sections are potentially corresponding. They must
981 have the same size, address, and name. We can't compare section indexes,
982 which would be more reliable, because some sections may have been
984 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
987 /* In-memory addresses may start at a different offset, relativize them. */
988 if (bfd_get_section_vma (first
->owner
, first
)
989 - bfd_get_start_address (first
->owner
)
990 != bfd_get_section_vma (second
->owner
, second
)
991 - bfd_get_start_address (second
->owner
))
994 if (bfd_get_section_name (first
->owner
, first
) == NULL
995 || bfd_get_section_name (second
->owner
, second
) == NULL
996 || strcmp (bfd_get_section_name (first
->owner
, first
),
997 bfd_get_section_name (second
->owner
, second
)) != 0)
1000 /* Otherwise check that they are in corresponding objfiles. */
1003 if (obj
->obfd
== first
->owner
)
1005 gdb_assert (obj
!= NULL
);
1007 if (obj
->separate_debug_objfile
!= NULL
1008 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1010 if (obj
->separate_debug_objfile_backlink
!= NULL
1011 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1020 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1022 struct objfile
*objfile
;
1023 struct bound_minimal_symbol msymbol
;
1025 /* If we know that this is not a text address, return failure. This is
1026 necessary because we loop based on texthigh and textlow, which do
1027 not include the data ranges. */
1028 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1030 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
1031 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
1032 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
1033 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
1034 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
1037 ALL_OBJFILES (objfile
)
1039 struct compunit_symtab
*cust
= NULL
;
1042 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1049 /* Hash function for the symbol cache. */
1052 hash_symbol_entry (const struct objfile
*objfile_context
,
1053 const char *name
, domain_enum domain
)
1055 unsigned int hash
= (uintptr_t) objfile_context
;
1058 hash
+= htab_hash_string (name
);
1060 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1061 to map to the same slot. */
1062 if (domain
== STRUCT_DOMAIN
)
1063 hash
+= VAR_DOMAIN
* 7;
1070 /* Equality function for the symbol cache. */
1073 eq_symbol_entry (const struct symbol_cache_slot
*slot
,
1074 const struct objfile
*objfile_context
,
1075 const char *name
, domain_enum domain
)
1077 const char *slot_name
;
1078 domain_enum slot_domain
;
1080 if (slot
->state
== SYMBOL_SLOT_UNUSED
)
1083 if (slot
->objfile_context
!= objfile_context
)
1086 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1088 slot_name
= slot
->value
.not_found
.name
;
1089 slot_domain
= slot
->value
.not_found
.domain
;
1093 slot_name
= SYMBOL_SEARCH_NAME (slot
->value
.found
.symbol
);
1094 slot_domain
= SYMBOL_DOMAIN (slot
->value
.found
.symbol
);
1097 /* NULL names match. */
1098 if (slot_name
== NULL
&& name
== NULL
)
1100 /* But there's no point in calling symbol_matches_domain in the
1101 SYMBOL_SLOT_FOUND case. */
1102 if (slot_domain
!= domain
)
1105 else if (slot_name
!= NULL
&& name
!= NULL
)
1107 /* It's important that we use the same comparison that was done the
1108 first time through. If the slot records a found symbol, then this
1109 means using strcmp_iw on SYMBOL_SEARCH_NAME. See dictionary.c.
1110 It also means using symbol_matches_domain for found symbols.
1113 If the slot records a not-found symbol, then require a precise match.
1114 We could still be lax with whitespace like strcmp_iw though. */
1116 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1118 if (strcmp (slot_name
, name
) != 0)
1120 if (slot_domain
!= domain
)
1125 struct symbol
*sym
= slot
->value
.found
.symbol
;
1127 if (strcmp_iw (slot_name
, name
) != 0)
1129 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1130 slot_domain
, domain
))
1136 /* Only one name is NULL. */
1143 /* Given a cache of size SIZE, return the size of the struct (with variable
1144 length array) in bytes. */
1147 symbol_cache_byte_size (unsigned int size
)
1149 return (sizeof (struct block_symbol_cache
)
1150 + ((size
- 1) * sizeof (struct symbol_cache_slot
)));
1156 resize_symbol_cache (struct symbol_cache
*cache
, unsigned int new_size
)
1158 /* If there's no change in size, don't do anything.
1159 All caches have the same size, so we can just compare with the size
1160 of the global symbols cache. */
1161 if ((cache
->global_symbols
!= NULL
1162 && cache
->global_symbols
->size
== new_size
)
1163 || (cache
->global_symbols
== NULL
1167 xfree (cache
->global_symbols
);
1168 xfree (cache
->static_symbols
);
1172 cache
->global_symbols
= NULL
;
1173 cache
->static_symbols
= NULL
;
1177 size_t total_size
= symbol_cache_byte_size (new_size
);
1179 cache
->global_symbols
1180 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1181 cache
->static_symbols
1182 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1183 cache
->global_symbols
->size
= new_size
;
1184 cache
->static_symbols
->size
= new_size
;
1188 /* Make a symbol cache of size SIZE. */
1190 static struct symbol_cache
*
1191 make_symbol_cache (unsigned int size
)
1193 struct symbol_cache
*cache
;
1195 cache
= XCNEW (struct symbol_cache
);
1196 resize_symbol_cache (cache
, symbol_cache_size
);
1200 /* Free the space used by CACHE. */
1203 free_symbol_cache (struct symbol_cache
*cache
)
1205 xfree (cache
->global_symbols
);
1206 xfree (cache
->static_symbols
);
1210 /* Return the symbol cache of PSPACE.
1211 Create one if it doesn't exist yet. */
1213 static struct symbol_cache
*
1214 get_symbol_cache (struct program_space
*pspace
)
1216 struct symbol_cache
*cache
1217 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1221 cache
= make_symbol_cache (symbol_cache_size
);
1222 set_program_space_data (pspace
, symbol_cache_key
, cache
);
1228 /* Delete the symbol cache of PSPACE.
1229 Called when PSPACE is destroyed. */
1232 symbol_cache_cleanup (struct program_space
*pspace
, void *data
)
1234 struct symbol_cache
*cache
= (struct symbol_cache
*) data
;
1236 free_symbol_cache (cache
);
1239 /* Set the size of the symbol cache in all program spaces. */
1242 set_symbol_cache_size (unsigned int new_size
)
1244 struct program_space
*pspace
;
1246 ALL_PSPACES (pspace
)
1248 struct symbol_cache
*cache
1249 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1251 /* The pspace could have been created but not have a cache yet. */
1253 resize_symbol_cache (cache
, new_size
);
1257 /* Called when symbol-cache-size is set. */
1260 set_symbol_cache_size_handler (char *args
, int from_tty
,
1261 struct cmd_list_element
*c
)
1263 if (new_symbol_cache_size
> MAX_SYMBOL_CACHE_SIZE
)
1265 /* Restore the previous value.
1266 This is the value the "show" command prints. */
1267 new_symbol_cache_size
= symbol_cache_size
;
1269 error (_("Symbol cache size is too large, max is %u."),
1270 MAX_SYMBOL_CACHE_SIZE
);
1272 symbol_cache_size
= new_symbol_cache_size
;
1274 set_symbol_cache_size (symbol_cache_size
);
1277 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1278 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1279 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1280 failed (and thus this one will too), or NULL if the symbol is not present
1282 If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
1283 set to the cache and slot of the symbol to save the result of a full lookup
1286 static struct block_symbol
1287 symbol_cache_lookup (struct symbol_cache
*cache
,
1288 struct objfile
*objfile_context
, int block
,
1289 const char *name
, domain_enum domain
,
1290 struct block_symbol_cache
**bsc_ptr
,
1291 struct symbol_cache_slot
**slot_ptr
)
1293 struct block_symbol_cache
*bsc
;
1295 struct symbol_cache_slot
*slot
;
1297 if (block
== GLOBAL_BLOCK
)
1298 bsc
= cache
->global_symbols
;
1300 bsc
= cache
->static_symbols
;
1305 return (struct block_symbol
) {NULL
, NULL
};
1308 hash
= hash_symbol_entry (objfile_context
, name
, domain
);
1309 slot
= bsc
->symbols
+ hash
% bsc
->size
;
1311 if (eq_symbol_entry (slot
, objfile_context
, name
, domain
))
1313 if (symbol_lookup_debug
)
1314 fprintf_unfiltered (gdb_stdlog
,
1315 "%s block symbol cache hit%s for %s, %s\n",
1316 block
== GLOBAL_BLOCK
? "Global" : "Static",
1317 slot
->state
== SYMBOL_SLOT_NOT_FOUND
1318 ? " (not found)" : "",
1319 name
, domain_name (domain
));
1321 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1322 return SYMBOL_LOOKUP_FAILED
;
1323 return slot
->value
.found
;
1326 /* Symbol is not present in the cache. */
1331 if (symbol_lookup_debug
)
1333 fprintf_unfiltered (gdb_stdlog
,
1334 "%s block symbol cache miss for %s, %s\n",
1335 block
== GLOBAL_BLOCK
? "Global" : "Static",
1336 name
, domain_name (domain
));
1339 return (struct block_symbol
) {NULL
, NULL
};
1342 /* Clear out SLOT. */
1345 symbol_cache_clear_slot (struct symbol_cache_slot
*slot
)
1347 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1348 xfree (slot
->value
.not_found
.name
);
1349 slot
->state
= SYMBOL_SLOT_UNUSED
;
1352 /* Mark SYMBOL as found in SLOT.
1353 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1354 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1355 necessarily the objfile the symbol was found in. */
1358 symbol_cache_mark_found (struct block_symbol_cache
*bsc
,
1359 struct symbol_cache_slot
*slot
,
1360 struct objfile
*objfile_context
,
1361 struct symbol
*symbol
,
1362 const struct block
*block
)
1366 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1369 symbol_cache_clear_slot (slot
);
1371 slot
->state
= SYMBOL_SLOT_FOUND
;
1372 slot
->objfile_context
= objfile_context
;
1373 slot
->value
.found
.symbol
= symbol
;
1374 slot
->value
.found
.block
= block
;
1377 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1378 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1379 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1382 symbol_cache_mark_not_found (struct block_symbol_cache
*bsc
,
1383 struct symbol_cache_slot
*slot
,
1384 struct objfile
*objfile_context
,
1385 const char *name
, domain_enum domain
)
1389 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1392 symbol_cache_clear_slot (slot
);
1394 slot
->state
= SYMBOL_SLOT_NOT_FOUND
;
1395 slot
->objfile_context
= objfile_context
;
1396 slot
->value
.not_found
.name
= xstrdup (name
);
1397 slot
->value
.not_found
.domain
= domain
;
1400 /* Flush the symbol cache of PSPACE. */
1403 symbol_cache_flush (struct program_space
*pspace
)
1405 struct symbol_cache
*cache
1406 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1411 if (cache
->global_symbols
== NULL
)
1413 gdb_assert (symbol_cache_size
== 0);
1414 gdb_assert (cache
->static_symbols
== NULL
);
1418 /* If the cache is untouched since the last flush, early exit.
1419 This is important for performance during the startup of a program linked
1420 with 100s (or 1000s) of shared libraries. */
1421 if (cache
->global_symbols
->misses
== 0
1422 && cache
->static_symbols
->misses
== 0)
1425 gdb_assert (cache
->global_symbols
->size
== symbol_cache_size
);
1426 gdb_assert (cache
->static_symbols
->size
== symbol_cache_size
);
1428 for (pass
= 0; pass
< 2; ++pass
)
1430 struct block_symbol_cache
*bsc
1431 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1434 for (i
= 0; i
< bsc
->size
; ++i
)
1435 symbol_cache_clear_slot (&bsc
->symbols
[i
]);
1438 cache
->global_symbols
->hits
= 0;
1439 cache
->global_symbols
->misses
= 0;
1440 cache
->global_symbols
->collisions
= 0;
1441 cache
->static_symbols
->hits
= 0;
1442 cache
->static_symbols
->misses
= 0;
1443 cache
->static_symbols
->collisions
= 0;
1449 symbol_cache_dump (const struct symbol_cache
*cache
)
1453 if (cache
->global_symbols
== NULL
)
1455 printf_filtered (" <disabled>\n");
1459 for (pass
= 0; pass
< 2; ++pass
)
1461 const struct block_symbol_cache
*bsc
1462 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1466 printf_filtered ("Global symbols:\n");
1468 printf_filtered ("Static symbols:\n");
1470 for (i
= 0; i
< bsc
->size
; ++i
)
1472 const struct symbol_cache_slot
*slot
= &bsc
->symbols
[i
];
1476 switch (slot
->state
)
1478 case SYMBOL_SLOT_UNUSED
:
1480 case SYMBOL_SLOT_NOT_FOUND
:
1481 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i
,
1482 host_address_to_string (slot
->objfile_context
),
1483 slot
->value
.not_found
.name
,
1484 domain_name (slot
->value
.not_found
.domain
));
1486 case SYMBOL_SLOT_FOUND
:
1488 struct symbol
*found
= slot
->value
.found
.symbol
;
1489 const struct objfile
*context
= slot
->objfile_context
;
1491 printf_filtered (" [%4u] = %s, %s %s\n", i
,
1492 host_address_to_string (context
),
1493 SYMBOL_PRINT_NAME (found
),
1494 domain_name (SYMBOL_DOMAIN (found
)));
1502 /* The "mt print symbol-cache" command. */
1505 maintenance_print_symbol_cache (char *args
, int from_tty
)
1507 struct program_space
*pspace
;
1509 ALL_PSPACES (pspace
)
1511 struct symbol_cache
*cache
;
1513 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1515 pspace
->symfile_object_file
!= NULL
1516 ? objfile_name (pspace
->symfile_object_file
)
1517 : "(no object file)");
1519 /* If the cache hasn't been created yet, avoid creating one. */
1521 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1523 printf_filtered (" <empty>\n");
1525 symbol_cache_dump (cache
);
1529 /* The "mt flush-symbol-cache" command. */
1532 maintenance_flush_symbol_cache (char *args
, int from_tty
)
1534 struct program_space
*pspace
;
1536 ALL_PSPACES (pspace
)
1538 symbol_cache_flush (pspace
);
1542 /* Print usage statistics of CACHE. */
1545 symbol_cache_stats (struct symbol_cache
*cache
)
1549 if (cache
->global_symbols
== NULL
)
1551 printf_filtered (" <disabled>\n");
1555 for (pass
= 0; pass
< 2; ++pass
)
1557 const struct block_symbol_cache
*bsc
1558 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1563 printf_filtered ("Global block cache stats:\n");
1565 printf_filtered ("Static block cache stats:\n");
1567 printf_filtered (" size: %u\n", bsc
->size
);
1568 printf_filtered (" hits: %u\n", bsc
->hits
);
1569 printf_filtered (" misses: %u\n", bsc
->misses
);
1570 printf_filtered (" collisions: %u\n", bsc
->collisions
);
1574 /* The "mt print symbol-cache-statistics" command. */
1577 maintenance_print_symbol_cache_statistics (char *args
, int from_tty
)
1579 struct program_space
*pspace
;
1581 ALL_PSPACES (pspace
)
1583 struct symbol_cache
*cache
;
1585 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1587 pspace
->symfile_object_file
!= NULL
1588 ? objfile_name (pspace
->symfile_object_file
)
1589 : "(no object file)");
1591 /* If the cache hasn't been created yet, avoid creating one. */
1593 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1595 printf_filtered (" empty, no stats available\n");
1597 symbol_cache_stats (cache
);
1601 /* This module's 'new_objfile' observer. */
1604 symtab_new_objfile_observer (struct objfile
*objfile
)
1606 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1607 symbol_cache_flush (current_program_space
);
1610 /* This module's 'free_objfile' observer. */
1613 symtab_free_objfile_observer (struct objfile
*objfile
)
1615 symbol_cache_flush (objfile
->pspace
);
1618 /* Debug symbols usually don't have section information. We need to dig that
1619 out of the minimal symbols and stash that in the debug symbol. */
1622 fixup_section (struct general_symbol_info
*ginfo
,
1623 CORE_ADDR addr
, struct objfile
*objfile
)
1625 struct minimal_symbol
*msym
;
1627 /* First, check whether a minimal symbol with the same name exists
1628 and points to the same address. The address check is required
1629 e.g. on PowerPC64, where the minimal symbol for a function will
1630 point to the function descriptor, while the debug symbol will
1631 point to the actual function code. */
1632 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1634 ginfo
->section
= MSYMBOL_SECTION (msym
);
1637 /* Static, function-local variables do appear in the linker
1638 (minimal) symbols, but are frequently given names that won't
1639 be found via lookup_minimal_symbol(). E.g., it has been
1640 observed in frv-uclinux (ELF) executables that a static,
1641 function-local variable named "foo" might appear in the
1642 linker symbols as "foo.6" or "foo.3". Thus, there is no
1643 point in attempting to extend the lookup-by-name mechanism to
1644 handle this case due to the fact that there can be multiple
1647 So, instead, search the section table when lookup by name has
1648 failed. The ``addr'' and ``endaddr'' fields may have already
1649 been relocated. If so, the relocation offset (i.e. the
1650 ANOFFSET value) needs to be subtracted from these values when
1651 performing the comparison. We unconditionally subtract it,
1652 because, when no relocation has been performed, the ANOFFSET
1653 value will simply be zero.
1655 The address of the symbol whose section we're fixing up HAS
1656 NOT BEEN adjusted (relocated) yet. It can't have been since
1657 the section isn't yet known and knowing the section is
1658 necessary in order to add the correct relocation value. In
1659 other words, we wouldn't even be in this function (attempting
1660 to compute the section) if it were already known.
1662 Note that it is possible to search the minimal symbols
1663 (subtracting the relocation value if necessary) to find the
1664 matching minimal symbol, but this is overkill and much less
1665 efficient. It is not necessary to find the matching minimal
1666 symbol, only its section.
1668 Note that this technique (of doing a section table search)
1669 can fail when unrelocated section addresses overlap. For
1670 this reason, we still attempt a lookup by name prior to doing
1671 a search of the section table. */
1673 struct obj_section
*s
;
1676 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1678 int idx
= s
- objfile
->sections
;
1679 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1684 if (obj_section_addr (s
) - offset
<= addr
1685 && addr
< obj_section_endaddr (s
) - offset
)
1687 ginfo
->section
= idx
;
1692 /* If we didn't find the section, assume it is in the first
1693 section. If there is no allocated section, then it hardly
1694 matters what we pick, so just pick zero. */
1698 ginfo
->section
= fallback
;
1703 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1710 if (!SYMBOL_OBJFILE_OWNED (sym
))
1713 /* We either have an OBJFILE, or we can get at it from the sym's
1714 symtab. Anything else is a bug. */
1715 gdb_assert (objfile
|| symbol_symtab (sym
));
1717 if (objfile
== NULL
)
1718 objfile
= symbol_objfile (sym
);
1720 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1723 /* We should have an objfile by now. */
1724 gdb_assert (objfile
);
1726 switch (SYMBOL_CLASS (sym
))
1730 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1733 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1737 /* Nothing else will be listed in the minsyms -- no use looking
1742 fixup_section (&sym
->ginfo
, addr
, objfile
);
1747 /* Compute the demangled form of NAME as used by the various symbol
1748 lookup functions. The result can either be the input NAME
1749 directly, or a pointer to a buffer owned by the STORAGE object.
1751 For Ada, this function just returns NAME, unmodified.
1752 Normally, Ada symbol lookups are performed using the encoded name
1753 rather than the demangled name, and so it might seem to make sense
1754 for this function to return an encoded version of NAME.
1755 Unfortunately, we cannot do this, because this function is used in
1756 circumstances where it is not appropriate to try to encode NAME.
1757 For instance, when displaying the frame info, we demangle the name
1758 of each parameter, and then perform a symbol lookup inside our
1759 function using that demangled name. In Ada, certain functions
1760 have internally-generated parameters whose name contain uppercase
1761 characters. Encoding those name would result in those uppercase
1762 characters to become lowercase, and thus cause the symbol lookup
1766 demangle_for_lookup (const char *name
, enum language lang
,
1767 demangle_result_storage
&storage
)
1769 /* If we are using C++, D, or Go, demangle the name before doing a
1770 lookup, so we can always binary search. */
1771 if (lang
== language_cplus
)
1773 char *demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1774 if (demangled_name
!= NULL
)
1775 return storage
.set_malloc_ptr (demangled_name
);
1777 /* If we were given a non-mangled name, canonicalize it
1778 according to the language (so far only for C++). */
1779 std::string canon
= cp_canonicalize_string (name
);
1780 if (!canon
.empty ())
1781 return storage
.swap_string (canon
);
1783 else if (lang
== language_d
)
1785 char *demangled_name
= d_demangle (name
, 0);
1786 if (demangled_name
!= NULL
)
1787 return storage
.set_malloc_ptr (demangled_name
);
1789 else if (lang
== language_go
)
1791 char *demangled_name
= go_demangle (name
, 0);
1792 if (demangled_name
!= NULL
)
1793 return storage
.set_malloc_ptr (demangled_name
);
1801 This function (or rather its subordinates) have a bunch of loops and
1802 it would seem to be attractive to put in some QUIT's (though I'm not really
1803 sure whether it can run long enough to be really important). But there
1804 are a few calls for which it would appear to be bad news to quit
1805 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1806 that there is C++ code below which can error(), but that probably
1807 doesn't affect these calls since they are looking for a known
1808 variable and thus can probably assume it will never hit the C++
1812 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1813 const domain_enum domain
, enum language lang
,
1814 struct field_of_this_result
*is_a_field_of_this
)
1816 demangle_result_storage storage
;
1817 const char *modified_name
= demangle_for_lookup (name
, lang
, storage
);
1819 return lookup_symbol_aux (modified_name
, block
, domain
, lang
,
1820 is_a_field_of_this
);
1826 lookup_symbol (const char *name
, const struct block
*block
,
1828 struct field_of_this_result
*is_a_field_of_this
)
1830 return lookup_symbol_in_language (name
, block
, domain
,
1831 current_language
->la_language
,
1832 is_a_field_of_this
);
1838 lookup_language_this (const struct language_defn
*lang
,
1839 const struct block
*block
)
1841 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1842 return (struct block_symbol
) {NULL
, NULL
};
1844 if (symbol_lookup_debug
> 1)
1846 struct objfile
*objfile
= lookup_objfile_from_block (block
);
1848 fprintf_unfiltered (gdb_stdlog
,
1849 "lookup_language_this (%s, %s (objfile %s))",
1850 lang
->la_name
, host_address_to_string (block
),
1851 objfile_debug_name (objfile
));
1858 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
, VAR_DOMAIN
);
1861 if (symbol_lookup_debug
> 1)
1863 fprintf_unfiltered (gdb_stdlog
, " = %s (%s, block %s)\n",
1864 SYMBOL_PRINT_NAME (sym
),
1865 host_address_to_string (sym
),
1866 host_address_to_string (block
));
1868 return (struct block_symbol
) {sym
, block
};
1870 if (BLOCK_FUNCTION (block
))
1872 block
= BLOCK_SUPERBLOCK (block
);
1875 if (symbol_lookup_debug
> 1)
1876 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1877 return (struct block_symbol
) {NULL
, NULL
};
1880 /* Given TYPE, a structure/union,
1881 return 1 if the component named NAME from the ultimate target
1882 structure/union is defined, otherwise, return 0. */
1885 check_field (struct type
*type
, const char *name
,
1886 struct field_of_this_result
*is_a_field_of_this
)
1890 /* The type may be a stub. */
1891 type
= check_typedef (type
);
1893 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1895 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1897 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1899 is_a_field_of_this
->type
= type
;
1900 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1905 /* C++: If it was not found as a data field, then try to return it
1906 as a pointer to a method. */
1908 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1910 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1912 is_a_field_of_this
->type
= type
;
1913 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1918 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1919 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
1925 /* Behave like lookup_symbol except that NAME is the natural name
1926 (e.g., demangled name) of the symbol that we're looking for. */
1928 static struct block_symbol
1929 lookup_symbol_aux (const char *name
, const struct block
*block
,
1930 const domain_enum domain
, enum language language
,
1931 struct field_of_this_result
*is_a_field_of_this
)
1933 struct block_symbol result
;
1934 const struct language_defn
*langdef
;
1936 if (symbol_lookup_debug
)
1938 struct objfile
*objfile
= lookup_objfile_from_block (block
);
1940 fprintf_unfiltered (gdb_stdlog
,
1941 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
1942 name
, host_address_to_string (block
),
1944 ? objfile_debug_name (objfile
) : "NULL",
1945 domain_name (domain
), language_str (language
));
1948 /* Make sure we do something sensible with is_a_field_of_this, since
1949 the callers that set this parameter to some non-null value will
1950 certainly use it later. If we don't set it, the contents of
1951 is_a_field_of_this are undefined. */
1952 if (is_a_field_of_this
!= NULL
)
1953 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
1955 /* Search specified block and its superiors. Don't search
1956 STATIC_BLOCK or GLOBAL_BLOCK. */
1958 result
= lookup_local_symbol (name
, block
, domain
, language
);
1959 if (result
.symbol
!= NULL
)
1961 if (symbol_lookup_debug
)
1963 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
1964 host_address_to_string (result
.symbol
));
1969 /* If requested to do so by the caller and if appropriate for LANGUAGE,
1970 check to see if NAME is a field of `this'. */
1972 langdef
= language_def (language
);
1974 /* Don't do this check if we are searching for a struct. It will
1975 not be found by check_field, but will be found by other
1977 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
1979 result
= lookup_language_this (langdef
, block
);
1983 struct type
*t
= result
.symbol
->type
;
1985 /* I'm not really sure that type of this can ever
1986 be typedefed; just be safe. */
1987 t
= check_typedef (t
);
1988 if (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
1989 t
= TYPE_TARGET_TYPE (t
);
1991 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1992 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1993 error (_("Internal error: `%s' is not an aggregate"),
1994 langdef
->la_name_of_this
);
1996 if (check_field (t
, name
, is_a_field_of_this
))
1998 if (symbol_lookup_debug
)
2000 fprintf_unfiltered (gdb_stdlog
,
2001 "lookup_symbol_aux (...) = NULL\n");
2003 return (struct block_symbol
) {NULL
, NULL
};
2008 /* Now do whatever is appropriate for LANGUAGE to look
2009 up static and global variables. */
2011 result
= langdef
->la_lookup_symbol_nonlocal (langdef
, name
, block
, domain
);
2012 if (result
.symbol
!= NULL
)
2014 if (symbol_lookup_debug
)
2016 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2017 host_address_to_string (result
.symbol
));
2022 /* Now search all static file-level symbols. Not strictly correct,
2023 but more useful than an error. */
2025 result
= lookup_static_symbol (name
, domain
);
2026 if (symbol_lookup_debug
)
2028 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2029 result
.symbol
!= NULL
2030 ? host_address_to_string (result
.symbol
)
2036 /* Check to see if the symbol is defined in BLOCK or its superiors.
2037 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2039 static struct block_symbol
2040 lookup_local_symbol (const char *name
, const struct block
*block
,
2041 const domain_enum domain
,
2042 enum language language
)
2045 const struct block
*static_block
= block_static_block (block
);
2046 const char *scope
= block_scope (block
);
2048 /* Check if either no block is specified or it's a global block. */
2050 if (static_block
== NULL
)
2051 return (struct block_symbol
) {NULL
, NULL
};
2053 while (block
!= static_block
)
2055 sym
= lookup_symbol_in_block (name
, block
, domain
);
2057 return (struct block_symbol
) {sym
, block
};
2059 if (language
== language_cplus
|| language
== language_fortran
)
2061 struct block_symbol sym
2062 = cp_lookup_symbol_imports_or_template (scope
, name
, block
,
2065 if (sym
.symbol
!= NULL
)
2069 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
2071 block
= BLOCK_SUPERBLOCK (block
);
2074 /* We've reached the end of the function without finding a result. */
2076 return (struct block_symbol
) {NULL
, NULL
};
2082 lookup_objfile_from_block (const struct block
*block
)
2084 struct objfile
*obj
;
2085 struct compunit_symtab
*cust
;
2090 block
= block_global_block (block
);
2091 /* Look through all blockvectors. */
2092 ALL_COMPUNITS (obj
, cust
)
2093 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
2096 if (obj
->separate_debug_objfile_backlink
)
2097 obj
= obj
->separate_debug_objfile_backlink
;
2108 lookup_symbol_in_block (const char *name
, const struct block
*block
,
2109 const domain_enum domain
)
2113 if (symbol_lookup_debug
> 1)
2115 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2117 fprintf_unfiltered (gdb_stdlog
,
2118 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2119 name
, host_address_to_string (block
),
2120 objfile_debug_name (objfile
),
2121 domain_name (domain
));
2124 sym
= block_lookup_symbol (block
, name
, domain
);
2127 if (symbol_lookup_debug
> 1)
2129 fprintf_unfiltered (gdb_stdlog
, " = %s\n",
2130 host_address_to_string (sym
));
2132 return fixup_symbol_section (sym
, NULL
);
2135 if (symbol_lookup_debug
> 1)
2136 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2143 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
2145 const domain_enum domain
)
2147 struct objfile
*objfile
;
2149 for (objfile
= main_objfile
;
2151 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
2153 struct block_symbol result
2154 = lookup_symbol_in_objfile (objfile
, GLOBAL_BLOCK
, name
, domain
);
2156 if (result
.symbol
!= NULL
)
2160 return (struct block_symbol
) {NULL
, NULL
};
2163 /* Check to see if the symbol is defined in one of the OBJFILE's
2164 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2165 depending on whether or not we want to search global symbols or
2168 static struct block_symbol
2169 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
, int block_index
,
2170 const char *name
, const domain_enum domain
)
2172 struct compunit_symtab
*cust
;
2174 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2176 if (symbol_lookup_debug
> 1)
2178 fprintf_unfiltered (gdb_stdlog
,
2179 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2180 objfile_debug_name (objfile
),
2181 block_index
== GLOBAL_BLOCK
2182 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2183 name
, domain_name (domain
));
2186 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
2188 const struct blockvector
*bv
;
2189 const struct block
*block
;
2190 struct block_symbol result
;
2192 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2193 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2194 result
.symbol
= block_lookup_symbol_primary (block
, name
, domain
);
2195 result
.block
= block
;
2196 if (result
.symbol
!= NULL
)
2198 if (symbol_lookup_debug
> 1)
2200 fprintf_unfiltered (gdb_stdlog
, " = %s (block %s)\n",
2201 host_address_to_string (result
.symbol
),
2202 host_address_to_string (block
));
2204 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2210 if (symbol_lookup_debug
> 1)
2211 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2212 return (struct block_symbol
) {NULL
, NULL
};
2215 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2216 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2217 and all associated separate debug objfiles.
2219 Normally we only look in OBJFILE, and not any separate debug objfiles
2220 because the outer loop will cause them to be searched too. This case is
2221 different. Here we're called from search_symbols where it will only
2222 call us for the the objfile that contains a matching minsym. */
2224 static struct block_symbol
2225 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
2226 const char *linkage_name
,
2229 enum language lang
= current_language
->la_language
;
2230 struct objfile
*main_objfile
, *cur_objfile
;
2232 demangle_result_storage storage
;
2233 const char *modified_name
= demangle_for_lookup (linkage_name
, lang
, storage
);
2235 if (objfile
->separate_debug_objfile_backlink
)
2236 main_objfile
= objfile
->separate_debug_objfile_backlink
;
2238 main_objfile
= objfile
;
2240 for (cur_objfile
= main_objfile
;
2242 cur_objfile
= objfile_separate_debug_iterate (main_objfile
, cur_objfile
))
2244 struct block_symbol result
;
2246 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
2247 modified_name
, domain
);
2248 if (result
.symbol
== NULL
)
2249 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
2250 modified_name
, domain
);
2251 if (result
.symbol
!= NULL
)
2255 return (struct block_symbol
) {NULL
, NULL
};
2258 /* A helper function that throws an exception when a symbol was found
2259 in a psymtab but not in a symtab. */
2261 static void ATTRIBUTE_NORETURN
2262 error_in_psymtab_expansion (int block_index
, const char *name
,
2263 struct compunit_symtab
*cust
)
2266 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2267 %s may be an inlined function, or may be a template function\n \
2268 (if a template, try specifying an instantiation: %s<type>)."),
2269 block_index
== GLOBAL_BLOCK
? "global" : "static",
2271 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
2275 /* A helper function for various lookup routines that interfaces with
2276 the "quick" symbol table functions. */
2278 static struct block_symbol
2279 lookup_symbol_via_quick_fns (struct objfile
*objfile
, int block_index
,
2280 const char *name
, const domain_enum domain
)
2282 struct compunit_symtab
*cust
;
2283 const struct blockvector
*bv
;
2284 const struct block
*block
;
2285 struct block_symbol result
;
2288 return (struct block_symbol
) {NULL
, NULL
};
2290 if (symbol_lookup_debug
> 1)
2292 fprintf_unfiltered (gdb_stdlog
,
2293 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2294 objfile_debug_name (objfile
),
2295 block_index
== GLOBAL_BLOCK
2296 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2297 name
, domain_name (domain
));
2300 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
2303 if (symbol_lookup_debug
> 1)
2305 fprintf_unfiltered (gdb_stdlog
,
2306 "lookup_symbol_via_quick_fns (...) = NULL\n");
2308 return (struct block_symbol
) {NULL
, NULL
};
2311 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2312 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2313 result
.symbol
= block_lookup_symbol (block
, name
, domain
);
2314 if (result
.symbol
== NULL
)
2315 error_in_psymtab_expansion (block_index
, name
, cust
);
2317 if (symbol_lookup_debug
> 1)
2319 fprintf_unfiltered (gdb_stdlog
,
2320 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2321 host_address_to_string (result
.symbol
),
2322 host_address_to_string (block
));
2325 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2326 result
.block
= block
;
2333 basic_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2335 const struct block
*block
,
2336 const domain_enum domain
)
2338 struct block_symbol result
;
2340 /* NOTE: carlton/2003-05-19: The comments below were written when
2341 this (or what turned into this) was part of lookup_symbol_aux;
2342 I'm much less worried about these questions now, since these
2343 decisions have turned out well, but I leave these comments here
2346 /* NOTE: carlton/2002-12-05: There is a question as to whether or
2347 not it would be appropriate to search the current global block
2348 here as well. (That's what this code used to do before the
2349 is_a_field_of_this check was moved up.) On the one hand, it's
2350 redundant with the lookup in all objfiles search that happens
2351 next. On the other hand, if decode_line_1 is passed an argument
2352 like filename:var, then the user presumably wants 'var' to be
2353 searched for in filename. On the third hand, there shouldn't be
2354 multiple global variables all of which are named 'var', and it's
2355 not like decode_line_1 has ever restricted its search to only
2356 global variables in a single filename. All in all, only
2357 searching the static block here seems best: it's correct and it's
2360 /* NOTE: carlton/2002-12-05: There's also a possible performance
2361 issue here: if you usually search for global symbols in the
2362 current file, then it would be slightly better to search the
2363 current global block before searching all the symtabs. But there
2364 are other factors that have a much greater effect on performance
2365 than that one, so I don't think we should worry about that for
2368 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2369 the current objfile. Searching the current objfile first is useful
2370 for both matching user expectations as well as performance. */
2372 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2373 if (result
.symbol
!= NULL
)
2376 /* If we didn't find a definition for a builtin type in the static block,
2377 search for it now. This is actually the right thing to do and can be
2378 a massive performance win. E.g., when debugging a program with lots of
2379 shared libraries we could search all of them only to find out the
2380 builtin type isn't defined in any of them. This is common for types
2382 if (domain
== VAR_DOMAIN
)
2384 struct gdbarch
*gdbarch
;
2387 gdbarch
= target_gdbarch ();
2389 gdbarch
= block_gdbarch (block
);
2390 result
.symbol
= language_lookup_primitive_type_as_symbol (langdef
,
2392 result
.block
= NULL
;
2393 if (result
.symbol
!= NULL
)
2397 return lookup_global_symbol (name
, block
, domain
);
2403 lookup_symbol_in_static_block (const char *name
,
2404 const struct block
*block
,
2405 const domain_enum domain
)
2407 const struct block
*static_block
= block_static_block (block
);
2410 if (static_block
== NULL
)
2411 return (struct block_symbol
) {NULL
, NULL
};
2413 if (symbol_lookup_debug
)
2415 struct objfile
*objfile
= lookup_objfile_from_block (static_block
);
2417 fprintf_unfiltered (gdb_stdlog
,
2418 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2421 host_address_to_string (block
),
2422 objfile_debug_name (objfile
),
2423 domain_name (domain
));
2426 sym
= lookup_symbol_in_block (name
, static_block
, domain
);
2427 if (symbol_lookup_debug
)
2429 fprintf_unfiltered (gdb_stdlog
,
2430 "lookup_symbol_in_static_block (...) = %s\n",
2431 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
2433 return (struct block_symbol
) {sym
, static_block
};
2436 /* Perform the standard symbol lookup of NAME in OBJFILE:
2437 1) First search expanded symtabs, and if not found
2438 2) Search the "quick" symtabs (partial or .gdb_index).
2439 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2441 static struct block_symbol
2442 lookup_symbol_in_objfile (struct objfile
*objfile
, int block_index
,
2443 const char *name
, const domain_enum domain
)
2445 struct block_symbol result
;
2447 if (symbol_lookup_debug
)
2449 fprintf_unfiltered (gdb_stdlog
,
2450 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2451 objfile_debug_name (objfile
),
2452 block_index
== GLOBAL_BLOCK
2453 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2454 name
, domain_name (domain
));
2457 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
2459 if (result
.symbol
!= NULL
)
2461 if (symbol_lookup_debug
)
2463 fprintf_unfiltered (gdb_stdlog
,
2464 "lookup_symbol_in_objfile (...) = %s"
2466 host_address_to_string (result
.symbol
));
2471 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
2473 if (symbol_lookup_debug
)
2475 fprintf_unfiltered (gdb_stdlog
,
2476 "lookup_symbol_in_objfile (...) = %s%s\n",
2477 result
.symbol
!= NULL
2478 ? host_address_to_string (result
.symbol
)
2480 result
.symbol
!= NULL
? " (via quick fns)" : "");
2488 lookup_static_symbol (const char *name
, const domain_enum domain
)
2490 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2491 struct objfile
*objfile
;
2492 struct block_symbol result
;
2493 struct block_symbol_cache
*bsc
;
2494 struct symbol_cache_slot
*slot
;
2496 /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
2497 NULL for OBJFILE_CONTEXT. */
2498 result
= symbol_cache_lookup (cache
, NULL
, STATIC_BLOCK
, name
, domain
,
2500 if (result
.symbol
!= NULL
)
2502 if (SYMBOL_LOOKUP_FAILED_P (result
))
2503 return (struct block_symbol
) {NULL
, NULL
};
2507 ALL_OBJFILES (objfile
)
2509 result
= lookup_symbol_in_objfile (objfile
, STATIC_BLOCK
, name
, domain
);
2510 if (result
.symbol
!= NULL
)
2512 /* Still pass NULL for OBJFILE_CONTEXT here. */
2513 symbol_cache_mark_found (bsc
, slot
, NULL
, result
.symbol
,
2519 /* Still pass NULL for OBJFILE_CONTEXT here. */
2520 symbol_cache_mark_not_found (bsc
, slot
, NULL
, name
, domain
);
2521 return (struct block_symbol
) {NULL
, NULL
};
2524 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2526 struct global_sym_lookup_data
2528 /* The name of the symbol we are searching for. */
2531 /* The domain to use for our search. */
2534 /* The field where the callback should store the symbol if found.
2535 It should be initialized to {NULL, NULL} before the search is started. */
2536 struct block_symbol result
;
2539 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2540 It searches by name for a symbol in the GLOBAL_BLOCK of the given
2541 OBJFILE. The arguments for the search are passed via CB_DATA,
2542 which in reality is a pointer to struct global_sym_lookup_data. */
2545 lookup_symbol_global_iterator_cb (struct objfile
*objfile
,
2548 struct global_sym_lookup_data
*data
=
2549 (struct global_sym_lookup_data
*) cb_data
;
2551 gdb_assert (data
->result
.symbol
== NULL
2552 && data
->result
.block
== NULL
);
2554 data
->result
= lookup_symbol_in_objfile (objfile
, GLOBAL_BLOCK
,
2555 data
->name
, data
->domain
);
2557 /* If we found a match, tell the iterator to stop. Otherwise,
2559 return (data
->result
.symbol
!= NULL
);
2565 lookup_global_symbol (const char *name
,
2566 const struct block
*block
,
2567 const domain_enum domain
)
2569 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2570 struct block_symbol result
;
2571 struct objfile
*objfile
;
2572 struct global_sym_lookup_data lookup_data
;
2573 struct block_symbol_cache
*bsc
;
2574 struct symbol_cache_slot
*slot
;
2576 objfile
= lookup_objfile_from_block (block
);
2578 /* First see if we can find the symbol in the cache.
2579 This works because we use the current objfile to qualify the lookup. */
2580 result
= symbol_cache_lookup (cache
, objfile
, GLOBAL_BLOCK
, name
, domain
,
2582 if (result
.symbol
!= NULL
)
2584 if (SYMBOL_LOOKUP_FAILED_P (result
))
2585 return (struct block_symbol
) {NULL
, NULL
};
2589 /* Call library-specific lookup procedure. */
2590 if (objfile
!= NULL
)
2591 result
= solib_global_lookup (objfile
, name
, domain
);
2593 /* If that didn't work go a global search (of global blocks, heh). */
2594 if (result
.symbol
== NULL
)
2596 memset (&lookup_data
, 0, sizeof (lookup_data
));
2597 lookup_data
.name
= name
;
2598 lookup_data
.domain
= domain
;
2599 gdbarch_iterate_over_objfiles_in_search_order
2600 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
2601 lookup_symbol_global_iterator_cb
, &lookup_data
, objfile
);
2602 result
= lookup_data
.result
;
2605 if (result
.symbol
!= NULL
)
2606 symbol_cache_mark_found (bsc
, slot
, objfile
, result
.symbol
, result
.block
);
2608 symbol_cache_mark_not_found (bsc
, slot
, objfile
, name
, domain
);
2614 symbol_matches_domain (enum language symbol_language
,
2615 domain_enum symbol_domain
,
2618 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2619 Similarly, any Ada type declaration implicitly defines a typedef. */
2620 if (symbol_language
== language_cplus
2621 || symbol_language
== language_d
2622 || symbol_language
== language_ada
2623 || symbol_language
== language_rust
)
2625 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
2626 && symbol_domain
== STRUCT_DOMAIN
)
2629 /* For all other languages, strict match is required. */
2630 return (symbol_domain
== domain
);
2636 lookup_transparent_type (const char *name
)
2638 return current_language
->la_lookup_transparent_type (name
);
2641 /* A helper for basic_lookup_transparent_type that interfaces with the
2642 "quick" symbol table functions. */
2644 static struct type
*
2645 basic_lookup_transparent_type_quick (struct objfile
*objfile
, int block_index
,
2648 struct compunit_symtab
*cust
;
2649 const struct blockvector
*bv
;
2650 struct block
*block
;
2655 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
2660 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2661 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2662 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2663 block_find_non_opaque_type
, NULL
);
2665 error_in_psymtab_expansion (block_index
, name
, cust
);
2666 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2667 return SYMBOL_TYPE (sym
);
2670 /* Subroutine of basic_lookup_transparent_type to simplify it.
2671 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2672 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2674 static struct type
*
2675 basic_lookup_transparent_type_1 (struct objfile
*objfile
, int block_index
,
2678 const struct compunit_symtab
*cust
;
2679 const struct blockvector
*bv
;
2680 const struct block
*block
;
2681 const struct symbol
*sym
;
2683 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
2685 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2686 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2687 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2688 block_find_non_opaque_type
, NULL
);
2691 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2692 return SYMBOL_TYPE (sym
);
2699 /* The standard implementation of lookup_transparent_type. This code
2700 was modeled on lookup_symbol -- the parts not relevant to looking
2701 up types were just left out. In particular it's assumed here that
2702 types are available in STRUCT_DOMAIN and only in file-static or
2706 basic_lookup_transparent_type (const char *name
)
2708 struct objfile
*objfile
;
2711 /* Now search all the global symbols. Do the symtab's first, then
2712 check the psymtab's. If a psymtab indicates the existence
2713 of the desired name as a global, then do psymtab-to-symtab
2714 conversion on the fly and return the found symbol. */
2716 ALL_OBJFILES (objfile
)
2718 t
= basic_lookup_transparent_type_1 (objfile
, GLOBAL_BLOCK
, name
);
2723 ALL_OBJFILES (objfile
)
2725 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
2730 /* Now search the static file-level symbols.
2731 Not strictly correct, but more useful than an error.
2732 Do the symtab's first, then
2733 check the psymtab's. If a psymtab indicates the existence
2734 of the desired name as a file-level static, then do psymtab-to-symtab
2735 conversion on the fly and return the found symbol. */
2737 ALL_OBJFILES (objfile
)
2739 t
= basic_lookup_transparent_type_1 (objfile
, STATIC_BLOCK
, name
);
2744 ALL_OBJFILES (objfile
)
2746 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
2751 return (struct type
*) 0;
2754 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2756 For each symbol that matches, CALLBACK is called. The symbol is
2757 passed to the callback.
2759 If CALLBACK returns false, the iteration ends. Otherwise, the
2760 search continues. */
2763 iterate_over_symbols (const struct block
*block
, const char *name
,
2764 const domain_enum domain
,
2765 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2767 struct block_iterator iter
;
2770 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2772 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2773 SYMBOL_DOMAIN (sym
), domain
))
2775 if (!callback (sym
))
2781 /* Find the compunit symtab associated with PC and SECTION.
2782 This will read in debug info as necessary. */
2784 struct compunit_symtab
*
2785 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2787 struct compunit_symtab
*cust
;
2788 struct compunit_symtab
*best_cust
= NULL
;
2789 struct objfile
*objfile
;
2790 CORE_ADDR distance
= 0;
2791 struct bound_minimal_symbol msymbol
;
2793 /* If we know that this is not a text address, return failure. This is
2794 necessary because we loop based on the block's high and low code
2795 addresses, which do not include the data ranges, and because
2796 we call find_pc_sect_psymtab which has a similar restriction based
2797 on the partial_symtab's texthigh and textlow. */
2798 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2800 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
2801 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
2802 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
2803 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
2804 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
2807 /* Search all symtabs for the one whose file contains our address, and which
2808 is the smallest of all the ones containing the address. This is designed
2809 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2810 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2811 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2813 This happens for native ecoff format, where code from included files
2814 gets its own symtab. The symtab for the included file should have
2815 been read in already via the dependency mechanism.
2816 It might be swifter to create several symtabs with the same name
2817 like xcoff does (I'm not sure).
2819 It also happens for objfiles that have their functions reordered.
2820 For these, the symtab we are looking for is not necessarily read in. */
2822 ALL_COMPUNITS (objfile
, cust
)
2825 const struct blockvector
*bv
;
2827 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2828 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2830 if (BLOCK_START (b
) <= pc
2831 && BLOCK_END (b
) > pc
2833 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2835 /* For an objfile that has its functions reordered,
2836 find_pc_psymtab will find the proper partial symbol table
2837 and we simply return its corresponding symtab. */
2838 /* In order to better support objfiles that contain both
2839 stabs and coff debugging info, we continue on if a psymtab
2841 if ((objfile
->flags
& OBJF_REORDERED
) && objfile
->sf
)
2843 struct compunit_symtab
*result
;
2846 = objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
,
2855 struct block_iterator iter
;
2856 struct symbol
*sym
= NULL
;
2858 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2860 fixup_symbol_section (sym
, objfile
);
2861 if (matching_obj_sections (SYMBOL_OBJ_SECTION (objfile
, sym
),
2866 continue; /* No symbol in this symtab matches
2869 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2874 if (best_cust
!= NULL
)
2877 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2879 ALL_OBJFILES (objfile
)
2881 struct compunit_symtab
*result
;
2885 result
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
,
2896 /* Find the compunit symtab associated with PC.
2897 This will read in debug info as necessary.
2898 Backward compatibility, no section. */
2900 struct compunit_symtab
*
2901 find_pc_compunit_symtab (CORE_ADDR pc
)
2903 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2907 /* Find the source file and line number for a given PC value and SECTION.
2908 Return a structure containing a symtab pointer, a line number,
2909 and a pc range for the entire source line.
2910 The value's .pc field is NOT the specified pc.
2911 NOTCURRENT nonzero means, if specified pc is on a line boundary,
2912 use the line that ends there. Otherwise, in that case, the line
2913 that begins there is used. */
2915 /* The big complication here is that a line may start in one file, and end just
2916 before the start of another file. This usually occurs when you #include
2917 code in the middle of a subroutine. To properly find the end of a line's PC
2918 range, we must search all symtabs associated with this compilation unit, and
2919 find the one whose first PC is closer than that of the next line in this
2922 /* If it's worth the effort, we could be using a binary search. */
2924 struct symtab_and_line
2925 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
2927 struct compunit_symtab
*cust
;
2928 struct symtab
*iter_s
;
2929 struct linetable
*l
;
2932 struct linetable_entry
*item
;
2933 const struct blockvector
*bv
;
2934 struct bound_minimal_symbol msymbol
;
2936 /* Info on best line seen so far, and where it starts, and its file. */
2938 struct linetable_entry
*best
= NULL
;
2939 CORE_ADDR best_end
= 0;
2940 struct symtab
*best_symtab
= 0;
2942 /* Store here the first line number
2943 of a file which contains the line at the smallest pc after PC.
2944 If we don't find a line whose range contains PC,
2945 we will use a line one less than this,
2946 with a range from the start of that file to the first line's pc. */
2947 struct linetable_entry
*alt
= NULL
;
2949 /* Info on best line seen in this file. */
2951 struct linetable_entry
*prev
;
2953 /* If this pc is not from the current frame,
2954 it is the address of the end of a call instruction.
2955 Quite likely that is the start of the following statement.
2956 But what we want is the statement containing the instruction.
2957 Fudge the pc to make sure we get that. */
2959 /* It's tempting to assume that, if we can't find debugging info for
2960 any function enclosing PC, that we shouldn't search for line
2961 number info, either. However, GAS can emit line number info for
2962 assembly files --- very helpful when debugging hand-written
2963 assembly code. In such a case, we'd have no debug info for the
2964 function, but we would have line info. */
2969 /* elz: added this because this function returned the wrong
2970 information if the pc belongs to a stub (import/export)
2971 to call a shlib function. This stub would be anywhere between
2972 two functions in the target, and the line info was erroneously
2973 taken to be the one of the line before the pc. */
2975 /* RT: Further explanation:
2977 * We have stubs (trampolines) inserted between procedures.
2979 * Example: "shr1" exists in a shared library, and a "shr1" stub also
2980 * exists in the main image.
2982 * In the minimal symbol table, we have a bunch of symbols
2983 * sorted by start address. The stubs are marked as "trampoline",
2984 * the others appear as text. E.g.:
2986 * Minimal symbol table for main image
2987 * main: code for main (text symbol)
2988 * shr1: stub (trampoline symbol)
2989 * foo: code for foo (text symbol)
2991 * Minimal symbol table for "shr1" image:
2993 * shr1: code for shr1 (text symbol)
2996 * So the code below is trying to detect if we are in the stub
2997 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
2998 * and if found, do the symbolization from the real-code address
2999 * rather than the stub address.
3001 * Assumptions being made about the minimal symbol table:
3002 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3003 * if we're really in the trampoline.s If we're beyond it (say
3004 * we're in "foo" in the above example), it'll have a closer
3005 * symbol (the "foo" text symbol for example) and will not
3006 * return the trampoline.
3007 * 2. lookup_minimal_symbol_text() will find a real text symbol
3008 * corresponding to the trampoline, and whose address will
3009 * be different than the trampoline address. I put in a sanity
3010 * check for the address being the same, to avoid an
3011 * infinite recursion.
3013 msymbol
= lookup_minimal_symbol_by_pc (pc
);
3014 if (msymbol
.minsym
!= NULL
)
3015 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
3017 struct bound_minimal_symbol mfunsym
3018 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
3021 if (mfunsym
.minsym
== NULL
)
3022 /* I eliminated this warning since it is coming out
3023 * in the following situation:
3024 * gdb shmain // test program with shared libraries
3025 * (gdb) break shr1 // function in shared lib
3026 * Warning: In stub for ...
3027 * In the above situation, the shared lib is not loaded yet,
3028 * so of course we can't find the real func/line info,
3029 * but the "break" still works, and the warning is annoying.
3030 * So I commented out the warning. RT */
3031 /* warning ("In stub for %s; unable to find real function/line info",
3032 SYMBOL_LINKAGE_NAME (msymbol)); */
3035 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
3036 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
3037 /* Avoid infinite recursion */
3038 /* See above comment about why warning is commented out. */
3039 /* warning ("In stub for %s; unable to find real function/line info",
3040 SYMBOL_LINKAGE_NAME (msymbol)); */
3044 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
3047 symtab_and_line val
;
3048 val
.pspace
= current_program_space
;
3050 cust
= find_pc_sect_compunit_symtab (pc
, section
);
3053 /* If no symbol information, return previous pc. */
3060 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3062 /* Look at all the symtabs that share this blockvector.
3063 They all have the same apriori range, that we found was right;
3064 but they have different line tables. */
3066 ALL_COMPUNIT_FILETABS (cust
, iter_s
)
3068 /* Find the best line in this symtab. */
3069 l
= SYMTAB_LINETABLE (iter_s
);
3075 /* I think len can be zero if the symtab lacks line numbers
3076 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3077 I'm not sure which, and maybe it depends on the symbol
3083 item
= l
->item
; /* Get first line info. */
3085 /* Is this file's first line closer than the first lines of other files?
3086 If so, record this file, and its first line, as best alternate. */
3087 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
3090 for (i
= 0; i
< len
; i
++, item
++)
3092 /* Leave prev pointing to the linetable entry for the last line
3093 that started at or before PC. */
3100 /* At this point, prev points at the line whose start addr is <= pc, and
3101 item points at the next line. If we ran off the end of the linetable
3102 (pc >= start of the last line), then prev == item. If pc < start of
3103 the first line, prev will not be set. */
3105 /* Is this file's best line closer than the best in the other files?
3106 If so, record this file, and its best line, as best so far. Don't
3107 save prev if it represents the end of a function (i.e. line number
3108 0) instead of a real line. */
3110 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
3113 best_symtab
= iter_s
;
3115 /* Discard BEST_END if it's before the PC of the current BEST. */
3116 if (best_end
<= best
->pc
)
3120 /* If another line (denoted by ITEM) is in the linetable and its
3121 PC is after BEST's PC, but before the current BEST_END, then
3122 use ITEM's PC as the new best_end. */
3123 if (best
&& i
< len
&& item
->pc
> best
->pc
3124 && (best_end
== 0 || best_end
> item
->pc
))
3125 best_end
= item
->pc
;
3130 /* If we didn't find any line number info, just return zeros.
3131 We used to return alt->line - 1 here, but that could be
3132 anywhere; if we don't have line number info for this PC,
3133 don't make some up. */
3136 else if (best
->line
== 0)
3138 /* If our best fit is in a range of PC's for which no line
3139 number info is available (line number is zero) then we didn't
3140 find any valid line information. */
3145 val
.symtab
= best_symtab
;
3146 val
.line
= best
->line
;
3148 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
3153 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3155 val
.section
= section
;
3159 /* Backward compatibility (no section). */
3161 struct symtab_and_line
3162 find_pc_line (CORE_ADDR pc
, int notcurrent
)
3164 struct obj_section
*section
;
3166 section
= find_pc_overlay (pc
);
3167 if (pc_in_unmapped_range (pc
, section
))
3168 pc
= overlay_mapped_address (pc
, section
);
3169 return find_pc_sect_line (pc
, section
, notcurrent
);
3175 find_pc_line_symtab (CORE_ADDR pc
)
3177 struct symtab_and_line sal
;
3179 /* This always passes zero for NOTCURRENT to find_pc_line.
3180 There are currently no callers that ever pass non-zero. */
3181 sal
= find_pc_line (pc
, 0);
3185 /* Find line number LINE in any symtab whose name is the same as
3188 If found, return the symtab that contains the linetable in which it was
3189 found, set *INDEX to the index in the linetable of the best entry
3190 found, and set *EXACT_MATCH nonzero if the value returned is an
3193 If not found, return NULL. */
3196 find_line_symtab (struct symtab
*symtab
, int line
,
3197 int *index
, int *exact_match
)
3199 int exact
= 0; /* Initialized here to avoid a compiler warning. */
3201 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3205 struct linetable
*best_linetable
;
3206 struct symtab
*best_symtab
;
3208 /* First try looking it up in the given symtab. */
3209 best_linetable
= SYMTAB_LINETABLE (symtab
);
3210 best_symtab
= symtab
;
3211 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
3212 if (best_index
< 0 || !exact
)
3214 /* Didn't find an exact match. So we better keep looking for
3215 another symtab with the same name. In the case of xcoff,
3216 multiple csects for one source file (produced by IBM's FORTRAN
3217 compiler) produce multiple symtabs (this is unavoidable
3218 assuming csects can be at arbitrary places in memory and that
3219 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3221 /* BEST is the smallest linenumber > LINE so far seen,
3222 or 0 if none has been seen so far.
3223 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3226 struct objfile
*objfile
;
3227 struct compunit_symtab
*cu
;
3230 if (best_index
>= 0)
3231 best
= best_linetable
->item
[best_index
].line
;
3235 ALL_OBJFILES (objfile
)
3238 objfile
->sf
->qf
->expand_symtabs_with_fullname (objfile
,
3239 symtab_to_fullname (symtab
));
3242 ALL_FILETABS (objfile
, cu
, s
)
3244 struct linetable
*l
;
3247 if (FILENAME_CMP (symtab
->filename
, s
->filename
) != 0)
3249 if (FILENAME_CMP (symtab_to_fullname (symtab
),
3250 symtab_to_fullname (s
)) != 0)
3252 l
= SYMTAB_LINETABLE (s
);
3253 ind
= find_line_common (l
, line
, &exact
, 0);
3263 if (best
== 0 || l
->item
[ind
].line
< best
)
3265 best
= l
->item
[ind
].line
;
3278 *index
= best_index
;
3280 *exact_match
= exact
;
3285 /* Given SYMTAB, returns all the PCs function in the symtab that
3286 exactly match LINE. Returns an empty vector if there are no exact
3287 matches, but updates BEST_ITEM in this case. */
3289 std::vector
<CORE_ADDR
>
3290 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
3291 struct linetable_entry
**best_item
)
3294 std::vector
<CORE_ADDR
> result
;
3296 /* First, collect all the PCs that are at this line. */
3302 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
3309 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
3311 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
3317 result
.push_back (SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
3325 /* Set the PC value for a given source file and line number and return true.
3326 Returns zero for invalid line number (and sets the PC to 0).
3327 The source file is specified with a struct symtab. */
3330 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
3332 struct linetable
*l
;
3339 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
3342 l
= SYMTAB_LINETABLE (symtab
);
3343 *pc
= l
->item
[ind
].pc
;
3350 /* Find the range of pc values in a line.
3351 Store the starting pc of the line into *STARTPTR
3352 and the ending pc (start of next line) into *ENDPTR.
3353 Returns 1 to indicate success.
3354 Returns 0 if could not find the specified line. */
3357 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
3360 CORE_ADDR startaddr
;
3361 struct symtab_and_line found_sal
;
3364 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
3367 /* This whole function is based on address. For example, if line 10 has
3368 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3369 "info line *0x123" should say the line goes from 0x100 to 0x200
3370 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3371 This also insures that we never give a range like "starts at 0x134
3372 and ends at 0x12c". */
3374 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
3375 if (found_sal
.line
!= sal
.line
)
3377 /* The specified line (sal) has zero bytes. */
3378 *startptr
= found_sal
.pc
;
3379 *endptr
= found_sal
.pc
;
3383 *startptr
= found_sal
.pc
;
3384 *endptr
= found_sal
.end
;
3389 /* Given a line table and a line number, return the index into the line
3390 table for the pc of the nearest line whose number is >= the specified one.
3391 Return -1 if none is found. The value is >= 0 if it is an index.
3392 START is the index at which to start searching the line table.
3394 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3397 find_line_common (struct linetable
*l
, int lineno
,
3398 int *exact_match
, int start
)
3403 /* BEST is the smallest linenumber > LINENO so far seen,
3404 or 0 if none has been seen so far.
3405 BEST_INDEX identifies the item for it. */
3407 int best_index
= -1;
3418 for (i
= start
; i
< len
; i
++)
3420 struct linetable_entry
*item
= &(l
->item
[i
]);
3422 if (item
->line
== lineno
)
3424 /* Return the first (lowest address) entry which matches. */
3429 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
3436 /* If we got here, we didn't get an exact match. */
3441 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
3443 struct symtab_and_line sal
;
3445 sal
= find_pc_line (pc
, 0);
3448 return sal
.symtab
!= 0;
3451 /* Given a function symbol SYM, find the symtab and line for the start
3453 If the argument FUNFIRSTLINE is nonzero, we want the first line
3454 of real code inside the function.
3455 This function should return SALs matching those from minsym_found,
3456 otherwise false multiple-locations breakpoints could be placed. */
3458 struct symtab_and_line
3459 find_function_start_sal (struct symbol
*sym
, int funfirstline
)
3461 fixup_symbol_section (sym
, NULL
);
3463 obj_section
*section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
3465 = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)), section
, 0);
3467 if (funfirstline
&& sal
.symtab
!= NULL
3468 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal
.symtab
))
3469 || SYMTAB_LANGUAGE (sal
.symtab
) == language_asm
))
3471 struct gdbarch
*gdbarch
= symbol_arch (sym
);
3473 sal
.pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
3474 if (gdbarch_skip_entrypoint_p (gdbarch
))
3475 sal
.pc
= gdbarch_skip_entrypoint (gdbarch
, sal
.pc
);
3479 /* We always should have a line for the function start address.
3480 If we don't, something is odd. Create a plain SAL refering
3481 just the PC and hope that skip_prologue_sal (if requested)
3482 can find a line number for after the prologue. */
3483 if (sal
.pc
< BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)))
3486 sal
.pspace
= current_program_space
;
3487 sal
.pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
3488 sal
.section
= section
;
3492 skip_prologue_sal (&sal
);
3497 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3498 address for that function that has an entry in SYMTAB's line info
3499 table. If such an entry cannot be found, return FUNC_ADDR
3503 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
3505 CORE_ADDR func_start
, func_end
;
3506 struct linetable
*l
;
3509 /* Give up if this symbol has no lineinfo table. */
3510 l
= SYMTAB_LINETABLE (symtab
);
3514 /* Get the range for the function's PC values, or give up if we
3515 cannot, for some reason. */
3516 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
3519 /* Linetable entries are ordered by PC values, see the commentary in
3520 symtab.h where `struct linetable' is defined. Thus, the first
3521 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3522 address we are looking for. */
3523 for (i
= 0; i
< l
->nitems
; i
++)
3525 struct linetable_entry
*item
= &(l
->item
[i
]);
3527 /* Don't use line numbers of zero, they mark special entries in
3528 the table. See the commentary on symtab.h before the
3529 definition of struct linetable. */
3530 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
3537 /* Adjust SAL to the first instruction past the function prologue.
3538 If the PC was explicitly specified, the SAL is not changed.
3539 If the line number was explicitly specified, at most the SAL's PC
3540 is updated. If SAL is already past the prologue, then do nothing. */
3543 skip_prologue_sal (struct symtab_and_line
*sal
)
3546 struct symtab_and_line start_sal
;
3547 CORE_ADDR pc
, saved_pc
;
3548 struct obj_section
*section
;
3550 struct objfile
*objfile
;
3551 struct gdbarch
*gdbarch
;
3552 const struct block
*b
, *function_block
;
3553 int force_skip
, skip
;
3555 /* Do not change the SAL if PC was specified explicitly. */
3556 if (sal
->explicit_pc
)
3559 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3561 switch_to_program_space_and_thread (sal
->pspace
);
3563 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
3566 fixup_symbol_section (sym
, NULL
);
3568 objfile
= symbol_objfile (sym
);
3569 pc
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
3570 section
= SYMBOL_OBJ_SECTION (objfile
, sym
);
3571 name
= SYMBOL_LINKAGE_NAME (sym
);
3575 struct bound_minimal_symbol msymbol
3576 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
3578 if (msymbol
.minsym
== NULL
)
3581 objfile
= msymbol
.objfile
;
3582 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
3583 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
3584 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
3587 gdbarch
= get_objfile_arch (objfile
);
3589 /* Process the prologue in two passes. In the first pass try to skip the
3590 prologue (SKIP is true) and verify there is a real need for it (indicated
3591 by FORCE_SKIP). If no such reason was found run a second pass where the
3592 prologue is not skipped (SKIP is false). */
3597 /* Be conservative - allow direct PC (without skipping prologue) only if we
3598 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3599 have to be set by the caller so we use SYM instead. */
3601 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym
))))
3609 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3610 so that gdbarch_skip_prologue has something unique to work on. */
3611 if (section_is_overlay (section
) && !section_is_mapped (section
))
3612 pc
= overlay_unmapped_address (pc
, section
);
3614 /* Skip "first line" of function (which is actually its prologue). */
3615 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3616 if (gdbarch_skip_entrypoint_p (gdbarch
))
3617 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
3619 pc
= gdbarch_skip_prologue_noexcept (gdbarch
, pc
);
3621 /* For overlays, map pc back into its mapped VMA range. */
3622 pc
= overlay_mapped_address (pc
, section
);
3624 /* Calculate line number. */
3625 start_sal
= find_pc_sect_line (pc
, section
, 0);
3627 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3628 line is still part of the same function. */
3629 if (skip
&& start_sal
.pc
!= pc
3630 && (sym
? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
3631 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
3632 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
3633 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
3635 /* First pc of next line */
3637 /* Recalculate the line number (might not be N+1). */
3638 start_sal
= find_pc_sect_line (pc
, section
, 0);
3641 /* On targets with executable formats that don't have a concept of
3642 constructors (ELF with .init has, PE doesn't), gcc emits a call
3643 to `__main' in `main' between the prologue and before user
3645 if (gdbarch_skip_main_prologue_p (gdbarch
)
3646 && name
&& strcmp_iw (name
, "main") == 0)
3648 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
3649 /* Recalculate the line number (might not be N+1). */
3650 start_sal
= find_pc_sect_line (pc
, section
, 0);
3654 while (!force_skip
&& skip
--);
3656 /* If we still don't have a valid source line, try to find the first
3657 PC in the lineinfo table that belongs to the same function. This
3658 happens with COFF debug info, which does not seem to have an
3659 entry in lineinfo table for the code after the prologue which has
3660 no direct relation to source. For example, this was found to be
3661 the case with the DJGPP target using "gcc -gcoff" when the
3662 compiler inserted code after the prologue to make sure the stack
3664 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
3666 pc
= skip_prologue_using_lineinfo (pc
, symbol_symtab (sym
));
3667 /* Recalculate the line number. */
3668 start_sal
= find_pc_sect_line (pc
, section
, 0);
3671 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3672 forward SAL to the end of the prologue. */
3677 sal
->section
= section
;
3679 /* Unless the explicit_line flag was set, update the SAL line
3680 and symtab to correspond to the modified PC location. */
3681 if (sal
->explicit_line
)
3684 sal
->symtab
= start_sal
.symtab
;
3685 sal
->line
= start_sal
.line
;
3686 sal
->end
= start_sal
.end
;
3688 /* Check if we are now inside an inlined function. If we can,
3689 use the call site of the function instead. */
3690 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
3691 function_block
= NULL
;
3694 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
3696 else if (BLOCK_FUNCTION (b
) != NULL
)
3698 b
= BLOCK_SUPERBLOCK (b
);
3700 if (function_block
!= NULL
3701 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
3703 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
3704 sal
->symtab
= symbol_symtab (BLOCK_FUNCTION (function_block
));
3708 /* Given PC at the function's start address, attempt to find the
3709 prologue end using SAL information. Return zero if the skip fails.
3711 A non-optimized prologue traditionally has one SAL for the function
3712 and a second for the function body. A single line function has
3713 them both pointing at the same line.
3715 An optimized prologue is similar but the prologue may contain
3716 instructions (SALs) from the instruction body. Need to skip those
3717 while not getting into the function body.
3719 The functions end point and an increasing SAL line are used as
3720 indicators of the prologue's endpoint.
3722 This code is based on the function refine_prologue_limit
3726 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
3728 struct symtab_and_line prologue_sal
;
3731 const struct block
*bl
;
3733 /* Get an initial range for the function. */
3734 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
3735 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3737 prologue_sal
= find_pc_line (start_pc
, 0);
3738 if (prologue_sal
.line
!= 0)
3740 /* For languages other than assembly, treat two consecutive line
3741 entries at the same address as a zero-instruction prologue.
3742 The GNU assembler emits separate line notes for each instruction
3743 in a multi-instruction macro, but compilers generally will not
3745 if (prologue_sal
.symtab
->language
!= language_asm
)
3747 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
3750 /* Skip any earlier lines, and any end-of-sequence marker
3751 from a previous function. */
3752 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
3753 || linetable
->item
[idx
].line
== 0)
3756 if (idx
+1 < linetable
->nitems
3757 && linetable
->item
[idx
+1].line
!= 0
3758 && linetable
->item
[idx
+1].pc
== start_pc
)
3762 /* If there is only one sal that covers the entire function,
3763 then it is probably a single line function, like
3765 if (prologue_sal
.end
>= end_pc
)
3768 while (prologue_sal
.end
< end_pc
)
3770 struct symtab_and_line sal
;
3772 sal
= find_pc_line (prologue_sal
.end
, 0);
3775 /* Assume that a consecutive SAL for the same (or larger)
3776 line mark the prologue -> body transition. */
3777 if (sal
.line
>= prologue_sal
.line
)
3779 /* Likewise if we are in a different symtab altogether
3780 (e.g. within a file included via #include). */
3781 if (sal
.symtab
!= prologue_sal
.symtab
)
3784 /* The line number is smaller. Check that it's from the
3785 same function, not something inlined. If it's inlined,
3786 then there is no point comparing the line numbers. */
3787 bl
= block_for_pc (prologue_sal
.end
);
3790 if (block_inlined_p (bl
))
3792 if (BLOCK_FUNCTION (bl
))
3797 bl
= BLOCK_SUPERBLOCK (bl
);
3802 /* The case in which compiler's optimizer/scheduler has
3803 moved instructions into the prologue. We look ahead in
3804 the function looking for address ranges whose
3805 corresponding line number is less the first one that we
3806 found for the function. This is more conservative then
3807 refine_prologue_limit which scans a large number of SALs
3808 looking for any in the prologue. */
3813 if (prologue_sal
.end
< end_pc
)
3814 /* Return the end of this line, or zero if we could not find a
3816 return prologue_sal
.end
;
3818 /* Don't return END_PC, which is past the end of the function. */
3819 return prologue_sal
.pc
;
3825 find_function_alias_target (bound_minimal_symbol msymbol
)
3827 if (!msymbol_is_text (msymbol
.minsym
))
3830 CORE_ADDR addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
3831 symbol
*sym
= find_pc_function (addr
);
3833 && SYMBOL_CLASS (sym
) == LOC_BLOCK
3834 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) == addr
)
3841 /* If P is of the form "operator[ \t]+..." where `...' is
3842 some legitimate operator text, return a pointer to the
3843 beginning of the substring of the operator text.
3844 Otherwise, return "". */
3847 operator_chars (const char *p
, const char **end
)
3850 if (!startswith (p
, CP_OPERATOR_STR
))
3852 p
+= CP_OPERATOR_LEN
;
3854 /* Don't get faked out by `operator' being part of a longer
3856 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
3859 /* Allow some whitespace between `operator' and the operator symbol. */
3860 while (*p
== ' ' || *p
== '\t')
3863 /* Recognize 'operator TYPENAME'. */
3865 if (isalpha (*p
) || *p
== '_' || *p
== '$')
3867 const char *q
= p
+ 1;
3869 while (isalnum (*q
) || *q
== '_' || *q
== '$')
3878 case '\\': /* regexp quoting */
3881 if (p
[2] == '=') /* 'operator\*=' */
3883 else /* 'operator\*' */
3887 else if (p
[1] == '[')
3890 error (_("mismatched quoting on brackets, "
3891 "try 'operator\\[\\]'"));
3892 else if (p
[2] == '\\' && p
[3] == ']')
3894 *end
= p
+ 4; /* 'operator\[\]' */
3898 error (_("nothing is allowed between '[' and ']'"));
3902 /* Gratuitous qoute: skip it and move on. */
3924 if (p
[0] == '-' && p
[1] == '>')
3926 /* Struct pointer member operator 'operator->'. */
3929 *end
= p
+ 3; /* 'operator->*' */
3932 else if (p
[2] == '\\')
3934 *end
= p
+ 4; /* Hopefully 'operator->\*' */
3939 *end
= p
+ 2; /* 'operator->' */
3943 if (p
[1] == '=' || p
[1] == p
[0])
3954 error (_("`operator ()' must be specified "
3955 "without whitespace in `()'"));
3960 error (_("`operator ?:' must be specified "
3961 "without whitespace in `?:'"));
3966 error (_("`operator []' must be specified "
3967 "without whitespace in `[]'"));
3971 error (_("`operator %s' not supported"), p
);
3980 /* Data structure to maintain printing state for output_source_filename. */
3982 struct output_source_filename_data
3984 /* Cache of what we've seen so far. */
3985 struct filename_seen_cache
*filename_seen_cache
;
3987 /* Flag of whether we're printing the first one. */
3991 /* Slave routine for sources_info. Force line breaks at ,'s.
3992 NAME is the name to print.
3993 DATA contains the state for printing and watching for duplicates. */
3996 output_source_filename (const char *name
,
3997 struct output_source_filename_data
*data
)
3999 /* Since a single source file can result in several partial symbol
4000 tables, we need to avoid printing it more than once. Note: if
4001 some of the psymtabs are read in and some are not, it gets
4002 printed both under "Source files for which symbols have been
4003 read" and "Source files for which symbols will be read in on
4004 demand". I consider this a reasonable way to deal with the
4005 situation. I'm not sure whether this can also happen for
4006 symtabs; it doesn't hurt to check. */
4008 /* Was NAME already seen? */
4009 if (data
->filename_seen_cache
->seen (name
))
4011 /* Yes; don't print it again. */
4015 /* No; print it and reset *FIRST. */
4017 printf_filtered (", ");
4021 fputs_filtered (name
, gdb_stdout
);
4024 /* A callback for map_partial_symbol_filenames. */
4027 output_partial_symbol_filename (const char *filename
, const char *fullname
,
4030 output_source_filename (fullname
? fullname
: filename
,
4031 (struct output_source_filename_data
*) data
);
4035 info_sources_command (char *ignore
, int from_tty
)
4037 struct compunit_symtab
*cu
;
4039 struct objfile
*objfile
;
4040 struct output_source_filename_data data
;
4042 if (!have_full_symbols () && !have_partial_symbols ())
4044 error (_("No symbol table is loaded. Use the \"file\" command."));
4047 filename_seen_cache filenames_seen
;
4049 data
.filename_seen_cache
= &filenames_seen
;
4051 printf_filtered ("Source files for which symbols have been read in:\n\n");
4054 ALL_FILETABS (objfile
, cu
, s
)
4056 const char *fullname
= symtab_to_fullname (s
);
4058 output_source_filename (fullname
, &data
);
4060 printf_filtered ("\n\n");
4062 printf_filtered ("Source files for which symbols "
4063 "will be read in on demand:\n\n");
4065 filenames_seen
.clear ();
4067 map_symbol_filenames (output_partial_symbol_filename
, &data
,
4068 1 /*need_fullname*/);
4069 printf_filtered ("\n");
4072 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4073 non-zero compare only lbasename of FILES. */
4076 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
4080 if (file
!= NULL
&& nfiles
!= 0)
4082 for (i
= 0; i
< nfiles
; i
++)
4084 if (compare_filenames_for_search (file
, (basenames
4085 ? lbasename (files
[i
])
4090 else if (nfiles
== 0)
4095 /* Free any memory associated with a search. */
4098 free_search_symbols (struct symbol_search
*symbols
)
4100 struct symbol_search
*p
;
4101 struct symbol_search
*next
;
4103 for (p
= symbols
; p
!= NULL
; p
= next
)
4111 do_free_search_symbols_cleanup (void *symbolsp
)
4113 struct symbol_search
*symbols
= *(struct symbol_search
**) symbolsp
;
4115 free_search_symbols (symbols
);
4119 make_cleanup_free_search_symbols (struct symbol_search
**symbolsp
)
4121 return make_cleanup (do_free_search_symbols_cleanup
, symbolsp
);
4124 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4125 sort symbols, not minimal symbols. */
4128 compare_search_syms (const void *sa
, const void *sb
)
4130 struct symbol_search
*sym_a
= *(struct symbol_search
**) sa
;
4131 struct symbol_search
*sym_b
= *(struct symbol_search
**) sb
;
4134 c
= FILENAME_CMP (symbol_symtab (sym_a
->symbol
)->filename
,
4135 symbol_symtab (sym_b
->symbol
)->filename
);
4139 if (sym_a
->block
!= sym_b
->block
)
4140 return sym_a
->block
- sym_b
->block
;
4142 return strcmp (SYMBOL_PRINT_NAME (sym_a
->symbol
),
4143 SYMBOL_PRINT_NAME (sym_b
->symbol
));
4146 /* Sort the NFOUND symbols in list FOUND and remove duplicates.
4147 The duplicates are freed, and the new list is returned in
4148 *NEW_HEAD, *NEW_TAIL. */
4151 sort_search_symbols_remove_dups (struct symbol_search
*found
, int nfound
,
4152 struct symbol_search
**new_head
,
4153 struct symbol_search
**new_tail
)
4155 struct symbol_search
**symbols
, *symp
;
4158 gdb_assert (found
!= NULL
&& nfound
> 0);
4160 /* Build an array out of the list so we can easily sort them. */
4161 symbols
= XNEWVEC (struct symbol_search
*, nfound
);
4164 for (i
= 0; i
< nfound
; i
++)
4166 gdb_assert (symp
!= NULL
);
4167 gdb_assert (symp
->block
>= 0 && symp
->block
<= 1);
4171 gdb_assert (symp
== NULL
);
4173 qsort (symbols
, nfound
, sizeof (struct symbol_search
*),
4174 compare_search_syms
);
4176 /* Collapse out the dups. */
4177 for (i
= 1, j
= 1; i
< nfound
; ++i
)
4179 if (compare_search_syms (&symbols
[j
- 1], &symbols
[i
]) != 0)
4180 symbols
[j
++] = symbols
[i
];
4185 symbols
[j
- 1]->next
= NULL
;
4187 /* Rebuild the linked list. */
4188 for (i
= 0; i
< nunique
- 1; i
++)
4189 symbols
[i
]->next
= symbols
[i
+ 1];
4190 symbols
[nunique
- 1]->next
= NULL
;
4192 *new_head
= symbols
[0];
4193 *new_tail
= symbols
[nunique
- 1];
4197 /* Search the symbol table for matches to the regular expression REGEXP,
4198 returning the results in *MATCHES.
4200 Only symbols of KIND are searched:
4201 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4202 and constants (enums)
4203 FUNCTIONS_DOMAIN - search all functions
4204 TYPES_DOMAIN - search all type names
4205 ALL_DOMAIN - an internal error for this function
4207 free_search_symbols should be called when *MATCHES is no longer needed.
4209 Within each file the results are sorted locally; each symtab's global and
4210 static blocks are separately alphabetized.
4211 Duplicate entries are removed. */
4214 search_symbols (const char *regexp
, enum search_domain kind
,
4215 int nfiles
, const char *files
[],
4216 struct symbol_search
**matches
)
4218 struct compunit_symtab
*cust
;
4219 const struct blockvector
*bv
;
4222 struct block_iterator iter
;
4224 struct objfile
*objfile
;
4225 struct minimal_symbol
*msymbol
;
4227 static const enum minimal_symbol_type types
[]
4228 = {mst_data
, mst_text
, mst_abs
};
4229 static const enum minimal_symbol_type types2
[]
4230 = {mst_bss
, mst_file_text
, mst_abs
};
4231 static const enum minimal_symbol_type types3
[]
4232 = {mst_file_data
, mst_solib_trampoline
, mst_abs
};
4233 static const enum minimal_symbol_type types4
[]
4234 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_abs
};
4235 enum minimal_symbol_type ourtype
;
4236 enum minimal_symbol_type ourtype2
;
4237 enum minimal_symbol_type ourtype3
;
4238 enum minimal_symbol_type ourtype4
;
4239 struct symbol_search
*found
;
4240 struct symbol_search
*tail
;
4242 gdb::optional
<compiled_regex
> preg
;
4244 /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
4245 CLEANUP_CHAIN is freed only in the case of an error. */
4246 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
4247 struct cleanup
*retval_chain
;
4249 gdb_assert (kind
<= TYPES_DOMAIN
);
4251 ourtype
= types
[kind
];
4252 ourtype2
= types2
[kind
];
4253 ourtype3
= types3
[kind
];
4254 ourtype4
= types4
[kind
];
4260 /* Make sure spacing is right for C++ operators.
4261 This is just a courtesy to make the matching less sensitive
4262 to how many spaces the user leaves between 'operator'
4263 and <TYPENAME> or <OPERATOR>. */
4265 const char *opname
= operator_chars (regexp
, &opend
);
4270 int fix
= -1; /* -1 means ok; otherwise number of
4273 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
4275 /* There should 1 space between 'operator' and 'TYPENAME'. */
4276 if (opname
[-1] != ' ' || opname
[-2] == ' ')
4281 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4282 if (opname
[-1] == ' ')
4285 /* If wrong number of spaces, fix it. */
4288 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
4290 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
4295 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4297 preg
.emplace (regexp
, cflags
, _("Invalid regexp"));
4300 /* Search through the partial symtabs *first* for all symbols
4301 matching the regexp. That way we don't have to reproduce all of
4302 the machinery below. */
4303 expand_symtabs_matching ([&] (const char *filename
, bool basenames
)
4305 return file_matches (filename
, files
, nfiles
,
4308 [&] (const char *symname
)
4310 return (!preg
|| preg
->exec (symname
,
4316 /* Here, we search through the minimal symbol tables for functions
4317 and variables that match, and force their symbols to be read.
4318 This is in particular necessary for demangled variable names,
4319 which are no longer put into the partial symbol tables.
4320 The symbol will then be found during the scan of symtabs below.
4322 For functions, find_pc_symtab should succeed if we have debug info
4323 for the function, for variables we have to call
4324 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4326 If the lookup fails, set found_misc so that we will rescan to print
4327 any matching symbols without debug info.
4328 We only search the objfile the msymbol came from, we no longer search
4329 all objfiles. In large programs (1000s of shared libs) searching all
4330 objfiles is not worth the pain. */
4332 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
4334 ALL_MSYMBOLS (objfile
, msymbol
)
4338 if (msymbol
->created_by_gdb
)
4341 if (MSYMBOL_TYPE (msymbol
) == ourtype
4342 || MSYMBOL_TYPE (msymbol
) == ourtype2
4343 || MSYMBOL_TYPE (msymbol
) == ourtype3
4344 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4347 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4350 /* Note: An important side-effect of these lookup functions
4351 is to expand the symbol table if msymbol is found, for the
4352 benefit of the next loop on ALL_COMPUNITS. */
4353 if (kind
== FUNCTIONS_DOMAIN
4354 ? (find_pc_compunit_symtab
4355 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
)) == NULL
)
4356 : (lookup_symbol_in_objfile_from_linkage_name
4357 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
4368 retval_chain
= make_cleanup_free_search_symbols (&found
);
4370 ALL_COMPUNITS (objfile
, cust
)
4372 bv
= COMPUNIT_BLOCKVECTOR (cust
);
4373 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
4375 b
= BLOCKVECTOR_BLOCK (bv
, i
);
4376 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4378 struct symtab
*real_symtab
= symbol_symtab (sym
);
4382 /* Check first sole REAL_SYMTAB->FILENAME. It does not need to be
4383 a substring of symtab_to_fullname as it may contain "./" etc. */
4384 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
4385 || ((basenames_may_differ
4386 || file_matches (lbasename (real_symtab
->filename
),
4388 && file_matches (symtab_to_fullname (real_symtab
),
4391 || preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
4393 && ((kind
== VARIABLES_DOMAIN
4394 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
4395 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
4396 && SYMBOL_CLASS (sym
) != LOC_BLOCK
4397 /* LOC_CONST can be used for more than just enums,
4398 e.g., c++ static const members.
4399 We only want to skip enums here. */
4400 && !(SYMBOL_CLASS (sym
) == LOC_CONST
4401 && (TYPE_CODE (SYMBOL_TYPE (sym
))
4402 == TYPE_CODE_ENUM
)))
4403 || (kind
== FUNCTIONS_DOMAIN
4404 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
4405 || (kind
== TYPES_DOMAIN
4406 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
4409 struct symbol_search
*psr
= XCNEW (struct symbol_search
);
4427 sort_search_symbols_remove_dups (found
, nfound
, &found
, &tail
);
4428 /* Note: nfound is no longer useful beyond this point. */
4431 /* If there are no eyes, avoid all contact. I mean, if there are
4432 no debug symbols, then add matching minsyms. */
4434 if (found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
4436 ALL_MSYMBOLS (objfile
, msymbol
)
4440 if (msymbol
->created_by_gdb
)
4443 if (MSYMBOL_TYPE (msymbol
) == ourtype
4444 || MSYMBOL_TYPE (msymbol
) == ourtype2
4445 || MSYMBOL_TYPE (msymbol
) == ourtype3
4446 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4448 if (!preg
|| preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4451 /* For functions we can do a quick check of whether the
4452 symbol might be found via find_pc_symtab. */
4453 if (kind
!= FUNCTIONS_DOMAIN
4454 || (find_pc_compunit_symtab
4455 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
)) == NULL
))
4457 if (lookup_symbol_in_objfile_from_linkage_name
4458 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
), VAR_DOMAIN
)
4462 struct symbol_search
*psr
= XNEW (struct symbol_search
);
4464 psr
->msymbol
.minsym
= msymbol
;
4465 psr
->msymbol
.objfile
= objfile
;
4480 discard_cleanups (retval_chain
);
4481 do_cleanups (old_chain
);
4485 /* Helper function for symtab_symbol_info, this function uses
4486 the data returned from search_symbols() to print information
4487 regarding the match to gdb_stdout. */
4490 print_symbol_info (enum search_domain kind
,
4492 int block
, const char *last
)
4494 struct symtab
*s
= symbol_symtab (sym
);
4495 const char *s_filename
= symtab_to_filename_for_display (s
);
4497 if (last
== NULL
|| filename_cmp (last
, s_filename
) != 0)
4499 fputs_filtered ("\nFile ", gdb_stdout
);
4500 fputs_filtered (s_filename
, gdb_stdout
);
4501 fputs_filtered (":\n", gdb_stdout
);
4504 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
4505 printf_filtered ("static ");
4507 /* Typedef that is not a C++ class. */
4508 if (kind
== TYPES_DOMAIN
4509 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
4510 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
4511 /* variable, func, or typedef-that-is-c++-class. */
4512 else if (kind
< TYPES_DOMAIN
4513 || (kind
== TYPES_DOMAIN
4514 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
4516 type_print (SYMBOL_TYPE (sym
),
4517 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4518 ? "" : SYMBOL_PRINT_NAME (sym
)),
4521 printf_filtered (";\n");
4525 /* This help function for symtab_symbol_info() prints information
4526 for non-debugging symbols to gdb_stdout. */
4529 print_msymbol_info (struct bound_minimal_symbol msymbol
)
4531 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
4534 if (gdbarch_addr_bit (gdbarch
) <= 32)
4535 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
4536 & (CORE_ADDR
) 0xffffffff,
4539 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
4541 printf_filtered ("%s %s\n",
4542 tmp
, MSYMBOL_PRINT_NAME (msymbol
.minsym
));
4545 /* This is the guts of the commands "info functions", "info types", and
4546 "info variables". It calls search_symbols to find all matches and then
4547 print_[m]symbol_info to print out some useful information about the
4551 symtab_symbol_info (char *regexp
, enum search_domain kind
, int from_tty
)
4553 static const char * const classnames
[] =
4554 {"variable", "function", "type"};
4555 struct symbol_search
*symbols
;
4556 struct symbol_search
*p
;
4557 struct cleanup
*old_chain
;
4558 const char *last_filename
= NULL
;
4561 gdb_assert (kind
<= TYPES_DOMAIN
);
4563 /* Must make sure that if we're interrupted, symbols gets freed. */
4564 search_symbols (regexp
, kind
, 0, NULL
, &symbols
);
4565 old_chain
= make_cleanup_free_search_symbols (&symbols
);
4568 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4569 classnames
[kind
], regexp
);
4571 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
4573 for (p
= symbols
; p
!= NULL
; p
= p
->next
)
4577 if (p
->msymbol
.minsym
!= NULL
)
4581 printf_filtered (_("\nNon-debugging symbols:\n"));
4584 print_msymbol_info (p
->msymbol
);
4588 print_symbol_info (kind
,
4593 = symtab_to_filename_for_display (symbol_symtab (p
->symbol
));
4597 do_cleanups (old_chain
);
4601 info_variables_command (char *regexp
, int from_tty
)
4603 symtab_symbol_info (regexp
, VARIABLES_DOMAIN
, from_tty
);
4607 info_functions_command (char *regexp
, int from_tty
)
4609 symtab_symbol_info (regexp
, FUNCTIONS_DOMAIN
, from_tty
);
4614 info_types_command (char *regexp
, int from_tty
)
4616 symtab_symbol_info (regexp
, TYPES_DOMAIN
, from_tty
);
4619 /* Breakpoint all functions matching regular expression. */
4622 rbreak_command_wrapper (char *regexp
, int from_tty
)
4624 rbreak_command (regexp
, from_tty
);
4627 /* A cleanup function that calls end_rbreak_breakpoints. */
4630 do_end_rbreak_breakpoints (void *ignore
)
4632 end_rbreak_breakpoints ();
4636 rbreak_command (char *regexp
, int from_tty
)
4638 struct symbol_search
*ss
;
4639 struct symbol_search
*p
;
4640 struct cleanup
*old_chain
;
4641 char *string
= NULL
;
4643 const char **files
= NULL
;
4644 const char *file_name
;
4649 char *colon
= strchr (regexp
, ':');
4651 if (colon
&& *(colon
+ 1) != ':')
4656 colon_index
= colon
- regexp
;
4657 local_name
= (char *) alloca (colon_index
+ 1);
4658 memcpy (local_name
, regexp
, colon_index
);
4659 local_name
[colon_index
--] = 0;
4660 while (isspace (local_name
[colon_index
]))
4661 local_name
[colon_index
--] = 0;
4662 file_name
= local_name
;
4665 regexp
= skip_spaces (colon
+ 1);
4669 search_symbols (regexp
, FUNCTIONS_DOMAIN
, nfiles
, files
, &ss
);
4670 old_chain
= make_cleanup_free_search_symbols (&ss
);
4671 make_cleanup (free_current_contents
, &string
);
4673 start_rbreak_breakpoints ();
4674 make_cleanup (do_end_rbreak_breakpoints
, NULL
);
4675 for (p
= ss
; p
!= NULL
; p
= p
->next
)
4677 if (p
->msymbol
.minsym
== NULL
)
4679 struct symtab
*symtab
= symbol_symtab (p
->symbol
);
4680 const char *fullname
= symtab_to_fullname (symtab
);
4682 int newlen
= (strlen (fullname
)
4683 + strlen (SYMBOL_LINKAGE_NAME (p
->symbol
))
4688 string
= (char *) xrealloc (string
, newlen
);
4691 strcpy (string
, fullname
);
4692 strcat (string
, ":'");
4693 strcat (string
, SYMBOL_LINKAGE_NAME (p
->symbol
));
4694 strcat (string
, "'");
4695 break_command (string
, from_tty
);
4696 print_symbol_info (FUNCTIONS_DOMAIN
,
4699 symtab_to_filename_for_display (symtab
));
4703 int newlen
= (strlen (MSYMBOL_LINKAGE_NAME (p
->msymbol
.minsym
)) + 3);
4707 string
= (char *) xrealloc (string
, newlen
);
4710 strcpy (string
, "'");
4711 strcat (string
, MSYMBOL_LINKAGE_NAME (p
->msymbol
.minsym
));
4712 strcat (string
, "'");
4714 break_command (string
, from_tty
);
4715 printf_filtered ("<function, no debug info> %s;\n",
4716 MSYMBOL_PRINT_NAME (p
->msymbol
.minsym
));
4720 do_cleanups (old_chain
);
4724 /* Evaluate if NAME matches SYM_TEXT and SYM_TEXT_LEN.
4726 Either sym_text[sym_text_len] != '(' and then we search for any
4727 symbol starting with SYM_TEXT text.
4729 Otherwise sym_text[sym_text_len] == '(' and then we require symbol name to
4730 be terminated at that point. Partial symbol tables do not have parameters
4734 compare_symbol_name (const char *name
, const char *sym_text
, int sym_text_len
)
4736 int (*ncmp
) (const char *, const char *, size_t);
4738 ncmp
= (case_sensitivity
== case_sensitive_on
? strncmp
: strncasecmp
);
4740 if (ncmp (name
, sym_text
, sym_text_len
) != 0)
4743 if (sym_text
[sym_text_len
] == '(')
4745 /* User searches for `name(someth...'. Require NAME to be terminated.
4746 Normally psymtabs and gdbindex have no parameter types so '\0' will be
4747 present but accept even parameters presence. In this case this
4748 function is in fact strcmp_iw but whitespace skipping is not supported
4749 for tab completion. */
4751 if (name
[sym_text_len
] != '\0' && name
[sym_text_len
] != '(')
4758 /* Test to see if the symbol specified by SYMNAME (which is already
4759 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
4760 characters. If so, add it to the current completion list. */
4763 completion_list_add_name (completion_tracker
&tracker
,
4764 const char *symname
,
4765 const char *sym_text
, int sym_text_len
,
4766 const char *text
, const char *word
)
4768 /* Clip symbols that cannot match. */
4769 if (!compare_symbol_name (symname
, sym_text
, sym_text_len
))
4772 /* We have a match for a completion, so add SYMNAME to the current list
4773 of matches. Note that the name is moved to freshly malloc'd space. */
4778 if (word
== sym_text
)
4780 newobj
= (char *) xmalloc (strlen (symname
) + 5);
4781 strcpy (newobj
, symname
);
4783 else if (word
> sym_text
)
4785 /* Return some portion of symname. */
4786 newobj
= (char *) xmalloc (strlen (symname
) + 5);
4787 strcpy (newobj
, symname
+ (word
- sym_text
));
4791 /* Return some of SYM_TEXT plus symname. */
4792 newobj
= (char *) xmalloc (strlen (symname
) + (sym_text
- word
) + 5);
4793 strncpy (newobj
, word
, sym_text
- word
);
4794 newobj
[sym_text
- word
] = '\0';
4795 strcat (newobj
, symname
);
4798 gdb::unique_xmalloc_ptr
<char> completion (newobj
);
4800 tracker
.add_completion (std::move (completion
));
4804 /* completion_list_add_name wrapper for struct symbol. */
4807 completion_list_add_symbol (completion_tracker
&tracker
,
4809 const char *sym_text
, int sym_text_len
,
4810 const char *text
, const char *word
)
4812 completion_list_add_name (tracker
, SYMBOL_NATURAL_NAME (sym
),
4813 sym_text
, sym_text_len
, text
, word
);
4816 /* completion_list_add_name wrapper for struct minimal_symbol. */
4819 completion_list_add_msymbol (completion_tracker
&tracker
,
4820 minimal_symbol
*sym
,
4821 const char *sym_text
, int sym_text_len
,
4822 const char *text
, const char *word
)
4824 completion_list_add_name (tracker
, MSYMBOL_NATURAL_NAME (sym
),
4825 sym_text
, sym_text_len
, text
, word
);
4828 /* ObjC: In case we are completing on a selector, look as the msymbol
4829 again and feed all the selectors into the mill. */
4832 completion_list_objc_symbol (completion_tracker
&tracker
,
4833 struct minimal_symbol
*msymbol
,
4834 const char *sym_text
, int sym_text_len
,
4835 const char *text
, const char *word
)
4837 static char *tmp
= NULL
;
4838 static unsigned int tmplen
= 0;
4840 const char *method
, *category
, *selector
;
4843 method
= MSYMBOL_NATURAL_NAME (msymbol
);
4845 /* Is it a method? */
4846 if ((method
[0] != '-') && (method
[0] != '+'))
4849 if (sym_text
[0] == '[')
4850 /* Complete on shortened method method. */
4851 completion_list_add_name (tracker
, method
+ 1,
4852 sym_text
, sym_text_len
, text
, word
);
4854 while ((strlen (method
) + 1) >= tmplen
)
4860 tmp
= (char *) xrealloc (tmp
, tmplen
);
4862 selector
= strchr (method
, ' ');
4863 if (selector
!= NULL
)
4866 category
= strchr (method
, '(');
4868 if ((category
!= NULL
) && (selector
!= NULL
))
4870 memcpy (tmp
, method
, (category
- method
));
4871 tmp
[category
- method
] = ' ';
4872 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
4873 completion_list_add_name (tracker
, tmp
,
4874 sym_text
, sym_text_len
, text
, word
);
4875 if (sym_text
[0] == '[')
4876 completion_list_add_name (tracker
, tmp
+ 1,
4877 sym_text
, sym_text_len
, text
, word
);
4880 if (selector
!= NULL
)
4882 /* Complete on selector only. */
4883 strcpy (tmp
, selector
);
4884 tmp2
= strchr (tmp
, ']');
4888 completion_list_add_name (tracker
, tmp
,
4889 sym_text
, sym_text_len
, text
, word
);
4893 /* Break the non-quoted text based on the characters which are in
4894 symbols. FIXME: This should probably be language-specific. */
4897 language_search_unquoted_string (const char *text
, const char *p
)
4899 for (; p
> text
; --p
)
4901 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
4905 if ((current_language
->la_language
== language_objc
))
4907 if (p
[-1] == ':') /* Might be part of a method name. */
4909 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
4910 p
-= 2; /* Beginning of a method name. */
4911 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
4912 { /* Might be part of a method name. */
4915 /* Seeing a ' ' or a '(' is not conclusive evidence
4916 that we are in the middle of a method name. However,
4917 finding "-[" or "+[" should be pretty un-ambiguous.
4918 Unfortunately we have to find it now to decide. */
4921 if (isalnum (t
[-1]) || t
[-1] == '_' ||
4922 t
[-1] == ' ' || t
[-1] == ':' ||
4923 t
[-1] == '(' || t
[-1] == ')')
4928 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
4929 p
= t
- 2; /* Method name detected. */
4930 /* Else we leave with p unchanged. */
4940 completion_list_add_fields (completion_tracker
&tracker
,
4942 const char *sym_text
, int sym_text_len
,
4943 const char *text
, const char *word
)
4945 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
4947 struct type
*t
= SYMBOL_TYPE (sym
);
4948 enum type_code c
= TYPE_CODE (t
);
4951 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
4952 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
4953 if (TYPE_FIELD_NAME (t
, j
))
4954 completion_list_add_name (tracker
, TYPE_FIELD_NAME (t
, j
),
4955 sym_text
, sym_text_len
, text
, word
);
4959 /* Add matching symbols from SYMTAB to the current completion list. */
4962 add_symtab_completions (struct compunit_symtab
*cust
,
4963 completion_tracker
&tracker
,
4964 const char *sym_text
, int sym_text_len
,
4965 const char *text
, const char *word
,
4966 enum type_code code
)
4969 const struct block
*b
;
4970 struct block_iterator iter
;
4976 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
4979 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), i
);
4980 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4982 if (code
== TYPE_CODE_UNDEF
4983 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
4984 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
4985 completion_list_add_symbol (tracker
, sym
,
4986 sym_text
, sym_text_len
,
4993 default_collect_symbol_completion_matches_break_on
4994 (completion_tracker
&tracker
,
4995 complete_symbol_mode mode
,
4996 const char *text
, const char *word
,
4997 const char *break_on
, enum type_code code
)
4999 /* Problem: All of the symbols have to be copied because readline
5000 frees them. I'm not going to worry about this; hopefully there
5001 won't be that many. */
5004 struct compunit_symtab
*cust
;
5005 struct minimal_symbol
*msymbol
;
5006 struct objfile
*objfile
;
5007 const struct block
*b
;
5008 const struct block
*surrounding_static_block
, *surrounding_global_block
;
5009 struct block_iterator iter
;
5010 /* The symbol we are completing on. Points in same buffer as text. */
5011 const char *sym_text
;
5012 /* Length of sym_text. */
5015 /* Now look for the symbol we are supposed to complete on. */
5016 if (mode
== complete_symbol_mode::LINESPEC
)
5022 const char *quote_pos
= NULL
;
5024 /* First see if this is a quoted string. */
5026 for (p
= text
; *p
!= '\0'; ++p
)
5028 if (quote_found
!= '\0')
5030 if (*p
== quote_found
)
5031 /* Found close quote. */
5033 else if (*p
== '\\' && p
[1] == quote_found
)
5034 /* A backslash followed by the quote character
5035 doesn't end the string. */
5038 else if (*p
== '\'' || *p
== '"')
5044 if (quote_found
== '\'')
5045 /* A string within single quotes can be a symbol, so complete on it. */
5046 sym_text
= quote_pos
+ 1;
5047 else if (quote_found
== '"')
5048 /* A double-quoted string is never a symbol, nor does it make sense
5049 to complete it any other way. */
5055 /* It is not a quoted string. Break it based on the characters
5056 which are in symbols. */
5059 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
5060 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
5069 sym_text_len
= strlen (sym_text
);
5071 /* Prepare SYM_TEXT_LEN for compare_symbol_name. */
5073 if (current_language
->la_language
== language_cplus
5074 || current_language
->la_language
== language_fortran
)
5076 /* These languages may have parameters entered by user but they are never
5077 present in the partial symbol tables. */
5079 const char *cs
= (const char *) memchr (sym_text
, '(', sym_text_len
);
5082 sym_text_len
= cs
- sym_text
;
5084 gdb_assert (sym_text
[sym_text_len
] == '\0' || sym_text
[sym_text_len
] == '(');
5086 /* At this point scan through the misc symbol vectors and add each
5087 symbol you find to the list. Eventually we want to ignore
5088 anything that isn't a text symbol (everything else will be
5089 handled by the psymtab code below). */
5091 if (code
== TYPE_CODE_UNDEF
)
5093 ALL_MSYMBOLS (objfile
, msymbol
)
5097 completion_list_add_msymbol (tracker
,
5098 msymbol
, sym_text
, sym_text_len
,
5101 completion_list_objc_symbol (tracker
,
5102 msymbol
, sym_text
, sym_text_len
,
5107 /* Add completions for all currently loaded symbol tables. */
5108 ALL_COMPUNITS (objfile
, cust
)
5109 add_symtab_completions (cust
, tracker
,
5110 sym_text
, sym_text_len
, text
, word
, code
);
5112 /* Look through the partial symtabs for all symbols which begin by
5113 matching SYM_TEXT. Expand all CUs that you find to the list. */
5114 expand_symtabs_matching (NULL
,
5115 [&] (const char *name
) /* symbol matcher */
5117 return compare_symbol_name (name
,
5121 [&] (compunit_symtab
*symtab
) /* expansion notify */
5123 add_symtab_completions (symtab
,
5125 sym_text
, sym_text_len
,
5130 /* Search upwards from currently selected frame (so that we can
5131 complete on local vars). Also catch fields of types defined in
5132 this places which match our text string. Only complete on types
5133 visible from current context. */
5135 b
= get_selected_block (0);
5136 surrounding_static_block
= block_static_block (b
);
5137 surrounding_global_block
= block_global_block (b
);
5138 if (surrounding_static_block
!= NULL
)
5139 while (b
!= surrounding_static_block
)
5143 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5145 if (code
== TYPE_CODE_UNDEF
)
5147 completion_list_add_symbol (tracker
, sym
,
5148 sym_text
, sym_text_len
, text
,
5150 completion_list_add_fields (tracker
, sym
,
5151 sym_text
, sym_text_len
, text
,
5154 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5155 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
5156 completion_list_add_symbol (tracker
, sym
,
5157 sym_text
, sym_text_len
, text
,
5161 /* Stop when we encounter an enclosing function. Do not stop for
5162 non-inlined functions - the locals of the enclosing function
5163 are in scope for a nested function. */
5164 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
5166 b
= BLOCK_SUPERBLOCK (b
);
5169 /* Add fields from the file's types; symbols will be added below. */
5171 if (code
== TYPE_CODE_UNDEF
)
5173 if (surrounding_static_block
!= NULL
)
5174 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
5175 completion_list_add_fields (tracker
, sym
,
5176 sym_text
, sym_text_len
, text
, word
);
5178 if (surrounding_global_block
!= NULL
)
5179 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
5180 completion_list_add_fields (tracker
, sym
,
5181 sym_text
, sym_text_len
, text
, word
);
5184 /* Skip macros if we are completing a struct tag -- arguable but
5185 usually what is expected. */
5186 if (current_language
->la_macro_expansion
== macro_expansion_c
5187 && code
== TYPE_CODE_UNDEF
)
5189 struct macro_scope
*scope
;
5191 /* This adds a macro's name to the current completion list. */
5192 auto add_macro_name
= [&] (const char *macro_name
,
5193 const macro_definition
*,
5194 macro_source_file
*,
5197 completion_list_add_name (tracker
, macro_name
,
5198 sym_text
, sym_text_len
,
5202 /* Add any macros visible in the default scope. Note that this
5203 may yield the occasional wrong result, because an expression
5204 might be evaluated in a scope other than the default. For
5205 example, if the user types "break file:line if <TAB>", the
5206 resulting expression will be evaluated at "file:line" -- but
5207 at there does not seem to be a way to detect this at
5209 scope
= default_macro_scope ();
5212 macro_for_each_in_scope (scope
->file
, scope
->line
,
5217 /* User-defined macros are always visible. */
5218 macro_for_each (macro_user_macros
, add_macro_name
);
5223 default_collect_symbol_completion_matches (completion_tracker
&tracker
,
5224 complete_symbol_mode mode
,
5225 const char *text
, const char *word
,
5226 enum type_code code
)
5228 return default_collect_symbol_completion_matches_break_on (tracker
, mode
,
5233 /* Collect all symbols (regardless of class) which begin by matching
5237 collect_symbol_completion_matches (completion_tracker
&tracker
,
5238 complete_symbol_mode mode
,
5239 const char *text
, const char *word
)
5241 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5246 /* Like collect_symbol_completion_matches, but only collect
5247 STRUCT_DOMAIN symbols whose type code is CODE. */
5250 collect_symbol_completion_matches_type (completion_tracker
&tracker
,
5251 const char *text
, const char *word
,
5252 enum type_code code
)
5254 complete_symbol_mode mode
= complete_symbol_mode::EXPRESSION
;
5256 gdb_assert (code
== TYPE_CODE_UNION
5257 || code
== TYPE_CODE_STRUCT
5258 || code
== TYPE_CODE_ENUM
);
5259 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5263 /* Like collect_symbol_completion_matches, but collects a list of
5264 symbols defined in all source files named SRCFILE. */
5267 collect_file_symbol_completion_matches (completion_tracker
&tracker
,
5268 complete_symbol_mode mode
,
5269 const char *text
, const char *word
,
5270 const char *srcfile
)
5272 /* The symbol we are completing on. Points in same buffer as text. */
5273 const char *sym_text
;
5274 /* Length of sym_text. */
5277 /* Now look for the symbol we are supposed to complete on.
5278 FIXME: This should be language-specific. */
5279 if (mode
== complete_symbol_mode::LINESPEC
)
5285 const char *quote_pos
= NULL
;
5287 /* First see if this is a quoted string. */
5289 for (p
= text
; *p
!= '\0'; ++p
)
5291 if (quote_found
!= '\0')
5293 if (*p
== quote_found
)
5294 /* Found close quote. */
5296 else if (*p
== '\\' && p
[1] == quote_found
)
5297 /* A backslash followed by the quote character
5298 doesn't end the string. */
5301 else if (*p
== '\'' || *p
== '"')
5307 if (quote_found
== '\'')
5308 /* A string within single quotes can be a symbol, so complete on it. */
5309 sym_text
= quote_pos
+ 1;
5310 else if (quote_found
== '"')
5311 /* A double-quoted string is never a symbol, nor does it make sense
5312 to complete it any other way. */
5318 /* Not a quoted string. */
5319 sym_text
= language_search_unquoted_string (text
, p
);
5323 sym_text_len
= strlen (sym_text
);
5325 /* Go through symtabs for SRCFILE and check the externs and statics
5326 for symbols which match. */
5327 iterate_over_symtabs (srcfile
, [&] (symtab
*s
)
5329 add_symtab_completions (SYMTAB_COMPUNIT (s
),
5331 sym_text
, sym_text_len
,
5332 text
, word
, TYPE_CODE_UNDEF
);
5337 /* A helper function for make_source_files_completion_list. It adds
5338 another file name to a list of possible completions, growing the
5339 list as necessary. */
5342 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
5343 completion_list
*list
)
5346 size_t fnlen
= strlen (fname
);
5350 /* Return exactly fname. */
5351 newobj
= (char *) xmalloc (fnlen
+ 5);
5352 strcpy (newobj
, fname
);
5354 else if (word
> text
)
5356 /* Return some portion of fname. */
5357 newobj
= (char *) xmalloc (fnlen
+ 5);
5358 strcpy (newobj
, fname
+ (word
- text
));
5362 /* Return some of TEXT plus fname. */
5363 newobj
= (char *) xmalloc (fnlen
+ (text
- word
) + 5);
5364 strncpy (newobj
, word
, text
- word
);
5365 newobj
[text
- word
] = '\0';
5366 strcat (newobj
, fname
);
5368 list
->emplace_back (newobj
);
5372 not_interesting_fname (const char *fname
)
5374 static const char *illegal_aliens
[] = {
5375 "_globals_", /* inserted by coff_symtab_read */
5380 for (i
= 0; illegal_aliens
[i
]; i
++)
5382 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
5388 /* An object of this type is passed as the user_data argument to
5389 map_partial_symbol_filenames. */
5390 struct add_partial_filename_data
5392 struct filename_seen_cache
*filename_seen_cache
;
5396 completion_list
*list
;
5399 /* A callback for map_partial_symbol_filenames. */
5402 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
5405 struct add_partial_filename_data
*data
5406 = (struct add_partial_filename_data
*) user_data
;
5408 if (not_interesting_fname (filename
))
5410 if (!data
->filename_seen_cache
->seen (filename
)
5411 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
5413 /* This file matches for a completion; add it to the
5414 current list of matches. */
5415 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
5419 const char *base_name
= lbasename (filename
);
5421 if (base_name
!= filename
5422 && !data
->filename_seen_cache
->seen (base_name
)
5423 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
5424 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
5428 /* Return a list of all source files whose names begin with matching
5429 TEXT. The file names are looked up in the symbol tables of this
5433 make_source_files_completion_list (const char *text
, const char *word
)
5435 struct compunit_symtab
*cu
;
5437 struct objfile
*objfile
;
5438 size_t text_len
= strlen (text
);
5439 completion_list list
;
5440 const char *base_name
;
5441 struct add_partial_filename_data datum
;
5442 struct cleanup
*back_to
;
5444 if (!have_full_symbols () && !have_partial_symbols ())
5447 filename_seen_cache filenames_seen
;
5449 ALL_FILETABS (objfile
, cu
, s
)
5451 if (not_interesting_fname (s
->filename
))
5453 if (!filenames_seen
.seen (s
->filename
)
5454 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
5456 /* This file matches for a completion; add it to the current
5458 add_filename_to_list (s
->filename
, text
, word
, &list
);
5462 /* NOTE: We allow the user to type a base name when the
5463 debug info records leading directories, but not the other
5464 way around. This is what subroutines of breakpoint
5465 command do when they parse file names. */
5466 base_name
= lbasename (s
->filename
);
5467 if (base_name
!= s
->filename
5468 && !filenames_seen
.seen (base_name
)
5469 && filename_ncmp (base_name
, text
, text_len
) == 0)
5470 add_filename_to_list (base_name
, text
, word
, &list
);
5474 datum
.filename_seen_cache
= &filenames_seen
;
5477 datum
.text_len
= text_len
;
5479 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
5480 0 /*need_fullname*/);
5487 /* Return the "main_info" object for the current program space. If
5488 the object has not yet been created, create it and fill in some
5491 static struct main_info
*
5492 get_main_info (void)
5494 struct main_info
*info
5495 = (struct main_info
*) program_space_data (current_program_space
,
5496 main_progspace_key
);
5500 /* It may seem strange to store the main name in the progspace
5501 and also in whatever objfile happens to see a main name in
5502 its debug info. The reason for this is mainly historical:
5503 gdb returned "main" as the name even if no function named
5504 "main" was defined the program; and this approach lets us
5505 keep compatibility. */
5506 info
= XCNEW (struct main_info
);
5507 info
->language_of_main
= language_unknown
;
5508 set_program_space_data (current_program_space
, main_progspace_key
,
5515 /* A cleanup to destroy a struct main_info when a progspace is
5519 main_info_cleanup (struct program_space
*pspace
, void *data
)
5521 struct main_info
*info
= (struct main_info
*) data
;
5524 xfree (info
->name_of_main
);
5529 set_main_name (const char *name
, enum language lang
)
5531 struct main_info
*info
= get_main_info ();
5533 if (info
->name_of_main
!= NULL
)
5535 xfree (info
->name_of_main
);
5536 info
->name_of_main
= NULL
;
5537 info
->language_of_main
= language_unknown
;
5541 info
->name_of_main
= xstrdup (name
);
5542 info
->language_of_main
= lang
;
5546 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5550 find_main_name (void)
5552 const char *new_main_name
;
5553 struct objfile
*objfile
;
5555 /* First check the objfiles to see whether a debuginfo reader has
5556 picked up the appropriate main name. Historically the main name
5557 was found in a more or less random way; this approach instead
5558 relies on the order of objfile creation -- which still isn't
5559 guaranteed to get the correct answer, but is just probably more
5561 ALL_OBJFILES (objfile
)
5563 if (objfile
->per_bfd
->name_of_main
!= NULL
)
5565 set_main_name (objfile
->per_bfd
->name_of_main
,
5566 objfile
->per_bfd
->language_of_main
);
5571 /* Try to see if the main procedure is in Ada. */
5572 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5573 be to add a new method in the language vector, and call this
5574 method for each language until one of them returns a non-empty
5575 name. This would allow us to remove this hard-coded call to
5576 an Ada function. It is not clear that this is a better approach
5577 at this point, because all methods need to be written in a way
5578 such that false positives never be returned. For instance, it is
5579 important that a method does not return a wrong name for the main
5580 procedure if the main procedure is actually written in a different
5581 language. It is easy to guaranty this with Ada, since we use a
5582 special symbol generated only when the main in Ada to find the name
5583 of the main procedure. It is difficult however to see how this can
5584 be guarantied for languages such as C, for instance. This suggests
5585 that order of call for these methods becomes important, which means
5586 a more complicated approach. */
5587 new_main_name
= ada_main_name ();
5588 if (new_main_name
!= NULL
)
5590 set_main_name (new_main_name
, language_ada
);
5594 new_main_name
= d_main_name ();
5595 if (new_main_name
!= NULL
)
5597 set_main_name (new_main_name
, language_d
);
5601 new_main_name
= go_main_name ();
5602 if (new_main_name
!= NULL
)
5604 set_main_name (new_main_name
, language_go
);
5608 new_main_name
= pascal_main_name ();
5609 if (new_main_name
!= NULL
)
5611 set_main_name (new_main_name
, language_pascal
);
5615 /* The languages above didn't identify the name of the main procedure.
5616 Fallback to "main". */
5617 set_main_name ("main", language_unknown
);
5623 struct main_info
*info
= get_main_info ();
5625 if (info
->name_of_main
== NULL
)
5628 return info
->name_of_main
;
5631 /* Return the language of the main function. If it is not known,
5632 return language_unknown. */
5635 main_language (void)
5637 struct main_info
*info
= get_main_info ();
5639 if (info
->name_of_main
== NULL
)
5642 return info
->language_of_main
;
5645 /* Handle ``executable_changed'' events for the symtab module. */
5648 symtab_observer_executable_changed (void)
5650 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5651 set_main_name (NULL
, language_unknown
);
5654 /* Return 1 if the supplied producer string matches the ARM RealView
5655 compiler (armcc). */
5658 producer_is_realview (const char *producer
)
5660 static const char *const arm_idents
[] = {
5661 "ARM C Compiler, ADS",
5662 "Thumb C Compiler, ADS",
5663 "ARM C++ Compiler, ADS",
5664 "Thumb C++ Compiler, ADS",
5665 "ARM/Thumb C/C++ Compiler, RVCT",
5666 "ARM C/C++ Compiler, RVCT"
5670 if (producer
== NULL
)
5673 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
5674 if (startswith (producer
, arm_idents
[i
]))
5682 /* The next index to hand out in response to a registration request. */
5684 static int next_aclass_value
= LOC_FINAL_VALUE
;
5686 /* The maximum number of "aclass" registrations we support. This is
5687 constant for convenience. */
5688 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5690 /* The objects representing the various "aclass" values. The elements
5691 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5692 elements are those registered at gdb initialization time. */
5694 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
5696 /* The globally visible pointer. This is separate from 'symbol_impl'
5697 so that it can be const. */
5699 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
5701 /* Make sure we saved enough room in struct symbol. */
5703 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
5705 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5706 is the ops vector associated with this index. This returns the new
5707 index, which should be used as the aclass_index field for symbols
5711 register_symbol_computed_impl (enum address_class aclass
,
5712 const struct symbol_computed_ops
*ops
)
5714 int result
= next_aclass_value
++;
5716 gdb_assert (aclass
== LOC_COMPUTED
);
5717 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5718 symbol_impl
[result
].aclass
= aclass
;
5719 symbol_impl
[result
].ops_computed
= ops
;
5721 /* Sanity check OPS. */
5722 gdb_assert (ops
!= NULL
);
5723 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
5724 gdb_assert (ops
->describe_location
!= NULL
);
5725 gdb_assert (ops
->get_symbol_read_needs
!= NULL
);
5726 gdb_assert (ops
->read_variable
!= NULL
);
5731 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5732 OPS is the ops vector associated with this index. This returns the
5733 new index, which should be used as the aclass_index field for symbols
5737 register_symbol_block_impl (enum address_class aclass
,
5738 const struct symbol_block_ops
*ops
)
5740 int result
= next_aclass_value
++;
5742 gdb_assert (aclass
== LOC_BLOCK
);
5743 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5744 symbol_impl
[result
].aclass
= aclass
;
5745 symbol_impl
[result
].ops_block
= ops
;
5747 /* Sanity check OPS. */
5748 gdb_assert (ops
!= NULL
);
5749 gdb_assert (ops
->find_frame_base_location
!= NULL
);
5754 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5755 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5756 this index. This returns the new index, which should be used as
5757 the aclass_index field for symbols of this type. */
5760 register_symbol_register_impl (enum address_class aclass
,
5761 const struct symbol_register_ops
*ops
)
5763 int result
= next_aclass_value
++;
5765 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
5766 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5767 symbol_impl
[result
].aclass
= aclass
;
5768 symbol_impl
[result
].ops_register
= ops
;
5773 /* Initialize elements of 'symbol_impl' for the constants in enum
5777 initialize_ordinary_address_classes (void)
5781 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
5782 symbol_impl
[i
].aclass
= (enum address_class
) i
;
5787 /* Helper function to initialize the fields of an objfile-owned symbol.
5788 It assumed that *SYM is already all zeroes. */
5791 initialize_objfile_symbol_1 (struct symbol
*sym
)
5793 SYMBOL_OBJFILE_OWNED (sym
) = 1;
5794 SYMBOL_SECTION (sym
) = -1;
5797 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
5800 initialize_objfile_symbol (struct symbol
*sym
)
5802 memset (sym
, 0, sizeof (*sym
));
5803 initialize_objfile_symbol_1 (sym
);
5806 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5810 allocate_symbol (struct objfile
*objfile
)
5812 struct symbol
*result
;
5814 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
5815 initialize_objfile_symbol_1 (result
);
5820 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5823 struct template_symbol
*
5824 allocate_template_symbol (struct objfile
*objfile
)
5826 struct template_symbol
*result
;
5828 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
5829 initialize_objfile_symbol_1 (&result
->base
);
5837 symbol_objfile (const struct symbol
*symbol
)
5839 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
5840 return SYMTAB_OBJFILE (symbol
->owner
.symtab
);
5846 symbol_arch (const struct symbol
*symbol
)
5848 if (!SYMBOL_OBJFILE_OWNED (symbol
))
5849 return symbol
->owner
.arch
;
5850 return get_objfile_arch (SYMTAB_OBJFILE (symbol
->owner
.symtab
));
5856 symbol_symtab (const struct symbol
*symbol
)
5858 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
5859 return symbol
->owner
.symtab
;
5865 symbol_set_symtab (struct symbol
*symbol
, struct symtab
*symtab
)
5867 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
5868 symbol
->owner
.symtab
= symtab
;
5874 _initialize_symtab (void)
5876 initialize_ordinary_address_classes ();
5879 = register_program_space_data_with_cleanup (NULL
, main_info_cleanup
);
5882 = register_program_space_data_with_cleanup (NULL
, symbol_cache_cleanup
);
5884 add_info ("variables", info_variables_command
, _("\
5885 All global and static variable names, or those matching REGEXP."));
5887 add_com ("whereis", class_info
, info_variables_command
, _("\
5888 All global and static variable names, or those matching REGEXP."));
5890 add_info ("functions", info_functions_command
,
5891 _("All function names, or those matching REGEXP."));
5893 /* FIXME: This command has at least the following problems:
5894 1. It prints builtin types (in a very strange and confusing fashion).
5895 2. It doesn't print right, e.g. with
5896 typedef struct foo *FOO
5897 type_print prints "FOO" when we want to make it (in this situation)
5898 print "struct foo *".
5899 I also think "ptype" or "whatis" is more likely to be useful (but if
5900 there is much disagreement "info types" can be fixed). */
5901 add_info ("types", info_types_command
,
5902 _("All type names, or those matching REGEXP."));
5904 add_info ("sources", info_sources_command
,
5905 _("Source files in the program."));
5907 add_com ("rbreak", class_breakpoint
, rbreak_command
,
5908 _("Set a breakpoint for all functions matching REGEXP."));
5910 add_setshow_enum_cmd ("multiple-symbols", no_class
,
5911 multiple_symbols_modes
, &multiple_symbols_mode
,
5913 Set the debugger behavior when more than one symbol are possible matches\n\
5914 in an expression."), _("\
5915 Show how the debugger handles ambiguities in expressions."), _("\
5916 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
5917 NULL
, NULL
, &setlist
, &showlist
);
5919 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
5920 &basenames_may_differ
, _("\
5921 Set whether a source file may have multiple base names."), _("\
5922 Show whether a source file may have multiple base names."), _("\
5923 (A \"base name\" is the name of a file with the directory part removed.\n\
5924 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
5925 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
5926 before comparing them. Canonicalization is an expensive operation,\n\
5927 but it allows the same file be known by more than one base name.\n\
5928 If not set (the default), all source files are assumed to have just\n\
5929 one base name, and gdb will do file name comparisons more efficiently."),
5931 &setlist
, &showlist
);
5933 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
5934 _("Set debugging of symbol table creation."),
5935 _("Show debugging of symbol table creation."), _("\
5936 When enabled (non-zero), debugging messages are printed when building\n\
5937 symbol tables. A value of 1 (one) normally provides enough information.\n\
5938 A value greater than 1 provides more verbose information."),
5941 &setdebuglist
, &showdebuglist
);
5943 add_setshow_zuinteger_cmd ("symbol-lookup", no_class
, &symbol_lookup_debug
,
5945 Set debugging of symbol lookup."), _("\
5946 Show debugging of symbol lookup."), _("\
5947 When enabled (non-zero), symbol lookups are logged."),
5949 &setdebuglist
, &showdebuglist
);
5951 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class
,
5952 &new_symbol_cache_size
,
5953 _("Set the size of the symbol cache."),
5954 _("Show the size of the symbol cache."), _("\
5955 The size of the symbol cache.\n\
5956 If zero then the symbol cache is disabled."),
5957 set_symbol_cache_size_handler
, NULL
,
5958 &maintenance_set_cmdlist
,
5959 &maintenance_show_cmdlist
);
5961 add_cmd ("symbol-cache", class_maintenance
, maintenance_print_symbol_cache
,
5962 _("Dump the symbol cache for each program space."),
5963 &maintenanceprintlist
);
5965 add_cmd ("symbol-cache-statistics", class_maintenance
,
5966 maintenance_print_symbol_cache_statistics
,
5967 _("Print symbol cache statistics for each program space."),
5968 &maintenanceprintlist
);
5970 add_cmd ("flush-symbol-cache", class_maintenance
,
5971 maintenance_flush_symbol_cache
,
5972 _("Flush the symbol cache for each program space."),
5975 observer_attach_executable_changed (symtab_observer_executable_changed
);
5976 observer_attach_new_objfile (symtab_new_objfile_observer
);
5977 observer_attach_free_objfile (symtab_free_objfile_observer
);