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