| /* Symbol table lookup for the GNU debugger, GDB. |
| |
| Copyright (C) 1986-2016 Free Software Foundation, Inc. |
| |
| This file is part of GDB. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| |
| #include "defs.h" |
| #include "symtab.h" |
| #include "gdbtypes.h" |
| #include "gdbcore.h" |
| #include "frame.h" |
| #include "target.h" |
| #include "value.h" |
| #include "symfile.h" |
| #include "objfiles.h" |
| #include "gdbcmd.h" |
| #include "gdb_regex.h" |
| #include "expression.h" |
| #include "language.h" |
| #include "demangle.h" |
| #include "inferior.h" |
| #include "source.h" |
| #include "filenames.h" /* for FILENAME_CMP */ |
| #include "objc-lang.h" |
| #include "d-lang.h" |
| #include "ada-lang.h" |
| #include "go-lang.h" |
| #include "p-lang.h" |
| #include "addrmap.h" |
| #include "cli/cli-utils.h" |
| #include "fnmatch.h" |
| #include "hashtab.h" |
| |
| #include "gdb_obstack.h" |
| #include "block.h" |
| #include "dictionary.h" |
| |
| #include <sys/types.h> |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #include <ctype.h> |
| #include "cp-abi.h" |
| #include "cp-support.h" |
| #include "observer.h" |
| #include "solist.h" |
| #include "macrotab.h" |
| #include "macroscope.h" |
| |
| #include "parser-defs.h" |
| #include "completer.h" |
| |
| /* Forward declarations for local functions. */ |
| |
| static void rbreak_command (char *, int); |
| |
| static int find_line_common (struct linetable *, int, int *, int); |
| |
| static struct block_symbol |
| lookup_symbol_aux (const char *name, |
| const struct block *block, |
| const domain_enum domain, |
| enum language language, |
| struct field_of_this_result *); |
| |
| static |
| struct block_symbol lookup_local_symbol (const char *name, |
| const struct block *block, |
| const domain_enum domain, |
| enum language language); |
| |
| static struct block_symbol |
| lookup_symbol_in_objfile (struct objfile *objfile, int block_index, |
| const char *name, const domain_enum domain); |
| |
| /* See symtab.h. */ |
| const struct block_symbol null_block_symbol = { NULL, NULL }; |
| |
| extern initialize_file_ftype _initialize_symtab; |
| |
| /* Program space key for finding name and language of "main". */ |
| |
| static const struct program_space_data *main_progspace_key; |
| |
| /* Type of the data stored on the program space. */ |
| |
| struct main_info |
| { |
| /* Name of "main". */ |
| |
| char *name_of_main; |
| |
| /* Language of "main". */ |
| |
| enum language language_of_main; |
| }; |
| |
| /* Program space key for finding its symbol cache. */ |
| |
| static const struct program_space_data *symbol_cache_key; |
| |
| /* The default symbol cache size. |
| There is no extra cpu cost for large N (except when flushing the cache, |
| which is rare). The value here is just a first attempt. A better default |
| value may be higher or lower. A prime number can make up for a bad hash |
| computation, so that's why the number is what it is. */ |
| #define DEFAULT_SYMBOL_CACHE_SIZE 1021 |
| |
| /* The maximum symbol cache size. |
| There's no method to the decision of what value to use here, other than |
| there's no point in allowing a user typo to make gdb consume all memory. */ |
| #define MAX_SYMBOL_CACHE_SIZE (1024*1024) |
| |
| /* symbol_cache_lookup returns this if a previous lookup failed to find the |
| symbol in any objfile. */ |
| #define SYMBOL_LOOKUP_FAILED \ |
| ((struct block_symbol) {(struct symbol *) 1, NULL}) |
| #define SYMBOL_LOOKUP_FAILED_P(SIB) (SIB.symbol == (struct symbol *) 1) |
| |
| /* Recording lookups that don't find the symbol is just as important, if not |
| more so, than recording found symbols. */ |
| |
| enum symbol_cache_slot_state |
| { |
| SYMBOL_SLOT_UNUSED, |
| SYMBOL_SLOT_NOT_FOUND, |
| SYMBOL_SLOT_FOUND |
| }; |
| |
| struct symbol_cache_slot |
| { |
| enum symbol_cache_slot_state state; |
| |
| /* The objfile that was current when the symbol was looked up. |
| This is only needed for global blocks, but for simplicity's sake |
| we allocate the space for both. If data shows the extra space used |
| for static blocks is a problem, we can split things up then. |
| |
| Global blocks need cache lookup to include the objfile context because |
| we need to account for gdbarch_iterate_over_objfiles_in_search_order |
| which can traverse objfiles in, effectively, any order, depending on |
| the current objfile, thus affecting which symbol is found. Normally, |
| only the current objfile is searched first, and then the rest are |
| searched in recorded order; but putting cache lookup inside |
| gdbarch_iterate_over_objfiles_in_search_order would be awkward. |
| Instead we just make the current objfile part of the context of |
| cache lookup. This means we can record the same symbol multiple times, |
| each with a different "current objfile" that was in effect when the |
| lookup was saved in the cache, but cache space is pretty cheap. */ |
| const struct objfile *objfile_context; |
| |
| union |
| { |
| struct block_symbol found; |
| struct |
| { |
| char *name; |
| domain_enum domain; |
| } not_found; |
| } value; |
| }; |
| |
| /* Symbols don't specify global vs static block. |
| So keep them in separate caches. */ |
| |
| struct block_symbol_cache |
| { |
| unsigned int hits; |
| unsigned int misses; |
| unsigned int collisions; |
| |
| /* SYMBOLS is a variable length array of this size. |
| One can imagine that in general one cache (global/static) should be a |
| fraction of the size of the other, but there's no data at the moment |
| on which to decide. */ |
| unsigned int size; |
| |
| struct symbol_cache_slot symbols[1]; |
| }; |
| |
| /* The symbol cache. |
| |
| Searching for symbols in the static and global blocks over multiple objfiles |
| again and again can be slow, as can searching very big objfiles. This is a |
| simple cache to improve symbol lookup performance, which is critical to |
| overall gdb performance. |
| |
| Symbols are hashed on the name, its domain, and block. |
| They are also hashed on their objfile for objfile-specific lookups. */ |
| |
| struct symbol_cache |
| { |
| struct block_symbol_cache *global_symbols; |
| struct block_symbol_cache *static_symbols; |
| }; |
| |
| /* When non-zero, print debugging messages related to symtab creation. */ |
| unsigned int symtab_create_debug = 0; |
| |
| /* When non-zero, print debugging messages related to symbol lookup. */ |
| unsigned int symbol_lookup_debug = 0; |
| |
| /* The size of the cache is staged here. */ |
| static unsigned int new_symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE; |
| |
| /* The current value of the symbol cache size. |
| This is saved so that if the user enters a value too big we can restore |
| the original value from here. */ |
| static unsigned int symbol_cache_size = DEFAULT_SYMBOL_CACHE_SIZE; |
| |
| /* Non-zero if a file may be known by two different basenames. |
| This is the uncommon case, and significantly slows down gdb. |
| Default set to "off" to not slow down the common case. */ |
| int basenames_may_differ = 0; |
| |
| /* Allow the user to configure the debugger behavior with respect |
| to multiple-choice menus when more than one symbol matches during |
| a symbol lookup. */ |
| |
| const char multiple_symbols_ask[] = "ask"; |
| const char multiple_symbols_all[] = "all"; |
| const char multiple_symbols_cancel[] = "cancel"; |
| static const char *const multiple_symbols_modes[] = |
| { |
| multiple_symbols_ask, |
| multiple_symbols_all, |
| multiple_symbols_cancel, |
| NULL |
| }; |
| static const char *multiple_symbols_mode = multiple_symbols_all; |
| |
| /* Read-only accessor to AUTO_SELECT_MODE. */ |
| |
| const char * |
| multiple_symbols_select_mode (void) |
| { |
| return multiple_symbols_mode; |
| } |
| |
| /* Return the name of a domain_enum. */ |
| |
| const char * |
| domain_name (domain_enum e) |
| { |
| switch (e) |
| { |
| case UNDEF_DOMAIN: return "UNDEF_DOMAIN"; |
| case VAR_DOMAIN: return "VAR_DOMAIN"; |
| case STRUCT_DOMAIN: return "STRUCT_DOMAIN"; |
| case MODULE_DOMAIN: return "MODULE_DOMAIN"; |
| case LABEL_DOMAIN: return "LABEL_DOMAIN"; |
| case COMMON_BLOCK_DOMAIN: return "COMMON_BLOCK_DOMAIN"; |
| default: gdb_assert_not_reached ("bad domain_enum"); |
| } |
| } |
| |
| /* Return the name of a search_domain . */ |
| |
| const char * |
| search_domain_name (enum search_domain e) |
| { |
| switch (e) |
| { |
| case VARIABLES_DOMAIN: return "VARIABLES_DOMAIN"; |
| case FUNCTIONS_DOMAIN: return "FUNCTIONS_DOMAIN"; |
| case TYPES_DOMAIN: return "TYPES_DOMAIN"; |
| case ALL_DOMAIN: return "ALL_DOMAIN"; |
| default: gdb_assert_not_reached ("bad search_domain"); |
| } |
| } |
| |
| /* See symtab.h. */ |
| |
| struct symtab * |
| compunit_primary_filetab (const struct compunit_symtab *cust) |
| { |
| gdb_assert (COMPUNIT_FILETABS (cust) != NULL); |
| |
| /* The primary file symtab is the first one in the list. */ |
| return COMPUNIT_FILETABS (cust); |
| } |
| |
| /* See symtab.h. */ |
| |
| enum language |
| compunit_language (const struct compunit_symtab *cust) |
| { |
| struct symtab *symtab = compunit_primary_filetab (cust); |
| |
| /* The language of the compunit symtab is the language of its primary |
| source file. */ |
| return SYMTAB_LANGUAGE (symtab); |
| } |
| |
| /* See whether FILENAME matches SEARCH_NAME using the rule that we |
| advertise to the user. (The manual's description of linespecs |
| describes what we advertise). Returns true if they match, false |
| otherwise. */ |
| |
| int |
| compare_filenames_for_search (const char *filename, const char *search_name) |
| { |
| int len = strlen (filename); |
| size_t search_len = strlen (search_name); |
| |
| if (len < search_len) |
| return 0; |
| |
| /* The tail of FILENAME must match. */ |
| if (FILENAME_CMP (filename + len - search_len, search_name) != 0) |
| return 0; |
| |
| /* Either the names must completely match, or the character |
| preceding the trailing SEARCH_NAME segment of FILENAME must be a |
| directory separator. |
| |
| The check !IS_ABSOLUTE_PATH ensures SEARCH_NAME "/dir/file.c" |
| cannot match FILENAME "/path//dir/file.c" - as user has requested |
| absolute path. The sama applies for "c:\file.c" possibly |
| incorrectly hypothetically matching "d:\dir\c:\file.c". |
| |
| The HAS_DRIVE_SPEC purpose is to make FILENAME "c:file.c" |
| compatible with SEARCH_NAME "file.c". In such case a compiler had |
| to put the "c:file.c" name into debug info. Such compatibility |
| works only on GDB built for DOS host. */ |
| return (len == search_len |
| || (!IS_ABSOLUTE_PATH (search_name) |
| && IS_DIR_SEPARATOR (filename[len - search_len - 1])) |
| || (HAS_DRIVE_SPEC (filename) |
| && STRIP_DRIVE_SPEC (filename) == &filename[len - search_len])); |
| } |
| |
| /* Same as compare_filenames_for_search, but for glob-style patterns. |
| Heads up on the order of the arguments. They match the order of |
| compare_filenames_for_search, but it's the opposite of the order of |
| arguments to gdb_filename_fnmatch. */ |
| |
| int |
| compare_glob_filenames_for_search (const char *filename, |
| const char *search_name) |
| { |
| /* We rely on the property of glob-style patterns with FNM_FILE_NAME that |
| all /s have to be explicitly specified. */ |
| int file_path_elements = count_path_elements (filename); |
| int search_path_elements = count_path_elements (search_name); |
| |
| if (search_path_elements > file_path_elements) |
| return 0; |
| |
| if (IS_ABSOLUTE_PATH (search_name)) |
| { |
| return (search_path_elements == file_path_elements |
| && gdb_filename_fnmatch (search_name, filename, |
| FNM_FILE_NAME | FNM_NOESCAPE) == 0); |
| } |
| |
| { |
| const char *file_to_compare |
| = strip_leading_path_elements (filename, |
| file_path_elements - search_path_elements); |
| |
| return gdb_filename_fnmatch (search_name, file_to_compare, |
| FNM_FILE_NAME | FNM_NOESCAPE) == 0; |
| } |
| } |
| |
| /* Check for a symtab of a specific name by searching some symtabs. |
| This is a helper function for callbacks of iterate_over_symtabs. |
| |
| If NAME is not absolute, then REAL_PATH is NULL |
| If NAME is absolute, then REAL_PATH is the gdb_realpath form of NAME. |
| |
| The return value, NAME, REAL_PATH, CALLBACK, and DATA |
| are identical to the `map_symtabs_matching_filename' method of |
| quick_symbol_functions. |
| |
| FIRST and AFTER_LAST indicate the range of compunit symtabs to search. |
| Each symtab within the specified compunit symtab is also searched. |
| AFTER_LAST is one past the last compunit symtab to search; NULL means to |
| search until the end of the list. */ |
| |
| int |
| iterate_over_some_symtabs (const char *name, |
| const char *real_path, |
| int (*callback) (struct symtab *symtab, |
| void *data), |
| void *data, |
| struct compunit_symtab *first, |
| struct compunit_symtab *after_last) |
| { |
| struct compunit_symtab *cust; |
| struct symtab *s; |
| const char* base_name = lbasename (name); |
| |
| for (cust = first; cust != NULL && cust != after_last; cust = cust->next) |
| { |
| ALL_COMPUNIT_FILETABS (cust, s) |
| { |
| if (compare_filenames_for_search (s->filename, name)) |
| { |
| if (callback (s, data)) |
| return 1; |
| continue; |
| } |
| |
| /* Before we invoke realpath, which can get expensive when many |
| files are involved, do a quick comparison of the basenames. */ |
| if (! basenames_may_differ |
| && FILENAME_CMP (base_name, lbasename (s->filename)) != 0) |
| continue; |
| |
| if (compare_filenames_for_search (symtab_to_fullname (s), name)) |
| { |
| if (callback (s, data)) |
| return 1; |
| continue; |
| } |
| |
| /* If the user gave us an absolute path, try to find the file in |
| this symtab and use its absolute path. */ |
| if (real_path != NULL) |
| { |
| const char *fullname = symtab_to_fullname (s); |
| |
| gdb_assert (IS_ABSOLUTE_PATH (real_path)); |
| gdb_assert (IS_ABSOLUTE_PATH (name)); |
| if (FILENAME_CMP (real_path, fullname) == 0) |
| { |
| if (callback (s, data)) |
| return 1; |
| continue; |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* Check for a symtab of a specific name; first in symtabs, then in |
| psymtabs. *If* there is no '/' in the name, a match after a '/' |
| in the symtab filename will also work. |
| |
| Calls CALLBACK with each symtab that is found and with the supplied |
| DATA. If CALLBACK returns true, the search stops. */ |
| |
| void |
| iterate_over_symtabs (const char *name, |
| int (*callback) (struct symtab *symtab, |
| void *data), |
| void *data) |
| { |
| struct objfile *objfile; |
| char *real_path = NULL; |
| struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); |
| |
| /* Here we are interested in canonicalizing an absolute path, not |
| absolutizing a relative path. */ |
| if (IS_ABSOLUTE_PATH (name)) |
| { |
| real_path = gdb_realpath (name); |
| make_cleanup (xfree, real_path); |
| gdb_assert (IS_ABSOLUTE_PATH (real_path)); |
| } |
| |
| ALL_OBJFILES (objfile) |
| { |
| if (iterate_over_some_symtabs (name, real_path, callback, data, |
| objfile->compunit_symtabs, NULL)) |
| { |
| do_cleanups (cleanups); |
| return; |
| } |
| } |
| |
| /* Same search rules as above apply here, but now we look thru the |
| psymtabs. */ |
| |
| ALL_OBJFILES (objfile) |
| { |
| if (objfile->sf |
| && objfile->sf->qf->map_symtabs_matching_filename (objfile, |
| name, |
| real_path, |
| callback, |
| data)) |
| { |
| do_cleanups (cleanups); |
| return; |
| } |
| } |
| |
| do_cleanups (cleanups); |
| } |
| |
| /* The callback function used by lookup_symtab. */ |
| |
| static int |
| lookup_symtab_callback (struct symtab *symtab, void *data) |
| { |
| struct symtab **result_ptr = (struct symtab **) data; |
| |
| *result_ptr = symtab; |
| return 1; |
| } |
| |
| /* A wrapper for iterate_over_symtabs that returns the first matching |
| symtab, or NULL. */ |
| |
| struct symtab * |
| lookup_symtab (const char *name) |
| { |
| struct symtab *result = NULL; |
| |
| iterate_over_symtabs (name, lookup_symtab_callback, &result); |
| return result; |
| } |
| |
| |
| /* Mangle a GDB method stub type. This actually reassembles the pieces of the |
| full method name, which consist of the class name (from T), the unadorned |
| method name from METHOD_ID, and the signature for the specific overload, |
| specified by SIGNATURE_ID. Note that this function is g++ specific. */ |
| |
| char * |
| gdb_mangle_name (struct type *type, int method_id, int signature_id) |
| { |
| int mangled_name_len; |
| char *mangled_name; |
| struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id); |
| struct fn_field *method = &f[signature_id]; |
| const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id); |
| const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id); |
| const char *newname = type_name_no_tag (type); |
| |
| /* Does the form of physname indicate that it is the full mangled name |
| of a constructor (not just the args)? */ |
| int is_full_physname_constructor; |
| |
| int is_constructor; |
| int is_destructor = is_destructor_name (physname); |
| /* Need a new type prefix. */ |
| const char *const_prefix = method->is_const ? "C" : ""; |
| const char *volatile_prefix = method->is_volatile ? "V" : ""; |
| char buf[20]; |
| int len = (newname == NULL ? 0 : strlen (newname)); |
| |
| /* Nothing to do if physname already contains a fully mangled v3 abi name |
| or an operator name. */ |
| if ((physname[0] == '_' && physname[1] == 'Z') |
| || is_operator_name (field_name)) |
| return xstrdup (physname); |
| |
| is_full_physname_constructor = is_constructor_name (physname); |
| |
| is_constructor = is_full_physname_constructor |
| || (newname && strcmp (field_name, newname) == 0); |
| |
| if (!is_destructor) |
| is_destructor = (startswith (physname, "__dt")); |
| |
| if (is_destructor || is_full_physname_constructor) |
| { |
| mangled_name = (char *) xmalloc (strlen (physname) + 1); |
| strcpy (mangled_name, physname); |
| return mangled_name; |
| } |
| |
| if (len == 0) |
| { |
| xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix); |
| } |
| else if (physname[0] == 't' || physname[0] == 'Q') |
| { |
| /* The physname for template and qualified methods already includes |
| the class name. */ |
| xsnprintf (buf, sizeof (buf), "__%s%s", const_prefix, volatile_prefix); |
| newname = NULL; |
| len = 0; |
| } |
| else |
| { |
| xsnprintf (buf, sizeof (buf), "__%s%s%d", const_prefix, |
| volatile_prefix, len); |
| } |
| mangled_name_len = ((is_constructor ? 0 : strlen (field_name)) |
| + strlen (buf) + len + strlen (physname) + 1); |
| |
| mangled_name = (char *) xmalloc (mangled_name_len); |
| if (is_constructor) |
| mangled_name[0] = '\0'; |
| else |
| strcpy (mangled_name, field_name); |
| |
| strcat (mangled_name, buf); |
| /* If the class doesn't have a name, i.e. newname NULL, then we just |
| mangle it using 0 for the length of the class. Thus it gets mangled |
| as something starting with `::' rather than `classname::'. */ |
| if (newname != NULL) |
| strcat (mangled_name, newname); |
| |
| strcat (mangled_name, physname); |
| return (mangled_name); |
| } |
| |
| /* Set the demangled name of GSYMBOL to NAME. NAME must be already |
| correctly allocated. */ |
| |
| void |
| symbol_set_demangled_name (struct general_symbol_info *gsymbol, |
| const char *name, |
| struct obstack *obstack) |
| { |
| if (gsymbol->language == language_ada) |
| { |
| if (name == NULL) |
| { |
| gsymbol->ada_mangled = 0; |
| gsymbol->language_specific.obstack = obstack; |
| } |
| else |
| { |
| gsymbol->ada_mangled = 1; |
| gsymbol->language_specific.demangled_name = name; |
| } |
| } |
| else |
| gsymbol->language_specific.demangled_name = name; |
| } |
| |
| /* Return the demangled name of GSYMBOL. */ |
| |
| const char * |
| symbol_get_demangled_name (const struct general_symbol_info *gsymbol) |
| { |
| if (gsymbol->language == language_ada) |
| { |
| if (!gsymbol->ada_mangled) |
| return NULL; |
| /* Fall through. */ |
| } |
| |
| return gsymbol->language_specific.demangled_name; |
| } |
| |
| |
| /* Initialize the language dependent portion of a symbol |
| depending upon the language for the symbol. */ |
| |
| void |
| symbol_set_language (struct general_symbol_info *gsymbol, |
| enum language language, |
| struct obstack *obstack) |
| { |
| gsymbol->language = language; |
| if (gsymbol->language == language_cplus |
| || gsymbol->language == language_d |
| || gsymbol->language == language_go |
| || gsymbol->language == language_java |
| || gsymbol->language == language_objc |
| || gsymbol->language == language_fortran) |
| { |
| symbol_set_demangled_name (gsymbol, NULL, obstack); |
| } |
| else if (gsymbol->language == language_ada) |
| { |
| gdb_assert (gsymbol->ada_mangled == 0); |
| gsymbol->language_specific.obstack = obstack; |
| } |
| else |
| { |
| memset (&gsymbol->language_specific, 0, |
| sizeof (gsymbol->language_specific)); |
| } |
| } |
| |
| /* Functions to initialize a symbol's mangled name. */ |
| |
| /* Objects of this type are stored in the demangled name hash table. */ |
| struct demangled_name_entry |
| { |
| const char *mangled; |
| char demangled[1]; |
| }; |
| |
| /* Hash function for the demangled name hash. */ |
| |
| static hashval_t |
| hash_demangled_name_entry (const void *data) |
| { |
| const struct demangled_name_entry *e |
| = (const struct demangled_name_entry *) data; |
| |
| return htab_hash_string (e->mangled); |
| } |
| |
| /* Equality function for the demangled name hash. */ |
| |
| static int |
| eq_demangled_name_entry (const void *a, const void *b) |
| { |
| const struct demangled_name_entry *da |
| = (const struct demangled_name_entry *) a; |
| const struct demangled_name_entry *db |
| = (const struct demangled_name_entry *) b; |
| |
| return strcmp (da->mangled, db->mangled) == 0; |
| } |
| |
| /* Create the hash table used for demangled names. Each hash entry is |
| a pair of strings; one for the mangled name and one for the demangled |
| name. The entry is hashed via just the mangled name. */ |
| |
| static void |
| create_demangled_names_hash (struct objfile *objfile) |
| { |
| /* Choose 256 as the starting size of the hash table, somewhat arbitrarily. |
| The hash table code will round this up to the next prime number. |
| Choosing a much larger table size wastes memory, and saves only about |
| 1% in symbol reading. */ |
| |
| objfile->per_bfd->demangled_names_hash = htab_create_alloc |
| (256, hash_demangled_name_entry, eq_demangled_name_entry, |
| NULL, xcalloc, xfree); |
| } |
| |
| /* Try to determine the demangled name for a symbol, based on the |
| language of that symbol. If the language is set to language_auto, |
| it will attempt to find any demangling algorithm that works and |
| then set the language appropriately. The returned name is allocated |
| by the demangler and should be xfree'd. */ |
| |
| static char * |
| symbol_find_demangled_name (struct general_symbol_info *gsymbol, |
| const char *mangled) |
| { |
| char *demangled = NULL; |
| int i; |
| int recognized; |
| |
| if (gsymbol->language == language_unknown) |
| gsymbol->language = language_auto; |
| |
| if (gsymbol->language != language_auto) |
| { |
| const struct language_defn *lang = language_def (gsymbol->language); |
| |
| language_sniff_from_mangled_name (lang, mangled, &demangled); |
| return demangled; |
| } |
| |
| for (i = language_unknown; i < nr_languages; ++i) |
| { |
| enum language l = (enum language) i; |
| const struct language_defn *lang = language_def (l); |
| |
| if (language_sniff_from_mangled_name (lang, mangled, &demangled)) |
| { |
| gsymbol->language = l; |
| return demangled; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /* Set both the mangled and demangled (if any) names for GSYMBOL based |
| on LINKAGE_NAME and LEN. Ordinarily, NAME is copied onto the |
| objfile's obstack; but if COPY_NAME is 0 and if NAME is |
| NUL-terminated, then this function assumes that NAME is already |
| correctly saved (either permanently or with a lifetime tied to the |
| objfile), and it will not be copied. |
| |
| The hash table corresponding to OBJFILE is used, and the memory |
| comes from the per-BFD storage_obstack. LINKAGE_NAME is copied, |
| so the pointer can be discarded after calling this function. */ |
| |
| /* We have to be careful when dealing with Java names: when we run |
| into a Java minimal symbol, we don't know it's a Java symbol, so it |
| gets demangled as a C++ name. This is unfortunate, but there's not |
| much we can do about it: but when demangling partial symbols and |
| regular symbols, we'd better not reuse the wrong demangled name. |
| (See PR gdb/1039.) We solve this by putting a distinctive prefix |
| on Java names when storing them in the hash table. */ |
| |
| /* FIXME: carlton/2003-03-13: This is an unfortunate situation. I |
| don't mind the Java prefix so much: different languages have |
| different demangling requirements, so it's only natural that we |
| need to keep language data around in our demangling cache. But |
| it's not good that the minimal symbol has the wrong demangled name. |
| Unfortunately, I can't think of any easy solution to that |
| problem. */ |
| |
| #define JAVA_PREFIX "##JAVA$$" |
| #define JAVA_PREFIX_LEN 8 |
| |
| void |
| symbol_set_names (struct general_symbol_info *gsymbol, |
| const char *linkage_name, int len, int copy_name, |
| struct objfile *objfile) |
| { |
| struct demangled_name_entry **slot; |
| /* A 0-terminated copy of the linkage name. */ |
| const char *linkage_name_copy; |
| /* A copy of the linkage name that might have a special Java prefix |
| added to it, for use when looking names up in the hash table. */ |
| const char *lookup_name; |
| /* The length of lookup_name. */ |
| int lookup_len; |
| struct demangled_name_entry entry; |
| struct objfile_per_bfd_storage *per_bfd = objfile->per_bfd; |
| |
| if (gsymbol->language == language_ada) |
| { |
| /* In Ada, we do the symbol lookups using the mangled name, so |
| we can save some space by not storing the demangled name. |
| |
| As a side note, we have also observed some overlap between |
| the C++ mangling and Ada mangling, similarly to what has |
| been observed with Java. Because we don't store the demangled |
| name with the symbol, we don't need to use the same trick |
| as Java. */ |
| if (!copy_name) |
| gsymbol->name = linkage_name; |
| else |
| { |
| char *name = (char *) obstack_alloc (&per_bfd->storage_obstack, |
| len + 1); |
| |
| memcpy (name, linkage_name, len); |
| name[len] = '\0'; |
| gsymbol->name = name; |
| } |
| symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack); |
| |
| return; |
| } |
| |
| if (per_bfd->demangled_names_hash == NULL) |
| create_demangled_names_hash (objfile); |
| |
| /* The stabs reader generally provides names that are not |
| NUL-terminated; most of the other readers don't do this, so we |
| can just use the given copy, unless we're in the Java case. */ |
| if (gsymbol->language == language_java) |
| { |
| char *alloc_name; |
| |
| lookup_len = len + JAVA_PREFIX_LEN; |
| alloc_name = (char *) alloca (lookup_len + 1); |
| memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN); |
| memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len); |
| alloc_name[lookup_len] = '\0'; |
| |
| lookup_name = alloc_name; |
| linkage_name_copy = alloc_name + JAVA_PREFIX_LEN; |
| } |
| else if (linkage_name[len] != '\0') |
| { |
| char *alloc_name; |
| |
| lookup_len = len; |
| alloc_name = (char *) alloca (lookup_len + 1); |
| memcpy (alloc_name, linkage_name, len); |
| alloc_name[lookup_len] = '\0'; |
| |
| lookup_name = alloc_name; |
| linkage_name_copy = alloc_name; |
| } |
| else |
| { |
| lookup_len = len; |
| lookup_name = linkage_name; |
| linkage_name_copy = linkage_name; |
| } |
| |
| entry.mangled = lookup_name; |
| slot = ((struct demangled_name_entry **) |
| htab_find_slot (per_bfd->demangled_names_hash, |
| &entry, INSERT)); |
| |
| /* If this name is not in the hash table, add it. */ |
| if (*slot == NULL |
| /* A C version of the symbol may have already snuck into the table. |
| This happens to, e.g., main.init (__go_init_main). Cope. */ |
| || (gsymbol->language == language_go |
| && (*slot)->demangled[0] == '\0')) |
| { |
| char *demangled_name = symbol_find_demangled_name (gsymbol, |
| linkage_name_copy); |
| int demangled_len = demangled_name ? strlen (demangled_name) : 0; |
| |
| /* Suppose we have demangled_name==NULL, copy_name==0, and |
| lookup_name==linkage_name. In this case, we already have the |
| mangled name saved, and we don't have a demangled name. So, |
| you might think we could save a little space by not recording |
| this in the hash table at all. |
| |
| It turns out that it is actually important to still save such |
| an entry in the hash table, because storing this name gives |
| us better bcache hit rates for partial symbols. */ |
| if (!copy_name && lookup_name == linkage_name) |
| { |
| *slot |
| = ((struct demangled_name_entry *) |
| obstack_alloc (&per_bfd->storage_obstack, |
| offsetof (struct demangled_name_entry, demangled) |
| + demangled_len + 1)); |
| (*slot)->mangled = lookup_name; |
| } |
| else |
| { |
| char *mangled_ptr; |
| |
| /* If we must copy the mangled name, put it directly after |
| the demangled name so we can have a single |
| allocation. */ |
| *slot |
| = ((struct demangled_name_entry *) |
| obstack_alloc (&per_bfd->storage_obstack, |
| offsetof (struct demangled_name_entry, demangled) |
| + lookup_len + demangled_len + 2)); |
| mangled_ptr = &((*slot)->demangled[demangled_len + 1]); |
| strcpy (mangled_ptr, lookup_name); |
| (*slot)->mangled = mangled_ptr; |
| } |
| |
| if (demangled_name != NULL) |
| { |
| strcpy ((*slot)->demangled, demangled_name); |
| xfree (demangled_name); |
| } |
| else |
| (*slot)->demangled[0] = '\0'; |
| } |
| |
| gsymbol->name = (*slot)->mangled + lookup_len - len; |
| if ((*slot)->demangled[0] != '\0') |
| symbol_set_demangled_name (gsymbol, (*slot)->demangled, |
| &per_bfd->storage_obstack); |
| else |
| symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack); |
| } |
| |
| /* Return the source code name of a symbol. In languages where |
| demangling is necessary, this is the demangled name. */ |
| |
| const char * |
| symbol_natural_name (const struct general_symbol_info *gsymbol) |
| { |
| switch (gsymbol->language) |
| { |
| case language_cplus: |
| case language_d: |
| case language_go: |
| case language_java: |
| case language_objc: |
| case language_fortran: |
| if (symbol_get_demangled_name (gsymbol) != NULL) |
| return symbol_get_demangled_name (gsymbol); |
| break; |
| case language_ada: |
| return ada_decode_symbol (gsymbol); |
| default: |
| break; |
| } |
| return gsymbol->name; |
| } |
| |
| /* Return the demangled name for a symbol based on the language for |
| that symbol. If no demangled name exists, return NULL. */ |
| |
| const char * |
| symbol_demangled_name (const struct general_symbol_info *gsymbol) |
| { |
| const char *dem_name = NULL; |
| |
| switch (gsymbol->language) |
| { |
| case language_cplus: |
| case language_d: |
| case language_go: |
| case language_java: |
| case language_objc: |
| case language_fortran: |
| dem_name = symbol_get_demangled_name (gsymbol); |
| break; |
| case language_ada: |
| dem_name = ada_decode_symbol (gsymbol); |
| break; |
| default: |
| break; |
| } |
| return dem_name; |
| } |
| |
| /* Return the search name of a symbol---generally the demangled or |
| linkage name of the symbol, depending on how it will be searched for. |
| If there is no distinct demangled name, then returns the same value |
| (same pointer) as SYMBOL_LINKAGE_NAME. */ |
| |
| const char * |
| symbol_search_name (const struct general_symbol_info *gsymbol) |
| { |
| if (gsymbol->language == language_ada) |
| return gsymbol->name; |
| else |
| return symbol_natural_name (gsymbol); |
| } |
| |
| /* Initialize the structure fields to zero values. */ |
| |
| void |
| init_sal (struct symtab_and_line *sal) |
| { |
| memset (sal, 0, sizeof (*sal)); |
| } |
| |
| |
| /* Return 1 if the two sections are the same, or if they could |
| plausibly be copies of each other, one in an original object |
| file and another in a separated debug file. */ |
| |
| int |
| matching_obj_sections (struct obj_section *obj_first, |
| struct obj_section *obj_second) |
| { |
| asection *first = obj_first? obj_first->the_bfd_section : NULL; |
| asection *second = obj_second? obj_second->the_bfd_section : NULL; |
| struct objfile *obj; |
| |
| /* If they're the same section, then they match. */ |
| if (first == second) |
| return 1; |
| |
| /* If either is NULL, give up. */ |
| if (first == NULL || second == NULL) |
| return 0; |
| |
| /* This doesn't apply to absolute symbols. */ |
| if (first->owner == NULL || second->owner == NULL) |
| return 0; |
| |
| /* If they're in the same object file, they must be different sections. */ |
| if (first->owner == second->owner) |
| return 0; |
| |
| /* Check whether the two sections are potentially corresponding. They must |
| have the same size, address, and name. We can't compare section indexes, |
| which would be more reliable, because some sections may have been |
| stripped. */ |
| if (bfd_get_section_size (first) != bfd_get_section_size (second)) |
| return 0; |
| |
| /* In-memory addresses may start at a different offset, relativize them. */ |
| if (bfd_get_section_vma (first->owner, first) |
| - bfd_get_start_address (first->owner) |
| != bfd_get_section_vma (second->owner, second) |
| - bfd_get_start_address (second->owner)) |
| return 0; |
| |
| if (bfd_get_section_name (first->owner, first) == NULL |
| || bfd_get_section_name (second->owner, second) == NULL |
| || strcmp (bfd_get_section_name (first->owner, first), |
| bfd_get_section_name (second->owner, second)) != 0) |
| return 0; |
| |
| /* Otherwise check that they are in corresponding objfiles. */ |
| |
| ALL_OBJFILES (obj) |
| if (obj->obfd == first->owner) |
| break; |
| gdb_assert (obj != NULL); |
| |
| if (obj->separate_debug_objfile != NULL |
| && obj->separate_debug_objfile->obfd == second->owner) |
| return 1; |
| if (obj->separate_debug_objfile_backlink != NULL |
| && obj->separate_debug_objfile_backlink->obfd == second->owner) |
| return 1; |
| |
| return 0; |
| } |
| |
| /* See symtab.h. */ |
| |
| void |
| expand_symtab_containing_pc (CORE_ADDR pc, struct obj_section *section) |
| { |
| struct objfile *objfile; |
| struct bound_minimal_symbol msymbol; |
| |
| /* If we know that this is not a text address, return failure. This is |
| necessary because we loop based on texthigh and textlow, which do |
| not include the data ranges. */ |
| msymbol = lookup_minimal_symbol_by_pc_section (pc, section); |
| if (msymbol.minsym |
| && (MSYMBOL_TYPE (msymbol.minsym) == mst_data |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_bss |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_abs |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss)) |
| return; |
| |
| ALL_OBJFILES (objfile) |
| { |
| struct compunit_symtab *cust = NULL; |
| |
| if (objfile->sf) |
| cust = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol, |
| pc, section, 0); |
| if (cust) |
| return; |
| } |
| } |
| |
| /* Hash function for the symbol cache. */ |
| |
| static unsigned int |
| hash_symbol_entry (const struct objfile *objfile_context, |
| const char *name, domain_enum domain) |
| { |
| unsigned int hash = (uintptr_t) objfile_context; |
| |
| if (name != NULL) |
| hash += htab_hash_string (name); |
| |
| /* Because of symbol_matches_domain we need VAR_DOMAIN and STRUCT_DOMAIN |
| to map to the same slot. */ |
| if (domain == STRUCT_DOMAIN) |
| hash += VAR_DOMAIN * 7; |
| else |
| hash += domain * 7; |
| |
| return hash; |
| } |
| |
| /* Equality function for the symbol cache. */ |
| |
| static int |
| eq_symbol_entry (const struct symbol_cache_slot *slot, |
| const struct objfile *objfile_context, |
| const char *name, domain_enum domain) |
| { |
| const char *slot_name; |
| domain_enum slot_domain; |
| |
| if (slot->state == SYMBOL_SLOT_UNUSED) |
| return 0; |
| |
| if (slot->objfile_context != objfile_context) |
| return 0; |
| |
| if (slot->state == SYMBOL_SLOT_NOT_FOUND) |
| { |
| slot_name = slot->value.not_found.name; |
| slot_domain = slot->value.not_found.domain; |
| } |
| else |
| { |
| slot_name = SYMBOL_SEARCH_NAME (slot->value.found.symbol); |
| slot_domain = SYMBOL_DOMAIN (slot->value.found.symbol); |
| } |
| |
| /* NULL names match. */ |
| if (slot_name == NULL && name == NULL) |
| { |
| /* But there's no point in calling symbol_matches_domain in the |
| SYMBOL_SLOT_FOUND case. */ |
| if (slot_domain != domain) |
| return 0; |
| } |
| else if (slot_name != NULL && name != NULL) |
| { |
| /* It's important that we use the same comparison that was done the |
| first time through. If the slot records a found symbol, then this |
| means using strcmp_iw on SYMBOL_SEARCH_NAME. See dictionary.c. |
| It also means using symbol_matches_domain for found symbols. |
| See block.c. |
| |
| If the slot records a not-found symbol, then require a precise match. |
| We could still be lax with whitespace like strcmp_iw though. */ |
| |
| if (slot->state == SYMBOL_SLOT_NOT_FOUND) |
| { |
| if (strcmp (slot_name, name) != 0) |
| return 0; |
| if (slot_domain != domain) |
| return 0; |
| } |
| else |
| { |
| struct symbol *sym = slot->value.found.symbol; |
| |
| if (strcmp_iw (slot_name, name) != 0) |
| return 0; |
| if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym), |
| slot_domain, domain)) |
| return 0; |
| } |
| } |
| else |
| { |
| /* Only one name is NULL. */ |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| /* Given a cache of size SIZE, return the size of the struct (with variable |
| length array) in bytes. */ |
| |
| static size_t |
| symbol_cache_byte_size (unsigned int size) |
| { |
| return (sizeof (struct block_symbol_cache) |
| + ((size - 1) * sizeof (struct symbol_cache_slot))); |
| } |
| |
| /* Resize CACHE. */ |
| |
| static void |
| resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size) |
| { |
| /* If there's no change in size, don't do anything. |
| All caches have the same size, so we can just compare with the size |
| of the global symbols cache. */ |
| if ((cache->global_symbols != NULL |
| && cache->global_symbols->size == new_size) |
| || (cache->global_symbols == NULL |
| && new_size == 0)) |
| return; |
| |
| xfree (cache->global_symbols); |
| xfree (cache->static_symbols); |
| |
| if (new_size == 0) |
| { |
| cache->global_symbols = NULL; |
| cache->static_symbols = NULL; |
| } |
| else |
| { |
| size_t total_size = symbol_cache_byte_size (new_size); |
| |
| cache->global_symbols |
| = (struct block_symbol_cache *) xcalloc (1, total_size); |
| cache->static_symbols |
| = (struct block_symbol_cache *) xcalloc (1, total_size); |
| cache->global_symbols->size = new_size; |
| cache->static_symbols->size = new_size; |
| } |
| } |
| |
| /* Make a symbol cache of size SIZE. */ |
| |
| static struct symbol_cache * |
| make_symbol_cache (unsigned int size) |
| { |
| struct symbol_cache *cache; |
| |
| cache = XCNEW (struct symbol_cache); |
| resize_symbol_cache (cache, symbol_cache_size); |
| return cache; |
| } |
| |
| /* Free the space used by CACHE. */ |
| |
| static void |
| free_symbol_cache (struct symbol_cache *cache) |
| { |
| xfree (cache->global_symbols); |
| xfree (cache->static_symbols); |
| xfree (cache); |
| } |
| |
| /* Return the symbol cache of PSPACE. |
| Create one if it doesn't exist yet. */ |
| |
| static struct symbol_cache * |
| get_symbol_cache (struct program_space *pspace) |
| { |
| struct symbol_cache *cache |
| = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key); |
| |
| if (cache == NULL) |
| { |
| cache = make_symbol_cache (symbol_cache_size); |
| set_program_space_data (pspace, symbol_cache_key, cache); |
| } |
| |
| return cache; |
| } |
| |
| /* Delete the symbol cache of PSPACE. |
| Called when PSPACE is destroyed. */ |
| |
| static void |
| symbol_cache_cleanup (struct program_space *pspace, void *data) |
| { |
| struct symbol_cache *cache = (struct symbol_cache *) data; |
| |
| free_symbol_cache (cache); |
| } |
| |
| /* Set the size of the symbol cache in all program spaces. */ |
| |
| static void |
| set_symbol_cache_size (unsigned int new_size) |
| { |
| struct program_space *pspace; |
| |
| ALL_PSPACES (pspace) |
| { |
| struct symbol_cache *cache |
| = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key); |
| |
| /* The pspace could have been created but not have a cache yet. */ |
| if (cache != NULL) |
| resize_symbol_cache (cache, new_size); |
| } |
| } |
| |
| /* Called when symbol-cache-size is set. */ |
| |
| static void |
| set_symbol_cache_size_handler (char *args, int from_tty, |
| struct cmd_list_element *c) |
| { |
| if (new_symbol_cache_size > MAX_SYMBOL_CACHE_SIZE) |
| { |
| /* Restore the previous value. |
| This is the value the "show" command prints. */ |
| new_symbol_cache_size = symbol_cache_size; |
| |
| error (_("Symbol cache size is too large, max is %u."), |
| MAX_SYMBOL_CACHE_SIZE); |
| } |
| symbol_cache_size = new_symbol_cache_size; |
| |
| set_symbol_cache_size (symbol_cache_size); |
| } |
| |
| /* Lookup symbol NAME,DOMAIN in BLOCK in the symbol cache of PSPACE. |
| OBJFILE_CONTEXT is the current objfile, which may be NULL. |
| The result is the symbol if found, SYMBOL_LOOKUP_FAILED if a previous lookup |
| failed (and thus this one will too), or NULL if the symbol is not present |
| in the cache. |
| If the symbol is not present in the cache, then *BSC_PTR and *SLOT_PTR are |
| set to the cache and slot of the symbol to save the result of a full lookup |
| attempt. */ |
| |
| static struct block_symbol |
| symbol_cache_lookup (struct symbol_cache *cache, |
| struct objfile *objfile_context, int block, |
| const char *name, domain_enum domain, |
| struct block_symbol_cache **bsc_ptr, |
| struct symbol_cache_slot **slot_ptr) |
| { |
| struct block_symbol_cache *bsc; |
| unsigned int hash; |
| struct symbol_cache_slot *slot; |
| |
| if (block == GLOBAL_BLOCK) |
| bsc = cache->global_symbols; |
| else |
| bsc = cache->static_symbols; |
| if (bsc == NULL) |
| { |
| *bsc_ptr = NULL; |
| *slot_ptr = NULL; |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| hash = hash_symbol_entry (objfile_context, name, domain); |
| slot = bsc->symbols + hash % bsc->size; |
| |
| if (eq_symbol_entry (slot, objfile_context, name, domain)) |
| { |
| if (symbol_lookup_debug) |
| fprintf_unfiltered (gdb_stdlog, |
| "%s block symbol cache hit%s for %s, %s\n", |
| block == GLOBAL_BLOCK ? "Global" : "Static", |
| slot->state == SYMBOL_SLOT_NOT_FOUND |
| ? " (not found)" : "", |
| name, domain_name (domain)); |
| ++bsc->hits; |
| if (slot->state == SYMBOL_SLOT_NOT_FOUND) |
| return SYMBOL_LOOKUP_FAILED; |
| return slot->value.found; |
| } |
| |
| /* Symbol is not present in the cache. */ |
| |
| *bsc_ptr = bsc; |
| *slot_ptr = slot; |
| |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "%s block symbol cache miss for %s, %s\n", |
| block == GLOBAL_BLOCK ? "Global" : "Static", |
| name, domain_name (domain)); |
| } |
| ++bsc->misses; |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* Clear out SLOT. */ |
| |
| static void |
| symbol_cache_clear_slot (struct symbol_cache_slot *slot) |
| { |
| if (slot->state == SYMBOL_SLOT_NOT_FOUND) |
| xfree (slot->value.not_found.name); |
| slot->state = SYMBOL_SLOT_UNUSED; |
| } |
| |
| /* Mark SYMBOL as found in SLOT. |
| OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL |
| if it's not needed to distinguish lookups (STATIC_BLOCK). It is *not* |
| necessarily the objfile the symbol was found in. */ |
| |
| static void |
| symbol_cache_mark_found (struct block_symbol_cache *bsc, |
| struct symbol_cache_slot *slot, |
| struct objfile *objfile_context, |
| struct symbol *symbol, |
| const struct block *block) |
| { |
| if (bsc == NULL) |
| return; |
| if (slot->state != SYMBOL_SLOT_UNUSED) |
| { |
| ++bsc->collisions; |
| symbol_cache_clear_slot (slot); |
| } |
| slot->state = SYMBOL_SLOT_FOUND; |
| slot->objfile_context = objfile_context; |
| slot->value.found.symbol = symbol; |
| slot->value.found.block = block; |
| } |
| |
| /* Mark symbol NAME, DOMAIN as not found in SLOT. |
| OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL |
| if it's not needed to distinguish lookups (STATIC_BLOCK). */ |
| |
| static void |
| symbol_cache_mark_not_found (struct block_symbol_cache *bsc, |
| struct symbol_cache_slot *slot, |
| struct objfile *objfile_context, |
| const char *name, domain_enum domain) |
| { |
| if (bsc == NULL) |
| return; |
| if (slot->state != SYMBOL_SLOT_UNUSED) |
| { |
| ++bsc->collisions; |
| symbol_cache_clear_slot (slot); |
| } |
| slot->state = SYMBOL_SLOT_NOT_FOUND; |
| slot->objfile_context = objfile_context; |
| slot->value.not_found.name = xstrdup (name); |
| slot->value.not_found.domain = domain; |
| } |
| |
| /* Flush the symbol cache of PSPACE. */ |
| |
| static void |
| symbol_cache_flush (struct program_space *pspace) |
| { |
| struct symbol_cache *cache |
| = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key); |
| int pass; |
| |
| if (cache == NULL) |
| return; |
| if (cache->global_symbols == NULL) |
| { |
| gdb_assert (symbol_cache_size == 0); |
| gdb_assert (cache->static_symbols == NULL); |
| return; |
| } |
| |
| /* If the cache is untouched since the last flush, early exit. |
| This is important for performance during the startup of a program linked |
| with 100s (or 1000s) of shared libraries. */ |
| if (cache->global_symbols->misses == 0 |
| && cache->static_symbols->misses == 0) |
| return; |
| |
| gdb_assert (cache->global_symbols->size == symbol_cache_size); |
| gdb_assert (cache->static_symbols->size == symbol_cache_size); |
| |
| for (pass = 0; pass < 2; ++pass) |
| { |
| struct block_symbol_cache *bsc |
| = pass == 0 ? cache->global_symbols : cache->static_symbols; |
| unsigned int i; |
| |
| for (i = 0; i < bsc->size; ++i) |
| symbol_cache_clear_slot (&bsc->symbols[i]); |
| } |
| |
| cache->global_symbols->hits = 0; |
| cache->global_symbols->misses = 0; |
| cache->global_symbols->collisions = 0; |
| cache->static_symbols->hits = 0; |
| cache->static_symbols->misses = 0; |
| cache->static_symbols->collisions = 0; |
| } |
| |
| /* Dump CACHE. */ |
| |
| static void |
| symbol_cache_dump (const struct symbol_cache *cache) |
| { |
| int pass; |
| |
| if (cache->global_symbols == NULL) |
| { |
| printf_filtered (" <disabled>\n"); |
| return; |
| } |
| |
| for (pass = 0; pass < 2; ++pass) |
| { |
| const struct block_symbol_cache *bsc |
| = pass == 0 ? cache->global_symbols : cache->static_symbols; |
| unsigned int i; |
| |
| if (pass == 0) |
| printf_filtered ("Global symbols:\n"); |
| else |
| printf_filtered ("Static symbols:\n"); |
| |
| for (i = 0; i < bsc->size; ++i) |
| { |
| const struct symbol_cache_slot *slot = &bsc->symbols[i]; |
| |
| QUIT; |
| |
| switch (slot->state) |
| { |
| case SYMBOL_SLOT_UNUSED: |
| break; |
| case SYMBOL_SLOT_NOT_FOUND: |
| printf_filtered (" [%4u] = %s, %s %s (not found)\n", i, |
| host_address_to_string (slot->objfile_context), |
| slot->value.not_found.name, |
| domain_name (slot->value.not_found.domain)); |
| break; |
| case SYMBOL_SLOT_FOUND: |
| { |
| struct symbol *found = slot->value.found.symbol; |
| const struct objfile *context = slot->objfile_context; |
| |
| printf_filtered (" [%4u] = %s, %s %s\n", i, |
| host_address_to_string (context), |
| SYMBOL_PRINT_NAME (found), |
| domain_name (SYMBOL_DOMAIN (found))); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* The "mt print symbol-cache" command. */ |
| |
| static void |
| maintenance_print_symbol_cache (char *args, int from_tty) |
| { |
| struct program_space *pspace; |
| |
| ALL_PSPACES (pspace) |
| { |
| struct symbol_cache *cache; |
| |
| printf_filtered (_("Symbol cache for pspace %d\n%s:\n"), |
| pspace->num, |
| pspace->symfile_object_file != NULL |
| ? objfile_name (pspace->symfile_object_file) |
| : "(no object file)"); |
| |
| /* If the cache hasn't been created yet, avoid creating one. */ |
| cache |
| = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key); |
| if (cache == NULL) |
| printf_filtered (" <empty>\n"); |
| else |
| symbol_cache_dump (cache); |
| } |
| } |
| |
| /* The "mt flush-symbol-cache" command. */ |
| |
| static void |
| maintenance_flush_symbol_cache (char *args, int from_tty) |
| { |
| struct program_space *pspace; |
| |
| ALL_PSPACES (pspace) |
| { |
| symbol_cache_flush (pspace); |
| } |
| } |
| |
| /* Print usage statistics of CACHE. */ |
| |
| static void |
| symbol_cache_stats (struct symbol_cache *cache) |
| { |
| int pass; |
| |
| if (cache->global_symbols == NULL) |
| { |
| printf_filtered (" <disabled>\n"); |
| return; |
| } |
| |
| for (pass = 0; pass < 2; ++pass) |
| { |
| const struct block_symbol_cache *bsc |
| = pass == 0 ? cache->global_symbols : cache->static_symbols; |
| |
| QUIT; |
| |
| if (pass == 0) |
| printf_filtered ("Global block cache stats:\n"); |
| else |
| printf_filtered ("Static block cache stats:\n"); |
| |
| printf_filtered (" size: %u\n", bsc->size); |
| printf_filtered (" hits: %u\n", bsc->hits); |
| printf_filtered (" misses: %u\n", bsc->misses); |
| printf_filtered (" collisions: %u\n", bsc->collisions); |
| } |
| } |
| |
| /* The "mt print symbol-cache-statistics" command. */ |
| |
| static void |
| maintenance_print_symbol_cache_statistics (char *args, int from_tty) |
| { |
| struct program_space *pspace; |
| |
| ALL_PSPACES (pspace) |
| { |
| struct symbol_cache *cache; |
| |
| printf_filtered (_("Symbol cache statistics for pspace %d\n%s:\n"), |
| pspace->num, |
| pspace->symfile_object_file != NULL |
| ? objfile_name (pspace->symfile_object_file) |
| : "(no object file)"); |
| |
| /* If the cache hasn't been created yet, avoid creating one. */ |
| cache |
| = (struct symbol_cache *) program_space_data (pspace, symbol_cache_key); |
| if (cache == NULL) |
| printf_filtered (" empty, no stats available\n"); |
| else |
| symbol_cache_stats (cache); |
| } |
| } |
| |
| /* This module's 'new_objfile' observer. */ |
| |
| static void |
| symtab_new_objfile_observer (struct objfile *objfile) |
| { |
| /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL. */ |
| symbol_cache_flush (current_program_space); |
| } |
| |
| /* This module's 'free_objfile' observer. */ |
| |
| static void |
| symtab_free_objfile_observer (struct objfile *objfile) |
| { |
| symbol_cache_flush (objfile->pspace); |
| } |
| |
| /* Debug symbols usually don't have section information. We need to dig that |
| out of the minimal symbols and stash that in the debug symbol. */ |
| |
| void |
| fixup_section (struct general_symbol_info *ginfo, |
| CORE_ADDR addr, struct objfile *objfile) |
| { |
| struct minimal_symbol *msym; |
| |
| /* First, check whether a minimal symbol with the same name exists |
| and points to the same address. The address check is required |
| e.g. on PowerPC64, where the minimal symbol for a function will |
| point to the function descriptor, while the debug symbol will |
| point to the actual function code. */ |
| msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile); |
| if (msym) |
| ginfo->section = MSYMBOL_SECTION (msym); |
| else |
| { |
| /* Static, function-local variables do appear in the linker |
| (minimal) symbols, but are frequently given names that won't |
| be found via lookup_minimal_symbol(). E.g., it has been |
| observed in frv-uclinux (ELF) executables that a static, |
| function-local variable named "foo" might appear in the |
| linker symbols as "foo.6" or "foo.3". Thus, there is no |
| point in attempting to extend the lookup-by-name mechanism to |
| handle this case due to the fact that there can be multiple |
| names. |
| |
| So, instead, search the section table when lookup by name has |
| failed. The ``addr'' and ``endaddr'' fields may have already |
| been relocated. If so, the relocation offset (i.e. the |
| ANOFFSET value) needs to be subtracted from these values when |
| performing the comparison. We unconditionally subtract it, |
| because, when no relocation has been performed, the ANOFFSET |
| value will simply be zero. |
| |
| The address of the symbol whose section we're fixing up HAS |
| NOT BEEN adjusted (relocated) yet. It can't have been since |
| the section isn't yet known and knowing the section is |
| necessary in order to add the correct relocation value. In |
| other words, we wouldn't even be in this function (attempting |
| to compute the section) if it were already known. |
| |
| Note that it is possible to search the minimal symbols |
| (subtracting the relocation value if necessary) to find the |
| matching minimal symbol, but this is overkill and much less |
| efficient. It is not necessary to find the matching minimal |
| symbol, only its section. |
| |
| Note that this technique (of doing a section table search) |
| can fail when unrelocated section addresses overlap. For |
| this reason, we still attempt a lookup by name prior to doing |
| a search of the section table. */ |
| |
| struct obj_section *s; |
| int fallback = -1; |
| |
| ALL_OBJFILE_OSECTIONS (objfile, s) |
| { |
| int idx = s - objfile->sections; |
| CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx); |
| |
| if (fallback == -1) |
| fallback = idx; |
| |
| if (obj_section_addr (s) - offset <= addr |
| && addr < obj_section_endaddr (s) - offset) |
| { |
| ginfo->section = idx; |
| return; |
| } |
| } |
| |
| /* If we didn't find the section, assume it is in the first |
| section. If there is no allocated section, then it hardly |
| matters what we pick, so just pick zero. */ |
| if (fallback == -1) |
| ginfo->section = 0; |
| else |
| ginfo->section = fallback; |
| } |
| } |
| |
| struct symbol * |
| fixup_symbol_section (struct symbol *sym, struct objfile *objfile) |
| { |
| CORE_ADDR addr; |
| |
| if (!sym) |
| return NULL; |
| |
| if (!SYMBOL_OBJFILE_OWNED (sym)) |
| return sym; |
| |
| /* We either have an OBJFILE, or we can get at it from the sym's |
| symtab. Anything else is a bug. */ |
| gdb_assert (objfile || symbol_symtab (sym)); |
| |
| if (objfile == NULL) |
| objfile = symbol_objfile (sym); |
| |
| if (SYMBOL_OBJ_SECTION (objfile, sym)) |
| return sym; |
| |
| /* We should have an objfile by now. */ |
| gdb_assert (objfile); |
| |
| switch (SYMBOL_CLASS (sym)) |
| { |
| case LOC_STATIC: |
| case LOC_LABEL: |
| addr = SYMBOL_VALUE_ADDRESS (sym); |
| break; |
| case LOC_BLOCK: |
| addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); |
| break; |
| |
| default: |
| /* Nothing else will be listed in the minsyms -- no use looking |
| it up. */ |
| return sym; |
| } |
| |
| fixup_section (&sym->ginfo, addr, objfile); |
| |
| return sym; |
| } |
| |
| /* Compute the demangled form of NAME as used by the various symbol |
| lookup functions. The result is stored in *RESULT_NAME. Returns a |
| cleanup which can be used to clean up the result. |
| |
| For Ada, this function just sets *RESULT_NAME to NAME, unmodified. |
| Normally, Ada symbol lookups are performed using the encoded name |
| rather than the demangled name, and so it might seem to make sense |
| for this function to return an encoded version of NAME. |
| Unfortunately, we cannot do this, because this function is used in |
| circumstances where it is not appropriate to try to encode NAME. |
| For instance, when displaying the frame info, we demangle the name |
| of each parameter, and then perform a symbol lookup inside our |
| function using that demangled name. In Ada, certain functions |
| have internally-generated parameters whose name contain uppercase |
| characters. Encoding those name would result in those uppercase |
| characters to become lowercase, and thus cause the symbol lookup |
| to fail. */ |
| |
| struct cleanup * |
| demangle_for_lookup (const char *name, enum language lang, |
| const char **result_name) |
| { |
| char *demangled_name = NULL; |
| const char *modified_name = NULL; |
| struct cleanup *cleanup = make_cleanup (null_cleanup, 0); |
| |
| modified_name = name; |
| |
| /* If we are using C++, D, Go, or Java, demangle the name before doing a |
| lookup, so we can always binary search. */ |
| if (lang == language_cplus) |
| { |
| demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS); |
| if (demangled_name) |
| { |
| modified_name = demangled_name; |
| make_cleanup (xfree, demangled_name); |
| } |
| else |
| { |
| /* If we were given a non-mangled name, canonicalize it |
| according to the language (so far only for C++). */ |
| demangled_name = cp_canonicalize_string (name); |
| if (demangled_name) |
| { |
| modified_name = demangled_name; |
| make_cleanup (xfree, demangled_name); |
| } |
| } |
| } |
| else if (lang == language_java) |
| { |
| demangled_name = gdb_demangle (name, |
| DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA); |
| if (demangled_name) |
| { |
| modified_name = demangled_name; |
| make_cleanup (xfree, demangled_name); |
| } |
| } |
| else if (lang == language_d) |
| { |
| demangled_name = d_demangle (name, 0); |
| if (demangled_name) |
| { |
| modified_name = demangled_name; |
| make_cleanup (xfree, demangled_name); |
| } |
| } |
| else if (lang == language_go) |
| { |
| demangled_name = go_demangle (name, 0); |
| if (demangled_name) |
| { |
| modified_name = demangled_name; |
| make_cleanup (xfree, demangled_name); |
| } |
| } |
| |
| *result_name = modified_name; |
| return cleanup; |
| } |
| |
| /* See symtab.h. |
| |
| This function (or rather its subordinates) have a bunch of loops and |
| it would seem to be attractive to put in some QUIT's (though I'm not really |
| sure whether it can run long enough to be really important). But there |
| are a few calls for which it would appear to be bad news to quit |
| out of here: e.g., find_proc_desc in alpha-mdebug-tdep.c. (Note |
| that there is C++ code below which can error(), but that probably |
| doesn't affect these calls since they are looking for a known |
| variable and thus can probably assume it will never hit the C++ |
| code). */ |
| |
| struct block_symbol |
| lookup_symbol_in_language (const char *name, const struct block *block, |
| const domain_enum domain, enum language lang, |
| struct field_of_this_result *is_a_field_of_this) |
| { |
| const char *modified_name; |
| struct block_symbol returnval; |
| struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name); |
| |
| returnval = lookup_symbol_aux (modified_name, block, domain, lang, |
| is_a_field_of_this); |
| do_cleanups (cleanup); |
| |
| return returnval; |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| lookup_symbol (const char *name, const struct block *block, |
| domain_enum domain, |
| struct field_of_this_result *is_a_field_of_this) |
| { |
| return lookup_symbol_in_language (name, block, domain, |
| current_language->la_language, |
| is_a_field_of_this); |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| lookup_language_this (const struct language_defn *lang, |
| const struct block *block) |
| { |
| if (lang->la_name_of_this == NULL || block == NULL) |
| return (struct block_symbol) {NULL, NULL}; |
| |
| if (symbol_lookup_debug > 1) |
| { |
| struct objfile *objfile = lookup_objfile_from_block (block); |
| |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_language_this (%s, %s (objfile %s))", |
| lang->la_name, host_address_to_string (block), |
| objfile_debug_name (objfile)); |
| } |
| |
| while (block) |
| { |
| struct symbol *sym; |
| |
| sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN); |
| if (sym != NULL) |
| { |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, " = %s (%s, block %s)\n", |
| SYMBOL_PRINT_NAME (sym), |
| host_address_to_string (sym), |
| host_address_to_string (block)); |
| } |
| return (struct block_symbol) {sym, block}; |
| } |
| if (BLOCK_FUNCTION (block)) |
| break; |
| block = BLOCK_SUPERBLOCK (block); |
| } |
| |
| if (symbol_lookup_debug > 1) |
| fprintf_unfiltered (gdb_stdlog, " = NULL\n"); |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* Given TYPE, a structure/union, |
| return 1 if the component named NAME from the ultimate target |
| structure/union is defined, otherwise, return 0. */ |
| |
| static int |
| check_field (struct type *type, const char *name, |
| struct field_of_this_result *is_a_field_of_this) |
| { |
| int i; |
| |
| /* The type may be a stub. */ |
| type = check_typedef (type); |
| |
| for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) |
| { |
| const char *t_field_name = TYPE_FIELD_NAME (type, i); |
| |
| if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) |
| { |
| is_a_field_of_this->type = type; |
| is_a_field_of_this->field = &TYPE_FIELD (type, i); |
| return 1; |
| } |
| } |
| |
| /* C++: If it was not found as a data field, then try to return it |
| as a pointer to a method. */ |
| |
| for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i) |
| { |
| if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0) |
| { |
| is_a_field_of_this->type = type; |
| is_a_field_of_this->fn_field = &TYPE_FN_FIELDLIST (type, i); |
| return 1; |
| } |
| } |
| |
| for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) |
| if (check_field (TYPE_BASECLASS (type, i), name, is_a_field_of_this)) |
| return 1; |
| |
| return 0; |
| } |
| |
| /* Behave like lookup_symbol except that NAME is the natural name |
| (e.g., demangled name) of the symbol that we're looking for. */ |
| |
| static struct block_symbol |
| lookup_symbol_aux (const char *name, const struct block *block, |
| const domain_enum domain, enum language language, |
| struct field_of_this_result *is_a_field_of_this) |
| { |
| struct block_symbol result; |
| const struct language_defn *langdef; |
| |
| if (symbol_lookup_debug) |
| { |
| struct objfile *objfile = lookup_objfile_from_block (block); |
| |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n", |
| name, host_address_to_string (block), |
| objfile != NULL |
| ? objfile_debug_name (objfile) : "NULL", |
| domain_name (domain), language_str (language)); |
| } |
| |
| /* Make sure we do something sensible with is_a_field_of_this, since |
| the callers that set this parameter to some non-null value will |
| certainly use it later. If we don't set it, the contents of |
| is_a_field_of_this are undefined. */ |
| if (is_a_field_of_this != NULL) |
| memset (is_a_field_of_this, 0, sizeof (*is_a_field_of_this)); |
| |
| /* Search specified block and its superiors. Don't search |
| STATIC_BLOCK or GLOBAL_BLOCK. */ |
| |
| result = lookup_local_symbol (name, block, domain, language); |
| if (result.symbol != NULL) |
| { |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n", |
| host_address_to_string (result.symbol)); |
| } |
| return result; |
| } |
| |
| /* If requested to do so by the caller and if appropriate for LANGUAGE, |
| check to see if NAME is a field of `this'. */ |
| |
| langdef = language_def (language); |
| |
| /* Don't do this check if we are searching for a struct. It will |
| not be found by check_field, but will be found by other |
| means. */ |
| if (is_a_field_of_this != NULL && domain != STRUCT_DOMAIN) |
| { |
| result = lookup_language_this (langdef, block); |
| |
| if (result.symbol) |
| { |
| struct type *t = result.symbol->type; |
| |
| /* I'm not really sure that type of this can ever |
| be typedefed; just be safe. */ |
| t = check_typedef (t); |
| if (TYPE_CODE (t) == TYPE_CODE_PTR |
| || TYPE_CODE (t) == TYPE_CODE_REF) |
| t = TYPE_TARGET_TYPE (t); |
| |
| if (TYPE_CODE (t) != TYPE_CODE_STRUCT |
| && TYPE_CODE (t) != TYPE_CODE_UNION) |
| error (_("Internal error: `%s' is not an aggregate"), |
| langdef->la_name_of_this); |
| |
| if (check_field (t, name, is_a_field_of_this)) |
| { |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_aux (...) = NULL\n"); |
| } |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| } |
| } |
| |
| /* Now do whatever is appropriate for LANGUAGE to look |
| up static and global variables. */ |
| |
| result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain); |
| if (result.symbol != NULL) |
| { |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n", |
| host_address_to_string (result.symbol)); |
| } |
| return result; |
| } |
| |
| /* Now search all static file-level symbols. Not strictly correct, |
| but more useful than an error. */ |
| |
| result = lookup_static_symbol (name, domain); |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n", |
| result.symbol != NULL |
| ? host_address_to_string (result.symbol) |
| : "NULL"); |
| } |
| return result; |
| } |
| |
| /* Check to see if the symbol is defined in BLOCK or its superiors. |
| Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ |
| |
| static struct block_symbol |
| lookup_local_symbol (const char *name, const struct block *block, |
| const domain_enum domain, |
| enum language language) |
| { |
| struct symbol *sym; |
| const struct block *static_block = block_static_block (block); |
| const char *scope = block_scope (block); |
| |
| /* Check if either no block is specified or it's a global block. */ |
| |
| if (static_block == NULL) |
| return (struct block_symbol) {NULL, NULL}; |
| |
| while (block != static_block) |
| { |
| sym = lookup_symbol_in_block (name, block, domain); |
| if (sym != NULL) |
| return (struct block_symbol) {sym, block}; |
| |
| if (language == language_cplus || language == language_fortran) |
| { |
| struct block_symbol sym |
| = cp_lookup_symbol_imports_or_template (scope, name, block, |
| domain); |
| |
| if (sym.symbol != NULL) |
| return sym; |
| } |
| |
| if (BLOCK_FUNCTION (block) != NULL && block_inlined_p (block)) |
| break; |
| block = BLOCK_SUPERBLOCK (block); |
| } |
| |
| /* We've reached the end of the function without finding a result. */ |
| |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* See symtab.h. */ |
| |
| struct objfile * |
| lookup_objfile_from_block (const struct block *block) |
| { |
| struct objfile *obj; |
| struct compunit_symtab *cust; |
| |
| if (block == NULL) |
| return NULL; |
| |
| block = block_global_block (block); |
| /* Look through all blockvectors. */ |
| ALL_COMPUNITS (obj, cust) |
| if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), |
| GLOBAL_BLOCK)) |
| { |
| if (obj->separate_debug_objfile_backlink) |
| obj = obj->separate_debug_objfile_backlink; |
| |
| return obj; |
| } |
| |
| return NULL; |
| } |
| |
| /* See symtab.h. */ |
| |
| struct symbol * |
| lookup_symbol_in_block (const char *name, const struct block *block, |
| const domain_enum domain) |
| { |
| struct symbol *sym; |
| |
| if (symbol_lookup_debug > 1) |
| { |
| struct objfile *objfile = lookup_objfile_from_block (block); |
| |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_block (%s, %s (objfile %s), %s)", |
| name, host_address_to_string (block), |
| objfile_debug_name (objfile), |
| domain_name (domain)); |
| } |
| |
| sym = block_lookup_symbol (block, name, domain); |
| if (sym) |
| { |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, " = %s\n", |
| host_address_to_string (sym)); |
| } |
| return fixup_symbol_section (sym, NULL); |
| } |
| |
| if (symbol_lookup_debug > 1) |
| fprintf_unfiltered (gdb_stdlog, " = NULL\n"); |
| return NULL; |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| lookup_global_symbol_from_objfile (struct objfile *main_objfile, |
| const char *name, |
| const domain_enum domain) |
| { |
| struct objfile *objfile; |
| |
| for (objfile = main_objfile; |
| objfile; |
| objfile = objfile_separate_debug_iterate (main_objfile, objfile)) |
| { |
| struct block_symbol result |
| = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, name, domain); |
| |
| if (result.symbol != NULL) |
| return result; |
| } |
| |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* Check to see if the symbol is defined in one of the OBJFILE's |
| symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK, |
| depending on whether or not we want to search global symbols or |
| static symbols. */ |
| |
| static struct block_symbol |
| lookup_symbol_in_objfile_symtabs (struct objfile *objfile, int block_index, |
| const char *name, const domain_enum domain) |
| { |
| struct compunit_symtab *cust; |
| |
| gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK); |
| |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)", |
| objfile_debug_name (objfile), |
| block_index == GLOBAL_BLOCK |
| ? "GLOBAL_BLOCK" : "STATIC_BLOCK", |
| name, domain_name (domain)); |
| } |
| |
| ALL_OBJFILE_COMPUNITS (objfile, cust) |
| { |
| const struct blockvector *bv; |
| const struct block *block; |
| struct block_symbol result; |
| |
| bv = COMPUNIT_BLOCKVECTOR (cust); |
| block = BLOCKVECTOR_BLOCK (bv, block_index); |
| result.symbol = block_lookup_symbol_primary (block, name, domain); |
| result.block = block; |
| if (result.symbol != NULL) |
| { |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, " = %s (block %s)\n", |
| host_address_to_string (result.symbol), |
| host_address_to_string (block)); |
| } |
| result.symbol = fixup_symbol_section (result.symbol, objfile); |
| return result; |
| |
| } |
| } |
| |
| if (symbol_lookup_debug > 1) |
| fprintf_unfiltered (gdb_stdlog, " = NULL\n"); |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* Wrapper around lookup_symbol_in_objfile_symtabs for search_symbols. |
| Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE |
| and all associated separate debug objfiles. |
| |
| Normally we only look in OBJFILE, and not any separate debug objfiles |
| because the outer loop will cause them to be searched too. This case is |
| different. Here we're called from search_symbols where it will only |
| call us for the the objfile that contains a matching minsym. */ |
| |
| static struct block_symbol |
| lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile, |
| const char *linkage_name, |
| domain_enum domain) |
| { |
| enum language lang = current_language->la_language; |
| const char *modified_name; |
| struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang, |
| &modified_name); |
| struct objfile *main_objfile, *cur_objfile; |
| |
| if (objfile->separate_debug_objfile_backlink) |
| main_objfile = objfile->separate_debug_objfile_backlink; |
| else |
| main_objfile = objfile; |
| |
| for (cur_objfile = main_objfile; |
| cur_objfile; |
| cur_objfile = objfile_separate_debug_iterate (main_objfile, cur_objfile)) |
| { |
| struct block_symbol result; |
| |
| result = lookup_symbol_in_objfile_symtabs (cur_objfile, GLOBAL_BLOCK, |
| modified_name, domain); |
| if (result.symbol == NULL) |
| result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK, |
| modified_name, domain); |
| if (result.symbol != NULL) |
| { |
| do_cleanups (cleanup); |
| return result; |
| } |
| } |
| |
| do_cleanups (cleanup); |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* A helper function that throws an exception when a symbol was found |
| in a psymtab but not in a symtab. */ |
| |
| static void ATTRIBUTE_NORETURN |
| error_in_psymtab_expansion (int block_index, const char *name, |
| struct compunit_symtab *cust) |
| { |
| error (_("\ |
| Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n\ |
| %s may be an inlined function, or may be a template function\n \ |
| (if a template, try specifying an instantiation: %s<type>)."), |
| block_index == GLOBAL_BLOCK ? "global" : "static", |
| name, |
| symtab_to_filename_for_display (compunit_primary_filetab (cust)), |
| name, name); |
| } |
| |
| /* A helper function for various lookup routines that interfaces with |
| the "quick" symbol table functions. */ |
| |
| static struct block_symbol |
| lookup_symbol_via_quick_fns (struct objfile *objfile, int block_index, |
| const char *name, const domain_enum domain) |
| { |
| struct compunit_symtab *cust; |
| const struct blockvector *bv; |
| const struct block *block; |
| struct block_symbol result; |
| |
| if (!objfile->sf) |
| return (struct block_symbol) {NULL, NULL}; |
| |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n", |
| objfile_debug_name (objfile), |
| block_index == GLOBAL_BLOCK |
| ? "GLOBAL_BLOCK" : "STATIC_BLOCK", |
| name, domain_name (domain)); |
| } |
| |
| cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, domain); |
| if (cust == NULL) |
| { |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_via_quick_fns (...) = NULL\n"); |
| } |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| bv = COMPUNIT_BLOCKVECTOR (cust); |
| block = BLOCKVECTOR_BLOCK (bv, block_index); |
| result.symbol = block_lookup_symbol (block, name, domain); |
| if (result.symbol == NULL) |
| error_in_psymtab_expansion (block_index, name, cust); |
| |
| if (symbol_lookup_debug > 1) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_via_quick_fns (...) = %s (block %s)\n", |
| host_address_to_string (result.symbol), |
| host_address_to_string (block)); |
| } |
| |
| result.symbol = fixup_symbol_section (result.symbol, objfile); |
| result.block = block; |
| return result; |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| basic_lookup_symbol_nonlocal (const struct language_defn *langdef, |
| const char *name, |
| const struct block *block, |
| const domain_enum domain) |
| { |
| struct block_symbol result; |
| |
| /* NOTE: carlton/2003-05-19: The comments below were written when |
| this (or what turned into this) was part of lookup_symbol_aux; |
| I'm much less worried about these questions now, since these |
| decisions have turned out well, but I leave these comments here |
| for posterity. */ |
| |
| /* NOTE: carlton/2002-12-05: There is a question as to whether or |
| not it would be appropriate to search the current global block |
| here as well. (That's what this code used to do before the |
| is_a_field_of_this check was moved up.) On the one hand, it's |
| redundant with the lookup in all objfiles search that happens |
| next. On the other hand, if decode_line_1 is passed an argument |
| like filename:var, then the user presumably wants 'var' to be |
| searched for in filename. On the third hand, there shouldn't be |
| multiple global variables all of which are named 'var', and it's |
| not like decode_line_1 has ever restricted its search to only |
| global variables in a single filename. All in all, only |
| searching the static block here seems best: it's correct and it's |
| cleanest. */ |
| |
| /* NOTE: carlton/2002-12-05: There's also a possible performance |
| issue here: if you usually search for global symbols in the |
| current file, then it would be slightly better to search the |
| current global block before searching all the symtabs. But there |
| are other factors that have a much greater effect on performance |
| than that one, so I don't think we should worry about that for |
| now. */ |
| |
| /* NOTE: dje/2014-10-26: The lookup in all objfiles search could skip |
| the current objfile. Searching the current objfile first is useful |
| for both matching user expectations as well as performance. */ |
| |
| result = lookup_symbol_in_static_block (name, block, domain); |
| if (result.symbol != NULL) |
| return result; |
| |
| /* If we didn't find a definition for a builtin type in the static block, |
| search for it now. This is actually the right thing to do and can be |
| a massive performance win. E.g., when debugging a program with lots of |
| shared libraries we could search all of them only to find out the |
| builtin type isn't defined in any of them. This is common for types |
| like "void". */ |
| if (domain == VAR_DOMAIN) |
| { |
| struct gdbarch *gdbarch; |
| |
| if (block == NULL) |
| gdbarch = target_gdbarch (); |
| else |
| gdbarch = block_gdbarch (block); |
| result.symbol = language_lookup_primitive_type_as_symbol (langdef, |
| gdbarch, name); |
| result.block = NULL; |
| if (result.symbol != NULL) |
| return result; |
| } |
| |
| return lookup_global_symbol (name, block, domain); |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| lookup_symbol_in_static_block (const char *name, |
| const struct block *block, |
| const domain_enum domain) |
| { |
| const struct block *static_block = block_static_block (block); |
| struct symbol *sym; |
| |
| if (static_block == NULL) |
| return (struct block_symbol) {NULL, NULL}; |
| |
| if (symbol_lookup_debug) |
| { |
| struct objfile *objfile = lookup_objfile_from_block (static_block); |
| |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_static_block (%s, %s (objfile %s)," |
| " %s)\n", |
| name, |
| host_address_to_string (block), |
| objfile_debug_name (objfile), |
| domain_name (domain)); |
| } |
| |
| sym = lookup_symbol_in_block (name, static_block, domain); |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_static_block (...) = %s\n", |
| sym != NULL ? host_address_to_string (sym) : "NULL"); |
| } |
| return (struct block_symbol) {sym, static_block}; |
| } |
| |
| /* Perform the standard symbol lookup of NAME in OBJFILE: |
| 1) First search expanded symtabs, and if not found |
| 2) Search the "quick" symtabs (partial or .gdb_index). |
| BLOCK_INDEX is one of GLOBAL_BLOCK or STATIC_BLOCK. */ |
| |
| static struct block_symbol |
| lookup_symbol_in_objfile (struct objfile *objfile, int block_index, |
| const char *name, const domain_enum domain) |
| { |
| struct block_symbol result; |
| |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_objfile (%s, %s, %s, %s)\n", |
| objfile_debug_name (objfile), |
| block_index == GLOBAL_BLOCK |
| ? "GLOBAL_BLOCK" : "STATIC_BLOCK", |
| name, domain_name (domain)); |
| } |
| |
| result = lookup_symbol_in_objfile_symtabs (objfile, block_index, |
| name, domain); |
| if (result.symbol != NULL) |
| { |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_objfile (...) = %s" |
| " (in symtabs)\n", |
| host_address_to_string (result.symbol)); |
| } |
| return result; |
| } |
| |
| result = lookup_symbol_via_quick_fns (objfile, block_index, |
| name, domain); |
| if (symbol_lookup_debug) |
| { |
| fprintf_unfiltered (gdb_stdlog, |
| "lookup_symbol_in_objfile (...) = %s%s\n", |
| result.symbol != NULL |
| ? host_address_to_string (result.symbol) |
| : "NULL", |
| result.symbol != NULL ? " (via quick fns)" : ""); |
| } |
| return result; |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| lookup_static_symbol (const char *name, const domain_enum domain) |
| { |
| struct symbol_cache *cache = get_symbol_cache (current_program_space); |
| struct objfile *objfile; |
| struct block_symbol result; |
| struct block_symbol_cache *bsc; |
| struct symbol_cache_slot *slot; |
| |
| /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass |
| NULL for OBJFILE_CONTEXT. */ |
| result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain, |
| &bsc, &slot); |
| if (result.symbol != NULL) |
| { |
| if (SYMBOL_LOOKUP_FAILED_P (result)) |
| return (struct block_symbol) {NULL, NULL}; |
| return result; |
| } |
| |
| ALL_OBJFILES (objfile) |
| { |
| result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain); |
| if (result.symbol != NULL) |
| { |
| /* Still pass NULL for OBJFILE_CONTEXT here. */ |
| symbol_cache_mark_found (bsc, slot, NULL, result.symbol, |
| result.block); |
| return result; |
| } |
| } |
| |
| /* Still pass NULL for OBJFILE_CONTEXT here. */ |
| symbol_cache_mark_not_found (bsc, slot, NULL, name, domain); |
| return (struct block_symbol) {NULL, NULL}; |
| } |
| |
| /* Private data to be used with lookup_symbol_global_iterator_cb. */ |
| |
| struct global_sym_lookup_data |
| { |
| /* The name of the symbol we are searching for. */ |
| const char *name; |
| |
| /* The domain to use for our search. */ |
| domain_enum domain; |
| |
| /* The field where the callback should store the symbol if found. |
| It should be initialized to {NULL, NULL} before the search is started. */ |
| struct block_symbol result; |
| }; |
| |
| /* A callback function for gdbarch_iterate_over_objfiles_in_search_order. |
| It searches by name for a symbol in the GLOBAL_BLOCK of the given |
| OBJFILE. The arguments for the search are passed via CB_DATA, |
| which in reality is a pointer to struct global_sym_lookup_data. */ |
| |
| static int |
| lookup_symbol_global_iterator_cb (struct objfile *objfile, |
| void *cb_data) |
| { |
| struct global_sym_lookup_data *data = |
| (struct global_sym_lookup_data *) cb_data; |
| |
| gdb_assert (data->result.symbol == NULL |
| && data->result.block == NULL); |
| |
| data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, |
| data->name, data->domain); |
| |
| /* If we found a match, tell the iterator to stop. Otherwise, |
| keep going. */ |
| return (data->result.symbol != NULL); |
| } |
| |
| /* See symtab.h. */ |
| |
| struct block_symbol |
| lookup_global_symbol (const char *name, |
| const struct block *block, |
| const domain_enum domain) |
| { |
| struct symbol_cache *cache = get_symbol_cache (current_program_space); |
| struct block_symbol result; |
| struct objfile *objfile; |
| struct global_sym_lookup_data lookup_data; |
| struct block_symbol_cache *bsc; |
| struct symbol_cache_slot *slot; |
| |
| objfile = lookup_objfile_from_block (block); |
| |
| /* First see if we can find the symbol in the cache. |
| This works because we use the current objfile to qualify the lookup. */ |
| result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain, |
| &bsc, &slot); |
| if (result.symbol != NULL) |
| { |
| if (SYMBOL_LOOKUP_FAILED_P (result)) |
| return (struct block_symbol) {NULL, NULL}; |
| return result; |
| } |
| |
| /* Call library-specific lookup procedure. */ |
| if (objfile != NULL) |
| result = solib_global_lookup (objfile, name, domain); |
| |
| /* If that didn't work go a global search (of global blocks, heh). */ |
| if (result.symbol == NULL) |
| { |
| memset (&lookup_data, 0, sizeof (lookup_data)); |
| lookup_data.name = name; |
| lookup_data.domain = domain; |
| gdbarch_iterate_over_objfiles_in_search_order |
| (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (), |
| lookup_symbol_global_iterator_cb, &lookup_data, objfile); |
| result = lookup_data.result; |
| } |
| |
| if (result.symbol != NULL) |
| symbol_cache_mark_found (bsc, slot, objfile, result.symbol, result.block); |
| else |
| symbol_cache_mark_not_found (bsc, slot, objfile, name, domain); |
| |
| return result; |
| } |
| |
| int |
| symbol_matches_domain (enum language symbol_language, |
| domain_enum symbol_domain, |
| domain_enum domain) |
| { |
| /* For C++ "struct foo { ... }" also defines a typedef for "foo". |
| A Java class declaration also defines a typedef for the class. |
| Similarly, any Ada type declaration implicitly defines a typedef. */ |
| if (symbol_language == language_cplus |
| || symbol_language == language_d |
| || symbol_language == language_java |
| || symbol_language == language_ada) |
| { |
| if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN) |
| && symbol_domain == STRUCT_DOMAIN) |
| return 1; |
| } |
| /* For all other languages, strict match is required. */ |
| return (symbol_domain == domain); |
| } |
| |
| /* See symtab.h. */ |
| |
| struct type * |
| lookup_transparent_type (const char *name) |
| { |
| return current_language->la_lookup_transparent_type (name); |
| } |
| |
| /* A helper for basic_lookup_transparent_type that interfaces with the |
| "quick" symbol table functions. */ |
| |
| static struct type * |
| basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index, |
| const char *name) |
| { |
| struct compunit_symtab *cust; |
| const struct blockvector *bv; |
| struct block *block; |
| struct symbol *sym; |
| |
| if (!objfile->sf) |
| return NULL; |
| cust = objfile->sf->qf->lookup_symbol (objfile, block_index, name, |
| STRUCT_DOMAIN); |
| if (cust == NULL) |
| return NULL; |
| |
| bv = COMPUNIT_BLOCKVECTOR (cust); |
| block = BLOCKVECTOR_BLOCK (bv, block_index); |
| sym = block_find_symbol (block, name, STRUCT_DOMAIN, |
| block_find_non_opaque_type, NULL); |
| if (sym == NULL) |
| error_in_psymtab_expansion (block_index, name, cust); |
| gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))); |
| return SYMBOL_TYPE (sym); |
| } |
| |
| /* Subroutine of basic_lookup_transparent_type to simplify it. |
| Look up the non-opaque definition of NAME in BLOCK_INDEX of OBJFILE. |
| BLOCK_INDEX is either GLOBAL_BLOCK or STATIC_BLOCK. */ |
| |
| static struct type * |
| basic_lookup_transparent_type_1 (struct objfile *objfile, int block_index, |
| const char *name) |
| { |
| const struct compunit_symtab *cust; |
| const struct blockvector *bv; |
| const struct block *block; |
| const struct symbol *sym; |
| |
| ALL_OBJFILE_COMPUNITS (objfile, cust) |
| { |
| bv = COMPUNIT_BLOCKVECTOR (cust); |
| block = BLOCKVECTOR_BLOCK (bv, block_index); |
| sym = block_find_symbol (block, name, STRUCT_DOMAIN, |
| block_find_non_opaque_type, NULL); |
| if (sym != NULL) |
| { |
| gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))); |
| return SYMBOL_TYPE (sym); |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /* The standard implementation of lookup_transparent_type. This code |
| was modeled on lookup_symbol -- the parts not relevant to looking |
| up types were just left out. In particular it's assumed here that |
| types are available in STRUCT_DOMAIN and only in file-static or |
| global blocks. */ |
| |
| struct type * |
| basic_lookup_transparent_type (const char *name) |
| { |
| struct objfile *objfile; |
| struct type *t; |
| |
| /* Now search all the global symbols. Do the symtab's first, then |
| check the psymtab's. If a psymtab indicates the existence |
| of the desired name as a global, then do psymtab-to-symtab |
| conversion on the fly and return the found symbol. */ |
| |
| ALL_OBJFILES (objfile) |
| { |
| t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name); |
| if (t) |
| return t; |
| } |
| |
| ALL_OBJFILES (objfile) |
| { |
| t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name); |
| if (t) |
| return t; |
| } |
| |
| /* Now search the static file-level symbols. |
| Not strictly correct, but more useful than an error. |
| Do the symtab's first, then |
| check the psymtab's. If a psymtab indicates the existence |
| of the desired name as a file-level static, then do psymtab-to-symtab |
| conversion on the fly and return the found symbol. */ |
| |
| ALL_OBJFILES (objfile) |
| { |
| t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name); |
| if (t) |
| return t; |
| } |
| |
| ALL_OBJFILES (objfile) |
| { |
| t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name); |
| if (t) |
| return t; |
| } |
| |
| return (struct type *) 0; |
| } |
| |
| /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK. |
| |
| For each symbol that matches, CALLBACK is called. The symbol and |
| DATA are passed to the callback. |
| |
| If CALLBACK returns zero, the iteration ends. Otherwise, the |
| search continues. */ |
| |
| void |
| iterate_over_symbols (const struct block *block, const char *name, |
| const domain_enum domain, |
| symbol_found_callback_ftype *callback, |
| void *data) |
| { |
| struct block_iterator iter; |
| struct symbol *sym; |
| |
| ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym) |
| { |
| if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), |
| SYMBOL_DOMAIN (sym), domain)) |
| { |
| if (!callback (sym, data)) |
| return; |
| } |
| } |
| } |
| |
| /* Find the compunit symtab associated with PC and SECTION. |
| This will read in debug info as necessary. */ |
| |
| struct compunit_symtab * |
| find_pc_sect_compunit_symtab (CORE_ADDR pc, struct obj_section *section) |
| { |
| struct compunit_symtab *cust; |
| struct compunit_symtab *best_cust = NULL; |
| struct objfile *objfile; |
| CORE_ADDR distance = 0; |
| struct bound_minimal_symbol msymbol; |
| |
| /* If we know that this is not a text address, return failure. This is |
| necessary because we loop based on the block's high and low code |
| addresses, which do not include the data ranges, and because |
| we call find_pc_sect_psymtab which has a similar restriction based |
| on the partial_symtab's texthigh and textlow. */ |
| msymbol = lookup_minimal_symbol_by_pc_section (pc, section); |
| if (msymbol.minsym |
| && (MSYMBOL_TYPE (msymbol.minsym) == mst_data |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_bss |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_abs |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_file_data |
| || MSYMBOL_TYPE (msymbol.minsym) == mst_file_bss)) |
| return NULL; |
| |
| /* Search all symtabs for the one whose file contains our address, and which |
| is the smallest of all the ones containing the address. This is designed |
| to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000 |
| and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from |
| 0x1000-0x4000, but for address 0x2345 we want to return symtab b. |
| |
| This happens for native ecoff format, where code from included files |