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