From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-io1-xd44.google.com (mail-io1-xd44.google.com [IPv6:2607:f8b0:4864:20::d44]) by sourceware.org (Postfix) with ESMTPS id BAD8F385B834 for ; Mon, 22 Jun 2020 09:56:21 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org BAD8F385B834 Received: by mail-io1-xd44.google.com with SMTP id c4so5205721iot.4 for ; Mon, 22 Jun 2020 02:56:21 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=pyWM3XGF7d8UwoFxUBHJksjREnDLaLXfMcGmyYl5iIY=; b=sYtc0wCt/MK/D1jaypYkacXeO31qwOwcGP7MGGspWY89pXQzS0MaMjZAJcadeNpDVk DTdEdaQ/zckzVecVNfWa2vAh7OllOXVWEfYY440TZYgtMxwxhUKCFsZBnVQvznG5TRtZ AqBDaMKKGxEoGh+4wICYnauybcPGfAyRfAsrqV/IXao6ojd0sDTf3ji1uN8kmF85GR1N n9yRkvSwV8qsEynj198O+eiWdTJiKHcHvm22+OLobaHuIprZrS0aXwRzUDCx1qCg0e6M rwA9xnaMvh7VsRxZQ/Lkj0eOHARkLAlObFvzJqv+s7Y0kfZtY2ChHPAFJAdElT1c6sQU dX7w== X-Gm-Message-State: AOAM532tbm/BZ0w2NYO6YBsDzloJPq1fd6JeAe1L64vo4hBKj0bVgZMk fbIYf9QObRk8klljaZD72QMrDFTCVY2Sx6Ai73kyiw== X-Google-Smtp-Source: ABdhPJz/OwaFmNnDl1mdtmwdMtxy560lgxjgGZF+XORAyBv9fLwwv7k+wD/RuNsW1AuRL6Q7i4TgbVjKFILFblLMJf4= X-Received: by 2002:a02:7616:: with SMTP id z22mr8943963jab.62.1592819780545; Mon, 22 Jun 2020 02:56:20 -0700 (PDT) MIME-Version: 1.0 References: <20200619214305.562-1-maennich@google.com> <20200619214305.562-17-maennich@google.com> In-Reply-To: <20200619214305.562-17-maennich@google.com> From: Giuliano Procida Date: Mon, 22 Jun 2020 10:56:03 +0100 Message-ID: Subject: Re: [PATCH v1 16/16] dwarf reader: drop (now) unused code related symbol table reading To: Matthias Maennich Cc: libabigail@sourceware.org, Dodji Seketeli , kernel-team@android.com Content-Type: text/plain; charset="UTF-8" X-Spam-Status: No, score=-29.6 required=5.0 tests=BAYES_00, DKIMWL_WL_MED, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, ENV_AND_HDR_SPF_MATCH, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, USER_IN_DEF_DKIM_WL, USER_IN_DEF_SPF_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-List-Received-Date: Mon, 22 Jun 2020 09:56:25 -0000 Hi. On Fri, 19 Jun 2020 at 22:43, Matthias Maennich wrote: > > The introduction of the new symtab reader incorporated much of the > existing functionality. Now that the most code parts are migrated to the > new symtab reader, we can safely remove the old code paths. > > Ignoring the symbol table is not a thing anymore. The new symtab reader > does read the symtab unconditionally for consistency reasons. Hence also > remove all functionality around conditional symtab reading. > > * include/abg-dwarf-reader.h (set_ignore_symbol_table): Remove. > (get_ignore_symbol_table): Likewise. > * src/abg-dwarf-reader.cc (add_symbol_to_map): Likewise. > (read_context::options_type::ignore_symbol_table): Likewise. > (read_context::options_type): Adjust. > (read_context::fun_addr_sym_map_): Remove. > (read_context::fun_entry_addr_sym_map_): Likewise. > (read_context::fun_syms_): Likewise. > (read_context::var_addr_sym_map_): Likewise. > (read_context::var_syms_): Likewise. > (read_context::undefined_fun_syms_): Likewise. > (read_context::undefined_var_syms_): Likewise. > (read_context::initialize): Adjust. > (read_context::lookup_elf_symbol_from_index): Remove. > (read_context::fun_entry_addr_sym_map_sptr): Likewise. > (read_context::fun_entry_addr_sym_map): Likewise. > (read_context::fun_syms_sptr): Likewise. > (read_context::fun_syms): Likewise. > (read_context::var_syms_sptr): Likewise. > (read_context::var_syms): Likewise. > (read_context::undefined_fun_syms_sptr): Likewise. > (read_context::undefined_var_syms_sptr): Likewise. > (read_context::load_symbol_maps_from_symtab_section): Likewise. > (read_context::load_symbol_maps): Likewise. > (read_context::maybe_load_symbol_maps): Likewise. > (set_ignore_symbol_table): Likewise. > (get_ignore_symbol_table): Likewise. > (create_default_var_sym): Likewise. > (build_var_decl): Adjust. > (function_is_suppressed): Likewise. > (variable_is_suppressed): Likewise. > (build_function_decl): Likewise. > (add_symbol_to_map): Remove. > (read_corpus_from_elf): Adjust. > (build_corpus_group_from_kernel_dist_under): Likewise. > * tools/abidw.cc (main): Likewise. > Reviewed-by: Giuliano Procida > Signed-off-by: Matthias Maennich > --- > include/abg-dwarf-reader.h | 6 - > src/abg-dwarf-reader.cc | 656 +------------------------------------ > src/abg-tools-utils.cc | 13 - > tools/abidw.cc | 2 - > 4 files changed, 12 insertions(+), 665 deletions(-) > > diff --git a/include/abg-dwarf-reader.h b/include/abg-dwarf-reader.h > index d0329aed9ccf..3f062e04502d 100644 > --- a/include/abg-dwarf-reader.h > +++ b/include/abg-dwarf-reader.h > @@ -195,12 +195,6 @@ set_drop_undefined_syms(read_context& ctxt, > void > set_do_log(read_context& ctxt, bool f); > > -void > -set_ignore_symbol_table(read_context &ctxt, bool f); > - > -bool > -get_ignore_symbol_table(const read_context &ctxt); > - > void > set_environment(read_context& ctxt, > ir::environment*); > diff --git a/src/abg-dwarf-reader.cc b/src/abg-dwarf-reader.cc > index 2b978c239243..b69fcc79cfd6 100644 > --- a/src/abg-dwarf-reader.cc > +++ b/src/abg-dwarf-reader.cc > @@ -291,10 +291,6 @@ static bool > operator<(const imported_unit_point& l, const imported_unit_point& r) > {return l.offset_of_import < r.offset_of_import;} > > -static void > -add_symbol_to_map(const elf_symbol_sptr& sym, > - string_elf_symbols_map_type& map); > - > static bool > get_parent_die(const read_context& ctxt, > const Dwarf_Die* die, > @@ -2026,7 +2022,6 @@ public: > environment* env; > bool load_in_linux_kernel_mode; > bool load_all_types; > - bool ignore_symbol_table; > bool show_stats; > bool do_log; > > @@ -2034,7 +2029,6 @@ public: > : env(), > load_in_linux_kernel_mode(), > load_all_types(), > - ignore_symbol_table(), > show_stats(), > do_log() > {} > @@ -2230,19 +2224,6 @@ public: > offset_offset_map_type alternate_die_parent_map_; > offset_offset_map_type type_section_die_parent_map_; > list var_decls_to_add_; > - addr_elf_symbol_sptr_map_sptr fun_addr_sym_map_; > - // On PPC64, the function entry point address is different from the > - // GElf_Sym::st_value value, which is the address of the descriptor > - // of the function. The map below thus associates the address of > - // the entry point to the function symbol. If we are not on ppc64, > - // then this map ought to be empty. Only the fun_addr_sym_map_ is > - // used in that case. On ppc64, though, both maps are used. > - addr_elf_symbol_sptr_map_sptr fun_entry_addr_sym_map_; > - string_elf_symbols_map_sptr fun_syms_; > - addr_elf_symbol_sptr_map_sptr var_addr_sym_map_; > - string_elf_symbols_map_sptr var_syms_; > - string_elf_symbols_map_sptr undefined_fun_syms_; > - string_elf_symbols_map_sptr undefined_var_syms_; > vector dt_needed_; > string dt_soname_; > string elf_architecture_; > @@ -2378,13 +2359,6 @@ public: > alternate_die_parent_map_.clear(); > type_section_die_parent_map_.clear(); > var_decls_to_add_.clear(); > - fun_addr_sym_map_.reset(); > - fun_entry_addr_sym_map_.reset(); > - fun_syms_.reset(); > - var_addr_sym_map_.reset(); > - var_syms_.reset(); > - undefined_fun_syms_.reset(); > - undefined_var_syms_.reset(); > dt_needed_.clear(); > dt_soname_.clear(); > elf_architecture_.clear(); > @@ -5044,88 +5018,6 @@ public: > return true; > } > > - /// Given the index of a symbol into the symbol table of an ELF > - /// file, look the symbol up, build an instace of @ref elf_symbol > - /// and return it. > - /// > - /// @param symbol_index the index of the symbol into the symbol > - /// table of the current elf file. > - /// > - /// @return the elf symbol found or nil if none was found. > - elf_symbol_sptr > - lookup_elf_symbol_from_index(size_t symbol_index) > - { > - GElf_Sym s; > - elf_symbol_sptr result = > - lookup_elf_symbol_from_index(symbol_index, s); > - return result; > - } > - > - /// Lookup an ELF symbol given its index into the .symtab section. > - /// > - /// This function returns both the native symbol (from libelf) and > - /// the @p abigail::ir::elf_symbol instance, which is the > - /// libabigail-specific representation of the symbol. > - /// > - /// @param symbol_index the index of the symbol to look for. > - /// > - /// @param native_sym output parameter. This is set to the native > - /// ELF symbol found iff the function returns a non-nil value. > - /// > - /// @return an instance of libabigail::ir::elf_symbol representing > - /// the ELF symbol found, iff one was found. Otherwise, returns > - /// nil. > - elf_symbol_sptr > - lookup_elf_symbol_from_index(size_t symbol_index, > - GElf_Sym &native_sym) > - { > - if (!lookup_native_elf_symbol_from_index(symbol_index, native_sym)) > - return elf_symbol_sptr(); > - > - Elf_Scn* symtab_section = find_symbol_table_section(); > - if (!symtab_section) > - return elf_symbol_sptr(); > - > - GElf_Shdr header_mem; > - GElf_Shdr* symtab_sheader = gelf_getshdr(symtab_section, > - &header_mem); > - > - Elf_Data* symtab = elf_getdata(symtab_section, 0); > - ABG_ASSERT(symtab); > - > - bool sym_is_defined = native_sym.st_shndx != SHN_UNDEF; > - bool sym_is_common = native_sym.st_shndx == SHN_COMMON; // this occurs in > - // relocatable > - // files. > - const char* name_str = elf_strptr(elf_handle(), > - symtab_sheader->sh_link, > - native_sym.st_name); > - if (name_str == 0) > - name_str = ""; > - > - elf_symbol::version ver; > - elf_helpers::get_version_for_symbol(elf_handle(), symbol_index, > - sym_is_defined, ver); > - > - elf_symbol::visibility vis = > - stv_to_elf_symbol_visibility(GELF_ST_VISIBILITY(native_sym.st_other)); > - > - Elf_Scn* strings_section = find_ksymtab_strings_section(elf_handle()); > - size_t strings_ndx = strings_section > - ? elf_ndxscn(strings_section) > - : 0; > - > - elf_symbol_sptr sym = > - elf_symbol::create(env(), symbol_index, native_sym.st_size, > - name_str, stt_to_elf_symbol_type > - (GELF_ST_TYPE(native_sym.st_info)), > - stb_to_elf_symbol_binding > - (GELF_ST_BIND(native_sym.st_info)), > - sym_is_defined, sym_is_common, ver, vis, > - native_sym.st_shndx == strings_ndx); > - return sym; > - } > - > /// Test if a given function symbol has been exported. > /// > /// @param symbol_address the address of the symbol we are looking > @@ -5206,102 +5098,6 @@ public: > return symtab_; > } > > - /// Getter for a pointer to the map that associates the address of > - /// an entry point of a function with the symbol of that function. > - /// > - /// Note that on non-"PPC64 ELFv1" binaries, this map is the same as > - /// the one that assciates the address of a function with the symbol > - /// of that function. > - /// > - /// @return a pointer to the map that associates the address of an > - /// entry point of a function with the symbol of that function. > - addr_elf_symbol_sptr_map_sptr& > - fun_entry_addr_sym_map_sptr() > - { > - if (!fun_entry_addr_sym_map_ && !fun_addr_sym_map_) > - maybe_load_symbol_maps(); > - if (architecture_is_ppc64(elf_handle())) > - return fun_entry_addr_sym_map_; > - return fun_addr_sym_map_; > - } > - > - /// Getter for the map that associates the address of an entry point > - /// of a function with the symbol of that function. > - /// > - /// Note that on non-"PPC64 ELFv1" binaries, this map is the same as > - /// the one that assciates the address of a function with the symbol > - /// of that function. > - /// > - /// @return the map that associates the address of an entry point of > - /// a function with the symbol of that function. > - addr_elf_symbol_sptr_map_type& > - fun_entry_addr_sym_map() > - {return *fun_entry_addr_sym_map_sptr();} > - > - /// Getter for the map of function symbols (name -> sym). > - /// > - /// @return a shared pointer to the map of function symbols. > - const string_elf_symbols_map_sptr& > - fun_syms_sptr() const > - { > - maybe_load_symbol_maps(); > - return fun_syms_; > - } > - > - /// Getter for the map of function symbols (name -> sym). > - /// > - /// @return a reference to the map of function symbols. > - string_elf_symbols_map_type& > - fun_syms() > - { > - maybe_load_symbol_maps(); > - return *fun_syms_; > - } > - > - /// Getter for the map of variable symbols (name -> sym) > - /// > - /// @return a shared pointer to the map of variable symbols. > - const string_elf_symbols_map_sptr > - var_syms_sptr() const > - { > - maybe_load_symbol_maps(); > - return var_syms_; > - } > - > - /// Getter for the map of variable symbols (name -> sym) > - /// > - /// @return a reference to the map of variable symbols. > - string_elf_symbols_map_type& > - var_syms() > - { > - maybe_load_symbol_maps(); > - return *var_syms_; > - } > - > - /// Getter for the map of undefined function symbols (name -> vector > - /// of symbols). > - /// > - /// @return a (smart) pointer to the map of undefined function > - /// symbols. > - const string_elf_symbols_map_sptr& > - undefined_fun_syms_sptr() const > - { > - maybe_load_symbol_maps(); > - return undefined_fun_syms_; > - } > - > - /// Getter for the map of undefined variable symbols (name -> vector > - /// of symbols). > - /// > - /// @return a (smart) pointer to the map of undefined variable > - /// symbols. > - const string_elf_symbols_map_sptr& > - undefined_var_syms_sptr() const > - { > - maybe_load_symbol_maps(); > - return undefined_var_syms_; > - } > - > /// Getter for the ELF dt_needed tag. > const vector& > dt_needed() const > @@ -5317,232 +5113,6 @@ public: > elf_architecture() const > {return elf_architecture_;} > > - /// Load the maps address -> function symbol, address -> variable > - /// symbol and the maps of function and variable undefined symbols. > - /// > - /// @param load_fun_map whether to load the address to function map. > - /// > - /// @param load_var_map whether to laod the address to variable map. > - /// > - /// @param load_undefined_fun_map whether to load the undefined > - /// function map. > - /// > - /// @param load_undefined_var_map whether to laod the undefined > - /// variable map. > - /// > - /// @return return true iff the maps have be loaded. > - bool > - load_symbol_maps_from_symtab_section(bool load_fun_map, > - bool load_var_map, > - bool load_undefined_fun_map, > - bool load_undefined_var_map) > - { > - Elf_Scn* symtab_section = find_symbol_table_section(); > - if (!symtab_section) > - return false; > - > - GElf_Shdr header_mem; > - GElf_Shdr* symtab_sheader = gelf_getshdr(symtab_section, > - &header_mem); > - > - // check for bogus section header > - if (symtab_sheader->sh_entsize == 0) > - return false; > - > - size_t nb_syms = symtab_sheader->sh_size / symtab_sheader->sh_entsize; > - > - Elf_Data* symtab = elf_getdata(symtab_section, 0); > - if (!symtab) > - return false; > - > - GElf_Ehdr elf_header; > - ABG_ASSERT(gelf_getehdr(elf_handle(), &elf_header)); > - > - bool is_ppc64 = architecture_is_ppc64(elf_handle()); > - > - for (size_t i = 0; i < nb_syms; ++i) > - { > - GElf_Sym* sym, sym_mem; > - sym = gelf_getsym(symtab, i, &sym_mem); > - ABG_ASSERT(sym); > - > - if ((load_fun_map || load_undefined_fun_map) > - && (GELF_ST_TYPE(sym->st_info) == STT_FUNC > - || GELF_ST_TYPE(sym->st_info) == STT_GNU_IFUNC)) > - { > - elf_symbol_sptr symbol = lookup_elf_symbol_from_index(i); > - ABG_ASSERT(symbol); > - ABG_ASSERT(symbol->is_function()); > - > - // If the symbol was suppressed by a suppression > - // specification then drop it on the floor. > - if (is_elf_symbol_suppressed(symbol)) > - continue; > - > - if (load_fun_map && symbol->is_public()) > - { > - (*fun_syms_)[symbol->get_name()].push_back(symbol); > - > - { > - GElf_Addr symbol_value = > - maybe_adjust_et_rel_sym_addr_to_abs_addr(elf_handle(), > - sym); > - > - addr_elf_symbol_sptr_map_type::const_iterator it = > - fun_addr_sym_map_->find(symbol_value); > - if (it == fun_addr_sym_map_->end()) > - (*fun_addr_sym_map_)[symbol_value] = symbol; > - else //if (sym->st_value != 0) > - it->second->get_main_symbol()->add_alias(symbol); > - > - if (is_ppc64) > - { > - // For ppc64 ELFv1 binaries, we need to build a > - // function entry point address -> function > - // symbol map. This is in addition to the > - // function pointer -> symbol map. This is > - // because on ppc64 ELFv1, a function pointer is > - // different from a function entry point > - // address. > - // > - // On ppc64 ELFv1, the DWARF DIE of a function > - // references the address of the entry point of > - // the function symbol; whereas the value of the > - // function symbol is the function pointer. As > - // these addresses are different, if I we want > - // to get to the symbol of a function from its > - // entry point address (as referenced by DWARF > - // function DIEs) we must have the two maps I > - // mentionned right above. > - // > - // In other words, we need a map that associates > - // a function enty point address with the symbol > - // of that function, to be able to get the > - // function symbol that corresponds to a given > - // function DIE, on ppc64. > - // > - // The value of the function pointer (the value > - // of the symbol) usually refers to the offset > - // of a table in the .opd section. But > - // sometimes, for a symbol named "foo", the > - // corresponding symbol named ".foo" (note the > - // dot before foo) which value is the entry > - // point address of the function; that entry > - // point address refers to a region in the .text > - // section. > - // > - // So we are only interested in values of the > - // symbol that are in the .opd section. > - GElf_Addr fn_desc_addr = sym->st_value; > - GElf_Addr fn_entry_point_addr = > - lookup_ppc64_elf_fn_entry_point_address( > - elf_handle(), fn_desc_addr); > - addr_elf_symbol_sptr_map_type::const_iterator it2 = > - fun_entry_addr_sym_map().find(fn_entry_point_addr); > - > - if (it2 == fun_entry_addr_sym_map().end()) > - fun_entry_addr_sym_map()[fn_entry_point_addr] = symbol; > - else if (address_is_in_opd_section(elf_handle(), > - fn_desc_addr)) > - { > - // Either > - // > - // 'symbol' must have been registered as an > - // alias for it2->second->get_main_symbol(), > - // right before the "if (ppc64)" statement. > - // > - // Or > - // > - // if the name of 'symbol' is foo, then the > - // name of it2->second is ".foo". That is, > - // foo is the name of the symbol when it > - // refers to the function descriptor in the > - // .opd section and ".foo" is an internal > - // name for the address of the entry point > - // of foo. > - // > - // In the latter case, we just want to keep > - // a refernce to "foo" as .foo is an > - // internal name. > - > - bool two_symbols_alias = > - it2->second->get_main_symbol()->does_alias(*symbol); > - bool symbol_is_foo_and_prev_symbol_is_dot_foo = > - (it2->second->get_name() > - == string(".") + symbol->get_name()); > - > - ABG_ASSERT(two_symbols_alias > - || symbol_is_foo_and_prev_symbol_is_dot_foo); > - > - if (symbol_is_foo_and_prev_symbol_is_dot_foo) > - // Let's just keep a reference of the > - // symbol that the user sees in the source > - // code (the one named foo). The symbol > - // which name is prefixed with a "dot" is > - // an artificial one. > - fun_entry_addr_sym_map()[fn_entry_point_addr] = symbol; > - } > - } > - } > - } > - else if (load_undefined_fun_map && !symbol->is_defined()) > - (*undefined_fun_syms_)[symbol->get_name()].push_back(symbol); > - } > - else if ((load_var_map || load_undefined_var_map) > - && (GELF_ST_TYPE(sym->st_info) == STT_OBJECT > - || GELF_ST_TYPE(sym->st_info) == STT_TLS) > - // If the symbol is for an OBJECT, the index of the > - // section it refers to cannot be absolute. > - // Otherwise that OBJECT is not a variable. > - && (sym->st_shndx != SHN_ABS > - || GELF_ST_TYPE(sym->st_info) != STT_OBJECT )) > - { > - elf_symbol_sptr symbol = lookup_elf_symbol_from_index(i); > - ABG_ASSERT(symbol); > - ABG_ASSERT(symbol->is_variable()); > - > - if (load_var_map && symbol->is_public()) > - { > - (*var_syms_)[symbol->get_name()].push_back(symbol); > - > - if (symbol->is_common_symbol()) > - { > - string_elf_symbols_map_type::iterator it = > - var_syms_->find(symbol->get_name()); > - ABG_ASSERT(it != var_syms_->end()); > - const elf_symbols& common_sym_instances = it->second; > - ABG_ASSERT(!common_sym_instances.empty()); > - if (common_sym_instances.size() > 1) > - { > - elf_symbol_sptr main_common_sym = > - common_sym_instances[0]; > - ABG_ASSERT(main_common_sym->get_name() > - == symbol->get_name()); > - ABG_ASSERT(main_common_sym->is_common_symbol()); > - ABG_ASSERT(symbol.get() != main_common_sym.get()); > - main_common_sym->add_common_instance(symbol); > - } > - } > - else > - { > - GElf_Addr symbol_value = > - maybe_adjust_et_rel_sym_addr_to_abs_addr(elf_handle(), > - sym); > - addr_elf_symbol_sptr_map_type::const_iterator it = > - var_addr_sym_map_->find(symbol_value); > - if (it == var_addr_sym_map_->end()) > - (*var_addr_sym_map_)[symbol_value] = symbol; > - else > - it->second->get_main_symbol()->add_alias(symbol); > - } > - } > - else if (load_undefined_var_map && !symbol->is_defined()) > - (*undefined_var_syms_)[symbol->get_name()].push_back(symbol); > - } > - } > - return true; > - } > - > /// Test if a given ELF symbol was suppressed by a suppression > /// specification. > /// > @@ -5558,71 +5128,6 @@ public: > symbol->get_type())); > } > > - /// Load the maps of function symbol address -> function symbol, > - /// global variable symbol address -> variable symbol and also the > - /// maps of function and variable undefined symbols. > - /// > - /// All these maps are loaded only if they are not loaded already. > - /// > - /// @return true iff everything went fine. > - bool > - load_symbol_maps() > - { > - bool load_fun_map = !fun_addr_sym_map_ ; > - bool load_var_map = !var_addr_sym_map_; > - bool load_undefined_fun_map = !undefined_fun_syms_; > - bool load_undefined_var_map = !undefined_var_syms_; > - > - if (!fun_syms_) > - fun_syms_.reset(new string_elf_symbols_map_type); > - > - if (!fun_addr_sym_map_) > - fun_addr_sym_map_.reset(new addr_elf_symbol_sptr_map_type); > - > - if (!fun_entry_addr_sym_map_ && architecture_is_ppc64(elf_handle())) > - fun_entry_addr_sym_map_.reset(new addr_elf_symbol_sptr_map_type); > - > - if (!var_syms_) > - var_syms_.reset(new string_elf_symbols_map_type); > - > - if (!var_addr_sym_map_) > - var_addr_sym_map_.reset(new addr_elf_symbol_sptr_map_type); > - > - if (!undefined_fun_syms_) > - undefined_fun_syms_.reset(new string_elf_symbols_map_type); > - > - if (!undefined_var_syms_) > - undefined_var_syms_.reset(new string_elf_symbols_map_type); > - > - if (!options_.ignore_symbol_table) > - { > - if (load_symbol_maps_from_symtab_section(load_fun_map, > - load_var_map, > - load_undefined_fun_map, > - load_undefined_var_map)) > - return true; > - return false; > - } > - return true; > - } > - > - /// Load the symbol maps if necessary. > - /// > - /// @return true iff the symbol maps has been loaded by this > - /// invocation. > - bool > - maybe_load_symbol_maps() const > - { > - if (!fun_addr_sym_map_ > - || !var_addr_sym_map_ > - || !fun_syms_ > - || !var_syms_ > - || !undefined_fun_syms_ > - || !undefined_var_syms_) > - return const_cast(this)->load_symbol_maps(); > - return false; > - } > - > /// Load the DT_NEEDED and DT_SONAME elf TAGS. > /// > void > @@ -6494,46 +5999,6 @@ void > set_do_log(read_context& ctxt, bool f) > {ctxt.do_log(f);} > > -/// Setter of the "set_ignore_symbol_table" flag. > -/// > -/// This flag tells if we should load information about ELF symbol > -/// tables. Not loading the symbol tables is a speed optimization > -/// that is done when the set of symbols we care about is provided > -/// off-hand. This is the case when we are supposed to analyze a > -/// Linux kernel binary. In that case, because we have the white list > -/// of functions/variable symbols we care about, we don't need to > -/// analyze the symbol table; things are thus faster in that case. > -/// > -/// By default, the symbol table is analyzed so this boolean is set to > -/// false. > -/// > -/// @param ctxt the read context to consider. > -/// > -/// @param f the new value of the flag. > -void > -set_ignore_symbol_table(read_context &ctxt, bool f) > -{ctxt.options_.ignore_symbol_table = f;} > - > -/// Getter of the "set_ignore_symbol_table" flag. > -/// > -/// This flag tells if we should load information about ELF symbol > -/// tables. Not loading the symbol tables is a speed optimization > -/// that is done when the set of symbols we care about is provided > -/// off-hand. This is the case when we are supposed to analyze a > -/// Linux kernel binary. In that case, because we have the white list > -/// of functions/variable symbols we care about, we don't need to > -/// analyze the symbol table; things are thus faster in that case. > -/// > -/// By default, the symbol table is analyzed so this boolean is set to > -/// false. > -/// > -/// @param ctxt the read context to consider. > -/// > -/// @return the value of the flag. > -bool > -get_ignore_symbol_table(const read_context& ctxt) > -{return ctxt.options_.ignore_symbol_table;} > - > /// Test if a given DIE is anonymous > /// > /// @param die the DIE to consider. > @@ -13483,33 +12948,6 @@ build_or_get_var_decl_if_not_suppressed(read_context& ctxt, > return var; > } > > -/// Create a variable symbol with a given name. > -/// > -/// @param sym_name the name of the variable symbol. > -/// > -/// @param env the environment to create the default symbol in. > -/// > -/// @return the newly created symbol. > -static elf_symbol_sptr > -create_default_var_sym(const string& sym_name, const environment *env) > -{ > - elf_symbol::version ver; > - elf_symbol::visibility vis = elf_symbol::DEFAULT_VISIBILITY; > - elf_symbol_sptr result = > - elf_symbol::create(env, > - /*symbol index=*/ 0, > - /*symbol size=*/ 0, > - sym_name, > - /*symbol type=*/ elf_symbol::OBJECT_TYPE, > - /*symbol binding=*/ elf_symbol::GLOBAL_BINDING, > - /*symbol is defined=*/ true, > - /*symbol is common=*/ false, > - /*symbol version=*/ ver, > - /*symbol_visibility=*/vis, > - /*is_linux_string_cst=*/false); > - return result; > -} > - > /// Build a @ref var_decl out of a DW_TAG_variable DIE. > /// > /// @param ctxt the read context to use. > @@ -13581,23 +13019,9 @@ build_var_decl(read_context& ctxt, > if (!result->get_symbol()) > { > elf_symbol_sptr var_sym; > - if (get_ignore_symbol_table(ctxt)) > - { > - string var_name = > - result->get_linkage_name().empty() > - ? result->get_name() > - : result->get_linkage_name(); > - > - var_sym = create_default_var_sym(var_name, ctxt.env()); > - ABG_ASSERT(var_sym); > - add_symbol_to_map(var_sym, ctxt.var_syms()); > - } > - else > - { > - Dwarf_Addr var_addr; > - if (ctxt.get_variable_address(die, var_addr)) > - var_sym = var_sym = ctxt.variable_symbol_is_exported(var_addr); > - } > + Dwarf_Addr var_addr; > + if (ctxt.get_variable_address(die, var_addr)) > + var_sym = var_sym = ctxt.variable_symbol_is_exported(var_addr); > > if (var_sym) > { > @@ -13658,15 +13082,9 @@ function_is_suppressed(const read_context& ctxt, > Dwarf_Addr fn_addr; > if (!ctxt.get_function_address(function_die, fn_addr)) > return true; > - if (!get_ignore_symbol_table(ctxt)) > - { > - // We were not instructed to ignore (avoid loading) the > - // symbol table, so we can rely on its presence to see if > - // the address corresponds to the address of an exported > - // function symbol. > - if (!ctxt.function_symbol_is_exported(fn_addr)) > - return true; > - } > + > + if (!ctxt.function_symbol_is_exported(fn_addr)) > + return true; > } > > return suppr::function_is_suppressed(ctxt, qualified_name, > @@ -13769,15 +13187,9 @@ variable_is_suppressed(const read_context& ctxt, > Dwarf_Addr var_addr = 0; > if (!ctxt.get_variable_address(variable_die, var_addr)) > return true; > - if (!get_ignore_symbol_table(ctxt)) > - { > - // We were not instructed to ignore (avoid loading) the > - // symbol table, so we can rely on its presence to see if > - // the address corresponds to the address of an exported > - // variable symbol. > - if (!ctxt.variable_symbol_is_exported(var_addr)) > - return true; > - } > + > + if (!ctxt.variable_symbol_is_exported(var_addr)) > + return true; > } > > return suppr::variable_is_suppressed(ctxt, qualified_name, > @@ -14028,23 +13440,9 @@ build_function_decl(read_context& ctxt, > if (!result->get_symbol()) > { > elf_symbol_sptr fn_sym; > - if (get_ignore_symbol_table(ctxt)) > - { > - string fn_name = > - result->get_linkage_name().empty() > - ? result->get_name() > - : result->get_linkage_name(); > - > - fn_sym = create_default_fn_sym(fn_name, ctxt.env()); > - ABG_ASSERT(fn_sym); > - add_symbol_to_map(fn_sym, ctxt.fun_syms()); > - } > - else > - { > - Dwarf_Addr fn_addr; > - if (ctxt.get_function_address(die, fn_addr)) > - fn_sym = ctxt.function_symbol_is_exported(fn_addr); > - } > + Dwarf_Addr fn_addr; > + if (ctxt.get_function_address(die, fn_addr)) > + fn_sym = ctxt.function_symbol_is_exported(fn_addr); > > if (fn_sym) > { > @@ -14074,29 +13472,6 @@ build_function_decl(read_context& ctxt, > return result; > } > > -/// Add a symbol to a symbol map. > -/// > -/// @param sym the symbol to add. > -/// > -/// @param map the symbol map to add the symbol into. > -static void > -add_symbol_to_map(const elf_symbol_sptr& sym, > - string_elf_symbols_map_type& map) > -{ > - if (!sym) > - return; > - > - string_elf_symbols_map_type::iterator it = map.find(sym->get_name()); > - if (it == map.end()) > - { > - elf_symbols syms; > - syms.push_back(sym); > - map[sym->get_name()] = syms; > - } > - else > - it->second.push_back(sym); > -} > - > /// Read all @ref abigail::translation_unit possible from the debug info > /// accessible through a DWARF Front End Library handle, and stuff > /// them into a libabigail ABI Corpus. > @@ -15341,13 +14716,6 @@ read_corpus_from_elf(read_context& ctxt, status& status) > > ctxt.load_elf_properties(); // DT_SONAME, DT_NEEDED, architecture > > - if (!get_ignore_symbol_table(ctxt)) > - { > - // Read the symbols for publicly defined decls > - if (!ctxt.load_symbol_maps()) > - status |= STATUS_NO_SYMBOLS_FOUND; > - } > - > if (!ctxt.symtab() || !ctxt.symtab()->has_symbols()) > status |= STATUS_NO_SYMBOLS_FOUND; > > diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc > index dfbec879de8d..9116a97a62e9 100644 > --- a/src/abg-tools-utils.cc > +++ b/src/abg-tools-utils.cc > @@ -2563,12 +2563,6 @@ build_corpus_group_from_kernel_dist_under(const string& root, > << t > << "\n"; > > - // If we have been given a whitelist of functions and > - // variable symbols to look at, then we can avoid loading > - // and analyzing the ELF symbol table. > - bool do_ignore_symbol_table = !kabi_wl_paths.empty(); > - set_ignore_symbol_table(*ctxt, do_ignore_symbol_table); > - > group.reset(new corpus_group(env.get(), root)); > > set_read_context_corpus_group(*ctxt, group); > @@ -2608,13 +2602,6 @@ build_corpus_group_from_kernel_dist_under(const string& root, > /*read_all_types=*/false, > /*linux_kernel_mode=*/true); > > - // If we have been given a whitelist of functions and > - // variable symbols to look at, then we can avoid loading > - // and analyzing the ELF symbol table. > - bool do_ignore_symbol_table = !kabi_wl_paths.empty(); > - > - set_ignore_symbol_table(*ctxt, do_ignore_symbol_table); > - > load_generate_apply_suppressions(*ctxt, suppr_paths, > kabi_wl_paths, supprs); > > diff --git a/tools/abidw.cc b/tools/abidw.cc > index 2cd848df9fb8..58072e7072c4 100644 > --- a/tools/abidw.cc > +++ b/tools/abidw.cc > @@ -828,8 +828,6 @@ main(int argc, char* argv[]) > set_show_stats(ctxt, opts.show_stats); > set_suppressions(ctxt, opts); > abigail::dwarf_reader::set_do_log(ctxt, opts.do_log); > - if (!opts.kabi_whitelist_supprs.empty()) > - set_ignore_symbol_table(ctxt, true); > > if (opts.check_alt_debug_info_path) > { > -- > 2.27.0.111.gc72c7da667-goog >