// dynobj.h -- dynamic object support for gold   -*- C++ -*-

// Copyright (C) 2006-2024 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <[email protected]>.

// This file is part of gold.

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
// MA 02110-1301, USA.

#ifndef GOLD_DYNOBJ_H
#define GOLD_DYNOBJ_H

#include <vector>

#include "stringpool.h"
#include "object.h"

namespace gold
{

class Version_script_info;

// A dynamic object (ET_DYN).  This is an abstract base class itself.
// The implementations is the template class Sized_dynobj.

class Dynobj : public Object
{
public:
 // We keep a list of all the DT_NEEDED entries we find.
 typedef std::vector<std::string> Needed;

 Dynobj(const std::string& name, Input_file* input_file, off_t offset = 0);

 // Return the name to use in a DT_NEEDED entry for this object.
 const char*
 soname() const
 { return this->soname_.c_str(); }

 // Return the list of DT_NEEDED strings.
 const Needed&
 needed() const
 { return this->needed_; }

 // Return whether this dynamic object has any DT_NEEDED entries
 // which were not seen during the link.
 bool
 has_unknown_needed_entries() const
 {
   gold_assert(this->unknown_needed_ != UNKNOWN_NEEDED_UNSET);
   return this->unknown_needed_ == UNKNOWN_NEEDED_TRUE;
 }

 // Set whether this dynamic object has any DT_NEEDED entries which
 // were not seen during the link.
 void
 set_has_unknown_needed_entries(bool set)
 {
   gold_assert(this->unknown_needed_ == UNKNOWN_NEEDED_UNSET);
   this->unknown_needed_ = set ? UNKNOWN_NEEDED_TRUE : UNKNOWN_NEEDED_FALSE;
 }

 // Return the word size of the object file.
 int
 elfsize() const
 { gold_unreachable(); }

 // Return TRUE if this is a big-endian object file.
 bool
 is_big_endian() const
 { gold_unreachable(); }

 // Compute the ELF hash code for a string.
 static uint32_t
 elf_hash(const char*);

 // Create a standard ELF hash table, setting *PPHASH and *PHASHLEN.
 // DYNSYMS is the global dynamic symbols.  LOCAL_DYNSYM_COUNT is the
 // number of local dynamic symbols, which is the index of the first
 // dynamic gobal symbol.
 static void
 create_elf_hash_table(const std::vector<Symbol*>& dynsyms,
                       unsigned int local_dynsym_count,
                       unsigned char** pphash,
                       unsigned int* phashlen);

 // Create a GNU hash table, setting *PPHASH and *PHASHLEN.  DYNSYMS
 // is the global dynamic symbols.  LOCAL_DYNSYM_COUNT is the number
 // of local dynamic symbols, which is the index of the first dynamic
 // gobal symbol.
 static void
 create_gnu_hash_table(const std::vector<Symbol*>& dynsyms,
                       unsigned int local_dynsym_count,
                       unsigned char** pphash, unsigned int* phashlen);

protected:
 // Return a pointer to this object.
 virtual Dynobj*
 do_dynobj()
 { return this; }

 // Set the DT_SONAME string.
 void
 set_soname_string(const char* s)
 { this->soname_.assign(s); }

 // Add an entry to the list of DT_NEEDED strings.
 void
 add_needed(const char* s)
 { this->needed_.push_back(std::string(s)); }

private:
 // Compute the GNU hash code for a string.
 static uint32_t
 gnu_hash(const char*);

 // Compute the number of hash buckets to use.
 static unsigned int
 compute_bucket_count(const std::vector<uint32_t>& hashcodes,
                      bool for_gnu_hash_table);

 // Sized version of create_elf_hash_table.
 template<int size, bool big_endian>
 static void
 sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
                             const std::vector<uint32_t>& chain,
                             unsigned char* phash,
                             unsigned int hashlen);

 // Sized version of create_gnu_hash_table.
 template<int size, bool big_endian>
 static void
 sized_create_gnu_hash_table(const std::vector<Symbol*>& hashed_dynsyms,
                             const std::vector<uint32_t>& dynsym_hashvals,
                             unsigned int unhashed_dynsym_count,
                             unsigned char** pphash,
                             unsigned int* phashlen);

 // Values for the has_unknown_needed_entries_ field.
 enum Unknown_needed
 {
   UNKNOWN_NEEDED_UNSET,
   UNKNOWN_NEEDED_TRUE,
   UNKNOWN_NEEDED_FALSE
 };

 // The DT_SONAME name, if any.
 std::string soname_;
 // The list of DT_NEEDED entries.
 Needed needed_;
 // Whether this dynamic object has any DT_NEEDED entries not seen
 // during the link.
 Unknown_needed unknown_needed_;
};

