#if !defined (SYMTAB_H)
#define SYMTAB_H 1
+#include <array>
#include <vector>
#include <string>
#include "gdb_vecs.h"
struct agent_expr;
struct program_space;
struct language_defn;
-struct probe;
struct common_block;
struct obj_section;
struct cmd_list_element;
+class probe;
struct lookup_name_info;
/* How to match a lookup name against a symbol search name. */
otherwise. If non-NULL, store the matching results in MATCH. */
bool matches (const char *symbol_search_name,
symbol_name_match_type match_type,
- completion_match *match) const;
+ completion_match_result *comp_match_res) const;
/* The Ada-encoded lookup name. */
const std::string &lookup_name () const
/* Create a new object. */
lookup_name_info (std::string name,
symbol_name_match_type match_type,
- bool completion_mode = false)
+ 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))
{}
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; }
+ const bool ignore_parameters () const { return m_ignore_parameters; }
+
+ /* 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,
+ true /* ignore params */);
+ }
/* Get the search name hash for searches in language LANG. */
unsigned int search_name_hash (language lang) const
/* The lookup info as passed to the ctor. */
symbol_name_match_type m_match_type;
bool m_completion_mode;
+ bool m_ignore_parameters;
std::string m_name;
/* Language-specific info. These fields are filled lazily the first
SYMBOL_SEARCH_NAME should be a symbol's "search" name.
- On success and if non-NULL, MATCH is set to point to the symbol
- name as should be presented to the user as a completion match list
- element. In most languages, this is the same as the symbol's
- search name, but in some, like Ada, the display name is dynamically
- computed within the comparison routine. */
+ On success and if non-NULL, COMP_MATCH_RES->match is set to point
+ to the symbol name as should be presented to the user as a
+ completion match list element. In most languages, this is the same
+ as the symbol's search name, but in some, like Ada, the display
+ name is dynamically computed within the comparison routine.
+
+ Also, on success and if non-NULL, COMP_MATCH_RES->match_for_lcd
+ points the part of SYMBOL_SEARCH_NAME that was considered to match
+ LOOKUP_NAME. E.g., in C++, in linespec/wild mode, if the symbol is
+ "foo::function()" and LOOKUP_NAME is "function(", MATCH_FOR_LCD
+ points to "function()" inside SYMBOL_SEARCH_NAME. */
typedef bool (symbol_name_matcher_ftype)
(const char *symbol_search_name,
const lookup_name_info &lookup_name,
- completion_match *match);
+ completion_match_result *comp_match_res);
/* Some of the structures in this file are space critical.
The space-critical structures are:
const struct symbol_register_ops *ops_register;
};
+/* struct symbol has some subclasses. This enum is used to
+ differentiate between them. */
+
+enum symbol_subclass_kind
+{
+ /* Plain struct symbol. */
+ SYMBOL_NONE,
+
+ /* struct template_symbol. */
+ SYMBOL_TEMPLATE,
+
+ /* struct rust_vtable_symbol. */
+ SYMBOL_RUST_VTABLE
+};
+
/* This structure is space critical. See space comments at the top. */
struct symbol
/* Whether this is an inlined function (class LOC_BLOCK only). */
unsigned is_inlined : 1;
- /* True if this is a C++ function symbol with template arguments.
- In this case the symbol is really a "struct template_symbol". */
- unsigned is_cplus_template_function : 1;
+ /* The concrete type of this symbol. */
+
+ ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;
/* Line number of this symbol's definition, except for inlined
functions. For an inlined function (class LOC_BLOCK and
#define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
#define SYMBOL_INLINED(symbol) (symbol)->is_inlined
#define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
- (symbol)->is_cplus_template_function
+ (((symbol)->subclass) == SYMBOL_TEMPLATE)
#define SYMBOL_TYPE(symbol) (symbol)->type
#define SYMBOL_LINE(symbol) (symbol)->line
#define SYMBOL_COMPUTED_OPS(symbol) (SYMBOL_IMPL (symbol).ops_computed)
extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
/* An instance of this type is used to represent a C++ template
- function. It includes a "struct symbol" as a kind of base class;
- users downcast to "struct template_symbol *" when needed. A symbol
- is really of this type iff SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is
- true. */
+ function. A symbol is really of this type iff
+ SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is true. */
-struct template_symbol
+struct template_symbol : public symbol
{
- /* The base class. */
- struct symbol base;
-
/* The number of template arguments. */
int n_template_arguments;
struct symbol **template_arguments;
};
+/* A symbol that represents a Rust virtual table object. */
+
+struct rust_vtable_symbol : public symbol
+{
+ /* The concrete type for which this vtable was created; that is, in
+ "impl Trait for Type", this is "Type". */
+ struct type *concrete_type;
+};
+
\f
/* Each item represents a line-->pc (or the reverse) mapping. This is
somewhat more wasteful of space than one might wish, but since only
extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
+/* Find the symbol at the given address. Returns NULL if no symbol
+ found. Only exact matches for ADDRESS are considered. */
+
+extern struct symbol *find_symbol_at_address (CORE_ADDR);
+
extern int find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
CORE_ADDR *address,
CORE_ADDR *endaddr,
bool explicit_line = false;
/* The probe associated with this symtab_and_line. */
- struct probe *probe = NULL;
+ probe *prob = NULL;
/* If PROBE is not NULL, then this is the objfile in which the probe
originated. */
struct objfile *objfile = NULL;
extern completion_list
make_source_files_completion_list (const char *, const char *);
+/* Return whether SYM is a function/method, as opposed to a data symbol. */
+
+extern bool symbol_is_function_or_method (symbol *sym);
+
+/* Return whether MSYMBOL is a function/method, as opposed to a data
+ symbol */
+
+extern bool symbol_is_function_or_method (minimal_symbol *msymbol);
+
+/* Return whether SYM should be skipped in completion mode MODE. In
+ linespec mode, we're only interested in functions/methods. */
+
+template<typename Symbol>
+static bool
+completion_skip_symbol (complete_symbol_mode mode, Symbol *sym)
+{
+ return (mode == complete_symbol_mode::LINESPEC
+ && !symbol_is_function_or_method (sym));
+}
+
/* symtab.c */
int matching_obj_sections (struct obj_section *, struct obj_section *);
language symbol_language,
const char *symname,
const lookup_name_info &lookup_name,
- const char *sym_text, int sym_text_len,
const char *text, const char *word);
#endif /* !defined(SYMTAB_H) */