/* Symbol table definitions for GDB.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include <array>
#include <vector>
#include <string>
+#include <set>
#include "gdbsupport/gdb_vecs.h"
#include "gdbtypes.h"
#include "gdb_obstack.h"
class lookup_name_info final
{
public:
- /* Create a new object. */
- lookup_name_info (std::string name,
+ /* We delete this overload so that the callers are required to
+ explicitly handle the lifetime of the name. */
+ lookup_name_info (std::string &&name,
+ symbol_name_match_type match_type,
+ bool completion_mode = false,
+ bool ignore_parameters = false) = delete;
+
+ /* This overload requires that NAME have a lifetime at least as long
+ as the lifetime of this object. */
+ lookup_name_info (const std::string &name,
symbol_name_match_type match_type,
bool completion_mode = false,
bool ignore_parameters = false)
: m_match_type (match_type),
m_completion_mode (completion_mode),
m_ignore_parameters (ignore_parameters),
- m_name (std::move (name))
+ m_name (name)
+ {}
+
+ /* This overload requires that NAME have a lifetime at least as long
+ as the lifetime of this object. */
+ lookup_name_info (const char *name,
+ symbol_name_match_type match_type,
+ bool completion_mode = false,
+ bool ignore_parameters = false)
+ : m_match_type (match_type),
+ m_completion_mode (completion_mode),
+ m_ignore_parameters (ignore_parameters),
+ m_name (name)
{}
/* Getters. See description of each corresponding field. */
symbol_name_match_type match_type () const { return m_match_type; }
bool completion_mode () const { return m_completion_mode; }
- const std::string &name () const { return m_name; }
+ gdb::string_view name () const { return m_name; }
const bool ignore_parameters () const { return m_ignore_parameters; }
+ /* Like the "name" method but guarantees that the returned string is
+ \0-terminated. */
+ const char *c_str () const
+ {
+ /* Actually this is always guaranteed due to how the class is
+ constructed. */
+ return m_name.data ();
+ }
+
/* Return a version of this lookup name that is usable with
comparisons against symbols have no parameter info, such as
psymbols and GDB index symbols. */
lookup_name_info make_ignore_params () const
{
- return lookup_name_info (m_name, m_match_type, m_completion_mode,
+ return lookup_name_info (c_str (), m_match_type, m_completion_mode,
true /* ignore params */);
}
if (!m_demangled_hashes_p[lang])
{
m_demangled_hashes[lang]
- = ::search_name_hash (lang, language_lookup_name (lang).c_str ());
+ = ::search_name_hash (lang, language_lookup_name (lang));
m_demangled_hashes_p[lang] = true;
}
return m_demangled_hashes[lang];
}
/* Get the search name for searches in language LANG. */
- const std::string &language_lookup_name (language lang) const
+ const char *language_lookup_name (language lang) const
{
switch (lang)
{
case language_ada:
- return ada ().lookup_name ();
+ return ada ().lookup_name ().c_str ();
case language_cplus:
- return cplus ().lookup_name ();
+ return cplus ().lookup_name ().c_str ();
case language_d:
- return d ().lookup_name ();
+ return d ().lookup_name ().c_str ();
case language_go:
- return go ().lookup_name ();
+ return go ().lookup_name ().c_str ();
default:
- return m_name;
+ return m_name.data ();
}
}
symbol_name_match_type m_match_type;
bool m_completion_mode;
bool m_ignore_parameters;
- std::string m_name;
+ gdb::string_view m_name;
/* Language-specific info. These fields are filled lazily the first
time a lookup is done in the corresponding language. They're
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
/* 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; }
+
+ /* Set the demangled name of this symbol to NAME. NAME must be
+ already correctly allocated. If the symbol's language is Ada,
+ then the name is ignored and the obstack is set. */
+ void set_demangled_name (const char *name, struct obstack *obstack);
+
+ enum language language () const
+ { return m_language; }
+
+ /* Initializes the language dependent portion of a symbol
+ 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
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
This is used to select one of the fields from the language specific
union above. */
- ENUM_BITFIELD(language) language : LANGUAGE_BITS;
+ ENUM_BITFIELD(language) m_language : LANGUAGE_BITS;
/* This is only used by Ada. If set, then the 'demangled_name' field
of language_specific is valid. Otherwise, the 'obstack' field is
section_offsets for this objfile. Negative means that the symbol
does not get relocated relative to a section. */
- short section;
-};
+ short m_section;
+
+ /* Set the index into the obj_section list (within the containing
+ objfile) for the section that contains this symbol. See M_SECTION
+ for more details. */
+
+ void set_section_index (short idx)
+ { m_section = idx; }
+
+ /* Return the index into the obj_section list (within the containing
+ objfile) for the section that contains this symbol. See M_SECTION
+ for more details. */
+
+ short section_index () const
+ { return m_section; }
-extern void symbol_set_demangled_name (struct general_symbol_info *,
- const char *,
- struct obstack *);
+ /* Return the obj_section from OBJFILE for this symbol. The symbol
+ returned is based on the SECTION member variable, and can be nullptr
+ if SECTION is negative. */
-extern const char *symbol_get_demangled_name
- (const struct general_symbol_info *);
+ struct obj_section *obj_section (const struct objfile *objfile) const;
+};
extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
#define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->value.common_block
#define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
#define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
-#define SYMBOL_LANGUAGE(symbol) (symbol)->language
-#define SYMBOL_SECTION(symbol) (symbol)->section
-#define SYMBOL_OBJ_SECTION(objfile, symbol) \
- (((symbol)->section >= 0) \
- ? (&(((objfile)->sections)[(symbol)->section])) \
- : NULL)
-
-/* Initializes the language dependent portion of a symbol
- depending upon the language for the symbol. */
-#define SYMBOL_SET_LANGUAGE(symbol,language,obstack) \
- (symbol_set_language ((symbol), (language), (obstack)))
-extern void symbol_set_language (struct general_symbol_info *symbol,
- enum language language,
- struct obstack *obstack);
/* Try to determine the demangled name for a symbol, based on the
language of that symbol. If the language is set to language_auto,
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);
-
/* Return true if NAME matches the "search" name of SYMBOL, according
to the symbol's language. */
#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \
(((symbol)->maybe_copied) ? get_msymbol_address (objfile, symbol) \
: ((symbol)->value.address \
- + ANOFFSET ((objfile)->section_offsets, ((symbol)->section))))
+ + (objfile)->section_offsets[(symbol)->section_index ()]))
/* For a bound minsym, we can easily compute the address directly. */
#define BMSYMBOL_VALUE_ADDRESS(symbol) \
MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
#define MSYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
#define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
#define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
-#define MSYMBOL_LANGUAGE(symbol) (symbol)->language
-#define MSYMBOL_SECTION(symbol) (symbol)->section
-#define MSYMBOL_OBJ_SECTION(objfile, symbol) \
- (((symbol)->section >= 0) \
- ? (&(((objfile)->sections)[(symbol)->section])) \
- : NULL)
#include "minsyms.h"
void (*generate_c_location) (struct symbol *symbol, string_file *stream,
struct gdbarch *gdbarch,
- unsigned char *registers_used,
+ std::vector<bool> ®isters_used,
CORE_ADDR pc, const char *result_name);
};
/* Class-initialization of bitfields is only allowed in C++20. */
: domain (UNDEF_DOMAIN),
aclass_index (0),
- is_objfile_owned (0),
+ is_objfile_owned (1),
is_argument (0),
is_inlined (0),
maybe_copied (0),
subclass (SYMBOL_NONE)
{
/* 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;
+ general_symbol_info needs to stay a POD type. */
+ m_name = nullptr;
value.ivalue = 0;
language_specific.obstack = nullptr;
- language = language_unknown;
+ m_language = language_unknown;
ada_mangled = 0;
- section = 0;
+ m_section = -1;
/* GCC 4.8.5 (on CentOS 7) does not correctly compile class-
- initialization of unions, so we initialize it manually here. */
+ initialization of unions, so we initialize it manually here. */
owner.symtab = nullptr;
}
+ symbol (const symbol &) = default;
+ symbol &operator= (const symbol &) = default;
+
/* Data type of value */
struct type *type = nullptr;
struct linetable_entry
{
+ /* The line number for this entry. */
int line;
+
+ /* True if this PC is a good location to place a breakpoint for LINE. */
+ unsigned is_stmt : 1;
+
+ /* The address for this entry. */
CORE_ADDR pc;
};
};
/* How to relocate the symbols from each section in a symbol file.
- Each struct contains an array of offsets.
The ordering and meaning of the offsets is file-type-dependent;
typically it is indexed by section numbers or symbol types or
- something like that.
+ something like that. */
- To give us flexibility in changing the internal representation
- of these offsets, the ANOFFSET macro must be used to insert and
- extract offset values in the struct. */
-
-struct section_offsets
-{
- CORE_ADDR offsets[1]; /* As many as needed. */
-};
-
-#define ANOFFSET(secoff, whichone) \
- ((whichone == -1) \
- ? (internal_error (__FILE__, __LINE__, \
- _("Section index is uninitialized")), -1) \
- : secoff->offsets[whichone])
-
-/* The size of a section_offsets table for N sections. */
-#define SIZEOF_N_SECTION_OFFSETS(n) \
- (sizeof (struct section_offsets) \
- + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
+typedef std::vector<CORE_ADDR> section_offsets;
/* Each source file or header is represented by a struct symtab.
The name "symtab" is historical, another name for it is "filetab".
This is recorded as:
objfile -> foo.c(cu) -> bar.c(cu) -> NULL
- | |
- v v
- foo.c bar.c
- | |
- v v
- foo1.h foo1.h
- | |
- v v
- foo2.h bar.h
- | |
- v v
- NULL NULL
+ | |
+ v v
+ foo.c bar.c
+ | |
+ v v
+ foo1.h foo1.h
+ | |
+ v v
+ foo2.h bar.h
+ | |
+ v v
+ NULL NULL
where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
and the files foo.c, etc. are struct symtab objects. */
extern enum language compunit_language (const struct compunit_symtab *cust);
+/* Return true if this symtab is the "main" symtab of its compunit_symtab. */
+
+static inline bool
+is_main_symtab_of_compunit_symtab (struct symtab *symtab)
+{
+ return symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab));
+}
\f
/* The virtual function table is now an array of structures which have the
const struct block *block,
domain_enum domain);
-/* A default version of lookup_symbol_nonlocal for use by languages
- that can't think of anything better to do.
- This implements the C lookup rules. */
-
-extern struct block_symbol
- basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
- const char *,
- const struct block *,
- const domain_enum);
-
/* Some helper functions for languages that need to write their own
lookup_symbol_nonlocal functions. */
CORE_ADDR *address, CORE_ADDR *endaddr,
const struct block **block = nullptr);
+/* Like find_pc_partial_function, above, but returns the underlying
+ general_symbol_info (rather than the name) as an out parameter. */
+
+extern bool find_pc_partial_function_sym
+ (CORE_ADDR pc, const general_symbol_info **sym,
+ CORE_ADDR *address, CORE_ADDR *endaddr,
+ const struct block **block = nullptr);
+
/* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are
set to start and end addresses of the range containing the entry pc.
bool explicit_pc = false;
bool explicit_line = false;
+ /* If the line number information is valid, then this indicates if this
+ line table entry had the is-stmt flag set or not. */
+ bool is_stmt = false;
+
/* The probe associated with this symtab_and_line. */
probe *prob = NULL;
/* If PROBE is not NULL, then this is the objfile in which the probe
symbol_name_match_type name_match_type,
const char *text, const char *word, const char *break_on,
enum type_code code);
-extern void default_collect_symbol_completion_matches
- (completion_tracker &tracker,
- complete_symbol_mode,
- symbol_name_match_type name_match_type,
- const char *,
- const char *,
- enum type_code);
extern void collect_symbol_completion_matches
(completion_tracker &tracker,
complete_symbol_mode mode,
m_exclude_minsyms = exclude_minsyms;
}
+ /* Set the maximum number of search results to be returned. */
+ void set_max_search_results (size_t max_search_results)
+ {
+ m_max_search_results = max_search_results;
+ }
+
/* Search the symbols from all objfiles in the current program space
looking for matches as defined by the current state of this object.
private:
/* The kind of symbols are we searching for.
VARIABLES_DOMAIN - Search all symbols, excluding functions, type
- names, and constants (enums).
+ names, and constants (enums).
FUNCTIONS_DOMAIN - Search all functions..
TYPES_DOMAIN - Search all type names.
MODULES_DOMAIN - Search all Fortran modules.
/* When this flag is false then minsyms that match M_SYMBOL_REGEXP will
be included in the results, otherwise they are excluded. */
bool m_exclude_minsyms = false;
+
+ /* Maximum number of search results. We currently impose a hard limit
+ of SIZE_MAX, there is no "unlimited". */
+ size_t m_max_search_results = SIZE_MAX;
+
+ /* Expand symtabs in OBJFILE that match PREG, are of type M_KIND. Return
+ true if any msymbols were seen that we should later consider adding to
+ the results list. */
+ bool expand_symtabs (objfile *objfile,
+ const gdb::optional<compiled_regex> &preg) const;
+
+ /* Add symbols from symtabs in OBJFILE that match PREG, and TREG, and are
+ of type M_KIND, to the results set RESULTS_SET. Return false if we
+ stop adding results early due to having already found too many results
+ (based on M_MAX_SEARCH_RESULTS limit), otherwise return true.
+ Returning true does not indicate that any results were added, just
+ that we didn't _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
+ bool add_matching_symbols (objfile *objfile,
+ const gdb::optional<compiled_regex> &preg,
+ const gdb::optional<compiled_regex> &treg,
+ std::set<symbol_search> *result_set) const;
+
+ /* Add msymbols from OBJFILE that match PREG and M_KIND, to the results
+ vector RESULTS. Return false if we stop adding results early due to
+ having already found too many results (based on max search results
+ limit M_MAX_SEARCH_RESULTS), otherwise return true. Returning true
+ does not indicate that any results were added, just that we didn't
+ _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
+ bool add_matching_msymbols (objfile *objfile,
+ const gdb::optional<compiled_regex> &preg,
+ std::vector<symbol_search> *results) const;
+
+ /* Return true if MSYMBOL is of type KIND. */
+ static bool is_suitable_msymbol (const enum search_domain kind,
+ const minimal_symbol *msymbol);
};
/* When searching for Fortran symbols within modules (functions/variables)
void fixup_section (struct general_symbol_info *ginfo,
CORE_ADDR addr, struct objfile *objfile);
-/* Look up objfile containing BLOCK. */
-
-struct objfile *lookup_objfile_from_block (const struct block *block);
-
extern unsigned int symtab_create_debug;
extern unsigned int symbol_lookup_debug;
/* Storage type used by demangle_for_lookup. demangle_for_lookup
either returns a const char * pointer that points to either of the
fields of this type, or a pointer to the input NAME. This is done
- this way because the underlying functions that demangle_for_lookup
- calls either return a std::string (e.g., cp_canonicalize_string) or
- a malloc'ed buffer (libiberty's demangled), and we want to avoid
- unnecessary reallocation/string copying. */
+ this way to avoid depending on the precise details of the storage
+ for the string. */
class demangle_result_storage
{
public:
- /* Swap the std::string storage with STR, and return a pointer to
- the beginning of the new string. */
- const char *swap_string (std::string &str)
+ /* Swap the malloc storage to STR, and return a pointer to the
+ beginning of the new string. */
+ const char *set_malloc_ptr (gdb::unique_xmalloc_ptr<char> &&str)
{
- std::swap (m_string, str);
- return m_string.c_str ();
+ m_malloc = std::move (str);
+ return m_malloc.get ();
}
/* Set the malloc storage to now point at PTR. Any previous malloc
private:
/* The storage. */
- std::string m_string;
gdb::unique_xmalloc_ptr<char> m_malloc;
};
demangle_for_lookup (const char *name, enum language lang,
demangle_result_storage &storage);
-struct symbol *allocate_symbol (struct objfile *);
-
-void initialize_objfile_symbol (struct symbol *);
-
-struct template_symbol *allocate_template_symbol (struct objfile *);
-
/* Test to see if the symbol of language SYMBOL_LANGUAGE specified by
SYMNAME (which is already demangled for C++ symbols) matches
SYM_TEXT in the first SYM_TEXT_LEN characters. If so, add it to
- the current completion list. */
-void completion_list_add_name (completion_tracker &tracker,
+ the current completion list and return true. Otherwise, return
+ false. */
+bool completion_list_add_name (completion_tracker &tracker,
language symbol_language,
const char *symname,
const lookup_name_info &lookup_name,
std::vector<bound_minimal_symbol> m_minimal_symbols;
};
+/* Class used to encapsulate the filename filtering for the "info sources"
+ command. */
+
+struct info_sources_filter
+{
+ /* If filename filtering is being used (see M_C_REGEXP) then which part
+ of the filename is being filtered against? */
+ enum class match_on
+ {
+ /* Match against the full filename. */
+ FULLNAME,
+
+ /* Match only against the directory part of the full filename. */
+ DIRNAME,
+
+ /* Match only against the basename part of the full filename. */
+ BASENAME
+ };
+
+ /* Create a filter of MATCH_TYPE using regular expression REGEXP. If
+ REGEXP is nullptr then all files will match the filter and MATCH_TYPE
+ is ignored.
+
+ The string pointed too by REGEXP must remain live and unchanged for
+ this lifetime of this object as the object only retains a copy of the
+ pointer. */
+ info_sources_filter (match_on match_type, const char *regexp);
+
+ DISABLE_COPY_AND_ASSIGN (info_sources_filter);
+
+ /* Does FULLNAME match the filter defined by this object, return true if
+ it does, otherwise, return false. If there is no filtering defined
+ then this function will always return true. */
+ bool matches (const char *fullname) const;
+
+private:
+
+ /* The type of filtering in place. */
+ match_on m_match_type;
+
+ /* Points to the original regexp used to create this filter. */
+ const char *m_regexp;
+
+ /* A compiled version of M_REGEXP. This object is only given a value if
+ M_REGEXP is not nullptr and is not the empty string. */
+ gdb::optional<compiled_regex> m_c_regexp;
+};
+
+/* Perform the core of the 'info sources' command.
+
+ FILTER is used to perform regular expression based filtering on the
+ source files that will be displayed.
+
+ Output is written to UIOUT in CLI or MI style as appropriate. */
+
+extern void info_sources_worker (struct ui_out *uiout,
+ bool group_by_objfile,
+ const info_sources_filter &filter);
+
#endif /* !defined(SYMTAB_H) */