#include <array>
#include <vector>
#include <string>
+#include <set>
#include "gdbsupport/gdb_vecs.h"
#include "gdbtypes.h"
#include "gdb_obstack.h"
returns the same value (same pointer) as linkage_name (). */
const char *search_name () const;
+ /* 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
+ be terminated and either already on the objfile's obstack or
+ permanently allocated. */
+ void set_linkage_name (const char *linkage_name)
+ { name = linkage_name; }
+
+ enum language language () const
+ { return m_language; }
+
/* 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
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
#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) \
enum language language,
struct obstack *obstack);
-/* 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
- be terminated and either already on the objfile's obstack or
- permanently allocated. */
-#define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
- (symbol)->name = (linkage_name)
+/* Try to determine the demangled name for a symbol, based on the
+ language of that symbol. If the language is set to language_auto,
+ it will attempt to find any demangling algorithm that works and
+ then set the language appropriately. The returned name is allocated
+ by the demangler and should be xfree'd. */
+
+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,
(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);
+ 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 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) \
extern const char *domain_name (domain_enum);
-/* Searching domains, used for `search_symbols'. Element numbers are
+/* Searching domains, used when searching for symbols. Element numbers are
hardcoded in GDB, check all enum uses before changing it. */
enum search_domain
name = nullptr;
value.ivalue = 0;
language_specific.obstack = nullptr;
- language = language_unknown;
+ m_language = language_unknown;
ada_mangled = 0;
section = 0;
/* GCC 4.8.5 (on CentOS 7) does not correctly compile class-
extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
/* Symbol searching */
-/* Note: struct symbol_search, search_symbols, et.al. are declared here,
- instead of making them local to symtab.c, for gdbtk's sake. */
-/* When using search_symbols, a vector of the following structs is
- returned. */
+/* When using the symbol_searcher struct to search for symbols, a vector of
+ the following structs is returned. */
struct symbol_search
{
symbol_search (int block_, struct symbol *symbol_)
const symbol_search &sym_b);
};
-extern std::vector<symbol_search> search_symbols (const char *,
- enum search_domain,
- const char *,
- int,
- const char **,
- bool);
+/* In order to search for global symbols of a particular kind matching
+ particular regular expressions, create an instance of this structure and
+ call the SEARCH member function. */
+class global_symbol_searcher
+{
+public:
+
+ /* Constructor. */
+ global_symbol_searcher (enum search_domain kind,
+ const char *symbol_name_regexp)
+ : m_kind (kind),
+ m_symbol_name_regexp (symbol_name_regexp)
+ {
+ /* The symbol searching is designed to only find one kind of thing. */
+ gdb_assert (m_kind != ALL_DOMAIN);
+ }
+
+ /* Set the optional regexp that matches against the symbol type. */
+ void set_symbol_type_regexp (const char *regexp)
+ {
+ m_symbol_type_regexp = regexp;
+ }
+
+ /* Set the flag to exclude minsyms from the search results. */
+ void set_exclude_minsyms (bool exclude_minsyms)
+ {
+ 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.
+
+ Within each file the results are sorted locally; each symtab's global
+ and static blocks are separately alphabetized. Duplicate entries are
+ removed. */
+ std::vector<symbol_search> search () const;
+
+ /* The set of source files to search in for matching symbols. This is
+ currently public so that it can be populated after this object has
+ been constructed. */
+ std::vector<const char *> filenames;
+
+private:
+ /* The kind of symbols are we searching for.
+ VARIABLES_DOMAIN - Search all symbols, excluding functions, type
+ names, and constants (enums).
+ FUNCTIONS_DOMAIN - Search all functions..
+ TYPES_DOMAIN - Search all type names.
+ MODULES_DOMAIN - Search all Fortran modules.
+ ALL_DOMAIN - Not valid for this function. */
+ enum search_domain m_kind;
+
+ /* Regular expression to match against the symbol name. */
+ const char *m_symbol_name_regexp = nullptr;
+
+ /* Regular expression to match against the symbol type. */
+ const char *m_symbol_type_regexp = nullptr;
+
+ /* 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)
we return a vector of this type. The first item in the pair is the
(const char *module_regexp, const char *regexp,
const char *type_regexp, search_domain kind);
+/* Convert a global or static symbol SYM (based on BLOCK, which should be
+ either GLOBAL_BLOCK or STATIC_BLOCK) into a string for use in 'info'
+ type commands (e.g. 'info variables', 'info functions', etc). KIND is
+ the type of symbol that was searched for which gave us SYM. */
+
+extern std::string symbol_to_info_string (struct symbol *sym, int block,
+ enum search_domain kind);
+
extern bool treg_matches_sym_type_name (const compiled_regex &treg,
const struct symbol *sym);
projects / deliverable / binutils-gdb.git / blobdiff