// A dynamic object, size and endian specific version.

template<int size, bool big_endian>
class Sized_dynobj : public Dynobj
{
public:
 typedef typename Sized_relobj_file<size, big_endian>::Symbols Symbols;

 Sized_dynobj(const std::string& name, Input_file* input_file, off_t offset,
              const typename elfcpp::Ehdr<size, big_endian>&);

 // Set up the object file based on TARGET.
 void
 setup();

 // Read the symbols.
 void
 do_read_symbols(Read_symbols_data*);

 // Lay out the input sections.
 void
 do_layout(Symbol_table*, Layout*, Read_symbols_data*);

 // Add the symbols to the symbol table.
 void
 do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);

 Archive::Should_include
 do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
                          std::string* why);

 // Iterate over global symbols, calling a visitor class V for each.
 void
 do_for_all_global_symbols(Read_symbols_data* sd,
                           Library_base::Symbol_visitor_base* v);

 // Iterate over local symbols, calling a visitor class V for each GOT offset
 // associated with a local symbol.
 void
 do_for_all_local_got_entries(Got_offset_list::Visitor* v) const;

 // Get the size of a section.
 uint64_t
 do_section_size(unsigned int shndx)
 { return this->elf_file_.section_size(shndx); }

 // Get the name of a section.
 std::string
 do_section_name(unsigned int shndx) const
 { return this->elf_file_.section_name(shndx); }

 // Return a view of the contents of a section.  Set *PLEN to the
 // size.
 const unsigned char*
 do_section_contents(unsigned int shndx, section_size_type* plen,
                     bool cache)
 {
   Location loc(this->elf_file_.section_contents(shndx));
   *plen = convert_to_section_size_type(loc.data_size);
   if (*plen == 0)
     {
       static const unsigned char empty[1] = { '\0' };
       return empty;
     }
   return this->get_view(loc.file_offset, *plen, true, cache);
 }

 // Return section flags.
 uint64_t
 do_section_flags(unsigned int shndx)
 { return this->elf_file_.section_flags(shndx); }

 // Not used for dynobj.
 uint64_t
 do_section_entsize(unsigned int )
 { gold_unreachable(); }

 // Return section address.
 uint64_t
 do_section_address(unsigned int shndx)
 { return this->elf_file_.section_addr(shndx); }

 // Return section type.
 unsigned int
 do_section_type(unsigned int shndx)
 { return this->elf_file_.section_type(shndx); }

 // Return the section link field.
 unsigned int
 do_section_link(unsigned int shndx)
 { return this->elf_file_.section_link(shndx); }

 // Return the section link field.
 unsigned int
 do_section_info(unsigned int shndx)
 { return this->elf_file_.section_info(shndx); }

 // Return the section alignment.
 uint64_t
 do_section_addralign(unsigned int shndx)
 { return this->elf_file_.section_addralign(shndx); }

 // Return the Xindex structure to use.
 Xindex*
 do_initialize_xindex();

 // Get symbol counts.
 void
 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;

 // Get the global symbols.
 const Symbols*
 do_get_global_symbols() const
 { return this->symbols_; }

protected:
 // Read the symbols.  This is common code for all target-specific
 // overrides of do_read_symbols().
 void
 base_read_symbols(Read_symbols_data*);

private:
 // For convenience.
 typedef Sized_dynobj<size, big_endian> This;
 static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 static const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
 typedef elfcpp::Shdr<size, big_endian> Shdr;
 typedef elfcpp::Dyn<size, big_endian> Dyn;

 // Adjust a section index if necessary.
 unsigned int
 adjust_shndx(unsigned int shndx)
 {
   if (shndx >= elfcpp::SHN_LORESERVE)
     shndx += this->elf_file_.large_shndx_offset();
   return shndx;
 }

 // Find the dynamic symbol table and the version sections, given the
 // section headers.
 void
 find_dynsym_sections(const unsigned char* pshdrs,
                      unsigned int* pversym_shndx,
                      unsigned int* pverdef_shndx,
                      unsigned int* pverneed_shndx,
                      unsigned int* pdynamic_shndx);

 // Read the dynamic symbol section SHNDX.
 void
 read_dynsym_section(const unsigned char* pshdrs, unsigned int shndx,
                     elfcpp::SHT type, unsigned int link,
                     File_view** view, section_size_type* view_size,
                     unsigned int* view_info);

 // Read the dynamic tags.
 void
 read_dynamic(const unsigned char* pshdrs, unsigned int dynamic_shndx,
              unsigned int strtab_shndx, const unsigned char* strtabu,
              off_t strtab_size);

 // Mapping from version number to version name.
 typedef std::vector<const char*> Version_map;

 // Create the version map.
 void
 make_version_map(Read_symbols_data* sd, Version_map*) const;

 // Add version definitions to the version map.
 void
 make_verdef_map(Read_symbols_data* sd, Version_map*) const;

 // Add version references to the version map.
 void
 make_verneed_map(Read_symbols_data* sd, Version_map*) const;

 // Add an entry to the version map.
 void
 set_version_map(Version_map*, unsigned int ndx, const char* name) const;

 // General access to the ELF file.
 elfcpp::Elf_file<size, big_endian, Object> elf_file_;
 // The section index of the dynamic symbol table.
 unsigned int dynsym_shndx_;
 // The entries in the symbol table for the symbols.  We only keep
 // this if we need it to print symbol information.
 Symbols* symbols_;
 // Number of defined symbols.
 size_t defined_count_;
};

