1 /* Symbol table lookup for the GNU debugger, GDB.
3 Copyright (C) 1986-2019 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"
46 #include "typeprint.h"
48 #include "gdb_obstack.h"
50 #include "dictionary.h"
52 #include <sys/types.h>
57 #include "cp-support.h"
58 #include "observable.h"
61 #include "macroscope.h"
63 #include "parser-defs.h"
64 #include "completer.h"
65 #include "progspace-and-thread.h"
66 #include "common/gdb_optional.h"
67 #include "filename-seen-cache.h"
68 #include "arch-utils.h"
70 #include "common/pathstuff.h"
72 /* Forward declarations for local functions. */
74 static void rbreak_command (const char *, int);
76 static int find_line_common (struct linetable
*, int, int *, int);
78 static struct block_symbol
79 lookup_symbol_aux (const char *name
,
80 symbol_name_match_type match_type
,
81 const struct block
*block
,
82 const domain_enum domain
,
83 enum language language
,
84 struct field_of_this_result
*);
87 struct block_symbol
lookup_local_symbol (const char *name
,
88 symbol_name_match_type match_type
,
89 const struct block
*block
,
90 const domain_enum domain
,
91 enum language language
);
93 static struct block_symbol
94 lookup_symbol_in_objfile (struct objfile
*objfile
, int block_index
,
95 const char *name
, const domain_enum domain
);
98 const struct block_symbol null_block_symbol
= { NULL
, NULL
};
100 /* Program space key for finding name and language of "main". */
102 static const struct program_space_data
*main_progspace_key
;
104 /* Type of the data stored on the program space. */
108 /* Name of "main". */
112 /* Language of "main". */
114 enum language language_of_main
;
117 /* Program space key for finding its symbol cache. */
119 static const struct program_space_data
*symbol_cache_key
;
121 /* The default symbol cache size.
122 There is no extra cpu cost for large N (except when flushing the cache,
123 which is rare). The value here is just a first attempt. A better default
124 value may be higher or lower. A prime number can make up for a bad hash
125 computation, so that's why the number is what it is. */
126 #define DEFAULT_SYMBOL_CACHE_SIZE 1021
128 /* The maximum symbol cache size.
129 There's no method to the decision of what value to use here, other than
130 there's no point in allowing a user typo to make gdb consume all memory. */
131 #define MAX_SYMBOL_CACHE_SIZE (1024*1024)
133 /* symbol_cache_lookup returns this if a previous lookup failed to find the
134 symbol in any objfile. */
135 #define SYMBOL_LOOKUP_FAILED \
136 ((struct block_symbol) {(struct symbol *) 1, NULL})
137 #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1)
139 /* Recording lookups that don't find the symbol is just as important, if not
140 more so, than recording found symbols. */
142 enum symbol_cache_slot_state
145 SYMBOL_SLOT_NOT_FOUND
,
149 struct symbol_cache_slot
151 enum symbol_cache_slot_state state
;
153 /* The objfile that was current when the symbol was looked up.
154 This is only needed for global blocks, but for simplicity's sake
155 we allocate the space for both. If data shows the extra space used
156 for static blocks is a problem, we can split things up then.
158 Global blocks need cache lookup to include the objfile context because
159 we need to account for gdbarch_iterate_over_objfiles_in_search_order
160 which can traverse objfiles in, effectively, any order, depending on
161 the current objfile, thus affecting which symbol is found. Normally,
162 only the current objfile is searched first, and then the rest are
163 searched in recorded order; but putting cache lookup inside
164 gdbarch_iterate_over_objfiles_in_search_order would be awkward.
165 Instead we just make the current objfile part of the context of
166 cache lookup. This means we can record the same symbol multiple times,
167 each with a different "current objfile" that was in effect when the
168 lookup was saved in the cache, but cache space is pretty cheap. */
169 const struct objfile
*objfile_context
;
173 struct block_symbol found
;
182 /* Symbols don't specify global vs static block.
183 So keep them in separate caches. */
185 struct block_symbol_cache
189 unsigned int collisions
;
191 /* SYMBOLS is a variable length array of this size.
192 One can imagine that in general one cache (global/static) should be a
193 fraction of the size of the other, but there's no data at the moment
194 on which to decide. */
197 struct symbol_cache_slot symbols
[1];
202 Searching for symbols in the static and global blocks over multiple objfiles
203 again and again can be slow, as can searching very big objfiles. This is a
204 simple cache to improve symbol lookup performance, which is critical to
205 overall gdb performance.
207 Symbols are hashed on the name, its domain, and block.
208 They are also hashed on their objfile for objfile-specific lookups. */
212 struct block_symbol_cache
*global_symbols
;
213 struct block_symbol_cache
*static_symbols
;
216 /* When non-zero, print debugging messages related to symtab creation. */
217 unsigned int symtab_create_debug
= 0;
219 /* When non-zero, print debugging messages related to symbol lookup. */
220 unsigned int symbol_lookup_debug
= 0;
222 /* The size of the cache is staged here. */
223 static unsigned int new_symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
225 /* The current value of the symbol cache size.
226 This is saved so that if the user enters a value too big we can restore
227 the original value from here. */
228 static unsigned int symbol_cache_size
= DEFAULT_SYMBOL_CACHE_SIZE
;
230 /* Non-zero if a file may be known by two different basenames.
231 This is the uncommon case, and significantly slows down gdb.
232 Default set to "off" to not slow down the common case. */
233 int basenames_may_differ
= 0;
235 /* Allow the user to configure the debugger behavior with respect
236 to multiple-choice menus when more than one symbol matches during
239 const char multiple_symbols_ask
[] = "ask";
240 const char multiple_symbols_all
[] = "all";
241 const char multiple_symbols_cancel
[] = "cancel";
242 static const char *const multiple_symbols_modes
[] =
244 multiple_symbols_ask
,
245 multiple_symbols_all
,
246 multiple_symbols_cancel
,
249 static const char *multiple_symbols_mode
= multiple_symbols_all
;
251 /* Read-only accessor to AUTO_SELECT_MODE. */
254 multiple_symbols_select_mode (void)
256 return multiple_symbols_mode
;
259 /* Return the name of a domain_enum. */
262 domain_name (domain_enum e
)
266 case UNDEF_DOMAIN
: return "UNDEF_DOMAIN";
267 case VAR_DOMAIN
: return "VAR_DOMAIN";
268 case STRUCT_DOMAIN
: return "STRUCT_DOMAIN";
269 case MODULE_DOMAIN
: return "MODULE_DOMAIN";
270 case LABEL_DOMAIN
: return "LABEL_DOMAIN";
271 case COMMON_BLOCK_DOMAIN
: return "COMMON_BLOCK_DOMAIN";
272 default: gdb_assert_not_reached ("bad domain_enum");
276 /* Return the name of a search_domain . */
279 search_domain_name (enum search_domain e
)
283 case VARIABLES_DOMAIN
: return "VARIABLES_DOMAIN";
284 case FUNCTIONS_DOMAIN
: return "FUNCTIONS_DOMAIN";
285 case TYPES_DOMAIN
: return "TYPES_DOMAIN";
286 case ALL_DOMAIN
: return "ALL_DOMAIN";
287 default: gdb_assert_not_reached ("bad search_domain");
294 compunit_primary_filetab (const struct compunit_symtab
*cust
)
296 gdb_assert (COMPUNIT_FILETABS (cust
) != NULL
);
298 /* The primary file symtab is the first one in the list. */
299 return COMPUNIT_FILETABS (cust
);
305 compunit_language (const struct compunit_symtab
*cust
)
307 struct symtab
*symtab
= compunit_primary_filetab (cust
);
309 /* The language of the compunit symtab is the language of its primary
311 return SYMTAB_LANGUAGE (symtab
);
314 /* See whether FILENAME matches SEARCH_NAME using the rule that we
315 advertise to the user. (The manual's description of linespecs
316 describes what we advertise). Returns true if they match, false
320 compare_filenames_for_search (const char *filename
, const char *search_name
)
322 int len
= strlen (filename
);
323 size_t search_len
= strlen (search_name
);
325 if (len
< search_len
)
328 /* The tail of FILENAME must match. */
329 if (FILENAME_CMP (filename
+ len
- search_len
, search_name
) != 0)
332 /* Either the names must completely match, or the character
333 preceding the trailing SEARCH_NAME segment of FILENAME must be a
336 The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c"
337 cannot match FILENAME "/path//dir/file.c" - as user has requested
338 absolute path. The sama applies for "c:\file.c" possibly
339 incorrectly hypothetically matching "d:\dir\c:\file.c".
341 The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c"
342 compatible with SEARCH_NAME "file.c". In such case a compiler had
343 to put the "c:file.c" name into debug info. Such compatibility
344 works only on GDB built for DOS host. */
345 return (len
== search_len
346 || (!IS_ABSOLUTE_PATH (search_name
)
347 && IS_DIR_SEPARATOR (filename
[len
- search_len
- 1]))
348 || (HAS_DRIVE_SPEC (filename
)
349 && STRIP_DRIVE_SPEC (filename
) == &filename
[len
- search_len
]));
352 /* Same as compare_filenames_for_search, but for glob-style patterns.
353 Heads up on the order of the arguments. They match the order of
354 compare_filenames_for_search, but it's the opposite of the order of
355 arguments to gdb_filename_fnmatch. */
358 compare_glob_filenames_for_search (const char *filename
,
359 const char *search_name
)
361 /* We rely on the property of glob-style patterns with FNM_FILE_NAME that
362 all /s have to be explicitly specified. */
363 int file_path_elements
= count_path_elements (filename
);
364 int search_path_elements
= count_path_elements (search_name
);
366 if (search_path_elements
> file_path_elements
)
369 if (IS_ABSOLUTE_PATH (search_name
))
371 return (search_path_elements
== file_path_elements
372 && gdb_filename_fnmatch (search_name
, filename
,
373 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0);
377 const char *file_to_compare
378 = strip_leading_path_elements (filename
,
379 file_path_elements
- search_path_elements
);
381 return gdb_filename_fnmatch (search_name
, file_to_compare
,
382 FNM_FILE_NAME
| FNM_NOESCAPE
) == 0;
386 /* Check for a symtab of a specific name by searching some symtabs.
387 This is a helper function for callbacks of iterate_over_symtabs.
389 If NAME is not absolute, then REAL_PATH is NULL
390 If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME.
392 The return value, NAME, REAL_PATH and CALLBACK are identical to the
393 `map_symtabs_matching_filename' method of quick_symbol_functions.
395 FIRST and AFTER_LAST indicate the range of compunit symtabs to search.
396 Each symtab within the specified compunit symtab is also searched.
397 AFTER_LAST is one past the last compunit symtab to search; NULL means to
398 search until the end of the list. */
401 iterate_over_some_symtabs (const char *name
,
402 const char *real_path
,
403 struct compunit_symtab
*first
,
404 struct compunit_symtab
*after_last
,
405 gdb::function_view
<bool (symtab
*)> callback
)
407 struct compunit_symtab
*cust
;
408 const char* base_name
= lbasename (name
);
410 for (cust
= first
; cust
!= NULL
&& cust
!= after_last
; cust
= cust
->next
)
412 for (symtab
*s
: compunit_filetabs (cust
))
414 if (compare_filenames_for_search (s
->filename
, name
))
421 /* Before we invoke realpath, which can get expensive when many
422 files are involved, do a quick comparison of the basenames. */
423 if (! basenames_may_differ
424 && FILENAME_CMP (base_name
, lbasename (s
->filename
)) != 0)
427 if (compare_filenames_for_search (symtab_to_fullname (s
), name
))
434 /* If the user gave us an absolute path, try to find the file in
435 this symtab and use its absolute path. */
436 if (real_path
!= NULL
)
438 const char *fullname
= symtab_to_fullname (s
);
440 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
441 gdb_assert (IS_ABSOLUTE_PATH (name
));
442 if (FILENAME_CMP (real_path
, fullname
) == 0)
455 /* Check for a symtab of a specific name; first in symtabs, then in
456 psymtabs. *If* there is no '/' in the name, a match after a '/'
457 in the symtab filename will also work.
459 Calls CALLBACK with each symtab that is found. If CALLBACK returns
460 true, the search stops. */
463 iterate_over_symtabs (const char *name
,
464 gdb::function_view
<bool (symtab
*)> callback
)
466 gdb::unique_xmalloc_ptr
<char> real_path
;
468 /* Here we are interested in canonicalizing an absolute path, not
469 absolutizing a relative path. */
470 if (IS_ABSOLUTE_PATH (name
))
472 real_path
= gdb_realpath (name
);
473 gdb_assert (IS_ABSOLUTE_PATH (real_path
.get ()));
476 for (objfile
*objfile
: all_objfiles (current_program_space
))
478 if (iterate_over_some_symtabs (name
, real_path
.get (),
479 objfile
->compunit_symtabs
, NULL
,
484 /* Same search rules as above apply here, but now we look thru the
487 for (objfile
*objfile
: all_objfiles (current_program_space
))
490 && objfile
->sf
->qf
->map_symtabs_matching_filename (objfile
,
498 /* A wrapper for iterate_over_symtabs that returns the first matching
502 lookup_symtab (const char *name
)
504 struct symtab
*result
= NULL
;
506 iterate_over_symtabs (name
, [&] (symtab
*symtab
)
516 /* Mangle a GDB method stub type. This actually reassembles the pieces of the
517 full method name, which consist of the class name (from T), the unadorned
518 method name from METHOD_ID, and the signature for the specific overload,
519 specified by SIGNATURE_ID. Note that this function is g++ specific. */
522 gdb_mangle_name (struct type
*type
, int method_id
, int signature_id
)
524 int mangled_name_len
;
526 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, method_id
);
527 struct fn_field
*method
= &f
[signature_id
];
528 const char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, method_id
);
529 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, signature_id
);
530 const char *newname
= TYPE_NAME (type
);
532 /* Does the form of physname indicate that it is the full mangled name
533 of a constructor (not just the args)? */
534 int is_full_physname_constructor
;
537 int is_destructor
= is_destructor_name (physname
);
538 /* Need a new type prefix. */
539 const char *const_prefix
= method
->is_const
? "C" : "";
540 const char *volatile_prefix
= method
->is_volatile
? "V" : "";
542 int len
= (newname
== NULL
? 0 : strlen (newname
));
544 /* Nothing to do if physname already contains a fully mangled v3 abi name
545 or an operator name. */
546 if ((physname
[0] == '_' && physname
[1] == 'Z')
547 || is_operator_name (field_name
))
548 return xstrdup (physname
);
550 is_full_physname_constructor
= is_constructor_name (physname
);
552 is_constructor
= is_full_physname_constructor
553 || (newname
&& strcmp (field_name
, newname
) == 0);
556 is_destructor
= (startswith (physname
, "__dt"));
558 if (is_destructor
|| is_full_physname_constructor
)
560 mangled_name
= (char *) xmalloc (strlen (physname
) + 1);
561 strcpy (mangled_name
, physname
);
567 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
569 else if (physname
[0] == 't' || physname
[0] == 'Q')
571 /* The physname for template and qualified methods already includes
573 xsnprintf (buf
, sizeof (buf
), "__%s%s", const_prefix
, volatile_prefix
);
579 xsnprintf (buf
, sizeof (buf
), "__%s%s%d", const_prefix
,
580 volatile_prefix
, len
);
582 mangled_name_len
= ((is_constructor
? 0 : strlen (field_name
))
583 + strlen (buf
) + len
+ strlen (physname
) + 1);
585 mangled_name
= (char *) xmalloc (mangled_name_len
);
587 mangled_name
[0] = '\0';
589 strcpy (mangled_name
, field_name
);
591 strcat (mangled_name
, buf
);
592 /* If the class doesn't have a name, i.e. newname NULL, then we just
593 mangle it using 0 for the length of the class. Thus it gets mangled
594 as something starting with `::' rather than `classname::'. */
596 strcat (mangled_name
, newname
);
598 strcat (mangled_name
, physname
);
599 return (mangled_name
);
602 /* Set the demangled name of GSYMBOL to NAME. NAME must be already
603 correctly allocated. */
606 symbol_set_demangled_name (struct general_symbol_info
*gsymbol
,
608 struct obstack
*obstack
)
610 if (gsymbol
->language
== language_ada
)
614 gsymbol
->ada_mangled
= 0;
615 gsymbol
->language_specific
.obstack
= obstack
;
619 gsymbol
->ada_mangled
= 1;
620 gsymbol
->language_specific
.demangled_name
= name
;
624 gsymbol
->language_specific
.demangled_name
= name
;
627 /* Return the demangled name of GSYMBOL. */
630 symbol_get_demangled_name (const struct general_symbol_info
*gsymbol
)
632 if (gsymbol
->language
== language_ada
)
634 if (!gsymbol
->ada_mangled
)
639 return gsymbol
->language_specific
.demangled_name
;
643 /* Initialize the language dependent portion of a symbol
644 depending upon the language for the symbol. */
647 symbol_set_language (struct general_symbol_info
*gsymbol
,
648 enum language language
,
649 struct obstack
*obstack
)
651 gsymbol
->language
= language
;
652 if (gsymbol
->language
== language_cplus
653 || gsymbol
->language
== language_d
654 || gsymbol
->language
== language_go
655 || gsymbol
->language
== language_objc
656 || gsymbol
->language
== language_fortran
)
658 symbol_set_demangled_name (gsymbol
, NULL
, obstack
);
660 else if (gsymbol
->language
== language_ada
)
662 gdb_assert (gsymbol
->ada_mangled
== 0);
663 gsymbol
->language_specific
.obstack
= obstack
;
667 memset (&gsymbol
->language_specific
, 0,
668 sizeof (gsymbol
->language_specific
));
672 /* Functions to initialize a symbol's mangled name. */
674 /* Objects of this type are stored in the demangled name hash table. */
675 struct demangled_name_entry
681 /* Hash function for the demangled name hash. */
684 hash_demangled_name_entry (const void *data
)
686 const struct demangled_name_entry
*e
687 = (const struct demangled_name_entry
*) data
;
689 return htab_hash_string (e
->mangled
);
692 /* Equality function for the demangled name hash. */
695 eq_demangled_name_entry (const void *a
, const void *b
)
697 const struct demangled_name_entry
*da
698 = (const struct demangled_name_entry
*) a
;
699 const struct demangled_name_entry
*db
700 = (const struct demangled_name_entry
*) b
;
702 return strcmp (da
->mangled
, db
->mangled
) == 0;
705 /* Create the hash table used for demangled names. Each hash entry is
706 a pair of strings; one for the mangled name and one for the demangled
707 name. The entry is hashed via just the mangled name. */
710 create_demangled_names_hash (struct objfile_per_bfd_storage
*per_bfd
)
712 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily.
713 The hash table code will round this up to the next prime number.
714 Choosing a much larger table size wastes memory, and saves only about
715 1% in symbol reading. */
717 per_bfd
->demangled_names_hash
= htab_create_alloc
718 (256, hash_demangled_name_entry
, eq_demangled_name_entry
,
719 NULL
, xcalloc
, xfree
);
722 /* Try to determine the demangled name for a symbol, based on the
723 language of that symbol. If the language is set to language_auto,
724 it will attempt to find any demangling algorithm that works and
725 then set the language appropriately. The returned name is allocated
726 by the demangler and should be xfree'd. */
729 symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
732 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_per_bfd_storage
*per_bfd
)
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
;
782 if (gsymbol
->language
== language_ada
)
784 /* In Ada, we do the symbol lookups using the mangled name, so
785 we can save some space by not storing the demangled name. */
787 gsymbol
->name
= linkage_name
;
790 char *name
= (char *) obstack_alloc (&per_bfd
->storage_obstack
,
793 memcpy (name
, linkage_name
, len
);
795 gsymbol
->name
= name
;
797 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
802 if (per_bfd
->demangled_names_hash
== NULL
)
803 create_demangled_names_hash (per_bfd
);
805 if (linkage_name
[len
] != '\0')
809 alloc_name
= (char *) alloca (len
+ 1);
810 memcpy (alloc_name
, linkage_name
, len
);
811 alloc_name
[len
] = '\0';
813 linkage_name_copy
= alloc_name
;
816 linkage_name_copy
= linkage_name
;
818 /* Set the symbol language. */
819 char *demangled_name_ptr
820 = symbol_find_demangled_name (gsymbol
, linkage_name_copy
);
821 gdb::unique_xmalloc_ptr
<char> demangled_name (demangled_name_ptr
);
823 entry
.mangled
= linkage_name_copy
;
824 slot
= ((struct demangled_name_entry
**)
825 htab_find_slot (per_bfd
->demangled_names_hash
,
828 /* If this name is not in the hash table, add it. */
830 /* A C version of the symbol may have already snuck into the table.
831 This happens to, e.g., main.init (__go_init_main). Cope. */
832 || (gsymbol
->language
== language_go
833 && (*slot
)->demangled
[0] == '\0'))
835 int demangled_len
= demangled_name
? strlen (demangled_name
.get ()) : 0;
837 /* Suppose we have demangled_name==NULL, copy_name==0, and
838 linkage_name_copy==linkage_name. In this case, we already have the
839 mangled name saved, and we don't have a demangled name. So,
840 you might think we could save a little space by not recording
841 this in the hash table at all.
843 It turns out that it is actually important to still save such
844 an entry in the hash table, because storing this name gives
845 us better bcache hit rates for partial symbols. */
846 if (!copy_name
&& linkage_name_copy
== linkage_name
)
849 = ((struct demangled_name_entry
*)
850 obstack_alloc (&per_bfd
->storage_obstack
,
851 offsetof (struct demangled_name_entry
, demangled
)
852 + demangled_len
+ 1));
853 (*slot
)->mangled
= linkage_name
;
859 /* If we must copy the mangled name, put it directly after
860 the demangled name so we can have a single
863 = ((struct demangled_name_entry
*)
864 obstack_alloc (&per_bfd
->storage_obstack
,
865 offsetof (struct demangled_name_entry
, demangled
)
866 + len
+ demangled_len
+ 2));
867 mangled_ptr
= &((*slot
)->demangled
[demangled_len
+ 1]);
868 strcpy (mangled_ptr
, linkage_name_copy
);
869 (*slot
)->mangled
= mangled_ptr
;
872 if (demangled_name
!= NULL
)
873 strcpy ((*slot
)->demangled
, demangled_name
.get());
875 (*slot
)->demangled
[0] = '\0';
878 gsymbol
->name
= (*slot
)->mangled
;
879 if ((*slot
)->demangled
[0] != '\0')
880 symbol_set_demangled_name (gsymbol
, (*slot
)->demangled
,
881 &per_bfd
->storage_obstack
);
883 symbol_set_demangled_name (gsymbol
, NULL
, &per_bfd
->storage_obstack
);
886 /* Return the source code name of a symbol. In languages where
887 demangling is necessary, this is the demangled name. */
890 symbol_natural_name (const struct general_symbol_info
*gsymbol
)
892 switch (gsymbol
->language
)
898 case language_fortran
:
899 if (symbol_get_demangled_name (gsymbol
) != NULL
)
900 return symbol_get_demangled_name (gsymbol
);
903 return ada_decode_symbol (gsymbol
);
907 return gsymbol
->name
;
910 /* Return the demangled name for a symbol based on the language for
911 that symbol. If no demangled name exists, return NULL. */
914 symbol_demangled_name (const struct general_symbol_info
*gsymbol
)
916 const char *dem_name
= NULL
;
918 switch (gsymbol
->language
)
924 case language_fortran
:
925 dem_name
= symbol_get_demangled_name (gsymbol
);
928 dem_name
= ada_decode_symbol (gsymbol
);
936 /* Return the search name of a symbol---generally the demangled or
937 linkage name of the symbol, depending on how it will be searched for.
938 If there is no distinct demangled name, then returns the same value
939 (same pointer) as SYMBOL_LINKAGE_NAME. */
942 symbol_search_name (const struct general_symbol_info
*gsymbol
)
944 if (gsymbol
->language
== language_ada
)
945 return gsymbol
->name
;
947 return symbol_natural_name (gsymbol
);
953 symbol_matches_search_name (const struct general_symbol_info
*gsymbol
,
954 const lookup_name_info
&name
)
956 symbol_name_matcher_ftype
*name_match
957 = get_symbol_name_matcher (language_def (gsymbol
->language
), name
);
958 return name_match (symbol_search_name (gsymbol
), name
, NULL
);
963 /* Return 1 if the two sections are the same, or if they could
964 plausibly be copies of each other, one in an original object
965 file and another in a separated debug file. */
968 matching_obj_sections (struct obj_section
*obj_first
,
969 struct obj_section
*obj_second
)
971 asection
*first
= obj_first
? obj_first
->the_bfd_section
: NULL
;
972 asection
*second
= obj_second
? obj_second
->the_bfd_section
: NULL
;
975 /* If they're the same section, then they match. */
979 /* If either is NULL, give up. */
980 if (first
== NULL
|| second
== NULL
)
983 /* This doesn't apply to absolute symbols. */
984 if (first
->owner
== NULL
|| second
->owner
== NULL
)
987 /* If they're in the same object file, they must be different sections. */
988 if (first
->owner
== second
->owner
)
991 /* Check whether the two sections are potentially corresponding. They must
992 have the same size, address, and name. We can't compare section indexes,
993 which would be more reliable, because some sections may have been
995 if (bfd_get_section_size (first
) != bfd_get_section_size (second
))
998 /* In-memory addresses may start at a different offset, relativize them. */
999 if (bfd_get_section_vma (first
->owner
, first
)
1000 - bfd_get_start_address (first
->owner
)
1001 != bfd_get_section_vma (second
->owner
, second
)
1002 - bfd_get_start_address (second
->owner
))
1005 if (bfd_get_section_name (first
->owner
, first
) == NULL
1006 || bfd_get_section_name (second
->owner
, second
) == NULL
1007 || strcmp (bfd_get_section_name (first
->owner
, first
),
1008 bfd_get_section_name (second
->owner
, second
)) != 0)
1011 /* Otherwise check that they are in corresponding objfiles. */
1013 for (objfile
*objfile
: all_objfiles (current_program_space
))
1014 if (objfile
->obfd
== first
->owner
)
1019 gdb_assert (obj
!= NULL
);
1021 if (obj
->separate_debug_objfile
!= NULL
1022 && obj
->separate_debug_objfile
->obfd
== second
->owner
)
1024 if (obj
->separate_debug_objfile_backlink
!= NULL
1025 && obj
->separate_debug_objfile_backlink
->obfd
== second
->owner
)
1034 expand_symtab_containing_pc (CORE_ADDR pc
, struct obj_section
*section
)
1036 struct bound_minimal_symbol msymbol
;
1038 /* If we know that this is not a text address, return failure. This is
1039 necessary because we loop based on texthigh and textlow, which do
1040 not include the data ranges. */
1041 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
1043 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
1044 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
1045 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
1046 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
1047 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
1050 for (objfile
*objfile
: all_objfiles (current_program_space
))
1052 struct compunit_symtab
*cust
= NULL
;
1055 cust
= objfile
->sf
->qf
->find_pc_sect_compunit_symtab (objfile
, msymbol
,
1062 /* Hash function for the symbol cache. */
1065 hash_symbol_entry (const struct objfile
*objfile_context
,
1066 const char *name
, domain_enum domain
)
1068 unsigned int hash
= (uintptr_t) objfile_context
;
1071 hash
+= htab_hash_string (name
);
1073 /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN
1074 to map to the same slot. */
1075 if (domain
== STRUCT_DOMAIN
)
1076 hash
+= VAR_DOMAIN
* 7;
1083 /* Equality function for the symbol cache. */
1086 eq_symbol_entry (const struct symbol_cache_slot
*slot
,
1087 const struct objfile
*objfile_context
,
1088 const char *name
, domain_enum domain
)
1090 const char *slot_name
;
1091 domain_enum slot_domain
;
1093 if (slot
->state
== SYMBOL_SLOT_UNUSED
)
1096 if (slot
->objfile_context
!= objfile_context
)
1099 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1101 slot_name
= slot
->value
.not_found
.name
;
1102 slot_domain
= slot
->value
.not_found
.domain
;
1106 slot_name
= SYMBOL_SEARCH_NAME (slot
->value
.found
.symbol
);
1107 slot_domain
= SYMBOL_DOMAIN (slot
->value
.found
.symbol
);
1110 /* NULL names match. */
1111 if (slot_name
== NULL
&& name
== NULL
)
1113 /* But there's no point in calling symbol_matches_domain in the
1114 SYMBOL_SLOT_FOUND case. */
1115 if (slot_domain
!= domain
)
1118 else if (slot_name
!= NULL
&& name
!= NULL
)
1120 /* It's important that we use the same comparison that was done
1121 the first time through. If the slot records a found symbol,
1122 then this means using the symbol name comparison function of
1123 the symbol's language with SYMBOL_SEARCH_NAME. See
1124 dictionary.c. It also means using symbol_matches_domain for
1125 found symbols. See block.c.
1127 If the slot records a not-found symbol, then require a precise match.
1128 We could still be lax with whitespace like strcmp_iw though. */
1130 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1132 if (strcmp (slot_name
, name
) != 0)
1134 if (slot_domain
!= domain
)
1139 struct symbol
*sym
= slot
->value
.found
.symbol
;
1140 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1142 if (!SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
1145 if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
1146 slot_domain
, domain
))
1152 /* Only one name is NULL. */
1159 /* Given a cache of size SIZE, return the size of the struct (with variable
1160 length array) in bytes. */
1163 symbol_cache_byte_size (unsigned int size
)
1165 return (sizeof (struct block_symbol_cache
)
1166 + ((size
- 1) * sizeof (struct symbol_cache_slot
)));
1172 resize_symbol_cache (struct symbol_cache
*cache
, unsigned int new_size
)
1174 /* If there's no change in size, don't do anything.
1175 All caches have the same size, so we can just compare with the size
1176 of the global symbols cache. */
1177 if ((cache
->global_symbols
!= NULL
1178 && cache
->global_symbols
->size
== new_size
)
1179 || (cache
->global_symbols
== NULL
1183 xfree (cache
->global_symbols
);
1184 xfree (cache
->static_symbols
);
1188 cache
->global_symbols
= NULL
;
1189 cache
->static_symbols
= NULL
;
1193 size_t total_size
= symbol_cache_byte_size (new_size
);
1195 cache
->global_symbols
1196 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1197 cache
->static_symbols
1198 = (struct block_symbol_cache
*) xcalloc (1, total_size
);
1199 cache
->global_symbols
->size
= new_size
;
1200 cache
->static_symbols
->size
= new_size
;
1204 /* Make a symbol cache of size SIZE. */
1206 static struct symbol_cache
*
1207 make_symbol_cache (unsigned int size
)
1209 struct symbol_cache
*cache
;
1211 cache
= XCNEW (struct symbol_cache
);
1212 resize_symbol_cache (cache
, symbol_cache_size
);
1216 /* Free the space used by CACHE. */
1219 free_symbol_cache (struct symbol_cache
*cache
)
1221 xfree (cache
->global_symbols
);
1222 xfree (cache
->static_symbols
);
1226 /* Return the symbol cache of PSPACE.
1227 Create one if it doesn't exist yet. */
1229 static struct symbol_cache
*
1230 get_symbol_cache (struct program_space
*pspace
)
1232 struct symbol_cache
*cache
1233 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1237 cache
= make_symbol_cache (symbol_cache_size
);
1238 set_program_space_data (pspace
, symbol_cache_key
, cache
);
1244 /* Delete the symbol cache of PSPACE.
1245 Called when PSPACE is destroyed. */
1248 symbol_cache_cleanup (struct program_space
*pspace
, void *data
)
1250 struct symbol_cache
*cache
= (struct symbol_cache
*) data
;
1252 free_symbol_cache (cache
);
1255 /* Set the size of the symbol cache in all program spaces. */
1258 set_symbol_cache_size (unsigned int new_size
)
1260 struct program_space
*pspace
;
1262 ALL_PSPACES (pspace
)
1264 struct symbol_cache
*cache
1265 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1267 /* The pspace could have been created but not have a cache yet. */
1269 resize_symbol_cache (cache
, new_size
);
1273 /* Called when symbol-cache-size is set. */
1276 set_symbol_cache_size_handler (const char *args
, int from_tty
,
1277 struct cmd_list_element
*c
)
1279 if (new_symbol_cache_size
> MAX_SYMBOL_CACHE_SIZE
)
1281 /* Restore the previous value.
1282 This is the value the "show" command prints. */
1283 new_symbol_cache_size
= symbol_cache_size
;
1285 error (_("Symbol cache size is too large, max is %u."),
1286 MAX_SYMBOL_CACHE_SIZE
);
1288 symbol_cache_size
= new_symbol_cache_size
;
1290 set_symbol_cache_size (symbol_cache_size
);
1293 /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE.
1294 OBJFILE_CONTEXT is the current objfile, which may be NULL.
1295 The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup
1296 failed (and thus this one will too), or NULL if the symbol is not present
1298 If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are
1299 set to the cache and slot of the symbol to save the result of a full lookup
1302 static struct block_symbol
1303 symbol_cache_lookup (struct symbol_cache
*cache
,
1304 struct objfile
*objfile_context
, int block
,
1305 const char *name
, domain_enum domain
,
1306 struct block_symbol_cache
**bsc_ptr
,
1307 struct symbol_cache_slot
**slot_ptr
)
1309 struct block_symbol_cache
*bsc
;
1311 struct symbol_cache_slot
*slot
;
1313 if (block
== GLOBAL_BLOCK
)
1314 bsc
= cache
->global_symbols
;
1316 bsc
= cache
->static_symbols
;
1321 return (struct block_symbol
) {NULL
, NULL
};
1324 hash
= hash_symbol_entry (objfile_context
, name
, domain
);
1325 slot
= bsc
->symbols
+ hash
% bsc
->size
;
1327 if (eq_symbol_entry (slot
, objfile_context
, name
, domain
))
1329 if (symbol_lookup_debug
)
1330 fprintf_unfiltered (gdb_stdlog
,
1331 "%s block symbol cache hit%s for %s, %s\n",
1332 block
== GLOBAL_BLOCK
? "Global" : "Static",
1333 slot
->state
== SYMBOL_SLOT_NOT_FOUND
1334 ? " (not found)" : "",
1335 name
, domain_name (domain
));
1337 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1338 return SYMBOL_LOOKUP_FAILED
;
1339 return slot
->value
.found
;
1342 /* Symbol is not present in the cache. */
1347 if (symbol_lookup_debug
)
1349 fprintf_unfiltered (gdb_stdlog
,
1350 "%s block symbol cache miss for %s, %s\n",
1351 block
== GLOBAL_BLOCK
? "Global" : "Static",
1352 name
, domain_name (domain
));
1355 return (struct block_symbol
) {NULL
, NULL
};
1358 /* Clear out SLOT. */
1361 symbol_cache_clear_slot (struct symbol_cache_slot
*slot
)
1363 if (slot
->state
== SYMBOL_SLOT_NOT_FOUND
)
1364 xfree (slot
->value
.not_found
.name
);
1365 slot
->state
= SYMBOL_SLOT_UNUSED
;
1368 /* Mark SYMBOL as found in SLOT.
1369 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1370 if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not*
1371 necessarily the objfile the symbol was found in. */
1374 symbol_cache_mark_found (struct block_symbol_cache
*bsc
,
1375 struct symbol_cache_slot
*slot
,
1376 struct objfile
*objfile_context
,
1377 struct symbol
*symbol
,
1378 const struct block
*block
)
1382 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1385 symbol_cache_clear_slot (slot
);
1387 slot
->state
= SYMBOL_SLOT_FOUND
;
1388 slot
->objfile_context
= objfile_context
;
1389 slot
->value
.found
.symbol
= symbol
;
1390 slot
->value
.found
.block
= block
;
1393 /* Mark symbol NAME, DOMAIN as not found in SLOT.
1394 OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
1395 if it's not needed to distinguish lookups (STATIC_BLOCK). */
1398 symbol_cache_mark_not_found (struct block_symbol_cache
*bsc
,
1399 struct symbol_cache_slot
*slot
,
1400 struct objfile
*objfile_context
,
1401 const char *name
, domain_enum domain
)
1405 if (slot
->state
!= SYMBOL_SLOT_UNUSED
)
1408 symbol_cache_clear_slot (slot
);
1410 slot
->state
= SYMBOL_SLOT_NOT_FOUND
;
1411 slot
->objfile_context
= objfile_context
;
1412 slot
->value
.not_found
.name
= xstrdup (name
);
1413 slot
->value
.not_found
.domain
= domain
;
1416 /* Flush the symbol cache of PSPACE. */
1419 symbol_cache_flush (struct program_space
*pspace
)
1421 struct symbol_cache
*cache
1422 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1427 if (cache
->global_symbols
== NULL
)
1429 gdb_assert (symbol_cache_size
== 0);
1430 gdb_assert (cache
->static_symbols
== NULL
);
1434 /* If the cache is untouched since the last flush, early exit.
1435 This is important for performance during the startup of a program linked
1436 with 100s (or 1000s) of shared libraries. */
1437 if (cache
->global_symbols
->misses
== 0
1438 && cache
->static_symbols
->misses
== 0)
1441 gdb_assert (cache
->global_symbols
->size
== symbol_cache_size
);
1442 gdb_assert (cache
->static_symbols
->size
== symbol_cache_size
);
1444 for (pass
= 0; pass
< 2; ++pass
)
1446 struct block_symbol_cache
*bsc
1447 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1450 for (i
= 0; i
< bsc
->size
; ++i
)
1451 symbol_cache_clear_slot (&bsc
->symbols
[i
]);
1454 cache
->global_symbols
->hits
= 0;
1455 cache
->global_symbols
->misses
= 0;
1456 cache
->global_symbols
->collisions
= 0;
1457 cache
->static_symbols
->hits
= 0;
1458 cache
->static_symbols
->misses
= 0;
1459 cache
->static_symbols
->collisions
= 0;
1465 symbol_cache_dump (const struct symbol_cache
*cache
)
1469 if (cache
->global_symbols
== NULL
)
1471 printf_filtered (" <disabled>\n");
1475 for (pass
= 0; pass
< 2; ++pass
)
1477 const struct block_symbol_cache
*bsc
1478 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1482 printf_filtered ("Global symbols:\n");
1484 printf_filtered ("Static symbols:\n");
1486 for (i
= 0; i
< bsc
->size
; ++i
)
1488 const struct symbol_cache_slot
*slot
= &bsc
->symbols
[i
];
1492 switch (slot
->state
)
1494 case SYMBOL_SLOT_UNUSED
:
1496 case SYMBOL_SLOT_NOT_FOUND
:
1497 printf_filtered (" [%4u] = %s, %s %s (not found)\n", i
,
1498 host_address_to_string (slot
->objfile_context
),
1499 slot
->value
.not_found
.name
,
1500 domain_name (slot
->value
.not_found
.domain
));
1502 case SYMBOL_SLOT_FOUND
:
1504 struct symbol
*found
= slot
->value
.found
.symbol
;
1505 const struct objfile
*context
= slot
->objfile_context
;
1507 printf_filtered (" [%4u] = %s, %s %s\n", i
,
1508 host_address_to_string (context
),
1509 SYMBOL_PRINT_NAME (found
),
1510 domain_name (SYMBOL_DOMAIN (found
)));
1518 /* The "mt print symbol-cache" command. */
1521 maintenance_print_symbol_cache (const char *args
, int from_tty
)
1523 struct program_space
*pspace
;
1525 ALL_PSPACES (pspace
)
1527 struct symbol_cache
*cache
;
1529 printf_filtered (_("Symbol cache for pspace %d\n%s:\n"),
1531 pspace
->symfile_object_file
!= NULL
1532 ? objfile_name (pspace
->symfile_object_file
)
1533 : "(no object file)");
1535 /* If the cache hasn't been created yet, avoid creating one. */
1537 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1539 printf_filtered (" <empty>\n");
1541 symbol_cache_dump (cache
);
1545 /* The "mt flush-symbol-cache" command. */
1548 maintenance_flush_symbol_cache (const char *args
, int from_tty
)
1550 struct program_space
*pspace
;
1552 ALL_PSPACES (pspace
)
1554 symbol_cache_flush (pspace
);
1558 /* Print usage statistics of CACHE. */
1561 symbol_cache_stats (struct symbol_cache
*cache
)
1565 if (cache
->global_symbols
== NULL
)
1567 printf_filtered (" <disabled>\n");
1571 for (pass
= 0; pass
< 2; ++pass
)
1573 const struct block_symbol_cache
*bsc
1574 = pass
== 0 ? cache
->global_symbols
: cache
->static_symbols
;
1579 printf_filtered ("Global block cache stats:\n");
1581 printf_filtered ("Static block cache stats:\n");
1583 printf_filtered (" size: %u\n", bsc
->size
);
1584 printf_filtered (" hits: %u\n", bsc
->hits
);
1585 printf_filtered (" misses: %u\n", bsc
->misses
);
1586 printf_filtered (" collisions: %u\n", bsc
->collisions
);
1590 /* The "mt print symbol-cache-statistics" command. */
1593 maintenance_print_symbol_cache_statistics (const char *args
, int from_tty
)
1595 struct program_space
*pspace
;
1597 ALL_PSPACES (pspace
)
1599 struct symbol_cache
*cache
;
1601 printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"),
1603 pspace
->symfile_object_file
!= NULL
1604 ? objfile_name (pspace
->symfile_object_file
)
1605 : "(no object file)");
1607 /* If the cache hasn't been created yet, avoid creating one. */
1609 = (struct symbol_cache
*) program_space_data (pspace
, symbol_cache_key
);
1611 printf_filtered (" empty, no stats available\n");
1613 symbol_cache_stats (cache
);
1617 /* This module's 'new_objfile' observer. */
1620 symtab_new_objfile_observer (struct objfile
*objfile
)
1622 /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */
1623 symbol_cache_flush (current_program_space
);
1626 /* This module's 'free_objfile' observer. */
1629 symtab_free_objfile_observer (struct objfile
*objfile
)
1631 symbol_cache_flush (objfile
->pspace
);
1634 /* Debug symbols usually don't have section information. We need to dig that
1635 out of the minimal symbols and stash that in the debug symbol. */
1638 fixup_section (struct general_symbol_info
*ginfo
,
1639 CORE_ADDR addr
, struct objfile
*objfile
)
1641 struct minimal_symbol
*msym
;
1643 /* First, check whether a minimal symbol with the same name exists
1644 and points to the same address. The address check is required
1645 e.g. on PowerPC64, where the minimal symbol for a function will
1646 point to the function descriptor, while the debug symbol will
1647 point to the actual function code. */
1648 msym
= lookup_minimal_symbol_by_pc_name (addr
, ginfo
->name
, objfile
);
1650 ginfo
->section
= MSYMBOL_SECTION (msym
);
1653 /* Static, function-local variables do appear in the linker
1654 (minimal) symbols, but are frequently given names that won't
1655 be found via lookup_minimal_symbol(). E.g., it has been
1656 observed in frv-uclinux (ELF) executables that a static,
1657 function-local variable named "foo" might appear in the
1658 linker symbols as "foo.6" or "foo.3". Thus, there is no
1659 point in attempting to extend the lookup-by-name mechanism to
1660 handle this case due to the fact that there can be multiple
1663 So, instead, search the section table when lookup by name has
1664 failed. The ``addr'' and ``endaddr'' fields may have already
1665 been relocated. If so, the relocation offset (i.e. the
1666 ANOFFSET value) needs to be subtracted from these values when
1667 performing the comparison. We unconditionally subtract it,
1668 because, when no relocation has been performed, the ANOFFSET
1669 value will simply be zero.
1671 The address of the symbol whose section we're fixing up HAS
1672 NOT BEEN adjusted (relocated) yet. It can't have been since
1673 the section isn't yet known and knowing the section is
1674 necessary in order to add the correct relocation value. In
1675 other words, we wouldn't even be in this function (attempting
1676 to compute the section) if it were already known.
1678 Note that it is possible to search the minimal symbols
1679 (subtracting the relocation value if necessary) to find the
1680 matching minimal symbol, but this is overkill and much less
1681 efficient. It is not necessary to find the matching minimal
1682 symbol, only its section.
1684 Note that this technique (of doing a section table search)
1685 can fail when unrelocated section addresses overlap. For
1686 this reason, we still attempt a lookup by name prior to doing
1687 a search of the section table. */
1689 struct obj_section
*s
;
1692 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1694 int idx
= s
- objfile
->sections
;
1695 CORE_ADDR offset
= ANOFFSET (objfile
->section_offsets
, idx
);
1700 if (obj_section_addr (s
) - offset
<= addr
1701 && addr
< obj_section_endaddr (s
) - offset
)
1703 ginfo
->section
= idx
;
1708 /* If we didn't find the section, assume it is in the first
1709 section. If there is no allocated section, then it hardly
1710 matters what we pick, so just pick zero. */
1714 ginfo
->section
= fallback
;
1719 fixup_symbol_section (struct symbol
*sym
, struct objfile
*objfile
)
1726 if (!SYMBOL_OBJFILE_OWNED (sym
))
1729 /* We either have an OBJFILE, or we can get at it from the sym's
1730 symtab. Anything else is a bug. */
1731 gdb_assert (objfile
|| symbol_symtab (sym
));
1733 if (objfile
== NULL
)
1734 objfile
= symbol_objfile (sym
);
1736 if (SYMBOL_OBJ_SECTION (objfile
, sym
))
1739 /* We should have an objfile by now. */
1740 gdb_assert (objfile
);
1742 switch (SYMBOL_CLASS (sym
))
1746 addr
= SYMBOL_VALUE_ADDRESS (sym
);
1749 addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1753 /* Nothing else will be listed in the minsyms -- no use looking
1758 fixup_section (&sym
->ginfo
, addr
, objfile
);
1765 demangle_for_lookup_info::demangle_for_lookup_info
1766 (const lookup_name_info
&lookup_name
, language lang
)
1768 demangle_result_storage storage
;
1770 if (lookup_name
.ignore_parameters () && lang
== language_cplus
)
1772 gdb::unique_xmalloc_ptr
<char> without_params
1773 = cp_remove_params_if_any (lookup_name
.name ().c_str (),
1774 lookup_name
.completion_mode ());
1776 if (without_params
!= NULL
)
1778 if (lookup_name
.match_type () != symbol_name_match_type::SEARCH_NAME
)
1779 m_demangled_name
= demangle_for_lookup (without_params
.get (),
1785 if (lookup_name
.match_type () == symbol_name_match_type::SEARCH_NAME
)
1786 m_demangled_name
= lookup_name
.name ();
1788 m_demangled_name
= demangle_for_lookup (lookup_name
.name ().c_str (),
1794 const lookup_name_info
&
1795 lookup_name_info::match_any ()
1797 /* Lookup any symbol that "" would complete. I.e., this matches all
1799 static const lookup_name_info
lookup_name ({}, symbol_name_match_type::FULL
,
1805 /* Compute the demangled form of NAME as used by the various symbol
1806 lookup functions. The result can either be the input NAME
1807 directly, or a pointer to a buffer owned by the STORAGE object.
1809 For Ada, this function just returns NAME, unmodified.
1810 Normally, Ada symbol lookups are performed using the encoded name
1811 rather than the demangled name, and so it might seem to make sense
1812 for this function to return an encoded version of NAME.
1813 Unfortunately, we cannot do this, because this function is used in
1814 circumstances where it is not appropriate to try to encode NAME.
1815 For instance, when displaying the frame info, we demangle the name
1816 of each parameter, and then perform a symbol lookup inside our
1817 function using that demangled name. In Ada, certain functions
1818 have internally-generated parameters whose name contain uppercase
1819 characters. Encoding those name would result in those uppercase
1820 characters to become lowercase, and thus cause the symbol lookup
1824 demangle_for_lookup (const char *name
, enum language lang
,
1825 demangle_result_storage
&storage
)
1827 /* If we are using C++, D, or Go, demangle the name before doing a
1828 lookup, so we can always binary search. */
1829 if (lang
== language_cplus
)
1831 char *demangled_name
= gdb_demangle (name
, DMGL_ANSI
| DMGL_PARAMS
);
1832 if (demangled_name
!= NULL
)
1833 return storage
.set_malloc_ptr (demangled_name
);
1835 /* If we were given a non-mangled name, canonicalize it
1836 according to the language (so far only for C++). */
1837 std::string canon
= cp_canonicalize_string (name
);
1838 if (!canon
.empty ())
1839 return storage
.swap_string (canon
);
1841 else if (lang
== language_d
)
1843 char *demangled_name
= d_demangle (name
, 0);
1844 if (demangled_name
!= NULL
)
1845 return storage
.set_malloc_ptr (demangled_name
);
1847 else if (lang
== language_go
)
1849 char *demangled_name
= go_demangle (name
, 0);
1850 if (demangled_name
!= NULL
)
1851 return storage
.set_malloc_ptr (demangled_name
);
1860 search_name_hash (enum language language
, const char *search_name
)
1862 return language_def (language
)->la_search_name_hash (search_name
);
1867 This function (or rather its subordinates) have a bunch of loops and
1868 it would seem to be attractive to put in some QUIT's (though I'm not really
1869 sure whether it can run long enough to be really important). But there
1870 are a few calls for which it would appear to be bad news to quit
1871 out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note
1872 that there is C++ code below which can error(), but that probably
1873 doesn't affect these calls since they are looking for a known
1874 variable and thus can probably assume it will never hit the C++
1878 lookup_symbol_in_language (const char *name
, const struct block
*block
,
1879 const domain_enum domain
, enum language lang
,
1880 struct field_of_this_result
*is_a_field_of_this
)
1882 demangle_result_storage storage
;
1883 const char *modified_name
= demangle_for_lookup (name
, lang
, storage
);
1885 return lookup_symbol_aux (modified_name
,
1886 symbol_name_match_type::FULL
,
1887 block
, domain
, lang
,
1888 is_a_field_of_this
);
1894 lookup_symbol (const char *name
, const struct block
*block
,
1896 struct field_of_this_result
*is_a_field_of_this
)
1898 return lookup_symbol_in_language (name
, block
, domain
,
1899 current_language
->la_language
,
1900 is_a_field_of_this
);
1906 lookup_symbol_search_name (const char *search_name
, const struct block
*block
,
1909 return lookup_symbol_aux (search_name
, symbol_name_match_type::SEARCH_NAME
,
1910 block
, domain
, language_asm
, NULL
);
1916 lookup_language_this (const struct language_defn
*lang
,
1917 const struct block
*block
)
1919 if (lang
->la_name_of_this
== NULL
|| block
== NULL
)
1920 return (struct block_symbol
) {NULL
, NULL
};
1922 if (symbol_lookup_debug
> 1)
1924 struct objfile
*objfile
= lookup_objfile_from_block (block
);
1926 fprintf_unfiltered (gdb_stdlog
,
1927 "lookup_language_this (%s, %s (objfile %s))",
1928 lang
->la_name
, host_address_to_string (block
),
1929 objfile_debug_name (objfile
));
1936 sym
= block_lookup_symbol (block
, lang
->la_name_of_this
,
1937 symbol_name_match_type::SEARCH_NAME
,
1941 if (symbol_lookup_debug
> 1)
1943 fprintf_unfiltered (gdb_stdlog
, " = %s (%s, block %s)\n",
1944 SYMBOL_PRINT_NAME (sym
),
1945 host_address_to_string (sym
),
1946 host_address_to_string (block
));
1948 return (struct block_symbol
) {sym
, block
};
1950 if (BLOCK_FUNCTION (block
))
1952 block
= BLOCK_SUPERBLOCK (block
);
1955 if (symbol_lookup_debug
> 1)
1956 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1957 return (struct block_symbol
) {NULL
, NULL
};
1960 /* Given TYPE, a structure/union,
1961 return 1 if the component named NAME from the ultimate target
1962 structure/union is defined, otherwise, return 0. */
1965 check_field (struct type
*type
, const char *name
,
1966 struct field_of_this_result
*is_a_field_of_this
)
1970 /* The type may be a stub. */
1971 type
= check_typedef (type
);
1973 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1975 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1977 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1979 is_a_field_of_this
->type
= type
;
1980 is_a_field_of_this
->field
= &TYPE_FIELD (type
, i
);
1985 /* C++: If it was not found as a data field, then try to return it
1986 as a pointer to a method. */
1988 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1990 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
1992 is_a_field_of_this
->type
= type
;
1993 is_a_field_of_this
->fn_field
= &TYPE_FN_FIELDLIST (type
, i
);
1998 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1999 if (check_field (TYPE_BASECLASS (type
, i
), name
, is_a_field_of_this
))
2005 /* Behave like lookup_symbol except that NAME is the natural name
2006 (e.g., demangled name) of the symbol that we're looking for. */
2008 static struct block_symbol
2009 lookup_symbol_aux (const char *name
, symbol_name_match_type match_type
,
2010 const struct block
*block
,
2011 const domain_enum domain
, enum language language
,
2012 struct field_of_this_result
*is_a_field_of_this
)
2014 struct block_symbol result
;
2015 const struct language_defn
*langdef
;
2017 if (symbol_lookup_debug
)
2019 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2021 fprintf_unfiltered (gdb_stdlog
,
2022 "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
2023 name
, host_address_to_string (block
),
2025 ? objfile_debug_name (objfile
) : "NULL",
2026 domain_name (domain
), language_str (language
));
2029 /* Make sure we do something sensible with is_a_field_of_this, since
2030 the callers that set this parameter to some non-null value will
2031 certainly use it later. If we don't set it, the contents of
2032 is_a_field_of_this are undefined. */
2033 if (is_a_field_of_this
!= NULL
)
2034 memset (is_a_field_of_this
, 0, sizeof (*is_a_field_of_this
));
2036 /* Search specified block and its superiors. Don't search
2037 STATIC_BLOCK or GLOBAL_BLOCK. */
2039 result
= lookup_local_symbol (name
, match_type
, block
, domain
, language
);
2040 if (result
.symbol
!= NULL
)
2042 if (symbol_lookup_debug
)
2044 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2045 host_address_to_string (result
.symbol
));
2050 /* If requested to do so by the caller and if appropriate for LANGUAGE,
2051 check to see if NAME is a field of `this'. */
2053 langdef
= language_def (language
);
2055 /* Don't do this check if we are searching for a struct. It will
2056 not be found by check_field, but will be found by other
2058 if (is_a_field_of_this
!= NULL
&& domain
!= STRUCT_DOMAIN
)
2060 result
= lookup_language_this (langdef
, block
);
2064 struct type
*t
= result
.symbol
->type
;
2066 /* I'm not really sure that type of this can ever
2067 be typedefed; just be safe. */
2068 t
= check_typedef (t
);
2069 if (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2070 t
= TYPE_TARGET_TYPE (t
);
2072 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2073 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2074 error (_("Internal error: `%s' is not an aggregate"),
2075 langdef
->la_name_of_this
);
2077 if (check_field (t
, name
, is_a_field_of_this
))
2079 if (symbol_lookup_debug
)
2081 fprintf_unfiltered (gdb_stdlog
,
2082 "lookup_symbol_aux (...) = NULL\n");
2084 return (struct block_symbol
) {NULL
, NULL
};
2089 /* Now do whatever is appropriate for LANGUAGE to look
2090 up static and global variables. */
2092 result
= langdef
->la_lookup_symbol_nonlocal (langdef
, name
, block
, domain
);
2093 if (result
.symbol
!= NULL
)
2095 if (symbol_lookup_debug
)
2097 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2098 host_address_to_string (result
.symbol
));
2103 /* Now search all static file-level symbols. Not strictly correct,
2104 but more useful than an error. */
2106 result
= lookup_static_symbol (name
, domain
);
2107 if (symbol_lookup_debug
)
2109 fprintf_unfiltered (gdb_stdlog
, "lookup_symbol_aux (...) = %s\n",
2110 result
.symbol
!= NULL
2111 ? host_address_to_string (result
.symbol
)
2117 /* Check to see if the symbol is defined in BLOCK or its superiors.
2118 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */
2120 static struct block_symbol
2121 lookup_local_symbol (const char *name
,
2122 symbol_name_match_type match_type
,
2123 const struct block
*block
,
2124 const domain_enum domain
,
2125 enum language language
)
2128 const struct block
*static_block
= block_static_block (block
);
2129 const char *scope
= block_scope (block
);
2131 /* Check if either no block is specified or it's a global block. */
2133 if (static_block
== NULL
)
2134 return (struct block_symbol
) {NULL
, NULL
};
2136 while (block
!= static_block
)
2138 sym
= lookup_symbol_in_block (name
, match_type
, block
, domain
);
2140 return (struct block_symbol
) {sym
, block
};
2142 if (language
== language_cplus
|| language
== language_fortran
)
2144 struct block_symbol blocksym
2145 = cp_lookup_symbol_imports_or_template (scope
, name
, block
,
2148 if (blocksym
.symbol
!= NULL
)
2152 if (BLOCK_FUNCTION (block
) != NULL
&& block_inlined_p (block
))
2154 block
= BLOCK_SUPERBLOCK (block
);
2157 /* We've reached the end of the function without finding a result. */
2159 return (struct block_symbol
) {NULL
, NULL
};
2165 lookup_objfile_from_block (const struct block
*block
)
2170 block
= block_global_block (block
);
2171 /* Look through all blockvectors. */
2172 for (objfile
*obj
: all_objfiles (current_program_space
))
2174 for (compunit_symtab
*cust
: objfile_compunits (obj
))
2175 if (block
== BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
),
2178 if (obj
->separate_debug_objfile_backlink
)
2179 obj
= obj
->separate_debug_objfile_backlink
;
2191 lookup_symbol_in_block (const char *name
, symbol_name_match_type match_type
,
2192 const struct block
*block
,
2193 const domain_enum domain
)
2197 if (symbol_lookup_debug
> 1)
2199 struct objfile
*objfile
= lookup_objfile_from_block (block
);
2201 fprintf_unfiltered (gdb_stdlog
,
2202 "lookup_symbol_in_block (%s, %s (objfile %s), %s)",
2203 name
, host_address_to_string (block
),
2204 objfile_debug_name (objfile
),
2205 domain_name (domain
));
2208 sym
= block_lookup_symbol (block
, name
, match_type
, domain
);
2211 if (symbol_lookup_debug
> 1)
2213 fprintf_unfiltered (gdb_stdlog
, " = %s\n",
2214 host_address_to_string (sym
));
2216 return fixup_symbol_section (sym
, NULL
);
2219 if (symbol_lookup_debug
> 1)
2220 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2227 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
2229 const domain_enum domain
)
2231 struct objfile
*objfile
;
2233 for (objfile
= main_objfile
;
2235 objfile
= objfile_separate_debug_iterate (main_objfile
, objfile
))
2237 struct block_symbol result
2238 = lookup_symbol_in_objfile (objfile
, GLOBAL_BLOCK
, name
, domain
);
2240 if (result
.symbol
!= NULL
)
2244 return (struct block_symbol
) {NULL
, NULL
};
2247 /* Check to see if the symbol is defined in one of the OBJFILE's
2248 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK,
2249 depending on whether or not we want to search global symbols or
2252 static struct block_symbol
2253 lookup_symbol_in_objfile_symtabs (struct objfile
*objfile
, int block_index
,
2254 const char *name
, const domain_enum domain
)
2256 gdb_assert (block_index
== GLOBAL_BLOCK
|| block_index
== STATIC_BLOCK
);
2258 if (symbol_lookup_debug
> 1)
2260 fprintf_unfiltered (gdb_stdlog
,
2261 "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
2262 objfile_debug_name (objfile
),
2263 block_index
== GLOBAL_BLOCK
2264 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2265 name
, domain_name (domain
));
2268 for (compunit_symtab
*cust
: objfile_compunits (objfile
))
2270 const struct blockvector
*bv
;
2271 const struct block
*block
;
2272 struct block_symbol result
;
2274 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2275 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2276 result
.symbol
= block_lookup_symbol_primary (block
, name
, domain
);
2277 result
.block
= block
;
2278 if (result
.symbol
!= NULL
)
2280 if (symbol_lookup_debug
> 1)
2282 fprintf_unfiltered (gdb_stdlog
, " = %s (block %s)\n",
2283 host_address_to_string (result
.symbol
),
2284 host_address_to_string (block
));
2286 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2292 if (symbol_lookup_debug
> 1)
2293 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
2294 return (struct block_symbol
) {NULL
, NULL
};
2297 /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols.
2298 Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
2299 and all associated separate debug objfiles.
2301 Normally we only look in OBJFILE, and not any separate debug objfiles
2302 because the outer loop will cause them to be searched too. This case is
2303 different. Here we're called from search_symbols where it will only
2304 call us for the the objfile that contains a matching minsym. */
2306 static struct block_symbol
2307 lookup_symbol_in_objfile_from_linkage_name (struct objfile
*objfile
,
2308 const char *linkage_name
,
2311 enum language lang
= current_language
->la_language
;
2312 struct objfile
*main_objfile
, *cur_objfile
;
2314 demangle_result_storage storage
;
2315 const char *modified_name
= demangle_for_lookup (linkage_name
, lang
, storage
);
2317 if (objfile
->separate_debug_objfile_backlink
)
2318 main_objfile
= objfile
->separate_debug_objfile_backlink
;
2320 main_objfile
= objfile
;
2322 for (cur_objfile
= main_objfile
;
2324 cur_objfile
= objfile_separate_debug_iterate (main_objfile
, cur_objfile
))
2326 struct block_symbol result
;
2328 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, GLOBAL_BLOCK
,
2329 modified_name
, domain
);
2330 if (result
.symbol
== NULL
)
2331 result
= lookup_symbol_in_objfile_symtabs (cur_objfile
, STATIC_BLOCK
,
2332 modified_name
, domain
);
2333 if (result
.symbol
!= NULL
)
2337 return (struct block_symbol
) {NULL
, NULL
};
2340 /* A helper function that throws an exception when a symbol was found
2341 in a psymtab but not in a symtab. */
2343 static void ATTRIBUTE_NORETURN
2344 error_in_psymtab_expansion (int block_index
, const char *name
,
2345 struct compunit_symtab
*cust
)
2348 Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\
2349 %s may be an inlined function, or may be a template function\n \
2350 (if a template, try specifying an instantiation: %s<type>)."),
2351 block_index
== GLOBAL_BLOCK
? "global" : "static",
2353 symtab_to_filename_for_display (compunit_primary_filetab (cust
)),
2357 /* A helper function for various lookup routines that interfaces with
2358 the "quick" symbol table functions. */
2360 static struct block_symbol
2361 lookup_symbol_via_quick_fns (struct objfile
*objfile
, int block_index
,
2362 const char *name
, const domain_enum domain
)
2364 struct compunit_symtab
*cust
;
2365 const struct blockvector
*bv
;
2366 const struct block
*block
;
2367 struct block_symbol result
;
2370 return (struct block_symbol
) {NULL
, NULL
};
2372 if (symbol_lookup_debug
> 1)
2374 fprintf_unfiltered (gdb_stdlog
,
2375 "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
2376 objfile_debug_name (objfile
),
2377 block_index
== GLOBAL_BLOCK
2378 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2379 name
, domain_name (domain
));
2382 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
, domain
);
2385 if (symbol_lookup_debug
> 1)
2387 fprintf_unfiltered (gdb_stdlog
,
2388 "lookup_symbol_via_quick_fns (...) = NULL\n");
2390 return (struct block_symbol
) {NULL
, NULL
};
2393 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2394 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2395 result
.symbol
= block_lookup_symbol (block
, name
,
2396 symbol_name_match_type::FULL
, domain
);
2397 if (result
.symbol
== NULL
)
2398 error_in_psymtab_expansion (block_index
, name
, cust
);
2400 if (symbol_lookup_debug
> 1)
2402 fprintf_unfiltered (gdb_stdlog
,
2403 "lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
2404 host_address_to_string (result
.symbol
),
2405 host_address_to_string (block
));
2408 result
.symbol
= fixup_symbol_section (result
.symbol
, objfile
);
2409 result
.block
= block
;
2416 basic_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2418 const struct block
*block
,
2419 const domain_enum domain
)
2421 struct block_symbol result
;
2423 /* NOTE: carlton/2003-05-19: The comments below were written when
2424 this (or what turned into this) was part of lookup_symbol_aux;
2425 I'm much less worried about these questions now, since these
2426 decisions have turned out well, but I leave these comments here
2429 /* NOTE: carlton/2002-12-05: There is a question as to whether or
2430 not it would be appropriate to search the current global block
2431 here as well. (That's what this code used to do before the
2432 is_a_field_of_this check was moved up.) On the one hand, it's
2433 redundant with the lookup in all objfiles search that happens
2434 next. On the other hand, if decode_line_1 is passed an argument
2435 like filename:var, then the user presumably wants 'var' to be
2436 searched for in filename. On the third hand, there shouldn't be
2437 multiple global variables all of which are named 'var', and it's
2438 not like decode_line_1 has ever restricted its search to only
2439 global variables in a single filename. All in all, only
2440 searching the static block here seems best: it's correct and it's
2443 /* NOTE: carlton/2002-12-05: There's also a possible performance
2444 issue here: if you usually search for global symbols in the
2445 current file, then it would be slightly better to search the
2446 current global block before searching all the symtabs. But there
2447 are other factors that have a much greater effect on performance
2448 than that one, so I don't think we should worry about that for
2451 /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip
2452 the current objfile. Searching the current objfile first is useful
2453 for both matching user expectations as well as performance. */
2455 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2456 if (result
.symbol
!= NULL
)
2459 /* If we didn't find a definition for a builtin type in the static block,
2460 search for it now. This is actually the right thing to do and can be
2461 a massive performance win. E.g., when debugging a program with lots of
2462 shared libraries we could search all of them only to find out the
2463 builtin type isn't defined in any of them. This is common for types
2465 if (domain
== VAR_DOMAIN
)
2467 struct gdbarch
*gdbarch
;
2470 gdbarch
= target_gdbarch ();
2472 gdbarch
= block_gdbarch (block
);
2473 result
.symbol
= language_lookup_primitive_type_as_symbol (langdef
,
2475 result
.block
= NULL
;
2476 if (result
.symbol
!= NULL
)
2480 return lookup_global_symbol (name
, block
, domain
);
2486 lookup_symbol_in_static_block (const char *name
,
2487 const struct block
*block
,
2488 const domain_enum domain
)
2490 const struct block
*static_block
= block_static_block (block
);
2493 if (static_block
== NULL
)
2494 return (struct block_symbol
) {NULL
, NULL
};
2496 if (symbol_lookup_debug
)
2498 struct objfile
*objfile
= lookup_objfile_from_block (static_block
);
2500 fprintf_unfiltered (gdb_stdlog
,
2501 "lookup_symbol_in_static_block (%s, %s (objfile %s),"
2504 host_address_to_string (block
),
2505 objfile_debug_name (objfile
),
2506 domain_name (domain
));
2509 sym
= lookup_symbol_in_block (name
,
2510 symbol_name_match_type::FULL
,
2511 static_block
, domain
);
2512 if (symbol_lookup_debug
)
2514 fprintf_unfiltered (gdb_stdlog
,
2515 "lookup_symbol_in_static_block (...) = %s\n",
2516 sym
!= NULL
? host_address_to_string (sym
) : "NULL");
2518 return (struct block_symbol
) {sym
, static_block
};
2521 /* Perform the standard symbol lookup of NAME in OBJFILE:
2522 1) First search expanded symtabs, and if not found
2523 2) Search the "quick" symtabs (partial or .gdb_index).
2524 BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */
2526 static struct block_symbol
2527 lookup_symbol_in_objfile (struct objfile
*objfile
, int block_index
,
2528 const char *name
, const domain_enum domain
)
2530 struct block_symbol result
;
2532 if (symbol_lookup_debug
)
2534 fprintf_unfiltered (gdb_stdlog
,
2535 "lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
2536 objfile_debug_name (objfile
),
2537 block_index
== GLOBAL_BLOCK
2538 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
2539 name
, domain_name (domain
));
2542 result
= lookup_symbol_in_objfile_symtabs (objfile
, block_index
,
2544 if (result
.symbol
!= NULL
)
2546 if (symbol_lookup_debug
)
2548 fprintf_unfiltered (gdb_stdlog
,
2549 "lookup_symbol_in_objfile (...) = %s"
2551 host_address_to_string (result
.symbol
));
2556 result
= lookup_symbol_via_quick_fns (objfile
, block_index
,
2558 if (symbol_lookup_debug
)
2560 fprintf_unfiltered (gdb_stdlog
,
2561 "lookup_symbol_in_objfile (...) = %s%s\n",
2562 result
.symbol
!= NULL
2563 ? host_address_to_string (result
.symbol
)
2565 result
.symbol
!= NULL
? " (via quick fns)" : "");
2573 lookup_static_symbol (const char *name
, const domain_enum domain
)
2575 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2576 struct block_symbol result
;
2577 struct block_symbol_cache
*bsc
;
2578 struct symbol_cache_slot
*slot
;
2580 /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
2581 NULL for OBJFILE_CONTEXT. */
2582 result
= symbol_cache_lookup (cache
, NULL
, STATIC_BLOCK
, name
, domain
,
2584 if (result
.symbol
!= NULL
)
2586 if (SYMBOL_LOOKUP_FAILED_P (result
))
2587 return (struct block_symbol
) {NULL
, NULL
};
2591 for (objfile
*objfile
: all_objfiles (current_program_space
))
2593 result
= lookup_symbol_in_objfile (objfile
, STATIC_BLOCK
, name
, domain
);
2594 if (result
.symbol
!= NULL
)
2596 /* Still pass NULL for OBJFILE_CONTEXT here. */
2597 symbol_cache_mark_found (bsc
, slot
, NULL
, result
.symbol
,
2603 /* Still pass NULL for OBJFILE_CONTEXT here. */
2604 symbol_cache_mark_not_found (bsc
, slot
, NULL
, name
, domain
);
2605 return (struct block_symbol
) {NULL
, NULL
};
2608 /* Private data to be used with lookup_symbol_global_iterator_cb. */
2610 struct global_sym_lookup_data
2612 /* The name of the symbol we are searching for. */
2615 /* The domain to use for our search. */
2618 /* The field where the callback should store the symbol if found.
2619 It should be initialized to {NULL, NULL} before the search is started. */
2620 struct block_symbol result
;
2623 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
2624 It searches by name for a symbol in the GLOBAL_BLOCK of the given
2625 OBJFILE. The arguments for the search are passed via CB_DATA,
2626 which in reality is a pointer to struct global_sym_lookup_data. */
2629 lookup_symbol_global_iterator_cb (struct objfile
*objfile
,
2632 struct global_sym_lookup_data
*data
=
2633 (struct global_sym_lookup_data
*) cb_data
;
2635 gdb_assert (data
->result
.symbol
== NULL
2636 && data
->result
.block
== NULL
);
2638 data
->result
= lookup_symbol_in_objfile (objfile
, GLOBAL_BLOCK
,
2639 data
->name
, data
->domain
);
2641 /* If we found a match, tell the iterator to stop. Otherwise,
2643 return (data
->result
.symbol
!= NULL
);
2649 lookup_global_symbol (const char *name
,
2650 const struct block
*block
,
2651 const domain_enum domain
)
2653 struct symbol_cache
*cache
= get_symbol_cache (current_program_space
);
2654 struct block_symbol result
;
2655 struct objfile
*objfile
;
2656 struct global_sym_lookup_data lookup_data
;
2657 struct block_symbol_cache
*bsc
;
2658 struct symbol_cache_slot
*slot
;
2660 objfile
= lookup_objfile_from_block (block
);
2662 /* First see if we can find the symbol in the cache.
2663 This works because we use the current objfile to qualify the lookup. */
2664 result
= symbol_cache_lookup (cache
, objfile
, GLOBAL_BLOCK
, name
, domain
,
2666 if (result
.symbol
!= NULL
)
2668 if (SYMBOL_LOOKUP_FAILED_P (result
))
2669 return (struct block_symbol
) {NULL
, NULL
};
2673 /* Call library-specific lookup procedure. */
2674 if (objfile
!= NULL
)
2675 result
= solib_global_lookup (objfile
, name
, domain
);
2677 /* If that didn't work go a global search (of global blocks, heh). */
2678 if (result
.symbol
== NULL
)
2680 memset (&lookup_data
, 0, sizeof (lookup_data
));
2681 lookup_data
.name
= name
;
2682 lookup_data
.domain
= domain
;
2683 gdbarch_iterate_over_objfiles_in_search_order
2684 (objfile
!= NULL
? get_objfile_arch (objfile
) : target_gdbarch (),
2685 lookup_symbol_global_iterator_cb
, &lookup_data
, objfile
);
2686 result
= lookup_data
.result
;
2689 if (result
.symbol
!= NULL
)
2690 symbol_cache_mark_found (bsc
, slot
, objfile
, result
.symbol
, result
.block
);
2692 symbol_cache_mark_not_found (bsc
, slot
, objfile
, name
, domain
);
2698 symbol_matches_domain (enum language symbol_language
,
2699 domain_enum symbol_domain
,
2702 /* For C++ "struct foo { ... }" also defines a typedef for "foo".
2703 Similarly, any Ada type declaration implicitly defines a typedef. */
2704 if (symbol_language
== language_cplus
2705 || symbol_language
== language_d
2706 || symbol_language
== language_ada
2707 || symbol_language
== language_rust
)
2709 if ((domain
== VAR_DOMAIN
|| domain
== STRUCT_DOMAIN
)
2710 && symbol_domain
== STRUCT_DOMAIN
)
2713 /* For all other languages, strict match is required. */
2714 return (symbol_domain
== domain
);
2720 lookup_transparent_type (const char *name
)
2722 return current_language
->la_lookup_transparent_type (name
);
2725 /* A helper for basic_lookup_transparent_type that interfaces with the
2726 "quick" symbol table functions. */
2728 static struct type
*
2729 basic_lookup_transparent_type_quick (struct objfile
*objfile
, int block_index
,
2732 struct compunit_symtab
*cust
;
2733 const struct blockvector
*bv
;
2734 struct block
*block
;
2739 cust
= objfile
->sf
->qf
->lookup_symbol (objfile
, block_index
, name
,
2744 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2745 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2746 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2747 block_find_non_opaque_type
, NULL
);
2749 error_in_psymtab_expansion (block_index
, name
, cust
);
2750 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2751 return SYMBOL_TYPE (sym
);
2754 /* Subroutine of basic_lookup_transparent_type to simplify it.
2755 Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE.
2756 BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */
2758 static struct type
*
2759 basic_lookup_transparent_type_1 (struct objfile
*objfile
, int block_index
,
2762 const struct blockvector
*bv
;
2763 const struct block
*block
;
2764 const struct symbol
*sym
;
2766 for (compunit_symtab
*cust
: objfile_compunits (objfile
))
2768 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2769 block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
2770 sym
= block_find_symbol (block
, name
, STRUCT_DOMAIN
,
2771 block_find_non_opaque_type
, NULL
);
2774 gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)));
2775 return SYMBOL_TYPE (sym
);
2782 /* The standard implementation of lookup_transparent_type. This code
2783 was modeled on lookup_symbol -- the parts not relevant to looking
2784 up types were just left out. In particular it's assumed here that
2785 types are available in STRUCT_DOMAIN and only in file-static or
2789 basic_lookup_transparent_type (const char *name
)
2793 /* Now search all the global symbols. Do the symtab's first, then
2794 check the psymtab's. If a psymtab indicates the existence
2795 of the desired name as a global, then do psymtab-to-symtab
2796 conversion on the fly and return the found symbol. */
2798 for (objfile
*objfile
: all_objfiles (current_program_space
))
2800 t
= basic_lookup_transparent_type_1 (objfile
, GLOBAL_BLOCK
, name
);
2805 for (objfile
*objfile
: all_objfiles (current_program_space
))
2807 t
= basic_lookup_transparent_type_quick (objfile
, GLOBAL_BLOCK
, name
);
2812 /* Now search the static file-level symbols.
2813 Not strictly correct, but more useful than an error.
2814 Do the symtab's first, then
2815 check the psymtab's. If a psymtab indicates the existence
2816 of the desired name as a file-level static, then do psymtab-to-symtab
2817 conversion on the fly and return the found symbol. */
2819 for (objfile
*objfile
: all_objfiles (current_program_space
))
2821 t
= basic_lookup_transparent_type_1 (objfile
, STATIC_BLOCK
, name
);
2826 for (objfile
*objfile
: all_objfiles (current_program_space
))
2828 t
= basic_lookup_transparent_type_quick (objfile
, STATIC_BLOCK
, name
);
2833 return (struct type
*) 0;
2836 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2838 For each symbol that matches, CALLBACK is called. The symbol is
2839 passed to the callback.
2841 If CALLBACK returns false, the iteration ends. Otherwise, the
2842 search continues. */
2845 iterate_over_symbols (const struct block
*block
,
2846 const lookup_name_info
&name
,
2847 const domain_enum domain
,
2848 gdb::function_view
<symbol_found_callback_ftype
> callback
)
2850 struct block_iterator iter
;
2853 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, name
, iter
, sym
)
2855 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym
),
2856 SYMBOL_DOMAIN (sym
), domain
))
2858 struct block_symbol block_sym
= {sym
, block
};
2860 if (!callback (&block_sym
))
2866 /* Find the compunit symtab associated with PC and SECTION.
2867 This will read in debug info as necessary. */
2869 struct compunit_symtab
*
2870 find_pc_sect_compunit_symtab (CORE_ADDR pc
, struct obj_section
*section
)
2872 struct compunit_symtab
*best_cust
= NULL
;
2873 CORE_ADDR distance
= 0;
2874 struct bound_minimal_symbol msymbol
;
2876 /* If we know that this is not a text address, return failure. This is
2877 necessary because we loop based on the block's high and low code
2878 addresses, which do not include the data ranges, and because
2879 we call find_pc_sect_psymtab which has a similar restriction based
2880 on the partial_symtab's texthigh and textlow. */
2881 msymbol
= lookup_minimal_symbol_by_pc_section (pc
, section
);
2883 && (MSYMBOL_TYPE (msymbol
.minsym
) == mst_data
2884 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_bss
2885 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_abs
2886 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_data
2887 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_bss
))
2890 /* Search all symtabs for the one whose file contains our address, and which
2891 is the smallest of all the ones containing the address. This is designed
2892 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
2893 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from
2894 0x1000-0x4000, but for address 0x2345 we want to return symtab b.
2896 This happens for native ecoff format, where code from included files
2897 gets its own symtab. The symtab for the included file should have
2898 been read in already via the dependency mechanism.
2899 It might be swifter to create several symtabs with the same name
2900 like xcoff does (I'm not sure).
2902 It also happens for objfiles that have their functions reordered.
2903 For these, the symtab we are looking for is not necessarily read in. */
2905 for (objfile
*obj_file
: all_objfiles (current_program_space
))
2907 for (compunit_symtab
*cust
: objfile_compunits (obj_file
))
2910 const struct blockvector
*bv
;
2912 bv
= COMPUNIT_BLOCKVECTOR (cust
);
2913 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2915 if (BLOCK_START (b
) <= pc
2916 && BLOCK_END (b
) > pc
2918 || BLOCK_END (b
) - BLOCK_START (b
) < distance
))
2920 /* For an objfile that has its functions reordered,
2921 find_pc_psymtab will find the proper partial symbol table
2922 and we simply return its corresponding symtab. */
2923 /* In order to better support objfiles that contain both
2924 stabs and coff debugging info, we continue on if a psymtab
2926 if ((obj_file
->flags
& OBJF_REORDERED
) && obj_file
->sf
)
2928 struct compunit_symtab
*result
;
2931 = obj_file
->sf
->qf
->find_pc_sect_compunit_symtab (obj_file
,
2941 struct block_iterator iter
;
2942 struct symbol
*sym
= NULL
;
2944 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2946 fixup_symbol_section (sym
, obj_file
);
2947 if (matching_obj_sections (SYMBOL_OBJ_SECTION (obj_file
,
2953 continue; /* No symbol in this symtab matches
2956 distance
= BLOCK_END (b
) - BLOCK_START (b
);
2962 if (best_cust
!= NULL
)
2965 /* Not found in symtabs, search the "quick" symtabs (e.g. psymtabs). */
2967 for (objfile
*objf
: all_objfiles (current_program_space
))
2969 struct compunit_symtab
*result
;
2973 result
= objf
->sf
->qf
->find_pc_sect_compunit_symtab (objf
,
2984 /* Find the compunit symtab associated with PC.
2985 This will read in debug info as necessary.
2986 Backward compatibility, no section. */
2988 struct compunit_symtab
*
2989 find_pc_compunit_symtab (CORE_ADDR pc
)
2991 return find_pc_sect_compunit_symtab (pc
, find_pc_mapped_section (pc
));
2997 find_symbol_at_address (CORE_ADDR address
)
2999 for (objfile
*objfile
: all_objfiles (current_program_space
))
3001 if (objfile
->sf
== NULL
3002 || objfile
->sf
->qf
->find_compunit_symtab_by_address
== NULL
)
3005 struct compunit_symtab
*symtab
3006 = objfile
->sf
->qf
->find_compunit_symtab_by_address (objfile
, address
);
3009 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (symtab
);
3011 for (int i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; ++i
)
3013 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, i
);
3014 struct block_iterator iter
;
3017 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
3019 if (SYMBOL_CLASS (sym
) == LOC_STATIC
3020 && SYMBOL_VALUE_ADDRESS (sym
) == address
)
3032 /* Find the source file and line number for a given PC value and SECTION.
3033 Return a structure containing a symtab pointer, a line number,
3034 and a pc range for the entire source line.
3035 The value's .pc field is NOT the specified pc.
3036 NOTCURRENT nonzero means, if specified pc is on a line boundary,
3037 use the line that ends there. Otherwise, in that case, the line
3038 that begins there is used. */
3040 /* The big complication here is that a line may start in one file, and end just
3041 before the start of another file. This usually occurs when you #include
3042 code in the middle of a subroutine. To properly find the end of a line's PC
3043 range, we must search all symtabs associated with this compilation unit, and
3044 find the one whose first PC is closer than that of the next line in this
3047 struct symtab_and_line
3048 find_pc_sect_line (CORE_ADDR pc
, struct obj_section
*section
, int notcurrent
)
3050 struct compunit_symtab
*cust
;
3051 struct linetable
*l
;
3053 struct linetable_entry
*item
;
3054 const struct blockvector
*bv
;
3055 struct bound_minimal_symbol msymbol
;
3057 /* Info on best line seen so far, and where it starts, and its file. */
3059 struct linetable_entry
*best
= NULL
;
3060 CORE_ADDR best_end
= 0;
3061 struct symtab
*best_symtab
= 0;
3063 /* Store here the first line number
3064 of a file which contains the line at the smallest pc after PC.
3065 If we don't find a line whose range contains PC,
3066 we will use a line one less than this,
3067 with a range from the start of that file to the first line's pc. */
3068 struct linetable_entry
*alt
= NULL
;
3070 /* Info on best line seen in this file. */
3072 struct linetable_entry
*prev
;
3074 /* If this pc is not from the current frame,
3075 it is the address of the end of a call instruction.
3076 Quite likely that is the start of the following statement.
3077 But what we want is the statement containing the instruction.
3078 Fudge the pc to make sure we get that. */
3080 /* It's tempting to assume that, if we can't find debugging info for
3081 any function enclosing PC, that we shouldn't search for line
3082 number info, either. However, GAS can emit line number info for
3083 assembly files --- very helpful when debugging hand-written
3084 assembly code. In such a case, we'd have no debug info for the
3085 function, but we would have line info. */
3090 /* elz: added this because this function returned the wrong
3091 information if the pc belongs to a stub (import/export)
3092 to call a shlib function. This stub would be anywhere between
3093 two functions in the target, and the line info was erroneously
3094 taken to be the one of the line before the pc. */
3096 /* RT: Further explanation:
3098 * We have stubs (trampolines) inserted between procedures.
3100 * Example: "shr1" exists in a shared library, and a "shr1" stub also
3101 * exists in the main image.
3103 * In the minimal symbol table, we have a bunch of symbols
3104 * sorted by start address. The stubs are marked as "trampoline",
3105 * the others appear as text. E.g.:
3107 * Minimal symbol table for main image
3108 * main: code for main (text symbol)
3109 * shr1: stub (trampoline symbol)
3110 * foo: code for foo (text symbol)
3112 * Minimal symbol table for "shr1" image:
3114 * shr1: code for shr1 (text symbol)
3117 * So the code below is trying to detect if we are in the stub
3118 * ("shr1" stub), and if so, find the real code ("shr1" trampoline),
3119 * and if found, do the symbolization from the real-code address
3120 * rather than the stub address.
3122 * Assumptions being made about the minimal symbol table:
3123 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only
3124 * if we're really in the trampoline.s If we're beyond it (say
3125 * we're in "foo" in the above example), it'll have a closer
3126 * symbol (the "foo" text symbol for example) and will not
3127 * return the trampoline.
3128 * 2. lookup_minimal_symbol_text() will find a real text symbol
3129 * corresponding to the trampoline, and whose address will
3130 * be different than the trampoline address. I put in a sanity
3131 * check for the address being the same, to avoid an
3132 * infinite recursion.
3134 msymbol
= lookup_minimal_symbol_by_pc (pc
);
3135 if (msymbol
.minsym
!= NULL
)
3136 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
3138 struct bound_minimal_symbol mfunsym
3139 = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
3142 if (mfunsym
.minsym
== NULL
)
3143 /* I eliminated this warning since it is coming out
3144 * in the following situation:
3145 * gdb shmain // test program with shared libraries
3146 * (gdb) break shr1 // function in shared lib
3147 * Warning: In stub for ...
3148 * In the above situation, the shared lib is not loaded yet,
3149 * so of course we can't find the real func/line info,
3150 * but the "break" still works, and the warning is annoying.
3151 * So I commented out the warning. RT */
3152 /* warning ("In stub for %s; unable to find real function/line info",
3153 SYMBOL_LINKAGE_NAME (msymbol)); */
3156 else if (BMSYMBOL_VALUE_ADDRESS (mfunsym
)
3157 == BMSYMBOL_VALUE_ADDRESS (msymbol
))
3158 /* Avoid infinite recursion */
3159 /* See above comment about why warning is commented out. */
3160 /* warning ("In stub for %s; unable to find real function/line info",
3161 SYMBOL_LINKAGE_NAME (msymbol)); */
3165 return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym
), 0);
3168 symtab_and_line val
;
3169 val
.pspace
= current_program_space
;
3171 cust
= find_pc_sect_compunit_symtab (pc
, section
);
3174 /* If no symbol information, return previous pc. */
3181 bv
= COMPUNIT_BLOCKVECTOR (cust
);
3183 /* Look at all the symtabs that share this blockvector.
3184 They all have the same apriori range, that we found was right;
3185 but they have different line tables. */
3187 for (symtab
*iter_s
: compunit_filetabs (cust
))
3189 /* Find the best line in this symtab. */
3190 l
= SYMTAB_LINETABLE (iter_s
);
3196 /* I think len can be zero if the symtab lacks line numbers
3197 (e.g. gcc -g1). (Either that or the LINETABLE is NULL;
3198 I'm not sure which, and maybe it depends on the symbol
3204 item
= l
->item
; /* Get first line info. */
3206 /* Is this file's first line closer than the first lines of other files?
3207 If so, record this file, and its first line, as best alternate. */
3208 if (item
->pc
> pc
&& (!alt
|| item
->pc
< alt
->pc
))
3211 auto pc_compare
= [](const CORE_ADDR
& comp_pc
,
3212 const struct linetable_entry
& lhs
)->bool
3214 return comp_pc
< lhs
.pc
;
3217 struct linetable_entry
*first
= item
;
3218 struct linetable_entry
*last
= item
+ len
;
3219 item
= std::upper_bound (first
, last
, pc
, pc_compare
);
3221 prev
= item
- 1; /* Found a matching item. */
3223 /* At this point, prev points at the line whose start addr is <= pc, and
3224 item points at the next line. If we ran off the end of the linetable
3225 (pc >= start of the last line), then prev == item. If pc < start of
3226 the first line, prev will not be set. */
3228 /* Is this file's best line closer than the best in the other files?
3229 If so, record this file, and its best line, as best so far. Don't
3230 save prev if it represents the end of a function (i.e. line number
3231 0) instead of a real line. */
3233 if (prev
&& prev
->line
&& (!best
|| prev
->pc
> best
->pc
))
3236 best_symtab
= iter_s
;
3238 /* Discard BEST_END if it's before the PC of the current BEST. */
3239 if (best_end
<= best
->pc
)
3243 /* If another line (denoted by ITEM) is in the linetable and its
3244 PC is after BEST's PC, but before the current BEST_END, then
3245 use ITEM's PC as the new best_end. */
3246 if (best
&& item
< last
&& item
->pc
> best
->pc
3247 && (best_end
== 0 || best_end
> item
->pc
))
3248 best_end
= item
->pc
;
3253 /* If we didn't find any line number info, just return zeros.
3254 We used to return alt->line - 1 here, but that could be
3255 anywhere; if we don't have line number info for this PC,
3256 don't make some up. */
3259 else if (best
->line
== 0)
3261 /* If our best fit is in a range of PC's for which no line
3262 number info is available (line number is zero) then we didn't
3263 find any valid line information. */
3268 val
.symtab
= best_symtab
;
3269 val
.line
= best
->line
;
3271 if (best_end
&& (!alt
|| best_end
< alt
->pc
))
3276 val
.end
= BLOCK_END (BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
));
3278 val
.section
= section
;
3282 /* Backward compatibility (no section). */
3284 struct symtab_and_line
3285 find_pc_line (CORE_ADDR pc
, int notcurrent
)
3287 struct obj_section
*section
;
3289 section
= find_pc_overlay (pc
);
3290 if (pc_in_unmapped_range (pc
, section
))
3291 pc
= overlay_mapped_address (pc
, section
);
3292 return find_pc_sect_line (pc
, section
, notcurrent
);
3298 find_pc_line_symtab (CORE_ADDR pc
)
3300 struct symtab_and_line sal
;
3302 /* This always passes zero for NOTCURRENT to find_pc_line.
3303 There are currently no callers that ever pass non-zero. */
3304 sal
= find_pc_line (pc
, 0);
3308 /* Find line number LINE in any symtab whose name is the same as
3311 If found, return the symtab that contains the linetable in which it was
3312 found, set *INDEX to the index in the linetable of the best entry
3313 found, and set *EXACT_MATCH nonzero if the value returned is an
3316 If not found, return NULL. */
3319 find_line_symtab (struct symtab
*sym_tab
, int line
,
3320 int *index
, int *exact_match
)
3322 int exact
= 0; /* Initialized here to avoid a compiler warning. */
3324 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
3328 struct linetable
*best_linetable
;
3329 struct symtab
*best_symtab
;
3331 /* First try looking it up in the given symtab. */
3332 best_linetable
= SYMTAB_LINETABLE (sym_tab
);
3333 best_symtab
= sym_tab
;
3334 best_index
= find_line_common (best_linetable
, line
, &exact
, 0);
3335 if (best_index
< 0 || !exact
)
3337 /* Didn't find an exact match. So we better keep looking for
3338 another symtab with the same name. In the case of xcoff,
3339 multiple csects for one source file (produced by IBM's FORTRAN
3340 compiler) produce multiple symtabs (this is unavoidable
3341 assuming csects can be at arbitrary places in memory and that
3342 the GLOBAL_BLOCK of a symtab has a begin and end address). */
3344 /* BEST is the smallest linenumber > LINE so far seen,
3345 or 0 if none has been seen so far.
3346 BEST_INDEX and BEST_LINETABLE identify the item for it. */
3349 if (best_index
>= 0)
3350 best
= best_linetable
->item
[best_index
].line
;
3354 for (objfile
*objfile
: all_objfiles (current_program_space
))
3357 objfile
->sf
->qf
->expand_symtabs_with_fullname
3358 (objfile
, symtab_to_fullname (sym_tab
));
3361 for (objfile
*objfile
: all_objfiles (current_program_space
))
3363 for (compunit_symtab
*cu
: objfile_compunits (objfile
))
3365 for (symtab
*s
: compunit_filetabs (cu
))
3367 struct linetable
*l
;
3370 if (FILENAME_CMP (sym_tab
->filename
, s
->filename
) != 0)
3372 if (FILENAME_CMP (symtab_to_fullname (sym_tab
),
3373 symtab_to_fullname (s
)) != 0)
3375 l
= SYMTAB_LINETABLE (s
);
3376 ind
= find_line_common (l
, line
, &exact
, 0);
3386 if (best
== 0 || l
->item
[ind
].line
< best
)
3388 best
= l
->item
[ind
].line
;
3403 *index
= best_index
;
3405 *exact_match
= exact
;
3410 /* Given SYMTAB, returns all the PCs function in the symtab that
3411 exactly match LINE. Returns an empty vector if there are no exact
3412 matches, but updates BEST_ITEM in this case. */
3414 std::vector
<CORE_ADDR
>
3415 find_pcs_for_symtab_line (struct symtab
*symtab
, int line
,
3416 struct linetable_entry
**best_item
)
3419 std::vector
<CORE_ADDR
> result
;
3421 /* First, collect all the PCs that are at this line. */
3427 idx
= find_line_common (SYMTAB_LINETABLE (symtab
), line
, &was_exact
,
3434 struct linetable_entry
*item
= &SYMTAB_LINETABLE (symtab
)->item
[idx
];
3436 if (*best_item
== NULL
|| item
->line
< (*best_item
)->line
)
3442 result
.push_back (SYMTAB_LINETABLE (symtab
)->item
[idx
].pc
);
3450 /* Set the PC value for a given source file and line number and return true.
3451 Returns zero for invalid line number (and sets the PC to 0).
3452 The source file is specified with a struct symtab. */
3455 find_line_pc (struct symtab
*symtab
, int line
, CORE_ADDR
*pc
)
3457 struct linetable
*l
;
3464 symtab
= find_line_symtab (symtab
, line
, &ind
, NULL
);
3467 l
= SYMTAB_LINETABLE (symtab
);
3468 *pc
= l
->item
[ind
].pc
;
3475 /* Find the range of pc values in a line.
3476 Store the starting pc of the line into *STARTPTR
3477 and the ending pc (start of next line) into *ENDPTR.
3478 Returns 1 to indicate success.
3479 Returns 0 if could not find the specified line. */
3482 find_line_pc_range (struct symtab_and_line sal
, CORE_ADDR
*startptr
,
3485 CORE_ADDR startaddr
;
3486 struct symtab_and_line found_sal
;
3489 if (startaddr
== 0 && !find_line_pc (sal
.symtab
, sal
.line
, &startaddr
))
3492 /* This whole function is based on address. For example, if line 10 has
3493 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
3494 "info line *0x123" should say the line goes from 0x100 to 0x200
3495 and "info line *0x355" should say the line goes from 0x300 to 0x400.
3496 This also insures that we never give a range like "starts at 0x134
3497 and ends at 0x12c". */
3499 found_sal
= find_pc_sect_line (startaddr
, sal
.section
, 0);
3500 if (found_sal
.line
!= sal
.line
)
3502 /* The specified line (sal) has zero bytes. */
3503 *startptr
= found_sal
.pc
;
3504 *endptr
= found_sal
.pc
;
3508 *startptr
= found_sal
.pc
;
3509 *endptr
= found_sal
.end
;
3514 /* Given a line table and a line number, return the index into the line
3515 table for the pc of the nearest line whose number is >= the specified one.
3516 Return -1 if none is found. The value is >= 0 if it is an index.
3517 START is the index at which to start searching the line table.
3519 Set *EXACT_MATCH nonzero if the value returned is an exact match. */
3522 find_line_common (struct linetable
*l
, int lineno
,
3523 int *exact_match
, int start
)
3528 /* BEST is the smallest linenumber > LINENO so far seen,
3529 or 0 if none has been seen so far.
3530 BEST_INDEX identifies the item for it. */
3532 int best_index
= -1;
3543 for (i
= start
; i
< len
; i
++)
3545 struct linetable_entry
*item
= &(l
->item
[i
]);
3547 if (item
->line
== lineno
)
3549 /* Return the first (lowest address) entry which matches. */
3554 if (item
->line
> lineno
&& (best
== 0 || item
->line
< best
))
3561 /* If we got here, we didn't get an exact match. */
3566 find_pc_line_pc_range (CORE_ADDR pc
, CORE_ADDR
*startptr
, CORE_ADDR
*endptr
)
3568 struct symtab_and_line sal
;
3570 sal
= find_pc_line (pc
, 0);
3573 return sal
.symtab
!= 0;
3576 /* Helper for find_function_start_sal. Does most of the work, except
3577 setting the sal's symbol. */
3579 static symtab_and_line
3580 find_function_start_sal_1 (CORE_ADDR func_addr
, obj_section
*section
,
3583 symtab_and_line sal
= find_pc_sect_line (func_addr
, section
, 0);
3585 if (funfirstline
&& sal
.symtab
!= NULL
3586 && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal
.symtab
))
3587 || SYMTAB_LANGUAGE (sal
.symtab
) == language_asm
))
3589 struct gdbarch
*gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
3592 if (gdbarch_skip_entrypoint_p (gdbarch
))
3593 sal
.pc
= gdbarch_skip_entrypoint (gdbarch
, sal
.pc
);
3597 /* We always should have a line for the function start address.
3598 If we don't, something is odd. Create a plain SAL referring
3599 just the PC and hope that skip_prologue_sal (if requested)
3600 can find a line number for after the prologue. */
3601 if (sal
.pc
< func_addr
)
3604 sal
.pspace
= current_program_space
;
3606 sal
.section
= section
;
3610 skip_prologue_sal (&sal
);
3618 find_function_start_sal (CORE_ADDR func_addr
, obj_section
*section
,
3622 = find_function_start_sal_1 (func_addr
, section
, funfirstline
);
3624 /* find_function_start_sal_1 does a linetable search, so it finds
3625 the symtab and linenumber, but not a symbol. Fill in the
3626 function symbol too. */
3627 sal
.symbol
= find_pc_sect_containing_function (sal
.pc
, sal
.section
);
3635 find_function_start_sal (symbol
*sym
, bool funfirstline
)
3637 fixup_symbol_section (sym
, NULL
);
3639 = find_function_start_sal_1 (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)),
3640 SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
),
3647 /* Given a function start address FUNC_ADDR and SYMTAB, find the first
3648 address for that function that has an entry in SYMTAB's line info
3649 table. If such an entry cannot be found, return FUNC_ADDR
3653 skip_prologue_using_lineinfo (CORE_ADDR func_addr
, struct symtab
*symtab
)
3655 CORE_ADDR func_start
, func_end
;
3656 struct linetable
*l
;
3659 /* Give up if this symbol has no lineinfo table. */
3660 l
= SYMTAB_LINETABLE (symtab
);
3664 /* Get the range for the function's PC values, or give up if we
3665 cannot, for some reason. */
3666 if (!find_pc_partial_function (func_addr
, NULL
, &func_start
, &func_end
))
3669 /* Linetable entries are ordered by PC values, see the commentary in
3670 symtab.h where `struct linetable' is defined. Thus, the first
3671 entry whose PC is in the range [FUNC_START..FUNC_END[ is the
3672 address we are looking for. */
3673 for (i
= 0; i
< l
->nitems
; i
++)
3675 struct linetable_entry
*item
= &(l
->item
[i
]);
3677 /* Don't use line numbers of zero, they mark special entries in
3678 the table. See the commentary on symtab.h before the
3679 definition of struct linetable. */
3680 if (item
->line
> 0 && func_start
<= item
->pc
&& item
->pc
< func_end
)
3687 /* Adjust SAL to the first instruction past the function prologue.
3688 If the PC was explicitly specified, the SAL is not changed.
3689 If the line number was explicitly specified, at most the SAL's PC
3690 is updated. If SAL is already past the prologue, then do nothing. */
3693 skip_prologue_sal (struct symtab_and_line
*sal
)
3696 struct symtab_and_line start_sal
;
3697 CORE_ADDR pc
, saved_pc
;
3698 struct obj_section
*section
;
3700 struct objfile
*objfile
;
3701 struct gdbarch
*gdbarch
;
3702 const struct block
*b
, *function_block
;
3703 int force_skip
, skip
;
3705 /* Do not change the SAL if PC was specified explicitly. */
3706 if (sal
->explicit_pc
)
3709 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3711 switch_to_program_space_and_thread (sal
->pspace
);
3713 sym
= find_pc_sect_function (sal
->pc
, sal
->section
);
3716 fixup_symbol_section (sym
, NULL
);
3718 objfile
= symbol_objfile (sym
);
3719 pc
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
3720 section
= SYMBOL_OBJ_SECTION (objfile
, sym
);
3721 name
= SYMBOL_LINKAGE_NAME (sym
);
3725 struct bound_minimal_symbol msymbol
3726 = lookup_minimal_symbol_by_pc_section (sal
->pc
, sal
->section
);
3728 if (msymbol
.minsym
== NULL
)
3731 objfile
= msymbol
.objfile
;
3732 pc
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
3733 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
3734 name
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
3737 gdbarch
= get_objfile_arch (objfile
);
3739 /* Process the prologue in two passes. In the first pass try to skip the
3740 prologue (SKIP is true) and verify there is a real need for it (indicated
3741 by FORCE_SKIP). If no such reason was found run a second pass where the
3742 prologue is not skipped (SKIP is false). */
3747 /* Be conservative - allow direct PC (without skipping prologue) only if we
3748 have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
3749 have to be set by the caller so we use SYM instead. */
3751 && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym
))))
3759 /* If the function is in an unmapped overlay, use its unmapped LMA address,
3760 so that gdbarch_skip_prologue has something unique to work on. */
3761 if (section_is_overlay (section
) && !section_is_mapped (section
))
3762 pc
= overlay_unmapped_address (pc
, section
);
3764 /* Skip "first line" of function (which is actually its prologue). */
3765 pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3766 if (gdbarch_skip_entrypoint_p (gdbarch
))
3767 pc
= gdbarch_skip_entrypoint (gdbarch
, pc
);
3769 pc
= gdbarch_skip_prologue_noexcept (gdbarch
, pc
);
3771 /* For overlays, map pc back into its mapped VMA range. */
3772 pc
= overlay_mapped_address (pc
, section
);
3774 /* Calculate line number. */
3775 start_sal
= find_pc_sect_line (pc
, section
, 0);
3777 /* Check if gdbarch_skip_prologue left us in mid-line, and the next
3778 line is still part of the same function. */
3779 if (skip
&& start_sal
.pc
!= pc
3780 && (sym
? (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) <= start_sal
.end
3781 && start_sal
.end
< BLOCK_END (SYMBOL_BLOCK_VALUE (sym
)))
3782 : (lookup_minimal_symbol_by_pc_section (start_sal
.end
, section
).minsym
3783 == lookup_minimal_symbol_by_pc_section (pc
, section
).minsym
)))
3785 /* First pc of next line */
3787 /* Recalculate the line number (might not be N+1). */
3788 start_sal
= find_pc_sect_line (pc
, section
, 0);
3791 /* On targets with executable formats that don't have a concept of
3792 constructors (ELF with .init has, PE doesn't), gcc emits a call
3793 to `__main' in `main' between the prologue and before user
3795 if (gdbarch_skip_main_prologue_p (gdbarch
)
3796 && name
&& strcmp_iw (name
, "main") == 0)
3798 pc
= gdbarch_skip_main_prologue (gdbarch
, pc
);
3799 /* Recalculate the line number (might not be N+1). */
3800 start_sal
= find_pc_sect_line (pc
, section
, 0);
3804 while (!force_skip
&& skip
--);
3806 /* If we still don't have a valid source line, try to find the first
3807 PC in the lineinfo table that belongs to the same function. This
3808 happens with COFF debug info, which does not seem to have an
3809 entry in lineinfo table for the code after the prologue which has
3810 no direct relation to source. For example, this was found to be
3811 the case with the DJGPP target using "gcc -gcoff" when the
3812 compiler inserted code after the prologue to make sure the stack
3814 if (!force_skip
&& sym
&& start_sal
.symtab
== NULL
)
3816 pc
= skip_prologue_using_lineinfo (pc
, symbol_symtab (sym
));
3817 /* Recalculate the line number. */
3818 start_sal
= find_pc_sect_line (pc
, section
, 0);
3821 /* If we're already past the prologue, leave SAL unchanged. Otherwise
3822 forward SAL to the end of the prologue. */
3827 sal
->section
= section
;
3829 /* Unless the explicit_line flag was set, update the SAL line
3830 and symtab to correspond to the modified PC location. */
3831 if (sal
->explicit_line
)
3834 sal
->symtab
= start_sal
.symtab
;
3835 sal
->line
= start_sal
.line
;
3836 sal
->end
= start_sal
.end
;
3838 /* Check if we are now inside an inlined function. If we can,
3839 use the call site of the function instead. */
3840 b
= block_for_pc_sect (sal
->pc
, sal
->section
);
3841 function_block
= NULL
;
3844 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
3846 else if (BLOCK_FUNCTION (b
) != NULL
)
3848 b
= BLOCK_SUPERBLOCK (b
);
3850 if (function_block
!= NULL
3851 && SYMBOL_LINE (BLOCK_FUNCTION (function_block
)) != 0)
3853 sal
->line
= SYMBOL_LINE (BLOCK_FUNCTION (function_block
));
3854 sal
->symtab
= symbol_symtab (BLOCK_FUNCTION (function_block
));
3858 /* Given PC at the function's start address, attempt to find the
3859 prologue end using SAL information. Return zero if the skip fails.
3861 A non-optimized prologue traditionally has one SAL for the function
3862 and a second for the function body. A single line function has
3863 them both pointing at the same line.
3865 An optimized prologue is similar but the prologue may contain
3866 instructions (SALs) from the instruction body. Need to skip those
3867 while not getting into the function body.
3869 The functions end point and an increasing SAL line are used as
3870 indicators of the prologue's endpoint.
3872 This code is based on the function refine_prologue_limit
3876 skip_prologue_using_sal (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
)
3878 struct symtab_and_line prologue_sal
;
3881 const struct block
*bl
;
3883 /* Get an initial range for the function. */
3884 find_pc_partial_function (func_addr
, NULL
, &start_pc
, &end_pc
);
3885 start_pc
+= gdbarch_deprecated_function_start_offset (gdbarch
);
3887 prologue_sal
= find_pc_line (start_pc
, 0);
3888 if (prologue_sal
.line
!= 0)
3890 /* For languages other than assembly, treat two consecutive line
3891 entries at the same address as a zero-instruction prologue.
3892 The GNU assembler emits separate line notes for each instruction
3893 in a multi-instruction macro, but compilers generally will not
3895 if (prologue_sal
.symtab
->language
!= language_asm
)
3897 struct linetable
*linetable
= SYMTAB_LINETABLE (prologue_sal
.symtab
);
3900 /* Skip any earlier lines, and any end-of-sequence marker
3901 from a previous function. */
3902 while (linetable
->item
[idx
].pc
!= prologue_sal
.pc
3903 || linetable
->item
[idx
].line
== 0)
3906 if (idx
+1 < linetable
->nitems
3907 && linetable
->item
[idx
+1].line
!= 0
3908 && linetable
->item
[idx
+1].pc
== start_pc
)
3912 /* If there is only one sal that covers the entire function,
3913 then it is probably a single line function, like
3915 if (prologue_sal
.end
>= end_pc
)
3918 while (prologue_sal
.end
< end_pc
)
3920 struct symtab_and_line sal
;
3922 sal
= find_pc_line (prologue_sal
.end
, 0);
3925 /* Assume that a consecutive SAL for the same (or larger)
3926 line mark the prologue -> body transition. */
3927 if (sal
.line
>= prologue_sal
.line
)
3929 /* Likewise if we are in a different symtab altogether
3930 (e.g. within a file included via #include). */
3931 if (sal
.symtab
!= prologue_sal
.symtab
)
3934 /* The line number is smaller. Check that it's from the
3935 same function, not something inlined. If it's inlined,
3936 then there is no point comparing the line numbers. */
3937 bl
= block_for_pc (prologue_sal
.end
);
3940 if (block_inlined_p (bl
))
3942 if (BLOCK_FUNCTION (bl
))
3947 bl
= BLOCK_SUPERBLOCK (bl
);
3952 /* The case in which compiler's optimizer/scheduler has
3953 moved instructions into the prologue. We look ahead in
3954 the function looking for address ranges whose
3955 corresponding line number is less the first one that we
3956 found for the function. This is more conservative then
3957 refine_prologue_limit which scans a large number of SALs
3958 looking for any in the prologue. */
3963 if (prologue_sal
.end
< end_pc
)
3964 /* Return the end of this line, or zero if we could not find a
3966 return prologue_sal
.end
;
3968 /* Don't return END_PC, which is past the end of the function. */
3969 return prologue_sal
.pc
;
3975 find_function_alias_target (bound_minimal_symbol msymbol
)
3977 CORE_ADDR func_addr
;
3978 if (!msymbol_is_function (msymbol
.objfile
, msymbol
.minsym
, &func_addr
))
3981 symbol
*sym
= find_pc_function (func_addr
);
3983 && SYMBOL_CLASS (sym
) == LOC_BLOCK
3984 && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) == func_addr
)
3991 /* If P is of the form "operator[ \t]+..." where `...' is
3992 some legitimate operator text, return a pointer to the
3993 beginning of the substring of the operator text.
3994 Otherwise, return "". */
3997 operator_chars (const char *p
, const char **end
)
4000 if (!startswith (p
, CP_OPERATOR_STR
))
4002 p
+= CP_OPERATOR_LEN
;
4004 /* Don't get faked out by `operator' being part of a longer
4006 if (isalpha (*p
) || *p
== '_' || *p
== '$' || *p
== '\0')
4009 /* Allow some whitespace between `operator' and the operator symbol. */
4010 while (*p
== ' ' || *p
== '\t')
4013 /* Recognize 'operator TYPENAME'. */
4015 if (isalpha (*p
) || *p
== '_' || *p
== '$')
4017 const char *q
= p
+ 1;
4019 while (isalnum (*q
) || *q
== '_' || *q
== '$')
4028 case '\\': /* regexp quoting */
4031 if (p
[2] == '=') /* 'operator\*=' */
4033 else /* 'operator\*' */
4037 else if (p
[1] == '[')
4040 error (_("mismatched quoting on brackets, "
4041 "try 'operator\\[\\]'"));
4042 else if (p
[2] == '\\' && p
[3] == ']')
4044 *end
= p
+ 4; /* 'operator\[\]' */
4048 error (_("nothing is allowed between '[' and ']'"));
4052 /* Gratuitous qoute: skip it and move on. */
4074 if (p
[0] == '-' && p
[1] == '>')
4076 /* Struct pointer member operator 'operator->'. */
4079 *end
= p
+ 3; /* 'operator->*' */
4082 else if (p
[2] == '\\')
4084 *end
= p
+ 4; /* Hopefully 'operator->\*' */
4089 *end
= p
+ 2; /* 'operator->' */
4093 if (p
[1] == '=' || p
[1] == p
[0])
4104 error (_("`operator ()' must be specified "
4105 "without whitespace in `()'"));
4110 error (_("`operator ?:' must be specified "
4111 "without whitespace in `?:'"));
4116 error (_("`operator []' must be specified "
4117 "without whitespace in `[]'"));
4121 error (_("`operator %s' not supported"), p
);
4130 /* Data structure to maintain printing state for output_source_filename. */
4132 struct output_source_filename_data
4134 /* Cache of what we've seen so far. */
4135 struct filename_seen_cache
*filename_seen_cache
;
4137 /* Flag of whether we're printing the first one. */
4141 /* Slave routine for sources_info. Force line breaks at ,'s.
4142 NAME is the name to print.
4143 DATA contains the state for printing and watching for duplicates. */
4146 output_source_filename (const char *name
,
4147 struct output_source_filename_data
*data
)
4149 /* Since a single source file can result in several partial symbol
4150 tables, we need to avoid printing it more than once. Note: if
4151 some of the psymtabs are read in and some are not, it gets
4152 printed both under "Source files for which symbols have been
4153 read" and "Source files for which symbols will be read in on
4154 demand". I consider this a reasonable way to deal with the
4155 situation. I'm not sure whether this can also happen for
4156 symtabs; it doesn't hurt to check. */
4158 /* Was NAME already seen? */
4159 if (data
->filename_seen_cache
->seen (name
))
4161 /* Yes; don't print it again. */
4165 /* No; print it and reset *FIRST. */
4167 printf_filtered (", ");
4171 fputs_filtered (name
, gdb_stdout
);
4174 /* A callback for map_partial_symbol_filenames. */
4177 output_partial_symbol_filename (const char *filename
, const char *fullname
,
4180 output_source_filename (fullname
? fullname
: filename
,
4181 (struct output_source_filename_data
*) data
);
4185 info_sources_command (const char *ignore
, int from_tty
)
4187 struct output_source_filename_data data
;
4189 if (!have_full_symbols () && !have_partial_symbols ())
4191 error (_("No symbol table is loaded. Use the \"file\" command."));
4194 filename_seen_cache filenames_seen
;
4196 data
.filename_seen_cache
= &filenames_seen
;
4198 printf_filtered ("Source files for which symbols have been read in:\n\n");
4201 for (objfile
*objfile
: all_objfiles (current_program_space
))
4203 for (compunit_symtab
*cu
: objfile_compunits (objfile
))
4205 for (symtab
*s
: compunit_filetabs (cu
))
4207 const char *fullname
= symtab_to_fullname (s
);
4209 output_source_filename (fullname
, &data
);
4213 printf_filtered ("\n\n");
4215 printf_filtered ("Source files for which symbols "
4216 "will be read in on demand:\n\n");
4218 filenames_seen
.clear ();
4220 map_symbol_filenames (output_partial_symbol_filename
, &data
,
4221 1 /*need_fullname*/);
4222 printf_filtered ("\n");
4225 /* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
4226 non-zero compare only lbasename of FILES. */
4229 file_matches (const char *file
, const char *files
[], int nfiles
, int basenames
)
4233 if (file
!= NULL
&& nfiles
!= 0)
4235 for (i
= 0; i
< nfiles
; i
++)
4237 if (compare_filenames_for_search (file
, (basenames
4238 ? lbasename (files
[i
])
4243 else if (nfiles
== 0)
4248 /* Helper function for sort_search_symbols_remove_dups and qsort. Can only
4249 sort symbols, not minimal symbols. */
4252 symbol_search::compare_search_syms (const symbol_search
&sym_a
,
4253 const symbol_search
&sym_b
)
4257 c
= FILENAME_CMP (symbol_symtab (sym_a
.symbol
)->filename
,
4258 symbol_symtab (sym_b
.symbol
)->filename
);
4262 if (sym_a
.block
!= sym_b
.block
)
4263 return sym_a
.block
- sym_b
.block
;
4265 return strcmp (SYMBOL_PRINT_NAME (sym_a
.symbol
),
4266 SYMBOL_PRINT_NAME (sym_b
.symbol
));
4269 /* Returns true if the type_name of symbol_type of SYM matches TREG.
4270 If SYM has no symbol_type or symbol_name, returns false. */
4273 treg_matches_sym_type_name (const compiled_regex
&treg
,
4274 const struct symbol
*sym
)
4276 struct type
*sym_type
;
4277 std::string printed_sym_type_name
;
4279 if (symbol_lookup_debug
> 1)
4281 fprintf_unfiltered (gdb_stdlog
,
4282 "treg_matches_sym_type_name\n sym %s\n",
4283 SYMBOL_NATURAL_NAME (sym
));
4286 sym_type
= SYMBOL_TYPE (sym
);
4287 if (sym_type
== NULL
)
4291 scoped_switch_to_sym_language_if_auto
l (sym
);
4293 printed_sym_type_name
= type_to_string (sym_type
);
4297 if (symbol_lookup_debug
> 1)
4299 fprintf_unfiltered (gdb_stdlog
,
4300 " sym_type_name %s\n",
4301 printed_sym_type_name
.c_str ());
4305 if (printed_sym_type_name
.empty ())
4308 return treg
.exec (printed_sym_type_name
.c_str (), 0, NULL
, 0) == 0;
4312 /* Sort the symbols in RESULT and remove duplicates. */
4315 sort_search_symbols_remove_dups (std::vector
<symbol_search
> *result
)
4317 std::sort (result
->begin (), result
->end ());
4318 result
->erase (std::unique (result
->begin (), result
->end ()),
4322 /* Search the symbol table for matches to the regular expression REGEXP,
4323 returning the results.
4325 Only symbols of KIND are searched:
4326 VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
4327 and constants (enums).
4328 if T_REGEXP is not NULL, only returns var that have
4329 a type matching regular expression T_REGEXP.
4330 FUNCTIONS_DOMAIN - search all functions
4331 TYPES_DOMAIN - search all type names
4332 ALL_DOMAIN - an internal error for this function
4334 Within each file the results are sorted locally; each symtab's global and
4335 static blocks are separately alphabetized.
4336 Duplicate entries are removed. */
4338 std::vector
<symbol_search
>
4339 search_symbols (const char *regexp
, enum search_domain kind
,
4340 const char *t_regexp
,
4341 int nfiles
, const char *files
[])
4343 const struct blockvector
*bv
;
4346 struct block_iterator iter
;
4349 static const enum minimal_symbol_type types
[]
4350 = {mst_data
, mst_text
, mst_abs
};
4351 static const enum minimal_symbol_type types2
[]
4352 = {mst_bss
, mst_file_text
, mst_abs
};
4353 static const enum minimal_symbol_type types3
[]
4354 = {mst_file_data
, mst_solib_trampoline
, mst_abs
};
4355 static const enum minimal_symbol_type types4
[]
4356 = {mst_file_bss
, mst_text_gnu_ifunc
, mst_abs
};
4357 enum minimal_symbol_type ourtype
;
4358 enum minimal_symbol_type ourtype2
;
4359 enum minimal_symbol_type ourtype3
;
4360 enum minimal_symbol_type ourtype4
;
4361 std::vector
<symbol_search
> result
;
4362 gdb::optional
<compiled_regex
> preg
;
4363 gdb::optional
<compiled_regex
> treg
;
4365 gdb_assert (kind
<= TYPES_DOMAIN
);
4367 ourtype
= types
[kind
];
4368 ourtype2
= types2
[kind
];
4369 ourtype3
= types3
[kind
];
4370 ourtype4
= types4
[kind
];
4374 /* Make sure spacing is right for C++ operators.
4375 This is just a courtesy to make the matching less sensitive
4376 to how many spaces the user leaves between 'operator'
4377 and <TYPENAME> or <OPERATOR>. */
4379 const char *opname
= operator_chars (regexp
, &opend
);
4383 int fix
= -1; /* -1 means ok; otherwise number of
4386 if (isalpha (*opname
) || *opname
== '_' || *opname
== '$')
4388 /* There should 1 space between 'operator' and 'TYPENAME'. */
4389 if (opname
[-1] != ' ' || opname
[-2] == ' ')
4394 /* There should 0 spaces between 'operator' and 'OPERATOR'. */
4395 if (opname
[-1] == ' ')
4398 /* If wrong number of spaces, fix it. */
4401 char *tmp
= (char *) alloca (8 + fix
+ strlen (opname
) + 1);
4403 sprintf (tmp
, "operator%.*s%s", fix
, " ", opname
);
4408 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4410 preg
.emplace (regexp
, cflags
, _("Invalid regexp"));
4413 if (t_regexp
!= NULL
)
4415 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
4417 treg
.emplace (t_regexp
, cflags
, _("Invalid regexp"));
4420 /* Search through the partial symtabs *first* for all symbols
4421 matching the regexp. That way we don't have to reproduce all of
4422 the machinery below. */
4423 expand_symtabs_matching ([&] (const char *filename
, bool basenames
)
4425 return file_matches (filename
, files
, nfiles
,
4428 lookup_name_info::match_any (),
4429 [&] (const char *symname
)
4431 return (!preg
.has_value ()
4432 || preg
->exec (symname
,
4438 /* Here, we search through the minimal symbol tables for functions
4439 and variables that match, and force their symbols to be read.
4440 This is in particular necessary for demangled variable names,
4441 which are no longer put into the partial symbol tables.
4442 The symbol will then be found during the scan of symtabs below.
4444 For functions, find_pc_symtab should succeed if we have debug info
4445 for the function, for variables we have to call
4446 lookup_symbol_in_objfile_from_linkage_name to determine if the variable
4448 If the lookup fails, set found_misc so that we will rescan to print
4449 any matching symbols without debug info.
4450 We only search the objfile the msymbol came from, we no longer search
4451 all objfiles. In large programs (1000s of shared libs) searching all
4452 objfiles is not worth the pain. */
4454 if (nfiles
== 0 && (kind
== VARIABLES_DOMAIN
|| kind
== FUNCTIONS_DOMAIN
))
4456 for (objfile
*objfile
: all_objfiles (current_program_space
))
4458 for (minimal_symbol
*msymbol
: objfile_msymbols (objfile
))
4462 if (msymbol
->created_by_gdb
)
4465 if (MSYMBOL_TYPE (msymbol
) == ourtype
4466 || MSYMBOL_TYPE (msymbol
) == ourtype2
4467 || MSYMBOL_TYPE (msymbol
) == ourtype3
4468 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4470 if (!preg
.has_value ()
4471 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4474 /* Note: An important side-effect of these
4475 lookup functions is to expand the symbol
4476 table if msymbol is found, for the benefit of
4477 the next loop on compunits. */
4478 if (kind
== FUNCTIONS_DOMAIN
4479 ? (find_pc_compunit_symtab
4480 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4482 : (lookup_symbol_in_objfile_from_linkage_name
4483 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4493 for (objfile
*objfile
: all_objfiles (current_program_space
))
4495 for (compunit_symtab
*cust
: objfile_compunits (objfile
))
4497 bv
= COMPUNIT_BLOCKVECTOR (cust
);
4498 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
4500 b
= BLOCKVECTOR_BLOCK (bv
, i
);
4501 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
4503 struct symtab
*real_symtab
= symbol_symtab (sym
);
4507 /* Check first sole REAL_SYMTAB->FILENAME. It does
4508 not need to be a substring of symtab_to_fullname as
4509 it may contain "./" etc. */
4510 if ((file_matches (real_symtab
->filename
, files
, nfiles
, 0)
4511 || ((basenames_may_differ
4512 || file_matches (lbasename (real_symtab
->filename
),
4514 && file_matches (symtab_to_fullname (real_symtab
),
4516 && ((!preg
.has_value ()
4517 || preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
4519 && ((kind
== VARIABLES_DOMAIN
4520 && SYMBOL_CLASS (sym
) != LOC_TYPEDEF
4521 && SYMBOL_CLASS (sym
) != LOC_UNRESOLVED
4522 && SYMBOL_CLASS (sym
) != LOC_BLOCK
4523 /* LOC_CONST can be used for more than
4524 just enums, e.g., c++ static const
4525 members. We only want to skip enums
4527 && !(SYMBOL_CLASS (sym
) == LOC_CONST
4528 && (TYPE_CODE (SYMBOL_TYPE (sym
))
4530 && (!treg
.has_value ()
4531 || treg_matches_sym_type_name (*treg
, sym
)))
4532 || (kind
== FUNCTIONS_DOMAIN
4533 && SYMBOL_CLASS (sym
) == LOC_BLOCK
4534 && (!treg
.has_value ()
4535 || treg_matches_sym_type_name (*treg
,
4537 || (kind
== TYPES_DOMAIN
4538 && SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))))
4541 result
.emplace_back (i
, sym
);
4548 if (!result
.empty ())
4549 sort_search_symbols_remove_dups (&result
);
4551 /* If there are no eyes, avoid all contact. I mean, if there are
4552 no debug symbols, then add matching minsyms. But if the user wants
4553 to see symbols matching a type regexp, then never give a minimal symbol,
4554 as we assume that a minimal symbol does not have a type. */
4556 if ((found_misc
|| (nfiles
== 0 && kind
!= FUNCTIONS_DOMAIN
))
4557 && !treg
.has_value ())
4559 for (objfile
*objfile
: all_objfiles (current_program_space
))
4561 for (minimal_symbol
*msymbol
: objfile_msymbols (objfile
))
4565 if (msymbol
->created_by_gdb
)
4568 if (MSYMBOL_TYPE (msymbol
) == ourtype
4569 || MSYMBOL_TYPE (msymbol
) == ourtype2
4570 || MSYMBOL_TYPE (msymbol
) == ourtype3
4571 || MSYMBOL_TYPE (msymbol
) == ourtype4
)
4573 if (!preg
.has_value ()
4574 || preg
->exec (MSYMBOL_NATURAL_NAME (msymbol
), 0,
4577 /* For functions we can do a quick check of whether the
4578 symbol might be found via find_pc_symtab. */
4579 if (kind
!= FUNCTIONS_DOMAIN
4580 || (find_pc_compunit_symtab
4581 (MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
))
4584 if (lookup_symbol_in_objfile_from_linkage_name
4585 (objfile
, MSYMBOL_LINKAGE_NAME (msymbol
),
4590 result
.emplace_back (i
, msymbol
, objfile
);
4602 /* Helper function for symtab_symbol_info, this function uses
4603 the data returned from search_symbols() to print information
4604 regarding the match to gdb_stdout. If LAST is not NULL,
4605 print file and line number information for the symbol as
4606 well. Skip printing the filename if it matches LAST. */
4609 print_symbol_info (enum search_domain kind
,
4611 int block
, const char *last
)
4613 scoped_switch_to_sym_language_if_auto
l (sym
);
4614 struct symtab
*s
= symbol_symtab (sym
);
4618 const char *s_filename
= symtab_to_filename_for_display (s
);
4620 if (filename_cmp (last
, s_filename
) != 0)
4622 fputs_filtered ("\nFile ", gdb_stdout
);
4623 fputs_filtered (s_filename
, gdb_stdout
);
4624 fputs_filtered (":\n", gdb_stdout
);
4627 if (SYMBOL_LINE (sym
) != 0)
4628 printf_filtered ("%d:\t", SYMBOL_LINE (sym
));
4630 puts_filtered ("\t");
4633 if (kind
!= TYPES_DOMAIN
&& block
== STATIC_BLOCK
)
4634 printf_filtered ("static ");
4636 /* Typedef that is not a C++ class. */
4637 if (kind
== TYPES_DOMAIN
4638 && SYMBOL_DOMAIN (sym
) != STRUCT_DOMAIN
)
4639 typedef_print (SYMBOL_TYPE (sym
), sym
, gdb_stdout
);
4640 /* variable, func, or typedef-that-is-c++-class. */
4641 else if (kind
< TYPES_DOMAIN
4642 || (kind
== TYPES_DOMAIN
4643 && SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
))
4645 type_print (SYMBOL_TYPE (sym
),
4646 (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4647 ? "" : SYMBOL_PRINT_NAME (sym
)),
4650 printf_filtered (";\n");
4654 /* This help function for symtab_symbol_info() prints information
4655 for non-debugging symbols to gdb_stdout. */
4658 print_msymbol_info (struct bound_minimal_symbol msymbol
)
4660 struct gdbarch
*gdbarch
= get_objfile_arch (msymbol
.objfile
);
4663 if (gdbarch_addr_bit (gdbarch
) <= 32)
4664 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
)
4665 & (CORE_ADDR
) 0xffffffff,
4668 tmp
= hex_string_custom (BMSYMBOL_VALUE_ADDRESS (msymbol
),
4670 printf_filtered ("%s %s\n",
4671 tmp
, MSYMBOL_PRINT_NAME (msymbol
.minsym
));
4674 /* This is the guts of the commands "info functions", "info types", and
4675 "info variables". It calls search_symbols to find all matches and then
4676 print_[m]symbol_info to print out some useful information about the
4680 symtab_symbol_info (bool quiet
,
4681 const char *regexp
, enum search_domain kind
,
4682 const char *t_regexp
, int from_tty
)
4684 static const char * const classnames
[] =
4685 {"variable", "function", "type"};
4686 const char *last_filename
= "";
4689 gdb_assert (kind
<= TYPES_DOMAIN
);
4691 /* Must make sure that if we're interrupted, symbols gets freed. */
4692 std::vector
<symbol_search
> symbols
= search_symbols (regexp
, kind
,
4699 if (t_regexp
!= NULL
)
4701 (_("All %ss matching regular expression \"%s\""
4702 " with type matching regulation expression \"%s\":\n"),
4703 classnames
[kind
], regexp
, t_regexp
);
4705 printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
4706 classnames
[kind
], regexp
);
4710 if (t_regexp
!= NULL
)
4712 (_("All defined %ss"
4713 " with type matching regulation expression \"%s\" :\n"),
4714 classnames
[kind
], t_regexp
);
4716 printf_filtered (_("All defined %ss:\n"), classnames
[kind
]);
4720 for (const symbol_search
&p
: symbols
)
4724 if (p
.msymbol
.minsym
!= NULL
)
4729 printf_filtered (_("\nNon-debugging symbols:\n"));
4732 print_msymbol_info (p
.msymbol
);
4736 print_symbol_info (kind
,
4741 = symtab_to_filename_for_display (symbol_symtab (p
.symbol
));
4747 info_variables_command (const char *args
, int from_tty
)
4750 std::string t_regexp
;
4754 && extract_info_print_args (&args
, &quiet
, ®exp
, &t_regexp
))
4758 report_unrecognized_option_error ("info variables", args
);
4760 symtab_symbol_info (quiet
,
4761 regexp
.empty () ? NULL
: regexp
.c_str (),
4763 t_regexp
.empty () ? NULL
: t_regexp
.c_str (),
4769 info_functions_command (const char *args
, int from_tty
)
4772 std::string t_regexp
;
4776 && extract_info_print_args (&args
, &quiet
, ®exp
, &t_regexp
))
4780 report_unrecognized_option_error ("info functions", args
);
4782 symtab_symbol_info (quiet
,
4783 regexp
.empty () ? NULL
: regexp
.c_str (),
4785 t_regexp
.empty () ? NULL
: t_regexp
.c_str (),
4791 info_types_command (const char *regexp
, int from_tty
)
4793 symtab_symbol_info (false, regexp
, TYPES_DOMAIN
, NULL
, from_tty
);
4796 /* Breakpoint all functions matching regular expression. */
4799 rbreak_command_wrapper (char *regexp
, int from_tty
)
4801 rbreak_command (regexp
, from_tty
);
4805 rbreak_command (const char *regexp
, int from_tty
)
4808 const char **files
= NULL
;
4809 const char *file_name
;
4814 const char *colon
= strchr (regexp
, ':');
4816 if (colon
&& *(colon
+ 1) != ':')
4821 colon_index
= colon
- regexp
;
4822 local_name
= (char *) alloca (colon_index
+ 1);
4823 memcpy (local_name
, regexp
, colon_index
);
4824 local_name
[colon_index
--] = 0;
4825 while (isspace (local_name
[colon_index
]))
4826 local_name
[colon_index
--] = 0;
4827 file_name
= local_name
;
4830 regexp
= skip_spaces (colon
+ 1);
4834 std::vector
<symbol_search
> symbols
= search_symbols (regexp
,
4839 scoped_rbreak_breakpoints finalize
;
4840 for (const symbol_search
&p
: symbols
)
4842 if (p
.msymbol
.minsym
== NULL
)
4844 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
4845 const char *fullname
= symtab_to_fullname (symtab
);
4847 string
= string_printf ("%s:'%s'", fullname
,
4848 SYMBOL_LINKAGE_NAME (p
.symbol
));
4849 break_command (&string
[0], from_tty
);
4850 print_symbol_info (FUNCTIONS_DOMAIN
, p
.symbol
, p
.block
, NULL
);
4854 string
= string_printf ("'%s'",
4855 MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
));
4857 break_command (&string
[0], from_tty
);
4858 printf_filtered ("<function, no debug info> %s;\n",
4859 MSYMBOL_PRINT_NAME (p
.msymbol
.minsym
));
4865 /* Evaluate if SYMNAME matches LOOKUP_NAME. */
4868 compare_symbol_name (const char *symbol_name
, language symbol_language
,
4869 const lookup_name_info
&lookup_name
,
4870 completion_match_result
&match_res
)
4872 const language_defn
*lang
= language_def (symbol_language
);
4874 symbol_name_matcher_ftype
*name_match
4875 = get_symbol_name_matcher (lang
, lookup_name
);
4877 return name_match (symbol_name
, lookup_name
, &match_res
);
4883 completion_list_add_name (completion_tracker
&tracker
,
4884 language symbol_language
,
4885 const char *symname
,
4886 const lookup_name_info
&lookup_name
,
4887 const char *text
, const char *word
)
4889 completion_match_result
&match_res
4890 = tracker
.reset_completion_match_result ();
4892 /* Clip symbols that cannot match. */
4893 if (!compare_symbol_name (symname
, symbol_language
, lookup_name
, match_res
))
4896 /* Refresh SYMNAME from the match string. It's potentially
4897 different depending on language. (E.g., on Ada, the match may be
4898 the encoded symbol name wrapped in "<>"). */
4899 symname
= match_res
.match
.match ();
4900 gdb_assert (symname
!= NULL
);
4902 /* We have a match for a completion, so add SYMNAME to the current list
4903 of matches. Note that the name is moved to freshly malloc'd space. */
4906 gdb::unique_xmalloc_ptr
<char> completion
4907 = make_completion_match_str (symname
, text
, word
);
4909 /* Here we pass the match-for-lcd object to add_completion. Some
4910 languages match the user text against substrings of symbol
4911 names in some cases. E.g., in C++, "b push_ba" completes to
4912 "std::vector::push_back", "std::string::push_back", etc., and
4913 in this case we want the completion lowest common denominator
4914 to be "push_back" instead of "std::". */
4915 tracker
.add_completion (std::move (completion
),
4916 &match_res
.match_for_lcd
, text
, word
);
4920 /* completion_list_add_name wrapper for struct symbol. */
4923 completion_list_add_symbol (completion_tracker
&tracker
,
4925 const lookup_name_info
&lookup_name
,
4926 const char *text
, const char *word
)
4928 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
4929 SYMBOL_NATURAL_NAME (sym
),
4930 lookup_name
, text
, word
);
4933 /* completion_list_add_name wrapper for struct minimal_symbol. */
4936 completion_list_add_msymbol (completion_tracker
&tracker
,
4937 minimal_symbol
*sym
,
4938 const lookup_name_info
&lookup_name
,
4939 const char *text
, const char *word
)
4941 completion_list_add_name (tracker
, MSYMBOL_LANGUAGE (sym
),
4942 MSYMBOL_NATURAL_NAME (sym
),
4943 lookup_name
, text
, word
);
4947 /* ObjC: In case we are completing on a selector, look as the msymbol
4948 again and feed all the selectors into the mill. */
4951 completion_list_objc_symbol (completion_tracker
&tracker
,
4952 struct minimal_symbol
*msymbol
,
4953 const lookup_name_info
&lookup_name
,
4954 const char *text
, const char *word
)
4956 static char *tmp
= NULL
;
4957 static unsigned int tmplen
= 0;
4959 const char *method
, *category
, *selector
;
4962 method
= MSYMBOL_NATURAL_NAME (msymbol
);
4964 /* Is it a method? */
4965 if ((method
[0] != '-') && (method
[0] != '+'))
4969 /* Complete on shortened method method. */
4970 completion_list_add_name (tracker
, language_objc
,
4975 while ((strlen (method
) + 1) >= tmplen
)
4981 tmp
= (char *) xrealloc (tmp
, tmplen
);
4983 selector
= strchr (method
, ' ');
4984 if (selector
!= NULL
)
4987 category
= strchr (method
, '(');
4989 if ((category
!= NULL
) && (selector
!= NULL
))
4991 memcpy (tmp
, method
, (category
- method
));
4992 tmp
[category
- method
] = ' ';
4993 memcpy (tmp
+ (category
- method
) + 1, selector
, strlen (selector
) + 1);
4994 completion_list_add_name (tracker
, language_objc
, tmp
,
4995 lookup_name
, text
, word
);
4997 completion_list_add_name (tracker
, language_objc
, tmp
+ 1,
4998 lookup_name
, text
, word
);
5001 if (selector
!= NULL
)
5003 /* Complete on selector only. */
5004 strcpy (tmp
, selector
);
5005 tmp2
= strchr (tmp
, ']');
5009 completion_list_add_name (tracker
, language_objc
, tmp
,
5010 lookup_name
, text
, word
);
5014 /* Break the non-quoted text based on the characters which are in
5015 symbols. FIXME: This should probably be language-specific. */
5018 language_search_unquoted_string (const char *text
, const char *p
)
5020 for (; p
> text
; --p
)
5022 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0')
5026 if ((current_language
->la_language
== language_objc
))
5028 if (p
[-1] == ':') /* Might be part of a method name. */
5030 else if (p
[-1] == '[' && (p
[-2] == '-' || p
[-2] == '+'))
5031 p
-= 2; /* Beginning of a method name. */
5032 else if (p
[-1] == ' ' || p
[-1] == '(' || p
[-1] == ')')
5033 { /* Might be part of a method name. */
5036 /* Seeing a ' ' or a '(' is not conclusive evidence
5037 that we are in the middle of a method name. However,
5038 finding "-[" or "+[" should be pretty un-ambiguous.
5039 Unfortunately we have to find it now to decide. */
5042 if (isalnum (t
[-1]) || t
[-1] == '_' ||
5043 t
[-1] == ' ' || t
[-1] == ':' ||
5044 t
[-1] == '(' || t
[-1] == ')')
5049 if (t
[-1] == '[' && (t
[-2] == '-' || t
[-2] == '+'))
5050 p
= t
- 2; /* Method name detected. */
5051 /* Else we leave with p unchanged. */
5061 completion_list_add_fields (completion_tracker
&tracker
,
5063 const lookup_name_info
&lookup_name
,
5064 const char *text
, const char *word
)
5066 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
5068 struct type
*t
= SYMBOL_TYPE (sym
);
5069 enum type_code c
= TYPE_CODE (t
);
5072 if (c
== TYPE_CODE_UNION
|| c
== TYPE_CODE_STRUCT
)
5073 for (j
= TYPE_N_BASECLASSES (t
); j
< TYPE_NFIELDS (t
); j
++)
5074 if (TYPE_FIELD_NAME (t
, j
))
5075 completion_list_add_name (tracker
, SYMBOL_LANGUAGE (sym
),
5076 TYPE_FIELD_NAME (t
, j
),
5077 lookup_name
, text
, word
);
5084 symbol_is_function_or_method (symbol
*sym
)
5086 switch (TYPE_CODE (SYMBOL_TYPE (sym
)))
5088 case TYPE_CODE_FUNC
:
5089 case TYPE_CODE_METHOD
:
5099 symbol_is_function_or_method (minimal_symbol
*msymbol
)
5101 switch (MSYMBOL_TYPE (msymbol
))
5104 case mst_text_gnu_ifunc
:
5105 case mst_solib_trampoline
:
5115 bound_minimal_symbol
5116 find_gnu_ifunc (const symbol
*sym
)
5118 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
5121 lookup_name_info
lookup_name (SYMBOL_SEARCH_NAME (sym
),
5122 symbol_name_match_type::SEARCH_NAME
);
5123 struct objfile
*objfile
= symbol_objfile (sym
);
5125 CORE_ADDR address
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
5126 minimal_symbol
*ifunc
= NULL
;
5128 iterate_over_minimal_symbols (objfile
, lookup_name
,
5129 [&] (minimal_symbol
*minsym
)
5131 if (MSYMBOL_TYPE (minsym
) == mst_text_gnu_ifunc
5132 || MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5134 CORE_ADDR msym_addr
= MSYMBOL_VALUE_ADDRESS (objfile
, minsym
);
5135 if (MSYMBOL_TYPE (minsym
) == mst_data_gnu_ifunc
)
5137 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5139 = gdbarch_convert_from_func_ptr_addr (gdbarch
,
5141 current_top_target ());
5143 if (msym_addr
== address
)
5153 return {ifunc
, objfile
};
5157 /* Add matching symbols from SYMTAB to the current completion list. */
5160 add_symtab_completions (struct compunit_symtab
*cust
,
5161 completion_tracker
&tracker
,
5162 complete_symbol_mode mode
,
5163 const lookup_name_info
&lookup_name
,
5164 const char *text
, const char *word
,
5165 enum type_code code
)
5168 const struct block
*b
;
5169 struct block_iterator iter
;
5175 for (i
= GLOBAL_BLOCK
; i
<= STATIC_BLOCK
; i
++)
5178 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), i
);
5179 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5181 if (completion_skip_symbol (mode
, sym
))
5184 if (code
== TYPE_CODE_UNDEF
5185 || (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5186 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
))
5187 completion_list_add_symbol (tracker
, sym
,
5195 default_collect_symbol_completion_matches_break_on
5196 (completion_tracker
&tracker
, complete_symbol_mode mode
,
5197 symbol_name_match_type name_match_type
,
5198 const char *text
, const char *word
,
5199 const char *break_on
, enum type_code code
)
5201 /* Problem: All of the symbols have to be copied because readline
5202 frees them. I'm not going to worry about this; hopefully there
5203 won't be that many. */
5206 const struct block
*b
;
5207 const struct block
*surrounding_static_block
, *surrounding_global_block
;
5208 struct block_iterator iter
;
5209 /* The symbol we are completing on. Points in same buffer as text. */
5210 const char *sym_text
;
5212 /* Now look for the symbol we are supposed to complete on. */
5213 if (mode
== complete_symbol_mode::LINESPEC
)
5219 const char *quote_pos
= NULL
;
5221 /* First see if this is a quoted string. */
5223 for (p
= text
; *p
!= '\0'; ++p
)
5225 if (quote_found
!= '\0')
5227 if (*p
== quote_found
)
5228 /* Found close quote. */
5230 else if (*p
== '\\' && p
[1] == quote_found
)
5231 /* A backslash followed by the quote character
5232 doesn't end the string. */
5235 else if (*p
== '\'' || *p
== '"')
5241 if (quote_found
== '\'')
5242 /* A string within single quotes can be a symbol, so complete on it. */
5243 sym_text
= quote_pos
+ 1;
5244 else if (quote_found
== '"')
5245 /* A double-quoted string is never a symbol, nor does it make sense
5246 to complete it any other way. */
5252 /* It is not a quoted string. Break it based on the characters
5253 which are in symbols. */
5256 if (isalnum (p
[-1]) || p
[-1] == '_' || p
[-1] == '\0'
5257 || p
[-1] == ':' || strchr (break_on
, p
[-1]) != NULL
)
5266 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5268 /* At this point scan through the misc symbol vectors and add each
5269 symbol you find to the list. Eventually we want to ignore
5270 anything that isn't a text symbol (everything else will be
5271 handled by the psymtab code below). */
5273 if (code
== TYPE_CODE_UNDEF
)
5275 for (objfile
*objfile
: all_objfiles (current_program_space
))
5277 for (minimal_symbol
*msymbol
: objfile_msymbols (objfile
))
5281 if (completion_skip_symbol (mode
, msymbol
))
5284 completion_list_add_msymbol (tracker
, msymbol
, lookup_name
,
5287 completion_list_objc_symbol (tracker
, msymbol
, lookup_name
,
5293 /* Add completions for all currently loaded symbol tables. */
5294 for (objfile
*objfile
: all_objfiles (current_program_space
))
5296 for (compunit_symtab
*cust
: objfile_compunits (objfile
))
5297 add_symtab_completions (cust
, tracker
, mode
, lookup_name
,
5298 sym_text
, word
, code
);
5301 /* Look through the partial symtabs for all symbols which begin by
5302 matching SYM_TEXT. Expand all CUs that you find to the list. */
5303 expand_symtabs_matching (NULL
,
5306 [&] (compunit_symtab
*symtab
) /* expansion notify */
5308 add_symtab_completions (symtab
,
5309 tracker
, mode
, lookup_name
,
5310 sym_text
, word
, code
);
5314 /* Search upwards from currently selected frame (so that we can
5315 complete on local vars). Also catch fields of types defined in
5316 this places which match our text string. Only complete on types
5317 visible from current context. */
5319 b
= get_selected_block (0);
5320 surrounding_static_block
= block_static_block (b
);
5321 surrounding_global_block
= block_global_block (b
);
5322 if (surrounding_static_block
!= NULL
)
5323 while (b
!= surrounding_static_block
)
5327 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
5329 if (code
== TYPE_CODE_UNDEF
)
5331 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5333 completion_list_add_fields (tracker
, sym
, lookup_name
,
5336 else if (SYMBOL_DOMAIN (sym
) == STRUCT_DOMAIN
5337 && TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
5338 completion_list_add_symbol (tracker
, sym
, lookup_name
,
5342 /* Stop when we encounter an enclosing function. Do not stop for
5343 non-inlined functions - the locals of the enclosing function
5344 are in scope for a nested function. */
5345 if (BLOCK_FUNCTION (b
) != NULL
&& block_inlined_p (b
))
5347 b
= BLOCK_SUPERBLOCK (b
);
5350 /* Add fields from the file's types; symbols will be added below. */
5352 if (code
== TYPE_CODE_UNDEF
)
5354 if (surrounding_static_block
!= NULL
)
5355 ALL_BLOCK_SYMBOLS (surrounding_static_block
, iter
, sym
)
5356 completion_list_add_fields (tracker
, sym
, lookup_name
,
5359 if (surrounding_global_block
!= NULL
)
5360 ALL_BLOCK_SYMBOLS (surrounding_global_block
, iter
, sym
)
5361 completion_list_add_fields (tracker
, sym
, lookup_name
,
5365 /* Skip macros if we are completing a struct tag -- arguable but
5366 usually what is expected. */
5367 if (current_language
->la_macro_expansion
== macro_expansion_c
5368 && code
== TYPE_CODE_UNDEF
)
5370 gdb::unique_xmalloc_ptr
<struct macro_scope
> scope
;
5372 /* This adds a macro's name to the current completion list. */
5373 auto add_macro_name
= [&] (const char *macro_name
,
5374 const macro_definition
*,
5375 macro_source_file
*,
5378 completion_list_add_name (tracker
, language_c
, macro_name
,
5379 lookup_name
, sym_text
, word
);
5382 /* Add any macros visible in the default scope. Note that this
5383 may yield the occasional wrong result, because an expression
5384 might be evaluated in a scope other than the default. For
5385 example, if the user types "break file:line if <TAB>", the
5386 resulting expression will be evaluated at "file:line" -- but
5387 at there does not seem to be a way to detect this at
5389 scope
= default_macro_scope ();
5391 macro_for_each_in_scope (scope
->file
, scope
->line
,
5394 /* User-defined macros are always visible. */
5395 macro_for_each (macro_user_macros
, add_macro_name
);
5400 default_collect_symbol_completion_matches (completion_tracker
&tracker
,
5401 complete_symbol_mode mode
,
5402 symbol_name_match_type name_match_type
,
5403 const char *text
, const char *word
,
5404 enum type_code code
)
5406 return default_collect_symbol_completion_matches_break_on (tracker
, mode
,
5412 /* Collect all symbols (regardless of class) which begin by matching
5416 collect_symbol_completion_matches (completion_tracker
&tracker
,
5417 complete_symbol_mode mode
,
5418 symbol_name_match_type name_match_type
,
5419 const char *text
, const char *word
)
5421 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5427 /* Like collect_symbol_completion_matches, but only collect
5428 STRUCT_DOMAIN symbols whose type code is CODE. */
5431 collect_symbol_completion_matches_type (completion_tracker
&tracker
,
5432 const char *text
, const char *word
,
5433 enum type_code code
)
5435 complete_symbol_mode mode
= complete_symbol_mode::EXPRESSION
;
5436 symbol_name_match_type name_match_type
= symbol_name_match_type::EXPRESSION
;
5438 gdb_assert (code
== TYPE_CODE_UNION
5439 || code
== TYPE_CODE_STRUCT
5440 || code
== TYPE_CODE_ENUM
);
5441 current_language
->la_collect_symbol_completion_matches (tracker
, mode
,
5446 /* Like collect_symbol_completion_matches, but collects a list of
5447 symbols defined in all source files named SRCFILE. */
5450 collect_file_symbol_completion_matches (completion_tracker
&tracker
,
5451 complete_symbol_mode mode
,
5452 symbol_name_match_type name_match_type
,
5453 const char *text
, const char *word
,
5454 const char *srcfile
)
5456 /* The symbol we are completing on. Points in same buffer as text. */
5457 const char *sym_text
;
5459 /* Now look for the symbol we are supposed to complete on.
5460 FIXME: This should be language-specific. */
5461 if (mode
== complete_symbol_mode::LINESPEC
)
5467 const char *quote_pos
= NULL
;
5469 /* First see if this is a quoted string. */
5471 for (p
= text
; *p
!= '\0'; ++p
)
5473 if (quote_found
!= '\0')
5475 if (*p
== quote_found
)
5476 /* Found close quote. */
5478 else if (*p
== '\\' && p
[1] == quote_found
)
5479 /* A backslash followed by the quote character
5480 doesn't end the string. */
5483 else if (*p
== '\'' || *p
== '"')
5489 if (quote_found
== '\'')
5490 /* A string within single quotes can be a symbol, so complete on it. */
5491 sym_text
= quote_pos
+ 1;
5492 else if (quote_found
== '"')
5493 /* A double-quoted string is never a symbol, nor does it make sense
5494 to complete it any other way. */
5500 /* Not a quoted string. */
5501 sym_text
= language_search_unquoted_string (text
, p
);
5505 lookup_name_info
lookup_name (sym_text
, name_match_type
, true);
5507 /* Go through symtabs for SRCFILE and check the externs and statics
5508 for symbols which match. */
5509 iterate_over_symtabs (srcfile
, [&] (symtab
*s
)
5511 add_symtab_completions (SYMTAB_COMPUNIT (s
),
5512 tracker
, mode
, lookup_name
,
5513 sym_text
, word
, TYPE_CODE_UNDEF
);
5518 /* A helper function for make_source_files_completion_list. It adds
5519 another file name to a list of possible completions, growing the
5520 list as necessary. */
5523 add_filename_to_list (const char *fname
, const char *text
, const char *word
,
5524 completion_list
*list
)
5526 list
->emplace_back (make_completion_match_str (fname
, text
, word
));
5530 not_interesting_fname (const char *fname
)
5532 static const char *illegal_aliens
[] = {
5533 "_globals_", /* inserted by coff_symtab_read */
5538 for (i
= 0; illegal_aliens
[i
]; i
++)
5540 if (filename_cmp (fname
, illegal_aliens
[i
]) == 0)
5546 /* An object of this type is passed as the user_data argument to
5547 map_partial_symbol_filenames. */
5548 struct add_partial_filename_data
5550 struct filename_seen_cache
*filename_seen_cache
;
5554 completion_list
*list
;
5557 /* A callback for map_partial_symbol_filenames. */
5560 maybe_add_partial_symtab_filename (const char *filename
, const char *fullname
,
5563 struct add_partial_filename_data
*data
5564 = (struct add_partial_filename_data
*) user_data
;
5566 if (not_interesting_fname (filename
))
5568 if (!data
->filename_seen_cache
->seen (filename
)
5569 && filename_ncmp (filename
, data
->text
, data
->text_len
) == 0)
5571 /* This file matches for a completion; add it to the
5572 current list of matches. */
5573 add_filename_to_list (filename
, data
->text
, data
->word
, data
->list
);
5577 const char *base_name
= lbasename (filename
);
5579 if (base_name
!= filename
5580 && !data
->filename_seen_cache
->seen (base_name
)
5581 && filename_ncmp (base_name
, data
->text
, data
->text_len
) == 0)
5582 add_filename_to_list (base_name
, data
->text
, data
->word
, data
->list
);
5586 /* Return a list of all source files whose names begin with matching
5587 TEXT. The file names are looked up in the symbol tables of this
5591 make_source_files_completion_list (const char *text
, const char *word
)
5593 size_t text_len
= strlen (text
);
5594 completion_list list
;
5595 const char *base_name
;
5596 struct add_partial_filename_data datum
;
5598 if (!have_full_symbols () && !have_partial_symbols ())
5601 filename_seen_cache filenames_seen
;
5603 for (objfile
*objfile
: all_objfiles (current_program_space
))
5605 for (compunit_symtab
*cu
: objfile_compunits (objfile
))
5607 for (symtab
*s
: compunit_filetabs (cu
))
5609 if (not_interesting_fname (s
->filename
))
5611 if (!filenames_seen
.seen (s
->filename
)
5612 && filename_ncmp (s
->filename
, text
, text_len
) == 0)
5614 /* This file matches for a completion; add it to the current
5616 add_filename_to_list (s
->filename
, text
, word
, &list
);
5620 /* NOTE: We allow the user to type a base name when the
5621 debug info records leading directories, but not the other
5622 way around. This is what subroutines of breakpoint
5623 command do when they parse file names. */
5624 base_name
= lbasename (s
->filename
);
5625 if (base_name
!= s
->filename
5626 && !filenames_seen
.seen (base_name
)
5627 && filename_ncmp (base_name
, text
, text_len
) == 0)
5628 add_filename_to_list (base_name
, text
, word
, &list
);
5634 datum
.filename_seen_cache
= &filenames_seen
;
5637 datum
.text_len
= text_len
;
5639 map_symbol_filenames (maybe_add_partial_symtab_filename
, &datum
,
5640 0 /*need_fullname*/);
5647 /* Return the "main_info" object for the current program space. If
5648 the object has not yet been created, create it and fill in some
5651 static struct main_info
*
5652 get_main_info (void)
5654 struct main_info
*info
5655 = (struct main_info
*) program_space_data (current_program_space
,
5656 main_progspace_key
);
5660 /* It may seem strange to store the main name in the progspace
5661 and also in whatever objfile happens to see a main name in
5662 its debug info. The reason for this is mainly historical:
5663 gdb returned "main" as the name even if no function named
5664 "main" was defined the program; and this approach lets us
5665 keep compatibility. */
5666 info
= XCNEW (struct main_info
);
5667 info
->language_of_main
= language_unknown
;
5668 set_program_space_data (current_program_space
, main_progspace_key
,
5675 /* A cleanup to destroy a struct main_info when a progspace is
5679 main_info_cleanup (struct program_space
*pspace
, void *data
)
5681 struct main_info
*info
= (struct main_info
*) data
;
5684 xfree (info
->name_of_main
);
5689 set_main_name (const char *name
, enum language lang
)
5691 struct main_info
*info
= get_main_info ();
5693 if (info
->name_of_main
!= NULL
)
5695 xfree (info
->name_of_main
);
5696 info
->name_of_main
= NULL
;
5697 info
->language_of_main
= language_unknown
;
5701 info
->name_of_main
= xstrdup (name
);
5702 info
->language_of_main
= lang
;
5706 /* Deduce the name of the main procedure, and set NAME_OF_MAIN
5710 find_main_name (void)
5712 const char *new_main_name
;
5714 /* First check the objfiles to see whether a debuginfo reader has
5715 picked up the appropriate main name. Historically the main name
5716 was found in a more or less random way; this approach instead
5717 relies on the order of objfile creation -- which still isn't
5718 guaranteed to get the correct answer, but is just probably more
5720 for (objfile
*objfile
: all_objfiles (current_program_space
))
5722 if (objfile
->per_bfd
->name_of_main
!= NULL
)
5724 set_main_name (objfile
->per_bfd
->name_of_main
,
5725 objfile
->per_bfd
->language_of_main
);
5730 /* Try to see if the main procedure is in Ada. */
5731 /* FIXME: brobecker/2005-03-07: Another way of doing this would
5732 be to add a new method in the language vector, and call this
5733 method for each language until one of them returns a non-empty
5734 name. This would allow us to remove this hard-coded call to
5735 an Ada function. It is not clear that this is a better approach
5736 at this point, because all methods need to be written in a way
5737 such that false positives never be returned. For instance, it is
5738 important that a method does not return a wrong name for the main
5739 procedure if the main procedure is actually written in a different
5740 language. It is easy to guaranty this with Ada, since we use a
5741 special symbol generated only when the main in Ada to find the name
5742 of the main procedure. It is difficult however to see how this can
5743 be guarantied for languages such as C, for instance. This suggests
5744 that order of call for these methods becomes important, which means
5745 a more complicated approach. */
5746 new_main_name
= ada_main_name ();
5747 if (new_main_name
!= NULL
)
5749 set_main_name (new_main_name
, language_ada
);
5753 new_main_name
= d_main_name ();
5754 if (new_main_name
!= NULL
)
5756 set_main_name (new_main_name
, language_d
);
5760 new_main_name
= go_main_name ();
5761 if (new_main_name
!= NULL
)
5763 set_main_name (new_main_name
, language_go
);
5767 new_main_name
= pascal_main_name ();
5768 if (new_main_name
!= NULL
)
5770 set_main_name (new_main_name
, language_pascal
);
5774 /* The languages above didn't identify the name of the main procedure.
5775 Fallback to "main". */
5776 set_main_name ("main", language_unknown
);
5782 struct main_info
*info
= get_main_info ();
5784 if (info
->name_of_main
== NULL
)
5787 return info
->name_of_main
;
5790 /* Return the language of the main function. If it is not known,
5791 return language_unknown. */
5794 main_language (void)
5796 struct main_info
*info
= get_main_info ();
5798 if (info
->name_of_main
== NULL
)
5801 return info
->language_of_main
;
5804 /* Handle ``executable_changed'' events for the symtab module. */
5807 symtab_observer_executable_changed (void)
5809 /* NAME_OF_MAIN may no longer be the same, so reset it for now. */
5810 set_main_name (NULL
, language_unknown
);
5813 /* Return 1 if the supplied producer string matches the ARM RealView
5814 compiler (armcc). */
5817 producer_is_realview (const char *producer
)
5819 static const char *const arm_idents
[] = {
5820 "ARM C Compiler, ADS",
5821 "Thumb C Compiler, ADS",
5822 "ARM C++ Compiler, ADS",
5823 "Thumb C++ Compiler, ADS",
5824 "ARM/Thumb C/C++ Compiler, RVCT",
5825 "ARM C/C++ Compiler, RVCT"
5829 if (producer
== NULL
)
5832 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
5833 if (startswith (producer
, arm_idents
[i
]))
5841 /* The next index to hand out in response to a registration request. */
5843 static int next_aclass_value
= LOC_FINAL_VALUE
;
5845 /* The maximum number of "aclass" registrations we support. This is
5846 constant for convenience. */
5847 #define MAX_SYMBOL_IMPLS (LOC_FINAL_VALUE + 10)
5849 /* The objects representing the various "aclass" values. The elements
5850 from 0 up to LOC_FINAL_VALUE-1 represent themselves, and subsequent
5851 elements are those registered at gdb initialization time. */
5853 static struct symbol_impl symbol_impl
[MAX_SYMBOL_IMPLS
];
5855 /* The globally visible pointer. This is separate from 'symbol_impl'
5856 so that it can be const. */
5858 const struct symbol_impl
*symbol_impls
= &symbol_impl
[0];
5860 /* Make sure we saved enough room in struct symbol. */
5862 gdb_static_assert (MAX_SYMBOL_IMPLS
<= (1 << SYMBOL_ACLASS_BITS
));
5864 /* Register a computed symbol type. ACLASS must be LOC_COMPUTED. OPS
5865 is the ops vector associated with this index. This returns the new
5866 index, which should be used as the aclass_index field for symbols
5870 register_symbol_computed_impl (enum address_class aclass
,
5871 const struct symbol_computed_ops
*ops
)
5873 int result
= next_aclass_value
++;
5875 gdb_assert (aclass
== LOC_COMPUTED
);
5876 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5877 symbol_impl
[result
].aclass
= aclass
;
5878 symbol_impl
[result
].ops_computed
= ops
;
5880 /* Sanity check OPS. */
5881 gdb_assert (ops
!= NULL
);
5882 gdb_assert (ops
->tracepoint_var_ref
!= NULL
);
5883 gdb_assert (ops
->describe_location
!= NULL
);
5884 gdb_assert (ops
->get_symbol_read_needs
!= NULL
);
5885 gdb_assert (ops
->read_variable
!= NULL
);
5890 /* Register a function with frame base type. ACLASS must be LOC_BLOCK.
5891 OPS is the ops vector associated with this index. This returns the
5892 new index, which should be used as the aclass_index field for symbols
5896 register_symbol_block_impl (enum address_class aclass
,
5897 const struct symbol_block_ops
*ops
)
5899 int result
= next_aclass_value
++;
5901 gdb_assert (aclass
== LOC_BLOCK
);
5902 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5903 symbol_impl
[result
].aclass
= aclass
;
5904 symbol_impl
[result
].ops_block
= ops
;
5906 /* Sanity check OPS. */
5907 gdb_assert (ops
!= NULL
);
5908 gdb_assert (ops
->find_frame_base_location
!= NULL
);
5913 /* Register a register symbol type. ACLASS must be LOC_REGISTER or
5914 LOC_REGPARM_ADDR. OPS is the register ops vector associated with
5915 this index. This returns the new index, which should be used as
5916 the aclass_index field for symbols of this type. */
5919 register_symbol_register_impl (enum address_class aclass
,
5920 const struct symbol_register_ops
*ops
)
5922 int result
= next_aclass_value
++;
5924 gdb_assert (aclass
== LOC_REGISTER
|| aclass
== LOC_REGPARM_ADDR
);
5925 gdb_assert (result
< MAX_SYMBOL_IMPLS
);
5926 symbol_impl
[result
].aclass
= aclass
;
5927 symbol_impl
[result
].ops_register
= ops
;
5932 /* Initialize elements of 'symbol_impl' for the constants in enum
5936 initialize_ordinary_address_classes (void)
5940 for (i
= 0; i
< LOC_FINAL_VALUE
; ++i
)
5941 symbol_impl
[i
].aclass
= (enum address_class
) i
;
5946 /* Helper function to initialize the fields of an objfile-owned symbol.
5947 It assumed that *SYM is already all zeroes. */
5950 initialize_objfile_symbol_1 (struct symbol
*sym
)
5952 SYMBOL_OBJFILE_OWNED (sym
) = 1;
5953 SYMBOL_SECTION (sym
) = -1;
5956 /* Initialize the symbol SYM, and mark it as being owned by an objfile. */
5959 initialize_objfile_symbol (struct symbol
*sym
)
5961 memset (sym
, 0, sizeof (*sym
));
5962 initialize_objfile_symbol_1 (sym
);
5965 /* Allocate and initialize a new 'struct symbol' on OBJFILE's
5969 allocate_symbol (struct objfile
*objfile
)
5971 struct symbol
*result
;
5973 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
5974 initialize_objfile_symbol_1 (result
);
5979 /* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
5982 struct template_symbol
*
5983 allocate_template_symbol (struct objfile
*objfile
)
5985 struct template_symbol
*result
;
5987 result
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct template_symbol
);
5988 initialize_objfile_symbol_1 (result
);
5996 symbol_objfile (const struct symbol
*symbol
)
5998 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
5999 return SYMTAB_OBJFILE (symbol
->owner
.symtab
);
6005 symbol_arch (const struct symbol
*symbol
)
6007 if (!SYMBOL_OBJFILE_OWNED (symbol
))
6008 return symbol
->owner
.arch
;
6009 return get_objfile_arch (SYMTAB_OBJFILE (symbol
->owner
.symtab
));
6015 symbol_symtab (const struct symbol
*symbol
)
6017 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6018 return symbol
->owner
.symtab
;
6024 symbol_set_symtab (struct symbol
*symbol
, struct symtab
*symtab
)
6026 gdb_assert (SYMBOL_OBJFILE_OWNED (symbol
));
6027 symbol
->owner
.symtab
= symtab
;
6033 _initialize_symtab (void)
6035 initialize_ordinary_address_classes ();
6038 = register_program_space_data_with_cleanup (NULL
, main_info_cleanup
);
6041 = register_program_space_data_with_cleanup (NULL
, symbol_cache_cleanup
);
6043 add_info ("variables", info_variables_command
,
6044 info_print_args_help (_("\
6045 All global and static variable names or those matching REGEXPs.\n\
6046 Usage: info variables [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6047 Prints the global and static variables.\n"),
6048 _("global and static variables")));
6050 add_com ("whereis", class_info
, info_variables_command
,
6051 info_print_args_help (_("\
6052 All global and static variable names, or those matching REGEXPs.\n\
6053 Usage: whereis [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6054 Prints the global and static variables.\n"),
6055 _("global and static variables")));
6057 add_info ("functions", info_functions_command
,
6058 info_print_args_help (_("\
6059 All function names or those matching REGEXPs.\n\
6060 Usage: info functions [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
6061 Prints the functions.\n"),
6064 /* FIXME: This command has at least the following problems:
6065 1. It prints builtin types (in a very strange and confusing fashion).
6066 2. It doesn't print right, e.g. with
6067 typedef struct foo *FOO
6068 type_print prints "FOO" when we want to make it (in this situation)
6069 print "struct foo *".
6070 I also think "ptype" or "whatis" is more likely to be useful (but if
6071 there is much disagreement "info types" can be fixed). */
6072 add_info ("types", info_types_command
,
6073 _("All type names, or those matching REGEXP."));
6075 add_info ("sources", info_sources_command
,
6076 _("Source files in the program."));
6078 add_com ("rbreak", class_breakpoint
, rbreak_command
,
6079 _("Set a breakpoint for all functions matching REGEXP."));
6081 add_setshow_enum_cmd ("multiple-symbols", no_class
,
6082 multiple_symbols_modes
, &multiple_symbols_mode
,
6084 Set the debugger behavior when more than one symbol are possible matches\n\
6085 in an expression."), _("\
6086 Show how the debugger handles ambiguities in expressions."), _("\
6087 Valid values are \"ask\", \"all\", \"cancel\", and the default is \"all\"."),
6088 NULL
, NULL
, &setlist
, &showlist
);
6090 add_setshow_boolean_cmd ("basenames-may-differ", class_obscure
,
6091 &basenames_may_differ
, _("\
6092 Set whether a source file may have multiple base names."), _("\
6093 Show whether a source file may have multiple base names."), _("\
6094 (A \"base name\" is the name of a file with the directory part removed.\n\
6095 Example: The base name of \"/home/user/hello.c\" is \"hello.c\".)\n\
6096 If set, GDB will canonicalize file names (e.g., expand symlinks)\n\
6097 before comparing them. Canonicalization is an expensive operation,\n\
6098 but it allows the same file be known by more than one base name.\n\
6099 If not set (the default), all source files are assumed to have just\n\
6100 one base name, and gdb will do file name comparisons more efficiently."),
6102 &setlist
, &showlist
);
6104 add_setshow_zuinteger_cmd ("symtab-create", no_class
, &symtab_create_debug
,
6105 _("Set debugging of symbol table creation."),
6106 _("Show debugging of symbol table creation."), _("\
6107 When enabled (non-zero), debugging messages are printed when building\n\
6108 symbol tables. A value of 1 (one) normally provides enough information.\n\
6109 A value greater than 1 provides more verbose information."),
6112 &setdebuglist
, &showdebuglist
);
6114 add_setshow_zuinteger_cmd ("symbol-lookup", no_class
, &symbol_lookup_debug
,
6116 Set debugging of symbol lookup."), _("\
6117 Show debugging of symbol lookup."), _("\
6118 When enabled (non-zero), symbol lookups are logged."),
6120 &setdebuglist
, &showdebuglist
);
6122 add_setshow_zuinteger_cmd ("symbol-cache-size", no_class
,
6123 &new_symbol_cache_size
,
6124 _("Set the size of the symbol cache."),
6125 _("Show the size of the symbol cache."), _("\
6126 The size of the symbol cache.\n\
6127 If zero then the symbol cache is disabled."),
6128 set_symbol_cache_size_handler
, NULL
,
6129 &maintenance_set_cmdlist
,
6130 &maintenance_show_cmdlist
);
6132 add_cmd ("symbol-cache", class_maintenance
, maintenance_print_symbol_cache
,
6133 _("Dump the symbol cache for each program space."),
6134 &maintenanceprintlist
);
6136 add_cmd ("symbol-cache-statistics", class_maintenance
,
6137 maintenance_print_symbol_cache_statistics
,
6138 _("Print symbol cache statistics for each program space."),
6139 &maintenanceprintlist
);
6141 add_cmd ("flush-symbol-cache", class_maintenance
,
6142 maintenance_flush_symbol_cache
,
6143 _("Flush the symbol cache for each program space."),
6146 gdb::observers::executable_changed
.attach (symtab_observer_executable_changed
);
6147 gdb::observers::new_objfile
.attach (symtab_new_objfile_observer
);
6148 gdb::observers::free_objfile
.attach (symtab_free_objfile_observer
);