+2020-10-17 Tom Tromey <tom@tromey.com>
+
+ * xcoffread.c (xcoff_end_psymtab): Use partial_symtab::empty.
+ (scan_xcoff_symtab): Update.
+ * psymtab.h (class psymtab_storage) <global_psymbols,
+ static_psymbols, current_global_psymbols,
+ current_static_psymbols>: Remove.
+ * psymtab.c (require_partial_symbols, find_pc_sect_psymbol)
+ (match_partial_symbol, lookup_partial_symbol): Update.
+ (print_partial_symbols): Change parameters.
+ (dump_psymtab, recursively_search_psymtabs)
+ (psym_fill_psymbol_map, psym_find_compunit_symtab_by_address)
+ (sort_pst_symbols, partial_symtab::partial_symtab): Update.
+ (concat): Remove.
+ (end_psymtab_common): Simplify.
+ (append_psymbol_to_list): Change parameters.
+ (partial_symtabs::add_psymbol): Rename from add_psymbol_to_list.
+ (init_psymbol_list): Simplify.
+ (maintenance_info_psymtabs, maintenance_check_psymtabs): Update.
+ * psympriv.h (struct partial_symtab) <empty>: New method.
+ <globals_offset, n_global_syms, statics_offset, n_static_syms>:
+ Remove.
+ <global_psymbols, static_psymbols>: New members.
+ <add_psymbol>: New methods.
+ (add_psymbol_to_list): Don't declare.
+ (psymbol_placement): Move earlier.
+ * mdebugread.c (parse_partial_symbols): Update.
+ (handle_psymbol_enumerators): Change parameters.
+ (mdebug_expand_psymtab): Update.
+ * dwarf2/read.c (process_psymtab_comp_unit_reader)
+ (add_partial_symbol): Update.
+ * dwarf2/index-write.c (write_psymbols): Change parameters.
+ (write_one_signatured_type): Update.
+ (recursively_count_psymbols): Update.
+ (recursively_write_psymbols): Update.
+ (class debug_names) <recursively_write_psymbols>: Update.
+ <write_psymbols>: Change parameters.
+ <write_one_signatured_type>: Update.
+ * dbxread.c (read_dbx_symtab): Update.
+ (dbx_end_psymtab): Use partial_symtab::empty.
+ * ctfread.c (struct ctf_context) <pst>: New member.
+ (create_partial_symtab): Set it.
+ (ctf_psymtab_type_cb, ctf_psymtab_var_cb): Update.
+ (scan_partial_symbols): Use the psymtab's context. Update.
+
2020-10-17 Tom Tromey <tom@tromey.com>
* valprint.c (generic_value_print): Remove comment.
{
ctf_file_t *fp;
struct objfile *of;
+ partial_symtab *pst;
struct buildsym_compunit *builder;
};
ccx = XOBNEW (&objfile->objfile_obstack, struct ctf_context);
ccx->fp = cfp;
ccx->of = objfile;
+ ccx->pst = pst;
+ ccx->builder = nullptr;
pst->context = ccx;
return pst;
return 0;
}
- add_psymbol_to_list (name.get (), true,
+ ccp->pst->add_psymbol (name.get (), true,
domain, aclass, section,
psymbol_placement::GLOBAL,
0, language_c, ccp->of);
{
struct ctf_context *ccp = (struct ctf_context *) arg;
- add_psymbol_to_list (name, true,
- VAR_DOMAIN, LOC_STATIC, -1,
- psymbol_placement::GLOBAL,
- 0, language_c, ccp->of);
+ ccp->pst->add_psymbol (name, true,
+ VAR_DOMAIN, LOC_STATIC, -1,
+ psymbol_placement::GLOBAL,
+ 0, language_c, ccp->of);
return 0;
}
static void
scan_partial_symbols (ctf_file_t *cfp, struct objfile *of)
{
- struct ctf_context ccx;
bfd *abfd = of->obfd;
const char *name = bfd_get_filename (abfd);
ctf_psymtab *pst = create_partial_symtab (name, cfp, of);
- ccx.fp = cfp;
- ccx.of = of;
+ struct ctf_context *ccx = pst->context;
- if (ctf_type_iter (cfp, ctf_psymtab_type_cb, &ccx) == CTF_ERR)
+ if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
ctf_errmsg (ctf_errno (cfp)));
- if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, &ccx) == CTF_ERR)
+ if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
ctf_errmsg (ctf_errno (cfp)));
else
aclass = LOC_TYPEDEF;
- add_psymbol_to_list (tname.get (), true,
- tdomain, aclass, -1,
- psymbol_placement::STATIC,
- 0, language_c, of);
+ pst->add_psymbol (tname.get (), true,
+ tdomain, aclass, -1,
+ psymbol_placement::STATIC,
+ 0, language_c, of);
}
end_psymtab_common (of, pst);
switch (p[1])
{
case 'S':
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_STATIC,
- data_sect_index,
- psymbol_placement::STATIC,
- nlist.n_value, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_STATIC,
+ data_sect_index,
+ psymbol_placement::STATIC,
+ nlist.n_value, psymtab_language, objfile);
continue;
case 'G':
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_STATIC,
- data_sect_index,
- psymbol_placement::GLOBAL,
- nlist.n_value, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_STATIC,
+ data_sect_index,
+ psymbol_placement::GLOBAL,
+ nlist.n_value, psymtab_language, objfile);
continue;
case 'T':
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
- true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
p += 1;
}
}
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to
;
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (gdb::string_view (p, q - p), true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC, 0,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (p, q - p), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC, 0,
+ psymtab_language, objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC, 0,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC, 0,
+ psymtab_language, objfile);
continue;
case 'f':
pst->set_text_low (nlist.n_value);
textlow_not_set = 0;
}
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::STATIC,
- nlist.n_value, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
+ nlist.n_value, psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
pst->set_text_low (nlist.n_value);
textlow_not_set = 0;
}
- add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true,
- VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::GLOBAL,
- nlist.n_value, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (sym_name, sym_len), true,
+ VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
+ nlist.n_value, psymtab_language, objfile);
continue;
/* Two things show up here (hopefully); static symbols of
if (num_includes == 0
&& number_dependencies == 0
- && pst->n_global_syms == 0
- && pst->n_static_syms == 0
+ && pst->empty ()
&& has_line_numbers == 0)
{
/* Throw away this psymtab, it's empty. */
static void
write_psymbols (struct mapped_symtab *symtab,
std::unordered_set<partial_symbol *> &psyms_seen,
- struct partial_symbol **psymp,
- int count,
+ const std::vector<partial_symbol *> &symbols,
offset_type cu_index,
int is_static)
{
- for (; count-- > 0; ++psymp)
+ for (partial_symbol *psym : symbols)
{
- struct partial_symbol *psym = *psymp;
const char *name = psym->ginfo.search_name ();
if (psym->ginfo.language () == language_ada)
struct signatured_type *entry = (struct signatured_type *) *slot;
partial_symtab *psymtab = entry->per_cu.v.psymtab;
- write_psymbols (info->symtab,
- info->psyms_seen,
- (info->objfile->partial_symtabs->global_psymbols.data ()
- + psymtab->globals_offset),
- psymtab->n_global_syms, info->cu_index,
+ write_psymbols (info->symtab, info->psyms_seen,
+ psymtab->global_psymbols, info->cu_index,
0);
- write_psymbols (info->symtab,
- info->psyms_seen,
- (info->objfile->partial_symtabs->static_psymbols.data ()
- + psymtab->statics_offset),
- psymtab->n_static_syms, info->cu_index,
+ write_psymbols (info->symtab, info->psyms_seen,
+ psymtab->static_psymbols, info->cu_index,
1);
info->types_list.append_uint (8, BFD_ENDIAN_LITTLE,
recursively_count_psymbols (psymtab->dependencies[i],
psyms_seen);
- psyms_seen += psymtab->n_global_syms;
- psyms_seen += psymtab->n_static_syms;
+ psyms_seen += psymtab->global_psymbols.size ();
+ psyms_seen += psymtab->static_psymbols.size ();
}
/* Recurse into all "included" dependencies and write their symbols as
psymtab->dependencies[i],
symtab, psyms_seen, cu_index);
- write_psymbols (symtab,
- psyms_seen,
- (objfile->partial_symtabs->global_psymbols.data ()
- + psymtab->globals_offset),
- psymtab->n_global_syms, cu_index,
+ write_psymbols (symtab, psyms_seen,
+ psymtab->global_psymbols, cu_index,
0);
- write_psymbols (symtab,
- psyms_seen,
- (objfile->partial_symtabs->static_psymbols.data ()
- + psymtab->statics_offset),
- psymtab->n_static_syms, cu_index,
+ write_psymbols (symtab, psyms_seen,
+ psymtab->static_psymbols, cu_index,
1);
}
recursively_write_psymbols
(objfile, psymtab->dependencies[i], psyms_seen, cu_index);
- write_psymbols (psyms_seen,
- (objfile->partial_symtabs->global_psymbols.data ()
- + psymtab->globals_offset),
- psymtab->n_global_syms, cu_index, false, unit_kind::cu);
- write_psymbols (psyms_seen,
- (objfile->partial_symtabs->static_psymbols.data ()
- + psymtab->statics_offset),
- psymtab->n_static_syms, cu_index, true, unit_kind::cu);
+ write_psymbols (psyms_seen, psymtab->global_psymbols,
+ cu_index, false, unit_kind::cu);
+ write_psymbols (psyms_seen, psymtab->static_psymbols,
+ cu_index, true, unit_kind::cu);
}
/* Return number of bytes the .debug_names section will have. This
/* Call insert for all partial symbols and mark them in PSYMS_SEEN. */
void write_psymbols (std::unordered_set<partial_symbol *> &psyms_seen,
- struct partial_symbol **psymp, int count, int cu_index,
- bool is_static, unit_kind kind)
+ const std::vector<partial_symbol *> &symbols,
+ int cu_index, bool is_static, unit_kind kind)
{
- for (; count-- > 0; ++psymp)
+ for (partial_symbol *psym : symbols)
{
- struct partial_symbol *psym = *psymp;
-
/* Only add a given psymbol once. */
if (psyms_seen.insert (psym).second)
insert (psym, cu_index, is_static, kind);
{
partial_symtab *psymtab = entry->per_cu.v.psymtab;
- write_psymbols (info->psyms_seen,
- (info->objfile->partial_symtabs->global_psymbols.data ()
- + psymtab->globals_offset),
- psymtab->n_global_syms, info->cu_index, false,
- unit_kind::tu);
- write_psymbols (info->psyms_seen,
- (info->objfile->partial_symtabs->static_psymbols.data ()
- + psymtab->statics_offset),
- psymtab->n_static_syms, info->cu_index, true,
- unit_kind::tu);
+ write_psymbols (info->psyms_seen, psymtab->global_psymbols,
+ info->cu_index, false, unit_kind::tu);
+ write_psymbols (info->psyms_seen, psymtab->static_psymbols,
+ info->cu_index, true, unit_kind::tu);
info->types_list.append_uint (dwarf5_offset_size (), m_dwarf5_byte_order,
to_underlying (entry->per_cu.sect_off));
sect_offset_str (per_cu->sect_off),
paddress (gdbarch, pst->text_low (objfile)),
paddress (gdbarch, pst->text_high (objfile)),
- pst->n_global_syms, pst->n_static_syms);
+ (int) pst->global_psymbols.size (),
+ (int) pst->static_psymbols.size ());
}
/* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
&objfile->objfile_obstack);
psymbol.ginfo.set_linkage_name (pdi->linkage_name);
}
- add_psymbol_to_list (psymbol, *where, objfile);
+ cu->per_cu->v.psymtab->add_psymbol (psymbol, *where, objfile);
}
}
static struct linetable *shrink_linetable (struct linetable *);
-static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
- CORE_ADDR);
+static void handle_psymbol_enumerators (struct objfile *, partial_symtab *,
+ FDR *, int, CORE_ADDR);
static const char *mdebug_next_symbol_text (struct objfile *);
\f
switch (p[1])
{
case 'S':
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_STATIC,
- SECT_OFF_DATA (objfile),
- psymbol_placement::STATIC,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::STATIC,
+ sh.value,
+ psymtab_language, objfile);
continue;
case 'G':
/* The addresses in these entries are reported
to be wrong. See the code that reads 'G's
for symtabs. */
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_STATIC,
- SECT_OFF_DATA (objfile),
- psymbol_placement::GLOBAL,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::GLOBAL,
+ sh.value,
+ psymtab_language, objfile);
continue;
case 'T':
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list
+ pst->add_psymbol
(gdb::string_view (namestring, p - namestring),
true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
psymbol_placement::STATIC, 0, psymtab_language,
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list
+ pst->add_psymbol
(gdb::string_view (namestring,
p - namestring),
true, VAR_DOMAIN, LOC_TYPEDEF, -1,
if (p != namestring) /* a name is there, not
just :T... */
{
- add_psymbol_to_list
+ pst->add_psymbol
(gdb::string_view (namestring,
p - namestring),
true, VAR_DOMAIN, LOC_TYPEDEF, -1,
/* Note that the value doesn't matter for
enum constants in psymtabs, just in
symtabs. */
- add_psymbol_to_list (gdb::string_view (p,
- q - p),
- true, VAR_DOMAIN,
- LOC_CONST, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language,
- objfile);
+ pst->add_psymbol (gdb::string_view (p,
+ q - p),
+ true, VAR_DOMAIN,
+ LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language,
+ objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
continue;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
continue;
case 'f':
function_outside_compilation_unit_complaint
(copy.c_str ());
}
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::STATIC,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
+ sh.value,
+ psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
function_outside_compilation_unit_complaint
(copy.c_str ());
}
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::GLOBAL,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
+ sh.value,
+ psymtab_language, objfile);
continue;
/* Two things show up here (hopefully); static
symbol table, and the MAIN__ symbol via the minimal
symbol table. */
if (sh.st == stProc)
- add_psymbol_to_list (sym_name, true,
- VAR_DOMAIN, LOC_BLOCK,
- section,
- psymbol_placement::GLOBAL,
- sh.value, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, LOC_BLOCK,
+ section,
+ psymbol_placement::GLOBAL,
+ sh.value, psymtab_language, objfile);
else
- add_psymbol_to_list (sym_name, true,
- VAR_DOMAIN, LOC_BLOCK,
- section,
- psymbol_placement::STATIC,
- sh.value, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, LOC_BLOCK,
+ section,
+ psymbol_placement::STATIC,
+ sh.value, psymtab_language, objfile);
procaddr = sh.value;
&& sh.iss != 0
&& sh.index != cur_sdx + 2)
{
- add_psymbol_to_list (sym_name, true,
- STRUCT_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
}
- handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
+ handle_psymbol_enumerators (objfile, pst, fh,
+ sh.st, sh.value);
/* Skip over the block. */
new_sdx = sh.index;
continue;
}
/* Use this gdb symbol. */
- add_psymbol_to_list (sym_name, true,
- VAR_DOMAIN, theclass, section,
- psymbol_placement::STATIC,
- sh.value, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, theclass, section,
+ psymbol_placement::STATIC,
+ sh.value, psymtab_language, objfile);
skip:
cur_sdx++; /* Go to next file symbol. */
}
break;
}
char *sym_name = debug_info->ssext + psh->iss;
- add_psymbol_to_list (sym_name, true,
- VAR_DOMAIN, theclass,
- section,
- psymbol_placement::GLOBAL,
- svalue, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, theclass,
+ section,
+ psymbol_placement::GLOBAL,
+ svalue, psymtab_language, objfile);
}
}
partial_symtab *pst_del = objfile->partial_symtabs->psymtabs;
if (pst_del->next == NULL
&& pst_del->number_of_dependencies == 0
- && pst_del->n_global_syms == 0
- && pst_del->n_static_syms == 0)
+ && pst_del->empty ())
objfile->partial_symtabs->discard_psymtab (pst_del);
}
all the enum constants to the partial symbol table. */
static void
-handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
- CORE_ADDR svalue)
+handle_psymbol_enumerators (struct objfile *objfile, partial_symtab *pst,
+ FDR *fh, int stype, CORE_ADDR svalue)
{
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
/* Note that the value doesn't matter for enum constants
in psymtabs, just in symtabs. */
- add_psymbol_to_list (name, true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC, 0,
- psymtab_language, objfile);
+ pst->add_psymbol (name, true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC, 0,
+ psymtab_language, objfile);
ext_sym += external_sym_size;
}
}
/* Do nothing if this is a dummy psymtab. */
- if (pst->n_global_syms == 0 && pst->n_static_syms == 0
- && !pst->text_low_valid && !pst->text_high_valid)
+ if (pst->empty () && !pst->text_low_valid && !pst->text_high_valid)
return;
/* Now read the symbols for this symtab. */
PST_SEARCHED_AND_NOT_FOUND
};
+/* Specify whether a partial psymbol should be allocated on the global
+ list or the static list. */
+
+enum class psymbol_placement
+{
+ STATIC,
+ GLOBAL
+};
+
/* Each source file that has not been fully read in is represented by
a partial_symtab. This contains the information on where in the
executable the debugging symbols for a specific file are, and a
text_high_valid = 1;
}
+ /* Return true if this symtab is empty -- meaning that it contains
+ no symbols. It may still have dependencies. */
+ bool empty () const
+ {
+ return global_psymbols.empty () && static_psymbols.empty ();
+ }
+
+ /* Add a symbol to this partial symbol table of OBJFILE.
+
+ If COPY_NAME is true, make a copy of NAME, otherwise use the passed
+ reference.
+
+ THECLASS is the type of symbol.
+
+ SECTION is the index of the section of OBJFILE in which the symbol is found.
+
+ WHERE determines whether the symbol goes in the list of static or global
+ partial symbols.
+
+ COREADDR is the address of the symbol. For partial symbols that don't have
+ an address, zero is passed.
+
+ LANGUAGE is the language from which the symbol originates. This will
+ influence, amongst other things, how the symbol name is demangled. */
+
+ void add_psymbol (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);
+
+ /* Add a symbol to this partial symbol table of OBJFILE. The psymbol
+ must be fully constructed, and the names must be set and intern'd
+ as appropriate. */
+
+ void add_psymbol (const partial_symbol &psym,
+ psymbol_placement where,
+ struct objfile *objfile);
+
/* Chain of all existing partial symtabs. */
/* Global symbol list. This list will be sorted after readin to
improve access. Binary search will be the usual method of
- finding a symbol within it. globals_offset is an integer offset
- within global_psymbols[]. */
+ finding a symbol within it. */
- int globals_offset = 0;
- int n_global_syms = 0;
+ std::vector<partial_symbol *> global_psymbols;
/* Static symbol list. This list will *not* be sorted after readin;
to find a symbol in it, exhaustive search must be used. This is
reasonable because searches through this list will eventually
lead to either the read in of a files symbols for real (assumed
to take a *lot* of time; check) or an error (and we don't care
- how long errors take). This is an offset and size within
- static_psymbols[]. */
+ how long errors take). */
- int statics_offset = 0;
- int n_static_syms = 0;
+ std::vector<partial_symbol *> static_psymbols;
/* True iff objfile->psymtabs_addrmap is properly populated for this
partial_symtab. For discontiguous overlapping psymtabs is the only usable
void *read_symtab_private = nullptr;
};
-/* Specify whether a partial psymbol should be allocated on the global
- list or the static list. */
-
-enum class psymbol_placement
-{
- STATIC,
- GLOBAL
-};
-
-/* Add a symbol to the partial symbol table of OBJFILE.
-
- If COPY_NAME is true, make a copy of NAME, otherwise use the passed
- reference.
-
- THECLASS is the type of symbol.
-
- SECTION is the index of the section of OBJFILE in which the symbol is found.
-
- WHERE determines whether the symbol goes in the list of static or global
- partial symbols of OBJFILE.
-
- COREADDR is the address of the symbol. For partial symbols that don't have
- an address, zero is passed.
-
- LANGUAGE is the language from which the symbol originates. This will
- influence, amongst other things, how the symbol name is demangled. */
-
-extern void 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);
-
-/* Add a symbol to the partial symbol table of OBJFILE. The psymbol
- must be fully constructed, and the names must be set and intern'd
- as appropriate. */
-
-extern void add_psymbol_to_list (const partial_symbol &psym,
- psymbol_placement where,
- struct objfile *objfile);
-
/* Initialize storage for partial symbols. If partial symbol storage
has already been initialized, this does nothing. TOTAL_SYMBOLS is
an estimate of how many symbols there will be. */
objfile_name (objfile));
(*objfile->sf->sym_read_psymbols) (objfile);
- /* 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));
/* 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 (int i = 0; i < psymtab->n_global_syms; i++)
+ for (partial_symbol *p : psymtab->global_psymbols)
{
- 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)
}
}
- for (int i = 0; i < psymtab->n_static_syms; i++)
+ for (partial_symbol *p : psymtab->static_psymbols)
{
- 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)
{
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 length = (global
+ ? pst->global_psymbols.size ()
+ : pst->static_psymbols.size ());
int do_linear_search = 1;
if (length == 0)
return NULL;
start = (global ?
- &objfile->partial_symtabs->global_psymbols[pst->globals_offset] :
- &objfile->partial_symtabs->static_psymbols[pst->statics_offset]);
+ &pst->global_psymbols[0] :
+ &pst->static_psymbols[0]);
if (global && ordered_compare) /* Can use a binary search. */
{
{
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 length = (global
+ ? pst->global_psymbols.size ()
+ : pst->static_psymbols.size ());
int do_linear_search = 1;
if (length == 0)
return NULL;
start = (global ?
- &objfile->partial_symtabs->global_psymbols[pst->globals_offset] :
- &objfile->partial_symtabs->static_psymbols[pst->statics_offset]);
+ &pst->global_psymbols[0] :
+ &pst->static_psymbols[0]);
if (global) /* This means we can use a binary search. */
{
static void
print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
- struct partial_symbol **p, int count, const char *what,
- struct ui_file *outfile)
+ const std::vector<partial_symbol *> &symbols,
+ const char *what, struct ui_file *outfile)
{
fprintf_filtered (outfile, " %s partial symbols:\n", what);
- while (count-- > 0)
+ for (partial_symbol *p : symbols)
{
QUIT;
- fprintf_filtered (outfile, " `%s'", (*p)->ginfo.linkage_name ());
- if ((*p)->ginfo.demangled_name () != NULL)
+ fprintf_filtered (outfile, " `%s'", p->ginfo.linkage_name ());
+ if (p->ginfo.demangled_name () != NULL)
{
fprintf_filtered (outfile, " `%s'",
- (*p)->ginfo.demangled_name ());
+ p->ginfo.demangled_name ());
}
fputs_filtered (", ", outfile);
- switch ((*p)->domain)
+ switch (p->domain)
{
case UNDEF_DOMAIN:
fputs_filtered ("undefined domain, ", outfile);
fputs_filtered ("<invalid domain>, ", outfile);
break;
}
- switch ((*p)->aclass)
+ switch (p->aclass)
{
case LOC_UNDEF:
fputs_filtered ("undefined", outfile);
break;
}
fputs_filtered (", ", outfile);
- fputs_filtered (paddress (gdbarch, (*p)->unrelocated_address ()), outfile);
+ fputs_filtered (paddress (gdbarch, p->unrelocated_address ()), outfile);
fprintf_filtered (outfile, "\n");
- p++;
}
}
gdb_print_host_address (psymtab->user, outfile);
fprintf_filtered (outfile, "\n");
}
- if (psymtab->n_global_syms > 0)
+ if (!psymtab->global_psymbols.empty ())
{
print_partial_symbols
- (gdbarch, objfile,
- &objfile->partial_symtabs->global_psymbols[psymtab->globals_offset],
- psymtab->n_global_syms, "Global", outfile);
+ (gdbarch, objfile, psymtab->global_psymbols,
+ "Global", outfile);
}
- if (psymtab->n_static_syms > 0)
+ if (!psymtab->static_psymbols.empty ())
{
print_partial_symbols
- (gdbarch, objfile,
- &objfile->partial_symtabs->static_psymbols[psymtab->statics_offset],
- psymtab->n_static_syms, "Static", outfile);
+ (gdbarch, objfile, psymtab->static_psymbols,
+ "Static", outfile);
}
fprintf_filtered (outfile, "\n");
}
}
}
- 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 **gbound = (ps->global_psymbols.data ()
+ + ps->global_psymbols.size ());
+ partial_symbol **sbound = (ps->static_psymbols.data ()
+ + ps->static_psymbols.size ());
partial_symbol **bound = gbound;
/* Go through all of the symbols stored in a partial
symtab in one loop. */
- partial_symbol **psym = (objfile->partial_symtabs->global_psymbols.data ()
- + ps->globals_offset);
+ partial_symbol **psym = ps->global_psymbols.data ();
while (keep_going)
{
if (psym >= bound)
{
- if (bound == gbound && ps->n_static_syms != 0)
+ if (bound == gbound && !ps->static_psymbols.empty ())
{
- psym = (objfile->partial_symtabs->static_psymbols.data ()
- + ps->statics_offset);
+ psym = ps->static_psymbols.data ();
bound = sbound;
}
else
psym_fill_psymbol_map (struct objfile *objfile,
struct partial_symtab *psymtab,
std::set<CORE_ADDR> *seen_addrs,
- const std::vector<partial_symbol *> &symbols,
- int start,
- int length)
+ const std::vector<partial_symbol *> &symbols)
{
- for (int i = 0; i < length; ++i)
+ for (partial_symbol *psym : symbols)
{
- struct partial_symbol *psym = symbols[start + i];
-
if (psym->aclass == LOC_STATIC)
{
CORE_ADDR addr = psym->address (objfile);
{
psym_fill_psymbol_map (objfile, pst,
&seen_addrs,
- objfile->partial_symtabs->global_psymbols,
- pst->globals_offset,
- pst->n_global_syms);
+ pst->global_psymbols);
psym_fill_psymbol_map (objfile, pst,
&seen_addrs,
- objfile->partial_symtabs->static_psymbols,
- pst->statics_offset,
- pst->n_static_syms);
+ pst->static_psymbols);
}
objfile->psymbol_map.shrink_to_fit ();
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);
-
- /* The psymbols for this partial_symtab are currently at the end of the
- vector. */
- auto end = objfile->partial_symtabs->global_psymbols.end ();
-
- std::sort (begin, end, [] (partial_symbol *s1, partial_symbol *s2)
+ std::sort (pst->global_psymbols.begin (),
+ pst->global_psymbols.end (),
+ [] (partial_symbol *s1, partial_symbol *s2)
{
return strcmp_iw_ordered (s1->ginfo.search_name (),
s2->ginfo.search_name ()) < 0;
{
set_text_low (textlow);
set_text_high (raw_text_low ()); /* default */
-
- auto *v1 = new std::vector<partial_symbol *>;
- objfile->partial_symtabs->current_global_psymbols.push_back (v1);
- auto *v2 = new std::vector<partial_symbol *>;
- objfile->partial_symtabs->current_static_psymbols.push_back (v2);
-}
-
-/* Concat vectors V1 and V2. */
-
-static void
-concat (std::vector<partial_symbol *> *v1, std::vector<partial_symbol *> *v2)
-{
- v1->insert (v1->end (), v2->begin (), v2->end ());
- v2->clear ();
}
/* Perform "finishing up" operations of a partial symtab. */
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
- = current_global_psymbols->size ();
- pst->n_static_syms
- = 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;
+ pst->global_psymbols.shrink_to_fit ();
+ pst->static_psymbols.shrink_to_fit ();
sort_pst_symbols (objfile, pst);
}
/* Helper function, adds partial symbol to the given partial symbol list. */
static void
-append_psymbol_to_list (std::vector<partial_symbol *> *list,
+append_psymbol_to_list (std::vector<partial_symbol *> &list,
struct partial_symbol *psym,
struct objfile *objfile)
{
- list->push_back (psym);
+ list.push_back (psym);
OBJSTAT (objfile, n_psyms++);
}
/* See psympriv.h. */
void
-add_psymbol_to_list (const partial_symbol &psymbol,
- psymbol_placement where,
- struct objfile *objfile)
+partial_symtab::add_psymbol (const partial_symbol &psymbol,
+ psymbol_placement where,
+ struct objfile *objfile)
{
bool added;
return;
/* Save pointer to partial symbol in psymtab, growing symtab if needed. */
- std::vector<partial_symbol *> *list
+ std::vector<partial_symbol *> &list
= (where == psymbol_placement::STATIC
- ? objfile->partial_symtabs->current_static_psymbols.back ()
- : objfile->partial_symtabs->current_global_psymbols.back ());
+ ? static_psymbols
+ : global_psymbols);
append_psymbol_to_list (list, psym, objfile);
}
/* See psympriv.h. */
void
-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)
+partial_symtab::add_psymbol (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)
{
struct partial_symbol psymbol;
memset (&psymbol, 0, sizeof (psymbol));
psymbol.ginfo.set_language (language, objfile->partial_symtabs->obstack ());
psymbol.ginfo.compute_and_set_names (name, copy_name, objfile->per_bfd);
- add_psymbol_to_list (psymbol, where, objfile);
+ add_psymbol (psymbol, where, objfile);
}
/* See psympriv.h. */
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)
- {
- /* 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);
- }
}
/* See psympriv.h. */
(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);
- }
+ if (!psymtab->global_psymbols.empty ())
+ printf_filtered
+ ("(* (struct partial_symbol **) %s @ %d)\n",
+ host_address_to_string (psymtab->global_psymbols.data ()),
+ (int) psymtab->global_psymbols.size ());
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);
- }
+ if (!psymtab->static_psymbols.empty ())
+ printf_filtered
+ ("(* (struct partial_symbol **) %s @ %d)\n",
+ host_address_to_string (psymtab->static_psymbols.data ()),
+ (int) psymtab->static_psymbols.size ());
else
printf_filtered ("(none)\n");
if (psymtab->user)
struct compunit_symtab *cust = NULL;
const struct blockvector *bv;
const struct block *b;
- int i;
for (objfile *objfile : current_program_space->objfiles ())
for (partial_symtab *ps : require_partial_symbols (objfile, true))
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++)
+ for (partial_symbol *psym : ps->static_psymbols)
{
/* 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)
+ if (psym->aclass == LOC_BLOCK
+ && psym->ginfo.value.address == 0)
continue;
- sym = block_lookup_symbol (b, (*psym)->ginfo.search_name (),
+ sym = block_lookup_symbol (b, psym->ginfo.search_name (),
symbol_name_match_type::SEARCH_NAME,
- (*psym)->domain);
+ psym->domain);
if (!sym)
{
printf_filtered ("Static symbol `");
- puts_filtered ((*psym)->ginfo.linkage_name ());
+ 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++)
+ for (partial_symbol *psym : ps->global_psymbols)
{
- sym = block_lookup_symbol (b, (*psym)->ginfo.search_name (),
+ sym = block_lookup_symbol (b, psym->ginfo.search_name (),
symbol_name_match_type::SEARCH_NAME,
- (*psym)->domain);
+ psym->domain);
if (!sym)
{
printf_filtered ("Global symbol `");
- puts_filtered ((*psym)->ginfo.linkage_name ());
+ puts_filtered (psym->ginfo.linkage_name ());
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");
psymbol_bcache psymbol_cache;
- /* Vectors of all partial symbols read in from file. The actual data
- is stored in the objfile_obstack. */
-
- std::vector<partial_symbol *> global_psymbols;
- std::vector<partial_symbol *> static_psymbols;
-
- /* Stack of vectors of partial symbols, using during psymtab
- initialization. */
-
- std::vector<std::vector<partial_symbol *>*> current_global_psymbols;
- std::vector<std::vector<partial_symbol *>*> current_static_psymbols;
-
private:
/* The obstack where allocations are made. This is lazily allocated
if (num_includes == 0
&& number_dependencies == 0
- && pst->n_global_syms == 0
- && pst->n_static_syms == 0)
+ && pst->empty ())
{
/* Throw away this psymtab, it's empty. */
/* Empty psymtabs happen as a result of header files which don't have
switch (p[1])
{
case 'S':
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_STATIC,
- SECT_OFF_DATA (objfile),
- psymbol_placement::STATIC,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::STATIC,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
case 'G':
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_STATIC,
- SECT_OFF_DATA (objfile),
- psymbol_placement::GLOBAL,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::GLOBAL,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
case 'T':
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
p += 1;
}
}
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to
;
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (gdb::string_view (p, q - p), true,
- VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (p, q - p), true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_CONST, -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language, objfile);
continue;
case 'f':
function_outside_compilation_unit_complaint (name);
xfree (name);
}
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::STATIC,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
/* Global functions were ignored here, but now they
if (startswith (namestring, "@FIX"))
continue;
- add_psymbol_to_list (gdb::string_view (namestring,
- p - namestring),
- true, VAR_DOMAIN, LOC_BLOCK,
- SECT_OFF_TEXT (objfile),
- psymbol_placement::GLOBAL,
- symbol.n_value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
+ symbol.n_value,
+ psymtab_language, objfile);
continue;
/* Two things show up here (hopefully); static symbols of
projects / binutils-gdb.git / commitdiff