/* Symbol table definitions for GDB.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 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 (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 (std::move (name))
+ 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
short section;
};
-extern void symbol_set_demangled_name (struct general_symbol_info *,
- const char *,
- struct obstack *);
-
-extern const char *symbol_get_demangled_name
- (const struct general_symbol_info *);
-
extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
/* Return the address of SYM. The MAYBE_COPIED flag must be set on
#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,
it will attempt to find any demangling algorithm that works and
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,
- 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 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]))
/* 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) \
{
/* 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;
+ m_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-
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.
-
- 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])
+ something like that. */
-/* 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".
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
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
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.
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. */
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,
+ 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::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,
+ 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;
projects / deliverable / binutils-gdb.git / blobdiff