X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsymtab.h;h=d0465987749511b43211a7ab91fa7673f5ad9388;hb=a7773afff9035cb0e450478bcfe88a5920957e46;hp=2d826aabb50cd5848b04a68730f6e75e954e21e9;hpb=cf724bc93ee954a6f7aac0557afc41c1316dc80c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symtab.h b/gdb/symtab.h index 2d826aabb5..d046598774 100644 --- a/gdb/symtab.h +++ b/gdb/symtab.h @@ -1,6 +1,6 @@ /* Symbol table definitions for GDB. - Copyright (C) 1986-2017 Free Software Foundation, Inc. + Copyright (C) 1986-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -23,11 +23,13 @@ #include #include #include -#include "gdb_vecs.h" +#include "gdbsupport/gdb_vecs.h" #include "gdbtypes.h" -#include "common/enum-flags.h" -#include "common/function-view.h" -#include "common/gdb_optional.h" +#include "gdb_regex.h" +#include "gdbsupport/enum-flags.h" +#include "gdbsupport/function-view.h" +#include "gdbsupport/gdb_optional.h" +#include "gdbsupport/next-iterator.h" #include "completer.h" /* Opaque declarations. */ @@ -42,10 +44,10 @@ struct axs_value; 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. */ @@ -60,6 +62,16 @@ enum class symbol_name_match_type namespace/module/package. */ FULL, + /* 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. + 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 + avoids trying to demangle a name we already know is + demangled. */ + SEARCH_NAME, + /* Expression matching. The same as FULL matching in most languages. The same as WILD matching in Ada. */ EXPRESSION, @@ -84,7 +96,7 @@ class ada_lookup_name_info final 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 @@ -100,7 +112,11 @@ class ada_lookup_name_info final bool standard_p () const { return m_standard_p; } - private: + /* Return true if doing a verbatim match. */ + bool verbatim_p () const + { return m_verbatim_p; } + +private: /* The Ada-encoded lookup name. */ std::string m_encoded_name; @@ -295,15 +311,21 @@ private: 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: @@ -472,10 +494,11 @@ extern void symbol_set_language (struct general_symbol_info *symbol, /* Set the linkage and natural names of a symbol, by demangling the linkage name. */ #define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \ - symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile) + symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, \ + (objfile)->per_bfd) extern void symbol_set_names (struct general_symbol_info *symbol, - const char *linkage_name, int len, int copy_name, - struct objfile *objfile); + const char *linkage_name, int len, 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 @@ -521,7 +544,7 @@ extern const char *symbol_demangled_name #define SYMBOL_PRINT_NAME(symbol) \ (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol)) -extern int demangle; +extern bool demangle; /* Macro that returns the name to be used when sorting and searching symbols. In C++, we search for the demangled form of a name, @@ -560,8 +583,26 @@ enum minimal_symbol_type { mst_unknown = 0, /* Unknown type, the default */ mst_text, /* Generally executable instructions */ - mst_text_gnu_ifunc, /* Executable code returning address + + /* A GNU ifunc symbol, in the .text section. GDB uses to know + whether the user is setting a breakpoint on a GNU ifunc function, + and thus GDB needs to actually set the breakpoint on the target + function. It is also used to know whether the program stepped + into an ifunc resolver -- the resolver may get a separate + symbol/alias under a different name, but it'll have the same + address as the ifunc symbol. */ + mst_text_gnu_ifunc, /* Executable code returning address of executable code */ + + /* A GNU ifunc function descriptor symbol, in a data section + (typically ".opd"). Seen on architectures that use function + descriptors, like PPC64/ELFv1. In this case, this symbol's value + is the address of the descriptor. There'll be a corresponding + mst_text_gnu_ifunc synthetic symbol for the text/entry + address. */ + mst_data_gnu_ifunc, /* Executable code returning address + of executable code */ + mst_slot_got_plt, /* GOT entries for .plt sections */ mst_data, /* Generally initialized data */ mst_bss, /* Generally uninitialized data */ @@ -600,16 +641,8 @@ gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS)); between names and addresses, and vice versa. They are also sometimes used to figure out what full symbol table entries need to be read in. */ -struct minimal_symbol +struct minimal_symbol : public general_symbol_info { - - /* The general symbol info required for all types of symbols. - - The SYMBOL_VALUE_ADDRESS contains the address that this symbol - corresponds to. */ - - struct general_symbol_info mginfo; - /* Size of this symbol. dbx_end_psymtab in dbxread.c uses this information to calculate the end of the partial symtab based on the address of the last symbol plus the size of the last symbol. */ @@ -645,6 +678,14 @@ struct minimal_symbol the `next' pointer for the demangled hash table. */ struct minimal_symbol *demangled_hash_next; + + /* True if this symbol is of some data type. */ + + bool data_p () const; + + /* True if MSYMBOL is of some text type. */ + + bool text_p () const; }; #define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1 @@ -659,42 +700,38 @@ struct minimal_symbol #define MSYMBOL_HAS_SIZE(msymbol) ((msymbol)->has_size + 0) #define MSYMBOL_TYPE(msymbol) (msymbol)->type -#define MSYMBOL_VALUE(symbol) (symbol)->mginfo.value.ivalue +#define MSYMBOL_VALUE(symbol) (symbol)->value.ivalue /* The unrelocated address of the minimal symbol. */ -#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0) +#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->value.address + 0) /* The relocated address of the minimal symbol, using the section offsets from OBJFILE. */ #define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \ - ((symbol)->mginfo.value.address \ - + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section))) + ((symbol)->value.address \ + + ANOFFSET ((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 SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value) \ - ((symbol)->mginfo.value.address = (new_value)) -#define MSYMBOL_VALUE_BYTES(symbol) (symbol)->mginfo.value.bytes -#define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->mginfo.value.block -#define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->mginfo.value.chain -#define MSYMBOL_LANGUAGE(symbol) (symbol)->mginfo.language -#define MSYMBOL_SECTION(symbol) (symbol)->mginfo.section + ((symbol)->value.address = (new_value)) +#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)->mginfo.section >= 0) \ - ? (&(((objfile)->sections)[(symbol)->mginfo.section])) \ + (((symbol)->section >= 0) \ + ? (&(((objfile)->sections)[(symbol)->section])) \ : NULL) #define MSYMBOL_NATURAL_NAME(symbol) \ - (symbol_natural_name (&(symbol)->mginfo)) -#define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->mginfo.name + (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)->mginfo)) -#define MSYMBOL_SET_LANGUAGE(symbol,language,obstack) \ - (symbol_set_language (&(symbol)->mginfo, (language), (obstack))) + (symbol_demangled_name (symbol)) #define MSYMBOL_SEARCH_NAME(symbol) \ - (symbol_search_name (&(symbol)->mginfo)) -#define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \ - symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile) + (symbol_search_name (symbol)) #include "minsyms.h" @@ -945,7 +982,7 @@ struct symbol_computed_ops The generated C code must assign the location to a local variable; this variable's name is RESULT_NAME. */ - void (*generate_c_location) (struct symbol *symbol, string_file &stream, + void (*generate_c_location) (struct symbol *symbol, string_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, const char *result_name); @@ -1122,10 +1159,6 @@ struct block_symbol extern const struct symbol_impl *symbol_impls; -/* For convenience. All fields are NULL. This means "there is no - symbol". */ -extern const struct block_symbol null_block_symbol; - /* Note: There is no accessor macro for symbol.owner because it is "private". */ @@ -1288,16 +1321,6 @@ struct symtab const char *filename; - /* Total number of lines found in source file. */ - - int nlines; - - /* line_charpos[N] is the position of the (N-1)th line of the - source file. "position" means something we can lseek() to; it - is not guaranteed to be useful any other way. */ - - int *line_charpos; - /* Language of this source file. */ enum language language; @@ -1319,9 +1342,6 @@ struct symtab #define SYMTAB_DIRNAME(symtab) \ COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab)) -typedef struct symtab *symtab_ptr; -DEF_VEC_P (symtab_ptr); - /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well as the list of all source files (what gdb has historically associated with the term "symtab"). @@ -1449,10 +1469,16 @@ struct compunit_symtab #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab) #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table) -/* Iterate over all file tables (struct symtab) within a compunit. */ +/* A range adapter to allowing iterating over all the file tables + within a compunit. */ -#define ALL_COMPUNIT_FILETABS(cu, s) \ - for ((s) = (cu) -> filetabs; (s) != NULL; (s) = (s) -> next) +struct compunit_filetabs : public next_adapter +{ + compunit_filetabs (struct compunit_symtab *cu) + : next_adapter (cu->filetabs) + { + } +}; /* Return the primary symtab of CUST. */ @@ -1463,9 +1489,6 @@ extern struct symtab * extern enum language compunit_language (const struct compunit_symtab *cust); -typedef struct compunit_symtab *compunit_symtab_ptr; -DEF_VEC_P (compunit_symtab_ptr); - /* The virtual function table is now an array of structures which have the @@ -1548,6 +1571,20 @@ extern struct block_symbol lookup_symbol (const char *, const domain_enum, struct field_of_this_result *); +/* Find the definition for a specified symbol search name in 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 + 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 struct block_symbol lookup_symbol_search_name (const char *search_name, + const struct block *block, + domain_enum domain); + /* A default version of lookup_symbol_nonlocal for use by languages that can't think of anything better to do. This implements the C lookup rules. */ @@ -1597,6 +1634,7 @@ extern struct block_symbol extern struct symbol * lookup_symbol_in_block (const char *name, + symbol_name_match_type match_type, const struct block *block, const domain_enum domain); @@ -1617,28 +1655,99 @@ extern struct type *lookup_enum (const char *, const struct block *); /* from blockframe.c: */ -/* lookup the function symbol corresponding to the address. */ +/* lookup the function symbol corresponding to the address. The + return value will not be an inlined function; the containing + function will be returned instead. */ extern struct symbol *find_pc_function (CORE_ADDR); -/* lookup the function corresponding to the address and section. */ +/* lookup the function corresponding to the address and section. The + return value will not be an inlined function; the containing + function will be returned instead. */ extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *); +/* lookup the function symbol corresponding to the address and + section. The return value will be the closest enclosing function, + which might be an inline function. */ + +extern struct symbol *find_pc_sect_containing_function + (CORE_ADDR pc, struct obj_section *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, +/* Finds the "function" (text symbol) that is smaller than PC but + greatest of all of the potential text symbols in SECTION. Sets + *NAME and/or *ADDRESS conditionally if that pointer is non-null. + If ENDADDR is non-null, then set *ENDADDR to be the end of the + function (exclusive). If the optional parameter BLOCK is non-null, + then set *BLOCK to the address of the block corresponding to the + function symbol, if such a symbol could be found during the lookup; + nullptr is used as a return value for *BLOCK if no block is found. + This function either succeeds or fails (not halfway succeeds). If + it succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real + information and returns 1. If it fails, it sets *NAME, *ADDRESS + and *ENDADDR to zero and returns 0. + + If the function in question occupies non-contiguous ranges, + *ADDRESS and *ENDADDR are (subject to the conditions noted above) set + to the start and end of the range in which PC is found. Thus + *ADDRESS <= PC < *ENDADDR with no intervening gaps (in which ranges + from other functions might be found). + + This property allows find_pc_partial_function to be used (as it had + been prior to the introduction of non-contiguous range support) by + various tdep files for finding a start address and limit address + for prologue analysis. This still isn't ideal, however, because we + probably shouldn't be doing prologue analysis (in which + instructions are scanned to determine frame size and stack layout) + for any range that doesn't contain the entry pc. Moreover, a good + argument can be made that prologue analysis ought to be performed + starting from the entry pc even when PC is within some other range. + This might suggest that *ADDRESS and *ENDADDR ought to be set to the + limits of the entry pc range, but that will cause the + *ADDRESS <= PC < *ENDADDR condition to be violated; many of the + callers of find_pc_partial_function expect this condition to hold. + + Callers which require the start and/or end addresses for the range + containing the entry pc should instead call + find_function_entry_range_from_pc. */ + +extern int find_pc_partial_function (CORE_ADDR pc, const char **name, + CORE_ADDR *address, CORE_ADDR *endaddr, + const struct block **block = nullptr); + +/* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are + set to start and end addresses of the range containing the entry pc. + + Note that it is not necessarily the case that (for non-NULL ADDRESS + and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will + hold. + + See comment for find_pc_partial_function, above, for further + explanation. */ + +extern bool find_function_entry_range_from_pc (CORE_ADDR pc, + const char **name, CORE_ADDR *address, - CORE_ADDR *endaddr, - int *is_gnu_ifunc_p); + CORE_ADDR *endaddr); + +/* Return the type of a function with its first instruction exactly at + the PC address. Return NULL otherwise. */ + +extern struct type *find_function_type (CORE_ADDR pc); + +/* See if we can figure out the function's actual type from the type + that the resolver returns. RESOLVER_FUNADDR is the address of the + ifunc resolver. */ -/* lookup function from address, return name, start addr and end addr. */ +extern struct type *find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr); -extern int find_pc_partial_function (CORE_ADDR, const char **, CORE_ADDR *, - CORE_ADDR *); +/* Find the GNU ifunc minimal symbol that matches SYM. */ +extern bound_minimal_symbol find_gnu_ifunc (const symbol *sym); extern void clear_pc_function_cache (void); @@ -1716,6 +1825,7 @@ struct symtab_and_line struct symtab *symtab = NULL; struct symbol *symbol = NULL; struct obj_section *section = NULL; + struct minimal_symbol *msymbol = NULL; /* Line number. Line numbers start at 1 and proceed through symtab->nlines. 0 is never a valid line number; it is used to indicate that line number information is not available. */ @@ -1727,7 +1837,7 @@ struct symtab_and_line 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; @@ -1762,30 +1872,6 @@ extern void resolve_sal_pc (struct symtab_and_line *); extern void clear_solib (void); -/* source.c */ - -extern int identify_source_line (struct symtab *, int, int, CORE_ADDR); - -/* Flags passed as 4th argument to print_source_lines. */ - -enum print_source_lines_flag - { - /* Do not print an error message. */ - PRINT_SOURCE_LINES_NOERROR = (1 << 0), - - /* Print the filename in front of the source lines. */ - PRINT_SOURCE_LINES_FILENAME = (1 << 1) - }; -DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags); - -extern void print_source_lines (struct symtab *, int, int, - print_source_lines_flags); - -extern void forget_cached_source_info_for_objfile (struct objfile *); -extern void forget_cached_source_info (void); - -extern void select_source_symtab (struct symtab *); - /* The reason we're calling into a completion match list collector function. */ enum class complete_symbol_mode @@ -1854,8 +1940,17 @@ int matching_obj_sections (struct obj_section *, struct obj_section *); extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *); -extern struct symtab_and_line find_function_start_sal (struct symbol *sym, - int); +/* Given a function symbol SYM, find the symtab and line for the start + of the function. If FUNFIRSTLINE is true, we want the first line + of real code inside the function. */ +extern symtab_and_line find_function_start_sal (symbol *sym, bool + funfirstline); + +/* Same, but start with a function address/section instead of a + symbol. */ +extern symtab_and_line find_function_start_sal (CORE_ADDR func_addr, + obj_section *section, + bool funfirstline); extern void skip_prologue_sal (struct symtab_and_line *); @@ -1929,23 +2024,28 @@ private: }; extern std::vector search_symbols (const char *, - enum search_domain, int, - const char **); - -/* The name of the ``main'' function. - FIXME: cagney/2001-03-20: Can't make main_name() const since some - of the calling code currently assumes that the string isn't - const. */ -extern /*const */ char *main_name (void); + enum search_domain, + const char *, + int, + const char **, + bool); +extern bool treg_matches_sym_type_name (const compiled_regex &treg, + const struct symbol *sym); + +/* The name of the ``main'' function. */ +extern const char *main_name (); extern enum language main_language (void); -/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks. +/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global or static blocks, + as specified by BLOCK_INDEX. This searches MAIN_OBJFILE as well as any associated separate debug info objfiles of MAIN_OBJFILE. + BLOCK_INDEX can be GLOBAL_BLOCK or STATIC_BLOCK. Upon success fixes up the symbol's section if necessary. */ extern struct block_symbol lookup_global_symbol_from_objfile (struct objfile *main_objfile, + enum block_enum block_index, const char *name, const domain_enum domain); @@ -1964,7 +2064,7 @@ extern unsigned int symtab_create_debug; extern unsigned int symbol_lookup_debug; -extern int basenames_may_differ; +extern bool basenames_may_differ; int compare_filenames_for_search (const char *filename, const char *search_name); @@ -1990,13 +2090,32 @@ std::vector find_pcs_for_symtab_line true to indicate that LA_ITERATE_OVER_SYMBOLS should continue iterating, or false to indicate that the iteration should end. */ -typedef bool (symbol_found_callback_ftype) (symbol *sym); +typedef bool (symbol_found_callback_ftype) (struct block_symbol *bsym); + +/* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK. -void iterate_over_symbols (const struct block *block, + For each symbol that matches, CALLBACK is called. The symbol is + passed to the callback. + + If CALLBACK returns false, the iteration ends and this function + returns false. Otherwise, the search continues, and the function + eventually returns true. */ + +bool iterate_over_symbols (const struct block *block, const lookup_name_info &name, const domain_enum domain, gdb::function_view callback); +/* Like iterate_over_symbols, but if all calls to CALLBACK return + true, then calls CALLBACK one additional time with a block_symbol + that has a valid block but a NULL symbol. */ + +bool iterate_over_symbols_terminated + (const struct block *block, + const lookup_name_info &name, + const domain_enum domain, + gdb::function_view callback); + /* Storage type used by demangle_for_lookup. demangle_for_lookup either returns a const char * pointer that points to either of the fields of this type, or a pointer to the input NAME. This is done @@ -2051,4 +2170,47 @@ void completion_list_add_name (completion_tracker &tracker, const lookup_name_info &lookup_name, const char *text, const char *word); +/* A simple symbol searching class. */ + +class symbol_searcher +{ +public: + /* Returns the symbols found for the search. */ + const std::vector & + matching_symbols () const + { + return m_symbols; + } + + /* Returns the minimal symbols found for the search. */ + const std::vector & + matching_msymbols () const + { + return m_minimal_symbols; + } + + /* Search for all symbols named NAME in LANGUAGE with DOMAIN, restricting + search to FILE_SYMTABS and SEARCH_PSPACE, both of which may be NULL + to search all symtabs and program spaces. */ + void find_all_symbols (const std::string &name, + const struct language_defn *language, + enum search_domain search_domain, + std::vector *search_symtabs, + struct program_space *search_pspace); + + /* Reset this object to perform another search. */ + void reset () + { + m_symbols.clear (); + m_minimal_symbols.clear (); + } + +private: + /* Matching debug symbols. */ + std::vector m_symbols; + + /* Matching non-debug symbols. */ + std::vector m_minimal_symbols; +}; + #endif /* !defined(SYMTAB_H) */