throw_error (NOT_FOUND_ERROR, "%s", message);
}
+/* A callback function and the additional data to call it with. */
+
+struct symbol_and_data_callback
+{
+ /* The callback to use. */
+ symbol_found_callback_ftype *callback;
+
+ /* Data to be passed to the callback. */
+ void *data;
+};
+
+/* A helper for iterate_over_all_matching_symtabs that is used to
+ restrict calls to another callback to symbols representing inline
+ symbols only. */
+
+static int
+iterate_inline_only (struct symbol *sym, void *d)
+{
+ if (SYMBOL_INLINED (sym))
+ {
+ struct symbol_and_data_callback *cad = d;
+
+ return cad->callback (sym, cad->data);
+ }
+ return 1; /* Continue iterating. */
+}
+
/* Some data for the expand_symtabs_matching callback. */
struct symbol_matcher_data
/* A helper that walks over all matching symtabs in all objfiles and
calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
not NULL, then the search is restricted to just that program
- space. */
+ space. If INCLUDE_INLINE is nonzero then symbols representing
+ inlined instances of functions will be included in the result. */
static void
iterate_over_all_matching_symtabs (const char *name,
const domain_enum domain,
symbol_found_callback_ftype *callback,
void *data,
- struct program_space *search_pspace)
+ struct program_space *search_pspace,
+ int include_inline)
{
struct objfile *objfile;
struct program_space *pspace;
block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
+
+ if (include_inline)
+ {
+ struct symbol_and_data_callback cad = { callback, data };
+ int i;
+
+ for (i = FIRST_LOCAL_BLOCK;
+ i < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab)); i++)
+ {
+ block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), i);
+ LA_ITERATE_OVER_SYMBOLS (block, name, domain,
+ iterate_inline_only, &cad);
+ }
+ }
}
}
}
return;
}
+ /* Sort the list of method names alphabetically. */
+ qsort (VEC_address (const_char_ptr, item_names),
+ VEC_length (const_char_ptr, item_names),
+ sizeof (const_char_ptr), compare_strings);
+
printf_unfiltered (_("[0] cancel\n[1] all\n"));
for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
printf_unfiltered ("[%d] %s\n", i + 2, iter);
/* Locate the end of the first half of the linespec.
After the call, for instance, if the argptr string is "foo.c:123"
- p will point at "123". If there is only one part, like "foo", p
+ p will point at ":123". If there is only one part, like "foo", p
will point to "". If this is a C++ name, like "A::B::foo", p will
point to "::B::foo". Argptr is not changed by this call. */
/* First things first: if ARGPTR starts with a filename, get its
symtab and strip the filename from ARGPTR.
Avoid calling symtab_from_filename if we know can,
- it can be expensive. */
+ it can be expensive. We know we can avoid the call if we see a
+ single word (e.g., "break NAME") or if we see a qualified C++
+ name ("break QUAL::NAME"). */
- if (*p != '\0')
+ if (*p != '\0' && !(p[0] == ':' && p[1] == ':'))
{
TRY_CATCH (file_exception, RETURN_MASK_ERROR)
{
{
iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN,
collect_one_symbol, &collector,
- NULL);
+ NULL, 0);
iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
collect_one_symbol, &collector,
- NULL);
+ NULL, 0);
}
else
{
copy[p - *argptr] = 0;
iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
- collect_function_symbols, &result, NULL);
+ collect_function_symbols, &result, NULL,
+ 0);
if (VEC_empty (symbolp, result))
VEC_free (symbolp, result);
{
iterate_over_all_matching_symtabs (name, VAR_DOMAIN,
collect_symbols, info,
- pspace);
+ pspace, 1);
search_minsyms_for_name (info, name, pspace);
}
else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))