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

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.

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 634dab6ada01c924fb98deda126fb877a378f369..6520c8adf85925ed1fc05a000ab898d4c4a1ab59 100644 (file)
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -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",
-                             host_address_to_string (sym));
-               }
+             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",
-                        host_address_to_string (sym));
-                   }
+                 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",
-                 scope, name, host_address_to_string (block),
-                 domain_name (domain));
-    }
+  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",
-                 sym.symbol != NULL
-                 ? host_address_to_string (sym.symbol) : "NULL");
-    }
+  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",
-                 (sym.symbol != NULL
-                  ? host_address_to_string (sym.symbol)
-                  : "NULL"));
-    }
+  symbol_lookup_debug_printf ("cp_lookup_symbol_nonlocal (...) = %s",
+                             (sym.symbol != NULL
+                              ? host_address_to_string (sym.symbol)
+                              : "NULL"));
   return sym;
 }
 
@@ -921,11 +887,10 @@ 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",
-                 type_name != NULL ? type_name : "unnamed",
-                 nested_name, host_address_to_string (block),
-                 domain_name (domain));
+      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));
     }
 
   switch (parent_type->code ())
@@ -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",
-                       (sym.symbol != NULL
-                        ? host_address_to_string (sym.symbol)
-                        : "NULL"));
-         }
+       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:

diff --git a/gdb/language.c b/gdb/language.c
index 3962ee8fa246d99352d535c912b9a9521a2b8e59..5083a86c01218e546c3247fdf395edc5faa66b18 100644 (file)
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -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)",
-               la->name (), host_address_to_string (gdbarch), name);
+  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

diff --git a/gdb/minsyms.c b/gdb/minsyms.c
index 3b65669d176f36194898736b43fa0e44a08bdceb..dbde6ce5de4e6d876a37e95247619bcbfe0287ea 100644 (file)
--- a/gdb/minsyms.c
+++ b/gdb/minsyms.c
@@ -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",
-                         name, sfile != NULL ? sfile : "NULL",
-                         objfile_debug_name (objfile));
-           }
+         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,9 +434,9 @@ 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",
-                     host_address_to_string (minsym));
+         symbol_lookup_debug_printf
+           ("lookup_minimal_symbol (...) = %s (external)",
+            host_address_to_string (minsym));
        }
       return found.external_symbol;
     }
@@ -452,9 +448,9 @@ 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",
-                     host_address_to_string (minsym));
+         symbol_lookup_debug_printf
+           ("lookup_minimal_symbol (...) = %s (file-local)",
+            host_address_to_string (minsym));
        }
       return found.file_symbol;
     }
@@ -466,17 +462,16 @@ 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",
-                     host_address_to_string (minsym));
+         symbol_lookup_debug_printf
+           ("lookup_minimal_symbol (...) = %s (trampoline)",
+            host_address_to_string (minsym));
        }
 
       return found.trampoline_symbol;
     }
 
   /* Not found.  */
-  if (symbol_lookup_debug)
-    gdb_printf (gdb_stdlog, "lookup_minimal_symbol (...) = NULL\n");
+  symbol_lookup_debug_printf ("lookup_minimal_symbol (...) = NULL");
   return {};
 }
 

diff --git a/gdb/rust-lang.h b/gdb/rust-lang.h
index a1d10263feb3ffc355ad983de1600d7399d0c2c5..4e5f39c49456ba9e59e46d7364ea643000ffff32 100644 (file)
--- a/gdb/rust-lang.h
+++ b/gdb/rust-lang.h
@@ -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;

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 0d342f765f2feb85bbfb4df2e7861fb500ca2056..14d81f5468dfe377f8d9399f1e2a5b21ec2f3326 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -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",
-                   block == GLOBAL_BLOCK ? "Global" : "Static",
-                   slot->state == SYMBOL_SLOT_NOT_FOUND
-                   ? " (not found)" : "",
-                   name, domain_name (domain));
+      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));
       ++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",
-                 block == GLOBAL_BLOCK ? "Global" : "Static",
-                 name, domain_name (domain));
-    }
+  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))",
-                 lang->name (), host_address_to_string (block),
-                 objfile_debug_name (objfile));
-    }
+  symbol_lookup_debug_printf_v ("lookup_language_this (%s, %s (objfile %s))",
+                               lang->name (), host_address_to_string (block),
+                               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),
-                         host_address_to_string (block));
-           }
+         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,12 +2080,13 @@ 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",
-                 name, host_address_to_string (block),
-                 objfile != NULL
-                 ? objfile_debug_name (objfile) : "NULL",
-                 domain_name (domain), language_str (language));
+      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");
+      symbol_lookup_debug_printf
+       ("domain name = \"%s\", language = \"%s\")",
+        domain_name (domain), language_str (language));
     }
 
   /* Make sure we do something sensible with is_a_field_of_this, since
@@ -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",
-                     host_address_to_string (result.symbol));
-       }
+      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",
-                     host_address_to_string (result.symbol));
-       }
+      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)",
-                 name, host_address_to_string (block),
-                 objfile_debug_name (objfile),
-                 domain_name (domain));
+      symbol_lookup_debug_printf_v
+       ("lookup_symbol_in_block (%s, %s (objfile %s), %s)",
+        name, host_address_to_string (block),
+        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",
-                     host_address_to_string (sym));
-       }
+      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)",
-                 objfile_debug_name (objfile),
-                 block_index == GLOBAL_BLOCK
-                 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
-                 name, domain_name (domain));
-    }
+  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",
+     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",
-                     host_address_to_string (other.symbol),
-                     host_address_to_string (other.block));
-       }
+      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",
-                 objfile_debug_name (objfile),
-                 block_index == GLOBAL_BLOCK
-                 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
-                 name, domain_name (domain));
-    }
+  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",
+     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",
-                 host_address_to_string (result.symbol),
-                 host_address_to_string (block));
-    }
+  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),
-                 domain_name (domain));
+      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",
-                 objfile_debug_name (objfile),
-                 block_index == GLOBAL_BLOCK
-                 ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
-                 name, domain_name (domain));
-    }
+  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",
-                     host_address_to_string (result.symbol));
-       }
+      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",
-                 result.symbol != NULL
-                 ? host_address_to_string (result.symbol)
-                 : "NULL",
-                 result.symbol != NULL ? " (via quick fns)" : "");
-    }
+  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)"
+                             : "");
   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",
-                 sym->natural_name ());
-    }
+  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",
-                 printed_sym_type_name.c_str ());
-    }
-
+  symbol_lookup_debug_printf_v ("sym_type_name %s",
+                               printed_sym_type_name.c_str ());
 
   if (printed_sym_type_name.empty ())
     return false;

diff --git a/gdb/symtab.h b/gdb/symtab.h
index 4f3e84bbbe93c2b96ae377fba1933559629cbdbf..6eca61a759af86b0f4f8c371824522400231afbd 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -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,