FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gdb: convert 'set debug symbol-lookup' to new debug printing scheme

Browse source 
Convert the implementation of 'set debug symbol-lookup' to the new
debug printing scheme.

In a few places I've updated the debug output to remove places where
the printed debug message included the function name, the new debug
scheme already adds that, but I haven't done all the possible updates.
This commit is contained in:
Andrew Burgess 2022-12-02 12:10:10 +00:00
parent 9f50fe0835
commit b1e678d920
6 changed files with 161 additions and 276 deletions
Download patch file Download diff file Expand all files Collapse all files

83
gdb/cp-namespace.c
View file

@ -507,14 +507,9 @@ cp_lookup_symbol_imports_or_template (const char *scope,
struct symbol *function = block->function ();
struct block_symbol result;
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_imports_or_template"
" (%s, %s, %s, %s)\n",
scope, name, host_address_to_string (block),
domain_name (domain));
}
symbol_lookup_debug_printf
("cp_lookup_symbol_imports_or_template (%s, %s, %s, %s)",
scope, name, host_address_to_string (block), domain_name (domain));
if (function != NULL && function->language () == language_cplus)
{
@ -529,13 +524,9 @@ cp_lookup_symbol_imports_or_template (const char *scope,
if (sym != NULL)
{
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_imports_or_template"
" (...) = %s\n",
symbol_lookup_debug_printf
("cp_lookup_symbol_imports_or_template (...) = %s",
host_address_to_string (sym));
}
return (struct block_symbol) {sym, block};
}
}
@ -574,13 +565,9 @@ cp_lookup_symbol_imports_or_template (const char *scope,
TYPE_TEMPLATE_ARGUMENTS (context));
if (sym != NULL)
{
if (symbol_lookup_debug)
{
gdb_printf
(gdb_stdlog,
"cp_lookup_symbol_imports_or_template (...) = %s\n",
symbol_lookup_debug_printf
("cp_lookup_symbol_imports_or_template (...) = %s",
host_address_to_string (sym));
}
return (struct block_symbol) {sym, parent};
}
}
@ -588,13 +575,9 @@ cp_lookup_symbol_imports_or_template (const char *scope,
}
result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_imports_or_template (...) = %s\n",
result.symbol != NULL
? host_address_to_string (result.symbol) : "NULL");
}
symbol_lookup_debug_printf
("cp_lookup_symbol_imports_or_template (...) = %s",
result.symbol != NULL ? host_address_to_string (result.symbol) : "NULL");
return result;
}
@ -634,13 +617,9 @@ cp_lookup_symbol_namespace (const char *scope,
{
struct block_symbol sym;
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
symbol_lookup_debug_printf ("cp_lookup_symbol_namespace (%s, %s, %s, %s)",
scope, name, host_address_to_string (block),
domain_name (domain));
}
/* First, try to find the symbol in the given namespace. */
sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
@ -649,13 +628,9 @@ cp_lookup_symbol_namespace (const char *scope,
if (sym.symbol == NULL)
sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_namespace (...) = %s\n",
symbol_lookup_debug_printf ("cp_lookup_symbol_namespace (...) = %s",
sym.symbol != NULL
? host_address_to_string (sym.symbol) : "NULL");
}
return sym;
}
@ -740,14 +715,9 @@ cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
struct block_symbol sym;
const char *scope = block_scope (block);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_non_local"
" (%s, %s (scope %s), %s)\n",
name, host_address_to_string (block), scope,
domain_name (domain));
}
symbol_lookup_debug_printf
("cp_lookup_symbol_non_local (%s, %s (scope %s), %s)",
name, host_address_to_string (block), scope, domain_name (domain));
/* First, try to find the symbol in the given namespace, and all
containing namespaces. */
@ -757,14 +727,10 @@ cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
if (sym.symbol == NULL)
sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_symbol_nonlocal (...) = %s\n",
symbol_lookup_debug_printf ("cp_lookup_symbol_nonlocal (...) = %s",
(sym.symbol != NULL
? host_address_to_string (sym.symbol)
: "NULL"));
}
return sym;
}
@ -921,8 +887,7 @@ cp_lookup_nested_symbol (struct type *parent_type,
{
const char *type_name = saved_parent_type->name ();
gdb_printf (gdb_stdlog,
"cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
symbol_lookup_debug_printf ("cp_lookup_nested_symbol (%s, %s, %s, %s)",
type_name != NULL ? type_name : "unnamed",
nested_name, host_address_to_string (block),
domain_name (domain));
@ -955,25 +920,17 @@ cp_lookup_nested_symbol (struct type *parent_type,
concatenated_name, block, domain,
1, is_in_anonymous);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_nested_symbol (...) = %s\n",
symbol_lookup_debug_printf ("cp_lookup_nested_symbol (...) = %s",
(sym.symbol != NULL
? host_address_to_string (sym.symbol)
: "NULL"));
}
return sym;
}
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"cp_lookup_nested_symbol (...) = NULL"
" (func/method)\n");
}
symbol_lookup_debug_printf
("cp_lookup_nested_symbol (...) = NULL (func/method)");
return {};
default:

