#include "stack.h"
#include "location.h"
#include "common/function-view.h"
+#include "common/def-vector.h"
/* An enumeration of the various things a user might attempt to
complete for a linespec location. */
/* Prototypes for local functions. */
static void iterate_over_file_blocks
- (struct symtab *symtab, const char *name, domain_enum domain,
+ (struct symtab *symtab, const lookup_name_info &name,
+ domain_enum domain,
gdb::function_view<symbol_found_callback_ftype> callback);
static void initialize_defaults (struct symtab **default_symtab,
static void find_linespec_symbols (struct linespec_state *self,
VEC (symtab_ptr) *file_symtabs,
const char *name,
+ symbol_name_match_type name_match_type,
VEC (symbolp) **symbols,
VEC (bound_minimal_symbol_d) **minsyms);
int funfirstline, struct symbol *sym);
static void add_matching_symbols_to_info (const char *name,
+ symbol_name_match_type name_match_type,
+ enum search_domain search_domain,
struct collect_info *info,
struct program_space *pspace);
static void add_all_symbol_names_from_pspace (struct collect_info *info,
struct program_space *pspace,
- VEC (const_char_ptr) *names);
+ VEC (const_char_ptr) *names,
+ enum search_domain search_domain);
static VEC (symtab_ptr) *
collect_symtabs_from_filename (const char *file,
if (i != IF_KEYWORD_INDEX)
{
p += len;
- p = skip_spaces_const (p);
+ p = skip_spaces (p);
for (j = 0; linespec_keywords[j] != NULL; ++j)
{
int nextlen = strlen (linespec_keywords[j]);
{
if (isspace (*PARSER_STREAM (parser)))
{
- p = skip_spaces_const (PARSER_STREAM (parser));
+ p = skip_spaces (PARSER_STREAM (parser));
/* When we get here we know we've found something followed by
a space (we skip over parens and templates below).
So if we find a keyword now, we know it is a keyword and not,
if (PARSER_STREAM (parser)[1] == ':')
++(PARSER_STREAM (parser));
+ /* Do not tokenize ABI tags such as "[abi:cxx11]". */
+ else if (PARSER_STREAM (parser) - start > 4
+ && startswith (PARSER_STREAM (parser) - 4, "[abi"))
+ ++(PARSER_STREAM (parser));
+
/* Do not tokenify if the input length so far is one
(i.e, a single-letter drive name) and the next character
is a directory separator. This allows Windows-style
if (parser->lexer.current.type == LSTOKEN_CONSUMED)
{
/* Skip any whitespace. */
- PARSER_STREAM (parser) = skip_spaces_const (PARSER_STREAM (parser));
+ PARSER_STREAM (parser) = skip_spaces (PARSER_STREAM (parser));
/* Check for a keyword, they end the linespec. */
keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser));
static void
iterate_over_all_matching_symtabs
- (struct linespec_state *state, const char *name, const domain_enum domain,
+ (struct linespec_state *state,
+ const lookup_name_info &lookup_name,
+ const domain_enum name_domain,
+ enum search_domain search_domain,
struct program_space *search_pspace, bool include_inline,
gdb::function_view<symbol_found_callback_ftype> callback)
{
struct objfile *objfile;
struct program_space *pspace;
- /* The routine to be used for comparison. */
- symbol_name_cmp_ftype symbol_name_cmp
- = (state->language->la_get_symbol_name_cmp != NULL
- ? state->language->la_get_symbol_name_cmp (name)
- : strcmp_iw);
-
ALL_PSPACES (pspace)
{
if (search_pspace != NULL && search_pspace != pspace)
struct compunit_symtab *cu;
if (objfile->sf)
- objfile->sf->qf->expand_symtabs_matching
- (objfile,
- NULL,
- [&] (const char *symbol_name)
- {
- return symbol_name_cmp (symbol_name, name) == 0;
- },
- NULL,
- ALL_DOMAIN);
+ objfile->sf->qf->expand_symtabs_matching (objfile,
+ NULL,
+ lookup_name,
+ NULL, NULL,
+ search_domain);
ALL_OBJFILE_COMPUNITS (objfile, cu)
{
struct symtab *symtab = COMPUNIT_FILETABS (cu);
- iterate_over_file_blocks (symtab, name, domain, callback);
+ iterate_over_file_blocks (symtab, lookup_name, name_domain, callback);
if (include_inline)
{
{
block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), i);
state->language->la_iterate_over_symbols
- (block, name, domain, [&] (symbol *sym)
+ (block, lookup_name, name_domain, [&] (symbol *sym)
{
/* Restrict calls to CALLBACK to symbols
representing inline symbols only. */
static void
iterate_over_file_blocks
- (struct symtab *symtab, const char *name, domain_enum domain,
- gdb::function_view<symbol_found_callback_ftype> callback)
+ (struct symtab *symtab, const lookup_name_info &name,
+ domain_enum domain, gdb::function_view<symbol_found_callback_ftype> callback)
{
struct block *block;
LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback);
}
-/* A helper for find_method. This finds all methods in type T which
- match NAME. It adds matching symbol names to RESULT_NAMES, and
- adds T's direct superclasses to SUPERCLASSES. */
+/* A helper for find_method. This finds all methods in type T of
+ language T_LANG which match NAME. It adds matching symbol names to
+ RESULT_NAMES, and adds T's direct superclasses to SUPERCLASSES. */
static void
-find_methods (struct type *t, const char *name,
+find_methods (struct type *t, enum language t_lang, const char *name,
VEC (const_char_ptr) **result_names,
VEC (typep) **superclasses)
{
if (class_name)
{
int method_counter;
+ lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
+ symbol_name_matcher_ftype *symbol_name_compare
+ = language_get_symbol_name_matcher (language_def (t_lang), lookup_name);
t = check_typedef (t);
method_name = dem_opname;
}
- if (strcmp_iw (method_name, name) == 0)
+ if (symbol_name_compare (method_name, lookup_name, NULL))
{
int field_counter;
{
if (*PARSER_STREAM (parser) == ' ')
{
- parser->completion_word = skip_spaces_const (PARSER_STREAM (parser) + 1);
+ parser->completion_word = skip_spaces (PARSER_STREAM (parser) + 1);
parser->complete_what = next;
}
else
completion_tracker tmp_tracker;
const char *source_filename
= PARSER_EXPLICIT (parser)->source_filename;
+ symbol_name_match_type match_type
+ = PARSER_EXPLICIT (parser)->func_name_match_type;
linespec_complete_function (tmp_tracker,
parser->completion_word,
+ match_type,
source_filename);
if (tmp_tracker.have_completions ())
/* Try looking it up as a function/method. */
find_linespec_symbols (PARSER_STATE (parser),
PARSER_RESULT (parser)->file_symtabs, name,
+ PARSER_EXPLICIT (parser)->func_name_match_type,
&symbols, &minimal_symbols);
if (symbols != NULL || minimal_symbols != NULL)
if (ptr[i] == ' ')
{
LS_TOKEN_STOKEN (token).length = i;
- PARSER_STREAM (parser) = skip_spaces_const (ptr + i + 1);
+ PARSER_STREAM (parser) = skip_spaces (ptr + i + 1);
break;
}
}
else
{
struct linetable_entry *best_entry = NULL;
- int *filter;
- const struct block **blocks;
int i, j;
std::vector<symtab_and_line> intermediate_results
above, we see if there are other PCs that are in the same
block. If yes, the other PCs are filtered out. */
- filter = XNEWVEC (int, intermediate_results.size ());
- struct cleanup *cleanup = make_cleanup (xfree, filter);
- blocks = XNEWVEC (const struct block *, intermediate_results.size ());
- make_cleanup (xfree, blocks);
+ gdb::def_vector<int> filter (intermediate_results.size ());
+ gdb::def_vector<const block *> blocks (intermediate_results.size ());
for (i = 0; i < intermediate_results.size (); ++i)
{
add_sal_to_sals (self, &values, &intermediate_results[i],
sym ? SYMBOL_NATURAL_NAME (sym) : NULL, 0);
}
-
- do_cleanups (cleanup);
}
if (values.empty ())
linespec_p result,
const char *source_filename,
const char *function_name,
+ symbol_name_match_type fname_match_type,
const char *label_name,
struct line_offset line_offset)
{
VEC (symbolp) *symbols, *labels;
VEC (bound_minimal_symbol_d) *minimal_symbols;
+ result->explicit_loc.func_name_match_type = fname_match_type;
+
if (source_filename != NULL)
{
TRY
if (function_name != NULL)
{
find_linespec_symbols (self, result->file_symtabs,
- function_name, &symbols,
- &minimal_symbols);
+ function_name, fname_match_type,
+ &symbols, &minimal_symbols);
if (symbols == NULL && minimal_symbols == NULL)
symbol_not_found_error (function_name,
convert_explicit_location_to_linespec (self, result,
explicit_loc->source_filename,
explicit_loc->function_name,
+ explicit_loc->func_name_match_type,
explicit_loc->label_name,
explicit_loc->line_offset);
return convert_linespec_to_sals (self, result);
if no file is validly specified. Callers must check that.
Also, the line number returned may be invalid. */
-/* Parse the linespec in ARG. */
+/* Parse the linespec in ARG. MATCH_TYPE indicates how function names
+ should be matched. */
static std::vector<symtab_and_line>
-parse_linespec (linespec_parser *parser, const char *arg)
+parse_linespec (linespec_parser *parser, const char *arg,
+ symbol_name_match_type match_type)
{
linespec_token token;
struct gdb_exception file_exception = exception_none;
parser->lexer.stream = arg;
parser->completion_word = arg;
parser->complete_what = linespec_complete_what::FUNCTION;
+ PARSER_EXPLICIT (parser)->func_name_match_type = match_type;
/* Initialize the default symtab and line offset. */
initialize_defaults (&PARSER_STATE (parser)->default_symtab,
advances past a keyword automatically, so skip it
manually. */
parser->completion_word
- = skip_spaces_const (skip_to_space_const (PARSER_STREAM (parser)));
+ = skip_spaces (skip_to_space (PARSER_STREAM (parser)));
parser->complete_what = linespec_complete_what::EXPRESSION;
}
memset (parser, 0, sizeof (linespec_parser));
parser->lexer.current.type = LSTOKEN_CONSUMED;
memset (PARSER_RESULT (parser), 0, sizeof (struct linespec));
+ PARSER_EXPLICIT (parser)->func_name_match_type
+ = symbol_name_match_type::WILD;
PARSER_EXPLICIT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN;
linespec_state_constructor (PARSER_STATE (parser), flags, language,
search_pspace,
/* See description in linespec.h. */
void
-linespec_lex_to_end (char **stringp)
+linespec_lex_to_end (const char **stringp)
{
linespec_parser parser;
struct cleanup *cleanup;
void
linespec_complete_function (completion_tracker &tracker,
const char *function,
+ symbol_name_match_type func_match_type,
const char *source_filename)
{
complete_symbol_mode mode = complete_symbol_mode::LINESPEC;
if (source_filename != NULL)
{
- collect_file_symbol_completion_matches (tracker, mode,
- function, function,
- source_filename);
+ collect_file_symbol_completion_matches (tracker, mode, func_match_type,
+ function, function, source_filename);
}
else
- collect_symbol_completion_matches (tracker, mode, function, function);
+ {
+ collect_symbol_completion_matches (tracker, mode, func_match_type,
+ function, function);
+
+ }
}
/* Helper for complete_linespec to simplify it. SOURCE_FILENAME is
{
completion_list fn_list;
- linespec_complete_function (tracker, text, source_filename);
+ symbol_name_match_type match_type
+ = PARSER_EXPLICIT (parser)->func_name_match_type;
+ linespec_complete_function (tracker, text, match_type, source_filename);
if (source_filename == NULL)
{
/* Haven't seen a source component, like in "b
const struct language_defn *language,
const char *source_filename,
const char *function_name,
+ symbol_name_match_type func_name_match_type,
const char *label_name)
{
linespec_parser parser;
PARSER_RESULT (&parser),
source_filename,
function_name,
+ func_name_match_type,
NULL, unknown_offset);
}
CATCH (ex, RETURN_MASK_ERROR)
/* See description in linespec.h. */
void
-linespec_complete (completion_tracker &tracker, const char *text)
+linespec_complete (completion_tracker &tracker, const char *text,
+ symbol_name_match_type match_type)
{
linespec_parser parser;
struct cleanup *cleanup;
linespec_parser_new (&parser, 0, current_language, NULL, NULL, 0, NULL);
cleanup = make_cleanup (linespec_parser_delete, &parser);
parser.lexer.saved_arg = text;
+ PARSER_EXPLICIT (&parser)->func_name_match_type = match_type;
PARSER_STREAM (&parser) = text;
parser.completion_tracker = &tracker;
furthest completion point we managed to parse to. */
TRY
{
- parse_linespec (&parser, text);
+ parse_linespec (&parser, text, match_type);
}
CATCH (except, RETURN_MASK_ERROR)
{
VEC (bound_minimal_symbol_d) *minimal_symbols;
find_linespec_symbols (PARSER_STATE (&parser),
PARSER_RESULT (&parser)->file_symtabs,
- func_name,
+ func_name, match_type,
&function_symbols, &minimal_symbols);
PARSER_RESULT (&parser)->function_symbols = function_symbols;
the ':', then complete_linespec_component won't try to
complete on source filenames. */
- const char *text = parser.completion_word;
const char *word = parser.completion_word;
complete_linespec_component (&parser, tracker,
PARSER_STATE (parser)->is_linespec = 1;
TRY
{
- result = parse_linespec (parser, get_linespec_location (location));
+ const linespec_location *ls = get_linespec_location (location);
+ result = parse_linespec (parser,
+ ls->spec_string, ls->match_type);
}
CATCH (except, RETURN_MASK_ERROR)
{
/* See linespec.h. */
std::vector<symtab_and_line>
-decode_line_with_current_source (char *string, int flags)
+decode_line_with_current_source (const char *string, int flags)
{
if (string == 0)
error (_("Empty line specification."));
/* See linespec.h. */
std::vector<symtab_and_line>
-decode_line_with_last_displayed (char *string, int flags)
+decode_line_with_last_displayed (const char *string, int flags)
{
if (string == 0)
error (_("Empty line specification."));
return {};
}
- add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
+ add_all_symbol_names_from_pspace (&info, NULL, symbol_names,
+ FUNCTIONS_DOMAIN);
std::vector<symtab_and_line> values;
if (!VEC_empty (symbolp, info.result.symbols)
if (self->canonical)
{
- char *str;
+ std::string holder;
+ const char *str;
self->canonical->pre_expanded = 1;
if (ls->explicit_loc.source_filename)
{
- str = xstrprintf ("%s:%s",
- ls->explicit_loc.source_filename, saved_arg);
+ holder = string_printf ("%s:%s",
+ ls->explicit_loc.source_filename,
+ saved_arg);
+ str = holder.c_str ();
}
else
- str = xstrdup (saved_arg);
+ str = saved_arg;
- make_cleanup (xfree, str);
- self->canonical->location = new_linespec_location (&str);
+ self->canonical->location
+ = new_linespec_location (&str, symbol_name_match_type::FULL);
}
}
struct symtab *elt;
decode_compound_collector collector;
+ lookup_name_info lookup_name (class_name, symbol_name_match_type::FULL);
+
for (ix = 0; VEC_iterate (symtab_ptr, file_symtabs, ix, elt); ++ix)
{
if (elt == NULL)
{
- iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN,
+ iterate_over_all_matching_symtabs (state, lookup_name,
+ STRUCT_DOMAIN, ALL_DOMAIN,
NULL, false, collector);
- iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN,
+ iterate_over_all_matching_symtabs (state, lookup_name,
+ VAR_DOMAIN, ALL_DOMAIN,
NULL, false, collector);
}
else
been filtered out earlier. */
gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
set_current_program_space (SYMTAB_PSPACE (elt));
- iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN, collector);
- iterate_over_file_blocks (elt, class_name, VAR_DOMAIN, collector);
+ iterate_over_file_blocks (elt, lookup_name, STRUCT_DOMAIN, collector);
+ iterate_over_file_blocks (elt, lookup_name, VAR_DOMAIN, collector);
}
}
static void
add_all_symbol_names_from_pspace (struct collect_info *info,
struct program_space *pspace,
- VEC (const_char_ptr) *names)
+ VEC (const_char_ptr) *names,
+ enum search_domain search_domain)
{
int ix;
const char *iter;
for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
- add_matching_symbols_to_info (iter, info, pspace);
+ add_matching_symbols_to_info (iter,
+ symbol_name_match_type::FULL,
+ search_domain, info, pspace);
}
static void
find_superclass_methods (VEC (typep) *superclasses,
- const char *name,
+ const char *name, enum language name_lang,
VEC (const_char_ptr) **result_names)
{
int old_len = VEC_length (const_char_ptr, *result_names);
make_cleanup (VEC_cleanup (typep), &new_supers);
for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
- find_methods (t, name, result_names, &new_supers);
+ find_methods (t, name_lang, name, result_names, &new_supers);
if (VEC_length (const_char_ptr, *result_names) != old_len
|| VEC_empty (typep, new_supers))
gdb_assert (!pspace->executing_startup);
set_current_program_space (pspace);
t = check_typedef (SYMBOL_TYPE (sym));
- find_methods (t, method_name, &result_names, &superclass_vec);
+ find_methods (t, SYMBOL_LANGUAGE (sym),
+ method_name, &result_names, &superclass_vec);
/* Handle all items from a single program space at once; and be
sure not to miss the last batch. */
this program space, consider superclasses. */
if (VEC_length (const_char_ptr, result_names) == last_result_len)
find_superclass_methods (superclass_vec, method_name,
- &result_names);
+ SYMBOL_LANGUAGE (sym), &result_names);
/* We have a list of candidate symbol names, so now we
iterate over the symbol tables looking for all
matches in this pspace. */
- add_all_symbol_names_from_pspace (&info, pspace, result_names);
+ add_all_symbol_names_from_pspace (&info, pspace, result_names,
+ FUNCTIONS_DOMAIN);
VEC_truncate (typep, superclass_vec, 0);
last_result_len = VEC_length (const_char_ptr, result_names);
static void
find_function_symbols (struct linespec_state *state,
VEC (symtab_ptr) *file_symtabs, const char *name,
+ symbol_name_match_type name_match_type,
VEC (symbolp) **symbols,
VEC (bound_minimal_symbol_d) **minsyms)
{
find_imps (name, &symbol_names);
if (!VEC_empty (const_char_ptr, symbol_names))
add_all_symbol_names_from_pspace (&info, state->search_pspace,
- symbol_names);
+ symbol_names, FUNCTIONS_DOMAIN);
else
- add_matching_symbols_to_info (name, &info, state->search_pspace);
+ add_matching_symbols_to_info (name, name_match_type, FUNCTIONS_DOMAIN,
+ &info, state->search_pspace);
do_cleanups (cleanup);
static void
find_linespec_symbols (struct linespec_state *state,
VEC (symtab_ptr) *file_symtabs,
- const char *name,
+ const char *lookup_name,
+ symbol_name_match_type name_match_type,
VEC (symbolp) **symbols,
VEC (bound_minimal_symbol_d) **minsyms)
{
- demangle_result_storage demangle_storage;
- std::string ada_lookup_storage;
- const char *lookup_name;
-
- if (state->language->la_language == language_ada)
- {
- /* In Ada, the symbol lookups are performed using the encoded
- name rather than the demangled name. */
- ada_lookup_storage = ada_name_for_lookup (name);
- lookup_name = ada_lookup_storage.c_str ();
- }
- else
- {
- lookup_name = demangle_for_lookup (name,
- state->language->la_language,
- demangle_storage);
- }
-
std::string canon = cp_canonicalize_string_no_typedefs (lookup_name);
if (!canon.empty ())
lookup_name = canon.c_str ();
2) break class::method where method is in class (and not a baseclass) */
find_function_symbols (state, file_symtabs, lookup_name,
+ name_match_type,
symbols, minsyms);
/* If we were unable to locate a symbol of the same name, try dividing
{
int ix;
const struct block *block;
- struct symbol *sym;
struct symbol *fn_sym;
VEC (symbolp) *result = NULL;
struct minimal_symbol *msymbol,
std::vector<symtab_and_line> *result)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- CORE_ADDR pc;
struct symtab_and_line sal;
- sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
- (struct obj_section *) 0, 0);
- sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
-
- /* The minimal symbol might point to a function descriptor;
- resolve it to the actual code address instead. */
- pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target);
- if (pc != sal.pc)
- sal = find_pc_sect_line (pc, NULL, 0);
-
- if (self->funfirstline)
+ CORE_ADDR func_addr;
+ if (msymbol_is_function (objfile, msymbol, &func_addr))
{
- if (sal.symtab != NULL
- && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
- || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
+ sal = find_pc_sect_line (func_addr, NULL, 0);
+
+ if (self->funfirstline)
{
- /* If gdbarch_convert_from_func_ptr_addr does not apply then
- sal.SECTION, sal.LINE&co. will stay correct from above.
- If gdbarch_convert_from_func_ptr_addr applies then
- sal.SECTION is cleared from above and sal.LINE&co. will
- stay correct from the last find_pc_sect_line above. */
- sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
- sal.pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc,
- ¤t_target);
- if (gdbarch_skip_entrypoint_p (gdbarch))
- sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
+ if (sal.symtab != NULL
+ && (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
+ || SYMTAB_LANGUAGE (sal.symtab) == language_asm))
+ {
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+
+ sal.pc = func_addr;
+ if (gdbarch_skip_entrypoint_p (gdbarch))
+ sal.pc = gdbarch_skip_entrypoint (gdbarch, sal.pc);
+ }
+ else
+ skip_prologue_sal (&sal);
}
- else
- skip_prologue_sal (&sal);
}
+ else
+ {
+ sal.objfile = objfile;
+ sal.pc = MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
+ sal.pspace = current_program_space;
+ }
+
+ sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
add_sal_to_sals (self, result, &sal, MSYMBOL_NATURAL_NAME (msymbol), 0);
add_minsym (struct minimal_symbol *minsym, void *d)
{
struct collect_minsyms *info = (struct collect_minsyms *) d;
- bound_minimal_symbol_d mo;
-
- mo.minsym = minsym;
- mo.objfile = info->objfile;
if (info->symtab != NULL)
{
- CORE_ADDR pc;
- struct symtab_and_line sal;
- struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
-
- sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (info->objfile, minsym),
- NULL, 0);
- sal.section = MSYMBOL_OBJ_SECTION (info->objfile, minsym);
- pc
- = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, ¤t_target);
- if (pc != sal.pc)
- sal = find_pc_sect_line (pc, NULL, 0);
+ /* We're looking for a label for which we don't have debug
+ info. */
+ CORE_ADDR func_addr;
+ if (msymbol_is_function (info->objfile, minsym, &func_addr))
+ {
+ symtab_and_line sal = find_pc_sect_line (func_addr, NULL, 0);
- if (info->symtab != sal.symtab)
- return;
+ if (info->symtab != sal.symtab)
+ return;
+ }
}
- /* Exclude data symbols when looking for breakpoint locations. */
- if (!info->list_mode)
- switch (minsym->type)
- {
- case mst_slot_got_plt:
- case mst_data:
- case mst_bss:
- case mst_abs:
- case mst_file_data:
- case mst_file_bss:
- {
- /* Make sure this minsym is not a function descriptor
- before we decide to discard it. */
- struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
- CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr
- (gdbarch, BMSYMBOL_VALUE_ADDRESS (mo),
- ¤t_target);
-
- if (addr == BMSYMBOL_VALUE_ADDRESS (mo))
- return;
- }
- }
+ /* Exclude data symbols when looking for breakpoint locations. */
+ if (!info->list_mode && !msymbol_is_function (info->objfile, minsym))
+ return;
+ bound_minimal_symbol_d mo = {minsym, info->objfile};
VEC_safe_push (bound_minimal_symbol_d, info->msyms, &mo);
}
restrict results to the given SYMTAB. */
static void
-search_minsyms_for_name (struct collect_info *info, const char *name,
+search_minsyms_for_name (struct collect_info *info,
+ const lookup_name_info &name,
struct program_space *search_pspace,
struct symtab *symtab)
{
{
set_current_program_space (SYMTAB_PSPACE (symtab));
local.objfile = SYMTAB_OBJFILE(symtab);
- iterate_over_minimal_symbols (local.objfile, name, add_minsym,
- &local);
+ iterate_over_minimal_symbols (local.objfile, name, add_minsym, &local);
}
}
static void
add_matching_symbols_to_info (const char *name,
+ symbol_name_match_type name_match_type,
+ enum search_domain search_domain,
struct collect_info *info,
struct program_space *pspace)
{
int ix;
struct symtab *elt;
+ lookup_name_info lookup_name (name, name_match_type);
+
for (ix = 0; VEC_iterate (symtab_ptr, info->file_symtabs, ix, elt); ++ix)
{
if (elt == NULL)
{
- iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN,
+ iterate_over_all_matching_symtabs (info->state, lookup_name,
+ VAR_DOMAIN, search_domain,
pspace, true, [&] (symbol *sym)
{ return info->add_symbol (sym); });
- search_minsyms_for_name (info, name, pspace, NULL);
+ search_minsyms_for_name (info, lookup_name, pspace, NULL);
}
else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
{
been filtered out earlier. */
gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
set_current_program_space (SYMTAB_PSPACE (elt));
- iterate_over_file_blocks (elt, name, VAR_DOMAIN, [&] (symbol *sym)
+ iterate_over_file_blocks (elt, lookup_name, VAR_DOMAIN,
+ [&] (symbol *sym)
{ return info->add_symbol (sym); });
/* If no new symbols were found in this iteration and this symtab
this case. */
if (prev_len == VEC_length (symbolp, info->result.symbols)
&& elt->language == language_asm)
- search_minsyms_for_name (info, name, pspace, elt);
+ search_minsyms_for_name (info, lookup_name, pspace, elt);
}
}
}
{
*result = {};
result->symtab = symbol_symtab (sym);
+ result->symbol = sym;
result->line = SYMBOL_LINE (sym);
result->pc = SYMBOL_VALUE_ADDRESS (sym);
result->pspace = SYMTAB_PSPACE (result->symtab);
/* We know its line number. */
*result = {};
result->symtab = symbol_symtab (sym);
+ result->symbol = sym;
result->line = SYMBOL_LINE (sym);
+ result->pc = SYMBOL_VALUE_ADDRESS (sym);
result->pspace = SYMTAB_PSPACE (result->symtab);
return 1;
}