From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 547F4383B6CF for ; Tue, 6 Dec 2022 17:42:17 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 547F4383B6CF Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1670348537; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1pAbPg9dLJixhM9rgSqOXy46SWns/VSXn1XaZfUJrXQ=; b=gsRjfoCuJvqwvTVBxJz7mKVCR5QnekFe+4DhREn2hL0MI7rcgmBGO3LgSth3pT4y2lk/KK /QqTSCvFgZHaoVkVgpKdDJjtq3bReQnnk/UdjZ1sWAi2AAV/7+vfnQGyFp/nqs5edjYgdB 0bVj8dif0RW5DXRKylVc8MnB7CD93T8= Received: from mail-wm1-f72.google.com (mail-wm1-f72.google.com [209.85.128.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-637-QI9K0cIYNF--q0dSZKt86g-1; Tue, 06 Dec 2022 12:42:15 -0500 X-MC-Unique: QI9K0cIYNF--q0dSZKt86g-1 Received: by mail-wm1-f72.google.com with SMTP id f1-20020a1cc901000000b003cf703a4f08so5901562wmb.2 for ; Tue, 06 Dec 2022 09:42:15 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=1pAbPg9dLJixhM9rgSqOXy46SWns/VSXn1XaZfUJrXQ=; b=ImACMhyRy8jKv4sA7sqTk1hQw6udJLxvE6yiAOA3PoZLZcGwbNCphw88gJ5UGLtxxq XiJDbUkIAnX/SABEvxq1k3aet8HtOSPfq5Jx0Hj6yBdsy4j8GKswB/dGyaKTRVyoAZYv QixQJfys54xxQzFOz1+2IbM6CeWKIsx8ZxNr7HBBDwdFJz6pGMeRoXkoumnoJ/UloFlZ LQ7N/dcCaPKGgXsAMUn1a4H8s3ktmaN3e72y5mfd6kLidFwU2FdIzvuuVOdFyqq/HNYo acGuPwUnilrPb5KmWc6lcfDrM4x339XqQh/iwXElmmCj5E1ve4qmTKQ1PTbhRm3QW/Rb adDw== X-Gm-Message-State: ANoB5pmnmlfP+3D/nuThtHTqF9nylBrNglNIDbR27sAFqnuerAC7wRF2 gQjC+AwkL9My3eStbGWCBy9ZQ2oGJwYPFw9Sl2clepH905XK16mtEdsvqEh0H8HnAHrY8OOjecD jisetx12f941bPXQTsdBIRSsnPbLfkNwlVAh/npYTz0CqxijakWUoXdwS+n233qxLedDda+zdjw == X-Received: by 2002:a5d:4281:0:b0:22e:3c69:f587 with SMTP id k1-20020a5d4281000000b0022e3c69f587mr47498511wrq.670.1670348534181; Tue, 06 Dec 2022 09:42:14 -0800 (PST) X-Google-Smtp-Source: AA0mqf7ULp/xduRnDN6U7UaUY72JNNrwHWBQ204cYulf6hArQtFgae/+slXvbhuVSAvhuPQ+Ay5gQw== X-Received: by 2002:a5d:4281:0:b0:22e:3c69:f587 with SMTP id k1-20020a5d4281000000b0022e3c69f587mr47498489wrq.670.1670348533626; Tue, 06 Dec 2022 09:42:13 -0800 (PST) Received: from localhost ([31.111.84.238]) by smtp.gmail.com with ESMTPSA id h10-20020a5d504a000000b002366553eca7sm5503976wrt.83.2022.12.06.09.42.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 Dec 2022 09:42:13 -0800 (PST) From: Andrew Burgess To: gdb-patches@sourceware.org Cc: Andrew Burgess Subject: [PATCH 1/2] gdb: convert 'set debug symbol-lookup' to new debug printing scheme Date: Tue, 6 Dec 2022 17:42:08 +0000 Message-Id: <2244867a8f6bd29a2921b26b1658ed0f89a72023.1670348436.git.aburgess@redhat.com> X-Mailer: git-send-email 2.25.4 In-Reply-To: References: MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-10.9 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_STOCKGEN,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: 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. --- gdb/cp-namespace.c | 113 ++++++-------------- gdb/language.c | 12 +-- gdb/minsyms.c | 31 +++--- gdb/rust-lang.h | 12 +-- gdb/symtab.c | 257 ++++++++++++++++----------------------------- gdb/symtab.h | 12 +++ 6 files changed, 161 insertions(+), 276 deletions(-) diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c index 634dab6ada0..6520c8adf85 100644 --- 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 3962ee8fa24..5083a86c012 100644 --- 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 3b65669d176..dbde6ce5de4 100644 --- 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 a1d10263feb..4e5f39c4945 100644 --- a/gdb/rust-lang.h +++ b/gdb/rust-lang.h @@ -148,14 +148,10 @@ class rust_language : public language_defn { 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 0d342f765f2..14d81f5468d 100644 --- 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 4f3e84bbbe9..6eca61a759a 100644 --- 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, -- 2.25.4