1 // i386.cc -- i386 target support for gold. 2 3 // Copyright (C) 2006-2015 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 #include "gold.h" 24 25 #include <cstring> 26 27 #include "elfcpp.h" 28 #include "dwarf.h" 29 #include "parameters.h" 30 #include "reloc.h" 31 #include "i386.h" 32 #include "object.h" 33 #include "symtab.h" 34 #include "layout.h" 35 #include "output.h" 36 #include "copy-relocs.h" 37 #include "target.h" 38 #include "target-reloc.h" 39 #include "target-select.h" 40 #include "tls.h" 41 #include "freebsd.h" 42 #include "nacl.h" 43 #include "gc.h" 44 45 namespace 46 { 47 48 using namespace gold; 49 50 // A class to handle the .got.plt section. 51 52 class Output_data_got_plt_i386 : public Output_section_data_build 53 { 54 public: 55 Output_data_got_plt_i386(Layout* layout) 56 : Output_section_data_build(4), 57 layout_(layout) 58 { } 59 60 protected: 61 // Write out the PLT data. 62 void 63 do_write(Output_file*); 64 65 // Write to a map file. 66 void 67 do_print_to_mapfile(Mapfile* mapfile) const 68 { mapfile->print_output_data(this, "** GOT PLT"); } 69 70 private: 71 // A pointer to the Layout class, so that we can find the .dynamic 72 // section when we write out the GOT PLT section. 73 Layout* layout_; 74 }; 75 76 // A class to handle the PLT data. 77 // This is an abstract base class that handles most of the linker details 78 // but does not know the actual contents of PLT entries. The derived 79 // classes below fill in those details. 80 81 class Output_data_plt_i386 : public Output_section_data 82 { 83 public: 84 typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section; 85 86 Output_data_plt_i386(Layout*, uint64_t addralign, 87 Output_data_got_plt_i386*, Output_data_space*); 88 89 // Add an entry to the PLT. 90 void 91 add_entry(Symbol_table*, Layout*, Symbol* gsym); 92 93 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. 94 unsigned int 95 add_local_ifunc_entry(Symbol_table*, Layout*, 96 Sized_relobj_file<32, false>* relobj, 97 unsigned int local_sym_index); 98 99 // Return the .rel.plt section data. 100 Reloc_section* 101 rel_plt() const 102 { return this->rel_; } 103 104 // Return where the TLS_DESC relocations should go. 105 Reloc_section* 106 rel_tls_desc(Layout*); 107 108 // Return where the IRELATIVE relocations should go. 109 Reloc_section* 110 rel_irelative(Symbol_table*, Layout*); 111 112 // Return whether we created a section for IRELATIVE relocations. 113 bool 114 has_irelative_section() const 115 { return this->irelative_rel_ != NULL; } 116 117 // Return the number of PLT entries. 118 unsigned int 119 entry_count() const 120 { return this->count_ + this->irelative_count_; } 121 122 // Return the offset of the first non-reserved PLT entry. 123 unsigned int 124 first_plt_entry_offset() 125 { return this->get_plt_entry_size(); } 126 127 // Return the size of a PLT entry. 128 unsigned int 129 get_plt_entry_size() const 130 { return this->do_get_plt_entry_size(); } 131 132 // Return the PLT address to use for a global symbol. 133 uint64_t 134 address_for_global(const Symbol*); 135 136 // Return the PLT address to use for a local symbol. 137 uint64_t 138 address_for_local(const Relobj*, unsigned int symndx); 139 140 // Add .eh_frame information for the PLT. 141 void 142 add_eh_frame(Layout* layout) 143 { this->do_add_eh_frame(layout); } 144 145 protected: 146 // Fill the first PLT entry, given the pointer to the PLT section data 147 // and the runtime address of the GOT. 148 void 149 fill_first_plt_entry(unsigned char* pov, 150 elfcpp::Elf_types<32>::Elf_Addr got_address) 151 { this->do_fill_first_plt_entry(pov, got_address); } 152 153 // Fill a normal PLT entry, given the pointer to the entry's data in the 154 // section, the runtime address of the GOT, the offset into the GOT of 155 // the corresponding slot, the offset into the relocation section of the 156 // corresponding reloc, and the offset of this entry within the whole 157 // PLT. Return the offset from this PLT entry's runtime address that 158 // should be used to compute the initial value of the GOT slot. 159 unsigned int 160 fill_plt_entry(unsigned char* pov, 161 elfcpp::Elf_types<32>::Elf_Addr got_address, 162 unsigned int got_offset, 163 unsigned int plt_offset, 164 unsigned int plt_rel_offset) 165 { 166 return this->do_fill_plt_entry(pov, got_address, got_offset, 167 plt_offset, plt_rel_offset); 168 } 169 170 virtual unsigned int 171 do_get_plt_entry_size() const = 0; 172 173 virtual void 174 do_fill_first_plt_entry(unsigned char* pov, 175 elfcpp::Elf_types<32>::Elf_Addr got_address) = 0; 176 177 virtual unsigned int 178 do_fill_plt_entry(unsigned char* pov, 179 elfcpp::Elf_types<32>::Elf_Addr got_address, 180 unsigned int got_offset, 181 unsigned int plt_offset, 182 unsigned int plt_rel_offset) = 0; 183 184 virtual void 185 do_add_eh_frame(Layout*) = 0; 186 187 void 188 do_adjust_output_section(Output_section* os); 189 190 // Write to a map file. 191 void 192 do_print_to_mapfile(Mapfile* mapfile) const 193 { mapfile->print_output_data(this, _("** PLT")); } 194 195 // The .eh_frame unwind information for the PLT. 196 // The CIE is common across variants of the PLT format. 197 static const int plt_eh_frame_cie_size = 16; 198 static const unsigned char plt_eh_frame_cie[plt_eh_frame_cie_size]; 199 200 private: 201 // Set the final size. 202 void 203 set_final_data_size() 204 { 205 this->set_data_size((this->count_ + this->irelative_count_ + 1) 206 * this->get_plt_entry_size()); 207 } 208 209 // Write out the PLT data. 210 void 211 do_write(Output_file*); 212 213 // We keep a list of global STT_GNU_IFUNC symbols, each with its 214 // offset in the GOT. 215 struct Global_ifunc 216 { 217 Symbol* sym; 218 unsigned int got_offset; 219 }; 220 221 // We keep a list of local STT_GNU_IFUNC symbols, each with its 222 // offset in the GOT. 223 struct Local_ifunc 224 { 225 Sized_relobj_file<32, false>* object; 226 unsigned int local_sym_index; 227 unsigned int got_offset; 228 }; 229 230 // The reloc section. 231 Reloc_section* rel_; 232 // The TLS_DESC relocations, if necessary. These must follow the 233 // regular PLT relocs. 234 Reloc_section* tls_desc_rel_; 235 // The IRELATIVE relocations, if necessary. These must follow the 236 // regular relocatoins and the TLS_DESC relocations. 237 Reloc_section* irelative_rel_; 238 // The .got.plt section. 239 Output_data_got_plt_i386* got_plt_; 240 // The part of the .got.plt section used for IRELATIVE relocs. 241 Output_data_space* got_irelative_; 242 // The number of PLT entries. 243 unsigned int count_; 244 // Number of PLT entries with R_386_IRELATIVE relocs. These follow 245 // the regular PLT entries. 246 unsigned int irelative_count_; 247 // Global STT_GNU_IFUNC symbols. 248 std::vector<Global_ifunc> global_ifuncs_; 249 // Local STT_GNU_IFUNC symbols. 250 std::vector<Local_ifunc> local_ifuncs_; 251 }; 252 253 // This is an abstract class for the standard PLT layout. 254 // The derived classes below handle the actual PLT contents 255 // for the executable (non-PIC) and shared-library (PIC) cases. 256 // The unwind information is uniform across those two, so it's here. 257 258 class Output_data_plt_i386_standard : public Output_data_plt_i386 259 { 260 public: 261 Output_data_plt_i386_standard(Layout* layout, 262 Output_data_got_plt_i386* got_plt, 263 Output_data_space* got_irelative) 264 : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative) 265 { } 266 267 protected: 268 virtual unsigned int 269 do_get_plt_entry_size() const 270 { return plt_entry_size; } 271 272 virtual void 273 do_add_eh_frame(Layout* layout) 274 { 275 layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size, 276 plt_eh_frame_fde, plt_eh_frame_fde_size); 277 } 278 279 // The size of an entry in the PLT. 280 static const int plt_entry_size = 16; 281 282 // The .eh_frame unwind information for the PLT. 283 static const int plt_eh_frame_fde_size = 32; 284 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size]; 285 }; 286 287 // Actually fill the PLT contents for an executable (non-PIC). 288 289 class Output_data_plt_i386_exec : public Output_data_plt_i386_standard 290 { 291 public: 292 Output_data_plt_i386_exec(Layout* layout, 293 Output_data_got_plt_i386* got_plt, 294 Output_data_space* got_irelative) 295 : Output_data_plt_i386_standard(layout, got_plt, got_irelative) 296 { } 297 298 protected: 299 virtual void 300 do_fill_first_plt_entry(unsigned char* pov, 301 elfcpp::Elf_types<32>::Elf_Addr got_address); 302 303 virtual unsigned int 304 do_fill_plt_entry(unsigned char* pov, 305 elfcpp::Elf_types<32>::Elf_Addr got_address, 306 unsigned int got_offset, 307 unsigned int plt_offset, 308 unsigned int plt_rel_offset); 309 310 private: 311 // The first entry in the PLT for an executable. 312 static const unsigned char first_plt_entry[plt_entry_size]; 313 314 // Other entries in the PLT for an executable. 315 static const unsigned char plt_entry[plt_entry_size]; 316 }; 317 318 // Actually fill the PLT contents for a shared library (PIC). 319 320 class Output_data_plt_i386_dyn : public Output_data_plt_i386_standard 321 { 322 public: 323 Output_data_plt_i386_dyn(Layout* layout, 324 Output_data_got_plt_i386* got_plt, 325 Output_data_space* got_irelative) 326 : Output_data_plt_i386_standard(layout, got_plt, got_irelative) 327 { } 328 329 protected: 330 virtual void 331 do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr); 332 333 virtual unsigned int 334 do_fill_plt_entry(unsigned char* pov, 335 elfcpp::Elf_types<32>::Elf_Addr, 336 unsigned int got_offset, 337 unsigned int plt_offset, 338 unsigned int plt_rel_offset); 339 340 private: 341 // The first entry in the PLT for a shared object. 342 static const unsigned char first_plt_entry[plt_entry_size]; 343 344 // Other entries in the PLT for a shared object. 345 static const unsigned char plt_entry[plt_entry_size]; 346 }; 347 348 // The i386 target class. 349 // TLS info comes from 350 // http://people.redhat.com/drepper/tls.pdf 351 // http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt 352 353 class Target_i386 : public Sized_target<32, false> 354 { 355 public: 356 typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section; 357 358 Target_i386(const Target::Target_info* info = &i386_info) 359 : Sized_target<32, false>(info), 360 got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL), 361 got_tlsdesc_(NULL), global_offset_table_(NULL), rel_dyn_(NULL), 362 rel_irelative_(NULL), copy_relocs_(elfcpp::R_386_COPY), 363 got_mod_index_offset_(-1U), tls_base_symbol_defined_(false) 364 { } 365 366 // Process the relocations to determine unreferenced sections for 367 // garbage collection. 368 void 369 gc_process_relocs(Symbol_table* symtab, 370 Layout* layout, 371 Sized_relobj_file<32, false>* object, 372 unsigned int data_shndx, 373 unsigned int sh_type, 374 const unsigned char* prelocs, 375 size_t reloc_count, 376 Output_section* output_section, 377 bool needs_special_offset_handling, 378 size_t local_symbol_count, 379 const unsigned char* plocal_symbols); 380 381 // Scan the relocations to look for symbol adjustments. 382 void 383 scan_relocs(Symbol_table* symtab, 384 Layout* layout, 385 Sized_relobj_file<32, false>* object, 386 unsigned int data_shndx, 387 unsigned int sh_type, 388 const unsigned char* prelocs, 389 size_t reloc_count, 390 Output_section* output_section, 391 bool needs_special_offset_handling, 392 size_t local_symbol_count, 393 const unsigned char* plocal_symbols); 394 395 // Finalize the sections. 396 void 397 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*); 398 399 // Return the value to use for a dynamic which requires special 400 // treatment. 401 uint64_t 402 do_dynsym_value(const Symbol*) const; 403 404 // Relocate a section. 405 void 406 relocate_section(const Relocate_info<32, false>*, 407 unsigned int sh_type, 408 const unsigned char* prelocs, 409 size_t reloc_count, 410 Output_section* output_section, 411 bool needs_special_offset_handling, 412 unsigned char* view, 413 elfcpp::Elf_types<32>::Elf_Addr view_address, 414 section_size_type view_size, 415 const Reloc_symbol_changes*); 416 417 // Scan the relocs during a relocatable link. 418 void 419 scan_relocatable_relocs(Symbol_table* symtab, 420 Layout* layout, 421 Sized_relobj_file<32, false>* object, 422 unsigned int data_shndx, 423 unsigned int sh_type, 424 const unsigned char* prelocs, 425 size_t reloc_count, 426 Output_section* output_section, 427 bool needs_special_offset_handling, 428 size_t local_symbol_count, 429 const unsigned char* plocal_symbols, 430 Relocatable_relocs*); 431 432 // Emit relocations for a section. 433 void 434 relocate_relocs(const Relocate_info<32, false>*, 435 unsigned int sh_type, 436 const unsigned char* prelocs, 437 size_t reloc_count, 438 Output_section* output_section, 439 elfcpp::Elf_types<32>::Elf_Off offset_in_output_section, 440 const Relocatable_relocs*, 441 unsigned char* view, 442 elfcpp::Elf_types<32>::Elf_Addr view_address, 443 section_size_type view_size, 444 unsigned char* reloc_view, 445 section_size_type reloc_view_size); 446 447 // Return a string used to fill a code section with nops. 448 std::string 449 do_code_fill(section_size_type length) const; 450 451 // Return whether SYM is defined by the ABI. 452 bool 453 do_is_defined_by_abi(const Symbol* sym) const 454 { return strcmp(sym->name(), "___tls_get_addr") == 0; } 455 456 // Return whether a symbol name implies a local label. The UnixWare 457 // 2.1 cc generates temporary symbols that start with .X, so we 458 // recognize them here. FIXME: do other SVR4 compilers also use .X?. 459 // If so, we should move the .X recognition into 460 // Target::do_is_local_label_name. 461 bool 462 do_is_local_label_name(const char* name) const 463 { 464 if (name[0] == '.' && name[1] == 'X') 465 return true; 466 return Target::do_is_local_label_name(name); 467 } 468 469 // Return the PLT address to use for a global symbol. 470 uint64_t 471 do_plt_address_for_global(const Symbol* gsym) const 472 { return this->plt_section()->address_for_global(gsym); } 473 474 uint64_t 475 do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const 476 { return this->plt_section()->address_for_local(relobj, symndx); } 477 478 // We can tell whether we take the address of a function. 479 inline bool 480 do_can_check_for_function_pointers() const 481 { return true; } 482 483 // Return the base for a DW_EH_PE_datarel encoding. 484 uint64_t 485 do_ehframe_datarel_base() const; 486 487 // Return whether SYM is call to a non-split function. 488 bool 489 do_is_call_to_non_split(const Symbol* sym, unsigned int) const; 490 491 // Adjust -fsplit-stack code which calls non-split-stack code. 492 void 493 do_calls_non_split(Relobj* object, unsigned int shndx, 494 section_offset_type fnoffset, section_size_type fnsize, 495 unsigned char* view, section_size_type view_size, 496 std::string* from, std::string* to) const; 497 498 // Return the size of the GOT section. 499 section_size_type 500 got_size() const 501 { 502 gold_assert(this->got_ != NULL); 503 return this->got_->data_size(); 504 } 505 506 // Return the number of entries in the GOT. 507 unsigned int 508 got_entry_count() const 509 { 510 if (this->got_ == NULL) 511 return 0; 512 return this->got_size() / 4; 513 } 514 515 // Return the number of entries in the PLT. 516 unsigned int 517 plt_entry_count() const; 518 519 // Return the offset of the first non-reserved PLT entry. 520 unsigned int 521 first_plt_entry_offset() const; 522 523 // Return the size of each PLT entry. 524 unsigned int 525 plt_entry_size() const; 526 527 protected: 528 // Instantiate the plt_ member. 529 // This chooses the right PLT flavor for an executable or a shared object. 530 Output_data_plt_i386* 531 make_data_plt(Layout* layout, 532 Output_data_got_plt_i386* got_plt, 533 Output_data_space* got_irelative, 534 bool dyn) 535 { return this->do_make_data_plt(layout, got_plt, got_irelative, dyn); } 536 537 virtual Output_data_plt_i386* 538 do_make_data_plt(Layout* layout, 539 Output_data_got_plt_i386* got_plt, 540 Output_data_space* got_irelative, 541 bool dyn) 542 { 543 if (dyn) 544 return new Output_data_plt_i386_dyn(layout, got_plt, got_irelative); 545 else 546 return new Output_data_plt_i386_exec(layout, got_plt, got_irelative); 547 } 548 549 private: 550 // The class which scans relocations. 551 struct Scan 552 { 553 static inline int 554 555 get_reference_flags(unsigned int r_type); 556 557 inline void 558 local(Symbol_table* symtab, Layout* layout, Target_i386* target, 559 Sized_relobj_file<32, false>* object, 560 unsigned int data_shndx, 561 Output_section* output_section, 562 const elfcpp::Rel<32, false>& reloc, unsigned int r_type, 563 const elfcpp::Sym<32, false>& lsym, 564 bool is_discarded); 565 566 inline void 567 global(Symbol_table* symtab, Layout* layout, Target_i386* target, 568 Sized_relobj_file<32, false>* object, 569 unsigned int data_shndx, 570 Output_section* output_section, 571 const elfcpp::Rel<32, false>& reloc, unsigned int r_type, 572 Symbol* gsym); 573 574 inline bool 575 local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout, 576 Target_i386* target, 577 Sized_relobj_file<32, false>* object, 578 unsigned int data_shndx, 579 Output_section* output_section, 580 const elfcpp::Rel<32, false>& reloc, 581 unsigned int r_type, 582 const elfcpp::Sym<32, false>& lsym); 583 584 inline bool 585 global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout, 586 Target_i386* target, 587 Sized_relobj_file<32, false>* object, 588 unsigned int data_shndx, 589 Output_section* output_section, 590 const elfcpp::Rel<32, false>& reloc, 591 unsigned int r_type, 592 Symbol* gsym); 593 594 inline bool 595 possible_function_pointer_reloc(unsigned int r_type); 596 597 bool 598 reloc_needs_plt_for_ifunc(Sized_relobj_file<32, false>*, 599 unsigned int r_type); 600 601 static void 602 unsupported_reloc_local(Sized_relobj_file<32, false>*, unsigned int r_type); 603 604 static void 605 unsupported_reloc_global(Sized_relobj_file<32, false>*, unsigned int r_type, 606 Symbol*); 607 }; 608 609 // The class which implements relocation. 610 class Relocate 611 { 612 public: 613 Relocate() 614 : skip_call_tls_get_addr_(false), 615 local_dynamic_type_(LOCAL_DYNAMIC_NONE) 616 { } 617 618 ~Relocate() 619 { 620 if (this->skip_call_tls_get_addr_) 621 { 622 // FIXME: This needs to specify the location somehow. 623 gold_error(_("missing expected TLS relocation")); 624 } 625 } 626 627 // Return whether the static relocation needs to be applied. 628 inline bool 629 should_apply_static_reloc(const Sized_symbol<32>* gsym, 630 unsigned int r_type, 631 bool is_32bit, 632 Output_section* output_section); 633 634 // Do a relocation. Return false if the caller should not issue 635 // any warnings about this relocation. 636 inline bool 637 relocate(const Relocate_info<32, false>*, Target_i386*, Output_section*, 638 size_t relnum, const elfcpp::Rel<32, false>&, 639 unsigned int r_type, const Sized_symbol<32>*, 640 const Symbol_value<32>*, 641 unsigned char*, elfcpp::Elf_types<32>::Elf_Addr, 642 section_size_type); 643 644 private: 645 // Do a TLS relocation. 646 inline void 647 relocate_tls(const Relocate_info<32, false>*, Target_i386* target, 648 size_t relnum, const elfcpp::Rel<32, false>&, 649 unsigned int r_type, const Sized_symbol<32>*, 650 const Symbol_value<32>*, 651 unsigned char*, elfcpp::Elf_types<32>::Elf_Addr, 652 section_size_type); 653 654 // Do a TLS General-Dynamic to Initial-Exec transition. 655 inline void 656 tls_gd_to_ie(const Relocate_info<32, false>*, size_t relnum, 657 Output_segment* tls_segment, 658 const elfcpp::Rel<32, false>&, unsigned int r_type, 659 elfcpp::Elf_types<32>::Elf_Addr value, 660 unsigned char* view, 661 section_size_type view_size); 662 663 // Do a TLS General-Dynamic to Local-Exec transition. 664 inline void 665 tls_gd_to_le(const Relocate_info<32, false>*, size_t relnum, 666 Output_segment* tls_segment, 667 const elfcpp::Rel<32, false>&, unsigned int r_type, 668 elfcpp::Elf_types<32>::Elf_Addr value, 669 unsigned char* view, 670 section_size_type view_size); 671 672 // Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Initial-Exec 673 // transition. 674 inline void 675 tls_desc_gd_to_ie(const Relocate_info<32, false>*, size_t relnum, 676 Output_segment* tls_segment, 677 const elfcpp::Rel<32, false>&, unsigned int r_type, 678 elfcpp::Elf_types<32>::Elf_Addr value, 679 unsigned char* view, 680 section_size_type view_size); 681 682 // Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Local-Exec 683 // transition. 684 inline void 685 tls_desc_gd_to_le(const Relocate_info<32, false>*, size_t relnum, 686 Output_segment* tls_segment, 687 const elfcpp::Rel<32, false>&, unsigned int r_type, 688 elfcpp::Elf_types<32>::Elf_Addr value, 689 unsigned char* view, 690 section_size_type view_size); 691 692 // Do a TLS Local-Dynamic to Local-Exec transition. 693 inline void 694 tls_ld_to_le(const Relocate_info<32, false>*, size_t relnum, 695 Output_segment* tls_segment, 696 const elfcpp::Rel<32, false>&, unsigned int r_type, 697 elfcpp::Elf_types<32>::Elf_Addr value, 698 unsigned char* view, 699 section_size_type view_size); 700 701 // Do a TLS Initial-Exec to Local-Exec transition. 702 static inline void 703 tls_ie_to_le(const Relocate_info<32, false>*, size_t relnum, 704 Output_segment* tls_segment, 705 const elfcpp::Rel<32, false>&, unsigned int r_type, 706 elfcpp::Elf_types<32>::Elf_Addr value, 707 unsigned char* view, 708 section_size_type view_size); 709 710 // We need to keep track of which type of local dynamic relocation 711 // we have seen, so that we can optimize R_386_TLS_LDO_32 correctly. 712 enum Local_dynamic_type 713 { 714 LOCAL_DYNAMIC_NONE, 715 LOCAL_DYNAMIC_SUN, 716 LOCAL_DYNAMIC_GNU 717 }; 718 719 // This is set if we should skip the next reloc, which should be a 720 // PLT32 reloc against ___tls_get_addr. 721 bool skip_call_tls_get_addr_; 722 // The type of local dynamic relocation we have seen in the section 723 // being relocated, if any. 724 Local_dynamic_type local_dynamic_type_; 725 }; 726 727 // A class which returns the size required for a relocation type, 728 // used while scanning relocs during a relocatable link. 729 class Relocatable_size_for_reloc 730 { 731 public: 732 unsigned int 733 get_size_for_reloc(unsigned int, Relobj*); 734 }; 735 736 // Adjust TLS relocation type based on the options and whether this 737 // is a local symbol. 738 static tls::Tls_optimization 739 optimize_tls_reloc(bool is_final, int r_type); 740 741 // Check if relocation against this symbol is a candidate for 742 // conversion from 743 // mov foo@GOT(%reg), %reg 744 // to 745 // lea foo@GOTOFF(%reg), %reg. 746 static bool 747 can_convert_mov_to_lea(const Symbol* gsym) 748 { 749 gold_assert(gsym != NULL); 750 return (gsym->type() != elfcpp::STT_GNU_IFUNC 751 && !gsym->is_undefined () 752 && !gsym->is_from_dynobj() 753 && !gsym->is_preemptible() 754 && (!parameters->options().shared() 755 || (gsym->visibility() != elfcpp::STV_DEFAULT 756 && gsym->visibility() != elfcpp::STV_PROTECTED) 757 || parameters->options().Bsymbolic()) 758 && strcmp(gsym->name(), "_DYNAMIC") != 0); 759 } 760 761 // Get the GOT section, creating it if necessary. 762 Output_data_got<32, false>* 763 got_section(Symbol_table*, Layout*); 764 765 // Get the GOT PLT section. 766 Output_data_got_plt_i386* 767 got_plt_section() const 768 { 769 gold_assert(this->got_plt_ != NULL); 770 return this->got_plt_; 771 } 772 773 // Get the GOT section for TLSDESC entries. 774 Output_data_got<32, false>* 775 got_tlsdesc_section() const 776 { 777 gold_assert(this->got_tlsdesc_ != NULL); 778 return this->got_tlsdesc_; 779 } 780 781 // Create the PLT section. 782 void 783 make_plt_section(Symbol_table* symtab, Layout* layout); 784 785 // Create a PLT entry for a global symbol. 786 void 787 make_plt_entry(Symbol_table*, Layout*, Symbol*); 788 789 // Create a PLT entry for a local STT_GNU_IFUNC symbol. 790 void 791 make_local_ifunc_plt_entry(Symbol_table*, Layout*, 792 Sized_relobj_file<32, false>* relobj, 793 unsigned int local_sym_index); 794 795 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment. 796 void 797 define_tls_base_symbol(Symbol_table*, Layout*); 798 799 // Create a GOT entry for the TLS module index. 800 unsigned int 801 got_mod_index_entry(Symbol_table* symtab, Layout* layout, 802 Sized_relobj_file<32, false>* object); 803 804 // Get the PLT section. 805 Output_data_plt_i386* 806 plt_section() const 807 { 808 gold_assert(this->plt_ != NULL); 809 return this->plt_; 810 } 811 812 // Get the dynamic reloc section, creating it if necessary. 813 Reloc_section* 814 rel_dyn_section(Layout*); 815 816 // Get the section to use for TLS_DESC relocations. 817 Reloc_section* 818 rel_tls_desc_section(Layout*) const; 819 820 // Get the section to use for IRELATIVE relocations. 821 Reloc_section* 822 rel_irelative_section(Layout*); 823 824 // Add a potential copy relocation. 825 void 826 copy_reloc(Symbol_table* symtab, Layout* layout, 827 Sized_relobj_file<32, false>* object, 828 unsigned int shndx, Output_section* output_section, 829 Symbol* sym, const elfcpp::Rel<32, false>& reloc) 830 { 831 unsigned int r_type = elfcpp::elf_r_type<32>(reloc.get_r_info()); 832 this->copy_relocs_.copy_reloc(symtab, layout, 833 symtab->get_sized_symbol<32>(sym), 834 object, shndx, output_section, 835 r_type, reloc.get_r_offset(), 0, 836 this->rel_dyn_section(layout)); 837 } 838 839 // Information about this specific target which we pass to the 840 // general Target structure. 841 static const Target::Target_info i386_info; 842 843 // The types of GOT entries needed for this platform. 844 // These values are exposed to the ABI in an incremental link. 845 // Do not renumber existing values without changing the version 846 // number of the .gnu_incremental_inputs section. 847 enum Got_type 848 { 849 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol 850 GOT_TYPE_TLS_NOFFSET = 1, // GOT entry for negative TLS offset 851 GOT_TYPE_TLS_OFFSET = 2, // GOT entry for positive TLS offset 852 GOT_TYPE_TLS_PAIR = 3, // GOT entry for TLS module/offset pair 853 GOT_TYPE_TLS_DESC = 4 // GOT entry for TLS_DESC pair 854 }; 855 856 // The GOT section. 857 Output_data_got<32, false>* got_; 858 // The PLT section. 859 Output_data_plt_i386* plt_; 860 // The GOT PLT section. 861 Output_data_got_plt_i386* got_plt_; 862 // The GOT section for IRELATIVE relocations. 863 Output_data_space* got_irelative_; 864 // The GOT section for TLSDESC relocations. 865 Output_data_got<32, false>* got_tlsdesc_; 866 // The _GLOBAL_OFFSET_TABLE_ symbol. 867 Symbol* global_offset_table_; 868 // The dynamic reloc section. 869 Reloc_section* rel_dyn_; 870 // The section to use for IRELATIVE relocs. 871 Reloc_section* rel_irelative_; 872 // Relocs saved to avoid a COPY reloc. 873 Copy_relocs<elfcpp::SHT_REL, 32, false> copy_relocs_; 874 // Offset of the GOT entry for the TLS module index. 875 unsigned int got_mod_index_offset_; 876 // True if the _TLS_MODULE_BASE_ symbol has been defined. 877 bool tls_base_symbol_defined_; 878 }; 879 880 const Target::Target_info Target_i386::i386_info = 881 { 882 32, // size 883 false, // is_big_endian 884 elfcpp::EM_386, // machine_code 885 false, // has_make_symbol 886 false, // has_resolve 887 true, // has_code_fill 888 true, // is_default_stack_executable 889 true, // can_icf_inline_merge_sections 890 '\0', // wrap_char 891 "/usr/lib/libc.so.1", // dynamic_linker 892 0x08048000, // default_text_segment_address 893 0x1000, // abi_pagesize (overridable by -z max-page-size) 894 0x1000, // common_pagesize (overridable by -z common-page-size) 895 false, // isolate_execinstr 896 0, // rosegment_gap 897 elfcpp::SHN_UNDEF, // small_common_shndx 898 elfcpp::SHN_UNDEF, // large_common_shndx 899 0, // small_common_section_flags 900 0, // large_common_section_flags 901 NULL, // attributes_section 902 NULL, // attributes_vendor 903 "_start", // entry_symbol_name 904 32, // hash_entry_size 905 }; 906 907 // Get the GOT section, creating it if necessary. 908 909 Output_data_got<32, false>* 910 Target_i386::got_section(Symbol_table* symtab, Layout* layout) 911 { 912 if (this->got_ == NULL) 913 { 914 gold_assert(symtab != NULL && layout != NULL); 915 916 this->got_ = new Output_data_got<32, false>(); 917 918 // When using -z now, we can treat .got.plt as a relro section. 919 // Without -z now, it is modified after program startup by lazy 920 // PLT relocations. 921 bool is_got_plt_relro = parameters->options().now(); 922 Output_section_order got_order = (is_got_plt_relro 923 ? ORDER_RELRO 924 : ORDER_RELRO_LAST); 925 Output_section_order got_plt_order = (is_got_plt_relro 926 ? ORDER_RELRO 927 : ORDER_NON_RELRO_FIRST); 928 929 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 930 (elfcpp::SHF_ALLOC 931 | elfcpp::SHF_WRITE), 932 this->got_, got_order, true); 933 934 this->got_plt_ = new Output_data_got_plt_i386(layout); 935 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 936 (elfcpp::SHF_ALLOC 937 | elfcpp::SHF_WRITE), 938 this->got_plt_, got_plt_order, 939 is_got_plt_relro); 940 941 // The first three entries are reserved. 942 this->got_plt_->set_current_data_size(3 * 4); 943 944 if (!is_got_plt_relro) 945 { 946 // Those bytes can go into the relro segment. 947 layout->increase_relro(3 * 4); 948 } 949 950 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT. 951 this->global_offset_table_ = 952 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 953 Symbol_table::PREDEFINED, 954 this->got_plt_, 955 0, 0, elfcpp::STT_OBJECT, 956 elfcpp::STB_LOCAL, 957 elfcpp::STV_HIDDEN, 0, 958 false, false); 959 960 // If there are any IRELATIVE relocations, they get GOT entries 961 // in .got.plt after the jump slot relocations. 962 this->got_irelative_ = new Output_data_space(4, "** GOT IRELATIVE PLT"); 963 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 964 (elfcpp::SHF_ALLOC 965 | elfcpp::SHF_WRITE), 966 this->got_irelative_, 967 got_plt_order, is_got_plt_relro); 968 969 // If there are any TLSDESC relocations, they get GOT entries in 970 // .got.plt after the jump slot entries. 971 this->got_tlsdesc_ = new Output_data_got<32, false>(); 972 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 973 (elfcpp::SHF_ALLOC 974 | elfcpp::SHF_WRITE), 975 this->got_tlsdesc_, 976 got_plt_order, is_got_plt_relro); 977 } 978 979 return this->got_; 980 } 981 982 // Get the dynamic reloc section, creating it if necessary. 983 984 Target_i386::Reloc_section* 985 Target_i386::rel_dyn_section(Layout* layout) 986 { 987 if (this->rel_dyn_ == NULL) 988 { 989 gold_assert(layout != NULL); 990 this->rel_dyn_ = new Reloc_section(parameters->options().combreloc()); 991 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, 992 elfcpp::SHF_ALLOC, this->rel_dyn_, 993 ORDER_DYNAMIC_RELOCS, false); 994 } 995 return this->rel_dyn_; 996 } 997 998 // Get the section to use for IRELATIVE relocs, creating it if 999 // necessary. These go in .rel.dyn, but only after all other dynamic 1000 // relocations. They need to follow the other dynamic relocations so 1001 // that they can refer to global variables initialized by those 1002 // relocs. 1003 1004 Target_i386::Reloc_section* 1005 Target_i386::rel_irelative_section(Layout* layout) 1006 { 1007 if (this->rel_irelative_ == NULL) 1008 { 1009 // Make sure we have already create the dynamic reloc section. 1010 this->rel_dyn_section(layout); 1011 this->rel_irelative_ = new Reloc_section(false); 1012 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, 1013 elfcpp::SHF_ALLOC, this->rel_irelative_, 1014 ORDER_DYNAMIC_RELOCS, false); 1015 gold_assert(this->rel_dyn_->output_section() 1016 == this->rel_irelative_->output_section()); 1017 } 1018 return this->rel_irelative_; 1019 } 1020 1021 // Write the first three reserved words of the .got.plt section. 1022 // The remainder of the section is written while writing the PLT 1023 // in Output_data_plt_i386::do_write. 1024 1025 void 1026 Output_data_got_plt_i386::do_write(Output_file* of) 1027 { 1028 // The first entry in the GOT is the address of the .dynamic section 1029 // aka the PT_DYNAMIC segment. The next two entries are reserved. 1030 // We saved space for them when we created the section in 1031 // Target_i386::got_section. 1032 const off_t got_file_offset = this->offset(); 1033 gold_assert(this->data_size() >= 12); 1034 unsigned char* const got_view = of->get_output_view(got_file_offset, 12); 1035 Output_section* dynamic = this->layout_->dynamic_section(); 1036 uint32_t dynamic_addr = dynamic == NULL ? 0 : dynamic->address(); 1037 elfcpp::Swap<32, false>::writeval(got_view, dynamic_addr); 1038 memset(got_view + 4, 0, 8); 1039 of->write_output_view(got_file_offset, 12, got_view); 1040 } 1041 1042 // Create the PLT section. The ordinary .got section is an argument, 1043 // since we need to refer to the start. We also create our own .got 1044 // section just for PLT entries. 1045 1046 Output_data_plt_i386::Output_data_plt_i386(Layout* layout, 1047 uint64_t addralign, 1048 Output_data_got_plt_i386* got_plt, 1049 Output_data_space* got_irelative) 1050 : Output_section_data(addralign), 1051 tls_desc_rel_(NULL), irelative_rel_(NULL), got_plt_(got_plt), 1052 got_irelative_(got_irelative), count_(0), irelative_count_(0), 1053 global_ifuncs_(), local_ifuncs_() 1054 { 1055 this->rel_ = new Reloc_section(false); 1056 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 1057 elfcpp::SHF_ALLOC, this->rel_, 1058 ORDER_DYNAMIC_PLT_RELOCS, false); 1059 } 1060 1061 void 1062 Output_data_plt_i386::do_adjust_output_section(Output_section* os) 1063 { 1064 // UnixWare sets the entsize of .plt to 4, and so does the old GNU 1065 // linker, and so do we. 1066 os->set_entsize(4); 1067 } 1068 1069 // Add an entry to the PLT. 1070 1071 void 1072 Output_data_plt_i386::add_entry(Symbol_table* symtab, Layout* layout, 1073 Symbol* gsym) 1074 { 1075 gold_assert(!gsym->has_plt_offset()); 1076 1077 // Every PLT entry needs a reloc. 1078 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1079 && gsym->can_use_relative_reloc(false)) 1080 { 1081 gsym->set_plt_offset(this->irelative_count_ * this->get_plt_entry_size()); 1082 ++this->irelative_count_; 1083 section_offset_type got_offset = 1084 this->got_irelative_->current_data_size(); 1085 this->got_irelative_->set_current_data_size(got_offset + 4); 1086 Reloc_section* rel = this->rel_irelative(symtab, layout); 1087 rel->add_symbolless_global_addend(gsym, elfcpp::R_386_IRELATIVE, 1088 this->got_irelative_, got_offset); 1089 struct Global_ifunc gi; 1090 gi.sym = gsym; 1091 gi.got_offset = got_offset; 1092 this->global_ifuncs_.push_back(gi); 1093 } 1094 else 1095 { 1096 // When setting the PLT offset we skip the initial reserved PLT 1097 // entry. 1098 gsym->set_plt_offset((this->count_ + 1) * this->get_plt_entry_size()); 1099 1100 ++this->count_; 1101 1102 section_offset_type got_offset = this->got_plt_->current_data_size(); 1103 1104 // Every PLT entry needs a GOT entry which points back to the 1105 // PLT entry (this will be changed by the dynamic linker, 1106 // normally lazily when the function is called). 1107 this->got_plt_->set_current_data_size(got_offset + 4); 1108 1109 gsym->set_needs_dynsym_entry(); 1110 this->rel_->add_global(gsym, elfcpp::R_386_JUMP_SLOT, this->got_plt_, 1111 got_offset); 1112 } 1113 1114 // Note that we don't need to save the symbol. The contents of the 1115 // PLT are independent of which symbols are used. The symbols only 1116 // appear in the relocations. 1117 } 1118 1119 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return 1120 // the PLT offset. 1121 1122 unsigned int 1123 Output_data_plt_i386::add_local_ifunc_entry( 1124 Symbol_table* symtab, 1125 Layout* layout, 1126 Sized_relobj_file<32, false>* relobj, 1127 unsigned int local_sym_index) 1128 { 1129 unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size(); 1130 ++this->irelative_count_; 1131 1132 section_offset_type got_offset = this->got_irelative_->current_data_size(); 1133 1134 // Every PLT entry needs a GOT entry which points back to the PLT 1135 // entry. 1136 this->got_irelative_->set_current_data_size(got_offset + 4); 1137 1138 // Every PLT entry needs a reloc. 1139 Reloc_section* rel = this->rel_irelative(symtab, layout); 1140 rel->add_symbolless_local_addend(relobj, local_sym_index, 1141 elfcpp::R_386_IRELATIVE, 1142 this->got_irelative_, got_offset); 1143 1144 struct Local_ifunc li; 1145 li.object = relobj; 1146 li.local_sym_index = local_sym_index; 1147 li.got_offset = got_offset; 1148 this->local_ifuncs_.push_back(li); 1149 1150 return plt_offset; 1151 } 1152 1153 // Return where the TLS_DESC relocations should go, creating it if 1154 // necessary. These follow the JUMP_SLOT relocations. 1155 1156 Output_data_plt_i386::Reloc_section* 1157 Output_data_plt_i386::rel_tls_desc(Layout* layout) 1158 { 1159 if (this->tls_desc_rel_ == NULL) 1160 { 1161 this->tls_desc_rel_ = new Reloc_section(false); 1162 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 1163 elfcpp::SHF_ALLOC, this->tls_desc_rel_, 1164 ORDER_DYNAMIC_PLT_RELOCS, false); 1165 gold_assert(this->tls_desc_rel_->output_section() 1166 == this->rel_->output_section()); 1167 } 1168 return this->tls_desc_rel_; 1169 } 1170 1171 // Return where the IRELATIVE relocations should go in the PLT. These 1172 // follow the JUMP_SLOT and TLS_DESC relocations. 1173 1174 Output_data_plt_i386::Reloc_section* 1175 Output_data_plt_i386::rel_irelative(Symbol_table* symtab, Layout* layout) 1176 { 1177 if (this->irelative_rel_ == NULL) 1178 { 1179 // Make sure we have a place for the TLS_DESC relocations, in 1180 // case we see any later on. 1181 this->rel_tls_desc(layout); 1182 this->irelative_rel_ = new Reloc_section(false); 1183 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 1184 elfcpp::SHF_ALLOC, this->irelative_rel_, 1185 ORDER_DYNAMIC_PLT_RELOCS, false); 1186 gold_assert(this->irelative_rel_->output_section() 1187 == this->rel_->output_section()); 1188 1189 if (parameters->doing_static_link()) 1190 { 1191 // A statically linked executable will only have a .rel.plt 1192 // section to hold R_386_IRELATIVE relocs for STT_GNU_IFUNC 1193 // symbols. The library will use these symbols to locate 1194 // the IRELATIVE relocs at program startup time. 1195 symtab->define_in_output_data("__rel_iplt_start", NULL, 1196 Symbol_table::PREDEFINED, 1197 this->irelative_rel_, 0, 0, 1198 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1199 elfcpp::STV_HIDDEN, 0, false, true); 1200 symtab->define_in_output_data("__rel_iplt_end", NULL, 1201 Symbol_table::PREDEFINED, 1202 this->irelative_rel_, 0, 0, 1203 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1204 elfcpp::STV_HIDDEN, 0, true, true); 1205 } 1206 } 1207 return this->irelative_rel_; 1208 } 1209 1210 // Return the PLT address to use for a global symbol. 1211 1212 uint64_t 1213 Output_data_plt_i386::address_for_global(const Symbol* gsym) 1214 { 1215 uint64_t offset = 0; 1216 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1217 && gsym->can_use_relative_reloc(false)) 1218 offset = (this->count_ + 1) * this->get_plt_entry_size(); 1219 return this->address() + offset + gsym->plt_offset(); 1220 } 1221 1222 // Return the PLT address to use for a local symbol. These are always 1223 // IRELATIVE relocs. 1224 1225 uint64_t 1226 Output_data_plt_i386::address_for_local(const Relobj* object, 1227 unsigned int r_sym) 1228 { 1229 return (this->address() 1230 + (this->count_ + 1) * this->get_plt_entry_size() 1231 + object->local_plt_offset(r_sym)); 1232 } 1233 1234 // The first entry in the PLT for an executable. 1235 1236 const unsigned char Output_data_plt_i386_exec::first_plt_entry[plt_entry_size] = 1237 { 1238 0xff, 0x35, // pushl contents of memory address 1239 0, 0, 0, 0, // replaced with address of .got + 4 1240 0xff, 0x25, // jmp indirect 1241 0, 0, 0, 0, // replaced with address of .got + 8 1242 0, 0, 0, 0 // unused 1243 }; 1244 1245 void 1246 Output_data_plt_i386_exec::do_fill_first_plt_entry( 1247 unsigned char* pov, 1248 elfcpp::Elf_types<32>::Elf_Addr got_address) 1249 { 1250 memcpy(pov, first_plt_entry, plt_entry_size); 1251 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4); 1252 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8); 1253 } 1254 1255 // The first entry in the PLT for a shared object. 1256 1257 const unsigned char Output_data_plt_i386_dyn::first_plt_entry[plt_entry_size] = 1258 { 1259 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx) 1260 0xff, 0xa3, 8, 0, 0, 0, // jmp *8(%ebx) 1261 0, 0, 0, 0 // unused 1262 }; 1263 1264 void 1265 Output_data_plt_i386_dyn::do_fill_first_plt_entry( 1266 unsigned char* pov, 1267 elfcpp::Elf_types<32>::Elf_Addr) 1268 { 1269 memcpy(pov, first_plt_entry, plt_entry_size); 1270 } 1271 1272 // Subsequent entries in the PLT for an executable. 1273 1274 const unsigned char Output_data_plt_i386_exec::plt_entry[plt_entry_size] = 1275 { 1276 0xff, 0x25, // jmp indirect 1277 0, 0, 0, 0, // replaced with address of symbol in .got 1278 0x68, // pushl immediate 1279 0, 0, 0, 0, // replaced with offset into relocation table 1280 0xe9, // jmp relative 1281 0, 0, 0, 0 // replaced with offset to start of .plt 1282 }; 1283 1284 unsigned int 1285 Output_data_plt_i386_exec::do_fill_plt_entry( 1286 unsigned char* pov, 1287 elfcpp::Elf_types<32>::Elf_Addr got_address, 1288 unsigned int got_offset, 1289 unsigned int plt_offset, 1290 unsigned int plt_rel_offset) 1291 { 1292 memcpy(pov, plt_entry, plt_entry_size); 1293 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 1294 got_address + got_offset); 1295 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset); 1296 elfcpp::Swap<32, false>::writeval(pov + 12, - (plt_offset + 12 + 4)); 1297 return 6; 1298 } 1299 1300 // Subsequent entries in the PLT for a shared object. 1301 1302 const unsigned char Output_data_plt_i386_dyn::plt_entry[plt_entry_size] = 1303 { 1304 0xff, 0xa3, // jmp *offset(%ebx) 1305 0, 0, 0, 0, // replaced with offset of symbol in .got 1306 0x68, // pushl immediate 1307 0, 0, 0, 0, // replaced with offset into relocation table 1308 0xe9, // jmp relative 1309 0, 0, 0, 0 // replaced with offset to start of .plt 1310 }; 1311 1312 unsigned int 1313 Output_data_plt_i386_dyn::do_fill_plt_entry(unsigned char* pov, 1314 elfcpp::Elf_types<32>::Elf_Addr, 1315 unsigned int got_offset, 1316 unsigned int plt_offset, 1317 unsigned int plt_rel_offset) 1318 { 1319 memcpy(pov, plt_entry, plt_entry_size); 1320 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset); 1321 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset); 1322 elfcpp::Swap<32, false>::writeval(pov + 12, - (plt_offset + 12 + 4)); 1323 return 6; 1324 } 1325 1326 // The .eh_frame unwind information for the PLT. 1327 1328 const unsigned char 1329 Output_data_plt_i386::plt_eh_frame_cie[plt_eh_frame_cie_size] = 1330 { 1331 1, // CIE version. 1332 'z', // Augmentation: augmentation size included. 1333 'R', // Augmentation: FDE encoding included. 1334 '\0', // End of augmentation string. 1335 1, // Code alignment factor. 1336 0x7c, // Data alignment factor. 1337 8, // Return address column. 1338 1, // Augmentation size. 1339 (elfcpp::DW_EH_PE_pcrel // FDE encoding. 1340 | elfcpp::DW_EH_PE_sdata4), 1341 elfcpp::DW_CFA_def_cfa, 4, 4, // DW_CFA_def_cfa: r4 (esp) ofs 4. 1342 elfcpp::DW_CFA_offset + 8, 1, // DW_CFA_offset: r8 (eip) at cfa-4. 1343 elfcpp::DW_CFA_nop, // Align to 16 bytes. 1344 elfcpp::DW_CFA_nop 1345 }; 1346 1347 const unsigned char 1348 Output_data_plt_i386_standard::plt_eh_frame_fde[plt_eh_frame_fde_size] = 1349 { 1350 0, 0, 0, 0, // Replaced with offset to .plt. 1351 0, 0, 0, 0, // Replaced with size of .plt. 1352 0, // Augmentation size. 1353 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8. 1354 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 1355 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12. 1356 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16. 1357 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 1358 11, // Block length. 1359 elfcpp::DW_OP_breg4, 4, // Push %esp + 4. 1360 elfcpp::DW_OP_breg8, 0, // Push %eip. 1361 elfcpp::DW_OP_lit15, // Push 0xf. 1362 elfcpp::DW_OP_and, // & (%eip & 0xf). 1363 elfcpp::DW_OP_lit11, // Push 0xb. 1364 elfcpp::DW_OP_ge, // >= ((%eip & 0xf) >= 0xb) 1365 elfcpp::DW_OP_lit2, // Push 2. 1366 elfcpp::DW_OP_shl, // << (((%eip & 0xf) >= 0xb) << 2) 1367 elfcpp::DW_OP_plus, // + ((((%eip&0xf)>=0xb)<<2)+%esp+4 1368 elfcpp::DW_CFA_nop, // Align to 32 bytes. 1369 elfcpp::DW_CFA_nop, 1370 elfcpp::DW_CFA_nop, 1371 elfcpp::DW_CFA_nop 1372 }; 1373 1374 // Write out the PLT. This uses the hand-coded instructions above, 1375 // and adjusts them as needed. This is all specified by the i386 ELF 1376 // Processor Supplement. 1377 1378 void 1379 Output_data_plt_i386::do_write(Output_file* of) 1380 { 1381 const off_t offset = this->offset(); 1382 const section_size_type oview_size = 1383 convert_to_section_size_type(this->data_size()); 1384 unsigned char* const oview = of->get_output_view(offset, oview_size); 1385 1386 const off_t got_file_offset = this->got_plt_->offset(); 1387 gold_assert(parameters->incremental_update() 1388 || (got_file_offset + this->got_plt_->data_size() 1389 == this->got_irelative_->offset())); 1390 const section_size_type got_size = 1391 convert_to_section_size_type(this->got_plt_->data_size() 1392 + this->got_irelative_->data_size()); 1393 1394 unsigned char* const got_view = of->get_output_view(got_file_offset, 1395 got_size); 1396 1397 unsigned char* pov = oview; 1398 1399 elfcpp::Elf_types<32>::Elf_Addr plt_address = this->address(); 1400 elfcpp::Elf_types<32>::Elf_Addr got_address = this->got_plt_->address(); 1401 1402 this->fill_first_plt_entry(pov, got_address); 1403 pov += this->get_plt_entry_size(); 1404 1405 // The first three entries in the GOT are reserved, and are written 1406 // by Output_data_got_plt_i386::do_write. 1407 unsigned char* got_pov = got_view + 12; 1408 1409 const int rel_size = elfcpp::Elf_sizes<32>::rel_size; 1410 1411 unsigned int plt_offset = this->get_plt_entry_size(); 1412 unsigned int plt_rel_offset = 0; 1413 unsigned int got_offset = 12; 1414 const unsigned int count = this->count_ + this->irelative_count_; 1415 for (unsigned int i = 0; 1416 i < count; 1417 ++i, 1418 pov += this->get_plt_entry_size(), 1419 got_pov += 4, 1420 plt_offset += this->get_plt_entry_size(), 1421 plt_rel_offset += rel_size, 1422 got_offset += 4) 1423 { 1424 // Set and adjust the PLT entry itself. 1425 unsigned int lazy_offset = this->fill_plt_entry(pov, 1426 got_address, 1427 got_offset, 1428 plt_offset, 1429 plt_rel_offset); 1430 1431 // Set the entry in the GOT. 1432 elfcpp::Swap<32, false>::writeval(got_pov, 1433 plt_address + plt_offset + lazy_offset); 1434 } 1435 1436 // If any STT_GNU_IFUNC symbols have PLT entries, we need to change 1437 // the GOT to point to the actual symbol value, rather than point to 1438 // the PLT entry. That will let the dynamic linker call the right 1439 // function when resolving IRELATIVE relocations. 1440 unsigned char* got_irelative_view = got_view + this->got_plt_->data_size(); 1441 for (std::vector<Global_ifunc>::const_iterator p = 1442 this->global_ifuncs_.begin(); 1443 p != this->global_ifuncs_.end(); 1444 ++p) 1445 { 1446 const Sized_symbol<32>* ssym = 1447 static_cast<const Sized_symbol<32>*>(p->sym); 1448 elfcpp::Swap<32, false>::writeval(got_irelative_view + p->got_offset, 1449 ssym->value()); 1450 } 1451 1452 for (std::vector<Local_ifunc>::const_iterator p = 1453 this->local_ifuncs_.begin(); 1454 p != this->local_ifuncs_.end(); 1455 ++p) 1456 { 1457 const Symbol_value<32>* psymval = 1458 p->object->local_symbol(p->local_sym_index); 1459 elfcpp::Swap<32, false>::writeval(got_irelative_view + p->got_offset, 1460 psymval->value(p->object, 0)); 1461 } 1462 1463 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 1464 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); 1465 1466 of->write_output_view(offset, oview_size, oview); 1467 of->write_output_view(got_file_offset, got_size, got_view); 1468 } 1469 1470 // Create the PLT section. 1471 1472 void 1473 Target_i386::make_plt_section(Symbol_table* symtab, Layout* layout) 1474 { 1475 if (this->plt_ == NULL) 1476 { 1477 // Create the GOT sections first. 1478 this->got_section(symtab, layout); 1479 1480 const bool dyn = parameters->options().output_is_position_independent(); 1481 this->plt_ = this->make_data_plt(layout, 1482 this->got_plt_, 1483 this->got_irelative_, 1484 dyn); 1485 1486 // Add unwind information if requested. 1487 if (parameters->options().ld_generated_unwind_info()) 1488 this->plt_->add_eh_frame(layout); 1489 1490 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 1491 (elfcpp::SHF_ALLOC 1492 | elfcpp::SHF_EXECINSTR), 1493 this->plt_, ORDER_PLT, false); 1494 1495 // Make the sh_info field of .rel.plt point to .plt. 1496 Output_section* rel_plt_os = this->plt_->rel_plt()->output_section(); 1497 rel_plt_os->set_info_section(this->plt_->output_section()); 1498 } 1499 } 1500 1501 // Create a PLT entry for a global symbol. 1502 1503 void 1504 Target_i386::make_plt_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym) 1505 { 1506 if (gsym->has_plt_offset()) 1507 return; 1508 if (this->plt_ == NULL) 1509 this->make_plt_section(symtab, layout); 1510 this->plt_->add_entry(symtab, layout, gsym); 1511 } 1512 1513 // Make a PLT entry for a local STT_GNU_IFUNC symbol. 1514 1515 void 1516 Target_i386::make_local_ifunc_plt_entry(Symbol_table* symtab, Layout* layout, 1517 Sized_relobj_file<32, false>* relobj, 1518 unsigned int local_sym_index) 1519 { 1520 if (relobj->local_has_plt_offset(local_sym_index)) 1521 return; 1522 if (this->plt_ == NULL) 1523 this->make_plt_section(symtab, layout); 1524 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout, 1525 relobj, 1526 local_sym_index); 1527 relobj->set_local_plt_offset(local_sym_index, plt_offset); 1528 } 1529 1530 // Return the number of entries in the PLT. 1531 1532 unsigned int 1533 Target_i386::plt_entry_count() const 1534 { 1535 if (this->plt_ == NULL) 1536 return 0; 1537 return this->plt_->entry_count(); 1538 } 1539 1540 // Return the offset of the first non-reserved PLT entry. 1541 1542 unsigned int 1543 Target_i386::first_plt_entry_offset() const 1544 { 1545 return this->plt_->first_plt_entry_offset(); 1546 } 1547 1548 // Return the size of each PLT entry. 1549 1550 unsigned int 1551 Target_i386::plt_entry_size() const 1552 { 1553 return this->plt_->get_plt_entry_size(); 1554 } 1555 1556 // Get the section to use for TLS_DESC relocations. 1557 1558 Target_i386::Reloc_section* 1559 Target_i386::rel_tls_desc_section(Layout* layout) const 1560 { 1561 return this->plt_section()->rel_tls_desc(layout); 1562 } 1563 1564 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment. 1565 1566 void 1567 Target_i386::define_tls_base_symbol(Symbol_table* symtab, Layout* layout) 1568 { 1569 if (this->tls_base_symbol_defined_) 1570 return; 1571 1572 Output_segment* tls_segment = layout->tls_segment(); 1573 if (tls_segment != NULL) 1574 { 1575 bool is_exec = parameters->options().output_is_executable(); 1576 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL, 1577 Symbol_table::PREDEFINED, 1578 tls_segment, 0, 0, 1579 elfcpp::STT_TLS, 1580 elfcpp::STB_LOCAL, 1581 elfcpp::STV_HIDDEN, 0, 1582 (is_exec 1583 ? Symbol::SEGMENT_END 1584 : Symbol::SEGMENT_START), 1585 true); 1586 } 1587 this->tls_base_symbol_defined_ = true; 1588 } 1589 1590 // Create a GOT entry for the TLS module index. 1591 1592 unsigned int 1593 Target_i386::got_mod_index_entry(Symbol_table* symtab, Layout* layout, 1594 Sized_relobj_file<32, false>* object) 1595 { 1596 if (this->got_mod_index_offset_ == -1U) 1597 { 1598 gold_assert(symtab != NULL && layout != NULL && object != NULL); 1599 Reloc_section* rel_dyn = this->rel_dyn_section(layout); 1600 Output_data_got<32, false>* got = this->got_section(symtab, layout); 1601 unsigned int got_offset = got->add_constant(0); 1602 rel_dyn->add_local(object, 0, elfcpp::R_386_TLS_DTPMOD32, got, 1603 got_offset); 1604 got->add_constant(0); 1605 this->got_mod_index_offset_ = got_offset; 1606 } 1607 return this->got_mod_index_offset_; 1608 } 1609 1610 // Optimize the TLS relocation type based on what we know about the 1611 // symbol. IS_FINAL is true if the final address of this symbol is 1612 // known at link time. 1613 1614 tls::Tls_optimization 1615 Target_i386::optimize_tls_reloc(bool is_final, int r_type) 1616 { 1617 // If we are generating a shared library, then we can't do anything 1618 // in the linker. 1619 if (parameters->options().shared()) 1620 return tls::TLSOPT_NONE; 1621 1622 switch (r_type) 1623 { 1624 case elfcpp::R_386_TLS_GD: 1625 case elfcpp::R_386_TLS_GOTDESC: 1626 case elfcpp::R_386_TLS_DESC_CALL: 1627 // These are General-Dynamic which permits fully general TLS 1628 // access. Since we know that we are generating an executable, 1629 // we can convert this to Initial-Exec. If we also know that 1630 // this is a local symbol, we can further switch to Local-Exec. 1631 if (is_final) 1632 return tls::TLSOPT_TO_LE; 1633 return tls::TLSOPT_TO_IE; 1634 1635 case elfcpp::R_386_TLS_LDM: 1636 // This is Local-Dynamic, which refers to a local symbol in the 1637 // dynamic TLS block. Since we know that we generating an 1638 // executable, we can switch to Local-Exec. 1639 return tls::TLSOPT_TO_LE; 1640 1641 case elfcpp::R_386_TLS_LDO_32: 1642 // Another type of Local-Dynamic relocation. 1643 return tls::TLSOPT_TO_LE; 1644 1645 case elfcpp::R_386_TLS_IE: 1646 case elfcpp::R_386_TLS_GOTIE: 1647 case elfcpp::R_386_TLS_IE_32: 1648 // These are Initial-Exec relocs which get the thread offset 1649 // from the GOT. If we know that we are linking against the 1650 // local symbol, we can switch to Local-Exec, which links the 1651 // thread offset into the instruction. 1652 if (is_final) 1653 return tls::TLSOPT_TO_LE; 1654 return tls::TLSOPT_NONE; 1655 1656 case elfcpp::R_386_TLS_LE: 1657 case elfcpp::R_386_TLS_LE_32: 1658 // When we already have Local-Exec, there is nothing further we 1659 // can do. 1660 return tls::TLSOPT_NONE; 1661 1662 default: 1663 gold_unreachable(); 1664 } 1665 } 1666 1667 // Get the Reference_flags for a particular relocation. 1668 1669 int 1670 Target_i386::Scan::get_reference_flags(unsigned int r_type) 1671 { 1672 switch (r_type) 1673 { 1674 case elfcpp::R_386_NONE: 1675 case elfcpp::R_386_GNU_VTINHERIT: 1676 case elfcpp::R_386_GNU_VTENTRY: 1677 case elfcpp::R_386_GOTPC: 1678 // No symbol reference. 1679 return 0; 1680 1681 case elfcpp::R_386_32: 1682 case elfcpp::R_386_16: 1683 case elfcpp::R_386_8: 1684 return Symbol::ABSOLUTE_REF; 1685 1686 case elfcpp::R_386_PC32: 1687 case elfcpp::R_386_PC16: 1688 case elfcpp::R_386_PC8: 1689 case elfcpp::R_386_GOTOFF: 1690 return Symbol::RELATIVE_REF; 1691 1692 case elfcpp::R_386_PLT32: 1693 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF; 1694 1695 case elfcpp::R_386_GOT32: 1696 case elfcpp::R_386_GOT32X: 1697 // Absolute in GOT. 1698 return Symbol::ABSOLUTE_REF; 1699 1700 case elfcpp::R_386_TLS_GD: // Global-dynamic 1701 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 1702 case elfcpp::R_386_TLS_DESC_CALL: 1703 case elfcpp::R_386_TLS_LDM: // Local-dynamic 1704 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 1705 case elfcpp::R_386_TLS_IE: // Initial-exec 1706 case elfcpp::R_386_TLS_IE_32: 1707 case elfcpp::R_386_TLS_GOTIE: 1708 case elfcpp::R_386_TLS_LE: // Local-exec 1709 case elfcpp::R_386_TLS_LE_32: 1710 return Symbol::TLS_REF; 1711 1712 case elfcpp::R_386_COPY: 1713 case elfcpp::R_386_GLOB_DAT: 1714 case elfcpp::R_386_JUMP_SLOT: 1715 case elfcpp::R_386_RELATIVE: 1716 case elfcpp::R_386_IRELATIVE: 1717 case elfcpp::R_386_TLS_TPOFF: 1718 case elfcpp::R_386_TLS_DTPMOD32: 1719 case elfcpp::R_386_TLS_DTPOFF32: 1720 case elfcpp::R_386_TLS_TPOFF32: 1721 case elfcpp::R_386_TLS_DESC: 1722 case elfcpp::R_386_32PLT: 1723 case elfcpp::R_386_TLS_GD_32: 1724 case elfcpp::R_386_TLS_GD_PUSH: 1725 case elfcpp::R_386_TLS_GD_CALL: 1726 case elfcpp::R_386_TLS_GD_POP: 1727 case elfcpp::R_386_TLS_LDM_32: 1728 case elfcpp::R_386_TLS_LDM_PUSH: 1729 case elfcpp::R_386_TLS_LDM_CALL: 1730 case elfcpp::R_386_TLS_LDM_POP: 1731 case elfcpp::R_386_USED_BY_INTEL_200: 1732 default: 1733 // Not expected. We will give an error later. 1734 return 0; 1735 } 1736 } 1737 1738 // Report an unsupported relocation against a local symbol. 1739 1740 void 1741 Target_i386::Scan::unsupported_reloc_local(Sized_relobj_file<32, false>* object, 1742 unsigned int r_type) 1743 { 1744 gold_error(_("%s: unsupported reloc %u against local symbol"), 1745 object->name().c_str(), r_type); 1746 } 1747 1748 // Return whether we need to make a PLT entry for a relocation of a 1749 // given type against a STT_GNU_IFUNC symbol. 1750 1751 bool 1752 Target_i386::Scan::reloc_needs_plt_for_ifunc( 1753 Sized_relobj_file<32, false>* object, 1754 unsigned int r_type) 1755 { 1756 int flags = Scan::get_reference_flags(r_type); 1757 if (flags & Symbol::TLS_REF) 1758 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"), 1759 object->name().c_str(), r_type); 1760 return flags != 0; 1761 } 1762 1763 // Scan a relocation for a local symbol. 1764 1765 inline void 1766 Target_i386::Scan::local(Symbol_table* symtab, 1767 Layout* layout, 1768 Target_i386* target, 1769 Sized_relobj_file<32, false>* object, 1770 unsigned int data_shndx, 1771 Output_section* output_section, 1772 const elfcpp::Rel<32, false>& reloc, 1773 unsigned int r_type, 1774 const elfcpp::Sym<32, false>& lsym, 1775 bool is_discarded) 1776 { 1777 if (is_discarded) 1778 return; 1779 1780 // A local STT_GNU_IFUNC symbol may require a PLT entry. 1781 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC 1782 && this->reloc_needs_plt_for_ifunc(object, r_type)) 1783 { 1784 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1785 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym); 1786 } 1787 1788 switch (r_type) 1789 { 1790 case elfcpp::R_386_NONE: 1791 case elfcpp::R_386_GNU_VTINHERIT: 1792 case elfcpp::R_386_GNU_VTENTRY: 1793 break; 1794 1795 case elfcpp::R_386_32: 1796 // If building a shared library (or a position-independent 1797 // executable), we need to create a dynamic relocation for 1798 // this location. The relocation applied at link time will 1799 // apply the link-time value, so we flag the location with 1800 // an R_386_RELATIVE relocation so the dynamic loader can 1801 // relocate it easily. 1802 if (parameters->options().output_is_position_independent()) 1803 { 1804 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 1805 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1806 rel_dyn->add_local_relative(object, r_sym, elfcpp::R_386_RELATIVE, 1807 output_section, data_shndx, 1808 reloc.get_r_offset()); 1809 } 1810 break; 1811 1812 case elfcpp::R_386_16: 1813 case elfcpp::R_386_8: 1814 // If building a shared library (or a position-independent 1815 // executable), we need to create a dynamic relocation for 1816 // this location. Because the addend needs to remain in the 1817 // data section, we need to be careful not to apply this 1818 // relocation statically. 1819 if (parameters->options().output_is_position_independent()) 1820 { 1821 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 1822 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1823 if (lsym.get_st_type() != elfcpp::STT_SECTION) 1824 rel_dyn->add_local(object, r_sym, r_type, output_section, 1825 data_shndx, reloc.get_r_offset()); 1826 else 1827 { 1828 gold_assert(lsym.get_st_value() == 0); 1829 unsigned int shndx = lsym.get_st_shndx(); 1830 bool is_ordinary; 1831 shndx = object->adjust_sym_shndx(r_sym, shndx, 1832 &is_ordinary); 1833 if (!is_ordinary) 1834 object->error(_("section symbol %u has bad shndx %u"), 1835 r_sym, shndx); 1836 else 1837 rel_dyn->add_local_section(object, shndx, 1838 r_type, output_section, 1839 data_shndx, reloc.get_r_offset()); 1840 } 1841 } 1842 break; 1843 1844 case elfcpp::R_386_PC32: 1845 case elfcpp::R_386_PC16: 1846 case elfcpp::R_386_PC8: 1847 break; 1848 1849 case elfcpp::R_386_PLT32: 1850 // Since we know this is a local symbol, we can handle this as a 1851 // PC32 reloc. 1852 break; 1853 1854 case elfcpp::R_386_GOTOFF: 1855 case elfcpp::R_386_GOTPC: 1856 // We need a GOT section. 1857 target->got_section(symtab, layout); 1858 break; 1859 1860 case elfcpp::R_386_GOT32: 1861 case elfcpp::R_386_GOT32X: 1862 { 1863 // We need GOT section. 1864 Output_data_got<32, false>* got = target->got_section(symtab, layout); 1865 1866 // If the relocation symbol isn't IFUNC, 1867 // and is local, then we will convert 1868 // mov foo@GOT(%reg), %reg 1869 // to 1870 // lea foo@GOTOFF(%reg), %reg 1871 // in Relocate::relocate. 1872 if (reloc.get_r_offset() >= 2 1873 && lsym.get_st_type() != elfcpp::STT_GNU_IFUNC) 1874 { 1875 section_size_type stype; 1876 const unsigned char* view = object->section_contents(data_shndx, 1877 &stype, true); 1878 if (view[reloc.get_r_offset() - 2] == 0x8b) 1879 break; 1880 } 1881 1882 // Otherwise, the symbol requires a GOT entry. 1883 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1884 1885 // For a STT_GNU_IFUNC symbol we want the PLT offset. That 1886 // lets function pointers compare correctly with shared 1887 // libraries. Otherwise we would need an IRELATIVE reloc. 1888 bool is_new; 1889 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC) 1890 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD); 1891 else 1892 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD); 1893 if (is_new) 1894 { 1895 // If we are generating a shared object, we need to add a 1896 // dynamic RELATIVE relocation for this symbol's GOT entry. 1897 if (parameters->options().output_is_position_independent()) 1898 { 1899 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 1900 unsigned int got_offset = 1901 object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 1902 rel_dyn->add_local_relative(object, r_sym, 1903 elfcpp::R_386_RELATIVE, 1904 got, got_offset); 1905 } 1906 } 1907 } 1908 break; 1909 1910 // These are relocations which should only be seen by the 1911 // dynamic linker, and should never be seen here. 1912 case elfcpp::R_386_COPY: 1913 case elfcpp::R_386_GLOB_DAT: 1914 case elfcpp::R_386_JUMP_SLOT: 1915 case elfcpp::R_386_RELATIVE: 1916 case elfcpp::R_386_IRELATIVE: 1917 case elfcpp::R_386_TLS_TPOFF: 1918 case elfcpp::R_386_TLS_DTPMOD32: 1919 case elfcpp::R_386_TLS_DTPOFF32: 1920 case elfcpp::R_386_TLS_TPOFF32: 1921 case elfcpp::R_386_TLS_DESC: 1922 gold_error(_("%s: unexpected reloc %u in object file"), 1923 object->name().c_str(), r_type); 1924 break; 1925 1926 // These are initial TLS relocs, which are expected when 1927 // linking. 1928 case elfcpp::R_386_TLS_GD: // Global-dynamic 1929 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 1930 case elfcpp::R_386_TLS_DESC_CALL: 1931 case elfcpp::R_386_TLS_LDM: // Local-dynamic 1932 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 1933 case elfcpp::R_386_TLS_IE: // Initial-exec 1934 case elfcpp::R_386_TLS_IE_32: 1935 case elfcpp::R_386_TLS_GOTIE: 1936 case elfcpp::R_386_TLS_LE: // Local-exec 1937 case elfcpp::R_386_TLS_LE_32: 1938 { 1939 bool output_is_shared = parameters->options().shared(); 1940 const tls::Tls_optimization optimized_type 1941 = Target_i386::optimize_tls_reloc(!output_is_shared, r_type); 1942 switch (r_type) 1943 { 1944 case elfcpp::R_386_TLS_GD: // Global-dynamic 1945 if (optimized_type == tls::TLSOPT_NONE) 1946 { 1947 // Create a pair of GOT entries for the module index and 1948 // dtv-relative offset. 1949 Output_data_got<32, false>* got 1950 = target->got_section(symtab, layout); 1951 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1952 unsigned int shndx = lsym.get_st_shndx(); 1953 bool is_ordinary; 1954 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary); 1955 if (!is_ordinary) 1956 object->error(_("local symbol %u has bad shndx %u"), 1957 r_sym, shndx); 1958 else 1959 got->add_local_pair_with_rel(object, r_sym, shndx, 1960 GOT_TYPE_TLS_PAIR, 1961 target->rel_dyn_section(layout), 1962 elfcpp::R_386_TLS_DTPMOD32); 1963 } 1964 else if (optimized_type != tls::TLSOPT_TO_LE) 1965 unsupported_reloc_local(object, r_type); 1966 break; 1967 1968 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva) 1969 target->define_tls_base_symbol(symtab, layout); 1970 if (optimized_type == tls::TLSOPT_NONE) 1971 { 1972 // Create a double GOT entry with an R_386_TLS_DESC 1973 // reloc. The R_386_TLS_DESC reloc is resolved 1974 // lazily, so the GOT entry needs to be in an area in 1975 // .got.plt, not .got. Call got_section to make sure 1976 // the section has been created. 1977 target->got_section(symtab, layout); 1978 Output_data_got<32, false>* got = target->got_tlsdesc_section(); 1979 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1980 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC)) 1981 { 1982 unsigned int got_offset = got->add_constant(0); 1983 // The local symbol value is stored in the second 1984 // GOT entry. 1985 got->add_local(object, r_sym, GOT_TYPE_TLS_DESC); 1986 // That set the GOT offset of the local symbol to 1987 // point to the second entry, but we want it to 1988 // point to the first. 1989 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC, 1990 got_offset); 1991 Reloc_section* rt = target->rel_tls_desc_section(layout); 1992 rt->add_absolute(elfcpp::R_386_TLS_DESC, got, got_offset); 1993 } 1994 } 1995 else if (optimized_type != tls::TLSOPT_TO_LE) 1996 unsupported_reloc_local(object, r_type); 1997 break; 1998 1999 case elfcpp::R_386_TLS_DESC_CALL: 2000 break; 2001 2002 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2003 if (optimized_type == tls::TLSOPT_NONE) 2004 { 2005 // Create a GOT entry for the module index. 2006 target->got_mod_index_entry(symtab, layout, object); 2007 } 2008 else if (optimized_type != tls::TLSOPT_TO_LE) 2009 unsupported_reloc_local(object, r_type); 2010 break; 2011 2012 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2013 break; 2014 2015 case elfcpp::R_386_TLS_IE: // Initial-exec 2016 case elfcpp::R_386_TLS_IE_32: 2017 case elfcpp::R_386_TLS_GOTIE: 2018 layout->set_has_static_tls(); 2019 if (optimized_type == tls::TLSOPT_NONE) 2020 { 2021 // For the R_386_TLS_IE relocation, we need to create a 2022 // dynamic relocation when building a shared library. 2023 if (r_type == elfcpp::R_386_TLS_IE 2024 && parameters->options().shared()) 2025 { 2026 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2027 unsigned int r_sym 2028 = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2029 rel_dyn->add_local_relative(object, r_sym, 2030 elfcpp::R_386_RELATIVE, 2031 output_section, data_shndx, 2032 reloc.get_r_offset()); 2033 } 2034 // Create a GOT entry for the tp-relative offset. 2035 Output_data_got<32, false>* got 2036 = target->got_section(symtab, layout); 2037 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2038 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32 2039 ? elfcpp::R_386_TLS_TPOFF32 2040 : elfcpp::R_386_TLS_TPOFF); 2041 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32 2042 ? GOT_TYPE_TLS_OFFSET 2043 : GOT_TYPE_TLS_NOFFSET); 2044 got->add_local_with_rel(object, r_sym, got_type, 2045 target->rel_dyn_section(layout), 2046 dyn_r_type); 2047 } 2048 else if (optimized_type != tls::TLSOPT_TO_LE) 2049 unsupported_reloc_local(object, r_type); 2050 break; 2051 2052 case elfcpp::R_386_TLS_LE: // Local-exec 2053 case elfcpp::R_386_TLS_LE_32: 2054 layout->set_has_static_tls(); 2055 if (output_is_shared) 2056 { 2057 // We need to create a dynamic relocation. 2058 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION); 2059 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2060 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32 2061 ? elfcpp::R_386_TLS_TPOFF32 2062 : elfcpp::R_386_TLS_TPOFF); 2063 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2064 rel_dyn->add_local(object, r_sym, dyn_r_type, output_section, 2065 data_shndx, reloc.get_r_offset()); 2066 } 2067 break; 2068 2069 default: 2070 gold_unreachable(); 2071 } 2072 } 2073 break; 2074 2075 case elfcpp::R_386_32PLT: 2076 case elfcpp::R_386_TLS_GD_32: 2077 case elfcpp::R_386_TLS_GD_PUSH: 2078 case elfcpp::R_386_TLS_GD_CALL: 2079 case elfcpp::R_386_TLS_GD_POP: 2080 case elfcpp::R_386_TLS_LDM_32: 2081 case elfcpp::R_386_TLS_LDM_PUSH: 2082 case elfcpp::R_386_TLS_LDM_CALL: 2083 case elfcpp::R_386_TLS_LDM_POP: 2084 case elfcpp::R_386_USED_BY_INTEL_200: 2085 default: 2086 unsupported_reloc_local(object, r_type); 2087 break; 2088 } 2089 } 2090 2091 // Report an unsupported relocation against a global symbol. 2092 2093 void 2094 Target_i386::Scan::unsupported_reloc_global( 2095 Sized_relobj_file<32, false>* object, 2096 unsigned int r_type, 2097 Symbol* gsym) 2098 { 2099 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 2100 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 2101 } 2102 2103 inline bool 2104 Target_i386::Scan::possible_function_pointer_reloc(unsigned int r_type) 2105 { 2106 switch (r_type) 2107 { 2108 case elfcpp::R_386_32: 2109 case elfcpp::R_386_16: 2110 case elfcpp::R_386_8: 2111 case elfcpp::R_386_GOTOFF: 2112 case elfcpp::R_386_GOT32: 2113 case elfcpp::R_386_GOT32X: 2114 { 2115 return true; 2116 } 2117 default: 2118 return false; 2119 } 2120 return false; 2121 } 2122 2123 inline bool 2124 Target_i386::Scan::local_reloc_may_be_function_pointer( 2125 Symbol_table* , 2126 Layout* , 2127 Target_i386* , 2128 Sized_relobj_file<32, false>* , 2129 unsigned int , 2130 Output_section* , 2131 const elfcpp::Rel<32, false>& , 2132 unsigned int r_type, 2133 const elfcpp::Sym<32, false>&) 2134 { 2135 return possible_function_pointer_reloc(r_type); 2136 } 2137 2138 inline bool 2139 Target_i386::Scan::global_reloc_may_be_function_pointer( 2140 Symbol_table* , 2141 Layout* , 2142 Target_i386* , 2143 Sized_relobj_file<32, false>* , 2144 unsigned int , 2145 Output_section* , 2146 const elfcpp::Rel<32, false>& , 2147 unsigned int r_type, 2148 Symbol*) 2149 { 2150 return possible_function_pointer_reloc(r_type); 2151 } 2152 2153 // Scan a relocation for a global symbol. 2154 2155 inline void 2156 Target_i386::Scan::global(Symbol_table* symtab, 2157 Layout* layout, 2158 Target_i386* target, 2159 Sized_relobj_file<32, false>* object, 2160 unsigned int data_shndx, 2161 Output_section* output_section, 2162 const elfcpp::Rel<32, false>& reloc, 2163 unsigned int r_type, 2164 Symbol* gsym) 2165 { 2166 // A STT_GNU_IFUNC symbol may require a PLT entry. 2167 if (gsym->type() == elfcpp::STT_GNU_IFUNC 2168 && this->reloc_needs_plt_for_ifunc(object, r_type)) 2169 target->make_plt_entry(symtab, layout, gsym); 2170 2171 switch (r_type) 2172 { 2173 case elfcpp::R_386_NONE: 2174 case elfcpp::R_386_GNU_VTINHERIT: 2175 case elfcpp::R_386_GNU_VTENTRY: 2176 break; 2177 2178 case elfcpp::R_386_32: 2179 case elfcpp::R_386_16: 2180 case elfcpp::R_386_8: 2181 { 2182 // Make a PLT entry if necessary. 2183 if (gsym->needs_plt_entry()) 2184 { 2185 target->make_plt_entry(symtab, layout, gsym); 2186 // Since this is not a PC-relative relocation, we may be 2187 // taking the address of a function. In that case we need to 2188 // set the entry in the dynamic symbol table to the address of 2189 // the PLT entry. 2190 if (gsym->is_from_dynobj() && !parameters->options().shared()) 2191 gsym->set_needs_dynsym_value(); 2192 } 2193 // Make a dynamic relocation if necessary. 2194 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 2195 { 2196 if (!parameters->options().output_is_position_independent() 2197 && gsym->may_need_copy_reloc()) 2198 { 2199 target->copy_reloc(symtab, layout, object, 2200 data_shndx, output_section, gsym, reloc); 2201 } 2202 else if (r_type == elfcpp::R_386_32 2203 && gsym->type() == elfcpp::STT_GNU_IFUNC 2204 && gsym->can_use_relative_reloc(false) 2205 && !gsym->is_from_dynobj() 2206 && !gsym->is_undefined() 2207 && !gsym->is_preemptible()) 2208 { 2209 // Use an IRELATIVE reloc for a locally defined 2210 // STT_GNU_IFUNC symbol. This makes a function 2211 // address in a PIE executable match the address in a 2212 // shared library that it links against. 2213 Reloc_section* rel_dyn = target->rel_irelative_section(layout); 2214 rel_dyn->add_symbolless_global_addend(gsym, 2215 elfcpp::R_386_IRELATIVE, 2216 output_section, 2217 object, data_shndx, 2218 reloc.get_r_offset()); 2219 } 2220 else if (r_type == elfcpp::R_386_32 2221 && gsym->can_use_relative_reloc(false)) 2222 { 2223 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2224 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE, 2225 output_section, object, 2226 data_shndx, reloc.get_r_offset()); 2227 } 2228 else 2229 { 2230 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2231 rel_dyn->add_global(gsym, r_type, output_section, object, 2232 data_shndx, reloc.get_r_offset()); 2233 } 2234 } 2235 } 2236 break; 2237 2238 case elfcpp::R_386_PC32: 2239 case elfcpp::R_386_PC16: 2240 case elfcpp::R_386_PC8: 2241 { 2242 // Make a PLT entry if necessary. 2243 if (gsym->needs_plt_entry()) 2244 { 2245 // These relocations are used for function calls only in 2246 // non-PIC code. For a 32-bit relocation in a shared library, 2247 // we'll need a text relocation anyway, so we can skip the 2248 // PLT entry and let the dynamic linker bind the call directly 2249 // to the target. For smaller relocations, we should use a 2250 // PLT entry to ensure that the call can reach. 2251 if (!parameters->options().shared() 2252 || r_type != elfcpp::R_386_PC32) 2253 target->make_plt_entry(symtab, layout, gsym); 2254 } 2255 // Make a dynamic relocation if necessary. 2256 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 2257 { 2258 if (parameters->options().output_is_executable() 2259 && gsym->may_need_copy_reloc()) 2260 { 2261 target->copy_reloc(symtab, layout, object, 2262 data_shndx, output_section, gsym, reloc); 2263 } 2264 else 2265 { 2266 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2267 rel_dyn->add_global(gsym, r_type, output_section, object, 2268 data_shndx, reloc.get_r_offset()); 2269 } 2270 } 2271 } 2272 break; 2273 2274 case elfcpp::R_386_GOT32: 2275 case elfcpp::R_386_GOT32X: 2276 { 2277 // The symbol requires a GOT section. 2278 Output_data_got<32, false>* got = target->got_section(symtab, layout); 2279 2280 // If we convert this from 2281 // mov foo@GOT(%reg), %reg 2282 // to 2283 // lea foo@GOTOFF(%reg), %reg 2284 // in Relocate::relocate, then there is nothing to do here. 2285 if (reloc.get_r_offset() >= 2 2286 && Target_i386::can_convert_mov_to_lea(gsym)) 2287 { 2288 section_size_type stype; 2289 const unsigned char* view = object->section_contents(data_shndx, 2290 &stype, true); 2291 if (view[reloc.get_r_offset() - 2] == 0x8b) 2292 break; 2293 } 2294 2295 if (gsym->final_value_is_known()) 2296 { 2297 // For a STT_GNU_IFUNC symbol we want the PLT address. 2298 if (gsym->type() == elfcpp::STT_GNU_IFUNC) 2299 got->add_global_plt(gsym, GOT_TYPE_STANDARD); 2300 else 2301 got->add_global(gsym, GOT_TYPE_STANDARD); 2302 } 2303 else 2304 { 2305 // If this symbol is not fully resolved, we need to add a 2306 // GOT entry with a dynamic relocation. 2307 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2308 2309 // Use a GLOB_DAT rather than a RELATIVE reloc if: 2310 // 2311 // 1) The symbol may be defined in some other module. 2312 // 2313 // 2) We are building a shared library and this is a 2314 // protected symbol; using GLOB_DAT means that the dynamic 2315 // linker can use the address of the PLT in the main 2316 // executable when appropriate so that function address 2317 // comparisons work. 2318 // 2319 // 3) This is a STT_GNU_IFUNC symbol in position dependent 2320 // code, again so that function address comparisons work. 2321 if (gsym->is_from_dynobj() 2322 || gsym->is_undefined() 2323 || gsym->is_preemptible() 2324 || (gsym->visibility() == elfcpp::STV_PROTECTED 2325 && parameters->options().shared()) 2326 || (gsym->type() == elfcpp::STT_GNU_IFUNC 2327 && parameters->options().output_is_position_independent())) 2328 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, 2329 rel_dyn, elfcpp::R_386_GLOB_DAT); 2330 else 2331 { 2332 // For a STT_GNU_IFUNC symbol we want to write the PLT 2333 // offset into the GOT, so that function pointer 2334 // comparisons work correctly. 2335 bool is_new; 2336 if (gsym->type() != elfcpp::STT_GNU_IFUNC) 2337 is_new = got->add_global(gsym, GOT_TYPE_STANDARD); 2338 else 2339 { 2340 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD); 2341 // Tell the dynamic linker to use the PLT address 2342 // when resolving relocations. 2343 if (gsym->is_from_dynobj() 2344 && !parameters->options().shared()) 2345 gsym->set_needs_dynsym_value(); 2346 } 2347 if (is_new) 2348 { 2349 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD); 2350 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE, 2351 got, got_off); 2352 } 2353 } 2354 } 2355 } 2356 break; 2357 2358 case elfcpp::R_386_PLT32: 2359 // If the symbol is fully resolved, this is just a PC32 reloc. 2360 // Otherwise we need a PLT entry. 2361 if (gsym->final_value_is_known()) 2362 break; 2363 // If building a shared library, we can also skip the PLT entry 2364 // if the symbol is defined in the output file and is protected 2365 // or hidden. 2366 if (gsym->is_defined() 2367 && !gsym->is_from_dynobj() 2368 && !gsym->is_preemptible()) 2369 break; 2370 target->make_plt_entry(symtab, layout, gsym); 2371 break; 2372 2373 case elfcpp::R_386_GOTOFF: 2374 case elfcpp::R_386_GOTPC: 2375 // We need a GOT section. 2376 target->got_section(symtab, layout); 2377 break; 2378 2379 // These are relocations which should only be seen by the 2380 // dynamic linker, and should never be seen here. 2381 case elfcpp::R_386_COPY: 2382 case elfcpp::R_386_GLOB_DAT: 2383 case elfcpp::R_386_JUMP_SLOT: 2384 case elfcpp::R_386_RELATIVE: 2385 case elfcpp::R_386_IRELATIVE: 2386 case elfcpp::R_386_TLS_TPOFF: 2387 case elfcpp::R_386_TLS_DTPMOD32: 2388 case elfcpp::R_386_TLS_DTPOFF32: 2389 case elfcpp::R_386_TLS_TPOFF32: 2390 case elfcpp::R_386_TLS_DESC: 2391 gold_error(_("%s: unexpected reloc %u in object file"), 2392 object->name().c_str(), r_type); 2393 break; 2394 2395 // These are initial tls relocs, which are expected when 2396 // linking. 2397 case elfcpp::R_386_TLS_GD: // Global-dynamic 2398 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 2399 case elfcpp::R_386_TLS_DESC_CALL: 2400 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2401 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2402 case elfcpp::R_386_TLS_IE: // Initial-exec 2403 case elfcpp::R_386_TLS_IE_32: 2404 case elfcpp::R_386_TLS_GOTIE: 2405 case elfcpp::R_386_TLS_LE: // Local-exec 2406 case elfcpp::R_386_TLS_LE_32: 2407 { 2408 const bool is_final = gsym->final_value_is_known(); 2409 const tls::Tls_optimization optimized_type 2410 = Target_i386::optimize_tls_reloc(is_final, r_type); 2411 switch (r_type) 2412 { 2413 case elfcpp::R_386_TLS_GD: // Global-dynamic 2414 if (optimized_type == tls::TLSOPT_NONE) 2415 { 2416 // Create a pair of GOT entries for the module index and 2417 // dtv-relative offset. 2418 Output_data_got<32, false>* got 2419 = target->got_section(symtab, layout); 2420 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR, 2421 target->rel_dyn_section(layout), 2422 elfcpp::R_386_TLS_DTPMOD32, 2423 elfcpp::R_386_TLS_DTPOFF32); 2424 } 2425 else if (optimized_type == tls::TLSOPT_TO_IE) 2426 { 2427 // Create a GOT entry for the tp-relative offset. 2428 Output_data_got<32, false>* got 2429 = target->got_section(symtab, layout); 2430 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET, 2431 target->rel_dyn_section(layout), 2432 elfcpp::R_386_TLS_TPOFF); 2433 } 2434 else if (optimized_type != tls::TLSOPT_TO_LE) 2435 unsupported_reloc_global(object, r_type, gsym); 2436 break; 2437 2438 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (~oliva url) 2439 target->define_tls_base_symbol(symtab, layout); 2440 if (optimized_type == tls::TLSOPT_NONE) 2441 { 2442 // Create a double GOT entry with an R_386_TLS_DESC 2443 // reloc. The R_386_TLS_DESC reloc is resolved 2444 // lazily, so the GOT entry needs to be in an area in 2445 // .got.plt, not .got. Call got_section to make sure 2446 // the section has been created. 2447 target->got_section(symtab, layout); 2448 Output_data_got<32, false>* got = target->got_tlsdesc_section(); 2449 Reloc_section* rt = target->rel_tls_desc_section(layout); 2450 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt, 2451 elfcpp::R_386_TLS_DESC, 0); 2452 } 2453 else if (optimized_type == tls::TLSOPT_TO_IE) 2454 { 2455 // Create a GOT entry for the tp-relative offset. 2456 Output_data_got<32, false>* got 2457 = target->got_section(symtab, layout); 2458 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET, 2459 target->rel_dyn_section(layout), 2460 elfcpp::R_386_TLS_TPOFF); 2461 } 2462 else if (optimized_type != tls::TLSOPT_TO_LE) 2463 unsupported_reloc_global(object, r_type, gsym); 2464 break; 2465 2466 case elfcpp::R_386_TLS_DESC_CALL: 2467 break; 2468 2469 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2470 if (optimized_type == tls::TLSOPT_NONE) 2471 { 2472 // Create a GOT entry for the module index. 2473 target->got_mod_index_entry(symtab, layout, object); 2474 } 2475 else if (optimized_type != tls::TLSOPT_TO_LE) 2476 unsupported_reloc_global(object, r_type, gsym); 2477 break; 2478 2479 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2480 break; 2481 2482 case elfcpp::R_386_TLS_IE: // Initial-exec 2483 case elfcpp::R_386_TLS_IE_32: 2484 case elfcpp::R_386_TLS_GOTIE: 2485 layout->set_has_static_tls(); 2486 if (optimized_type == tls::TLSOPT_NONE) 2487 { 2488 // For the R_386_TLS_IE relocation, we need to create a 2489 // dynamic relocation when building a shared library. 2490 if (r_type == elfcpp::R_386_TLS_IE 2491 && parameters->options().shared()) 2492 { 2493 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2494 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE, 2495 output_section, object, 2496 data_shndx, 2497 reloc.get_r_offset()); 2498 } 2499 // Create a GOT entry for the tp-relative offset. 2500 Output_data_got<32, false>* got 2501 = target->got_section(symtab, layout); 2502 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32 2503 ? elfcpp::R_386_TLS_TPOFF32 2504 : elfcpp::R_386_TLS_TPOFF); 2505 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32 2506 ? GOT_TYPE_TLS_OFFSET 2507 : GOT_TYPE_TLS_NOFFSET); 2508 got->add_global_with_rel(gsym, got_type, 2509 target->rel_dyn_section(layout), 2510 dyn_r_type); 2511 } 2512 else if (optimized_type != tls::TLSOPT_TO_LE) 2513 unsupported_reloc_global(object, r_type, gsym); 2514 break; 2515 2516 case elfcpp::R_386_TLS_LE: // Local-exec 2517 case elfcpp::R_386_TLS_LE_32: 2518 layout->set_has_static_tls(); 2519 if (parameters->options().shared()) 2520 { 2521 // We need to create a dynamic relocation. 2522 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32 2523 ? elfcpp::R_386_TLS_TPOFF32 2524 : elfcpp::R_386_TLS_TPOFF); 2525 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2526 rel_dyn->add_global(gsym, dyn_r_type, output_section, object, 2527 data_shndx, reloc.get_r_offset()); 2528 } 2529 break; 2530 2531 default: 2532 gold_unreachable(); 2533 } 2534 } 2535 break; 2536 2537 case elfcpp::R_386_32PLT: 2538 case elfcpp::R_386_TLS_GD_32: 2539 case elfcpp::R_386_TLS_GD_PUSH: 2540 case elfcpp::R_386_TLS_GD_CALL: 2541 case elfcpp::R_386_TLS_GD_POP: 2542 case elfcpp::R_386_TLS_LDM_32: 2543 case elfcpp::R_386_TLS_LDM_PUSH: 2544 case elfcpp::R_386_TLS_LDM_CALL: 2545 case elfcpp::R_386_TLS_LDM_POP: 2546 case elfcpp::R_386_USED_BY_INTEL_200: 2547 default: 2548 unsupported_reloc_global(object, r_type, gsym); 2549 break; 2550 } 2551 } 2552 2553 // Process relocations for gc. 2554 2555 void 2556 Target_i386::gc_process_relocs(Symbol_table* symtab, 2557 Layout* layout, 2558 Sized_relobj_file<32, false>* object, 2559 unsigned int data_shndx, 2560 unsigned int, 2561 const unsigned char* prelocs, 2562 size_t reloc_count, 2563 Output_section* output_section, 2564 bool needs_special_offset_handling, 2565 size_t local_symbol_count, 2566 const unsigned char* plocal_symbols) 2567 { 2568 gold::gc_process_relocs<32, false, Target_i386, elfcpp::SHT_REL, 2569 Target_i386::Scan, 2570 Target_i386::Relocatable_size_for_reloc>( 2571 symtab, 2572 layout, 2573 this, 2574 object, 2575 data_shndx, 2576 prelocs, 2577 reloc_count, 2578 output_section, 2579 needs_special_offset_handling, 2580 local_symbol_count, 2581 plocal_symbols); 2582 } 2583 2584 // Scan relocations for a section. 2585 2586 void 2587 Target_i386::scan_relocs(Symbol_table* symtab, 2588 Layout* layout, 2589 Sized_relobj_file<32, false>* object, 2590 unsigned int data_shndx, 2591 unsigned int sh_type, 2592 const unsigned char* prelocs, 2593 size_t reloc_count, 2594 Output_section* output_section, 2595 bool needs_special_offset_handling, 2596 size_t local_symbol_count, 2597 const unsigned char* plocal_symbols) 2598 { 2599 if (sh_type == elfcpp::SHT_RELA) 2600 { 2601 gold_error(_("%s: unsupported RELA reloc section"), 2602 object->name().c_str()); 2603 return; 2604 } 2605 2606 gold::scan_relocs<32, false, Target_i386, elfcpp::SHT_REL, 2607 Target_i386::Scan>( 2608 symtab, 2609 layout, 2610 this, 2611 object, 2612 data_shndx, 2613 prelocs, 2614 reloc_count, 2615 output_section, 2616 needs_special_offset_handling, 2617 local_symbol_count, 2618 plocal_symbols); 2619 } 2620 2621 // Finalize the sections. 2622 2623 void 2624 Target_i386::do_finalize_sections( 2625 Layout* layout, 2626 const Input_objects*, 2627 Symbol_table* symtab) 2628 { 2629 const Reloc_section* rel_plt = (this->plt_ == NULL 2630 ? NULL 2631 : this->plt_->rel_plt()); 2632 layout->add_target_dynamic_tags(true, this->got_plt_, rel_plt, 2633 this->rel_dyn_, true, false); 2634 2635 // Emit any relocs we saved in an attempt to avoid generating COPY 2636 // relocs. 2637 if (this->copy_relocs_.any_saved_relocs()) 2638 this->copy_relocs_.emit(this->rel_dyn_section(layout)); 2639 2640 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of 2641 // the .got.plt section. 2642 Symbol* sym = this->global_offset_table_; 2643 if (sym != NULL) 2644 { 2645 uint32_t data_size = this->got_plt_->current_data_size(); 2646 symtab->get_sized_symbol<32>(sym)->set_symsize(data_size); 2647 } 2648 2649 if (parameters->doing_static_link() 2650 && (this->plt_ == NULL || !this->plt_->has_irelative_section())) 2651 { 2652 // If linking statically, make sure that the __rel_iplt symbols 2653 // were defined if necessary, even if we didn't create a PLT. 2654 static const Define_symbol_in_segment syms[] = 2655 { 2656 { 2657 "__rel_iplt_start", // name 2658 elfcpp::PT_LOAD, // segment_type 2659 elfcpp::PF_W, // segment_flags_set 2660 elfcpp::PF(0), // segment_flags_clear 2661 0, // value 2662 0, // size 2663 elfcpp::STT_NOTYPE, // type 2664 elfcpp::STB_GLOBAL, // binding 2665 elfcpp::STV_HIDDEN, // visibility 2666 0, // nonvis 2667 Symbol::SEGMENT_START, // offset_from_base 2668 true // only_if_ref 2669 }, 2670 { 2671 "__rel_iplt_end", // name 2672 elfcpp::PT_LOAD, // segment_type 2673 elfcpp::PF_W, // segment_flags_set 2674 elfcpp::PF(0), // segment_flags_clear 2675 0, // value 2676 0, // size 2677 elfcpp::STT_NOTYPE, // type 2678 elfcpp::STB_GLOBAL, // binding 2679 elfcpp::STV_HIDDEN, // visibility 2680 0, // nonvis 2681 Symbol::SEGMENT_START, // offset_from_base 2682 true // only_if_ref 2683 } 2684 }; 2685 2686 symtab->define_symbols(layout, 2, syms, 2687 layout->script_options()->saw_sections_clause()); 2688 } 2689 } 2690 2691 // Return whether a direct absolute static relocation needs to be applied. 2692 // In cases where Scan::local() or Scan::global() has created 2693 // a dynamic relocation other than R_386_RELATIVE, the addend 2694 // of the relocation is carried in the data, and we must not 2695 // apply the static relocation. 2696 2697 inline bool 2698 Target_i386::Relocate::should_apply_static_reloc(const Sized_symbol<32>* gsym, 2699 unsigned int r_type, 2700 bool is_32bit, 2701 Output_section* output_section) 2702 { 2703 // If the output section is not allocated, then we didn't call 2704 // scan_relocs, we didn't create a dynamic reloc, and we must apply 2705 // the reloc here. 2706 if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0) 2707 return true; 2708 2709 int ref_flags = Scan::get_reference_flags(r_type); 2710 2711 // For local symbols, we will have created a non-RELATIVE dynamic 2712 // relocation only if (a) the output is position independent, 2713 // (b) the relocation is absolute (not pc- or segment-relative), and 2714 // (c) the relocation is not 32 bits wide. 2715 if (gsym == NULL) 2716 return !(parameters->options().output_is_position_independent() 2717 && (ref_flags & Symbol::ABSOLUTE_REF) 2718 && !is_32bit); 2719 2720 // For global symbols, we use the same helper routines used in the 2721 // scan pass. If we did not create a dynamic relocation, or if we 2722 // created a RELATIVE dynamic relocation, we should apply the static 2723 // relocation. 2724 bool has_dyn = gsym->needs_dynamic_reloc(ref_flags); 2725 bool is_rel = (ref_flags & Symbol::ABSOLUTE_REF) 2726 && gsym->can_use_relative_reloc(ref_flags 2727 & Symbol::FUNCTION_CALL); 2728 return !has_dyn || is_rel; 2729 } 2730 2731 // Perform a relocation. 2732 2733 inline bool 2734 Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, 2735 Target_i386* target, 2736 Output_section* output_section, 2737 size_t relnum, 2738 const elfcpp::Rel<32, false>& rel, 2739 unsigned int r_type, 2740 const Sized_symbol<32>* gsym, 2741 const Symbol_value<32>* psymval, 2742 unsigned char* view, 2743 elfcpp::Elf_types<32>::Elf_Addr address, 2744 section_size_type view_size) 2745 { 2746 if (this->skip_call_tls_get_addr_) 2747 { 2748 if ((r_type != elfcpp::R_386_PLT32 2749 && r_type != elfcpp::R_386_PC32) 2750 || gsym == NULL 2751 || strcmp(gsym->name(), "___tls_get_addr") != 0) 2752 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2753 _("missing expected TLS relocation")); 2754 else 2755 { 2756 this->skip_call_tls_get_addr_ = false; 2757 return false; 2758 } 2759 } 2760 2761 if (view == NULL) 2762 return true; 2763 2764 const Sized_relobj_file<32, false>* object = relinfo->object; 2765 2766 // Pick the value to use for symbols defined in shared objects. 2767 Symbol_value<32> symval; 2768 if (gsym != NULL 2769 && gsym->type() == elfcpp::STT_GNU_IFUNC 2770 && r_type == elfcpp::R_386_32 2771 && gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)) 2772 && gsym->can_use_relative_reloc(false) 2773 && !gsym->is_from_dynobj() 2774 && !gsym->is_undefined() 2775 && !gsym->is_preemptible()) 2776 { 2777 // In this case we are generating a R_386_IRELATIVE reloc. We 2778 // want to use the real value of the symbol, not the PLT offset. 2779 } 2780 else if (gsym != NULL 2781 && gsym->use_plt_offset(Scan::get_reference_flags(r_type))) 2782 { 2783 symval.set_output_value(target->plt_address_for_global(gsym)); 2784 psymval = &symval; 2785 } 2786 else if (gsym == NULL && psymval->is_ifunc_symbol()) 2787 { 2788 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 2789 if (object->local_has_plt_offset(r_sym)) 2790 { 2791 symval.set_output_value(target->plt_address_for_local(object, r_sym)); 2792 psymval = &symval; 2793 } 2794 } 2795 2796 bool baseless; 2797 2798 switch (r_type) 2799 { 2800 case elfcpp::R_386_NONE: 2801 case elfcpp::R_386_GNU_VTINHERIT: 2802 case elfcpp::R_386_GNU_VTENTRY: 2803 break; 2804 2805 case elfcpp::R_386_32: 2806 if (should_apply_static_reloc(gsym, r_type, true, output_section)) 2807 Relocate_functions<32, false>::rel32(view, object, psymval); 2808 break; 2809 2810 case elfcpp::R_386_PC32: 2811 if (should_apply_static_reloc(gsym, r_type, true, output_section)) 2812 Relocate_functions<32, false>::pcrel32(view, object, psymval, address); 2813 break; 2814 2815 case elfcpp::R_386_16: 2816 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2817 Relocate_functions<32, false>::rel16(view, object, psymval); 2818 break; 2819 2820 case elfcpp::R_386_PC16: 2821 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2822 Relocate_functions<32, false>::pcrel16(view, object, psymval, address); 2823 break; 2824 2825 case elfcpp::R_386_8: 2826 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2827 Relocate_functions<32, false>::rel8(view, object, psymval); 2828 break; 2829 2830 case elfcpp::R_386_PC8: 2831 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2832 Relocate_functions<32, false>::pcrel8(view, object, psymval, address); 2833 break; 2834 2835 case elfcpp::R_386_PLT32: 2836 gold_assert(gsym == NULL 2837 || gsym->has_plt_offset() 2838 || gsym->final_value_is_known() 2839 || (gsym->is_defined() 2840 && !gsym->is_from_dynobj() 2841 && !gsym->is_preemptible())); 2842 Relocate_functions<32, false>::pcrel32(view, object, psymval, address); 2843 break; 2844 2845 case elfcpp::R_386_GOT32: 2846 case elfcpp::R_386_GOT32X: 2847 baseless = (view[-1] & 0xc7) == 0x5; 2848 // R_386_GOT32 and R_386_GOT32X don't work without base register 2849 // when generating a position-independent output file. 2850 if (baseless 2851 && parameters->options().output_is_position_independent()) 2852 { 2853 if(gsym) 2854 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2855 _("unexpected reloc %u against global symbol %s without base register in object file when generating a position-independent output file"), 2856 r_type, gsym->demangled_name().c_str()); 2857 else 2858 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2859 _("unexpected reloc %u against local symbol without base register in object file when generating a position-independent output file"), 2860 r_type); 2861 } 2862 2863 // Convert 2864 // mov foo@GOT(%reg), %reg 2865 // to 2866 // lea foo@GOTOFF(%reg), %reg 2867 // if possible. 2868 if (rel.get_r_offset() >= 2 2869 && view[-2] == 0x8b 2870 && ((gsym == NULL && !psymval->is_ifunc_symbol()) 2871 || (gsym != NULL 2872 && Target_i386::can_convert_mov_to_lea(gsym)))) 2873 { 2874 view[-2] = 0x8d; 2875 elfcpp::Elf_types<32>::Elf_Addr value; 2876 value = psymval->value(object, 0); 2877 // Don't subtract the .got.plt section address for baseless 2878 // addressing. 2879 if (!baseless) 2880 value -= target->got_plt_section()->address(); 2881 Relocate_functions<32, false>::rel32(view, value); 2882 } 2883 else 2884 { 2885 // The GOT pointer points to the end of the GOT section. 2886 // We need to subtract the size of the GOT section to get 2887 // the actual offset to use in the relocation. 2888 unsigned int got_offset = 0; 2889 if (gsym != NULL) 2890 { 2891 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 2892 got_offset = (gsym->got_offset(GOT_TYPE_STANDARD) 2893 - target->got_size()); 2894 } 2895 else 2896 { 2897 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 2898 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 2899 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD) 2900 - target->got_size()); 2901 } 2902 // Add the .got.plt section address for baseless addressing. 2903 if (baseless) 2904 got_offset += target->got_plt_section()->address(); 2905 Relocate_functions<32, false>::rel32(view, got_offset); 2906 } 2907 break; 2908 2909 case elfcpp::R_386_GOTOFF: 2910 { 2911 elfcpp::Elf_types<32>::Elf_Addr value; 2912 value = (psymval->value(object, 0) 2913 - target->got_plt_section()->address()); 2914 Relocate_functions<32, false>::rel32(view, value); 2915 } 2916 break; 2917 2918 case elfcpp::R_386_GOTPC: 2919 { 2920 elfcpp::Elf_types<32>::Elf_Addr value; 2921 value = target->got_plt_section()->address(); 2922 Relocate_functions<32, false>::pcrel32(view, value, address); 2923 } 2924 break; 2925 2926 case elfcpp::R_386_COPY: 2927 case elfcpp::R_386_GLOB_DAT: 2928 case elfcpp::R_386_JUMP_SLOT: 2929 case elfcpp::R_386_RELATIVE: 2930 case elfcpp::R_386_IRELATIVE: 2931 // These are outstanding tls relocs, which are unexpected when 2932 // linking. 2933 case elfcpp::R_386_TLS_TPOFF: 2934 case elfcpp::R_386_TLS_DTPMOD32: 2935 case elfcpp::R_386_TLS_DTPOFF32: 2936 case elfcpp::R_386_TLS_TPOFF32: 2937 case elfcpp::R_386_TLS_DESC: 2938 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2939 _("unexpected reloc %u in object file"), 2940 r_type); 2941 break; 2942 2943 // These are initial tls relocs, which are expected when 2944 // linking. 2945 case elfcpp::R_386_TLS_GD: // Global-dynamic 2946 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 2947 case elfcpp::R_386_TLS_DESC_CALL: 2948 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2949 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2950 case elfcpp::R_386_TLS_IE: // Initial-exec 2951 case elfcpp::R_386_TLS_IE_32: 2952 case elfcpp::R_386_TLS_GOTIE: 2953 case elfcpp::R_386_TLS_LE: // Local-exec 2954 case elfcpp::R_386_TLS_LE_32: 2955 this->relocate_tls(relinfo, target, relnum, rel, r_type, gsym, psymval, 2956 view, address, view_size); 2957 break; 2958 2959 case elfcpp::R_386_32PLT: 2960 case elfcpp::R_386_TLS_GD_32: 2961 case elfcpp::R_386_TLS_GD_PUSH: 2962 case elfcpp::R_386_TLS_GD_CALL: 2963 case elfcpp::R_386_TLS_GD_POP: 2964 case elfcpp::R_386_TLS_LDM_32: 2965 case elfcpp::R_386_TLS_LDM_PUSH: 2966 case elfcpp::R_386_TLS_LDM_CALL: 2967 case elfcpp::R_386_TLS_LDM_POP: 2968 case elfcpp::R_386_USED_BY_INTEL_200: 2969 default: 2970 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2971 _("unsupported reloc %u"), 2972 r_type); 2973 break; 2974 } 2975 2976 return true; 2977 } 2978 2979 // Perform a TLS relocation. 2980 2981 inline void 2982 Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo, 2983 Target_i386* target, 2984 size_t relnum, 2985 const elfcpp::Rel<32, false>& rel, 2986 unsigned int r_type, 2987 const Sized_symbol<32>* gsym, 2988 const Symbol_value<32>* psymval, 2989 unsigned char* view, 2990 elfcpp::Elf_types<32>::Elf_Addr, 2991 section_size_type view_size) 2992 { 2993 Output_segment* tls_segment = relinfo->layout->tls_segment(); 2994 2995 const Sized_relobj_file<32, false>* object = relinfo->object; 2996 2997 elfcpp::Elf_types<32>::Elf_Addr value = psymval->value(object, 0); 2998 2999 const bool is_final = (gsym == NULL 3000 ? !parameters->options().shared() 3001 : gsym->final_value_is_known()); 3002 const tls::Tls_optimization optimized_type 3003 = Target_i386::optimize_tls_reloc(is_final, r_type); 3004 switch (r_type) 3005 { 3006 case elfcpp::R_386_TLS_GD: // Global-dynamic 3007 if (optimized_type == tls::TLSOPT_TO_LE) 3008 { 3009 if (tls_segment == NULL) 3010 { 3011 gold_assert(parameters->errors()->error_count() > 0 3012 || issue_undefined_symbol_error(gsym)); 3013 return; 3014 } 3015 this->tls_gd_to_le(relinfo, relnum, tls_segment, 3016 rel, r_type, value, view, 3017 view_size); 3018 break; 3019 } 3020 else 3021 { 3022 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE 3023 ? GOT_TYPE_TLS_NOFFSET 3024 : GOT_TYPE_TLS_PAIR); 3025 unsigned int got_offset; 3026 if (gsym != NULL) 3027 { 3028 gold_assert(gsym->has_got_offset(got_type)); 3029 got_offset = gsym->got_offset(got_type) - target->got_size(); 3030 } 3031 else 3032 { 3033 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 3034 gold_assert(object->local_has_got_offset(r_sym, got_type)); 3035 got_offset = (object->local_got_offset(r_sym, got_type) 3036 - target->got_size()); 3037 } 3038 if (optimized_type == tls::TLSOPT_TO_IE) 3039 { 3040 this->tls_gd_to_ie(relinfo, relnum, tls_segment, rel, r_type, 3041 got_offset, view, view_size); 3042 break; 3043 } 3044 else if (optimized_type == tls::TLSOPT_NONE) 3045 { 3046 // Relocate the field with the offset of the pair of GOT 3047 // entries. 3048 Relocate_functions<32, false>::rel32(view, got_offset); 3049 break; 3050 } 3051 } 3052 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 3053 _("unsupported reloc %u"), 3054 r_type); 3055 break; 3056 3057 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 3058 case elfcpp::R_386_TLS_DESC_CALL: 3059 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU; 3060 if (optimized_type == tls::TLSOPT_TO_LE) 3061 { 3062 if (tls_segment == NULL) 3063 { 3064 gold_assert(parameters->errors()->error_count() > 0 3065 || issue_undefined_symbol_error(gsym)); 3066 return; 3067 } 3068 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment, 3069 rel, r_type, value, view, 3070 view_size); 3071 break; 3072 } 3073 else 3074 { 3075 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE 3076 ? GOT_TYPE_TLS_NOFFSET 3077 : GOT_TYPE_TLS_DESC); 3078 unsigned int got_offset = 0; 3079 if (r_type == elfcpp::R_386_TLS_GOTDESC 3080 && optimized_type == tls::TLSOPT_NONE) 3081 { 3082 // We created GOT entries in the .got.tlsdesc portion of 3083 // the .got.plt section, but the offset stored in the 3084 // symbol is the offset within .got.tlsdesc. 3085 got_offset = (target->got_size() 3086 + target->got_plt_section()->data_size()); 3087 } 3088 if (gsym != NULL) 3089 { 3090 gold_assert(gsym->has_got_offset(got_type)); 3091 got_offset += gsym->got_offset(got_type) - target->got_size(); 3092 } 3093 else 3094 { 3095 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 3096 gold_assert(object->local_has_got_offset(r_sym, got_type)); 3097 got_offset += (object->local_got_offset(r_sym, got_type) 3098 - target->got_size()); 3099 } 3100 if (optimized_type == tls::TLSOPT_TO_IE) 3101 { 3102 if (tls_segment == NULL) 3103 { 3104 gold_assert(parameters->errors()->error_count() > 0 3105 || issue_undefined_symbol_error(gsym)); 3106 return; 3107 } 3108 this->tls_desc_gd_to_ie(relinfo, relnum, tls_segment, rel, r_type, 3109 got_offset, view, view_size); 3110 break; 3111 } 3112 else if (optimized_type == tls::TLSOPT_NONE) 3113 { 3114 if (r_type == elfcpp::R_386_TLS_GOTDESC) 3115 { 3116 // Relocate the field with the offset of the pair of GOT 3117 // entries. 3118 Relocate_functions<32, false>::rel32(view, got_offset); 3119 } 3120 break; 3121 } 3122 } 3123 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 3124 _("unsupported reloc %u"), 3125 r_type); 3126 break; 3127 3128 case elfcpp::R_386_TLS_LDM: // Local-dynamic 3129 if (this->local_dynamic_type_ == LOCAL_DYNAMIC_SUN) 3130 { 3131 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 3132 _("both SUN and GNU model " 3133 "TLS relocations")); 3134 break; 3135 } 3136 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU; 3137 if (optimized_type == tls::TLSOPT_TO_LE) 3138 { 3139 if (tls_segment == NULL) 3140 { 3141 gold_assert(parameters->errors()->error_count() > 0 3142 || issue_undefined_symbol_error(gsym)); 3143 return; 3144 } 3145 this->tls_ld_to_le(relinfo, relnum, tls_segment, rel, r_type, 3146 value, view, view_size); 3147 break; 3148 } 3149 else if (optimized_type == tls::TLSOPT_NONE) 3150 { 3151 // Relocate the field with the offset of the GOT entry for 3152 // the module index. 3153 unsigned int got_offset; 3154 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL) 3155 - target->got_size()); 3156 Relocate_functions<32, false>::rel32(view, got_offset); 3157 break; 3158 } 3159 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 3160 _("unsupported reloc %u"), 3161 r_type); 3162 break; 3163 3164 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 3165 if (optimized_type == tls::TLSOPT_TO_LE) 3166 { 3167 // This reloc can appear in debugging sections, in which 3168 // case we must not convert to local-exec. We decide what 3169 // to do based on whether the section is marked as 3170 // containing executable code. That is what the GNU linker 3171 // does as well. 3172 elfcpp::Shdr<32, false> shdr(relinfo->data_shdr); 3173 if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0) 3174 { 3175 if (tls_segment == NULL) 3176 { 3177 gold_assert(parameters->errors()->error_count() > 0 3178 || issue_undefined_symbol_error(gsym)); 3179 return; 3180 } 3181 value -= tls_segment->memsz(); 3182 } 3183 } 3184 Relocate_functions<32, false>::rel32(view, value); 3185 break; 3186 3187 case elfcpp::R_386_TLS_IE: // Initial-exec 3188 case elfcpp::R_386_TLS_GOTIE: 3189 case elfcpp::R_386_TLS_IE_32: 3190 if (optimized_type == tls::TLSOPT_TO_LE) 3191 { 3192 if (tls_segment == NULL) 3193 { 3194 gold_assert(parameters->errors()->error_count() > 0 3195 || issue_undefined_symbol_error(gsym)); 3196 return; 3197 } 3198 Target_i386::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment, 3199 rel, r_type, value, view, 3200 view_size); 3201 break; 3202 } 3203 else if (optimized_type == tls::TLSOPT_NONE) 3204 { 3205 // Relocate the field with the offset of the GOT entry for 3206 // the tp-relative offset of the symbol. 3207 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32 3208 ? GOT_TYPE_TLS_OFFSET 3209 : GOT_TYPE_TLS_NOFFSET); 3210 unsigned int got_offset; 3211 if (gsym != NULL) 3212 { 3213 gold_assert(gsym->has_got_offset(got_type)); 3214 got_offset = gsym->got_offset(got_type); 3215 } 3216 else 3217 { 3218 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 3219 gold_assert(object->local_has_got_offset(r_sym, got_type)); 3220 got_offset = object->local_got_offset(r_sym, got_type); 3221 } 3222 // For the R_386_TLS_IE relocation, we need to apply the 3223 // absolute address of the GOT entry. 3224 if (r_type == elfcpp::R_386_TLS_IE) 3225 got_offset += target->got_plt_section()->address(); 3226 // All GOT offsets are relative to the end of the GOT. 3227 got_offset -= target->got_size(); 3228 Relocate_functions<32, false>::rel32(view, got_offset); 3229 break; 3230 } 3231 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 3232 _("unsupported reloc %u"), 3233 r_type); 3234 break; 3235 3236 case elfcpp::R_386_TLS_LE: // Local-exec 3237 // If we're creating a shared library, a dynamic relocation will 3238 // have been created for this location, so do not apply it now. 3239 if (!parameters->options().shared()) 3240 { 3241 if (tls_segment == NULL) 3242 { 3243 gold_assert(parameters->errors()->error_count() > 0 3244 || issue_undefined_symbol_error(gsym)); 3245 return; 3246 } 3247 value -= tls_segment->memsz(); 3248 Relocate_functions<32, false>::rel32(view, value); 3249 } 3250 break; 3251 3252 case elfcpp::R_386_TLS_LE_32: 3253 // If we're creating a shared library, a dynamic relocation will 3254 // have been created for this location, so do not apply it now. 3255 if (!parameters->options().shared()) 3256 { 3257 if (tls_segment == NULL) 3258 { 3259 gold_assert(parameters->errors()->error_count() > 0 3260 || issue_undefined_symbol_error(gsym)); 3261 return; 3262 } 3263 value = tls_segment->memsz() - value; 3264 Relocate_functions<32, false>::rel32(view, value); 3265 } 3266 break; 3267 } 3268 } 3269 3270 // Do a relocation in which we convert a TLS General-Dynamic to a 3271 // Local-Exec. 3272 3273 inline void 3274 Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo, 3275 size_t relnum, 3276 Output_segment* tls_segment, 3277 const elfcpp::Rel<32, false>& rel, 3278 unsigned int, 3279 elfcpp::Elf_types<32>::Elf_Addr value, 3280 unsigned char* view, 3281 section_size_type view_size) 3282 { 3283 // leal foo(,%reg,1),%eax; call ___tls_get_addr 3284 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax 3285 // leal foo(%reg),%eax; call ___tls_get_addr 3286 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax 3287 3288 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3289 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9); 3290 3291 unsigned char op1 = view[-1]; 3292 unsigned char op2 = view[-2]; 3293 3294 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3295 op2 == 0x8d || op2 == 0x04); 3296 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8); 3297 3298 int roff = 5; 3299 3300 if (op2 == 0x04) 3301 { 3302 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3); 3303 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d); 3304 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3305 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3))); 3306 memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12); 3307 } 3308 else 3309 { 3310 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3311 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4); 3312 if (rel.get_r_offset() + 9 < view_size 3313 && view[9] == 0x90) 3314 { 3315 // There is a trailing nop. Use the size byte subl. 3316 memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12); 3317 roff = 6; 3318 } 3319 else 3320 { 3321 // Use the five byte subl. 3322 memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11); 3323 } 3324 } 3325 3326 value = tls_segment->memsz() - value; 3327 Relocate_functions<32, false>::rel32(view + roff, value); 3328 3329 // The next reloc should be a PLT32 reloc against __tls_get_addr. 3330 // We can skip it. 3331 this->skip_call_tls_get_addr_ = true; 3332 } 3333 3334 // Do a relocation in which we convert a TLS General-Dynamic to an 3335 // Initial-Exec. 3336 3337 inline void 3338 Target_i386::Relocate::tls_gd_to_ie(const Relocate_info<32, false>* relinfo, 3339 size_t relnum, 3340 Output_segment*, 3341 const elfcpp::Rel<32, false>& rel, 3342 unsigned int, 3343 elfcpp::Elf_types<32>::Elf_Addr value, 3344 unsigned char* view, 3345 section_size_type view_size) 3346 { 3347 // leal foo(,%ebx,1),%eax; call ___tls_get_addr 3348 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax 3349 // leal foo(%ebx),%eax; call ___tls_get_addr; nop 3350 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax 3351 3352 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3353 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9); 3354 3355 unsigned char op1 = view[-1]; 3356 unsigned char op2 = view[-2]; 3357 3358 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3359 op2 == 0x8d || op2 == 0x04); 3360 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8); 3361 3362 int roff; 3363 3364 if (op2 == 0x04) 3365 { 3366 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3); 3367 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d); 3368 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3369 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3))); 3370 roff = 5; 3371 } 3372 else 3373 { 3374 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 10); 3375 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3376 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4); 3377 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[9] == 0x90); 3378 roff = 6; 3379 } 3380 3381 memcpy(view + roff - 8, "\x65\xa1\0\0\0\0\x03\x83\0\0\0", 12); 3382 Relocate_functions<32, false>::rel32(view + roff, value); 3383 3384 // The next reloc should be a PLT32 reloc against __tls_get_addr. 3385 // We can skip it. 3386 this->skip_call_tls_get_addr_ = true; 3387 } 3388 3389 // Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL 3390 // General-Dynamic to a Local-Exec. 3391 3392 inline void 3393 Target_i386::Relocate::tls_desc_gd_to_le( 3394 const Relocate_info<32, false>* relinfo, 3395 size_t relnum, 3396 Output_segment* tls_segment, 3397 const elfcpp::Rel<32, false>& rel, 3398 unsigned int r_type, 3399 elfcpp::Elf_types<32>::Elf_Addr value, 3400 unsigned char* view, 3401 section_size_type view_size) 3402 { 3403 if (r_type == elfcpp::R_386_TLS_GOTDESC) 3404 { 3405 // leal foo@TLSDESC(%ebx), %eax 3406 // ==> leal foo@NTPOFF, %eax 3407 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3408 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4); 3409 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3410 view[-2] == 0x8d && view[-1] == 0x83); 3411 view[-1] = 0x05; 3412 value -= tls_segment->memsz(); 3413 Relocate_functions<32, false>::rel32(view, value); 3414 } 3415 else 3416 { 3417 // call *foo@TLSCALL(%eax) 3418 // ==> nop; nop 3419 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL); 3420 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2); 3421 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3422 view[0] == 0xff && view[1] == 0x10); 3423 view[0] = 0x66; 3424 view[1] = 0x90; 3425 } 3426 } 3427 3428 // Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL 3429 // General-Dynamic to an Initial-Exec. 3430 3431 inline void 3432 Target_i386::Relocate::tls_desc_gd_to_ie( 3433 const Relocate_info<32, false>* relinfo, 3434 size_t relnum, 3435 Output_segment*, 3436 const elfcpp::Rel<32, false>& rel, 3437 unsigned int r_type, 3438 elfcpp::Elf_types<32>::Elf_Addr value, 3439 unsigned char* view, 3440 section_size_type view_size) 3441 { 3442 if (r_type == elfcpp::R_386_TLS_GOTDESC) 3443 { 3444 // leal foo@TLSDESC(%ebx), %eax 3445 // ==> movl foo@GOTNTPOFF(%ebx), %eax 3446 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3447 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4); 3448 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3449 view[-2] == 0x8d && view[-1] == 0x83); 3450 view[-2] = 0x8b; 3451 Relocate_functions<32, false>::rel32(view, value); 3452 } 3453 else 3454 { 3455 // call *foo@TLSCALL(%eax) 3456 // ==> nop; nop 3457 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL); 3458 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2); 3459 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3460 view[0] == 0xff && view[1] == 0x10); 3461 view[0] = 0x66; 3462 view[1] = 0x90; 3463 } 3464 } 3465 3466 // Do a relocation in which we convert a TLS Local-Dynamic to a 3467 // Local-Exec. 3468 3469 inline void 3470 Target_i386::Relocate::tls_ld_to_le(const Relocate_info<32, false>* relinfo, 3471 size_t relnum, 3472 Output_segment*, 3473 const elfcpp::Rel<32, false>& rel, 3474 unsigned int, 3475 elfcpp::Elf_types<32>::Elf_Addr, 3476 unsigned char* view, 3477 section_size_type view_size) 3478 { 3479 // leal foo(%reg), %eax; call ___tls_get_addr 3480 // ==> movl %gs:0,%eax; nop; leal 0(%esi,1),%esi 3481 3482 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3483 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9); 3484 3485 // FIXME: Does this test really always pass? 3486 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3487 view[-2] == 0x8d && view[-1] == 0x83); 3488 3489 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8); 3490 3491 memcpy(view - 2, "\x65\xa1\0\0\0\0\x90\x8d\x74\x26\0", 11); 3492 3493 // The next reloc should be a PLT32 reloc against __tls_get_addr. 3494 // We can skip it. 3495 this->skip_call_tls_get_addr_ = true; 3496 } 3497 3498 // Do a relocation in which we convert a TLS Initial-Exec to a 3499 // Local-Exec. 3500 3501 inline void 3502 Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo, 3503 size_t relnum, 3504 Output_segment* tls_segment, 3505 const elfcpp::Rel<32, false>& rel, 3506 unsigned int r_type, 3507 elfcpp::Elf_types<32>::Elf_Addr value, 3508 unsigned char* view, 3509 section_size_type view_size) 3510 { 3511 // We have to actually change the instructions, which means that we 3512 // need to examine the opcodes to figure out which instruction we 3513 // are looking at. 3514 if (r_type == elfcpp::R_386_TLS_IE) 3515 { 3516 // movl %gs:XX,%eax ==> movl $YY,%eax 3517 // movl %gs:XX,%reg ==> movl $YY,%reg 3518 // addl %gs:XX,%reg ==> addl $YY,%reg 3519 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -1); 3520 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4); 3521 3522 unsigned char op1 = view[-1]; 3523 if (op1 == 0xa1) 3524 { 3525 // movl XX,%eax ==> movl $YY,%eax 3526 view[-1] = 0xb8; 3527 } 3528 else 3529 { 3530 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3531 3532 unsigned char op2 = view[-2]; 3533 if (op2 == 0x8b) 3534 { 3535 // movl XX,%reg ==> movl $YY,%reg 3536 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3537 (op1 & 0xc7) == 0x05); 3538 view[-2] = 0xc7; 3539 view[-1] = 0xc0 | ((op1 >> 3) & 7); 3540 } 3541 else if (op2 == 0x03) 3542 { 3543 // addl XX,%reg ==> addl $YY,%reg 3544 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3545 (op1 & 0xc7) == 0x05); 3546 view[-2] = 0x81; 3547 view[-1] = 0xc0 | ((op1 >> 3) & 7); 3548 } 3549 else 3550 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0); 3551 } 3552 } 3553 else 3554 { 3555 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2 3556 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2 3557 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2 3558 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2); 3559 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4); 3560 3561 unsigned char op1 = view[-1]; 3562 unsigned char op2 = view[-2]; 3563 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 3564 (op1 & 0xc0) == 0x80 && (op1 & 7) != 4); 3565 if (op2 == 0x8b) 3566 { 3567 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2 3568 view[-2] = 0xc7; 3569 view[-1] = 0xc0 | ((op1 >> 3) & 7); 3570 } 3571 else if (op2 == 0x2b) 3572 { 3573 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2 3574 view[-2] = 0x81; 3575 view[-1] = 0xe8 | ((op1 >> 3) & 7); 3576 } 3577 else if (op2 == 0x03) 3578 { 3579 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2 3580 view[-2] = 0x81; 3581 view[-1] = 0xc0 | ((op1 >> 3) & 7); 3582 } 3583 else 3584 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0); 3585 } 3586 3587 value = tls_segment->memsz() - value; 3588 if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE) 3589 value = - value; 3590 3591 Relocate_functions<32, false>::rel32(view, value); 3592 } 3593 3594 // Relocate section data. 3595 3596 void 3597 Target_i386::relocate_section(const Relocate_info<32, false>* relinfo, 3598 unsigned int sh_type, 3599 const unsigned char* prelocs, 3600 size_t reloc_count, 3601 Output_section* output_section, 3602 bool needs_special_offset_handling, 3603 unsigned char* view, 3604 elfcpp::Elf_types<32>::Elf_Addr address, 3605 section_size_type view_size, 3606 const Reloc_symbol_changes* reloc_symbol_changes) 3607 { 3608 gold_assert(sh_type == elfcpp::SHT_REL); 3609 3610 gold::relocate_section<32, false, Target_i386, elfcpp::SHT_REL, 3611 Target_i386::Relocate, gold::Default_comdat_behavior>( 3612 relinfo, 3613 this, 3614 prelocs, 3615 reloc_count, 3616 output_section, 3617 needs_special_offset_handling, 3618 view, 3619 address, 3620 view_size, 3621 reloc_symbol_changes); 3622 } 3623 3624 // Return the size of a relocation while scanning during a relocatable 3625 // link. 3626 3627 unsigned int 3628 Target_i386::Relocatable_size_for_reloc::get_size_for_reloc( 3629 unsigned int r_type, 3630 Relobj* object) 3631 { 3632 switch (r_type) 3633 { 3634 case elfcpp::R_386_NONE: 3635 case elfcpp::R_386_GNU_VTINHERIT: 3636 case elfcpp::R_386_GNU_VTENTRY: 3637 case elfcpp::R_386_TLS_GD: // Global-dynamic 3638 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 3639 case elfcpp::R_386_TLS_DESC_CALL: 3640 case elfcpp::R_386_TLS_LDM: // Local-dynamic 3641 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 3642 case elfcpp::R_386_TLS_IE: // Initial-exec 3643 case elfcpp::R_386_TLS_IE_32: 3644 case elfcpp::R_386_TLS_GOTIE: 3645 case elfcpp::R_386_TLS_LE: // Local-exec 3646 case elfcpp::R_386_TLS_LE_32: 3647 return 0; 3648 3649 case elfcpp::R_386_32: 3650 case elfcpp::R_386_PC32: 3651 case elfcpp::R_386_GOT32: 3652 case elfcpp::R_386_GOT32X: 3653 case elfcpp::R_386_PLT32: 3654 case elfcpp::R_386_GOTOFF: 3655 case elfcpp::R_386_GOTPC: 3656 return 4; 3657 3658 case elfcpp::R_386_16: 3659 case elfcpp::R_386_PC16: 3660 return 2; 3661 3662 case elfcpp::R_386_8: 3663 case elfcpp::R_386_PC8: 3664 return 1; 3665 3666 // These are relocations which should only be seen by the 3667 // dynamic linker, and should never be seen here. 3668 case elfcpp::R_386_COPY: 3669 case elfcpp::R_386_GLOB_DAT: 3670 case elfcpp::R_386_JUMP_SLOT: 3671 case elfcpp::R_386_RELATIVE: 3672 case elfcpp::R_386_IRELATIVE: 3673 case elfcpp::R_386_TLS_TPOFF: 3674 case elfcpp::R_386_TLS_DTPMOD32: 3675 case elfcpp::R_386_TLS_DTPOFF32: 3676 case elfcpp::R_386_TLS_TPOFF32: 3677 case elfcpp::R_386_TLS_DESC: 3678 object->error(_("unexpected reloc %u in object file"), r_type); 3679 return 0; 3680 3681 case elfcpp::R_386_32PLT: 3682 case elfcpp::R_386_TLS_GD_32: 3683 case elfcpp::R_386_TLS_GD_PUSH: 3684 case elfcpp::R_386_TLS_GD_CALL: 3685 case elfcpp::R_386_TLS_GD_POP: 3686 case elfcpp::R_386_TLS_LDM_32: 3687 case elfcpp::R_386_TLS_LDM_PUSH: 3688 case elfcpp::R_386_TLS_LDM_CALL: 3689 case elfcpp::R_386_TLS_LDM_POP: 3690 case elfcpp::R_386_USED_BY_INTEL_200: 3691 default: 3692 object->error(_("unsupported reloc %u in object file"), r_type); 3693 return 0; 3694 } 3695 } 3696 3697 // Scan the relocs during a relocatable link. 3698 3699 void 3700 Target_i386::scan_relocatable_relocs(Symbol_table* symtab, 3701 Layout* layout, 3702 Sized_relobj_file<32, false>* object, 3703 unsigned int data_shndx, 3704 unsigned int sh_type, 3705 const unsigned char* prelocs, 3706 size_t reloc_count, 3707 Output_section* output_section, 3708 bool needs_special_offset_handling, 3709 size_t local_symbol_count, 3710 const unsigned char* plocal_symbols, 3711 Relocatable_relocs* rr) 3712 { 3713 gold_assert(sh_type == elfcpp::SHT_REL); 3714 3715 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_REL, 3716 Relocatable_size_for_reloc> Scan_relocatable_relocs; 3717 3718 gold::scan_relocatable_relocs<32, false, elfcpp::SHT_REL, 3719 Scan_relocatable_relocs>( 3720 symtab, 3721 layout, 3722 object, 3723 data_shndx, 3724 prelocs, 3725 reloc_count, 3726 output_section, 3727 needs_special_offset_handling, 3728 local_symbol_count, 3729 plocal_symbols, 3730 rr); 3731 } 3732 3733 // Emit relocations for a section. 3734 3735 void 3736 Target_i386::relocate_relocs( 3737 const Relocate_info<32, false>* relinfo, 3738 unsigned int sh_type, 3739 const unsigned char* prelocs, 3740 size_t reloc_count, 3741 Output_section* output_section, 3742 elfcpp::Elf_types<32>::Elf_Off offset_in_output_section, 3743 const Relocatable_relocs* rr, 3744 unsigned char* view, 3745 elfcpp::Elf_types<32>::Elf_Addr view_address, 3746 section_size_type view_size, 3747 unsigned char* reloc_view, 3748 section_size_type reloc_view_size) 3749 { 3750 gold_assert(sh_type == elfcpp::SHT_REL); 3751 3752 gold::relocate_relocs<32, false, elfcpp::SHT_REL>( 3753 relinfo, 3754 prelocs, 3755 reloc_count, 3756 output_section, 3757 offset_in_output_section, 3758 rr, 3759 view, 3760 view_address, 3761 view_size, 3762 reloc_view, 3763 reloc_view_size); 3764 } 3765 3766 // Return the value to use for a dynamic which requires special 3767 // treatment. This is how we support equality comparisons of function 3768 // pointers across shared library boundaries, as described in the 3769 // processor specific ABI supplement. 3770 3771 uint64_t 3772 Target_i386::do_dynsym_value(const Symbol* gsym) const 3773 { 3774 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); 3775 return this->plt_address_for_global(gsym); 3776 } 3777 3778 // Return a string used to fill a code section with nops to take up 3779 // the specified length. 3780 3781 std::string 3782 Target_i386::do_code_fill(section_size_type length) const 3783 { 3784 if (length >= 16) 3785 { 3786 // Build a jmp instruction to skip over the bytes. 3787 unsigned char jmp[5]; 3788 jmp[0] = 0xe9; 3789 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5); 3790 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5) 3791 + std::string(length - 5, static_cast<char>(0x90))); 3792 } 3793 3794 // Nop sequences of various lengths. 3795 const char nop1[1] = { '\x90' }; // nop 3796 const char nop2[2] = { '\x66', '\x90' }; // xchg %ax %ax 3797 const char nop3[3] = { '\x8d', '\x76', '\x00' }; // leal 0(%esi),%esi 3798 const char nop4[4] = { '\x8d', '\x74', '\x26', // leal 0(%esi,1),%esi 3799 '\x00'}; 3800 const char nop5[5] = { '\x90', '\x8d', '\x74', // nop 3801 '\x26', '\x00' }; // leal 0(%esi,1),%esi 3802 const char nop6[6] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi 3803 '\x00', '\x00', '\x00' }; 3804 const char nop7[7] = { '\x8d', '\xb4', '\x26', // leal 0L(%esi,1),%esi 3805 '\x00', '\x00', '\x00', 3806 '\x00' }; 3807 const char nop8[8] = { '\x90', '\x8d', '\xb4', // nop 3808 '\x26', '\x00', '\x00', // leal 0L(%esi,1),%esi 3809 '\x00', '\x00' }; 3810 const char nop9[9] = { '\x89', '\xf6', '\x8d', // movl %esi,%esi 3811 '\xbc', '\x27', '\x00', // leal 0L(%edi,1),%edi 3812 '\x00', '\x00', '\x00' }; 3813 const char nop10[10] = { '\x8d', '\x76', '\x00', // leal 0(%esi),%esi 3814 '\x8d', '\xbc', '\x27', // leal 0L(%edi,1),%edi 3815 '\x00', '\x00', '\x00', 3816 '\x00' }; 3817 const char nop11[11] = { '\x8d', '\x74', '\x26', // leal 0(%esi,1),%esi 3818 '\x00', '\x8d', '\xbc', // leal 0L(%edi,1),%edi 3819 '\x27', '\x00', '\x00', 3820 '\x00', '\x00' }; 3821 const char nop12[12] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi 3822 '\x00', '\x00', '\x00', // leal 0L(%edi),%edi 3823 '\x8d', '\xbf', '\x00', 3824 '\x00', '\x00', '\x00' }; 3825 const char nop13[13] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi 3826 '\x00', '\x00', '\x00', // leal 0L(%edi,1),%edi 3827 '\x8d', '\xbc', '\x27', 3828 '\x00', '\x00', '\x00', 3829 '\x00' }; 3830 const char nop14[14] = { '\x8d', '\xb4', '\x26', // leal 0L(%esi,1),%esi 3831 '\x00', '\x00', '\x00', // leal 0L(%edi,1),%edi 3832 '\x00', '\x8d', '\xbc', 3833 '\x27', '\x00', '\x00', 3834 '\x00', '\x00' }; 3835 const char nop15[15] = { '\xeb', '\x0d', '\x90', // jmp .+15 3836 '\x90', '\x90', '\x90', // nop,nop,nop,... 3837 '\x90', '\x90', '\x90', 3838 '\x90', '\x90', '\x90', 3839 '\x90', '\x90', '\x90' }; 3840 3841 const char* nops[16] = { 3842 NULL, 3843 nop1, nop2, nop3, nop4, nop5, nop6, nop7, 3844 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15 3845 }; 3846 3847 return std::string(nops[length], length); 3848 } 3849 3850 // Return the value to use for the base of a DW_EH_PE_datarel offset 3851 // in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their 3852 // assembler can not write out the difference between two labels in 3853 // different sections, so instead of using a pc-relative value they 3854 // use an offset from the GOT. 3855 3856 uint64_t 3857 Target_i386::do_ehframe_datarel_base() const 3858 { 3859 gold_assert(this->global_offset_table_ != NULL); 3860 Symbol* sym = this->global_offset_table_; 3861 Sized_symbol<32>* ssym = static_cast<Sized_symbol<32>*>(sym); 3862 return ssym->value(); 3863 } 3864 3865 // Return whether SYM should be treated as a call to a non-split 3866 // function. We don't want that to be true of a call to a 3867 // get_pc_thunk function. 3868 3869 bool 3870 Target_i386::do_is_call_to_non_split(const Symbol* sym, unsigned int) const 3871 { 3872 return (sym->type() == elfcpp::STT_FUNC 3873 && !is_prefix_of("__i686.get_pc_thunk.", sym->name())); 3874 } 3875 3876 // FNOFFSET in section SHNDX in OBJECT is the start of a function 3877 // compiled with -fsplit-stack. The function calls non-split-stack 3878 // code. We have to change the function so that it always ensures 3879 // that it has enough stack space to run some random function. 3880 3881 void 3882 Target_i386::do_calls_non_split(Relobj* object, unsigned int shndx, 3883 section_offset_type fnoffset, 3884 section_size_type fnsize, 3885 unsigned char* view, 3886 section_size_type view_size, 3887 std::string* from, 3888 std::string* to) const 3889 { 3890 // The function starts with a comparison of the stack pointer and a 3891 // field in the TCB. This is followed by a jump. 3892 3893 // cmp %gs:NN,%esp 3894 if (this->match_view(view, view_size, fnoffset, "\x65\x3b\x25", 3) 3895 && fnsize > 7) 3896 { 3897 // We will call __morestack if the carry flag is set after this 3898 // comparison. We turn the comparison into an stc instruction 3899 // and some nops. 3900 view[fnoffset] = '\xf9'; 3901 this->set_view_to_nop(view, view_size, fnoffset + 1, 6); 3902 } 3903 // lea NN(%esp),%ecx 3904 // lea NN(%esp),%edx 3905 else if ((this->match_view(view, view_size, fnoffset, "\x8d\x8c\x24", 3) 3906 || this->match_view(view, view_size, fnoffset, "\x8d\x94\x24", 3)) 3907 && fnsize > 7) 3908 { 3909 // This is loading an offset from the stack pointer for a 3910 // comparison. The offset is negative, so we decrease the 3911 // offset by the amount of space we need for the stack. This 3912 // means we will avoid calling __morestack if there happens to 3913 // be plenty of space on the stack already. 3914 unsigned char* pval = view + fnoffset + 3; 3915 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval); 3916 val -= parameters->options().split_stack_adjust_size(); 3917 elfcpp::Swap_unaligned<32, false>::writeval(pval, val); 3918 } 3919 else 3920 { 3921 if (!object->has_no_split_stack()) 3922 object->error(_("failed to match split-stack sequence at " 3923 "section %u offset %0zx"), 3924 shndx, static_cast<size_t>(fnoffset)); 3925 return; 3926 } 3927 3928 // We have to change the function so that it calls 3929 // __morestack_non_split instead of __morestack. The former will 3930 // allocate additional stack space. 3931 *from = "__morestack"; 3932 *to = "__morestack_non_split"; 3933 } 3934 3935 // The selector for i386 object files. Note this is never instantiated 3936 // directly. It's only used in Target_selector_i386_nacl, below. 3937 3938 class Target_selector_i386 : public Target_selector_freebsd 3939 { 3940 public: 3941 Target_selector_i386() 3942 : Target_selector_freebsd(elfcpp::EM_386, 32, false, 3943 "elf32-i386", "elf32-i386-freebsd", 3944 "elf_i386") 3945 { } 3946 3947 Target* 3948 do_instantiate_target() 3949 { return new Target_i386(); } 3950 }; 3951 3952 // NaCl variant. It uses different PLT contents. 3953 3954 class Output_data_plt_i386_nacl : public Output_data_plt_i386 3955 { 3956 public: 3957 Output_data_plt_i386_nacl(Layout* layout, 3958 Output_data_got_plt_i386* got_plt, 3959 Output_data_space* got_irelative) 3960 : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative) 3961 { } 3962 3963 protected: 3964 virtual unsigned int 3965 do_get_plt_entry_size() const 3966 { return plt_entry_size; } 3967 3968 virtual void 3969 do_add_eh_frame(Layout* layout) 3970 { 3971 layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size, 3972 plt_eh_frame_fde, plt_eh_frame_fde_size); 3973 } 3974 3975 // The size of an entry in the PLT. 3976 static const int plt_entry_size = 64; 3977 3978 // The .eh_frame unwind information for the PLT. 3979 static const int plt_eh_frame_fde_size = 32; 3980 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size]; 3981 }; 3982 3983 class Output_data_plt_i386_nacl_exec : public Output_data_plt_i386_nacl 3984 { 3985 public: 3986 Output_data_plt_i386_nacl_exec(Layout* layout, 3987 Output_data_got_plt_i386* got_plt, 3988 Output_data_space* got_irelative) 3989 : Output_data_plt_i386_nacl(layout, got_plt, got_irelative) 3990 { } 3991 3992 protected: 3993 virtual void 3994 do_fill_first_plt_entry(unsigned char* pov, 3995 elfcpp::Elf_types<32>::Elf_Addr got_address); 3996 3997 virtual unsigned int 3998 do_fill_plt_entry(unsigned char* pov, 3999 elfcpp::Elf_types<32>::Elf_Addr got_address, 4000 unsigned int got_offset, 4001 unsigned int plt_offset, 4002 unsigned int plt_rel_offset); 4003 4004 private: 4005 // The first entry in the PLT for an executable. 4006 static const unsigned char first_plt_entry[plt_entry_size]; 4007 4008 // Other entries in the PLT for an executable. 4009 static const unsigned char plt_entry[plt_entry_size]; 4010 }; 4011 4012 class Output_data_plt_i386_nacl_dyn : public Output_data_plt_i386_nacl 4013 { 4014 public: 4015 Output_data_plt_i386_nacl_dyn(Layout* layout, 4016 Output_data_got_plt_i386* got_plt, 4017 Output_data_space* got_irelative) 4018 : Output_data_plt_i386_nacl(layout, got_plt, got_irelative) 4019 { } 4020 4021 protected: 4022 virtual void 4023 do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr); 4024 4025 virtual unsigned int 4026 do_fill_plt_entry(unsigned char* pov, 4027 elfcpp::Elf_types<32>::Elf_Addr, 4028 unsigned int got_offset, 4029 unsigned int plt_offset, 4030 unsigned int plt_rel_offset); 4031 4032 private: 4033 // The first entry in the PLT for a shared object. 4034 static const unsigned char first_plt_entry[plt_entry_size]; 4035 4036 // Other entries in the PLT for a shared object. 4037 static const unsigned char plt_entry[plt_entry_size]; 4038 }; 4039 4040 class Target_i386_nacl : public Target_i386 4041 { 4042 public: 4043 Target_i386_nacl() 4044 : Target_i386(&i386_nacl_info) 4045 { } 4046 4047 protected: 4048 virtual Output_data_plt_i386* 4049 do_make_data_plt(Layout* layout, 4050 Output_data_got_plt_i386* got_plt, 4051 Output_data_space* got_irelative, 4052 bool dyn) 4053 { 4054 if (dyn) 4055 return new Output_data_plt_i386_nacl_dyn(layout, got_plt, got_irelative); 4056 else 4057 return new Output_data_plt_i386_nacl_exec(layout, got_plt, got_irelative); 4058 } 4059 4060 virtual std::string 4061 do_code_fill(section_size_type length) const; 4062 4063 private: 4064 static const Target::Target_info i386_nacl_info; 4065 }; 4066 4067 const Target::Target_info Target_i386_nacl::i386_nacl_info = 4068 { 4069 32, // size 4070 false, // is_big_endian 4071 elfcpp::EM_386, // machine_code 4072 false, // has_make_symbol 4073 false, // has_resolve 4074 true, // has_code_fill 4075 true, // is_default_stack_executable 4076 true, // can_icf_inline_merge_sections 4077 '\0', // wrap_char 4078 "/lib/ld-nacl-x86-32.so.1", // dynamic_linker 4079 0x20000, // default_text_segment_address 4080 0x10000, // abi_pagesize (overridable by -z max-page-size) 4081 0x10000, // common_pagesize (overridable by -z common-page-size) 4082 true, // isolate_execinstr 4083 0x10000000, // rosegment_gap 4084 elfcpp::SHN_UNDEF, // small_common_shndx 4085 elfcpp::SHN_UNDEF, // large_common_shndx 4086 0, // small_common_section_flags 4087 0, // large_common_section_flags 4088 NULL, // attributes_section 4089 NULL, // attributes_vendor 4090 "_start", // entry_symbol_name 4091 32, // hash_entry_size 4092 }; 4093 4094 #define NACLMASK 0xe0 // 32-byte alignment mask 4095 4096 const unsigned char 4097 Output_data_plt_i386_nacl_exec::first_plt_entry[plt_entry_size] = 4098 { 4099 0xff, 0x35, // pushl contents of memory address 4100 0, 0, 0, 0, // replaced with address of .got + 4 4101 0x8b, 0x0d, // movl contents of address, %ecx 4102 0, 0, 0, 0, // replaced with address of .got + 8 4103 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx 4104 0xff, 0xe1, // jmp *%ecx 4105 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4106 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4107 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4108 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4109 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4110 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4111 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4112 0x90, 0x90, 0x90, 0x90, 0x90 4113 }; 4114 4115 void 4116 Output_data_plt_i386_nacl_exec::do_fill_first_plt_entry( 4117 unsigned char* pov, 4118 elfcpp::Elf_types<32>::Elf_Addr got_address) 4119 { 4120 memcpy(pov, first_plt_entry, plt_entry_size); 4121 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4); 4122 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8); 4123 } 4124 4125 // The first entry in the PLT for a shared object. 4126 4127 const unsigned char 4128 Output_data_plt_i386_nacl_dyn::first_plt_entry[plt_entry_size] = 4129 { 4130 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx) 4131 0x8b, 0x4b, 0x08, // mov 0x8(%ebx), %ecx 4132 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx 4133 0xff, 0xe1, // jmp *%ecx 4134 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4135 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4136 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4137 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4138 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4139 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4140 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4141 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4142 0x90, 0x90, 0x90, 0x90, 0x90, // nops 4143 0x90, 0x90, 0x90, 0x90, 0x90 // nops 4144 }; 4145 4146 void 4147 Output_data_plt_i386_nacl_dyn::do_fill_first_plt_entry( 4148 unsigned char* pov, 4149 elfcpp::Elf_types<32>::Elf_Addr) 4150 { 4151 memcpy(pov, first_plt_entry, plt_entry_size); 4152 } 4153 4154 // Subsequent entries in the PLT for an executable. 4155 4156 const unsigned char 4157 Output_data_plt_i386_nacl_exec::plt_entry[plt_entry_size] = 4158 { 4159 0x8b, 0x0d, // movl contents of address, %ecx */ 4160 0, 0, 0, 0, // replaced with address of symbol in .got 4161 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx 4162 0xff, 0xe1, // jmp *%ecx 4163 4164 // Pad to the next 32-byte boundary with nop instructions. 4165 0x90, 4166 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4167 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4168 4169 // Lazy GOT entries point here (32-byte aligned). 4170 0x68, // pushl immediate 4171 0, 0, 0, 0, // replaced with offset into relocation table 4172 0xe9, // jmp relative 4173 0, 0, 0, 0, // replaced with offset to start of .plt 4174 4175 // Pad to the next 32-byte boundary with nop instructions. 4176 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4177 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4178 0x90, 0x90 4179 }; 4180 4181 unsigned int 4182 Output_data_plt_i386_nacl_exec::do_fill_plt_entry( 4183 unsigned char* pov, 4184 elfcpp::Elf_types<32>::Elf_Addr got_address, 4185 unsigned int got_offset, 4186 unsigned int plt_offset, 4187 unsigned int plt_rel_offset) 4188 { 4189 memcpy(pov, plt_entry, plt_entry_size); 4190 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 4191 got_address + got_offset); 4192 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset); 4193 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4)); 4194 return 32; 4195 } 4196 4197 // Subsequent entries in the PLT for a shared object. 4198 4199 const unsigned char 4200 Output_data_plt_i386_nacl_dyn::plt_entry[plt_entry_size] = 4201 { 4202 0x8b, 0x8b, // movl offset(%ebx), %ecx 4203 0, 0, 0, 0, // replaced with offset of symbol in .got 4204 0x83, 0xe1, 0xe0, // andl $NACLMASK, %ecx 4205 0xff, 0xe1, // jmp *%ecx 4206 4207 // Pad to the next 32-byte boundary with nop instructions. 4208 0x90, 4209 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4210 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4211 4212 // Lazy GOT entries point here (32-byte aligned). 4213 0x68, // pushl immediate 4214 0, 0, 0, 0, // replaced with offset into relocation table. 4215 0xe9, // jmp relative 4216 0, 0, 0, 0, // replaced with offset to start of .plt. 4217 4218 // Pad to the next 32-byte boundary with nop instructions. 4219 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4220 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4221 0x90, 0x90 4222 }; 4223 4224 unsigned int 4225 Output_data_plt_i386_nacl_dyn::do_fill_plt_entry( 4226 unsigned char* pov, 4227 elfcpp::Elf_types<32>::Elf_Addr, 4228 unsigned int got_offset, 4229 unsigned int plt_offset, 4230 unsigned int plt_rel_offset) 4231 { 4232 memcpy(pov, plt_entry, plt_entry_size); 4233 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset); 4234 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset); 4235 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4)); 4236 return 32; 4237 } 4238 4239 const unsigned char 4240 Output_data_plt_i386_nacl::plt_eh_frame_fde[plt_eh_frame_fde_size] = 4241 { 4242 0, 0, 0, 0, // Replaced with offset to .plt. 4243 0, 0, 0, 0, // Replaced with size of .plt. 4244 0, // Augmentation size. 4245 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8. 4246 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 4247 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12. 4248 elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64. 4249 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 4250 13, // Block length. 4251 elfcpp::DW_OP_breg4, 4, // Push %esp + 4. 4252 elfcpp::DW_OP_breg8, 0, // Push %eip. 4253 elfcpp::DW_OP_const1u, 63, // Push 0x3f. 4254 elfcpp::DW_OP_and, // & (%eip & 0x3f). 4255 elfcpp::DW_OP_const1u, 37, // Push 0x25. 4256 elfcpp::DW_OP_ge, // >= ((%eip & 0x3f) >= 0x25) 4257 elfcpp::DW_OP_lit2, // Push 2. 4258 elfcpp::DW_OP_shl, // << (((%eip & 0x3f) >= 0x25) << 2) 4259 elfcpp::DW_OP_plus, // + ((((%eip&0x3f)>=0x25)<<2)+%esp+4 4260 elfcpp::DW_CFA_nop, // Align to 32 bytes. 4261 elfcpp::DW_CFA_nop 4262 }; 4263 4264 // Return a string used to fill a code section with nops. 4265 // For NaCl, long NOPs are only valid if they do not cross 4266 // bundle alignment boundaries, so keep it simple with one-byte NOPs. 4267 std::string 4268 Target_i386_nacl::do_code_fill(section_size_type length) const 4269 { 4270 return std::string(length, static_cast<char>(0x90)); 4271 } 4272 4273 // The selector for i386-nacl object files. 4274 4275 class Target_selector_i386_nacl 4276 : public Target_selector_nacl<Target_selector_i386, Target_i386_nacl> 4277 { 4278 public: 4279 Target_selector_i386_nacl() 4280 : Target_selector_nacl<Target_selector_i386, 4281 Target_i386_nacl>("x86-32", 4282 "elf32-i386-nacl", 4283 "elf_i386_nacl") 4284 { } 4285 }; 4286 4287 Target_selector_i386_nacl target_selector_i386; 4288 4289 // IAMCU variant. It uses EM_IAMCU, not EM_386. 4290 4291 class Target_iamcu : public Target_i386 4292 { 4293 public: 4294 Target_iamcu() 4295 : Target_i386(&iamcu_info) 4296 { } 4297 4298 private: 4299 // Information about this specific target which we pass to the 4300 // general Target structure. 4301 static const Target::Target_info iamcu_info; 4302 }; 4303 4304 const Target::Target_info Target_iamcu::iamcu_info = 4305 { 4306 32, // size 4307 false, // is_big_endian 4308 elfcpp::EM_IAMCU, // machine_code 4309 false, // has_make_symbol 4310 false, // has_resolve 4311 true, // has_code_fill 4312 true, // is_default_stack_executable 4313 true, // can_icf_inline_merge_sections 4314 '\0', // wrap_char 4315 "/usr/lib/libc.so.1", // dynamic_linker 4316 0x08048000, // default_text_segment_address 4317 0x1000, // abi_pagesize (overridable by -z max-page-size) 4318 0x1000, // common_pagesize (overridable by -z common-page-size) 4319 false, // isolate_execinstr 4320 0, // rosegment_gap 4321 elfcpp::SHN_UNDEF, // small_common_shndx 4322 elfcpp::SHN_UNDEF, // large_common_shndx 4323 0, // small_common_section_flags 4324 0, // large_common_section_flags 4325 NULL, // attributes_section 4326 NULL, // attributes_vendor 4327 "_start", // entry_symbol_name 4328 32, // hash_entry_size 4329 }; 4330 4331 class Target_selector_iamcu : public Target_selector 4332 { 4333 public: 4334 Target_selector_iamcu() 4335 : Target_selector(elfcpp::EM_IAMCU, 32, false, "elf32-iamcu", 4336 "elf_iamcu") 4337 { } 4338 4339 Target* 4340 do_instantiate_target() 4341 { return new Target_iamcu(); } 4342 }; 4343 4344 Target_selector_iamcu target_selector_iamcu; 4345 4346 } // End anonymous namespace. 4347