struct fn_field *method = &f[signature_id];
const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
- const char *newname = TYPE_NAME (type);
+ const char *newname = type->name ();
/* Does the form of physname indicate that it is the full mangled name
of a constructor (not just the args)? */
return (mangled_name);
}
-/* Set the demangled name of GSYMBOL to NAME. NAME must be already
- correctly allocated. */
+/* See symtab.h. */
void
-symbol_set_demangled_name (struct general_symbol_info *gsymbol,
- const char *name,
- struct obstack *obstack)
+general_symbol_info::set_demangled_name (const char *name,
+ struct obstack *obstack)
{
- if (gsymbol->language () == language_ada)
+ if (language () == language_ada)
{
if (name == NULL)
{
- gsymbol->ada_mangled = 0;
- gsymbol->language_specific.obstack = obstack;
+ ada_mangled = 0;
+ language_specific.obstack = obstack;
}
else
{
- gsymbol->ada_mangled = 1;
- gsymbol->language_specific.demangled_name = name;
+ ada_mangled = 1;
+ language_specific.demangled_name = name;
}
}
else
- gsymbol->language_specific.demangled_name = name;
-}
-
-/* Return the demangled name of GSYMBOL. */
-
-const char *
-symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
-{
- if (gsymbol->language () == language_ada)
- {
- if (!gsymbol->ada_mangled)
- return NULL;
- /* Fall through. */
- }
-
- return gsymbol->language_specific.demangled_name;
+ language_specific.demangled_name = name;
}
\f
|| language == language_objc
|| language == language_fortran)
{
- symbol_set_demangled_name (this, NULL, obstack);
+ set_demangled_name (NULL, obstack);
}
else if (language == language_ada)
{
{
const struct language_defn *lang = language_def (gsymbol->language ());
- language_sniff_from_mangled_name (lang, mangled, &demangled);
+ lang->sniff_from_mangled_name (mangled, &demangled);
return demangled;
}
enum language l = (enum language) i;
const struct language_defn *lang = language_def (l);
- if (language_sniff_from_mangled_name (lang, mangled, &demangled))
+ if (lang->sniff_from_mangled_name (mangled, &demangled))
{
gsymbol->m_language = l;
return demangled;
m_name = obstack_strndup (&per_bfd->storage_obstack,
linkage_name.data (),
linkage_name.length ());
- symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack);
+ set_demangled_name (NULL, &per_bfd->storage_obstack);
return;
}
m_language = (*slot)->language;
m_name = (*slot)->mangled.data ();
- symbol_set_demangled_name (this, (*slot)->demangled.get (),
- &per_bfd->storage_obstack);
+ set_demangled_name ((*slot)->demangled.get (), &per_bfd->storage_obstack);
}
/* See symtab.h. */
case language_go:
case language_objc:
case language_fortran:
- if (symbol_get_demangled_name (this) != NULL)
- return symbol_get_demangled_name (this);
+ case language_rust:
+ if (language_specific.demangled_name != nullptr)
+ return language_specific.demangled_name;
break;
case language_ada:
return ada_decode_symbol (this);
case language_go:
case language_objc:
case language_fortran:
- dem_name = symbol_get_demangled_name (this);
+ case language_rust:
+ dem_name = language_specific.demangled_name;
break;
case language_ada:
dem_name = ada_decode_symbol (this);
static void
set_symbol_cache_size (unsigned int new_size)
{
- struct program_space *pspace;
-
- ALL_PSPACES (pspace)
+ for (struct program_space *pspace : program_spaces)
{
struct symbol_cache *cache = symbol_cache_key.get (pspace);
static void
maintenance_print_symbol_cache (const char *args, int from_tty)
{
- struct program_space *pspace;
-
- ALL_PSPACES (pspace)
+ for (struct program_space *pspace : program_spaces)
{
struct symbol_cache *cache;
static void
maintenance_flush_symbol_cache (const char *args, int from_tty)
{
- struct program_space *pspace;
-
- ALL_PSPACES (pspace)
+ for (struct program_space *pspace : program_spaces)
{
symbol_cache_flush (pspace);
}
static void
maintenance_print_symbol_cache_statistics (const char *args, int from_tty)
{
- struct program_space *pspace;
-
- ALL_PSPACES (pspace)
+ for (struct program_space *pspace : program_spaces)
{
struct symbol_cache *cache;
/* If we were given a non-mangled name, canonicalize it
according to the language (so far only for C++). */
- std::string canon = cp_canonicalize_string (name);
- if (!canon.empty ())
- return storage.swap_string (canon);
+ gdb::unique_xmalloc_ptr<char> canon = cp_canonicalize_string (name);
+ if (canon != nullptr)
+ return storage.set_malloc_ptr (std::move (canon));
}
else if (lang == language_d)
{
unsigned int
search_name_hash (enum language language, const char *search_name)
{
- return language_def (language)->la_search_name_hash (search_name);
+ return language_def (language)->search_name_hash (search_name);
}
/* See symtab.h.
if (symbol_lookup_debug > 1)
{
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = block_objfile (block);
fprintf_unfiltered (gdb_stdlog,
"lookup_language_this (%s, %s (objfile %s))",
/* The type may be a stub. */
type = check_typedef (type);
- for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
+ for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
is_a_field_of_this->type = type;
- is_a_field_of_this->field = &TYPE_FIELD (type, i);
+ is_a_field_of_this->field = &type->field (i);
return 1;
}
}
if (symbol_lookup_debug)
{
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = (block == nullptr
+ ? nullptr : block_objfile (block));
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
/* I'm not really sure that type of this can ever
be typedefed; just be safe. */
t = check_typedef (t);
- if (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+ if (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
t = TYPE_TARGET_TYPE (t);
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
error (_("Internal error: `%s' is not an aggregate"),
langdef->la_name_of_this);
/* See symtab.h. */
-struct objfile *
-lookup_objfile_from_block (const struct block *block)
-{
- if (block == NULL)
- return NULL;
-
- block = block_global_block (block);
- /* Look through all blockvectors. */
- for (objfile *obj : current_program_space->objfiles ())
- {
- for (compunit_symtab *cust : obj->compunits ())
- if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
- GLOBAL_BLOCK))
- {
- if (obj->separate_debug_objfile_backlink)
- obj = obj->separate_debug_objfile_backlink;
-
- return obj;
- }
- }
-
- return NULL;
-}
-
-/* See symtab.h. */
-
struct symbol *
lookup_symbol_in_block (const char *name, symbol_name_match_type match_type,
const struct block *block,
if (symbol_lookup_debug > 1)
{
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = (block == nullptr
+ ? nullptr : block_objfile (block));
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_in_block (%s, %s (objfile %s), %s)",
if (symbol_lookup_debug)
{
- struct objfile *objfile = lookup_objfile_from_block (static_block);
+ struct objfile *objfile = (block == nullptr
+ ? nullptr : block_objfile (block));
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_in_static_block (%s, %s (objfile %s),"
return { sym, global_block };
}
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = nullptr;
+ if (block != nullptr)
+ {
+ objfile = block_objfile (block);
+ if (objfile->separate_debug_objfile_backlink != nullptr)
+ objfile = objfile->separate_debug_objfile_backlink;
+ }
+
block_symbol bs
= lookup_global_or_static_symbol (name, GLOBAL_BLOCK, objfile, domain);
if (better_symbol (sym, bs.symbol, domain) == sym)
struct type *
lookup_transparent_type (const char *name)
{
- return current_language->la_lookup_transparent_type (name);
+ return current_language->lookup_transparent_type (name);
}
/* A helper for basic_lookup_transparent_type that interfaces with the
members. We only want to skip enums
here. */
&& !(SYMBOL_CLASS (sym) == LOC_CONST
- && (TYPE_CODE (SYMBOL_TYPE (sym))
+ && (SYMBOL_TYPE (sym)->code ()
== TYPE_CODE_ENUM))
&& (!treg.has_value ()
|| treg_matches_sym_type_name (*treg, sym)))
For the struct printing case below, things are worse, we force
printing of the ";" in this function, which is going to be wrong
for languages that don't require a ";" between statements. */
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_TYPEDEF)
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_TYPEDEF)
typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);
else
type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
/* See symtab.h. */
-void
+bool
completion_list_add_name (completion_tracker &tracker,
language symbol_language,
const char *symname,
/* Clip symbols that cannot match. */
if (!compare_symbol_name (symname, symbol_language, lookup_name, match_res))
- return;
+ return false;
/* Refresh SYMNAME from the match string. It's potentially
different depending on language. (E.g., on Ada, the match may be
tracker.add_completion (std::move (completion),
&match_res.match_for_lcd, text, word);
}
+
+ return true;
}
/* completion_list_add_name wrapper for struct symbol. */
const lookup_name_info &lookup_name,
const char *text, const char *word)
{
- completion_list_add_name (tracker, sym->language (),
- sym->natural_name (),
- lookup_name, text, word);
+ if (!completion_list_add_name (tracker, sym->language (),
+ sym->natural_name (),
+ lookup_name, text, word))
+ return;
/* C++ function symbols include the parameters within both the msymbol
name and the symbol name. The problem is that the msymbol name will
/* The call to canonicalize returns the empty string if the input
string is already in canonical form, thanks to this we don't
remove the symbol we just added above. */
- std::string str
+ gdb::unique_xmalloc_ptr<char> str
= cp_canonicalize_string_no_typedefs (sym->natural_name ());
- if (!str.empty ())
- tracker.remove_completion (str.c_str ());
+ if (str != nullptr)
+ tracker.remove_completion (str.get ());
}
}
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
{
struct type *t = SYMBOL_TYPE (sym);
- enum type_code c = TYPE_CODE (t);
+ enum type_code c = t->code ();
int j;
if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
- for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+ for (j = TYPE_N_BASECLASSES (t); j < t->num_fields (); j++)
if (TYPE_FIELD_NAME (t, j))
completion_list_add_name (tracker, sym->language (),
TYPE_FIELD_NAME (t, j),
bool
symbol_is_function_or_method (symbol *sym)
{
- switch (TYPE_CODE (SYMBOL_TYPE (sym)))
+ switch (SYMBOL_TYPE (sym)->code ())
{
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
if (code == TYPE_CODE_UNDEF
|| (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
+ && SYMBOL_TYPE (sym)->code () == code))
completion_list_add_symbol (tracker, sym,
lookup_name,
text, word);
sym_text, word);
}
else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
+ && SYMBOL_TYPE (sym)->code () == code)
completion_list_add_symbol (tracker, sym, lookup_name,
sym_text, word);
}
\f
-/* Initialize the symbol SYM, and mark it as being owned by an objfile. */
-
-void
-initialize_objfile_symbol (struct symbol *sym)
-{
- SYMBOL_OBJFILE_OWNED (sym) = 1;
- SYMBOL_SECTION (sym) = -1;
-}
-
-/* Allocate and initialize a new 'struct symbol' on OBJFILE's
- obstack. */
-
-struct symbol *
-allocate_symbol (struct objfile *objfile)
-{
- struct symbol *result = new (&objfile->objfile_obstack) symbol ();
-
- initialize_objfile_symbol (result);
-
- return result;
-}
-
-/* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
- obstack. */
-
-struct template_symbol *
-allocate_template_symbol (struct objfile *objfile)
-{
- struct template_symbol *result;
-
- result = new (&objfile->objfile_obstack) template_symbol ();
- initialize_objfile_symbol (result);
-
- return result;
-}
-
/* See symtab.h. */
struct objfile *
projects / deliverable / binutils-gdb.git / blobdiff