From patchwork Wed Jan 27 12:58:47 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?q?Matthias_M=C3=A4nnich?= X-Patchwork-Id: 41848 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C72683971C3C; Wed, 27 Jan 2021 12:59:42 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C72683971C3C DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1611752382; bh=mWWVwPNTlI0pdwpcwUXgN8kgRAkU+s+RqrD4jj3CqOc=; h=Date:In-Reply-To:References:Subject:To:List-Id:List-Unsubscribe: List-Archive:List-Help:List-Subscribe:From:Reply-To:Cc:From; b=Dw9oS5TFC0t+7YZQF03Vtb3dQBreFKJzd3B3ZhEB3Th0u9GyD7LxM24aFEPAKgskR QLKfwBrhovcb5Kzfk8Ne2TZboT/+JCzOuwgzfIZI3tOTQiZ6rgbeAJifZDhaHrUfun QMNiktypH4fcpzJCzvcVk3iER89au/n3NUvgk20c= X-Original-To: libabigail@sourceware.org Delivered-To: libabigail@sourceware.org Received: from mail-wr1-x449.google.com (mail-wr1-x449.google.com [IPv6:2a00:1450:4864:20::449]) by sourceware.org (Postfix) with ESMTPS id AEA833973039 for ; Wed, 27 Jan 2021 12:59:38 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org AEA833973039 Received: by mail-wr1-x449.google.com with SMTP id z9so902062wro.11 for ; Wed, 27 Jan 2021 04:59:38 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=mWWVwPNTlI0pdwpcwUXgN8kgRAkU+s+RqrD4jj3CqOc=; b=aZdthjDopUki0kWNugBFs9DXEGmBKVjqQ7Fg6mQC7lrdYf61e2absEeKT1CxqPuYHl ZYErr0uYX4yaHQEQDmmK0Wbur3tyi75qnP71+MIl5udQwG95V/SiEGHXPfSWoetM4/cA NU+BSKzLucZb1PN677O3mfbxVmxoHtha1/UwNUTnckAbD74xmMDXwoLkhXXW8PFyyh1i Pv4T45FbyQ11aEkpTlXv6ysEIqUYPmKmv/53hgKp6Ow7gMAGIZpfDYPro64C8FdrB3uS PiPAcEZPhIQbiGRu3LAFLfum8JgZn+34dsHHoMahGsHat465OSk8Rbg5OCU2WUh8Ff26 0TnQ== X-Gm-Message-State: AOAM530aMmje5SfAvwHvkcH6Q7yBZrPatfqbvP9JV4QAZW/wStJP+bfw AldU45uzTjQEaHQTwocsbt3c8yyfJZBDrYVN9qDc9e+AZ0laB2mOG3MabbBNrYm8mrfCyCY72D8 ebm8fH7hihxTyUSuI4nd5yp+kFTraAg5nSpGD6hFb+3T1TZx8vCvd4wjnsck0QNDec3XzV58= X-Google-Smtp-Source: ABdhPJyECQg5N0xNeNQhPwQqLUPleuC9cHdDwrcu/qyTMimCUxFO5WRc654EWwtHJYWAGO7cU2gWEuqWKL6Rcw== X-Received: from lux.lon.corp.google.com ([2a00:79e0:d:210:7220:84ff:fe09:a3aa]) (user=maennich job=sendgmr) by 2002:adf:dd81:: with SMTP id x1mr11145840wrl.249.1611752377518; Wed, 27 Jan 2021 04:59:37 -0800 (PST) Date: Wed, 27 Jan 2021 12:58:47 +0000 In-Reply-To: <20210127125853.886677-1-maennich@google.com> Message-Id: <20210127125853.886677-15-maennich@google.com> Mime-Version: 1.0 References: <20200619214305.562-1-maennich@google.com> <20210127125853.886677-1-maennich@google.com> X-Mailer: git-send-email 2.30.0.280.ga3ce27912f-goog Subject: [PATCH 14/20] abg-corpus: remove symbol maps and their setters To: libabigail@sourceware.org X-Spam-Status: No, score=-23.2 required=5.0 tests=BAYES_00, DKIMWL_WL_MED, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libabigail@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Mailing list of the Libabigail project List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-Patchwork-Original-From: Matthias Maennich via Libabigail From: =?utf-8?q?Matthias_M=C3=A4nnich?= Reply-To: Matthias Maennich Cc: maennich@google.com, kernel-team@android.com Errors-To: libabigail-bounces@sourceware.org Sender: "Libabigail" With the prework in previous commits, we are now able to drop the public symbols maps in corpus::priv and replace them by private members with access through getters. The getters use the new symtab implementation to generate the maps on the fly. Setters are not required anymore and are removed. Also remove redundant getters. We could also remove the getters for the symbol maps and the local caching variable and leave it all to lookup_symbol, but this is left for a later change. * include/abg-corpus.h (corpus::set_fun_symbol_map): Remove method declaration. (corpus::set_undefined_fun_symbol_map): Likewise. (corpus::set_var_symbol_map): Likewise. (corpus::set_undefined_var_symbol_map): Likewise. (corpus::get_fun_symbol_map_sptr): Likewise. (corpus::get_undefined_fun_symbol_map_sptr): Likewise. (corpus::get_var_symbol_map_sptr): Likewise. (corpus::get_undefined_var_symbol_map_sptr): Likewise. * src/abg-corpus-priv.h (corpus::priv::var_symbol_map): make private and mutable (corpus::priv::undefined_var_symbol_map): Likewise. (corpus::priv::fun_symbol_map): Likewise. (corpus::priv::undefined_fun_symbol_map): Likewise. (corpus::priv::get_fun_symbol_map): New method declaration. (corpus::priv::get_undefined_fun_symbol_map): Likewise. (corpus::priv::get_var_symbol_map): Likewise. (corpus::priv::get_undefined_var_symbol_map): Likewise. * src/abg-corpus.cc (corpus::priv::get_fun_symbol_map): New method implementation. (corpus::priv::get_undefined_fun_symbol_map): Likewise. (corpus::priv::get_var_symbol_map): Likewise. (corpus::priv::get_undefined_var_symbol_map): Likewise. (corpus::is_empty): depend on symtab only. (corpus::set_fun_symbol_map): Remove method. (corpus::set_undefined_fun_symbol_map): Likewise. (corpus::set_var_symbol_map): Likewise. (corpus::set_undefined_var_symbol_map): Likewise. (corpus::get_fun_symbol_map_sptr): Likewise. (corpus::get_undefined_fun_symbol_map_sptr): Likewise. (corpus::get_var_symbol_map_sptr): Likewise. (corpus::get_undefined_var_symbol_map_sptr): Likewise. (corpus::get_fun_symbol_map): Use corpus::priv proxy method. (corpus::get_undefined_fun_symbol_map): Likewise. (corpus::get_var_symbol_map): Likewise. (corpus::get_undefined_var_symbol_map): Likewise. * src/abg-dwarf-reader.cc (read_debug_info_into_corpus): Do not set corpus symbol maps anymore. * src/abg-reader.cc (read_corpus_from_input): Likewise. * tests/test-symtab.cc (assert_symbol_count): Do not access the corpus symbol maps through sptr anymore. * tests/data/test-read-dwarf/PR25007-sdhci.ko.abi: Adjust expected test output. Reviewed-by: Giuliano Procida Signed-off-by: Matthias Maennich --- include/abg-corpus.h | 24 --- src/abg-corpus-priv.h | 21 ++- src/abg-corpus.cc | 139 +++++++----------- src/abg-dwarf-reader.cc | 45 ------ src/abg-reader.cc | 11 -- .../data/test-read-dwarf/PR25007-sdhci.ko.abi | 2 - tests/test-symtab.cc | 15 +- 7 files changed, 79 insertions(+), 178 deletions(-) diff --git a/include/abg-corpus.h b/include/abg-corpus.h index 425702182056..09f057d705f7 100644 --- a/include/abg-corpus.h +++ b/include/abg-corpus.h @@ -158,27 +158,9 @@ public: const symtab_reader::symtab_sptr& get_symtab() const; - void - set_fun_symbol_map(string_elf_symbols_map_sptr); - - void - set_undefined_fun_symbol_map(string_elf_symbols_map_sptr); - - void - set_var_symbol_map(string_elf_symbols_map_sptr); - - void - set_undefined_var_symbol_map(string_elf_symbols_map_sptr); - - const string_elf_symbols_map_sptr - get_fun_symbol_map_sptr() const; - virtual const string_elf_symbols_map_type& get_fun_symbol_map() const; - const string_elf_symbols_map_sptr - get_undefined_fun_symbol_map_sptr() const; - const string_elf_symbols_map_type& get_undefined_fun_symbol_map() const; @@ -188,15 +170,9 @@ public: const elf_symbols& get_sorted_undefined_fun_symbols() const; - const string_elf_symbols_map_sptr - get_var_symbol_map_sptr() const; - virtual const string_elf_symbols_map_type& get_var_symbol_map() const; - const string_elf_symbols_map_sptr - get_undefined_var_symbol_map_sptr() const; - const string_elf_symbols_map_type& get_undefined_var_symbol_map() const; diff --git a/src/abg-corpus-priv.h b/src/abg-corpus-priv.h index c8bf7f9d4cf6..27a6524c8b42 100644 --- a/src/abg-corpus-priv.h +++ b/src/abg-corpus-priv.h @@ -15,6 +15,7 @@ #define __ABG_CORPUS_PRIV_H__ #include "abg-internal.h" +#include "abg-ir.h" #include "abg-regex.h" #include "abg-sptr-utils.h" #include "abg-symtab-reader.h" @@ -681,11 +682,7 @@ struct corpus::priv string_tu_map_type path_tu_map; vector fns; vector vars; - string_elf_symbols_map_sptr var_symbol_map; - string_elf_symbols_map_sptr undefined_var_symbol_map; symtab_reader::symtab_sptr symtab_; - string_elf_symbols_map_sptr fun_symbol_map; - string_elf_symbols_map_sptr undefined_fun_symbol_map; // The type maps contained in this data member are populated if the // corpus follows the One Definition Rule and thus if there is only // one copy of a type with a given name, per corpus. Otherwise, if @@ -706,10 +703,14 @@ private: priv(); mutable abg_compat::optional sorted_var_symbols; + mutable abg_compat::optional var_symbol_map; mutable abg_compat::optional sorted_undefined_var_symbols; + mutable abg_compat::optional undefined_var_symbol_map; mutable abg_compat::optional unrefed_var_symbols; mutable abg_compat::optional sorted_fun_symbols; + mutable abg_compat::optional fun_symbol_map; mutable abg_compat::optional sorted_undefined_fun_symbols; + mutable abg_compat::optional undefined_fun_symbol_map; mutable abg_compat::optional unrefed_fun_symbols; public: @@ -731,18 +732,30 @@ public: const elf_symbols& get_sorted_fun_symbols() const; + const string_elf_symbols_map_type& + get_fun_symbol_map() const; + const elf_symbols& get_sorted_undefined_fun_symbols() const; + const string_elf_symbols_map_type& + get_undefined_fun_symbol_map() const; + const elf_symbols& get_unreferenced_function_symbols() const; const elf_symbols& get_sorted_var_symbols() const; + const string_elf_symbols_map_type& + get_var_symbol_map() const; + const elf_symbols& get_sorted_undefined_var_symbols() const; + const string_elf_symbols_map_type& + get_undefined_var_symbol_map() const; + const elf_symbols& get_unreferenced_variable_symbols() const; diff --git a/src/abg-corpus.cc b/src/abg-corpus.cc index f9f51a360707..94615bc727ff 100644 --- a/src/abg-corpus.cc +++ b/src/abg-corpus.cc @@ -331,6 +331,18 @@ corpus::priv::get_sorted_fun_symbols() const return *sorted_fun_symbols; } +const string_elf_symbols_map_type& +corpus::priv::get_fun_symbol_map() const +{ + if (!fun_symbol_map) + { + fun_symbol_map = string_elf_symbols_map_type(); + for (const auto& symbol : get_sorted_fun_symbols()) + (*fun_symbol_map)[symbol->get_name()].push_back(symbol); + } + return *fun_symbol_map; +} + /// Getter for a sorted vector of the function symbols undefined in /// this corpus. /// @@ -352,6 +364,18 @@ corpus::priv::get_sorted_undefined_fun_symbols() const return *sorted_undefined_fun_symbols; } +const string_elf_symbols_map_type& +corpus::priv::get_undefined_fun_symbol_map() const +{ + if (!undefined_fun_symbol_map) + { + undefined_fun_symbol_map = string_elf_symbols_map_type(); + for (const auto& symbol : get_sorted_undefined_fun_symbols()) + (*undefined_fun_symbol_map)[symbol->get_name()].push_back(symbol); + } + return *undefined_fun_symbol_map; +} + /// Return a list of symbols that are not referenced by any function of /// corpus::get_functions(). /// @@ -425,6 +449,18 @@ corpus::priv::get_sorted_var_symbols() const return *sorted_var_symbols; } +const string_elf_symbols_map_type& +corpus::priv::get_var_symbol_map() const +{ + if (!var_symbol_map) + { + var_symbol_map = string_elf_symbols_map_type(); + for (const auto& symbol : get_sorted_var_symbols()) + (*var_symbol_map)[symbol->get_name()].push_back(symbol); + } + return *var_symbol_map; +} + /// Getter for a sorted vector of the variable symbols undefined in /// this corpus. /// @@ -446,6 +482,18 @@ corpus::priv::get_sorted_undefined_var_symbols() const return *sorted_undefined_var_symbols; } +const string_elf_symbols_map_type& +corpus::priv::get_undefined_var_symbol_map() const +{ + if (!undefined_var_symbol_map) + { + undefined_var_symbol_map = string_elf_symbols_map_type(); + for (const auto& symbol : get_sorted_undefined_var_symbols()) + (*undefined_var_symbol_map)[symbol->get_name()].push_back(symbol); + } + return *undefined_var_symbol_map; +} + /// Return a list of symbols that are not referenced by any variable of /// corpus::get_variables(). /// @@ -883,10 +931,7 @@ corpus::is_empty() const } } return (members_empty - && priv_->fun_symbol_map - && priv_->fun_symbol_map->empty() - && priv_->var_symbol_map - && priv_->var_symbol_map->empty() + && !get_symtab()->has_symbols() && priv_->soname.empty() && priv_->needed.empty()); } @@ -920,69 +965,12 @@ const symtab_reader::symtab_sptr& corpus::get_symtab() const { return priv_->symtab_; } -/// Setter of the function symbols map. -/// -/// @param map a shared pointer to the new function symbols map. -void -corpus::set_fun_symbol_map(string_elf_symbols_map_sptr map) -{priv_->fun_symbol_map = map;} - -/// Setter for the map of function symbols that are undefined in this -/// corpus. -/// -/// @param map a new map for function symbols not defined in this -/// corpus. The key of the map is the name of the function symbol. -/// The value is a vector of all the function symbols that have the -/// same name. -void -corpus::set_undefined_fun_symbol_map(string_elf_symbols_map_sptr map) -{priv_->undefined_fun_symbol_map = map;} - -/// Setter of the variable symbols map. -/// -/// @param map a shared pointer to the new variable symbols map. -void -corpus::set_var_symbol_map(string_elf_symbols_map_sptr map) -{priv_->var_symbol_map = map;} - -/// Setter for the map of variable symbols that are undefined in this -/// corpus. -/// -/// @param map a new map for variable symbols not defined in this -/// corpus. The key of the map is the name of the variable symbol. -/// The value is a vector of all the variable symbols that have the -/// same name. -void -corpus::set_undefined_var_symbol_map(string_elf_symbols_map_sptr map) -{priv_->undefined_var_symbol_map = map;} - -/// Getter for the function symbols map. -/// -/// @return a shared pointer to the function symbols map. -const string_elf_symbols_map_sptr -corpus::get_fun_symbol_map_sptr() const -{ - if (!priv_->fun_symbol_map) - priv_->fun_symbol_map.reset(new string_elf_symbols_map_type); - return priv_->fun_symbol_map; -} - /// Getter for the function symbols map. /// /// @return a reference to the function symbols map. const string_elf_symbols_map_type& corpus::get_fun_symbol_map() const -{return *get_fun_symbol_map_sptr();} - -/// Getter for the map of function symbols that are undefined in this -/// corpus. -/// -/// @return the map of function symbols not defined in this corpus. -/// The key of the map is the name of the function symbol. The value -/// is a vector of all the function symbols that have the same name. -const string_elf_symbols_map_sptr -corpus::get_undefined_fun_symbol_map_sptr() const -{return priv_->undefined_fun_symbol_map;} +{return priv_->get_fun_symbol_map();} /// Getter for the map of function symbols that are undefined in this /// corpus. @@ -992,7 +980,7 @@ corpus::get_undefined_fun_symbol_map_sptr() const /// is a vector of all the function symbols that have the same name. const string_elf_symbols_map_type& corpus::get_undefined_fun_symbol_map() const -{return *get_undefined_fun_symbol_map_sptr();} +{return priv_->get_undefined_fun_symbol_map();} const elf_symbols& corpus::get_sorted_fun_symbols() const @@ -1010,33 +998,12 @@ const elf_symbols& corpus::get_sorted_undefined_var_symbols() const { return priv_->get_sorted_undefined_var_symbols(); } -/// Getter for the variable symbols map. -/// -/// @return a shared pointer to the variable symbols map. -const string_elf_symbols_map_sptr -corpus::get_var_symbol_map_sptr() const -{ - if (!priv_->var_symbol_map) - priv_->var_symbol_map.reset(new string_elf_symbols_map_type); - return priv_->var_symbol_map; -} - /// Getter for the variable symbols map. /// /// @return a reference to the variabl symbols map. const string_elf_symbols_map_type& corpus::get_var_symbol_map() const -{return *get_var_symbol_map_sptr();} - -/// Getter for the map of variable symbols that are undefined in this -/// corpus. -/// -/// @return the map of variable symbols not defined in this corpus. -/// The key of the map is the name of the variable symbol. The value -/// is a vector of all the variable symbols that have the same name. -const string_elf_symbols_map_sptr -corpus::get_undefined_var_symbol_map_sptr() const -{return priv_->undefined_var_symbol_map;} +{return priv_->get_var_symbol_map();} /// Getter for the map of variable symbols that are undefined in this /// corpus. @@ -1046,7 +1013,7 @@ corpus::get_undefined_var_symbol_map_sptr() const /// is a vector of all the variable symbols that have the same name. const string_elf_symbols_map_type& corpus::get_undefined_var_symbol_map() const -{return *get_undefined_var_symbol_map_sptr();} +{return priv_->get_undefined_var_symbol_map();} /// Look in the function symbols map for a symbol with a given name. /// diff --git a/src/abg-dwarf-reader.cc b/src/abg-dwarf-reader.cc index b2a7144afe9d..6d4e8ae23c53 100644 --- a/src/abg-dwarf-reader.cc +++ b/src/abg-dwarf-reader.cc @@ -14661,51 +14661,6 @@ read_debug_info_into_corpus(read_context& ctxt) // Set symbols information to the corpus. ctxt.current_corpus()->set_symtab(ctxt.symtab()); - if (!get_ignore_symbol_table(ctxt)) - { - if (ctxt.load_in_linux_kernel_mode() - && is_linux_kernel(ctxt.elf_handle())) - { - string_elf_symbols_map_sptr exported_fn_symbols_map - (new string_elf_symbols_map_type); - auto filter = ctxt.symtab()->make_filter(); - filter.set_functions(); - - for (const auto& symbol : - symtab_reader::filtered_symtab(*ctxt.symtab(), filter)) - { - (*exported_fn_symbols_map)[symbol->get_name()].push_back(symbol); - } - - ctxt.current_corpus()->set_fun_symbol_map(exported_fn_symbols_map); - - string_elf_symbols_map_sptr exported_var_symbols_map( - new string_elf_symbols_map_type); - filter = ctxt.symtab()->make_filter(); - filter.set_variables(); - for (const auto& symbol : - symtab_reader::filtered_symtab(*ctxt.symtab(), filter)) - { - (*exported_var_symbols_map)[symbol->get_name()].push_back(symbol); - } - ctxt.current_corpus()->set_var_symbol_map(exported_var_symbols_map); - } - else - { - ctxt.current_corpus()->set_fun_symbol_map(ctxt.fun_syms_sptr()); - ctxt.current_corpus()->set_var_symbol_map(ctxt.var_syms_sptr()); - } - - ctxt.current_corpus()->set_undefined_fun_symbol_map - (ctxt.undefined_fun_syms_sptr()); - ctxt.current_corpus()->set_undefined_var_symbol_map - (ctxt.undefined_var_syms_sptr()); - } - else - { - ctxt.current_corpus()->set_fun_symbol_map(ctxt.fun_syms_sptr()); - ctxt.current_corpus()->set_var_symbol_map(ctxt.var_syms_sptr()); - } // Get out now if no debug info is found. if (!ctxt.dwarf()) diff --git a/src/abg-reader.cc b/src/abg-reader.cc index c26689ae17ca..296e1e2115d1 100644 --- a/src/abg-reader.cc +++ b/src/abg-reader.cc @@ -1908,17 +1908,6 @@ read_corpus_from_input(read_context& ctxt) // are nil, due to potential suppression specifications. That's // fine. corp.set_symtab(symtab_reader::symtab::load(fn_sym_db, var_sym_db)); - - if (fn_sym_db) - { - corp.set_fun_symbol_map(fn_sym_db); - fn_sym_db.reset(); - } - if (var_sym_db) - { - corp.set_var_symbol_map(var_sym_db); - var_sym_db.reset(); - } } ctxt.get_environment()->canonicalization_is_done(false); diff --git a/tests/data/test-read-dwarf/PR25007-sdhci.ko.abi b/tests/data/test-read-dwarf/PR25007-sdhci.ko.abi index 1167e5aa478a..4c9a766f1c7c 100644 --- a/tests/data/test-read-dwarf/PR25007-sdhci.ko.abi +++ b/tests/data/test-read-dwarf/PR25007-sdhci.ko.abi @@ -37,8 +37,6 @@ - - diff --git a/tests/test-symtab.cc b/tests/test-symtab.cc index ff467d8ad345..2df766de1c5c 100644 --- a/tests/test-symtab.cc +++ b/tests/test-symtab.cc @@ -89,17 +89,19 @@ assert_symbol_count(const std::string& path, REQUIRE((status & dwarf_reader::STATUS_OK)); const corpus& corpus = *corpus_ptr; + size_t total_symbols = 0; + if (function_symbols != N) { CHECK(corpus.get_sorted_fun_symbols().size() == function_symbols); CHECK(corpus.get_fun_symbol_map().size() == function_symbols); - CHECK(corpus.get_fun_symbol_map_sptr()->size() == function_symbols); + total_symbols += function_symbols; } if (variable_symbols != N) { CHECK(corpus.get_sorted_var_symbols().size() == variable_symbols); CHECK(corpus.get_var_symbol_map().size() == variable_symbols); - CHECK(corpus.get_var_symbol_map_sptr()->size() == variable_symbols); + total_symbols += variable_symbols; } if (undefined_variable_symbols != N) { @@ -107,8 +109,7 @@ assert_symbol_count(const std::string& path, == undefined_function_symbols); CHECK(corpus.get_undefined_fun_symbol_map().size() == undefined_function_symbols); - CHECK(corpus.get_undefined_fun_symbol_map_sptr()->size() - == undefined_function_symbols); + total_symbols += undefined_function_symbols; } if (undefined_function_symbols != N) { @@ -116,10 +117,12 @@ assert_symbol_count(const std::string& path, == undefined_variable_symbols); CHECK(corpus.get_undefined_var_symbol_map().size() == undefined_variable_symbols); - CHECK(corpus.get_undefined_var_symbol_map_sptr()->size() - == undefined_variable_symbols); + total_symbols += undefined_variable_symbols; } + // assert the corpus reports being empty consistently with the symbol count + CHECK(corpus.is_empty() == (total_symbols == 0)); + return corpus_ptr; }