/* Search name matching. This is like FULL, but the search name did
not come from the user; instead it is already a search name
- retrieved from a SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call.
+ retrieved from a search_name () call.
For Ada, this avoids re-encoding an already-encoded search name
(which would potentially incorrectly lowercase letters in the
linkage/search name that should remain uppercase). For C++, it
struct general_symbol_info
{
+ /* Short version as to when to use which name accessor:
+ Use natural_name () to refer to the name of the symbol in the original
+ source code. Use linkage_name () if you want to know what the linker
+ thinks the symbol's name is. Use print_name () for output. Use
+ demangled_name () if you specifically need to know whether natural_name ()
+ and linkage_name () are different. */
+
+ const char *linkage_name () const
+ { return 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
+ be mangled for ease of manipulation by the linker, this is the
+ demangled name. */
+ const char *natural_name () const;
+
+ /* Returns a version of the name of a symbol that is
+ suitable for output. In C++ this is the "demangled" form of the
+ name if demangle is on and the "mangled" form of the name if
+ demangle is off. In other languages this is just the symbol name.
+ The result should never be NULL. Don't use this for internal
+ purposes (e.g. storing in a hashtable): it's only suitable for output. */
+ const char *print_name () const
+ { return demangle ? natural_name () : linkage_name (); }
+
+ /* Return the demangled name for a symbol based on the language for
+ that symbol. If no demangled name exists, return NULL. */
+ const char *demangled_name () const;
+
+ /* Returns the name to be used when sorting and searching symbols.
+ In C++, we search for the demangled form of a name,
+ and so sort symbols accordingly. In Ada, however, we search by mangled
+ name. If there is no distinct demangled name, then this
+ 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; }
+
/* 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
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);
-
-/* Now come lots of name accessor macros. Short version as to when to
- use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
- symbol in the original source code. Use SYMBOL_LINKAGE_NAME if you
- want to know what the linker thinks the symbol's name is. Use
- SYMBOL_PRINT_NAME for output. Use SYMBOL_DEMANGLED_NAME if you
- specifically need to know whether SYMBOL_NATURAL_NAME and
- SYMBOL_LINKAGE_NAME are different. */
-
-/* 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
- be mangled for ease of manipulation by the linker, this is the
- demangled name. */
-
-#define SYMBOL_NATURAL_NAME(symbol) \
- (symbol_natural_name ((symbol)))
-extern const char *symbol_natural_name
- (const struct general_symbol_info *symbol);
-
-/* Return SYMBOL's name from the point of view of the linker. In
- languages like C++ where symbols may be mangled for ease of
- manipulation by the linker, this is the mangled name; otherwise,
- it's the same as SYMBOL_NATURAL_NAME. */
-
-#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->name
-
-/* Return the demangled name for a symbol based on the language for
- that symbol. If no demangled name exists, return NULL. */
-#define SYMBOL_DEMANGLED_NAME(symbol) \
- (symbol_demangled_name ((symbol)))
-extern const char *symbol_demangled_name
- (const struct general_symbol_info *symbol);
-
-/* Macro that returns a version of the name of a symbol that is
- suitable for output. In C++ this is the "demangled" form of the
- name if demangle is on and the "mangled" form of the name if
- demangle is off. In other languages this is just the symbol name.
- The result should never be NULL. Don't use this for internal
- purposes (e.g. storing in a hashtable): it's only suitable for output.
-
- N.B. symbol may be anything inheriting from general_symbol_info,
- e.g., struct symbol or struct minimal_symbol. */
-
-#define SYMBOL_PRINT_NAME(symbol) \
- (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
-
-/* Macro that returns the name to be used when sorting and searching symbols.
- In C++, we search for the demangled form of a name,
- and so sort symbols accordingly. In Ada, however, we search by mangled
- name. If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
- returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
-#define SYMBOL_SEARCH_NAME(symbol) \
- (symbol_search_name (symbol))
-extern const char *symbol_search_name (const struct general_symbol_info *ginfo);
+ 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. */
unsigned maybe_copied : 1;
+ /* Non-zero if this symbol ever had its demangled name set (even if
+ it was set to NULL). */
+ unsigned int name_set : 1;
+
/* Minimal symbols with the same hash key are kept on a linked
list. This is the link. */
? (&(((objfile)->sections)[(symbol)->section])) \
: NULL)
-#define MSYMBOL_NATURAL_NAME(symbol) \
- (symbol_natural_name (symbol))
-#define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->name
-#define MSYMBOL_PRINT_NAME(symbol) \
- (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
-#define MSYMBOL_DEMANGLED_NAME(symbol) \
- (symbol_demangled_name (symbol))
-#define MSYMBOL_SEARCH_NAME(symbol) \
- (symbol_search_name (symbol))
-
#include "minsyms.h"
\f
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
DOMAIN, visible from lexical block BLOCK if non-NULL or from
global/static blocks if BLOCK is NULL. The passed-in search name
should not come from the user; instead it should already be a
- search name as retrieved from a
- SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call. See definition of
+ search name as retrieved from a search_name () call. See definition of
symbol_name_match_type::SEARCH_NAME. Returns the struct symbol
pointer, or NULL if no symbol is found. The symbol's section is
fixed up if necessary. */
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;
+ }
+
+ /* 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;
+
+ /* 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 vector RESULTS. */
+ void add_matching_symbols (objfile *objfile,
+ const gdb::optional<compiled_regex> &preg,
+ const gdb::optional<compiled_regex> &treg,
+ std::vector<symbol_search> *results) const;
+
+ /* Add msymbols from OBJFILE that match PREG and M_KIND, to the
+ results vector RESULTS. */
+ void 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