#include "source.h"
#include "symtab.h"
#include "symfile.h"
+#include "block.h"
+#include "filenames.h"
/* We need to save a pointer to the real symbol functions.
Plus, the debug versions are malloc'd because we have to NULL out the
real_path ? real_path : NULL,
host_address_to_string (&callback));
- bool retval = false;
+ bool retval = true;
+ const char *name_basename = lbasename (name);
+
+ auto match_one_filename = [&] (const char *filename, bool basenames)
+ {
+ if (compare_filenames_for_search (filename, name))
+ return true;
+ if (basenames && FILENAME_CMP (name_basename, filename) == 0)
+ return true;
+ if (real_path != nullptr && IS_ABSOLUTE_PATH (filename)
+ && IS_ABSOLUTE_PATH (real_path))
+ return filename_cmp (filename, real_path) == 0;
+ return false;
+ };
+
+ compunit_symtab *last_made = this->compunit_symtabs;
+
+ auto on_expansion = [&] (compunit_symtab *symtab)
+ {
+ /* The callback to iterate_over_some_symtabs returns false to keep
+ going and true to continue, so we have to invert the result
+ here, for expand_symtabs_matching. */
+ bool result = !iterate_over_some_symtabs (name, real_path,
+ this->compunit_symtabs,
+ last_made,
+ callback);
+ last_made = this->compunit_symtabs;
+ return result;
+ };
+
for (const auto &iter : qf)
{
- retval = (iter->map_symtabs_matching_filename
- (this, name, real_path, callback));
- if (retval)
- break;
+ if (!iter->expand_symtabs_matching (this,
+ match_one_filename,
+ nullptr,
+ nullptr,
+ on_expansion,
+ (SEARCH_GLOBAL_BLOCK
+ | SEARCH_STATIC_BLOCK),
+ UNDEF_DOMAIN,
+ ALL_DOMAIN))
+ {
+ retval = false;
+ break;
+ }
}
if (debug_symfile)
"qf->map_symtabs_matching_filename (...) = %d\n",
retval);
- return retval;
+ /* We must re-invert the return value here to match the caller's
+ expectations. */
+ return !retval;
}
struct compunit_symtab *
objfile_debug_name (this), kind, name,
domain_name (domain));
+ lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
+
+ auto search_one_symtab = [&] (compunit_symtab *stab)
+ {
+ struct symbol *sym, *with_opaque = NULL;
+ const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
+ const struct block *block = BLOCKVECTOR_BLOCK (bv, kind);
+
+ sym = block_find_symbol (block, name, domain,
+ block_find_non_opaque_type_preferred,
+ &with_opaque);
+
+ /* Some caution must be observed with overloaded functions
+ and methods, since the index will not contain any overload
+ information (but NAME might contain it). */
+
+ if (sym != NULL
+ && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
+ {
+ retval = stab;
+ /* Found it. */
+ return false;
+ }
+ if (with_opaque != NULL
+ && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
+ retval = stab;
+
+ /* Keep looking through other psymtabs. */
+ return true;
+ };
+
for (const auto &iter : qf)
{
- retval = iter->lookup_symbol (this, kind, name, domain);
- if (retval != nullptr)
+ if (!iter->expand_symtabs_matching (this,
+ nullptr,
+ &lookup_name,
+ nullptr,
+ search_one_symtab,
+ kind == GLOBAL_BLOCK
+ ? SEARCH_GLOBAL_BLOCK
+ : SEARCH_STATIC_BLOCK,
+ domain,
+ ALL_DOMAIN))
break;
}
"qf->expand_symtabs_for_function (%s, \"%s\")\n",
objfile_debug_name (this), func_name);
+ lookup_name_info base_lookup (func_name, symbol_name_match_type::FULL);
+ lookup_name_info lookup_name = base_lookup.make_ignore_params ();
+
for (const auto &iter : qf)
- iter->expand_symtabs_for_function (this, func_name);
+ iter->expand_symtabs_matching (this,
+ nullptr,
+ &lookup_name,
+ nullptr,
+ nullptr,
+ (SEARCH_GLOBAL_BLOCK
+ | SEARCH_STATIC_BLOCK),
+ VAR_DOMAIN,
+ ALL_DOMAIN);
}
void
"qf->expand_symtabs_with_fullname (%s, \"%s\")\n",
objfile_debug_name (this), fullname);
+ const char *basename = lbasename (fullname);
+ auto file_matcher = [&] (const char *filename, bool basenames)
+ {
+ return filename_cmp (basenames ? basename : fullname, filename) == 0;
+ };
+
for (const auto &iter : qf)
- iter->expand_symtabs_with_fullname (this, fullname);
+ iter->expand_symtabs_matching (this,
+ file_matcher,
+ nullptr,
+ nullptr,
+ nullptr,
+ (SEARCH_GLOBAL_BLOCK
+ | SEARCH_STATIC_BLOCK),
+ UNDEF_DOMAIN,
+ ALL_DOMAIN);
}
void
callback, ordered_compare);
}
-void
+bool
objfile::expand_symtabs_matching
(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)
{
if (debug_symfile)
search_domain_name (kind));
for (const auto &iter : qf)
- iter->expand_symtabs_matching (this, file_matcher, lookup_name,
- symbol_matcher, expansion_notify, kind);
+ if (!iter->expand_symtabs_matching (this, file_matcher, lookup_name,
+ symbol_matcher, expansion_notify,
+ search_flags, domain, kind))
+ return false;
+ return true;
}
struct compunit_symtab *
}
void
-objfile::map_symbol_filenames (symbol_filename_ftype *fun, void *data,
- int need_fullname)
+objfile::map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
+ bool need_fullname)
{
if (debug_symfile)
fprintf_filtered (gdb_stdlog,
- "qf->map_symbol_filenames (%s, %s, %s, %d)\n",
+ "qf->map_symbol_filenames (%s, ..., %d)\n",
objfile_debug_name (this),
- host_address_to_string (fun),
- host_address_to_string (data),
need_fullname);
for (const auto &iter : qf)
- iter->map_symbol_filenames (this, fun, data, need_fullname);
+ iter->map_symbol_filenames (this, fun, need_fullname);
}
struct compunit_symtab *
projects / deliverable / binutils-gdb.git / blobdiff