X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fpsymtab.c;h=5960c593fcfc24d4c3b904ecec269c62630dcf99;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=8283545f9ea09850926fd81dee26df2f5bfdc157;hpb=ee0c32930c355b73172b2bef987e2a48ea909b12;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/psymtab.c b/gdb/psymtab.c index 8283545f9e..5960c593fc 100644 --- a/gdb/psymtab.c +++ b/gdb/psymtab.c @@ -1,6 +1,6 @@ /* Partial symbol tables. - Copyright (C) 2009-2017 Free Software Foundation, Inc. + Copyright (C) 2009-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -19,38 +19,28 @@ #include "defs.h" #include "symtab.h" -#include "psympriv.h" #include "objfiles.h" +#include "psympriv.h" #include "block.h" #include "filenames.h" #include "source.h" #include "addrmap.h" #include "gdbtypes.h" -#include "bcache.h" #include "ui-out.h" #include "command.h" -#include "readline/readline.h" +#include "readline/tilde.h" #include "gdb_regex.h" #include "dictionary.h" #include "language.h" #include "cp-support.h" #include "gdbcmd.h" - -struct psymbol_bcache -{ - struct bcache *bcache; -}; - -static struct partial_symbol *match_partial_symbol (struct objfile *, - struct partial_symtab *, - int, - const char *, domain_enum, - symbol_compare_ftype *, - symbol_compare_ftype *); +#include +#include static struct partial_symbol *lookup_partial_symbol (struct objfile *, struct partial_symtab *, - const char *, int, + const lookup_name_info &, + int, domain_enum); static const char *psymtab_to_fullname (struct partial_symtab *ps); @@ -60,17 +50,45 @@ static struct partial_symbol *find_pc_sect_psymbol (struct objfile *, CORE_ADDR, struct obj_section *); -static void fixup_psymbol_section (struct partial_symbol *psym, - struct objfile *objfile); - static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst); -/* Ensure that the partial symbols for OBJFILE have been loaded. This - function always returns its argument, as a convenience. */ + + +static unsigned long psymbol_hash (const void *addr, int length); +static int psymbol_compare (const void *addr1, const void *addr2, int length); + +psymtab_storage::psymtab_storage () + : psymbol_cache (psymbol_hash, psymbol_compare) +{ +} + +psymtab_storage::~psymtab_storage () +{ + partial_symtab *iter = psymtabs; + while (iter != nullptr) + { + partial_symtab *next = iter->next; + delete iter; + iter = next; + } +} + +/* See psymtab.h. */ + +void +psymtab_storage::install_psymtab (partial_symtab *pst) +{ + pst->next = psymtabs; + psymtabs = pst; +} + + + +/* See psymtab.h. */ -struct objfile * -require_partial_symbols (struct objfile *objfile, int verbose) +psymtab_storage::partial_symtab_range +require_partial_symbols (struct objfile *objfile, bool verbose) { if ((objfile->flags & OBJF_PSYMTABS_READ) == 0) { @@ -79,47 +97,24 @@ require_partial_symbols (struct objfile *objfile, int verbose) if (objfile->sf->sym_read_psymbols) { if (verbose) - { - printf_unfiltered (_("Reading symbols from %s..."), - objfile_name (objfile)); - gdb_flush (gdb_stdout); - } + printf_filtered (_("Reading symbols from %s...\n"), + objfile_name (objfile)); (*objfile->sf->sym_read_psymbols) (objfile); - if (verbose) - { - if (!objfile_has_symbols (objfile)) - { - wrap_here (""); - printf_unfiltered (_("(no debugging symbols found)...")); - wrap_here (""); - } - printf_unfiltered (_("done.\n")); - } + /* Partial symbols list are not expected to changed after this + point. */ + objfile->partial_symtabs->global_psymbols.shrink_to_fit (); + objfile->partial_symtabs->static_psymbols.shrink_to_fit (); + + if (verbose && !objfile_has_symbols (objfile)) + printf_filtered (_("(No debugging symbols found in %s)\n"), + objfile_name (objfile)); } } - return objfile; + return objfile->psymtabs (); } -/* Traverse all psymtabs in one objfile, requiring that the psymtabs - be read in. */ - -#define ALL_OBJFILE_PSYMTABS_REQUIRED(objfile, p) \ - for ((p) = require_partial_symbols (objfile, 1)->psymtabs; \ - (p) != NULL; \ - (p) = (p)->next) - -/* We want to make sure this file always requires psymtabs. */ - -#undef ALL_OBJFILE_PSYMTABS - -/* Traverse all psymtabs in all objfiles. */ - -#define ALL_PSYMTABS(objfile, p) \ - ALL_OBJFILES (objfile) \ - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p) - /* Helper function for psym_map_symtabs_matching_filename that expands the symtabs and calls the iterator. */ @@ -137,7 +132,7 @@ partial_map_expand_apply (struct objfile *objfile, gdb_assert (pst->user == NULL); /* Don't visit already-expanded psymtabs. */ - if (pst->readin) + if (pst->readin_p (objfile)) return 0; /* This may expand more than one symtab, and we want to iterate over @@ -158,57 +153,54 @@ psym_map_symtabs_matching_filename const char *real_path, gdb::function_view callback) { - struct partial_symtab *pst; const char *name_basename = lbasename (name); - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) - { - /* We can skip shared psymtabs here, because any file name will be - attached to the unshared psymtab. */ - if (pst->user != NULL) - continue; - - /* Anonymous psymtabs don't have a file name. */ - if (pst->anonymous) - continue; - - if (compare_filenames_for_search (pst->filename, name)) - { - if (partial_map_expand_apply (objfile, name, real_path, - pst, callback)) - return true; + for (partial_symtab *pst : require_partial_symbols (objfile, true)) + { + /* Anonymous psymtabs don't have a file name. */ + if (pst->anonymous) 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 (name_basename, lbasename (pst->filename)) != 0) - continue; + if (compare_filenames_for_search (pst->filename, name)) + { + while (pst->user) + pst = pst->user; - if (compare_filenames_for_search (psymtab_to_fullname (pst), name)) - { - if (partial_map_expand_apply (objfile, name, real_path, - pst, callback)) - return true; + if (partial_map_expand_apply (objfile, name, real_path, + pst, callback)) + return true; + 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 (name_basename, lbasename (pst->filename)) != 0) 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) - { - gdb_assert (IS_ABSOLUTE_PATH (real_path)); - gdb_assert (IS_ABSOLUTE_PATH (name)); - if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0) - { - if (partial_map_expand_apply (objfile, name, real_path, - pst, callback)) - return true; - continue; - } - } - } + if (compare_filenames_for_search (psymtab_to_fullname (pst), name)) + { + if (partial_map_expand_apply (objfile, name, real_path, + pst, callback)) + return true; + 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) + { + gdb_assert (IS_ABSOLUTE_PATH (real_path)); + gdb_assert (IS_ABSOLUTE_PATH (name)); + if (filename_cmp (psymtab_to_fullname (pst), real_path) == 0) + { + if (partial_map_expand_apply (objfile, name, real_path, + pst, callback)) + return true; + continue; + } + } + } return false; } @@ -224,7 +216,7 @@ find_pc_sect_psymtab_closer (struct objfile *objfile, { struct partial_symtab *tpst; struct partial_symtab *best_pst = pst; - CORE_ADDR best_addr = pst->textlow; + CORE_ADDR best_addr = pst->text_low (objfile); gdb_assert (!pst->psymtabs_addrmap_supported); @@ -248,7 +240,7 @@ find_pc_sect_psymtab_closer (struct objfile *objfile, that is closest and still less than the given PC. */ for (tpst = pst; tpst != NULL; tpst = tpst->next) { - if (pc >= tpst->textlow && pc < tpst->texthigh) + if (pc >= tpst->text_low (objfile) && pc < tpst->text_high (objfile)) { struct partial_symbol *p; CORE_ADDR this_addr; @@ -259,8 +251,7 @@ find_pc_sect_psymtab_closer (struct objfile *objfile, object's symbol table. */ p = find_pc_sect_psymbol (objfile, tpst, pc, section); if (p != NULL - && (SYMBOL_VALUE_ADDRESS (p) - == BMSYMBOL_VALUE_ADDRESS (msymbol))) + && (p->address (objfile) == BMSYMBOL_VALUE_ADDRESS (msymbol))) return tpst; /* Also accept the textlow value of a psymtab as a @@ -268,9 +259,9 @@ find_pc_sect_psymtab_closer (struct objfile *objfile, symbol tables with line information but no debug symbols (e.g. those produced by an assembler). */ if (p != NULL) - this_addr = SYMBOL_VALUE_ADDRESS (p); + this_addr = p->address (objfile); else - this_addr = tpst->textlow; + this_addr = tpst->text_low (objfile); /* Check whether it is closer than our current BEST_ADDR. Since this symbol address is @@ -302,15 +293,27 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc, struct obj_section *section, struct bound_minimal_symbol msymbol) { - struct partial_symtab *pst; - - /* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity - than the later used TEXTLOW/TEXTHIGH one. */ - - if (objfile->psymtabs_addrmap != NULL) + /* Try just the PSYMTABS_ADDRMAP mapping first as it has better + granularity than the later used TEXTLOW/TEXTHIGH one. However, we need + to take care as the PSYMTABS_ADDRMAP can hold things other than partial + symtabs in some cases. + + This function should only be called for objfiles that are using partial + symtabs, not for objfiles that are using indexes (.gdb_index or + .debug_names), however 'maintenance print psymbols' calls this function + directly for all objfiles. If we assume that PSYMTABS_ADDRMAP contains + partial symtabs then we will end up returning a pointer to an object + that is not a partial_symtab, which doesn't end well. */ + + if (objfile->partial_symtabs->psymtabs != NULL + && objfile->partial_symtabs->psymtabs_addrmap != NULL) { - pst = ((struct partial_symtab *) - addrmap_find (objfile->psymtabs_addrmap, pc)); + CORE_ADDR baseaddr = objfile->text_section_offset (); + + struct partial_symtab *pst + = ((struct partial_symtab *) + addrmap_find (objfile->partial_symtabs->psymtabs_addrmap, + pc - baseaddr)); if (pst != NULL) { /* FIXME: addrmaps currently do not handle overlayed sections, @@ -326,7 +329,7 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc, object's symbol table. */ p = find_pc_sect_psymbol (objfile, pst, pc, section); if (p == NULL - || (SYMBOL_VALUE_ADDRESS (p) + || (p->address (objfile) != BMSYMBOL_VALUE_ADDRESS (msymbol))) goto next; } @@ -352,9 +355,9 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc, its CUs may be missing in PSYMTABS_ADDRMAP as they may be varying debug info type in single OBJFILE. */ - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) + for (partial_symtab *pst : require_partial_symbols (objfile, true)) if (!pst->psymtabs_addrmap_supported - && pc >= pst->textlow && pc < pst->texthigh) + && pc >= pst->text_low (objfile) && pc < pst->text_high (objfile)) { struct partial_symtab *best_pst; @@ -381,15 +384,15 @@ psym_find_pc_sect_compunit_symtab (struct objfile *objfile, msymbol); if (ps != NULL) { - if (warn_if_readin && ps->readin) + if (warn_if_readin && ps->readin_p (objfile)) /* Might want to error() here (in case symtab is corrupt and will cause a core dump), but maybe we can successfully continue, so let's not. */ warning (_("\ (Internal error: pc %s in read in psymtab, but not in symtab.)\n"), - paddress (get_objfile_arch (objfile), pc)); + paddress (objfile->arch (), pc)); psymtab_to_symtab (objfile, ps); - return ps->compunit_symtab; + return ps->get_compunit_symtab (objfile); } return NULL; } @@ -402,63 +405,62 @@ find_pc_sect_psymbol (struct objfile *objfile, struct partial_symtab *psymtab, CORE_ADDR pc, struct obj_section *section) { - struct partial_symbol *best = NULL, *p, **pp; + struct partial_symbol *best = NULL; CORE_ADDR best_pc; + const CORE_ADDR textlow = psymtab->text_low (objfile); gdb_assert (psymtab != NULL); /* Cope with programs that start at address 0. */ - best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0; + best_pc = (textlow != 0) ? textlow - 1 : 0; /* Search the global symbols as well as the static symbols, so that find_pc_partial_function doesn't use a minimal symbol and thus cache a bad endaddr. */ - for (pp = objfile->global_psymbols.list + psymtab->globals_offset; - (pp - (objfile->global_psymbols.list + psymtab->globals_offset) - < psymtab->n_global_syms); - pp++) + for (int i = 0; i < psymtab->n_global_syms; i++) { - p = *pp; - if (SYMBOL_DOMAIN (p) == VAR_DOMAIN - && PSYMBOL_CLASS (p) == LOC_BLOCK - && pc >= SYMBOL_VALUE_ADDRESS (p) - && (SYMBOL_VALUE_ADDRESS (p) > best_pc - || (psymtab->textlow == 0 - && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0))) + partial_symbol *p + = objfile->partial_symtabs->global_psymbols[psymtab->globals_offset + + i]; + + if (p->domain == VAR_DOMAIN + && p->aclass == LOC_BLOCK + && pc >= p->address (objfile) + && (p->address (objfile) > best_pc + || (psymtab->text_low (objfile) == 0 + && best_pc == 0 && p->address (objfile) == 0))) { if (section != NULL) /* Match on a specific section. */ { - fixup_psymbol_section (p, objfile); - if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p), + if (!matching_obj_sections (p->obj_section (objfile), section)) continue; } - best_pc = SYMBOL_VALUE_ADDRESS (p); + best_pc = p->address (objfile); best = p; } } - for (pp = objfile->static_psymbols.list + psymtab->statics_offset; - (pp - (objfile->static_psymbols.list + psymtab->statics_offset) - < psymtab->n_static_syms); - pp++) + for (int i = 0; i < psymtab->n_static_syms; i++) { - p = *pp; - if (SYMBOL_DOMAIN (p) == VAR_DOMAIN - && PSYMBOL_CLASS (p) == LOC_BLOCK - && pc >= SYMBOL_VALUE_ADDRESS (p) - && (SYMBOL_VALUE_ADDRESS (p) > best_pc - || (psymtab->textlow == 0 - && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0))) + partial_symbol *p + = objfile->partial_symtabs->static_psymbols[psymtab->statics_offset + + i]; + + if (p->domain == VAR_DOMAIN + && p->aclass == LOC_BLOCK + && pc >= p->address (objfile) + && (p->address (objfile) > best_pc + || (psymtab->text_low (objfile) == 0 + && best_pc == 0 && p->address (objfile) == 0))) { if (section != NULL) /* Match on a specific section. */ { - fixup_psymbol_section (p, objfile); - if (!matching_obj_sections (SYMBOL_OBJ_SECTION (objfile, p), + if (!matching_obj_sections (p->obj_section (objfile), section)) continue; } - best_pc = SYMBOL_VALUE_ADDRESS (p); + best_pc = p->address (objfile); best = p; } } @@ -466,80 +468,97 @@ find_pc_sect_psymbol (struct objfile *objfile, return best; } -static void -fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile) -{ - CORE_ADDR addr; +/* Psymtab version of lookup_symbol. See its definition in + the definition of quick_symbol_functions in symfile.h. */ - if (psym == NULL) - return; +static struct compunit_symtab * +psym_lookup_symbol (struct objfile *objfile, + block_enum block_index, const char *name, + const domain_enum domain) +{ + const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0); + struct compunit_symtab *stab_best = NULL; - if (SYMBOL_SECTION (psym) >= 0) - return; + lookup_name_info lookup_name (name, symbol_name_match_type::FULL); - gdb_assert (objfile); + lookup_name_info psym_lookup_name = lookup_name.make_ignore_params (); - switch (PSYMBOL_CLASS (psym)) + for (partial_symtab *ps : require_partial_symbols (objfile, true)) { - case LOC_STATIC: - case LOC_LABEL: - case LOC_BLOCK: - addr = SYMBOL_VALUE_ADDRESS (psym); - break; - default: - /* Nothing else will be listed in the minsyms -- no use looking - it up. */ - return; + if (!ps->readin_p (objfile) + && lookup_partial_symbol (objfile, ps, psym_lookup_name, + psymtab_index, domain)) + { + struct symbol *sym, *with_opaque = NULL; + struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps); + /* Note: While psymtab_to_symtab can return NULL if the + partial symtab is empty, we can assume it won't here + because lookup_partial_symbol succeeded. */ + const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab); + const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index); + + sym = block_find_symbol (block, name, domain, + block_find_non_opaque_type_preferred, + &with_opaque); + + /* Some caution must be observed with overloaded functions + and methods, since the index will not contain any overload + information (but NAME might contain it). */ + + if (sym != NULL + && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name)) + return stab; + if (with_opaque != NULL + && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name)) + stab_best = stab; + + /* Keep looking through other psymtabs. */ + } } - fixup_section (&psym->ginfo, addr, objfile); + return stab_best; } -/* Psymtab version of lookup_symbol. See its definition in +/* Psymtab version of lookup_global_symbol_language. See its definition in the definition of quick_symbol_functions in symfile.h. */ -static struct compunit_symtab * -psym_lookup_symbol (struct objfile *objfile, - int block_index, const char *name, - const domain_enum domain) +static enum language +psym_lookup_global_symbol_language (struct objfile *objfile, const char *name, + domain_enum domain, bool *symbol_found_p) { - struct partial_symtab *ps; - const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0); - struct compunit_symtab *stab_best = NULL; + *symbol_found_p = false; + if (objfile->sf == NULL) + return language_unknown; - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) - { - if (!ps->readin && lookup_partial_symbol (objfile, ps, name, - psymtab_index, domain)) - { - struct symbol *sym, *with_opaque = NULL; - struct compunit_symtab *stab = psymtab_to_symtab (objfile, ps); - /* Note: While psymtab_to_symtab can return NULL if the partial symtab - is empty, we can assume it won't here because lookup_partial_symbol - succeeded. */ - const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab); - struct block *block = BLOCKVECTOR_BLOCK (bv, block_index); - - sym = block_find_symbol (block, name, domain, - block_find_non_opaque_type_preferred, - &with_opaque); - - /* Some caution must be observed with overloaded functions - and methods, since the index will not contain any overload - information (but NAME might contain it). */ - - if (sym != NULL - && SYMBOL_MATCHES_SEARCH_NAME (sym, name)) - return stab; - if (with_opaque != NULL - && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, name)) - stab_best = stab; - - /* Keep looking through other psymtabs. */ - } - } + lookup_name_info lookup_name (name, symbol_name_match_type::FULL); - return stab_best; + for (partial_symtab *ps : require_partial_symbols (objfile, true)) + { + struct partial_symbol *psym; + if (ps->readin_p (objfile)) + continue; + + psym = lookup_partial_symbol (objfile, ps, lookup_name, 1, domain); + if (psym) + { + *symbol_found_p = true; + return psym->ginfo.language (); + } + } + + return language_unknown; +} + +/* Returns true if PSYM matches LOOKUP_NAME. */ + +static bool +psymbol_name_matches (partial_symbol *psym, + const lookup_name_info &lookup_name) +{ + const language_defn *lang = language_def (psym->ginfo.language ()); + symbol_name_matcher_ftype *name_match + = get_symbol_name_matcher (lang, lookup_name); + return name_match (psym->ginfo.search_name (), lookup_name, NULL); } /* Look in PST for a symbol in DOMAIN whose name matches NAME. Search @@ -553,8 +572,7 @@ psym_lookup_symbol (struct objfile *objfile, static struct partial_symbol * match_partial_symbol (struct objfile *objfile, struct partial_symtab *pst, int global, - const char *name, domain_enum domain, - symbol_compare_ftype *match, + const lookup_name_info &name, domain_enum domain, symbol_compare_ftype *ordered_compare) { struct partial_symbol **start, **psym; @@ -563,10 +581,11 @@ match_partial_symbol (struct objfile *objfile, int do_linear_search = 1; if (length == 0) - return NULL; + return NULL; + start = (global ? - objfile->global_psymbols.list + pst->globals_offset : - objfile->static_psymbols.list + pst->statics_offset); + &objfile->partial_symtabs->global_psymbols[pst->globals_offset] : + &objfile->partial_symtabs->static_psymbols[pst->statics_offset]); if (global && ordered_compare) /* Can use a binary search. */ { @@ -585,7 +604,12 @@ match_partial_symbol (struct objfile *objfile, { center = bottom + (top - bottom) / 2; gdb_assert (center < top); - if (ordered_compare (SYMBOL_SEARCH_NAME (*center), name) >= 0) + + enum language lang = (*center)->ginfo.language (); + const char *lang_ln = name.language_lookup_name (lang); + + if (ordered_compare ((*center)->ginfo.search_name (), + lang_ln) >= 0) top = center; else bottom = center + 1; @@ -593,10 +617,10 @@ match_partial_symbol (struct objfile *objfile, gdb_assert (top == bottom); while (top <= real_top - && match (SYMBOL_SEARCH_NAME (*top), name) == 0) + && psymbol_name_matches (*top, name)) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (*top), - SYMBOL_DOMAIN (*top), domain)) + if (symbol_matches_domain ((*top)->ginfo.language (), + (*top)->domain, domain)) return *top; top++; } @@ -609,9 +633,9 @@ match_partial_symbol (struct objfile *objfile, { for (psym = start; psym < start + length; psym++) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym), - SYMBOL_DOMAIN (*psym), domain) - && match (SYMBOL_SEARCH_NAME (*psym), name) == 0) + if (symbol_matches_domain ((*psym)->ginfo.language (), + (*psym)->domain, domain) + && psymbol_name_matches (*psym, name)) return *psym; } } @@ -619,61 +643,27 @@ match_partial_symbol (struct objfile *objfile, return NULL; } -/* Returns the name used to search psymtabs. Unlike symtabs, psymtabs do - not contain any method/function instance information (since this would - force reading type information while reading psymtabs). Therefore, - if NAME contains overload information, it must be stripped before searching - psymtabs. - - The caller is responsible for freeing the return result. */ - -static char * -psymtab_search_name (const char *name) -{ - switch (current_language->la_language) - { - case language_cplus: - { - if (strchr (name, '(')) - { - char *ret = cp_remove_params (name); - - if (ret) - return ret; - } - } - break; - - default: - break; - } - - return xstrdup (name); -} - -/* Look, in partial_symtab PST, for symbol whose natural name is NAME. - Check the global symbols if GLOBAL, the static symbols if not. */ +/* Look, in partial_symtab PST, for symbol whose natural name is + LOOKUP_NAME. Check the global symbols if GLOBAL, the static + symbols if not. */ static struct partial_symbol * lookup_partial_symbol (struct objfile *objfile, - struct partial_symtab *pst, const char *name, + struct partial_symtab *pst, + const lookup_name_info &lookup_name, int global, domain_enum domain) { struct partial_symbol **start, **psym; struct partial_symbol **top, **real_top, **bottom, **center; int length = (global ? pst->n_global_syms : pst->n_static_syms); int do_linear_search = 1; - char *search_name; - struct cleanup *cleanup; if (length == 0) return NULL; - search_name = psymtab_search_name (name); - cleanup = make_cleanup (xfree, search_name); start = (global ? - objfile->global_psymbols.list + pst->globals_offset : - objfile->static_psymbols.list + pst->statics_offset); + &objfile->partial_symtabs->global_psymbols[pst->globals_offset] : + &objfile->partial_symtabs->static_psymbols[pst->statics_offset]); if (global) /* This means we can use a binary search. */ { @@ -691,11 +681,11 @@ lookup_partial_symbol (struct objfile *objfile, while (top > bottom) { center = bottom + (top - bottom) / 2; - if (!(center < top)) - internal_error (__FILE__, __LINE__, - _("failed internal consistency check")); - if (strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*center), - search_name) >= 0) + + gdb_assert (center < top); + + if (strcmp_iw_ordered ((*center)->ginfo.search_name (), + lookup_name.c_str ()) >= 0) { top = center; } @@ -704,26 +694,24 @@ lookup_partial_symbol (struct objfile *objfile, bottom = center + 1; } } - if (!(top == bottom)) - internal_error (__FILE__, __LINE__, - _("failed internal consistency check")); + + gdb_assert (top == bottom); /* For `case_sensitivity == case_sensitive_off' strcmp_iw_ordered will search more exactly than what matches SYMBOL_MATCHES_SEARCH_NAME. */ - while (top >= start && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name)) + while (top >= start && symbol_matches_search_name (&(*top)->ginfo, + lookup_name)) top--; /* Fixup to have a symbol which matches SYMBOL_MATCHES_SEARCH_NAME. */ top++; - while (top <= real_top && SYMBOL_MATCHES_SEARCH_NAME (*top, search_name)) + while (top <= real_top && symbol_matches_search_name (&(*top)->ginfo, + lookup_name)) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (*top), - SYMBOL_DOMAIN (*top), domain)) - { - do_cleanups (cleanup); - return *top; - } + if (symbol_matches_domain ((*top)->ginfo.language (), + (*top)->domain, domain)) + return *top; top++; } } @@ -735,17 +723,13 @@ lookup_partial_symbol (struct objfile *objfile, { for (psym = start; psym < start + length; psym++) { - if (symbol_matches_domain (SYMBOL_LANGUAGE (*psym), - SYMBOL_DOMAIN (*psym), domain) - && SYMBOL_MATCHES_SEARCH_NAME (*psym, search_name)) - { - do_cleanups (cleanup); - return *psym; - } + if (symbol_matches_domain ((*psym)->ginfo.language (), + (*psym)->domain, domain) + && symbol_matches_search_name (&(*psym)->ginfo, lookup_name)) + return *psym; } } - do_cleanups (cleanup); return NULL; } @@ -764,55 +748,25 @@ psymtab_to_symtab (struct objfile *objfile, struct partial_symtab *pst) pst = pst->user; /* If it's been looked up before, return it. */ - if (pst->compunit_symtab) - return pst->compunit_symtab; + if (pst->get_compunit_symtab (objfile)) + return pst->get_compunit_symtab (objfile); /* If it has not yet been read in, read it. */ - if (!pst->readin) + if (!pst->readin_p (objfile)) { scoped_restore decrementer = increment_reading_symtab (); - (*pst->read_symtab) (pst, objfile); - } - - return pst->compunit_symtab; -} - -/* Psymtab version of relocate. See its definition in - the definition of quick_symbol_functions in symfile.h. */ - -static void -psym_relocate (struct objfile *objfile, - const struct section_offsets *new_offsets, - const struct section_offsets *delta) -{ - struct partial_symbol **psym; - struct partial_symtab *p; + if (info_verbose) + { + printf_filtered (_("Reading in symbols for %s...\n"), + pst->filename); + gdb_flush (gdb_stdout); + } - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p) - { - p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); - p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); + pst->read_symtab (objfile); } - for (psym = objfile->global_psymbols.list; - psym < objfile->global_psymbols.next; - psym++) - { - fixup_psymbol_section (*psym, objfile); - if (SYMBOL_SECTION (*psym) >= 0) - SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, - SYMBOL_SECTION (*psym)); - } - for (psym = objfile->static_psymbols.list; - psym < objfile->static_psymbols.next; - psym++) - { - fixup_psymbol_section (*psym, objfile); - if (SYMBOL_SECTION (*psym) >= 0) - SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta, - SYMBOL_SECTION (*psym)); - } + return pst->get_compunit_symtab (objfile); } /* Psymtab version of find_last_source_symtab. See its definition in @@ -821,10 +775,9 @@ psym_relocate (struct objfile *objfile, static struct symtab * psym_find_last_source_symtab (struct objfile *ofp) { - struct partial_symtab *ps; struct partial_symtab *cs_pst = NULL; - ALL_OBJFILE_PSYMTABS_REQUIRED (ofp, ps) + for (partial_symtab *ps : require_partial_symbols (ofp, true)) { const char *name = ps->filename; int len = strlen (name); @@ -836,7 +789,7 @@ psym_find_last_source_symtab (struct objfile *ofp) if (cs_pst) { - if (cs_pst->readin) + if (cs_pst->readin_p (ofp)) { internal_error (__FILE__, __LINE__, _("select_source_symtab: " @@ -860,9 +813,7 @@ psym_find_last_source_symtab (struct objfile *ofp) static void psym_forget_cached_source_info (struct objfile *objfile) { - struct partial_symtab *pst; - - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, pst) + for (partial_symtab *pst : require_partial_symbols (objfile, true)) { if (pst->fullname != NULL) { @@ -873,7 +824,7 @@ psym_forget_cached_source_info (struct objfile *objfile) } static void -print_partial_symbols (struct gdbarch *gdbarch, +print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile, struct partial_symbol **p, int count, const char *what, struct ui_file *outfile) { @@ -881,13 +832,14 @@ print_partial_symbols (struct gdbarch *gdbarch, while (count-- > 0) { QUIT; - fprintf_filtered (outfile, " `%s'", SYMBOL_LINKAGE_NAME (*p)); - if (SYMBOL_DEMANGLED_NAME (*p) != NULL) + fprintf_filtered (outfile, " `%s'", (*p)->ginfo.linkage_name ()); + if ((*p)->ginfo.demangled_name () != NULL) { - fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p)); + fprintf_filtered (outfile, " `%s'", + (*p)->ginfo.demangled_name ()); } fputs_filtered (", ", outfile); - switch (SYMBOL_DOMAIN (*p)) + switch ((*p)->domain) { case UNDEF_DOMAIN: fputs_filtered ("undefined domain, ", outfile); @@ -898,14 +850,20 @@ print_partial_symbols (struct gdbarch *gdbarch, case STRUCT_DOMAIN: fputs_filtered ("struct domain, ", outfile); break; + case MODULE_DOMAIN: + fputs_filtered ("module domain, ", outfile); + break; case LABEL_DOMAIN: fputs_filtered ("label domain, ", outfile); break; + case COMMON_BLOCK_DOMAIN: + fputs_filtered ("common block domain, ", outfile); + break; default: fputs_filtered (", ", outfile); break; } - switch (PSYMBOL_CLASS (*p)) + switch ((*p)->aclass) { case LOC_UNDEF: fputs_filtered ("undefined", outfile); @@ -957,7 +915,7 @@ print_partial_symbols (struct gdbarch *gdbarch, break; } fputs_filtered (", ", outfile); - fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile); + fputs_filtered (paddress (gdbarch, (*p)->unrelocated_address ()), outfile); fprintf_filtered (outfile, "\n"); p++; } @@ -967,7 +925,7 @@ static void dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab, struct ui_file *outfile) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); int i; if (psymtab->anonymous) @@ -983,25 +941,23 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab, fprintf_filtered (outfile, "(object "); gdb_print_host_address (psymtab, outfile); fprintf_filtered (outfile, ")\n\n"); - fprintf_unfiltered (outfile, " Read from object file %s (", - objfile_name (objfile)); + fprintf_filtered (outfile, " Read from object file %s (", + objfile_name (objfile)); gdb_print_host_address (objfile, outfile); - fprintf_unfiltered (outfile, ")\n"); + fprintf_filtered (outfile, ")\n"); - if (psymtab->readin) + if (psymtab->readin_p (objfile)) { fprintf_filtered (outfile, " Full symtab was read (at "); - gdb_print_host_address (psymtab->compunit_symtab, outfile); - fprintf_filtered (outfile, " by function at "); - gdb_print_host_address (psymtab->read_symtab, outfile); + gdb_print_host_address (psymtab->get_compunit_symtab (objfile), outfile); fprintf_filtered (outfile, ")\n"); } fprintf_filtered (outfile, " Symbols cover text addresses "); - fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile); + fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile); fprintf_filtered (outfile, "-"); - fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile); + fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)), outfile); fprintf_filtered (outfile, "\n"); fprintf_filtered (outfile, " Address map supported - %s.\n", psymtab->psymtabs_addrmap_supported ? "yes" : "no"); @@ -1022,17 +978,17 @@ dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab, } if (psymtab->n_global_syms > 0) { - print_partial_symbols (gdbarch, - objfile->global_psymbols.list - + psymtab->globals_offset, - psymtab->n_global_syms, "Global", outfile); + print_partial_symbols + (gdbarch, objfile, + &objfile->partial_symtabs->global_psymbols[psymtab->globals_offset], + psymtab->n_global_syms, "Global", outfile); } if (psymtab->n_static_syms > 0) { - print_partial_symbols (gdbarch, - objfile->static_psymbols.list - + psymtab->statics_offset, - psymtab->n_static_syms, "Static", outfile); + print_partial_symbols + (gdbarch, objfile, + &objfile->partial_symtabs->static_psymbols[psymtab->statics_offset], + psymtab->n_static_syms, "Static", outfile); } fprintf_filtered (outfile, "\n"); } @@ -1044,12 +1000,11 @@ static void psym_print_stats (struct objfile *objfile) { int i; - struct partial_symtab *ps; i = 0; - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) + for (partial_symtab *ps : require_partial_symbols (objfile, true)) { - if (ps->readin == 0) + if (!ps->readin_p (objfile)) i++; } printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i); @@ -1063,10 +1018,10 @@ psym_dump (struct objfile *objfile) { struct partial_symtab *psymtab; - if (objfile->psymtabs) + if (objfile->partial_symtabs->psymtabs) { printf_filtered ("Psymtabs:\n"); - for (psymtab = objfile->psymtabs; + for (psymtab = objfile->partial_symtabs->psymtabs; psymtab != NULL; psymtab = psymtab->next) { @@ -1087,19 +1042,20 @@ static void psym_expand_symtabs_for_function (struct objfile *objfile, const char *func_name) { - struct partial_symtab *ps; + lookup_name_info base_lookup (func_name, symbol_name_match_type::FULL); + lookup_name_info lookup_name = base_lookup.make_ignore_params (); - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) - { - if (ps->readin) - continue; + for (partial_symtab *ps : require_partial_symbols (objfile, true)) + { + if (ps->readin_p (objfile)) + continue; - if ((lookup_partial_symbol (objfile, ps, func_name, 1, VAR_DOMAIN) - != NULL) - || (lookup_partial_symbol (objfile, ps, func_name, 0, VAR_DOMAIN) - != NULL)) - psymtab_to_symtab (objfile, ps); - } + if ((lookup_partial_symbol (objfile, ps, lookup_name, 1, VAR_DOMAIN) + != NULL) + || (lookup_partial_symbol (objfile, ps, lookup_name, 0, VAR_DOMAIN) + != NULL)) + psymtab_to_symtab (objfile, ps); + } } /* Psymtab version of expand_all_symtabs. See its definition in @@ -1108,12 +1064,8 @@ psym_expand_symtabs_for_function (struct objfile *objfile, static void psym_expand_all_symtabs (struct objfile *objfile) { - struct partial_symtab *psymtab; - - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab) - { - psymtab_to_symtab (objfile, psymtab); - } + for (partial_symtab *psymtab : require_partial_symbols (objfile, true)) + psymtab_to_symtab (objfile, psymtab); } /* Psymtab version of expand_symtabs_with_fullname. See its definition in @@ -1123,9 +1075,7 @@ static void psym_expand_symtabs_with_fullname (struct objfile *objfile, const char *fullname) { - struct partial_symtab *p; - - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, p) + for (partial_symtab *p : require_partial_symbols (objfile, true)) { /* Anonymous psymtabs don't have a name of a source file. */ if (p->anonymous) @@ -1148,13 +1098,11 @@ psym_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun, void *data, int need_fullname) { - struct partial_symtab *ps; - - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) + for (partial_symtab *ps : require_partial_symbols (objfile, true)) { const char *fullname; - if (ps->readin) + if (ps->readin_p (objfile)) continue; /* We can skip shared psymtabs here, because any file name will be @@ -1193,96 +1141,59 @@ psymtab_to_fullname (struct partial_symtab *ps) to handle cases like the file being moved. */ if (ps->fullname == NULL) { - int fd = find_and_open_source (ps->filename, ps->dirname, &ps->fullname); + gdb::unique_xmalloc_ptr fullname; + scoped_fd fd = find_and_open_source (ps->filename, ps->dirname, + &fullname); + ps->fullname = fullname.release (); - if (fd >= 0) - close (fd); - else + if (fd.get () < 0) { - char *fullname; - struct cleanup *back_to; - /* rewrite_source_path would be applied by find_and_open_source, we should report the pathname where GDB tried to find the file. */ if (ps->dirname == NULL || IS_ABSOLUTE_PATH (ps->filename)) - fullname = xstrdup (ps->filename); + fullname.reset (xstrdup (ps->filename)); else - fullname = concat (ps->dirname, SLASH_STRING, - ps->filename, (char *) NULL); + fullname.reset (concat (ps->dirname, SLASH_STRING, + ps->filename, (char *) NULL)); - back_to = make_cleanup (xfree, fullname); - ps->fullname = rewrite_source_path (fullname); + ps->fullname = rewrite_source_path (fullname.get ()).release (); if (ps->fullname == NULL) - ps->fullname = xstrdup (fullname); - do_cleanups (back_to); + ps->fullname = fullname.release (); } } return ps->fullname; } -/* For all symbols, s, in BLOCK that are in DOMAIN and match NAME - according to the function MATCH, call CALLBACK(BLOCK, s, DATA). - BLOCK is assumed to come from OBJFILE. Returns 1 iff CALLBACK - ever returns non-zero, and otherwise returns 0. */ - -static int -map_block (const char *name, domain_enum domain, struct objfile *objfile, - struct block *block, - int (*callback) (struct block *, struct symbol *, void *), - void *data, symbol_compare_ftype *match) -{ - struct block_iterator iter; - struct symbol *sym; - - for (sym = block_iter_match_first (block, name, match, &iter); - sym != NULL; sym = block_iter_match_next (name, match, &iter)) - { - if (symbol_matches_domain (SYMBOL_LANGUAGE (sym), - SYMBOL_DOMAIN (sym), domain)) - { - if (callback (block, sym, data)) - return 1; - } - } - - return 0; -} - /* Psymtab version of map_matching_symbols. See its definition in the definition of quick_symbol_functions in symfile.h. */ static void -psym_map_matching_symbols (struct objfile *objfile, - const char *name, domain_enum domain, - int global, - int (*callback) (struct block *, - struct symbol *, void *), - void *data, - symbol_compare_ftype *match, - symbol_compare_ftype *ordered_compare) +psym_map_matching_symbols + (struct objfile *objfile, + const lookup_name_info &name, domain_enum domain, + int global, + gdb::function_view callback, + symbol_compare_ftype *ordered_compare) { const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK; - struct partial_symtab *ps; - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) + for (partial_symtab *ps : require_partial_symbols (objfile, true)) { QUIT; - if (ps->readin - || match_partial_symbol (objfile, ps, global, name, domain, match, + if (ps->readin_p (objfile) + || match_partial_symbol (objfile, ps, global, name, domain, ordered_compare)) { struct compunit_symtab *cust = psymtab_to_symtab (objfile, ps); - struct block *block; + const struct block *block; if (cust == NULL) continue; block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), block_kind); - if (map_block (name, domain, objfile, block, - callback, data, match)) - return; - if (callback (block, NULL, data)) + if (!iterate_over_symbols_terminated (block, name, + domain, callback)) return; } } @@ -1295,11 +1206,12 @@ psym_map_matching_symbols (struct objfile *objfile, static bool recursively_search_psymtabs - (struct partial_symtab *ps, struct objfile *objfile, enum search_domain kind, + (struct partial_symtab *ps, + struct objfile *objfile, + enum search_domain domain, + const lookup_name_info &lookup_name, gdb::function_view sym_matcher) { - struct partial_symbol **psym; - struct partial_symbol **bound, **gbound, **sbound; int keep_going = 1; enum psymtab_search_status result = PST_SEARCHED_AND_NOT_FOUND; int i; @@ -1318,7 +1230,8 @@ recursively_search_psymtabs continue; r = recursively_search_psymtabs (ps->dependencies[i], - objfile, kind, sym_matcher); + objfile, domain, lookup_name, + sym_matcher); if (r != 0) { ps->searched_flag = PST_SEARCHED_AND_FOUND; @@ -1326,22 +1239,26 @@ recursively_search_psymtabs } } - gbound = (objfile->global_psymbols.list - + ps->globals_offset + ps->n_global_syms); - sbound = (objfile->static_psymbols.list - + ps->statics_offset + ps->n_static_syms); - bound = gbound; + partial_symbol **gbound + = (objfile->partial_symtabs->global_psymbols.data () + + ps->globals_offset + ps->n_global_syms); + partial_symbol **sbound + = (objfile->partial_symtabs->static_psymbols.data () + + ps->statics_offset + ps->n_static_syms); + partial_symbol **bound = gbound; /* Go through all of the symbols stored in a partial symtab in one loop. */ - psym = objfile->global_psymbols.list + ps->globals_offset; + partial_symbol **psym = (objfile->partial_symtabs->global_psymbols.data () + + ps->globals_offset); while (keep_going) { if (psym >= bound) { if (bound == gbound && ps->n_static_syms != 0) { - psym = objfile->static_psymbols.list + ps->statics_offset; + psym = (objfile->partial_symtabs->static_psymbols.data () + + ps->statics_offset); bound = sbound; } else @@ -1352,15 +1269,19 @@ recursively_search_psymtabs { QUIT; - if ((kind == ALL_DOMAIN - || (kind == VARIABLES_DOMAIN - && PSYMBOL_CLASS (*psym) != LOC_TYPEDEF - && PSYMBOL_CLASS (*psym) != LOC_BLOCK) - || (kind == FUNCTIONS_DOMAIN - && PSYMBOL_CLASS (*psym) == LOC_BLOCK) - || (kind == TYPES_DOMAIN - && PSYMBOL_CLASS (*psym) == LOC_TYPEDEF)) - && sym_matcher (SYMBOL_SEARCH_NAME (*psym))) + if ((domain == ALL_DOMAIN + || (domain == MODULES_DOMAIN + && (*psym)->domain == MODULE_DOMAIN) + || (domain == VARIABLES_DOMAIN + && (*psym)->aclass != LOC_TYPEDEF + && (*psym)->aclass != LOC_BLOCK) + || (domain == FUNCTIONS_DOMAIN + && (*psym)->aclass == LOC_BLOCK) + || (domain == TYPES_DOMAIN + && (*psym)->aclass == LOC_TYPEDEF)) + && psymbol_name_matches (*psym, lookup_name) + && (sym_matcher == NULL + || sym_matcher ((*psym)->ginfo.search_name ()))) { /* Found a match, so notify our caller. */ result = PST_SEARCHED_AND_FOUND; @@ -1381,23 +1302,20 @@ static void psym_expand_symtabs_matching (struct objfile *objfile, gdb::function_view file_matcher, + const lookup_name_info *lookup_name, gdb::function_view symbol_matcher, gdb::function_view expansion_notify, - enum search_domain kind) + enum search_domain domain) { - struct partial_symtab *ps; - /* Clear the search flags. */ - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) - { - ps->searched_flag = PST_NOT_SEARCHED; - } + for (partial_symtab *ps : require_partial_symbols (objfile, true)) + ps->searched_flag = PST_NOT_SEARCHED; - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) + for (partial_symtab *ps : objfile->psymtabs ()) { QUIT; - if (ps->readin) + if (ps->readin_p (objfile)) continue; /* We skip shared psymtabs because file-matching doesn't apply @@ -1425,7 +1343,10 @@ psym_expand_symtabs_matching continue; } - if (recursively_search_psymtabs (ps, objfile, kind, symbol_matcher)) + if ((symbol_matcher == NULL && lookup_name == NULL) + || recursively_search_psymtabs (ps, objfile, domain, + lookup_name->make_ignore_params (), + symbol_matcher)) { struct compunit_symtab *symtab = psymtab_to_symtab (objfile, ps); @@ -1442,7 +1363,83 @@ psym_expand_symtabs_matching static int psym_has_symbols (struct objfile *objfile) { - return objfile->psymtabs != NULL; + return objfile->partial_symtabs->psymtabs != NULL; +} + +/* Helper function for psym_find_compunit_symtab_by_address that fills + in psymbol_map for a given range of psymbols. */ + +static void +psym_fill_psymbol_map (struct objfile *objfile, + struct partial_symtab *psymtab, + std::set *seen_addrs, + const std::vector &symbols, + int start, + int length) +{ + for (int i = 0; i < length; ++i) + { + struct partial_symbol *psym = symbols[start + i]; + + if (psym->aclass == LOC_STATIC) + { + CORE_ADDR addr = psym->address (objfile); + if (seen_addrs->find (addr) == seen_addrs->end ()) + { + seen_addrs->insert (addr); + objfile->psymbol_map.emplace_back (addr, psymtab); + } + } + } +} + +/* See find_compunit_symtab_by_address in quick_symbol_functions, in + symfile.h. */ + +static compunit_symtab * +psym_find_compunit_symtab_by_address (struct objfile *objfile, + CORE_ADDR address) +{ + if (objfile->psymbol_map.empty ()) + { + std::set seen_addrs; + + for (partial_symtab *pst : require_partial_symbols (objfile, true)) + { + psym_fill_psymbol_map (objfile, pst, + &seen_addrs, + objfile->partial_symtabs->global_psymbols, + pst->globals_offset, + pst->n_global_syms); + psym_fill_psymbol_map (objfile, pst, + &seen_addrs, + objfile->partial_symtabs->static_psymbols, + pst->statics_offset, + pst->n_static_syms); + } + + objfile->psymbol_map.shrink_to_fit (); + + std::sort (objfile->psymbol_map.begin (), objfile->psymbol_map.end (), + [] (const std::pair &a, + const std::pair &b) + { + return a.first < b.first; + }); + } + + auto iter = std::lower_bound + (objfile->psymbol_map.begin (), objfile->psymbol_map.end (), address, + [] (const std::pair &a, + CORE_ADDR b) + { + return a.first < b; + }); + + if (iter == objfile->psymbol_map.end () || iter->first != address) + return NULL; + + return psymtab_to_symtab (objfile, iter->second); } const struct quick_symbol_functions psym_functions = @@ -1452,62 +1449,63 @@ const struct quick_symbol_functions psym_functions = psym_forget_cached_source_info, psym_map_symtabs_matching_filename, psym_lookup_symbol, + psym_lookup_global_symbol_language, psym_print_stats, psym_dump, - psym_relocate, psym_expand_symtabs_for_function, psym_expand_all_symtabs, psym_expand_symtabs_with_fullname, psym_map_matching_symbols, psym_expand_symtabs_matching, psym_find_pc_sect_compunit_symtab, + psym_find_compunit_symtab_by_address, psym_map_symbol_filenames }; -/* This compares two partial symbols by names, using strcmp_iw_ordered - for the comparison. */ - -static int -compare_psymbols (const void *s1p, const void *s2p) -{ - struct partial_symbol *const *s1 = (struct partial_symbol * const*) s1p; - struct partial_symbol *const *s2 = (struct partial_symbol * const*) s2p; - - return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1), - SYMBOL_SEARCH_NAME (*s2)); -} - static void sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst) { /* Sort the global list; don't sort the static list. */ + auto begin = objfile->partial_symtabs->global_psymbols.begin (); + std::advance (begin, pst->globals_offset); - qsort (objfile->global_psymbols.list + pst->globals_offset, - pst->n_global_syms, sizeof (struct partial_symbol *), - compare_psymbols); -} + /* The psymbols for this partial_symtab are currently at the end of the + vector. */ + auto end = objfile->partial_symtabs->global_psymbols.end (); -/* Allocate and partially fill a partial symtab. It will be - completely filled at the end of the symbol list. + std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2) + { + return strcmp_iw_ordered (s1->ginfo.search_name (), + s2->ginfo.search_name ()) < 0; + }); +} - FILENAME is the name of the symbol-file we are reading from. */ +/* Partially fill a partial symtab. It will be completely filled at + the end of the symbol list. */ -struct partial_symtab * -start_psymtab_common (struct objfile *objfile, - const char *filename, - CORE_ADDR textlow, struct partial_symbol **global_syms, - struct partial_symbol **static_syms) +partial_symtab::partial_symtab (const char *filename, + struct objfile *objfile, + CORE_ADDR textlow) + : partial_symtab (filename, objfile) { - struct partial_symtab *psymtab; + set_text_low (textlow); + set_text_high (raw_text_low ()); /* default */ + + auto *v1 = new std::vector; + objfile->partial_symtabs->current_global_psymbols.push_back (v1); + auto *v2 = new std::vector; + objfile->partial_symtabs->current_static_psymbols.push_back (v2); +} - psymtab = allocate_psymtab (filename, objfile); - psymtab->textlow = textlow; - psymtab->texthigh = psymtab->textlow; /* default */ - psymtab->globals_offset = global_syms - objfile->global_psymbols.list; - psymtab->statics_offset = static_syms - objfile->static_psymbols.list; - return psymtab; +/* Concat vectors V1 and V2. */ + +static void +concat (std::vector *v1, std::vector *v2) +{ + v1->insert (v1->end (), v2->begin (), v2->end ()); + v2->clear (); } /* Perform "finishing up" operations of a partial symtab. */ @@ -1515,12 +1513,26 @@ start_psymtab_common (struct objfile *objfile, void end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst) { + pst->globals_offset = objfile->partial_symtabs->global_psymbols.size (); + pst->statics_offset = objfile->partial_symtabs->static_psymbols.size (); + + auto *current_global_psymbols + = objfile->partial_symtabs->current_global_psymbols.back (); + auto *current_static_psymbols + = objfile->partial_symtabs->current_static_psymbols.back (); + objfile->partial_symtabs->current_global_psymbols.pop_back (); + objfile->partial_symtabs->current_static_psymbols.pop_back (); + pst->n_global_syms - = objfile->global_psymbols.next - (objfile->global_psymbols.list - + pst->globals_offset); + = current_global_psymbols->size (); pst->n_static_syms - = objfile->static_psymbols.next - (objfile->static_psymbols.list - + pst->statics_offset); + = current_static_psymbols->size (); + + concat (&objfile->partial_symtabs->global_psymbols, current_global_psymbols); + concat (&objfile->partial_symtabs->static_psymbols, current_static_psymbols); + + delete current_global_psymbols; + delete current_static_psymbols; sort_pst_symbols (objfile, pst); } @@ -1535,15 +1547,17 @@ psymbol_hash (const void *addr, int length) { unsigned long h = 0; struct partial_symbol *psymbol = (struct partial_symbol *) addr; - unsigned int lang = psymbol->ginfo.language; - unsigned int domain = PSYMBOL_DOMAIN (psymbol); - unsigned int theclass = PSYMBOL_CLASS (psymbol); - - h = hash_continue (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h); - h = hash_continue (&lang, sizeof (unsigned int), h); - h = hash_continue (&domain, sizeof (unsigned int), h); - h = hash_continue (&theclass, sizeof (unsigned int), h); - h = hash_continue (psymbol->ginfo.name, strlen (psymbol->ginfo.name), h); + unsigned int lang = psymbol->ginfo.language (); + unsigned int domain = psymbol->domain; + unsigned int theclass = psymbol->aclass; + + h = fast_hash (&psymbol->ginfo.value, sizeof (psymbol->ginfo.value), h); + h = fast_hash (&lang, sizeof (unsigned int), h); + h = fast_hash (&domain, sizeof (unsigned int), h); + h = fast_hash (&theclass, sizeof (unsigned int), h); + /* Note that psymbol names are interned via compute_and_set_names, so + there's no need to hash the contents of the name here. */ + h = fast_hash (&psymbol->ginfo.m_name, sizeof (psymbol->ginfo.m_name), h); return h; } @@ -1560,56 +1574,13 @@ psymbol_compare (const void *addr1, const void *addr2, int length) return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value, sizeof (sym1->ginfo.value)) == 0 - && sym1->ginfo.language == sym2->ginfo.language - && PSYMBOL_DOMAIN (sym1) == PSYMBOL_DOMAIN (sym2) - && PSYMBOL_CLASS (sym1) == PSYMBOL_CLASS (sym2) - && sym1->ginfo.name == sym2->ginfo.name); -} - -/* Initialize a partial symbol bcache. */ - -struct psymbol_bcache * -psymbol_bcache_init (void) -{ - struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache); - - bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare); - return bcache; -} - -/* Free a partial symbol bcache. */ - -void -psymbol_bcache_free (struct psymbol_bcache *bcache) -{ - if (bcache == NULL) - return; - - bcache_xfree (bcache->bcache); - xfree (bcache); -} - -/* Return the internal bcache of the psymbol_bcache BCACHE. */ - -struct bcache * -psymbol_bcache_get_bcache (struct psymbol_bcache *bcache) -{ - return bcache->bcache; -} - -/* Find a copy of the SYM in BCACHE. If BCACHE has never seen this - symbol before, add a copy to BCACHE. In either case, return a pointer - to BCACHE's copy of the symbol. If optional ADDED is not NULL, return - 1 in case of new entry or 0 if returning an old entry. */ - -static const struct partial_symbol * -psymbol_bcache_full (struct partial_symbol *sym, - struct psymbol_bcache *bcache, - int *added) -{ - return ((const struct partial_symbol *) - bcache_full (sym, sizeof (struct partial_symbol), bcache->bcache, - added)); + && sym1->ginfo.language () == sym2->ginfo.language () + && sym1->domain == sym2->domain + && sym1->aclass == sym2->aclass + /* Note that psymbol names are interned via + compute_and_set_names, so there's no need to compare the + contents of the name here. */ + && sym1->ginfo.linkage_name () == sym2->ginfo.linkage_name ()); } /* Helper function, initialises partial symbol structure and stashes @@ -1618,165 +1589,105 @@ psymbol_bcache_full (struct partial_symbol *sym, structure. In other words, having two symbols with the same name but different domain (or address) is possible and correct. */ -static const struct partial_symbol * -add_psymbol_to_bcache (const char *name, int namelength, int copy_name, - domain_enum domain, - enum address_class theclass, - CORE_ADDR coreaddr, - enum language language, struct objfile *objfile, +static struct partial_symbol * +add_psymbol_to_bcache (const partial_symbol &psymbol, + struct objfile *objfile, int *added) { - struct partial_symbol psymbol; - - /* We must ensure that the entire struct has been zeroed before - assigning to it, because an assignment may not touch some of the - holes. */ - memset (&psymbol, 0, sizeof (psymbol)); - - SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr; - SYMBOL_SECTION (&psymbol) = -1; - SYMBOL_SET_LANGUAGE (&psymbol, language, &objfile->objfile_obstack); - PSYMBOL_DOMAIN (&psymbol) = domain; - PSYMBOL_CLASS (&psymbol) = theclass; - - SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile); - /* Stash the partial symbol away in the cache. */ - return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added); -} - -/* Increase the space allocated for LISTP, which is probably - global_psymbols or static_psymbols. This space will eventually - be freed in free_objfile(). */ - -static void -extend_psymbol_list (struct psymbol_allocation_list *listp, - struct objfile *objfile) -{ - int new_size; - - if (listp->size == 0) - { - new_size = 255; - listp->list = XNEWVEC (struct partial_symbol *, new_size); - } - else - { - new_size = listp->size * 2; - listp->list = (struct partial_symbol **) - xrealloc ((char *) listp->list, - new_size * sizeof (struct partial_symbol *)); - } - /* Next assumes we only went one over. Should be good if - program works correctly. */ - listp->next = listp->list + listp->size; - listp->size = new_size; + return ((struct partial_symbol *) + objfile->partial_symtabs->psymbol_cache.insert + (&psymbol, sizeof (struct partial_symbol), added)); } /* Helper function, adds partial symbol to the given partial symbol list. */ static void -append_psymbol_to_list (struct psymbol_allocation_list *list, - const struct partial_symbol *psym, +append_psymbol_to_list (std::vector *list, + struct partial_symbol *psym, struct objfile *objfile) { - if (list->next >= list->list + list->size) - extend_psymbol_list (list, objfile); - *list->next++ = (struct partial_symbol *) psym; + list->push_back (psym); OBJSTAT (objfile, n_psyms++); } -/* Add a symbol with a long value to a psymtab. - Since one arg is a struct, we pass in a ptr and deref it (sigh). - The only value we need to store for psyms is an address. - For all other psyms pass zero for COREADDR. - Return the partial symbol that has been added. */ +/* See psympriv.h. */ void -add_psymbol_to_list (const char *name, int namelength, int copy_name, - domain_enum domain, - enum address_class theclass, - struct psymbol_allocation_list *list, - CORE_ADDR coreaddr, - enum language language, struct objfile *objfile) +add_psymbol_to_list (const partial_symbol &psymbol, + psymbol_placement where, + struct objfile *objfile) { - const struct partial_symbol *psym; + struct partial_symbol *psym; int added; /* Stash the partial symbol away in the cache. */ - psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass, - coreaddr, language, objfile, &added); + psym = add_psymbol_to_bcache (psymbol, objfile, &added); /* Do not duplicate global partial symbols. */ - if (list == &objfile->global_psymbols - && !added) + if (where == psymbol_placement::GLOBAL && !added) return; /* Save pointer to partial symbol in psymtab, growing symtab if needed. */ + std::vector *list + = (where == psymbol_placement::STATIC + ? objfile->partial_symtabs->current_static_psymbols.back () + : objfile->partial_symtabs->current_global_psymbols.back ()); append_psymbol_to_list (list, psym, objfile); } -/* Initialize storage for partial symbols. */ +/* See psympriv.h. */ void -init_psymbol_list (struct objfile *objfile, int total_symbols) +add_psymbol_to_list (gdb::string_view name, bool copy_name, + domain_enum domain, + enum address_class theclass, + short section, + psymbol_placement where, + CORE_ADDR coreaddr, + enum language language, struct objfile *objfile) { - /* Free any previously allocated psymbol lists. */ - - if (objfile->global_psymbols.list) - xfree (objfile->global_psymbols.list); - if (objfile->static_psymbols.list) - xfree (objfile->static_psymbols.list); - - /* Current best guess is that approximately a twentieth - of the total symbols (in a debugging file) are global or static - oriented symbols, then multiply that by slop factor of two. */ + struct partial_symbol psymbol; + memset (&psymbol, 0, sizeof (psymbol)); - objfile->global_psymbols.size = total_symbols / 10; - objfile->static_psymbols.size = total_symbols / 10; + psymbol.set_unrelocated_address (coreaddr); + psymbol.ginfo.section = section; + psymbol.domain = domain; + psymbol.aclass = theclass; + psymbol.ginfo.set_language (language, objfile->partial_symtabs->obstack ()); + psymbol.ginfo.compute_and_set_names (name, copy_name, objfile->per_bfd); - if (objfile->global_psymbols.size > 0) - { - objfile->global_psymbols.next = - objfile->global_psymbols.list = - XNEWVEC (struct partial_symbol *, objfile->global_psymbols.size); - } - if (objfile->static_psymbols.size > 0) - { - objfile->static_psymbols.next = - objfile->static_psymbols.list = - XNEWVEC (struct partial_symbol *, objfile->static_psymbols.size); - } + add_psymbol_to_list (psymbol, where, objfile); } -struct partial_symtab * -allocate_psymtab (const char *filename, struct objfile *objfile) -{ - struct partial_symtab *psymtab; +/* See psympriv.h. */ - if (objfile->free_psymtabs) +void +init_psymbol_list (struct objfile *objfile, int total_symbols) +{ + if (objfile->partial_symtabs->global_psymbols.capacity () == 0 + && objfile->partial_symtabs->static_psymbols.capacity () == 0) { - psymtab = objfile->free_psymtabs; - objfile->free_psymtabs = psymtab->next; + /* Current best guess is that approximately a twentieth of the + total symbols (in a debugging file) are global or static + oriented symbols, then multiply that by slop factor of + two. */ + objfile->partial_symtabs->global_psymbols.reserve (total_symbols / 10); + objfile->partial_symtabs->static_psymbols.reserve (total_symbols / 10); } - else - psymtab = (struct partial_symtab *) - obstack_alloc (&objfile->objfile_obstack, - sizeof (struct partial_symtab)); +} - memset (psymtab, 0, sizeof (struct partial_symtab)); - psymtab->filename - = (const char *) bcache (filename, strlen (filename) + 1, - objfile->per_bfd->filename_cache); - psymtab->compunit_symtab = NULL; +/* See psympriv.h. */ - /* Prepend it to the psymtab list for the objfile it belongs to. - Psymtabs are searched in most recent inserted -> least recent - inserted order. */ +partial_symtab::partial_symtab (const char *filename_, struct objfile *objfile) + : searched_flag (PST_NOT_SEARCHED), + text_low_valid (0), + text_high_valid (0) +{ + objfile->partial_symtabs->install_psymtab (this); - psymtab->next = objfile->psymtabs; - objfile->psymtabs = psymtab; + filename = objfile->intern (filename_); if (symtab_create_debug) { @@ -1789,20 +1700,45 @@ allocate_psymtab (const char *filename, struct objfile *objfile) { xfree (last_objfile_name); last_objfile_name = xstrdup (objfile_name (objfile)); - fprintf_unfiltered (gdb_stdlog, - "Creating one or more psymtabs for objfile %s ...\n", - last_objfile_name); + fprintf_filtered (gdb_stdlog, + "Creating one or more psymtabs for objfile %s ...\n", + last_objfile_name); } - fprintf_unfiltered (gdb_stdlog, - "Created psymtab %s for module %s.\n", - host_address_to_string (psymtab), filename); + fprintf_filtered (gdb_stdlog, + "Created psymtab %s for module %s.\n", + host_address_to_string (this), filename); } +} + +/* See psympriv.h. */ - return psymtab; +void +partial_symtab::expand_dependencies (struct objfile *objfile) +{ + for (int i = 0; i < number_of_dependencies; ++i) + { + if (!dependencies[i]->readin_p (objfile) + && dependencies[i]->user == NULL) + { + /* Inform about additional files to be read in. */ + if (info_verbose) + { + fputs_filtered (" ", gdb_stdout); + wrap_here (""); + fputs_filtered ("and ", gdb_stdout); + wrap_here (""); + printf_filtered ("%s...", dependencies[i]->filename); + wrap_here (""); /* Flush output */ + gdb_flush (gdb_stdout); + } + dependencies[i]->expand_psymtab (objfile); + } + } } + void -discard_psymtab (struct objfile *objfile, struct partial_symtab *pst) +psymtab_storage::discard_psymtab (struct partial_symtab *pst) { struct partial_symtab **prev_pst; @@ -1815,15 +1751,11 @@ discard_psymtab (struct objfile *objfile, struct partial_symtab *pst) /* First, snip it out of the psymtab chain. */ - prev_pst = &(objfile->psymtabs); + prev_pst = &psymtabs; while ((*prev_pst) != pst) prev_pst = &((*prev_pst)->next); (*prev_pst) = pst->next; - - /* Next, put it on a free list for recycling. */ - - pst->next = objfile->free_psymtabs; - objfile->free_psymtabs = pst; + delete pst; } @@ -1850,7 +1782,7 @@ dump_psymtab_addrmap_1 (void *datap, CORE_ADDR start_addr, void *obj) { struct dump_psymtab_addrmap_data *data = (struct dump_psymtab_addrmap_data *) datap; - struct gdbarch *gdbarch = get_objfile_arch (data->objfile); + struct gdbarch *gdbarch = data->objfile->arch (); struct partial_symtab *addrmap_psymtab = (struct partial_symtab *) obj; const char *psymtab_address_or_end = NULL; @@ -1889,7 +1821,7 @@ dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab, if ((psymtab == NULL || psymtab->psymtabs_addrmap_supported) - && objfile->psymtabs_addrmap != NULL) + && objfile->partial_symtabs->psymtabs_addrmap != NULL) { addrmap_dump_data.objfile = objfile; addrmap_dump_data.psymtab = psymtab; @@ -1897,18 +1829,16 @@ dump_psymtab_addrmap (struct objfile *objfile, struct partial_symtab *psymtab, addrmap_dump_data.previous_matched = 0; fprintf_filtered (outfile, "%sddress map:\n", psymtab == NULL ? "Entire a" : " A"); - addrmap_foreach (objfile->psymtabs_addrmap, dump_psymtab_addrmap_1, - &addrmap_dump_data); + addrmap_foreach (objfile->partial_symtabs->psymtabs_addrmap, + dump_psymtab_addrmap_1, &addrmap_dump_data); } } static void -maintenance_print_psymbols (char *args, int from_tty) +maintenance_print_psymbols (const char *args, int from_tty) { struct ui_file *outfile = gdb_stdout; char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL; - struct objfile *objfile; - struct partial_symtab *ps; int i, outfile_idx, found; CORE_ADDR pc = 0; struct obj_section *section = NULL; @@ -1977,7 +1907,7 @@ maintenance_print_psymbols (char *args, int from_tty) } found = 0; - ALL_OBJFILES (objfile) + for (objfile *objfile : current_program_space->objfiles ()) { int printed_objfile_header = 0; int print_for_objfile = 1; @@ -1996,7 +1926,8 @@ maintenance_print_psymbols (char *args, int from_tty) /* We don't assume each pc has a unique objfile (this is for debugging). */ - ps = find_pc_sect_psymtab (objfile, pc, section, msymbol); + struct partial_symtab *ps = find_pc_sect_psymtab (objfile, pc, + section, msymbol); if (ps != NULL) { if (!printed_objfile_header) @@ -2012,7 +1943,7 @@ maintenance_print_psymbols (char *args, int from_tty) } else { - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, ps) + for (partial_symtab *ps : require_partial_symbols (objfile, true)) { int print_for_source = 0; @@ -2042,7 +1973,7 @@ maintenance_print_psymbols (char *args, int from_tty) if (address_arg == NULL && source_arg == NULL - && objfile->psymtabs_addrmap != NULL) + && objfile->partial_symtabs->psymtabs_addrmap != NULL) { outfile->puts ("\n"); dump_psymtab_addrmap (objfile, NULL, outfile); @@ -2061,212 +1992,227 @@ maintenance_print_psymbols (char *args, int from_tty) /* List all the partial symbol tables whose names match REGEXP (optional). */ static void -maintenance_info_psymtabs (char *regexp, int from_tty) +maintenance_info_psymtabs (const char *regexp, int from_tty) { - struct program_space *pspace; - struct objfile *objfile; - if (regexp) re_comp (regexp); - ALL_PSPACES (pspace) - ALL_PSPACE_OBJFILES (pspace, objfile) - { - struct gdbarch *gdbarch = get_objfile_arch (objfile); - struct partial_symtab *psymtab; - - /* We don't want to print anything for this objfile until we - actually find a symtab whose name matches. */ - int printed_objfile_start = 0; - - ALL_OBJFILE_PSYMTABS_REQUIRED (objfile, psymtab) - { - QUIT; - - if (! regexp - || re_exec (psymtab->filename)) - { - if (! printed_objfile_start) - { - printf_filtered ("{ objfile %s ", objfile_name (objfile)); - wrap_here (" "); - printf_filtered ("((struct objfile *) %s)\n", - host_address_to_string (objfile)); - printed_objfile_start = 1; - } - - printf_filtered (" { psymtab %s ", psymtab->filename); - wrap_here (" "); - printf_filtered ("((struct partial_symtab *) %s)\n", - host_address_to_string (psymtab)); - - printf_filtered (" readin %s\n", - psymtab->readin ? "yes" : "no"); - printf_filtered (" fullname %s\n", - psymtab->fullname - ? psymtab->fullname : "(null)"); - printf_filtered (" text addresses "); - fputs_filtered (paddress (gdbarch, psymtab->textlow), - gdb_stdout); - printf_filtered (" -- "); - fputs_filtered (paddress (gdbarch, psymtab->texthigh), - gdb_stdout); - printf_filtered ("\n"); - printf_filtered (" psymtabs_addrmap_supported %s\n", - (psymtab->psymtabs_addrmap_supported - ? "yes" : "no")); - printf_filtered (" globals "); - if (psymtab->n_global_syms) - { - printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n", - host_address_to_string (objfile->global_psymbols.list - + psymtab->globals_offset), - psymtab->n_global_syms); - } - else - printf_filtered ("(none)\n"); - printf_filtered (" statics "); - if (psymtab->n_static_syms) - { - printf_filtered ("(* (struct partial_symbol **) %s @ %d)\n", - host_address_to_string (objfile->static_psymbols.list - + psymtab->statics_offset), - psymtab->n_static_syms); - } - else - printf_filtered ("(none)\n"); - printf_filtered (" dependencies "); - if (psymtab->number_of_dependencies) - { - int i; + for (struct program_space *pspace : program_spaces) + for (objfile *objfile : pspace->objfiles ()) + { + struct gdbarch *gdbarch = objfile->arch (); - printf_filtered ("{\n"); - for (i = 0; i < psymtab->number_of_dependencies; i++) - { - struct partial_symtab *dep = psymtab->dependencies[i]; + /* We don't want to print anything for this objfile until we + actually find a symtab whose name matches. */ + int printed_objfile_start = 0; - /* Note the string concatenation there --- no comma. */ - printf_filtered (" psymtab %s " - "((struct partial_symtab *) %s)\n", - dep->filename, - host_address_to_string (dep)); - } - printf_filtered (" }\n"); - } - else - printf_filtered ("(none)\n"); - printf_filtered (" }\n"); - } - } + for (partial_symtab *psymtab : require_partial_symbols (objfile, true)) + { + QUIT; + + if (! regexp + || re_exec (psymtab->filename)) + { + if (! printed_objfile_start) + { + printf_filtered ("{ objfile %s ", objfile_name (objfile)); + wrap_here (" "); + printf_filtered ("((struct objfile *) %s)\n", + host_address_to_string (objfile)); + printed_objfile_start = 1; + } + + printf_filtered (" { psymtab %s ", psymtab->filename); + wrap_here (" "); + printf_filtered ("((struct partial_symtab *) %s)\n", + host_address_to_string (psymtab)); + + printf_filtered (" readin %s\n", + psymtab->readin_p (objfile) ? "yes" : "no"); + printf_filtered (" fullname %s\n", + psymtab->fullname + ? psymtab->fullname : "(null)"); + printf_filtered (" text addresses "); + fputs_filtered (paddress (gdbarch, + psymtab->text_low (objfile)), + gdb_stdout); + printf_filtered (" -- "); + fputs_filtered (paddress (gdbarch, + psymtab->text_high (objfile)), + gdb_stdout); + printf_filtered ("\n"); + printf_filtered (" psymtabs_addrmap_supported %s\n", + (psymtab->psymtabs_addrmap_supported + ? "yes" : "no")); + printf_filtered (" globals "); + if (psymtab->n_global_syms) + { + auto p = &(objfile->partial_symtabs + ->global_psymbols[psymtab->globals_offset]); + + printf_filtered + ("(* (struct partial_symbol **) %s @ %d)\n", + host_address_to_string (p), + psymtab->n_global_syms); + } + else + printf_filtered ("(none)\n"); + printf_filtered (" statics "); + if (psymtab->n_static_syms) + { + auto p = &(objfile->partial_symtabs + ->static_psymbols[psymtab->statics_offset]); + + printf_filtered + ("(* (struct partial_symbol **) %s @ %d)\n", + host_address_to_string (p), + psymtab->n_static_syms); + } + else + printf_filtered ("(none)\n"); + if (psymtab->user) + printf_filtered (" user %s " + "((struct partial_symtab *) %s)\n", + psymtab->user->filename, + host_address_to_string (psymtab->user)); + printf_filtered (" dependencies "); + if (psymtab->number_of_dependencies) + { + int i; + + printf_filtered ("{\n"); + for (i = 0; i < psymtab->number_of_dependencies; i++) + { + struct partial_symtab *dep = psymtab->dependencies[i]; + + /* Note the string concatenation there --- no + comma. */ + printf_filtered (" psymtab %s " + "((struct partial_symtab *) %s)\n", + dep->filename, + host_address_to_string (dep)); + } + printf_filtered (" }\n"); + } + else + printf_filtered ("(none)\n"); + printf_filtered (" }\n"); + } + } - if (printed_objfile_start) - printf_filtered ("}\n"); - } + if (printed_objfile_start) + printf_filtered ("}\n"); + } } /* Check consistency of currently expanded psymtabs vs symtabs. */ static void -maintenance_check_psymtabs (char *ignore, int from_tty) +maintenance_check_psymtabs (const char *ignore, int from_tty) { struct symbol *sym; - struct partial_symbol **psym; struct compunit_symtab *cust = NULL; - struct partial_symtab *ps; const struct blockvector *bv; - struct objfile *objfile; - struct block *b; - int length; - - ALL_PSYMTABS (objfile, ps) - { - struct gdbarch *gdbarch = get_objfile_arch (objfile); - - /* We don't call psymtab_to_symtab here because that may cause symtab - expansion. When debugging a problem it helps if checkers leave - things unchanged. */ - cust = ps->compunit_symtab; + const struct block *b; + int i; - /* First do some checks that don't require the associated symtab. */ - if (ps->texthigh < ps->textlow) + for (objfile *objfile : current_program_space->objfiles ()) + for (partial_symtab *ps : require_partial_symbols (objfile, true)) { - printf_filtered ("Psymtab "); - puts_filtered (ps->filename); - printf_filtered (" covers bad range "); - fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout); - printf_filtered (" - "); - fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout); - printf_filtered ("\n"); - continue; - } + struct gdbarch *gdbarch = objfile->arch (); - /* Now do checks requiring the associated symtab. */ - if (cust == NULL) - continue; - bv = COMPUNIT_BLOCKVECTOR (cust); - b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - psym = objfile->static_psymbols.list + ps->statics_offset; - length = ps->n_static_syms; - while (length--) - { - sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym), - SYMBOL_DOMAIN (*psym)); - if (!sym) + /* We don't call psymtab_to_symtab here because that may cause symtab + expansion. When debugging a problem it helps if checkers leave + things unchanged. */ + cust = ps->get_compunit_symtab (objfile); + + /* First do some checks that don't require the associated symtab. */ + if (ps->text_high (objfile) < ps->text_low (objfile)) { - printf_filtered ("Static symbol `"); - puts_filtered (SYMBOL_LINKAGE_NAME (*psym)); - printf_filtered ("' only found in "); + printf_filtered ("Psymtab "); puts_filtered (ps->filename); - printf_filtered (" psymtab\n"); + printf_filtered (" covers bad range "); + fputs_filtered (paddress (gdbarch, ps->text_low (objfile)), + gdb_stdout); + printf_filtered (" - "); + fputs_filtered (paddress (gdbarch, ps->text_high (objfile)), + gdb_stdout); + printf_filtered ("\n"); + continue; } - psym++; - } - b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - psym = objfile->global_psymbols.list + ps->globals_offset; - length = ps->n_global_syms; - while (length--) - { - sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym), - SYMBOL_DOMAIN (*psym)); - if (!sym) + + /* Now do checks requiring the associated symtab. */ + if (cust == NULL) + continue; + bv = COMPUNIT_BLOCKVECTOR (cust); + b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + partial_symbol **psym + = &objfile->partial_symtabs->static_psymbols[ps->statics_offset]; + for (i = 0; i < ps->n_static_syms; psym++, i++) + { + /* Skip symbols for inlined functions without address. These may + or may not have a match in the full symtab. */ + if ((*psym)->aclass == LOC_BLOCK + && (*psym)->ginfo.value.address == 0) + continue; + + sym = block_lookup_symbol (b, (*psym)->ginfo.search_name (), + symbol_name_match_type::SEARCH_NAME, + (*psym)->domain); + if (!sym) + { + printf_filtered ("Static symbol `"); + puts_filtered ((*psym)->ginfo.linkage_name ()); + printf_filtered ("' only found in "); + puts_filtered (ps->filename); + printf_filtered (" psymtab\n"); + } + } + b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + psym = &objfile->partial_symtabs->global_psymbols[ps->globals_offset]; + for (i = 0; i < ps->n_global_syms; psym++, i++) + { + sym = block_lookup_symbol (b, (*psym)->ginfo.search_name (), + symbol_name_match_type::SEARCH_NAME, + (*psym)->domain); + if (!sym) + { + printf_filtered ("Global symbol `"); + puts_filtered ((*psym)->ginfo.linkage_name ()); + printf_filtered ("' only found in "); + puts_filtered (ps->filename); + printf_filtered (" psymtab\n"); + } + } + if (ps->raw_text_high () != 0 + && (ps->text_low (objfile) < BLOCK_START (b) + || ps->text_high (objfile) > BLOCK_END (b))) { - printf_filtered ("Global symbol `"); - puts_filtered (SYMBOL_LINKAGE_NAME (*psym)); - printf_filtered ("' only found in "); + printf_filtered ("Psymtab "); puts_filtered (ps->filename); - printf_filtered (" psymtab\n"); + printf_filtered (" covers "); + fputs_filtered (paddress (gdbarch, ps->text_low (objfile)), + gdb_stdout); + printf_filtered (" - "); + fputs_filtered (paddress (gdbarch, ps->text_high (objfile)), + gdb_stdout); + printf_filtered (" but symtab covers only "); + fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout); + printf_filtered (" - "); + fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout); + printf_filtered ("\n"); } - psym++; } - if (ps->texthigh != 0 - && (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))) - { - printf_filtered ("Psymtab "); - puts_filtered (ps->filename); - printf_filtered (" covers "); - fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout); - printf_filtered (" - "); - fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout); - printf_filtered (" but symtab covers only "); - fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout); - printf_filtered (" - "); - fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout); - printf_filtered ("\n"); - } - } } - - -extern initialize_file_ftype _initialize_psymtab; - +void _initialize_psymtab (); void -_initialize_psymtab (void) +_initialize_psymtab () { add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\ Print dump of current partial symbol definitions.\n\ -Usage: mt print psymbols [-objfile objfile] [-pc address] [--] [outfile]\n\ - mt print psymbols [-objfile objfile] [-source source] [--] [outfile]\n\ +Usage: mt print psymbols [-objfile OBJFILE] [-pc ADDRESS] [--] [OUTFILE]\n\ + mt print psymbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\ Entries in the partial symbol table are dumped to file OUTFILE,\n\ or the terminal if OUTFILE is unspecified.\n\ If ADDRESS is provided, dump only the file for that address.\n\