mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-27 03:51:15 +08:00
6829683679
quick_symbol_functions::relocated is only needed for psymtabs, and there it is only needed for Rust. However, because we've switched the DWARF reader away from psymtabs, this means there's no longer a need for this method at all.
233 lines
9.2 KiB
C++
233 lines
9.2 KiB
C++
/* "Quick" symbol functions
|
|
|
|
Copyright (C) 2021-2022 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef GDB_QUICK_SYMBOL_H
|
|
#define GDB_QUICK_SYMBOL_H
|
|
|
|
/* Like block_enum, but used as flags to pass to lookup functions. */
|
|
|
|
enum block_search_flag_values
|
|
{
|
|
SEARCH_GLOBAL_BLOCK = 1,
|
|
SEARCH_STATIC_BLOCK = 2
|
|
};
|
|
|
|
DEF_ENUM_FLAGS_TYPE (enum block_search_flag_values, block_search_flags);
|
|
|
|
/* Comparison function for symbol look ups. */
|
|
|
|
typedef int (symbol_compare_ftype) (const char *string1,
|
|
const char *string2);
|
|
|
|
/* Callback for quick_symbol_functions->map_symbol_filenames. */
|
|
|
|
typedef void (symbol_filename_ftype) (const char *filename,
|
|
const char *fullname);
|
|
|
|
/* Callback for quick_symbol_functions->expand_symtabs_matching
|
|
to match a file name. */
|
|
|
|
typedef bool (expand_symtabs_file_matcher_ftype) (const char *filename,
|
|
bool basenames);
|
|
|
|
/* Callback for quick_symbol_functions->expand_symtabs_matching
|
|
to match a symbol name. */
|
|
|
|
typedef bool (expand_symtabs_symbol_matcher_ftype) (const char *name);
|
|
|
|
/* Callback for quick_symbol_functions->expand_symtabs_matching
|
|
to be called after a symtab has been expanded. If this returns
|
|
true, more symtabs are checked; if it returns false, iteration
|
|
stops. */
|
|
|
|
typedef bool (expand_symtabs_exp_notify_ftype) (compunit_symtab *symtab);
|
|
|
|
/* The "quick" symbol functions exist so that symbol readers can
|
|
avoiding an initial read of all the symbols. For example, symbol
|
|
readers might choose to use the "partial symbol table" utilities,
|
|
which is one implementation of the quick symbol functions.
|
|
|
|
The quick symbol functions are generally opaque: the underlying
|
|
representation is hidden from the caller.
|
|
|
|
In general, these functions should only look at whatever special
|
|
index the symbol reader creates -- looking through the symbol
|
|
tables themselves is handled by generic code. If a function is
|
|
defined as returning a "symbol table", this means that the function
|
|
should only return a newly-created symbol table; it should not
|
|
examine pre-existing ones.
|
|
|
|
The exact list of functions here was determined in an ad hoc way
|
|
based on gdb's history. */
|
|
|
|
struct quick_symbol_functions
|
|
{
|
|
virtual ~quick_symbol_functions ()
|
|
{
|
|
}
|
|
|
|
/* Return true if this objfile has any "partial" symbols
|
|
available. */
|
|
virtual bool has_symbols (struct objfile *objfile) = 0;
|
|
|
|
/* Return true if OBJFILE has any unexpanded symtabs. A return value of
|
|
false indicates there are no unexpanded symtabs, this might mean that
|
|
all of the symtabs have been expanded (full debug has been read in),
|
|
or it might been that OBJFILE has no debug information. */
|
|
virtual bool has_unexpanded_symtabs (struct objfile *objfile) = 0;
|
|
|
|
/* Return the symbol table for the "last" file appearing in
|
|
OBJFILE. */
|
|
virtual struct symtab *find_last_source_symtab (struct objfile *objfile) = 0;
|
|
|
|
/* Forget all cached full file names for OBJFILE. */
|
|
virtual void forget_cached_source_info (struct objfile *objfile) = 0;
|
|
|
|
/* Check to see if the global symbol is defined in a "partial" symbol table
|
|
of OBJFILE. NAME is the name of the symbol to look for. DOMAIN
|
|
indicates what sort of symbol to search for.
|
|
|
|
If found, sets *symbol_found_p to true and returns the symbol language.
|
|
defined, or NULL if no such symbol table exists. */
|
|
virtual enum language lookup_global_symbol_language
|
|
(struct objfile *objfile,
|
|
const char *name,
|
|
domain_enum domain,
|
|
bool *symbol_found_p) = 0;
|
|
|
|
/* Print statistics about any indices loaded for OBJFILE. The
|
|
statistics should be printed to gdb_stdout. This is used for
|
|
"maint print statistics". Statistics are printed in two
|
|
sections. PRINT_BCACHE is false when printing the first section
|
|
of general statistics, and true when printing bcache statistics. */
|
|
virtual void print_stats (struct objfile *objfile, bool print_bcache) = 0;
|
|
|
|
/* Dump any indices loaded for OBJFILE. The dump should go to
|
|
gdb_stdout. This is used for "maint print objfiles". */
|
|
virtual void dump (struct objfile *objfile) = 0;
|
|
|
|
/* Read all symbol tables associated with OBJFILE. */
|
|
virtual void expand_all_symtabs (struct objfile *objfile) = 0;
|
|
|
|
/* Find global or static symbols in all tables that are in DOMAIN
|
|
and for which MATCH (symbol name, NAME) == 0, reading in partial
|
|
symbol tables as needed. Look through global symbols if GLOBAL
|
|
and otherwise static symbols.
|
|
|
|
MATCH must be weaker than strcmp_iw_ordered in the sense that
|
|
strcmp_iw_ordered(x,y) == 0 --> MATCH(x,y) == 0. ORDERED_COMPARE,
|
|
if non-null, must be an ordering relation compatible with
|
|
strcmp_iw_ordered in the sense that
|
|
strcmp_iw_ordered(x,y) == 0 --> ORDERED_COMPARE(x,y) == 0
|
|
and
|
|
strcmp_iw_ordered(x,y) <= 0 --> ORDERED_COMPARE(x,y) <= 0
|
|
(allowing strcmp_iw_ordered(x,y) < 0 while ORDERED_COMPARE(x, y) == 0).
|
|
*/
|
|
|
|
virtual void expand_matching_symbols
|
|
(struct objfile *,
|
|
const lookup_name_info &lookup_name,
|
|
domain_enum domain,
|
|
int global,
|
|
symbol_compare_ftype *ordered_compare) = 0;
|
|
|
|
/* Expand all symbol tables in OBJFILE matching some criteria.
|
|
|
|
FILE_MATCHER is called for each file in OBJFILE. The file name
|
|
is passed to it. If the matcher returns false, the file is
|
|
skipped. If FILE_MATCHER is NULL the file is not skipped. If
|
|
BASENAMES is true the matcher should consider only file base
|
|
names (the passed file name is already only the lbasename'd
|
|
part).
|
|
|
|
If the file is not skipped, and SYMBOL_MATCHER and LOOKUP_NAME are NULL,
|
|
the symbol table is expanded.
|
|
|
|
Otherwise, individual symbols are considered.
|
|
|
|
If DOMAIN or KIND do not match, the symbol is skipped.
|
|
If DOMAIN is UNDEF_DOMAIN, that is treated as a wildcard.
|
|
|
|
If the symbol name does not match LOOKUP_NAME, the symbol is skipped.
|
|
|
|
If SYMBOL_MATCHER returns false, then the symbol is skipped.
|
|
Note that if SYMBOL_MATCHER is non-NULL, then LOOKUP_NAME must
|
|
also be provided.
|
|
|
|
Otherwise, the symbol's symbol table is expanded and the
|
|
notification function is called. If the notification function
|
|
returns false, execution stops and this method returns false.
|
|
Otherwise, more files are considered. This method will return
|
|
true if all calls to the notification function return true. */
|
|
virtual bool expand_symtabs_matching
|
|
(struct objfile *objfile,
|
|
gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
|
|
const lookup_name_info *lookup_name,
|
|
gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
|
|
gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
|
|
block_search_flags search_flags,
|
|
domain_enum domain,
|
|
enum search_domain kind) = 0;
|
|
|
|
/* Return the comp unit from OBJFILE that contains PC and
|
|
SECTION. Return NULL if there is no such compunit. This
|
|
should return the compunit that contains a symbol whose
|
|
address exactly matches PC, or, if there is no exact match, the
|
|
compunit that contains a symbol whose address is closest to
|
|
PC. */
|
|
virtual struct compunit_symtab *find_pc_sect_compunit_symtab
|
|
(struct objfile *objfile, struct bound_minimal_symbol msymbol,
|
|
CORE_ADDR pc, struct obj_section *section, int warn_if_readin) = 0;
|
|
|
|
/* Return the comp unit from OBJFILE that contains a symbol at
|
|
ADDRESS. Return NULL if there is no such comp unit. Unlike
|
|
find_pc_sect_compunit_symtab, any sort of symbol (not just text
|
|
symbols) can be considered, and only exact address matches are
|
|
considered. */
|
|
virtual struct compunit_symtab *find_compunit_symtab_by_address
|
|
(struct objfile *objfile, CORE_ADDR address) = 0;
|
|
|
|
/* Call a callback for every file defined in OBJFILE whose symtab is
|
|
not already read in. FUN is the callback. It is passed the
|
|
file's FILENAME and the file's FULLNAME (if need_fullname is
|
|
non-zero). */
|
|
virtual void map_symbol_filenames
|
|
(struct objfile *objfile,
|
|
gdb::function_view<symbol_filename_ftype> fun,
|
|
bool need_fullname) = 0;
|
|
|
|
/* Return true if this class can lazily read the symbols. This may
|
|
only return true if there are in fact symbols to be read, because
|
|
this is used in the implementation of 'has_partial_symbols'. */
|
|
virtual bool can_lazily_read_symbols ()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* Read the partial symbols for OBJFILE. This will only ever be
|
|
called if can_lazily_read_symbols returns true. */
|
|
virtual void read_partial_symbols (struct objfile *objfile)
|
|
{
|
|
}
|
|
};
|
|
|
|
typedef std::unique_ptr<quick_symbol_functions> quick_symbol_functions_up;
|
|
|
|
#endif /* GDB_QUICK_SYMBOL_H */
|