10
gdb/language.c
View file

@ -1077,17 +1077,15 @@ language_lookup_primitive_type_as_symbol (const struct language_defn *la,
struct language_gdbarch *ld = get_language_gdbarch (gdbarch);
struct language_arch_info *lai = &ld->arch_info[la->la_language];
if (symbol_lookup_debug)
gdb_printf (gdb_stdlog,
"language_lookup_primitive_type_as_symbol"
" (%s, %s, %s)",
symbol_lookup_debug_printf
("language = \"%s\", gdbarch @ %s, type = \"%s\")",
la->name (), host_address_to_string (gdbarch), name);
struct symbol *sym
= lai->lookup_primitive_type_as_symbol (name, la->la_language);
if (symbol_lookup_debug)
gdb_printf (gdb_stdlog, " = %s\n", host_address_to_string (sym));
symbol_lookup_debug_printf ("found symbol @ %s",
host_address_to_string (sym));
/* Note: The result of symbol lookup is normally a symbol *and* the block
it was found in. Builtin types don't live in blocks. We *could* give

21
gdb/minsyms.c
View file

@ -385,13 +385,9 @@ lookup_minimal_symbol (const char *name, const char *sfile,
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"lookup_minimal_symbol (%s, %s, %s)\n",
symbol_lookup_debug_printf ("lookup_minimal_symbol (%s, %s, %s)",
name, sfile != NULL ? sfile : "NULL",
objfile_debug_name (objfile));
}
/* Do two passes: the first over the ordinary hash table,
and the second over the demangled hash table. */
@ -438,8 +434,8 @@ lookup_minimal_symbol (const char *name, const char *sfile,
{
minimal_symbol *minsym = found.external_symbol.minsym;
gdb_printf (gdb_stdlog,
"lookup_minimal_symbol (...) = %s (external)\n",
symbol_lookup_debug_printf
("lookup_minimal_symbol (...) = %s (external)",
host_address_to_string (minsym));
}
return found.external_symbol;
@ -452,8 +448,8 @@ lookup_minimal_symbol (const char *name, const char *sfile,
{
minimal_symbol *minsym = found.file_symbol.minsym;
gdb_printf (gdb_stdlog,
"lookup_minimal_symbol (...) = %s (file-local)\n",
symbol_lookup_debug_printf
("lookup_minimal_symbol (...) = %s (file-local)",
host_address_to_string (minsym));
}
return found.file_symbol;
@ -466,8 +462,8 @@ lookup_minimal_symbol (const char *name, const char *sfile,
{
minimal_symbol *minsym = found.trampoline_symbol.minsym;
gdb_printf (gdb_stdlog,
"lookup_minimal_symbol (...) = %s (trampoline)\n",
symbol_lookup_debug_printf
("lookup_minimal_symbol (...) = %s (trampoline)",
host_address_to_string (minsym));
}
@ -475,8 +471,7 @@ lookup_minimal_symbol (const char *name, const char *sfile,
}
/* Not found. */
if (symbol_lookup_debug)
gdb_printf (gdb_stdlog, "lookup_minimal_symbol (...) = NULL\n");
symbol_lookup_debug_printf ("lookup_minimal_symbol (...) = NULL");
return {};
}

12
gdb/rust-lang.h
View file

@ -148,14 +148,10 @@ public:
{
struct block_symbol result = {};
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"rust_lookup_symbol_non_local"
" (%s, %s (scope %s), %s)\n",
name, host_address_to_string (block),
block_scope (block), domain_name (domain));
}
symbol_lookup_debug_printf
("rust_lookup_symbol_non_local (%s, %s (scope %s), %s)",
name, host_address_to_string (block), block_scope (block),
domain_name (domain));
/* Look up bare names in the block's scope. */
std::string scopedname;

193
gdb/symtab.c
View file

@ -1424,13 +1424,11 @@ symbol_cache_lookup (struct symbol_cache *cache,
if (eq_symbol_entry (slot, objfile_context, name, domain))
{
if (symbol_lookup_debug)
gdb_printf (gdb_stdlog,
"%s block symbol cache hit%s for %s, %s\n",
symbol_lookup_debug_printf ("%s block symbol cache hit%s for %s, %s",
block == GLOBAL_BLOCK ? "Global" : "Static",
slot->state == SYMBOL_SLOT_NOT_FOUND
? " (not found)" : "",
name, domain_name (domain));
? " (not found)" : "", name,
domain_name (domain));
++bsc->hits;
if (slot->state == SYMBOL_SLOT_NOT_FOUND)
return SYMBOL_LOOKUP_FAILED;
@ -1439,13 +1437,9 @@ symbol_cache_lookup (struct symbol_cache *cache,
/* Symbol is not present in the cache. */
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"%s block symbol cache miss for %s, %s\n",
symbol_lookup_debug_printf ("%s block symbol cache miss for %s, %s",
block == GLOBAL_BLOCK ? "Global" : "Static",
name, domain_name (domain));
}
++bsc->misses;
return {};
}
@ -1996,15 +1990,9 @@ lookup_language_this (const struct language_defn *lang,
if (lang->name_of_this () == NULL || block == NULL)
return {};
if (symbol_lookup_debug > 1)
{
struct objfile *objfile = block_objfile (block);
gdb_printf (gdb_stdlog,
"lookup_language_this (%s, %s (objfile %s))",
symbol_lookup_debug_printf_v ("lookup_language_this (%s, %s (objfile %s))",
lang->name (), host_address_to_string (block),
objfile_debug_name (objfile));
}
objfile_debug_name (block_objfile (block)));
while (block)
{
@ -2015,13 +2003,10 @@ lookup_language_this (const struct language_defn *lang,
VAR_DOMAIN);
if (sym != NULL)
{
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog, " = %s (%s, block %s)\n",
sym->print_name (),
host_address_to_string (sym),
symbol_lookup_debug_printf_v
("lookup_language_this (...) = %s (%s, block %s)",
sym->print_name (), host_address_to_string (sym),
host_address_to_string (block));
}
return (struct block_symbol) {sym, block};
}
if (block->function ())
@ -2029,8 +2014,7 @@ lookup_language_this (const struct language_defn *lang,
block = block->superblock ();
}
if (symbol_lookup_debug > 1)
gdb_printf (gdb_stdlog, " = NULL\n");
symbol_lookup_debug_printf_v ("lookup_language_this (...) = NULL");
return {};
}
@ -2096,11 +2080,12 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
struct objfile *objfile = (block == nullptr
? nullptr : block_objfile (block));
gdb_printf (gdb_stdlog,
"lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
symbol_lookup_debug_printf
("demangled symbol name = \"%s\", block @ %s (objfile %s)",
name, host_address_to_string (block),
objfile != NULL
? objfile_debug_name (objfile) : "NULL",
objfile != NULL ? objfile_debug_name (objfile) : "NULL");
symbol_lookup_debug_printf
("domain name = \"%s\", language = \"%s\")",
domain_name (domain), language_str (language));
}
@ -2117,11 +2102,9 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
result = lookup_local_symbol (name, match_type, block, domain, language);
if (result.symbol != NULL)
{
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
symbol_lookup_debug_printf
("found symbol @ %s (using lookup_local_symbol)",
host_address_to_string (result.symbol));
}
return result;
}
@ -2154,11 +2137,7 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
if (check_field (t, name, is_a_field_of_this))
{
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_aux (...) = NULL\n");
}
symbol_lookup_debug_printf ("no symbol found");
return {};
}
}
@ -2170,11 +2149,9 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
result = langdef->lookup_symbol_nonlocal (name, block, domain);
if (result.symbol != NULL)
{
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
symbol_lookup_debug_printf
("found symbol @ %s (using language lookup_symbol_nonlocal)",
host_address_to_string (result.symbol));
}
return result;
}
@ -2182,13 +2159,9 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
but more useful than an error. */
result = lookup_static_symbol (name, domain);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
result.symbol != NULL
? host_address_to_string (result.symbol)
: "NULL");
}
symbol_lookup_debug_printf
("found symbol @ %s (using lookup_static_symbol)",
result.symbol != NULL ? host_address_to_string (result.symbol) : "NULL");
return result;
}
@ -2246,31 +2219,27 @@ lookup_symbol_in_block (const char *name, symbol_name_match_type match_type,
{
struct symbol *sym;
if (symbol_lookup_debug > 1)
if (symbol_lookup_debug)
{
struct objfile *objfile = (block == nullptr
? nullptr : block_objfile (block));
struct objfile *objfile
= block == nullptr ? nullptr : block_objfile (block);
gdb_printf (gdb_stdlog,
"lookup_symbol_in_block (%s, %s (objfile %s), %s)",
symbol_lookup_debug_printf_v
("lookup_symbol_in_block (%s, %s (objfile %s), %s)",
name, host_address_to_string (block),
objfile_debug_name (objfile),
objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
domain_name (domain));
}
sym = block_lookup_symbol (block, name, match_type, domain);
if (sym)
{
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog, " = %s\n",
symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = %s",
host_address_to_string (sym));
}
return fixup_symbol_section (sym, NULL);
}
if (symbol_lookup_debug > 1)
gdb_printf (gdb_stdlog, " = NULL\n");
symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = NULL");
return NULL;
}
@ -2308,15 +2277,11 @@ lookup_symbol_in_objfile_symtabs (struct objfile *objfile,
{
gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
symbol_lookup_debug_printf_v
("lookup_symbol_in_objfile_symtabs (%s, %s, %s, %s)",
objfile_debug_name (objfile),
block_index == GLOBAL_BLOCK
? "GLOBAL_BLOCK" : "STATIC_BLOCK",
block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
name, domain_name (domain));
}
struct block_symbol other;
other.symbol = NULL;
@ -2352,18 +2317,16 @@ lookup_symbol_in_objfile_symtabs (struct objfile *objfile,
if (other.symbol != NULL)
{
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog, " = %s (block %s)\n",
symbol_lookup_debug_printf_v
("lookup_symbol_in_objfile_symtabs (...) = %s (block %s)",
host_address_to_string (other.symbol),
host_address_to_string (other.block));
}
other.symbol = fixup_symbol_section (other.symbol, objfile);
return other;
}
if (symbol_lookup_debug > 1)
gdb_printf (gdb_stdlog, " = NULL\n");
symbol_lookup_debug_printf_v
("lookup_symbol_in_objfile_symtabs (...) = NULL");
return {};
}
@ -2438,24 +2401,17 @@ lookup_symbol_via_quick_fns (struct objfile *objfile,
const struct block *block;
struct block_symbol result;
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_via_quick_fns (%s, %s, %s, %s)\n",
symbol_lookup_debug_printf_v
("lookup_symbol_via_quick_fns (%s, %s, %s, %s)",
objfile_debug_name (objfile),
block_index == GLOBAL_BLOCK
? "GLOBAL_BLOCK" : "STATIC_BLOCK",
block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
name, domain_name (domain));
}
cust = objfile->lookup_symbol (block_index, name, domain);
if (cust == NULL)
{
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_via_quick_fns (...) = NULL\n");
}
symbol_lookup_debug_printf_v
("lookup_symbol_via_quick_fns (...) = NULL");
return {};
}
@ -2466,13 +2422,10 @@ lookup_symbol_via_quick_fns (struct objfile *objfile,
if (result.symbol == NULL)
error_in_psymtab_expansion (block_index, name, cust);
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_via_quick_fns (...) = %s (block %s)\n",
symbol_lookup_debug_printf_v
("lookup_symbol_via_quick_fns (...) = %s (block %s)",
host_address_to_string (result.symbol),
host_address_to_string (block));
}
result.symbol = fixup_symbol_section (result.symbol, objfile);
result.block = block;
@ -2538,24 +2491,19 @@ lookup_symbol_in_static_block (const char *name,
struct objfile *objfile = (block == nullptr
? nullptr : block_objfile (block));
gdb_printf (gdb_stdlog,
"lookup_symbol_in_static_block (%s, %s (objfile %s),"
" %s)\n",
name,
host_address_to_string (block),
objfile_debug_name (objfile),
symbol_lookup_debug_printf
("lookup_symbol_in_static_block (%s, %s (objfile %s), %s)",
name, host_address_to_string (block),
objfile != nullptr ? objfile_debug_name (objfile) : "NULL",
domain_name (domain));
}
sym = lookup_symbol_in_block (name,
symbol_name_match_type::FULL,
static_block, domain);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_in_static_block (...) = %s\n",
sym != NULL ? host_address_to_string (sym) : "NULL");
}
symbol_lookup_debug_printf ("lookup_symbol_in_static_block (...) = %s",
sym != NULL
? host_address_to_string (sym) : "NULL");
return (struct block_symbol) {sym, static_block};
}
@ -2572,41 +2520,30 @@ lookup_symbol_in_objfile (struct objfile *objfile, enum block_enum block_index,
gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_in_objfile (%s, %s, %s, %s)\n",
symbol_lookup_debug_printf ("lookup_symbol_in_objfile (%s, %s, %s, %s)",
objfile_debug_name (objfile),
block_index == GLOBAL_BLOCK
? "GLOBAL_BLOCK" : "STATIC_BLOCK",
name, domain_name (domain));
}
result = lookup_symbol_in_objfile_symtabs (objfile, block_index,
name, domain);
if (result.symbol != NULL)
{
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_in_objfile (...) = %s"
" (in symtabs)\n",
symbol_lookup_debug_printf
("lookup_symbol_in_objfile (...) = %s (in symtabs)",
host_address_to_string (result.symbol));
}
return result;
}
result = lookup_symbol_via_quick_fns (objfile, block_index,
name, domain);
if (symbol_lookup_debug)
{
gdb_printf (gdb_stdlog,
"lookup_symbol_in_objfile (...) = %s%s\n",
symbol_lookup_debug_printf ("lookup_symbol_in_objfile (...) = %s%s",
result.symbol != NULL
? host_address_to_string (result.symbol)
: "NULL",
result.symbol != NULL ? " (via quick fns)" : "");
}
result.symbol != NULL ? " (via quick fns)"
: "");
return result;
}
@ -4651,12 +4588,8 @@ treg_matches_sym_type_name (const compiled_regex &treg,
struct type *sym_type;
std::string printed_sym_type_name;
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog,
"treg_matches_sym_type_name\n sym %s\n",
symbol_lookup_debug_printf_v ("treg_matches_sym_type_name, sym %s",
sym->natural_name ());
}
sym_type = sym->type ();
if (sym_type == NULL)
@ -4668,14 +4601,8 @@ treg_matches_sym_type_name (const compiled_regex &treg,
printed_sym_type_name = type_to_string (sym_type);
}
if (symbol_lookup_debug > 1)
{
gdb_printf (gdb_stdlog,
" sym_type_name %s\n",
symbol_lookup_debug_printf_v ("sym_type_name %s",
printed_sym_type_name.c_str ());
}
if (printed_sym_type_name.empty ())
return false;

12
gdb/symtab.h
View file

@ -2625,6 +2625,18 @@ extern unsigned int symtab_create_debug;
extern unsigned int symbol_lookup_debug;
/* Print a "symbol-lookup" debug statement if symbol_lookup_debug is >= 1. */
#define symbol_lookup_debug_printf(fmt, ...) \
debug_prefixed_printf_cond (symbol_lookup_debug >= 1, "symbol-lookup", fmt, \
##__VA_ARGS__)
/* Print a "symbol-lookup" debug statement if symbol_lookup_debug is >= 2. */
#define symbol_lookup_debug_printf_v(fmt, ...) \
debug_prefixed_printf_cond (symbol_lookup_debug >= 2, "symbol-lookup", fmt, \
##__VA_ARGS__)
extern bool basenames_may_differ;
bool compare_filenames_for_search (const char *filename,