From patchwork Mon Aug 5 15:33:26 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Terekhov, Mikhail via Gdb-patches" X-Patchwork-Id: 33967 Received: (qmail 2960 invoked by alias); 5 Aug 2019 15:33:33 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 2952 invoked by uid 89); 5 Aug 2019 15:33:32 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-23.6 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: mail-qk1-f201.google.com Received: from mail-qk1-f201.google.com (HELO mail-qk1-f201.google.com) (209.85.222.201) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 05 Aug 2019 15:33:31 +0000 Received: by mail-qk1-f201.google.com with SMTP id v1so22901257qkf.21 for ; Mon, 05 Aug 2019 08:33:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=L6MOXF130SBq65wv87SUORCHyPZ7gGVmpmVvSTeuNWA=; b=C5IQIIV5HA1yY0gqC1dTpe701U3LC743l3BoEJLDUVi05Mo/zFhaqwYGSg9l+vwZ0f GKmkrjjpRmtnjmh4wgf9m8Vmn8Up8PFXOURubs7FSvbRcK70MNppTNG97iE023wquWO4 P6IP5G9+9m90FM4Ij8LGvxqTosMNC1Byuq66TXOVTCMlS48CEtHHGIJ/SbbNNXu+bQA7 L9HvnJmMMrqrmpqDM5MGbn5Z+tjsT5yiGLHwSpL3kNSWH3crJzplrdGuQGUZqDgwJO1U 9VFrATWNgqoNbEqbqHBVZewMwvt4jdRSQQgTC2mwnKC3OlpWtq3sjFxYYLoCBjMTV5Ag srsw== Date: Mon, 5 Aug 2019 10:33:26 -0500 In-Reply-To: Message-Id: <20190805153326.95512-1-cbiesinger@google.com> Mime-Version: 1.0 References: Subject: [PATCH v2] Factor out the common code in lookup_{static, global}_symbol X-Patchwork-Original-From: "Christian Biesinger via gdb-patches" From: "Terekhov, Mikhail via Gdb-patches" Reply-To: Christian Biesinger To: gdb-patches@sourceware.org Cc: Christian Biesinger The two functions are extremely similar; this factors out their code into a shared _internal function. gdb/ChangeLog: 2019-08-02 Christian Biesinger * symtab.c (lookup_static_symbol): Call the new function (and move it down to be next to lookup_global_symbol). (struct global_sym_lookup_data): Add block_enum member. (lookup_symbol_global_iterator_cb): Pass block_index instead of GLOBAL_BLOCK to lookup_symbol_in_objfile. (lookup_global_symbol_internal): New function. (lookup_global_symbol): Call new function. --- gdb/symtab.c | 82 ++++++++++++++++++++++++---------------------------- 1 file changed, 37 insertions(+), 45 deletions(-) diff --git a/gdb/symtab.c b/gdb/symtab.c index 87a0c8e4da..1a5a6bf20e 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -2566,44 +2566,6 @@ lookup_symbol_in_objfile (struct objfile *objfile, enum block_enum block_index, return result; } -/* See symtab.h. */ - -struct block_symbol -lookup_static_symbol (const char *name, const domain_enum domain) -{ - struct symbol_cache *cache = get_symbol_cache (current_program_space); - struct block_symbol result; - struct block_symbol_cache *bsc; - struct symbol_cache_slot *slot; - - /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass - NULL for OBJFILE_CONTEXT. */ - result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain, - &bsc, &slot); - if (result.symbol != NULL) - { - if (SYMBOL_LOOKUP_FAILED_P (result)) - return {}; - return result; - } - - for (objfile *objfile : current_program_space->objfiles ()) - { - result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain); - if (result.symbol != NULL) - { - /* Still pass NULL for OBJFILE_CONTEXT here. */ - symbol_cache_mark_found (bsc, slot, NULL, result.symbol, - result.block); - return result; - } - } - - /* Still pass NULL for OBJFILE_CONTEXT here. */ - symbol_cache_mark_not_found (bsc, slot, NULL, name, domain); - return {}; -} - /* Private data to be used with lookup_symbol_global_iterator_cb. */ struct global_sym_lookup_data @@ -2614,6 +2576,9 @@ struct global_sym_lookup_data /* The domain to use for our search. */ domain_enum domain; + /* The block index in which to search */ + enum block_enum block_index; + /* The field where the callback should store the symbol if found. It should be initialized to {NULL, NULL} before the search is started. */ struct block_symbol result; @@ -2634,7 +2599,7 @@ lookup_symbol_global_iterator_cb (struct objfile *objfile, gdb_assert (data->result.symbol == NULL && data->result.block == NULL); - data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK, + data->result = lookup_symbol_in_objfile (objfile, data->block_index, data->name, data->domain); /* If we found a match, tell the iterator to stop. Otherwise, @@ -2642,12 +2607,15 @@ lookup_symbol_global_iterator_cb (struct objfile *objfile, return (data->result.symbol != NULL); } -/* See symtab.h. */ +/* This function contains the common code of lookup_{global,static}_symbol. + BLOCK is only used if BLOCK_INDEX is GLOBAL_SCOPE, in which case it is + used to retrieve the objfile to start the lookup in. */ -struct block_symbol -lookup_global_symbol (const char *name, - const struct block *block, - const domain_enum domain) +static struct block_symbol +lookup_global_symbol_internal (const char *name, + enum block_enum block_index, + const struct block *block, + const domain_enum domain) { struct symbol_cache *cache = get_symbol_cache (current_program_space); struct block_symbol result; @@ -2656,11 +2624,14 @@ lookup_global_symbol (const char *name, struct block_symbol_cache *bsc; struct symbol_cache_slot *slot; + gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK); + gdb_assert (block == nullptr || block_index == GLOBAL_BLOCK); + objfile = lookup_objfile_from_block (block); /* First see if we can find the symbol in the cache. This works because we use the current objfile to qualify the lookup. */ - result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain, + result = symbol_cache_lookup (cache, objfile, block_index, name, domain, &bsc, &slot); if (result.symbol != NULL) { @@ -2678,6 +2649,7 @@ lookup_global_symbol (const char *name, { memset (&lookup_data, 0, sizeof (lookup_data)); lookup_data.name = name; + lookup_data.block_index = block_index; lookup_data.domain = domain; gdbarch_iterate_over_objfiles_in_search_order (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (), @@ -2693,6 +2665,26 @@ lookup_global_symbol (const char *name, return result; } +/* See symtab.h. */ + +struct block_symbol +lookup_static_symbol (const char *name, const domain_enum domain) +{ + /* TODO: Should static symbol lookup start with a block as well, so we can + prefer a static symbol in the current CU? */ + return lookup_global_symbol_internal (name, STATIC_BLOCK, nullptr, domain); +} + +/* See symtab.h. */ + +struct block_symbol +lookup_global_symbol (const char *name, + const struct block *block, + const domain_enum domain) +{ + return lookup_global_symbol_internal (name, GLOBAL_BLOCK, block, domain); +} + int symbol_matches_domain (enum language symbol_language, domain_enum symbol_domain,