gold/dynobj.h

   1 // dynobj.h -- dynamic object support for gold   -*- C++ -*-
   2
   3 #ifndef GOLD_DYNOBJ_H
   4 #define GOLD_DYNOBJ_H
   5
   6 #include <vector>
   7
   8 #include "stringpool.h"
   9 #include "object.h"
  10
  11 namespace gold
  12 {
  13
  14 class General_options;
  15 class Stringpool;
  16
  17 // A dynamic object (ET_DYN).  This is an abstract base class itself.
  18 // The implementations is the template class Sized_dynobj.
  19
  20 class Dynobj : public Object
  21 {
  22  public:
  23   Dynobj(const std::string& name, Input_file* input_file, off_t offset = 0)
  24     : Object(name, input_file, true, offset), soname_()
  25   { }
  26
  27   // Return the name to use in a DT_NEEDED entry for this object.
  28   const char*
  29   soname() const;
  30
  31   // Compute the ELF hash code for a string.
  32   static uint32_t
  33   elf_hash(const char*);
  34
  35   // Create a standard ELF hash table, setting *PPHASH and *PHASHLEN.
  36   // DYNSYMS is the global dynamic symbols.  LOCAL_DYNSYM_COUNT is the
  37   // number of local dynamic symbols, which is the index of the first
  38   // dynamic gobal symbol.
  39   static void
  40   create_elf_hash_table(const Target*, const std::vector<Symbol*>& dynsyms,
  41                         unsigned int local_dynsym_count,
  42                         unsigned char** pphash,
  43                         unsigned int* phashlen);
  44
  45   // Create a GNU hash table, setting *PPHASH and *PHASHLEN.  DYNSYMS
  46   // is the global dynamic symbols.  LOCAL_DYNSYM_COUNT is the number
  47   // of local dynamic symbols, which is the index of the first dynamic
  48   // gobal symbol.
  49   static void
  50   create_gnu_hash_table(const Target*, const std::vector<Symbol*>& dynsyms,
  51                         unsigned int local_dynsym_count,
  52                         unsigned char** pphash, unsigned int* phashlen);
  53
  54  protected:
  55   // Set the DT_SONAME string.
  56   void
  57   set_soname_string(const char* s)
  58   { this->soname_.assign(s); }
  59
  60  private:
  61   // Compute the GNU hash code for a string.
  62   static uint32_t
  63   gnu_hash(const char*);
  64
  65   // Compute the number of hash buckets to use.
  66   static unsigned int
  67   compute_bucket_count(const std::vector<uint32_t>& hashcodes,
  68                        bool for_gnu_hash_table);
  69
  70   // Sized version of create_elf_hash_table.
  71   template<bool big_endian>
  72   static void
  73   sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
  74                               const std::vector<uint32_t>& chain,
  75                               unsigned char* phash,
  76                               unsigned int hashlen);
  77
  78   // Sized version of create_gnu_hash_table.
  79   template<int size, bool big_endian>
  80   static void
  81   sized_create_gnu_hash_table(const std::vector<Symbol*>& hashed_dynsyms,
  82                               const std::vector<uint32_t>& dynsym_hashvals,
  83                               unsigned int unhashed_dynsym_count,
  84                               unsigned char** pphash,
  85                               unsigned int* phashlen);
  86
  87   // The DT_SONAME name, if any.
  88   std::string soname_;
  89 };
  90
  91 // A dynamic object, size and endian specific version.
  92
  93 template<int size, bool big_endian>
  94 class Sized_dynobj : public Dynobj
  95 {
  96  public:
  97   Sized_dynobj(const std::string& name, Input_file* input_file, off_t offset,
  98                const typename elfcpp::Ehdr<size, big_endian>&);
  99
 100   // Set up the object file based on the ELF header.
 101   void
 102   setup(const typename elfcpp::Ehdr<size, big_endian>&);
 103
 104   // Read the symbols.
 105   void
 106   do_read_symbols(Read_symbols_data*);
 107
 108   // Lay out the input sections.
 109   void
 110   do_layout(const General_options&, Symbol_table*, Layout*,
 111             Read_symbols_data*);
 112
 113   // Add the symbols to the symbol table.
 114   void
 115   do_add_symbols(Symbol_table*, Read_symbols_data*);
 116
 117   // Get the name of a section.
 118   std::string
 119   do_section_name(unsigned int shndx)
 120   { return this->elf_file_.section_name(shndx); }
 121
 122   // Return a view of the contents of a section.  Set *PLEN to the
 123   // size.
 124   Object::Location
 125   do_section_contents(unsigned int shndx)
 126   { return this->elf_file_.section_contents(shndx); }
 127
 128   // Return section flags.
 129   uint64_t
 130   do_section_flags(unsigned int shndx)
 131   { return this->elf_file_.section_flags(shndx); }
 132
 133  private:
 134   // For convenience.
 135   typedef Sized_dynobj<size, big_endian> This;
 136   static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 137   static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 138   static const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
 139   typedef elfcpp::Shdr<size, big_endian> Shdr;
 140   typedef elfcpp::Dyn<size, big_endian> Dyn;
 141
 142   // Find the dynamic symbol table and the version sections, given the
 143   // section headers.
 144   void
 145   find_dynsym_sections(const unsigned char* pshdrs,
 146                        unsigned int* pdynshm_shndx,
 147                        unsigned int* pversym_shndx,
 148                        unsigned int* pverdef_shndx,
 149                        unsigned int* pverneed_shndx,
 150                        unsigned int* pdynamic_shndx);
 151
 152   // Read the dynamic symbol section SHNDX.
 153   void
 154   read_dynsym_section(const unsigned char* pshdrs, unsigned int shndx,
 155                       elfcpp::SHT type, unsigned int link,
 156                       File_view** view, off_t* view_size,
 157                       unsigned int* view_info);
 158
 159   // Set the SONAME from the SHT_DYNAMIC section at DYNAMIC_SHNDX.
 160   // The STRTAB parameters may have the relevant string table.
 161   void
 162   set_soname(const unsigned char* pshdrs, unsigned int dynamic_shndx,
 163              unsigned int strtab_shndx, const unsigned char* strtabu,
 164              off_t strtab_size);
 165
 166   // Mapping from version number to version name.
 167   typedef std::vector<const char*> Version_map;
 168
 169   // Create the version map.
 170   void
 171   make_version_map(Read_symbols_data* sd, Version_map*) const;
 172
 173   // Add version definitions to the version map.
 174   void
 175   make_verdef_map(Read_symbols_data* sd, Version_map*) const;
 176
 177   // Add version references to the version map.
 178   void
 179   make_verneed_map(Read_symbols_data* sd, Version_map*) const;
 180
 181   // Add an entry to the version map.
 182   void
 183   set_version_map(Version_map*, unsigned int ndx, const char* name) const;
 184
 185   // General access to the ELF file.
 186   elfcpp::Elf_file<size, big_endian, Object> elf_file_;
 187 };
 188
 189 // A base class for Verdef and Verneed_version which just handles the
 190 // version index which will be stored in the SHT_GNU_versym section.
 191
 192 class Version_base
 193 {
 194  public:
 195   Version_base()
 196     : index_(-1U)
 197   { }
 198
 199   virtual
 200   ~Version_base()
 201   { }
 202
 203   // Return the version index.
 204   unsigned int
 205   index() const
 206   {
 207     gold_assert(this->index_ != -1U);
 208     return this->index_;
 209   }
 210
 211   // Set the version index.
 212   void
 213   set_index(unsigned int index)
 214   {
 215     gold_assert(this->index_ == -1U);
 216     this->index_ = index;
 217   }
 218
 219   // Clear the weak flag in a version definition.
 220   virtual void
 221   clear_weak() = 0;
 222
 223  private:
 224   Version_base(const Version_base&);
 225   Version_base& operator=(const Version_base&);
 226
 227   // The index of the version definition or reference.
 228   unsigned int index_;
 229 };
 230
 231 // This class handles a version being defined in the file we are
 232 // generating.
 233
 234 class Verdef : public Version_base
 235 {
 236  public:
 237   Verdef(const char* name, bool is_base, bool is_weak, bool is_symbol_created)
 238     : name_(name), deps_(), is_base_(is_base), is_weak_(is_weak),
 239       is_symbol_created_(is_symbol_created)
 240   { }
 241
 242   // Return the version name.
 243   const char*
 244   name() const
 245   { return this->name_; }
 246
 247   // Return the number of dependencies.
 248   unsigned int
 249   count_dependencies() const
 250   { return this->deps_.size(); }
 251
 252   // Add a dependency to this version.  The NAME should be
 253   // canonicalized in the dynamic Stringpool.
 254   void
 255   add_dependency(const char* name)
 256   { this->deps_.push_back(name); }
 257
 258   // Return whether this definition is weak.
 259   bool
 260   is_weak() const
 261   { return this->is_weak_; }
 262
 263   // Clear the weak flag.
 264   void
 265   clear_weak()
 266   { this->is_weak_ = false; }
 267
 268   // Return whether a version symbol has been created for this
 269   // definition.
 270   bool
 271   is_symbol_created() const
 272   { return this->is_symbol_created_; }
 273
 274   // Write contents to buffer.
 275   template<int size, bool big_endian>
 276   unsigned char*
 277   write(const Stringpool*, bool is_last, unsigned char*) const;
 278
 279  private:
 280   Verdef(const Verdef&);
 281   Verdef& operator=(const Verdef&);
 282
 283   // The type of the list of version dependencies.  Each dependency
 284   // should be canonicalized in the dynamic Stringpool.
 285   typedef std::vector<const char*> Deps;
 286
 287   // The name of this version.  This should be canonicalized in the
 288   // dynamic Stringpool.
 289   const char* name_;
 290   // A list of other versions which this version depends upon.
 291   Deps deps_;
 292   // Whether this is the base version.
 293   bool is_base_;
 294   // Whether this version is weak.
 295   bool is_weak_;
 296   // Whether a version symbol has been created.
 297   bool is_symbol_created_;
 298 };
 299
 300 // A referened version.  This will be associated with a filename by
 301 // Verneed.
 302
 303 class Verneed_version : public Version_base
 304 {
 305  public:
 306   Verneed_version(const char* version)
 307     : version_(version)
 308   { }
 309
 310   // Return the version name.
 311   const char*
 312   version() const
 313   { return this->version_; }
 314
 315   // Clear the weak flag.  This is invalid for a reference.
 316   void
 317   clear_weak()
 318   { gold_unreachable(); }
 319
 320  private:
 321   Verneed_version(const Verneed_version&);
 322   Verneed_version& operator=(const Verneed_version&);
 323
 324   const char* version_;
 325 };
 326
 327 // Version references in a single dynamic object.
 328
 329 class Verneed
 330 {
 331  public:
 332   Verneed(const char* filename)
 333     : filename_(filename), need_versions_()
 334   { }
 335
 336   ~Verneed();
 337
 338   // Return the file name.
 339   const char*
 340   filename() const
 341   { return this->filename_; }
 342
 343   // Return the number of versions.
 344   unsigned int
 345   count_versions() const
 346   { return this->need_versions_.size(); }
 347
 348   // Add a version name.  The name should be canonicalized in the
 349   // dynamic Stringpool.  If the name is already present, this does
 350   // nothing.
 351   Verneed_version*
 352   add_name(const char* name);
 353
 354   // Set the version indexes, starting at INDEX.  Return the updated
 355   // INDEX.
 356   unsigned int
 357   finalize(unsigned int index);
 358
 359   // Write contents to buffer.
 360   template<int size, bool big_endian>
 361   unsigned char*
 362   write(const Stringpool*, bool is_last, unsigned char*) const;
 363
 364  private:
 365   Verneed(const Verneed&);
 366   Verneed& operator=(const Verneed&);
 367
 368   // The type of the list of version names.  Each name should be
 369   // canonicalized in the dynamic Stringpool.
 370   typedef std::vector<Verneed_version*> Need_versions;
 371
 372   // The filename of the dynamic object.  This should be
 373   // canonicalized in the dynamic Stringpool.
 374   const char* filename_;
 375   // The list of version names.
 376   Need_versions need_versions_;
 377 };
 378
 379 // This class handles version definitions and references which go into
 380 // the output file.
 381
 382 class Versions
 383 {
 384  public:
 385   Versions()
 386     : defs_(), needs_(), version_table_(), is_finalized_(false)
 387   { }
 388
 389   ~Versions();
 390
 391   // SYM is going into the dynamic symbol table and has a version.
 392   // Record the appropriate version information.
 393   void
 394   record_version(const General_options*, Stringpool*, const Symbol* sym);
 395
 396   // Set the version indexes.  DYNSYM_INDEX is the index we should use
 397   // for the next dynamic symbol.  We add new dynamic symbols to SYMS
 398   // and return an updated DYNSYM_INDEX.
 399   unsigned int
 400   finalize(const Target*, Symbol_table* symtab, unsigned int dynsym_index,
 401            std::vector<Symbol*>* syms);
 402
 403   // Return whether there are any version definitions.
 404   bool
 405   any_defs() const
 406   { return !this->defs_.empty(); }
 407
 408   // Return whether there are any version references.
 409   bool
 410   any_needs() const
 411   { return !this->needs_.empty(); }
 412
 413   // Build an allocated buffer holding the contents of the symbol
 414   // version section (.gnu.version).
 415   template<int size, bool big_endian>
 416   void
 417   symbol_section_contents(const Stringpool*, unsigned int local_symcount,
 418                           const std::vector<Symbol*>& syms,
 419                           unsigned char**, unsigned int*) const;
 420
 421   // Build an allocated buffer holding the contents of the version
 422   // definition section (.gnu.version_d).
 423   template<int size, bool big_endian>
 424   void
 425   def_section_contents(const Stringpool*, unsigned char**,
 426                        unsigned int* psize, unsigned int* pentries) const;
 427
 428   // Build an allocated buffer holding the contents of the version
 429   // reference section (.gnu.version_r).
 430   template<int size, bool big_endian>
 431   void
 432   need_section_contents(const Stringpool*, unsigned char**,
 433                         unsigned int* psize, unsigned int* pentries) const;
 434
 435  private:
 436   // The type of the list of version definitions.
 437   typedef std::vector<Verdef*> Defs;
 438
 439   // The type of the list of version references.
 440   typedef std::vector<Verneed*> Needs;
 441
 442   // Handle a symbol SYM defined with version VERSION.
 443   void
 444   add_def(const General_options*, const Symbol* sym, const char* version,
 445           Stringpool::Key);
 446
 447   // Add a reference to version NAME in file FILENAME.
 448   void
 449   add_need(Stringpool*, const char* filename, const char* name,
 450            Stringpool::Key);
 451
 452   // Return the version index to use for SYM.
 453   unsigned int
 454   version_index(const Stringpool*, const Symbol* sym) const;
 455
 456   // We keep a hash table mapping canonicalized name/version pairs to
 457   // a version base.
 458   typedef std::pair<Stringpool::Key, Stringpool::Key> Key;
 459
 460   struct Version_table_hash
 461   {
 462     size_t
 463     operator()(const Key& k) const
 464     { return k.first + k.second; }
 465   };
 466
 467   struct Version_table_eq
 468   {
 469     bool
 470     operator()(const Key& k1, const Key& k2) const
 471     { return k1.first == k2.first && k1.second == k2.second; }
 472   };
 473
 474   typedef Unordered_map<Key, Version_base*, Version_table_hash,
 475                         Version_table_eq> Version_table;
 476
 477   // The version definitions.
 478   Defs defs_;
 479   // The version references.
 480   Needs needs_;
 481   // The mapping from a canonicalized version/filename pair to a
 482   // version index.  The filename may be NULL.
 483   Version_table version_table_;
 484   // Whether the version indexes have been set.
 485   bool is_finalized_;
 486 };
 487
 488 } // End namespace gold.
 489
 490 #endif // !defined(GOLD_DYNOBJ_H)