// A base class for Verdef and Verneed_version which just handles the
// version index which will be stored in the SHT_GNU_versym section.

class Version_base
{
public:
 Version_base()
   : index_(-1U)
 { }

 virtual
 ~Version_base()
 { }

 // Return the version index.
 unsigned int
 index() const
 {
   gold_assert(this->index_ != -1U);
   return this->index_;
 }

 // Set the version index.
 void
 set_index(unsigned int index)
 {
   gold_assert(this->index_ == -1U);
   this->index_ = index;
 }

 // Clear the weak flag in a version definition.
 virtual void
 clear_weak() = 0;

private:
 Version_base(const Version_base&);
 Version_base& operator=(const Version_base&);

 // The index of the version definition or reference.
 unsigned int index_;
};

// This class handles a version being defined in the file we are
// generating.

class Verdef : public Version_base
{
public:
 Verdef(const char* name, const std::vector<std::string>& deps,
        bool is_base, bool is_weak, bool is_info, bool is_symbol_created)
   : name_(name), deps_(deps), is_base_(is_base), is_weak_(is_weak),
     is_info_(is_info), is_symbol_created_(is_symbol_created)
 { }

 // Return the version name.
 const char*
 name() const
 { return this->name_; }

 // Return the number of dependencies.
 unsigned int
 count_dependencies() const
 { return this->deps_.size(); }

 // Add a dependency to this version.  The NAME should be
 // canonicalized in the dynamic Stringpool.
 void
 add_dependency(const char* name)
 { this->deps_.push_back(name); }

 // Return whether this definition is weak.
 bool
 is_weak() const
 { return this->is_weak_; }

 // Clear the weak flag.
 void
 clear_weak()
 { this->is_weak_ = false; }

 // Return whether this definition is informational.
 bool
 is_info() const
 { return this->is_info_; }

 // Return whether a version symbol has been created for this
 // definition.
 bool
 is_symbol_created() const
 { return this->is_symbol_created_; }

 // Write contents to buffer.
 template<int size, bool big_endian>
 unsigned char*
 write(const Stringpool*, bool is_last, unsigned char*) const;

private:
 Verdef(const Verdef&);
 Verdef& operator=(const Verdef&);

 // The type of the list of version dependencies.  Each dependency
 // should be canonicalized in the dynamic Stringpool.
 typedef std::vector<std::string> Deps;

 // The name of this version.  This should be canonicalized in the
 // dynamic Stringpool.
 const char* name_;
 // A list of other versions which this version depends upon.
 Deps deps_;
 // Whether this is the base version.
 bool is_base_;
 // Whether this version is weak.
 bool is_weak_;
 // Whether this version is informational.
 bool is_info_;
 // Whether a version symbol has been created.
 bool is_symbol_created_;
};

// A referened version.  This will be associated with a filename by
// Verneed.

class Verneed_version : public Version_base
{
public:
 Verneed_version(const char* version)
   : version_(version)
 { }

 // Return the version name.
 const char*
 version() const
 { return this->version_; }

 // Clear the weak flag.  This is invalid for a reference.
 void
 clear_weak()
 { gold_unreachable(); }

private:
 Verneed_version(const Verneed_version&);
 Verneed_version& operator=(const Verneed_version&);

 const char* version_;
};

// Version references in a single dynamic object.

class Verneed
{
public:
 Verneed(const char* filename)
   : filename_(filename), need_versions_()
 { }

 ~Verneed();

 // Return the file name.
 const char*
 filename() const
 { return this->filename_; }

 // Return the number of versions.
 unsigned int
 count_versions() const
 { return this->need_versions_.size(); }

 // Add a version name.  The name should be canonicalized in the
 // dynamic Stringpool.  If the name is already present, this does
 // nothing.
 Verneed_version*
 add_name(const char* name);

