@@ -1376,7 +1376,7 @@ ada_decode_symbol (const struct general_symbol_info *arg)
if (!gsymbol->ada_mangled)
{
- std::string decoded = ada_decode (gsymbol->name);
+ std::string decoded = ada_decode (gsymbol->linkage_name ());
struct obstack *obstack = gsymbol->language_specific.obstack;
gsymbol->ada_mangled = 1;
@@ -135,7 +135,7 @@ add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
struct pending *link;
/* If this is an alias for another symbol, don't add it. */
- if (symbol->name && symbol->name[0] == '#')
+ if (symbol->linkage_name () && symbol->linkage_name ()[0] == '#')
return;
/* We keep PENDINGSIZE symbols in each link of the list. If we
@@ -1568,7 +1568,7 @@ process_coff_symbol (struct coff_symbol *cs,
name = EXTERNAL_NAME (name, objfile->obfd);
sym->set_language (get_current_subfile ()->language,
&objfile->objfile_obstack);
- SYMBOL_SET_NAMES (sym, name, true, objfile);
+ sym->compute_and_set_names (name, true, objfile->per_bfd);
/* default assumptions */
SYMBOL_VALUE (sym) = cs->c_value;
@@ -399,7 +399,7 @@ ctf_add_enum_member_cb (const char *name, int enum_value, void *arg)
OBJSTAT (ccp->of, n_syms++);
sym->set_language (language_c, &ccp->of->objfile_obstack);
- SYMBOL_SET_NAMES (sym, name, false, ccp->of);
+ sym->compute_and_set_names (name, false, ccp->of->per_bfd);
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_TYPE (sym) = fip->ptype;
@@ -428,7 +428,7 @@ new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
OBJSTAT (objfile, n_syms++);
sym->set_language (language_c, &objfile->objfile_obstack);
- SYMBOL_SET_NAMES (sym, name.get (), true, objfile);
+ sym->compute_and_set_names (name.get (), true, objfile->per_bfd);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
@@ -1048,7 +1048,7 @@ ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
if (type)
{
sym = new_symbol (ccp, type, id);
- SYMBOL_SET_NAMES (sym, name, false, ccp->of);
+ sym->compute_and_set_names (name, false, ccp->of->per_bfd);
}
break;
case CTF_K_STRUCT:
@@ -1064,7 +1064,7 @@ ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
SYMBOL_TYPE (sym) = type;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
- SYMBOL_SET_NAMES (sym, name, false, ccp->of);
+ sym->compute_and_set_names (name, false, ccp->of->per_bfd);
add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
break;
default:
@@ -9953,7 +9953,7 @@ fixup_go_packaging (struct dwarf2_cu *cu)
sym = allocate_symbol (objfile);
sym->set_language (language_go, &objfile->objfile_obstack);
- SYMBOL_SET_NAMES (sym, saved_package_name, false, objfile);
+ sym->compute_and_set_names (saved_package_name, false, objfile->per_bfd);
/* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
e.g., "main" finds the "main" module and not C's main(). */
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
@@ -10878,7 +10878,7 @@ dwarf2_compute_name (const char *name,
/* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
but otherwise compute it by typename_concat inside GDB.
FIXME: Actually this is not really true, or at least not always true.
- It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
+ It's all very confusing. compute_and_set_names doesn't try to demangle
Fortran names because there is no mangling standard. So new_symbol
will set the demangled name to the result of dwarf2_full_name, and it is
the demangled name that GDB uses if it exists. */
@@ -21873,7 +21873,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
/* Cache this symbol's name and the name's demangled form (if any). */
sym->set_language (cu->language, &objfile->objfile_obstack);
linkagename = dwarf2_physname (name, die, cu);
- SYMBOL_SET_NAMES (sym, linkagename, false, objfile);
+ sym->compute_and_set_names (linkagename, false, objfile->per_bfd);
/* Fortran does not have mangling standard and the mangling does differ
between gfortran, iFort etc. */
@@ -672,8 +672,8 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
SYMBOL_BLOCK_VALUE (block_name) = new_block;
- block_name->name = obstack_strdup (&objfile->objfile_obstack,
- gdb_block_iter.name.get ());
+ block_name->m_name = obstack_strdup (&objfile->objfile_obstack,
+ gdb_block_iter.name.get ());
BLOCK_FUNCTION (new_block) = block_name;
@@ -1052,7 +1052,7 @@ language_alloc_type_symbol (enum language lang, struct type *type)
gdbarch = TYPE_OWNER (type).gdbarch;
symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
- symbol->name = TYPE_NAME (type);
+ symbol->m_name = TYPE_NAME (type);
symbol->set_language (lang, nullptr);
symbol->owner.arch = gdbarch;
SYMBOL_OBJFILE_OWNED (symbol) = 0;
@@ -4762,7 +4762,7 @@ new_symbol (const char *name)
struct symbol *s = allocate_symbol (mdebugread_objfile);
s->set_language (psymtab_language, &mdebugread_objfile->objfile_obstack);
- SYMBOL_SET_NAMES (s, name, true, mdebugread_objfile);
+ s->compute_and_set_names (name, true, mdebugread_objfile->per_bfd);
return s;
}
@@ -1132,10 +1132,10 @@ minimal_symbol_reader::record_full (gdb::string_view name,
&m_objfile->per_bfd->storage_obstack);
if (copy_name)
- msymbol->name = obstack_strndup (&m_objfile->per_bfd->storage_obstack,
- name.data (), name.size ());
+ msymbol->m_name = obstack_strndup (&m_objfile->per_bfd->storage_obstack,
+ name.data (), name.size ());
else
- msymbol->name = name.data ();
+ msymbol->m_name = name.data ();
SET_MSYMBOL_VALUE_ADDRESS (msymbol, address);
MSYMBOL_SECTION (msymbol) = section;
@@ -1397,22 +1397,23 @@ minimal_symbol_reader::install ()
for (minimal_symbol *msym = start; msym < end; ++msym)
{
size_t idx = msym - msymbols;
- hash_values[idx].name_length = strlen (msym->name);
+ hash_values[idx].name_length = strlen (msym->linkage_name ());
if (!msym->name_set)
{
- /* This will be freed later, by symbol_set_names. */
+ /* This will be freed later, by compute_and_set_names. */
char *demangled_name
- = symbol_find_demangled_name (msym, msym->name);
+ = symbol_find_demangled_name (msym, msym->linkage_name ());
symbol_set_demangled_name
(msym, demangled_name,
&m_objfile->per_bfd->storage_obstack);
msym->name_set = 1;
}
/* This mangled_name_hash computation has to be outside of
- the name_set check, or symbol_set_names below will
+ the name_set check, or compute_and_set_names below will
be called with an invalid hash value. */
hash_values[idx].mangled_name_hash
- = fast_hash (msym->name, hash_values[idx].name_length);
+ = fast_hash (msym->linkage_name (),
+ hash_values[idx].name_length);
hash_values[idx].minsym_hash
= msymbol_hash (msym->linkage_name ());
/* We only use this hash code if the search name differs
@@ -1431,10 +1432,9 @@ minimal_symbol_reader::install ()
for (minimal_symbol *msym = start; msym < end; ++msym)
{
size_t idx = msym - msymbols;
- symbol_set_names
- (msym,
- gdb::string_view(msym->name,
- hash_values[idx].name_length),
+ msym->compute_and_set_names
+ (gdb::string_view (msym->linkage_name (),
+ hash_values[idx].name_length),
false,
m_objfile->per_bfd,
hash_values[idx].mangled_name_hash);
@@ -835,7 +835,7 @@ print_partial_symbols (struct gdbarch *gdbarch, struct objfile *objfile,
while (count-- > 0)
{
QUIT;
- fprintf_filtered (outfile, " `%s'", (*p)->ginfo.name);
+ fprintf_filtered (outfile, " `%s'", (*p)->ginfo.linkage_name ());
if ((*p)->ginfo.demangled_name () != NULL)
{
fprintf_filtered (outfile, " `%s'",
@@ -1534,9 +1534,9 @@ psymbol_hash (const void *addr, int length)
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 symbol_set_names, so
+ /* 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.name, sizeof (psymbol->ginfo.name), h);
+ h = fast_hash (&psymbol->ginfo.m_name, sizeof (psymbol->ginfo.m_name), h);
return h;
}
@@ -1557,9 +1557,9 @@ psymbol_compare (const void *addr1, const void *addr2, int length)
&& 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
+ compute_and_set_names, so there's no need to compare the
contents of the name here. */
- && sym1->ginfo.name == sym2->ginfo.name);
+ && sym1->ginfo.linkage_name () == sym2->ginfo.linkage_name ());
}
/* Helper function, initialises partial symbol structure and stashes
@@ -1585,8 +1585,7 @@ add_psymbol_to_bcache (gdb::string_view name, bool copy_name,
psymbol.domain = domain;
psymbol.aclass = theclass;
psymbol.ginfo.set_language (language, objfile->partial_symtabs->obstack ());
- symbol_set_names (&psymbol.ginfo, name, copy_name,
- objfile->per_bfd);
+ psymbol.ginfo.compute_and_set_names (name, copy_name, objfile->per_bfd);
/* Stash the partial symbol away in the cache. */
return ((struct partial_symbol *)
@@ -2110,7 +2109,8 @@ maintenance_check_psymtabs (const char *ignore, int from_tty)
if (!sym)
{
printf_filtered ("Static symbol `");
- puts_filtered ((*psym)->ginfo.name);
+ /* TODO: Should this be print_name ()? */
+ puts_filtered ((*psym)->ginfo.linkage_name ());
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");
@@ -2128,7 +2128,8 @@ maintenance_check_psymtabs (const char *ignore, int from_tty)
if (!sym)
{
printf_filtered ("Global symbol `");
- puts_filtered ((*psym)->ginfo.name);
+ /* TODO: Should this be print_name ()? */
+ puts_filtered ((*psym)->ginfo.linkage_name ());
printf_filtered ("' only found in ");
puts_filtered (ps->filename);
printf_filtered (" psymtab\n");
@@ -749,14 +749,10 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
new_name = cp_canonicalize_string (name);
}
if (!new_name.empty ())
- {
- SYMBOL_SET_NAMES (sym,
- new_name,
- 1, objfile);
- }
+ sym->compute_and_set_names (new_name, true, objfile->per_bfd);
else
- SYMBOL_SET_NAMES (sym, gdb::string_view (string, p - string), true,
- objfile);
+ sym->compute_and_set_names (gdb::string_view (string, p - string), true,
+ objfile->per_bfd);
if (sym->language () == language_cplus)
cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
@@ -855,19 +855,19 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
so the pointer can be discarded after calling this function. */
void
-symbol_set_names (struct general_symbol_info *gsymbol,
- gdb::string_view linkage_name, bool copy_name,
- struct objfile_per_bfd_storage *per_bfd,
- gdb::optional<hashval_t> hash)
+general_symbol_info::compute_and_set_names (gdb::string_view linkage_name,
+ bool copy_name,
+ objfile_per_bfd_storage *per_bfd,
+ gdb::optional<hashval_t> hash)
{
struct demangled_name_entry **slot;
- if (gsymbol->language () == language_ada)
+ if (language () == language_ada)
{
/* In Ada, we do the symbol lookups using the mangled name, so
we can save some space by not storing the demangled name. */
if (!copy_name)
- gsymbol->name = linkage_name.data ();
+ m_name = linkage_name.data ();
else
{
char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,
@@ -875,9 +875,9 @@ symbol_set_names (struct general_symbol_info *gsymbol,
memcpy (name, linkage_name.data (), linkage_name.length ());
name[linkage_name.length ()] = '\0';
- gsymbol->name = name;
+ m_name = name;
}
- symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
+ symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack);
return;
}
@@ -896,7 +896,7 @@ symbol_set_names (struct general_symbol_info *gsymbol,
if (*slot == NULL
/* A C version of the symbol may have already snuck into the table.
This happens to, e.g., main.init (__go_init_main). Cope. */
- || (gsymbol->language () == language_go && (*slot)->demangled == nullptr))
+ || (language () == language_go && (*slot)->demangled == nullptr))
{
/* A 0-terminated copy of the linkage name. Callers must set COPY_NAME
to true if the string might not be nullterminated. We have to make
@@ -920,9 +920,9 @@ symbol_set_names (struct general_symbol_info *gsymbol,
allocated from the heap and needs to be freed by us, just
like if we called symbol_find_demangled_name here. */
gdb::unique_xmalloc_ptr<char> demangled_name
- (gsymbol->language_specific.demangled_name
- ? const_cast<char *> (gsymbol->language_specific.demangled_name)
- : symbol_find_demangled_name (gsymbol, linkage_name_copy.data ()));
+ (language_specific.demangled_name
+ ? const_cast<char *> (language_specific.demangled_name)
+ : symbol_find_demangled_name (this, linkage_name_copy.data ()));
/* Suppose we have demangled_name==NULL, copy_name==0, and
linkage_name_copy==linkage_name. In this case, we already have the
@@ -957,18 +957,17 @@ symbol_set_names (struct general_symbol_info *gsymbol,
(gdb::string_view (mangled_ptr, linkage_name.length ()));
}
(*slot)->demangled = std::move (demangled_name);
- (*slot)->language = gsymbol->language ();
+ (*slot)->language = language ();
}
- else if (gsymbol->language () == language_unknown
- || gsymbol->language () == language_auto)
- gsymbol->m_language = (*slot)->language;
+ else if (language () == language_unknown || language () == language_auto)
+ m_language = (*slot)->language;
- gsymbol->name = (*slot)->mangled.data ();
+ m_name = (*slot)->mangled.data ();
if ((*slot)->demangled != nullptr)
- symbol_set_demangled_name (gsymbol, (*slot)->demangled.get (),
+ symbol_set_demangled_name (this, (*slot)->demangled.get (),
&per_bfd->storage_obstack);
else
- symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
+ symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack);
}
/* See symtab.h. */
@@ -991,7 +990,7 @@ general_symbol_info::natural_name () const
default:
break;
}
- return name;
+ return linkage_name ();
}
/* See symtab.h. */
@@ -1025,7 +1024,7 @@ const char *
general_symbol_info::search_name () const
{
if (language () == language_ada)
- return name;
+ return linkage_name ();
else
return natural_name ();
}
@@ -1670,7 +1669,8 @@ fixup_section (struct general_symbol_info *ginfo,
e.g. on PowerPC64, where the minimal symbol for a function will
point to the function descriptor, while the debug symbol will
point to the actual function code. */
- msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
+ msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->linkage_name (),
+ objfile);
if (msym)
ginfo->section = MSYMBOL_SECTION (msym);
else
@@ -389,7 +389,7 @@ struct general_symbol_info
and linkage_name () are different. */
const char *linkage_name () const
- { return name; }
+ { return m_name; }
/* Return SYMBOL's "natural" name, i.e. the name that it was called in
the original source code. In languages like C++ where symbols may
@@ -419,11 +419,11 @@ struct general_symbol_info
/* Set just the linkage name of a symbol; do not try to demangle
it. Used for constructs which do not have a mangled name,
- e.g. struct tags. Unlike SYMBOL_SET_NAMES, linkage_name must
+ e.g. struct tags. Unlike compute_and_set_names, linkage_name must
be terminated and either already on the objfile's obstack or
permanently allocated. */
void set_linkage_name (const char *linkage_name)
- { name = linkage_name; }
+ { m_name = linkage_name; }
enum language language () const
{ return m_language; }
@@ -432,13 +432,21 @@ struct general_symbol_info
depending upon the language for the symbol. */
void set_language (enum language language, struct obstack *obstack);
+ /* Set the linkage and natural names of a symbol, by demangling
+ the linkage name. If linkage_name may not be nullterminated,
+ copy_name must be set to true. */
+ void compute_and_set_names (gdb::string_view linkage_name, bool copy_name,
+ struct objfile_per_bfd_storage *per_bfd,
+ gdb::optional<hashval_t> hash
+ = gdb::optional<hashval_t> ());
+
/* Name of the symbol. This is a required field. Storage for the
name is allocated on the objfile_obstack for the associated
objfile. For languages like C++ that make a distinction between
the mangled name and demangled name, this is the mangled
name. */
- const char *name;
+ const char *m_name;
/* Value of the symbol. Which member of this union to use, and what
it means, depends on what kind of symbol this is and its
@@ -544,18 +552,6 @@ extern CORE_ADDR get_symbol_address (const struct symbol *sym);
extern char *symbol_find_demangled_name (struct general_symbol_info *gsymbol,
const char *mangled);
-/* Set the linkage and natural names of a symbol, by demangling
- the linkage name. If linkage_name may not be nullterminated,
- copy_name must be set to true. */
-#define SYMBOL_SET_NAMES(symbol,linkage_name,copy_name,objfile) \
- symbol_set_names ((symbol), linkage_name, copy_name, \
- (objfile)->per_bfd)
-extern void symbol_set_names (struct general_symbol_info *symbol,
- gdb::string_view linkage_name, bool copy_name,
- struct objfile_per_bfd_storage *per_bfd,
- gdb::optional<hashval_t> hash
- = gdb::optional<hashval_t> ());
-
/* Return true if NAME matches the "search" name of SYMBOL, according
to the symbol's language. */
#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
@@ -1092,7 +1088,7 @@ struct symbol : public general_symbol_info, public allocate_on_obstack
{
/* We can't use an initializer list for members of a base class, and
general_symbol_info needs to stay a POD type. */
- name = nullptr;
+ m_name = nullptr;
value.ivalue = 0;
language_specific.obstack = nullptr;
m_language = language_unknown;