1 // dynobj.h -- dynamic object support for gold -*- C++ -*- 2 3 // Copyright 2006, 2007, 2008 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of gold. 7 8 // This program is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3 of the License, or 11 // (at your option) any later version. 12 13 // This program is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // You should have received a copy of the GNU General Public License 19 // along with this program; if not, write to the Free Software 20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 // MA 02110-1301, USA. 22 23 #ifndef GOLD_DYNOBJ_H 24 #define GOLD_DYNOBJ_H 25 26 #include <vector> 27 28 #include "stringpool.h" 29 #include "object.h" 30 31 namespace gold 32 { 33 34 class Version_script_info; 35 36 // A dynamic object (ET_DYN). This is an abstract base class itself. 37 // The implementations is the template class Sized_dynobj. 38 39 class Dynobj : public Object 40 { 41 public: 42 // We keep a list of all the DT_NEEDED entries we find. 43 typedef std::vector<std::string> Needed; 44 45 Dynobj(const std::string& name, Input_file* input_file, off_t offset = 0); 46 47 // Return the name to use in a DT_NEEDED entry for this object. 48 const char* 49 soname() const 50 { return this->soname_.c_str(); } 51 52 // Return the list of DT_NEEDED strings. 53 const Needed& 54 needed() const 55 { return this->needed_; } 56 57 // Return whether this dynamic object has any DT_NEEDED entries 58 // which were not seen during the link. 59 bool 60 has_unknown_needed_entries() const 61 { 62 gold_assert(this->unknown_needed_ != UNKNOWN_NEEDED_UNSET); 63 return this->unknown_needed_ == UNKNOWN_NEEDED_TRUE; 64 } 65 66 // Set whether this dynamic object has any DT_NEEDED entries which 67 // were not seen during the link. 68 void 69 set_has_unknown_needed_entries(bool set) 70 { 71 gold_assert(this->unknown_needed_ == UNKNOWN_NEEDED_UNSET); 72 this->unknown_needed_ = set ? UNKNOWN_NEEDED_TRUE : UNKNOWN_NEEDED_FALSE; 73 } 74 75 // Compute the ELF hash code for a string. 76 static uint32_t 77 elf_hash(const char*); 78 79 // Create a standard ELF hash table, setting *PPHASH and *PHASHLEN. 80 // DYNSYMS is the global dynamic symbols. LOCAL_DYNSYM_COUNT is the 81 // number of local dynamic symbols, which is the index of the first 82 // dynamic gobal symbol. 83 static void 84 create_elf_hash_table(const std::vector<Symbol*>& dynsyms, 85 unsigned int local_dynsym_count, 86 unsigned char** pphash, 87 unsigned int* phashlen); 88 89 // Create a GNU hash table, setting *PPHASH and *PHASHLEN. DYNSYMS 90 // is the global dynamic symbols. LOCAL_DYNSYM_COUNT is the number 91 // of local dynamic symbols, which is the index of the first dynamic 92 // gobal symbol. 93 static void 94 create_gnu_hash_table(const std::vector<Symbol*>& dynsyms, 95 unsigned int local_dynsym_count, 96 unsigned char** pphash, unsigned int* phashlen); 97 98 protected: 99 // Set the DT_SONAME string. 100 void 101 set_soname_string(const char* s) 102 { this->soname_.assign(s); } 103 104 // Add an entry to the list of DT_NEEDED strings. 105 void 106 add_needed(const char* s) 107 { this->needed_.push_back(std::string(s)); } 108 109 private: 110 // Compute the GNU hash code for a string. 111 static uint32_t 112 gnu_hash(const char*); 113 114 // Compute the number of hash buckets to use. 115 static unsigned int 116 compute_bucket_count(const std::vector<uint32_t>& hashcodes, 117 bool for_gnu_hash_table); 118 119 // Sized version of create_elf_hash_table. 120 template<bool big_endian> 121 static void 122 sized_create_elf_hash_table(const std::vector<uint32_t>& bucket, 123 const std::vector<uint32_t>& chain, 124 unsigned char* phash, 125 unsigned int hashlen); 126 127 // Sized version of create_gnu_hash_table. 128 template<int size, bool big_endian> 129 static void 130 sized_create_gnu_hash_table(const std::vector<Symbol*>& hashed_dynsyms, 131 const std::vector<uint32_t>& dynsym_hashvals, 132 unsigned int unhashed_dynsym_count, 133 unsigned char** pphash, 134 unsigned int* phashlen); 135 136 // Values for the has_unknown_needed_entries_ field. 137 enum Unknown_needed 138 { 139 UNKNOWN_NEEDED_UNSET, 140 UNKNOWN_NEEDED_TRUE, 141 UNKNOWN_NEEDED_FALSE 142 }; 143 144 // The DT_SONAME name, if any. 145 std::string soname_; 146 // The list of DT_NEEDED entries. 147 Needed needed_; 148 // Whether this dynamic object has any DT_NEEDED entries not seen 149 // during the link. 150 Unknown_needed unknown_needed_; 151 }; 152 153 // A dynamic object, size and endian specific version. 154 155 template<int size, bool big_endian> 156 class Sized_dynobj : public Dynobj 157 { 158 public: 159 typedef typename Sized_relobj<size, big_endian>::Symbols Symbols; 160 161 Sized_dynobj(const std::string& name, Input_file* input_file, off_t offset, 162 const typename elfcpp::Ehdr<size, big_endian>&); 163 164 // Set up the object file based on the ELF header. 165 void 166 setup(const typename elfcpp::Ehdr<size, big_endian>&); 167 168 // Read the symbols. 169 void 170 do_read_symbols(Read_symbols_data*); 171 172 // Lay out the input sections. 173 void 174 do_layout(Symbol_table*, Layout*, Read_symbols_data*); 175 176 // Add the symbols to the symbol table. 177 void 178 do_add_symbols(Symbol_table*, Read_symbols_data*); 179 180 // Get the size of a section. 181 uint64_t 182 do_section_size(unsigned int shndx) 183 { return this->elf_file_.section_size(shndx); } 184 185 // Get the name of a section. 186 std::string 187 do_section_name(unsigned int shndx) 188 { return this->elf_file_.section_name(shndx); } 189 190 // Return a view of the contents of a section. Set *PLEN to the 191 // size. 192 Object::Location 193 do_section_contents(unsigned int shndx) 194 { return this->elf_file_.section_contents(shndx); } 195 196 // Return section flags. 197 uint64_t 198 do_section_flags(unsigned int shndx) 199 { return this->elf_file_.section_flags(shndx); } 200 201 // Return section address. 202 uint64_t 203 do_section_address(unsigned int shndx) 204 { return this->elf_file_.section_addr(shndx); } 205 206 // Return section type. 207 unsigned int 208 do_section_type(unsigned int shndx) 209 { return this->elf_file_.section_type(shndx); } 210 211 // Return the section link field. 212 unsigned int 213 do_section_link(unsigned int shndx) 214 { return this->elf_file_.section_link(shndx); } 215 216 // Return the section link field. 217 unsigned int 218 do_section_info(unsigned int shndx) 219 { return this->elf_file_.section_info(shndx); } 220 221 // Return the section alignment. 222 uint64_t 223 do_section_addralign(unsigned int shndx) 224 { return this->elf_file_.section_addralign(shndx); } 225 226 // Return the Xindex structure to use. 227 Xindex* 228 do_initialize_xindex(); 229 230 // Get symbol counts. 231 void 232 do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const; 233 234 private: 235 // For convenience. 236 typedef Sized_dynobj<size, big_endian> This; 237 static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 238 static const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 239 static const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size; 240 typedef elfcpp::Shdr<size, big_endian> Shdr; 241 typedef elfcpp::Dyn<size, big_endian> Dyn; 242 243 // Adjust a section index if necessary. 244 unsigned int 245 adjust_shndx(unsigned int shndx) 246 { 247 if (shndx >= elfcpp::SHN_LORESERVE) 248 shndx += this->elf_file_.large_shndx_offset(); 249 return shndx; 250 } 251 252 // Find the dynamic symbol table and the version sections, given the 253 // section headers. 254 void 255 find_dynsym_sections(const unsigned char* pshdrs, 256 unsigned int* pversym_shndx, 257 unsigned int* pverdef_shndx, 258 unsigned int* pverneed_shndx, 259 unsigned int* pdynamic_shndx); 260 261 // Read the dynamic symbol section SHNDX. 262 void 263 read_dynsym_section(const unsigned char* pshdrs, unsigned int shndx, 264 elfcpp::SHT type, unsigned int link, 265 File_view** view, section_size_type* view_size, 266 unsigned int* view_info); 267 268 // Read the dynamic tags. 269 void 270 read_dynamic(const unsigned char* pshdrs, unsigned int dynamic_shndx, 271 unsigned int strtab_shndx, const unsigned char* strtabu, 272 off_t strtab_size); 273 274 // Mapping from version number to version name. 275 typedef std::vector<const char*> Version_map; 276 277 // Create the version map. 278 void 279 make_version_map(Read_symbols_data* sd, Version_map*) const; 280 281 // Add version definitions to the version map. 282 void 283 make_verdef_map(Read_symbols_data* sd, Version_map*) const; 284 285 // Add version references to the version map. 286 void 287 make_verneed_map(Read_symbols_data* sd, Version_map*) const; 288 289 // Add an entry to the version map. 290 void 291 set_version_map(Version_map*, unsigned int ndx, const char* name) const; 292 293 // General access to the ELF file. 294 elfcpp::Elf_file<size, big_endian, Object> elf_file_; 295 // The section index of the dynamic symbol table. 296 unsigned int dynsym_shndx_; 297 // The entries in the symbol table for the symbols. We only keep 298 // this if we need it to print symbol information. 299 Symbols* symbols_; 300 // Number of defined symbols. 301 size_t defined_count_; 302 }; 303 304 // A base class for Verdef and Verneed_version which just handles the 305 // version index which will be stored in the SHT_GNU_versym section. 306 307 class Version_base 308 { 309 public: 310 Version_base() 311 : index_(-1U) 312 { } 313 314 virtual 315 ~Version_base() 316 { } 317 318 // Return the version index. 319 unsigned int 320 index() const 321 { 322 gold_assert(this->index_ != -1U); 323 return this->index_; 324 } 325 326 // Set the version index. 327 void 328 set_index(unsigned int index) 329 { 330 gold_assert(this->index_ == -1U); 331 this->index_ = index; 332 } 333 334 // Clear the weak flag in a version definition. 335 virtual void 336 clear_weak() = 0; 337 338 private: 339 Version_base(const Version_base&); 340 Version_base& operator=(const Version_base&); 341 342 // The index of the version definition or reference. 343 unsigned int index_; 344 }; 345 346 // This class handles a version being defined in the file we are 347 // generating. 348 349 class Verdef : public Version_base 350 { 351 public: 352 Verdef(const char* name, const std::vector<std::string>& deps, 353 bool is_base, bool is_weak, bool is_symbol_created) 354 : name_(name), deps_(deps), is_base_(is_base), is_weak_(is_weak), 355 is_symbol_created_(is_symbol_created) 356 { } 357 358 // Return the version name. 359 const char* 360 name() const 361 { return this->name_; } 362 363 // Return the number of dependencies. 364 unsigned int 365 count_dependencies() const 366 { return this->deps_.size(); } 367 368 // Add a dependency to this version. The NAME should be 369 // canonicalized in the dynamic Stringpool. 370 void 371 add_dependency(const char* name) 372 { this->deps_.push_back(name); } 373 374 // Return whether this definition is weak. 375 bool 376 is_weak() const 377 { return this->is_weak_; } 378 379 // Clear the weak flag. 380 void 381 clear_weak() 382 { this->is_weak_ = false; } 383 384 // Return whether a version symbol has been created for this 385 // definition. 386 bool 387 is_symbol_created() const 388 { return this->is_symbol_created_; } 389 390 // Write contents to buffer. 391 template<int size, bool big_endian> 392 unsigned char* 393 write(const Stringpool*, bool is_last, unsigned char*) const; 394 395 private: 396 Verdef(const Verdef&); 397 Verdef& operator=(const Verdef&); 398 399 // The type of the list of version dependencies. Each dependency 400 // should be canonicalized in the dynamic Stringpool. 401 typedef std::vector<std::string> Deps; 402 403 // The name of this version. This should be canonicalized in the 404 // dynamic Stringpool. 405 const char* name_; 406 // A list of other versions which this version depends upon. 407 Deps deps_; 408 // Whether this is the base version. 409 bool is_base_; 410 // Whether this version is weak. 411 bool is_weak_; 412 // Whether a version symbol has been created. 413 bool is_symbol_created_; 414 }; 415 416 // A referened version. This will be associated with a filename by 417 // Verneed. 418 419 class Verneed_version : public Version_base 420 { 421 public: 422 Verneed_version(const char* version) 423 : version_(version) 424 { } 425 426 // Return the version name. 427 const char* 428 version() const 429 { return this->version_; } 430 431 // Clear the weak flag. This is invalid for a reference. 432 void 433 clear_weak() 434 { gold_unreachable(); } 435 436 private: 437 Verneed_version(const Verneed_version&); 438 Verneed_version& operator=(const Verneed_version&); 439 440 const char* version_; 441 }; 442 443 // Version references in a single dynamic object. 444 445 class Verneed 446 { 447 public: 448 Verneed(const char* filename) 449 : filename_(filename), need_versions_() 450 { } 451 452 ~Verneed(); 453 454 // Return the file name. 455 const char* 456 filename() const 457 { return this->filename_; } 458 459 // Return the number of versions. 460 unsigned int 461 count_versions() const 462 { return this->need_versions_.size(); } 463 464 // Add a version name. The name should be canonicalized in the 465 // dynamic Stringpool. If the name is already present, this does 466 // nothing. 467 Verneed_version* 468 add_name(const char* name); 469 470 // Set the version indexes, starting at INDEX. Return the updated 471 // INDEX. 472 unsigned int 473 finalize(unsigned int index); 474 475 // Write contents to buffer. 476 template<int size, bool big_endian> 477 unsigned char* 478 write(const Stringpool*, bool is_last, unsigned char*) const; 479 480 private: 481 Verneed(const Verneed&); 482 Verneed& operator=(const Verneed&); 483 484 // The type of the list of version names. Each name should be 485 // canonicalized in the dynamic Stringpool. 486 typedef std::vector<Verneed_version*> Need_versions; 487 488 // The filename of the dynamic object. This should be 489 // canonicalized in the dynamic Stringpool. 490 const char* filename_; 491 // The list of version names. 492 Need_versions need_versions_; 493 }; 494 495 // This class handles version definitions and references which go into 496 // the output file. 497 498 class Versions 499 { 500 public: 501 Versions(const Version_script_info&, Stringpool*); 502 503 ~Versions(); 504 505 // SYM is going into the dynamic symbol table and has a version. 506 // Record the appropriate version information. 507 void 508 record_version(const Symbol_table* symtab, Stringpool*, const Symbol* sym); 509 510 // Set the version indexes. DYNSYM_INDEX is the index we should use 511 // for the next dynamic symbol. We add new dynamic symbols to SYMS 512 // and return an updated DYNSYM_INDEX. 513 unsigned int 514 finalize(Symbol_table* symtab, unsigned int dynsym_index, 515 std::vector<Symbol*>* syms); 516 517 // Return whether there are any version definitions. 518 bool 519 any_defs() const 520 { return !this->defs_.empty(); } 521 522 // Return whether there are any version references. 523 bool 524 any_needs() const 525 { return !this->needs_.empty(); } 526 527 // Build an allocated buffer holding the contents of the symbol 528 // version section (.gnu.version). 529 template<int size, bool big_endian> 530 void 531 symbol_section_contents(const Symbol_table*, const Stringpool*, 532 unsigned int local_symcount, 533 const std::vector<Symbol*>& syms, 534 unsigned char**, unsigned int*) const; 535 536 // Build an allocated buffer holding the contents of the version 537 // definition section (.gnu.version_d). 538 template<int size, bool big_endian> 539 void 540 def_section_contents(const Stringpool*, unsigned char**, 541 unsigned int* psize, unsigned int* pentries) const; 542 543 // Build an allocated buffer holding the contents of the version 544 // reference section (.gnu.version_r). 545 template<int size, bool big_endian> 546 void 547 need_section_contents(const Stringpool*, unsigned char**, 548 unsigned int* psize, unsigned int* pentries) const; 549 550 const Version_script_info& 551 version_script() const 552 { return this->version_script_; } 553 554 private: 555 Versions(const Versions&); 556 Versions& operator=(const Versions&); 557 558 // The type of the list of version definitions. 559 typedef std::vector<Verdef*> Defs; 560 561 // The type of the list of version references. 562 typedef std::vector<Verneed*> Needs; 563 564 // Handle a symbol SYM defined with version VERSION. 565 void 566 add_def(const Symbol* sym, const char* version, Stringpool::Key); 567 568 // Add a reference to version NAME in file FILENAME. 569 void 570 add_need(Stringpool*, const char* filename, const char* name, 571 Stringpool::Key); 572 573 // Get the dynamic object to use for SYM. 574 Dynobj* 575 get_dynobj_for_sym(const Symbol_table*, const Symbol* sym) const; 576 577 // Return the version index to use for SYM. 578 unsigned int 579 version_index(const Symbol_table*, const Stringpool*, 580 const Symbol* sym) const; 581 582 // We keep a hash table mapping canonicalized name/version pairs to 583 // a version base. 584 typedef std::pair<Stringpool::Key, Stringpool::Key> Key; 585 586 struct Version_table_hash 587 { 588 size_t 589 operator()(const Key& k) const 590 { return k.first + k.second; } 591 }; 592 593 struct Version_table_eq 594 { 595 bool 596 operator()(const Key& k1, const Key& k2) const 597 { return k1.first == k2.first && k1.second == k2.second; } 598 }; 599 600 typedef Unordered_map<Key, Version_base*, Version_table_hash, 601 Version_table_eq> Version_table; 602 603 // The version definitions. 604 Defs defs_; 605 // The version references. 606 Needs needs_; 607 // The mapping from a canonicalized version/filename pair to a 608 // version index. The filename may be NULL. 609 Version_table version_table_; 610 // Whether the version indexes have been set. 611 bool is_finalized_; 612 // Contents of --version-script, if passed, or NULL. 613 const Version_script_info& version_script_; 614 }; 615 616 } // End namespace gold. 617 618 #endif // !defined(GOLD_DYNOBJ_H) 619