 // Set the version indexes, starting at INDEX.  Return the updated
 // INDEX.
 unsigned int
 finalize(unsigned int index);

 // Write contents to buffer.
 template<int size, bool big_endian>
 unsigned char*
 write(const Stringpool*, bool is_last, unsigned char*) const;

private:
 Verneed(const Verneed&);
 Verneed& operator=(const Verneed&);

 // The type of the list of version names.  Each name should be
 // canonicalized in the dynamic Stringpool.
 typedef std::vector<Verneed_version*> Need_versions;

 // The filename of the dynamic object.  This should be
 // canonicalized in the dynamic Stringpool.
 const char* filename_;
 // The list of version names.
 Need_versions need_versions_;
};

// This class handles version definitions and references which go into
// the output file.

class Versions
{
public:
 Versions(const Version_script_info&, Stringpool*);

 ~Versions();

 // SYM is going into the dynamic symbol table and has a version.
 // Record the appropriate version information.
 void
 record_version(const Symbol_table* symtab, Stringpool*, const Symbol* sym);

 // Set the version indexes.  DYNSYM_INDEX is the index we should use
 // for the next dynamic symbol.  We add new dynamic symbols to SYMS
 // and return an updated DYNSYM_INDEX.
 unsigned int
 finalize(Symbol_table* symtab, unsigned int dynsym_index,
          std::vector<Symbol*>* syms);

 // Return whether there are any version definitions.
 bool
 any_defs() const
 { return !this->defs_.empty(); }

 // Return whether there are any version references.
 bool
 any_needs() const
 { return !this->needs_.empty(); }

 // Build an allocated buffer holding the contents of the symbol
 // version section (.gnu.version).
 template<int size, bool big_endian>
 void
 symbol_section_contents(const Symbol_table*, const Stringpool*,
                         unsigned int local_symcount,
                         const std::vector<Symbol*>& syms,
                         unsigned char**, unsigned int*) const;

 // Build an allocated buffer holding the contents of the version
 // definition section (.gnu.version_d).
 template<int size, bool big_endian>
 void
 def_section_contents(const Stringpool*, unsigned char**,
                      unsigned int* psize, unsigned int* pentries) const;

 // Build an allocated buffer holding the contents of the version
 // reference section (.gnu.version_r).
 template<int size, bool big_endian>
 void
 need_section_contents(const Stringpool*, unsigned char**,
                       unsigned int* psize, unsigned int* pentries) const;

 const Version_script_info&
 version_script() const
 { return this->version_script_; }

private:
 Versions(const Versions&);
 Versions& operator=(const Versions&);

 // The type of the list of version definitions.
 typedef std::vector<Verdef*> Defs;

 // The type of the list of version references.
 typedef std::vector<Verneed*> Needs;

 // Handle a symbol SYM defined with version VERSION.
 void
 add_def(Stringpool*, const Symbol* sym, const char* version,
         Stringpool::Key);

 // Add a reference to version NAME in file FILENAME.
 void
 add_need(Stringpool*, const char* filename, const char* name,
          Stringpool::Key);

 // Get the dynamic object to use for SYM.
 Dynobj*
 get_dynobj_for_sym(const Symbol_table*, const Symbol* sym) const;

 // Return the version index to use for SYM.
 unsigned int
 version_index(const Symbol_table*, const Stringpool*,
               const Symbol* sym) const;

 // Define the base version of a shared library.
 void
 define_base_version(Stringpool* dynpool);

 // We keep a hash table mapping canonicalized name/version pairs to
 // a version base.
 typedef std::pair<Stringpool::Key, Stringpool::Key> Key;

 struct Version_table_hash
 {
   size_t
   operator()(const Key& k) const
   { return k.first + k.second; }
 };

 struct Version_table_eq
 {
   bool
   operator()(const Key& k1, const Key& k2) const
   { return k1.first == k2.first && k1.second == k2.second; }
 };

 typedef Unordered_map<Key, Version_base*, Version_table_hash,
                       Version_table_eq> Version_table;

 // The version definitions.
 Defs defs_;
 // The version references.
 Needs needs_;
 // The mapping from a canonicalized version/filename pair to a
 // version index.  The filename may be NULL.
 Version_table version_table_;
 // Whether the version indexes have been set.
 bool is_finalized_;
 // Contents of --version-script, if passed, or NULL.
 const Version_script_info& version_script_;
 // Whether we need to insert a base version.  This is only used for
 // shared libraries and is cleared when the base version is defined.
 bool needs_base_version_;
};

} // End namespace gold.

#endif // !defined(GOLD_DYNOBJ_H)

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.