static struct compunit_symtab *psymtab_to_symtab (struct objfile *objfile,
struct partial_symtab *pst);
+\f
+
+psymtab_storage::psymtab_storage ()
+ : psymbol_cache (psymbol_bcache_init ())
+{
+}
+
+psymtab_storage::~psymtab_storage ()
+{
+ psymbol_bcache_free (psymbol_cache);
+}
+
/* See psymtab.h. */
-objfile_psymtabs
+struct partial_symtab *
+psymtab_storage::allocate_psymtab ()
+{
+ struct partial_symtab *psymtab;
+
+ if (free_psymtabs != nullptr)
+ {
+ psymtab = free_psymtabs;
+ free_psymtabs = psymtab->next;
+ }
+ else
+ psymtab = XOBNEW (obstack (), struct partial_symtab);
+
+ memset (psymtab, 0, sizeof (struct partial_symtab));
+
+ psymtab->next = psymtabs;
+ psymtabs = psymtab;
+
+ return psymtab;
+}
+
+\f
+
+/* See psymtab.h. */
+
+psymtab_storage::partial_symtab_range
require_partial_symbols (struct objfile *objfile, int verbose)
{
if ((objfile->flags & OBJF_PSYMTABS_READ) == 0)
/* Partial symbols list are not expected to changed after this
point. */
- objfile->global_psymbols.shrink_to_fit ();
- objfile->static_psymbols.shrink_to_fit ();
+ 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"),
}
}
- return objfile_psymtabs (objfile);
+ return objfile->psymtabs ();
}
/* Helper function for psym_map_symtabs_matching_filename that
/* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
than the later used TEXTLOW/TEXTHIGH one. */
- if (objfile->psymtabs_addrmap != NULL)
+ if (objfile->partial_symtabs->psymtabs_addrmap != NULL)
{
struct partial_symtab *pst
= ((struct partial_symtab *)
- addrmap_find (objfile->psymtabs_addrmap, pc - baseaddr));
+ addrmap_find (objfile->partial_symtabs->psymtabs_addrmap,
+ pc - baseaddr));
if (pst != NULL)
{
/* FIXME: addrmaps currently do not handle overlayed sections,
cache a bad endaddr. */
for (int i = 0; i < psymtab->n_global_syms; i++)
{
- partial_symbol *p = objfile->global_psymbols[psymtab->globals_offset + i];
+ partial_symbol *p
+ = objfile->partial_symtabs->global_psymbols[psymtab->globals_offset
+ + i];
if (p->domain == VAR_DOMAIN
&& p->aclass == LOC_BLOCK
for (int i = 0; i < psymtab->n_static_syms; i++)
{
- partial_symbol *p = objfile->static_psymbols[psymtab->statics_offset + i];
+ partial_symbol *p
+ = objfile->partial_symtabs->static_psymbols[psymtab->statics_offset
+ + i];
if (p->domain == VAR_DOMAIN
&& p->aclass == LOC_BLOCK
psymbol_name_matches (partial_symbol *psym,
const lookup_name_info &lookup_name)
{
- const language_defn *lang = language_def (psym->language);
+ 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 (symbol_search_name (psym), lookup_name, NULL);
+ return name_match (symbol_search_name (&psym->ginfo), lookup_name, NULL);
}
/* Look in PST for a symbol in DOMAIN whose name matches NAME. Search
lookup_name_info lookup_name (name, match_type);
start = (global ?
- &objfile->global_psymbols[pst->globals_offset] :
- &objfile->static_psymbols[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. */
{
center = bottom + (top - bottom) / 2;
gdb_assert (center < top);
- enum language lang = (*center)->language;
+ enum language lang = (*center)->ginfo.language;
const char *lang_ln
= lookup_name.language_lookup_name (lang).c_str ();
- if (ordered_compare (symbol_search_name (*center), lang_ln) >= 0)
+ if (ordered_compare (symbol_search_name (&(*center)->ginfo),
+ lang_ln) >= 0)
top = center;
else
bottom = center + 1;
while (top <= real_top
&& psymbol_name_matches (*top, lookup_name))
{
- if (symbol_matches_domain ((*top)->language,
+ if (symbol_matches_domain ((*top)->ginfo.language,
(*top)->domain, domain))
return *top;
top++;
{
for (psym = start; psym < start + length; psym++)
{
- if (symbol_matches_domain ((*psym)->language,
+ if (symbol_matches_domain ((*psym)->ginfo.language,
(*psym)->domain, domain)
&& psymbol_name_matches (*psym, lookup_name))
return *psym;
lookup_name_info lookup_name (search_name.get (), symbol_name_match_type::FULL);
start = (global ?
- &objfile->global_psymbols[pst->globals_offset] :
- &objfile->static_psymbols[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. */
{
if (!(center < top))
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
- if (strcmp_iw_ordered (symbol_search_name (*center),
+ if (strcmp_iw_ordered (symbol_search_name (&(*center)->ginfo),
search_name.get ()) >= 0)
{
top = center;
/* 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, lookup_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, lookup_name))
+ while (top <= real_top && symbol_matches_search_name (&(*top)->ginfo,
+ lookup_name))
{
- if (symbol_matches_domain ((*top)->language,
+ if (symbol_matches_domain ((*top)->ginfo.language,
(*top)->domain, domain))
return *top;
top++;
{
for (psym = start; psym < start + length; psym++)
{
- if (symbol_matches_domain ((*psym)->language,
+ if (symbol_matches_domain ((*psym)->ginfo.language,
(*psym)->domain, domain)
- && symbol_matches_search_name (*psym, lookup_name))
+ && symbol_matches_search_name (&(*psym)->ginfo, lookup_name))
return *psym;
}
}
while (count-- > 0)
{
QUIT;
- fprintf_filtered (outfile, " `%s'", (*p)->name);
- if (symbol_demangled_name (*p) != NULL)
+ fprintf_filtered (outfile, " `%s'", (*p)->ginfo.name);
+ if (symbol_demangled_name (&(*p)->ginfo) != NULL)
{
- fprintf_filtered (outfile, " `%s'", symbol_demangled_name (*p));
+ fprintf_filtered (outfile, " `%s'",
+ symbol_demangled_name (&(*p)->ginfo));
}
fputs_filtered (", ", outfile);
switch ((*p)->domain)
}
if (psymtab->n_global_syms > 0)
{
- print_partial_symbols (gdbarch, objfile,
- &objfile->global_psymbols[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,
- &objfile->static_psymbols[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");
}
{
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)
{
}
partial_symbol **gbound
- = objfile->global_psymbols.data () + ps->globals_offset + ps->n_global_syms;
+ = (objfile->partial_symtabs->global_psymbols.data ()
+ + ps->globals_offset + ps->n_global_syms);
partial_symbol **sbound
- = objfile->static_psymbols.data () + ps->statics_offset + ps->n_static_syms;
+ = (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. */
- partial_symbol **psym = objfile->global_psymbols.data () + 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.data () + ps->statics_offset;
+ psym = (objfile->partial_symtabs->static_psymbols.data ()
+ + ps->statics_offset);
bound = sbound;
}
else
|| (domain == TYPES_DOMAIN
&& (*psym)->aclass == LOC_TYPEDEF))
&& psymbol_name_matches (*psym, lookup_name)
- && (sym_matcher == NULL || sym_matcher (symbol_search_name (*psym))))
+ && (sym_matcher == NULL
+ || sym_matcher (symbol_search_name (&(*psym)->ginfo))))
{
/* Found a match, so notify our caller. */
result = PST_SEARCHED_AND_FOUND;
for (partial_symtab *ps : require_partial_symbols (objfile, 1))
ps->searched_flag = PST_NOT_SEARCHED;
- for (partial_symtab *ps : objfile_psymtabs (objfile))
+ for (partial_symtab *ps : objfile->psymtabs ())
{
QUIT;
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
{
psym_fill_psymbol_map (objfile, pst,
&seen_addrs,
- objfile->global_psymbols,
+ objfile->partial_symtabs->global_psymbols,
pst->globals_offset,
pst->n_global_syms);
psym_fill_psymbol_map (objfile, pst,
&seen_addrs,
- objfile->static_psymbols,
+ objfile->partial_symtabs->static_psymbols,
pst->statics_offset,
pst->n_static_syms);
}
sort_pst_symbols (struct objfile *objfile, struct partial_symtab *pst)
{
/* Sort the global list; don't sort the static list. */
- auto begin = objfile->global_psymbols.begin ();
+ auto begin = objfile->partial_symtabs->global_psymbols.begin ();
std::advance (begin, pst->globals_offset);
/* The psymbols for this partial_symtab are currently at the end of the
vector. */
- auto end = objfile->global_psymbols.end ();
+ auto end = objfile->partial_symtabs->global_psymbols.end ();
std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
{
- return strcmp_iw_ordered (symbol_search_name (s1),
- symbol_search_name (s2)) < 0;
+ return strcmp_iw_ordered (symbol_search_name (&s1->ginfo),
+ symbol_search_name (&s2->ginfo)) < 0;
});
}
psymtab = allocate_psymtab (filename, objfile);
psymtab->set_text_low (textlow);
psymtab->set_text_high (psymtab->raw_text_low ()); /* default */
- psymtab->globals_offset = objfile->global_psymbols.size ();
- psymtab->statics_offset = objfile->static_psymbols.size ();
+ psymtab->globals_offset = objfile->partial_symtabs->global_psymbols.size ();
+ psymtab->statics_offset = objfile->partial_symtabs->static_psymbols.size ();
return psymtab;
}
void
end_psymtab_common (struct objfile *objfile, struct partial_symtab *pst)
{
- pst->n_global_syms = objfile->global_psymbols.size () - pst->globals_offset;
- pst->n_static_syms = objfile->static_psymbols.size () - pst->statics_offset;
+ pst->n_global_syms = (objfile->partial_symtabs->global_psymbols.size ()
+ - pst->globals_offset);
+ pst->n_static_syms = (objfile->partial_symtabs->static_psymbols.size ()
+ - pst->statics_offset);
sort_pst_symbols (objfile, pst);
}
{
unsigned long h = 0;
struct partial_symbol *psymbol = (struct partial_symbol *) addr;
- unsigned int lang = psymbol->language;
+ unsigned int lang = psymbol->ginfo.language;
unsigned int domain = psymbol->domain;
unsigned int theclass = psymbol->aclass;
- h = hash_continue (&psymbol->value, sizeof (psymbol->value), h);
+ 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);
/* Note that psymbol names are interned via symbol_set_names, so
there's no need to hash the contents of the name here. */
- h = hash_continue (&psymbol->name,
- sizeof (psymbol->name), h);
+ h = hash_continue (&psymbol->ginfo.name,
+ sizeof (psymbol->ginfo.name), h);
return h;
}
struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
- return (memcmp (&sym1->value, &sym2->value,
- sizeof (sym1->value)) == 0
- && sym1->language == sym2->language
+ return (memcmp (&sym1->ginfo.value, &sym2->ginfo.value,
+ sizeof (sym1->ginfo.value)) == 0
+ && sym1->ginfo.language == sym2->ginfo.language
&& sym1->domain == sym2->domain
&& sym1->aclass == sym2->aclass
/* Note that psymbol names are interned via
symbol_set_names, so there's no need to compare the
contents of the name here. */
- && sym1->name == sym2->name);
+ && sym1->ginfo.name == sym2->ginfo.name);
}
/* Initialize a partial symbol bcache. */
int *added)
{
struct partial_symbol psymbol;
+ memset (&psymbol, 0, sizeof (psymbol));
psymbol.set_unrelocated_address (coreaddr);
- psymbol.section = section;
+ psymbol.ginfo.section = section;
psymbol.domain = domain;
psymbol.aclass = theclass;
-
- memset (&psymbol.language_specific, 0, sizeof (psymbol.language_specific));
- psymbol.ada_mangled = 0;
- symbol_set_language (&psymbol, language, &objfile->objfile_obstack);
- symbol_set_names (&psymbol, name, namelength, copy_name, objfile);
+ symbol_set_language (&psymbol.ginfo, language,
+ objfile->partial_symtabs->obstack ());
+ symbol_set_names (&psymbol.ginfo, name, namelength, copy_name,
+ objfile->per_bfd);
/* Stash the partial symbol away in the cache. */
- return psymbol_bcache_full (&psymbol, objfile->psymbol_cache, added);
+ return psymbol_bcache_full (&psymbol,
+ objfile->partial_symtabs->psymbol_cache,
+ added);
}
/* Helper function, adds partial symbol to the given partial symbol list. */
/* Save pointer to partial symbol in psymtab, growing symtab if needed. */
std::vector<partial_symbol *> *list
= (where == psymbol_placement::STATIC
- ? &objfile->static_psymbols
- : &objfile->global_psymbols);
+ ? &objfile->partial_symtabs->static_psymbols
+ : &objfile->partial_symtabs->global_psymbols);
append_psymbol_to_list (list, psym, objfile);
}
void
init_psymbol_list (struct objfile *objfile, int total_symbols)
{
- if (objfile->global_psymbols.capacity () == 0
- && objfile->static_psymbols.capacity () == 0)
+ if (objfile->partial_symtabs->global_psymbols.capacity () == 0
+ && objfile->partial_symtabs->static_psymbols.capacity () == 0)
{
/* 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->global_psymbols.reserve (total_symbols / 10);
- objfile->static_psymbols.reserve (total_symbols / 10);
+ objfile->partial_symtabs->global_psymbols.reserve (total_symbols / 10);
+ objfile->partial_symtabs->static_psymbols.reserve (total_symbols / 10);
}
}
struct partial_symtab *
allocate_psymtab (const char *filename, struct objfile *objfile)
{
- struct partial_symtab *psymtab;
-
- if (objfile->free_psymtabs)
- {
- psymtab = objfile->free_psymtabs;
- objfile->free_psymtabs = psymtab->next;
- }
- else
- psymtab = XOBNEW (&objfile->objfile_obstack, partial_symtab);
+ struct partial_symtab *psymtab
+ = objfile->partial_symtabs->allocate_psymtab ();
- 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;
- /* Prepend it to the psymtab list for the objfile it belongs to.
- Psymtabs are searched in most recent inserted -> least recent
- inserted order. */
-
- psymtab->next = objfile->psymtabs;
- objfile->psymtabs = psymtab;
-
if (symtab_create_debug)
{
/* Be a bit clever with debugging messages, and don't print objfile
}
void
-discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
+psymtab_storage::discard_psymtab (struct partial_symtab *pst)
{
struct partial_symtab **prev_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;
+ pst->next = free_psymtabs;
+ free_psymtabs = pst;
}
\f
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;
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);
}
}
}
found = 0;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
{
int printed_objfile_header = 0;
int print_for_objfile = 1;
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);
re_comp (regexp);
ALL_PSPACES (pspace)
- for (objfile *objfile : all_objfiles (pspace))
+ for (objfile *objfile : pspace->objfiles ())
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
printf_filtered (" globals ");
if (psymtab->n_global_syms)
{
- auto p
- = &objfile->global_psymbols[psymtab->globals_offset];
+ auto p = &(objfile->partial_symtabs
+ ->global_psymbols[psymtab->globals_offset]);
printf_filtered
("(* (struct partial_symbol **) %s @ %d)\n",
printf_filtered (" statics ");
if (psymtab->n_static_syms)
{
- auto p
- = &objfile->static_psymbols[psymtab->statics_offset];
+ auto p = &(objfile->partial_symtabs
+ ->static_psymbols[psymtab->statics_offset]);
printf_filtered
("(* (struct partial_symbol **) %s @ %d)\n",
struct block *b;
int length;
- for (objfile *objfile : all_objfiles (current_program_space))
+ for (objfile *objfile : current_program_space->objfiles ())
for (partial_symtab *ps : require_partial_symbols (objfile, 1))
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
continue;
bv = COMPUNIT_BLOCKVECTOR (cust);
b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- partial_symbol **psym = &objfile->static_psymbols[ps->statics_offset];
+ partial_symbol **psym
+ = &objfile->partial_symtabs->static_psymbols[ps->statics_offset];
length = ps->n_static_syms;
while (length--)
{
- sym = block_lookup_symbol (b, symbol_search_name (*psym),
+ sym = block_lookup_symbol (b, symbol_search_name (&(*psym)->ginfo),
symbol_name_match_type::SEARCH_NAME,
(*psym)->domain);
if (!sym)
{
printf_filtered ("Static symbol `");
- puts_filtered ((*psym)->name);
+ puts_filtered ((*psym)->ginfo.name);
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");
psym++;
}
b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- psym = &objfile->global_psymbols[ps->globals_offset];
+ psym = &objfile->partial_symtabs->global_psymbols[ps->globals_offset];
length = ps->n_global_syms;
while (length--)
{
- sym = block_lookup_symbol (b, symbol_search_name (*psym),
+ sym = block_lookup_symbol (b, symbol_search_name (&(*psym)->ginfo),
symbol_name_match_type::SEARCH_NAME,
(*psym)->domain);
if (!sym)
{
printf_filtered ("Global symbol `");
- puts_filtered ((*psym)->name);
+ puts_filtered ((*psym)->ginfo.name);
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");