1// i386.cc -- i386 target support for gold. 2 3// Copyright (C) 2006-2022 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 elfcpp::SHT_PROGBITS, // unwind_section_type 929}; 930 931// Get the GOT section, creating it if necessary. 932 933Output_data_got<32, false>* 934Target_i386::got_section(Symbol_table* symtab, Layout* layout) 935{ 936 if (this->got_ == NULL) 937 { 938 gold_assert(symtab != NULL && layout != NULL); 939 940 this->got_ = new Output_data_got<32, false>(); 941 942 // When using -z now, we can treat .got.plt as a relro section. 943 // Without -z now, it is modified after program startup by lazy 944 // PLT relocations. 945 bool is_got_plt_relro = parameters->options().now(); 946 Output_section_order got_order = (is_got_plt_relro 947 ? ORDER_RELRO 948 : ORDER_RELRO_LAST); 949 Output_section_order got_plt_order = (is_got_plt_relro 950 ? ORDER_RELRO 951 : ORDER_NON_RELRO_FIRST); 952 953 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 954 (elfcpp::SHF_ALLOC 955 | elfcpp::SHF_WRITE), 956 this->got_, got_order, true); 957 958 this->got_plt_ = new Output_data_got_plt_i386(layout); 959 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 960 (elfcpp::SHF_ALLOC 961 | elfcpp::SHF_WRITE), 962 this->got_plt_, got_plt_order, 963 is_got_plt_relro); 964 965 // The first three entries are reserved. 966 this->got_plt_->set_current_data_size(3 * 4); 967 968 if (!is_got_plt_relro) 969 { 970 // Those bytes can go into the relro segment. 971 layout->increase_relro(3 * 4); 972 } 973 974 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT. 975 this->global_offset_table_ = 976 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 977 Symbol_table::PREDEFINED, 978 this->got_plt_, 979 0, 0, elfcpp::STT_OBJECT, 980 elfcpp::STB_LOCAL, 981 elfcpp::STV_HIDDEN, 0, 982 false, false); 983 984 // If there are any IRELATIVE relocations, they get GOT entries 985 // in .got.plt after the jump slot relocations. 986 this->got_irelative_ = new Output_data_space(4, "** GOT IRELATIVE PLT"); 987 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 988 (elfcpp::SHF_ALLOC 989 | elfcpp::SHF_WRITE), 990 this->got_irelative_, 991 got_plt_order, is_got_plt_relro); 992 993 // If there are any TLSDESC relocations, they get GOT entries in 994 // .got.plt after the jump slot entries. 995 this->got_tlsdesc_ = new Output_data_got<32, false>(); 996 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 997 (elfcpp::SHF_ALLOC 998 | elfcpp::SHF_WRITE), 999 this->got_tlsdesc_, 1000 got_plt_order, is_got_plt_relro); 1001 } 1002 1003 return this->got_; 1004} 1005 1006// Get the dynamic reloc section, creating it if necessary. 1007 1008Target_i386::Reloc_section* 1009Target_i386::rel_dyn_section(Layout* layout) 1010{ 1011 if (this->rel_dyn_ == NULL) 1012 { 1013 gold_assert(layout != NULL); 1014 this->rel_dyn_ = new Reloc_section(parameters->options().combreloc()); 1015 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, 1016 elfcpp::SHF_ALLOC, this->rel_dyn_, 1017 ORDER_DYNAMIC_RELOCS, false); 1018 } 1019 return this->rel_dyn_; 1020} 1021 1022// Get the section to use for IRELATIVE relocs, creating it if 1023// necessary. These go in .rel.dyn, but only after all other dynamic 1024// relocations. They need to follow the other dynamic relocations so 1025// that they can refer to global variables initialized by those 1026// relocs. 1027 1028Target_i386::Reloc_section* 1029Target_i386::rel_irelative_section(Layout* layout) 1030{ 1031 if (this->rel_irelative_ == NULL) 1032 { 1033 // Make sure we have already create the dynamic reloc section. 1034 this->rel_dyn_section(layout); 1035 this->rel_irelative_ = new Reloc_section(false); 1036 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, 1037 elfcpp::SHF_ALLOC, this->rel_irelative_, 1038 ORDER_DYNAMIC_RELOCS, false); 1039 gold_assert(this->rel_dyn_->output_section() 1040 == this->rel_irelative_->output_section()); 1041 } 1042 return this->rel_irelative_; 1043} 1044 1045// Write the first three reserved words of the .got.plt section. 1046// The remainder of the section is written while writing the PLT 1047// in Output_data_plt_i386::do_write. 1048 1049void 1050Output_data_got_plt_i386::do_write(Output_file* of) 1051{ 1052 // The first entry in the GOT is the address of the .dynamic section 1053 // aka the PT_DYNAMIC segment. The next two entries are reserved. 1054 // We saved space for them when we created the section in 1055 // Target_i386::got_section. 1056 const off_t got_file_offset = this->offset(); 1057 gold_assert(this->data_size() >= 12); 1058 unsigned char* const got_view = of->get_output_view(got_file_offset, 12); 1059 Output_section* dynamic = this->layout_->dynamic_section(); 1060 uint32_t dynamic_addr = dynamic == NULL ? 0 : dynamic->address(); 1061 elfcpp::Swap<32, false>::writeval(got_view, dynamic_addr); 1062 memset(got_view + 4, 0, 8); 1063 of->write_output_view(got_file_offset, 12, got_view); 1064} 1065 1066// Create the PLT section. The ordinary .got section is an argument, 1067// since we need to refer to the start. We also create our own .got 1068// section just for PLT entries. 1069 1070Output_data_plt_i386::Output_data_plt_i386(Layout* layout, 1071 uint64_t addralign, 1072 Output_data_got_plt_i386* got_plt, 1073 Output_data_space* got_irelative) 1074 : Output_section_data(addralign), 1075 tls_desc_rel_(NULL), irelative_rel_(NULL), got_plt_(got_plt), 1076 got_irelative_(got_irelative), count_(0), irelative_count_(0), 1077 global_ifuncs_(), local_ifuncs_() 1078{ 1079 this->rel_ = new Reloc_section(false); 1080 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 1081 elfcpp::SHF_ALLOC, this->rel_, 1082 ORDER_DYNAMIC_PLT_RELOCS, false); 1083} 1084 1085void 1086Output_data_plt_i386::do_adjust_output_section(Output_section* os) 1087{ 1088 // UnixWare sets the entsize of .plt to 4, and so does the old GNU 1089 // linker, and so do we. 1090 os->set_entsize(4); 1091} 1092 1093// Add an entry to the PLT. 1094 1095void 1096Output_data_plt_i386::add_entry(Symbol_table* symtab, Layout* layout, 1097 Symbol* gsym) 1098{ 1099 gold_assert(!gsym->has_plt_offset()); 1100 1101 // Every PLT entry needs a reloc. 1102 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1103 && gsym->can_use_relative_reloc(false)) 1104 { 1105 gsym->set_plt_offset(this->irelative_count_ * this->get_plt_entry_size()); 1106 ++this->irelative_count_; 1107 section_offset_type got_offset = 1108 this->got_irelative_->current_data_size(); 1109 this->got_irelative_->set_current_data_size(got_offset + 4); 1110 Reloc_section* rel = this->rel_irelative(symtab, layout); 1111 rel->add_symbolless_global_addend(gsym, elfcpp::R_386_IRELATIVE, 1112 this->got_irelative_, got_offset); 1113 struct Global_ifunc gi; 1114 gi.sym = gsym; 1115 gi.got_offset = got_offset; 1116 this->global_ifuncs_.push_back(gi); 1117 } 1118 else 1119 { 1120 // When setting the PLT offset we skip the initial reserved PLT 1121 // entry. 1122 gsym->set_plt_offset((this->count_ + 1) * this->get_plt_entry_size()); 1123 1124 ++this->count_; 1125 1126 section_offset_type got_offset = this->got_plt_->current_data_size(); 1127 1128 // Every PLT entry needs a GOT entry which points back to the 1129 // PLT entry (this will be changed by the dynamic linker, 1130 // normally lazily when the function is called). 1131 this->got_plt_->set_current_data_size(got_offset + 4); 1132 1133 gsym->set_needs_dynsym_entry(); 1134 this->rel_->add_global(gsym, elfcpp::R_386_JUMP_SLOT, this->got_plt_, 1135 got_offset); 1136 } 1137 1138 // Note that we don't need to save the symbol. The contents of the 1139 // PLT are independent of which symbols are used. The symbols only 1140 // appear in the relocations. 1141} 1142 1143// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return 1144// the PLT offset. 1145 1146unsigned int 1147Output_data_plt_i386::add_local_ifunc_entry( 1148 Symbol_table* symtab, 1149 Layout* layout, 1150 Sized_relobj_file<32, false>* relobj, 1151 unsigned int local_sym_index) 1152{ 1153 unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size(); 1154 ++this->irelative_count_; 1155 1156 section_offset_type got_offset = this->got_irelative_->current_data_size(); 1157 1158 // Every PLT entry needs a GOT entry which points back to the PLT 1159 // entry. 1160 this->got_irelative_->set_current_data_size(got_offset + 4); 1161 1162 // Every PLT entry needs a reloc. 1163 Reloc_section* rel = this->rel_irelative(symtab, layout); 1164 rel->add_symbolless_local_addend(relobj, local_sym_index, 1165 elfcpp::R_386_IRELATIVE, 1166 this->got_irelative_, got_offset); 1167 1168 struct Local_ifunc li; 1169 li.object = relobj; 1170 li.local_sym_index = local_sym_index; 1171 li.got_offset = got_offset; 1172 this->local_ifuncs_.push_back(li); 1173 1174 return plt_offset; 1175} 1176 1177// Return where the TLS_DESC relocations should go, creating it if 1178// necessary. These follow the JUMP_SLOT relocations. 1179 1180Output_data_plt_i386::Reloc_section* 1181Output_data_plt_i386::rel_tls_desc(Layout* layout) 1182{ 1183 if (this->tls_desc_rel_ == NULL) 1184 { 1185 this->tls_desc_rel_ = new Reloc_section(false); 1186 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 1187 elfcpp::SHF_ALLOC, this->tls_desc_rel_, 1188 ORDER_DYNAMIC_PLT_RELOCS, false); 1189 gold_assert(this->tls_desc_rel_->output_section() 1190 == this->rel_->output_section()); 1191 } 1192 return this->tls_desc_rel_; 1193} 1194 1195// Return where the IRELATIVE relocations should go in the PLT. These 1196// follow the JUMP_SLOT and TLS_DESC relocations. 1197 1198Output_data_plt_i386::Reloc_section* 1199Output_data_plt_i386::rel_irelative(Symbol_table* symtab, Layout* layout) 1200{ 1201 if (this->irelative_rel_ == NULL) 1202 { 1203 // Make sure we have a place for the TLS_DESC relocations, in 1204 // case we see any later on. 1205 this->rel_tls_desc(layout); 1206 this->irelative_rel_ = new Reloc_section(false); 1207 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 1208 elfcpp::SHF_ALLOC, this->irelative_rel_, 1209 ORDER_DYNAMIC_PLT_RELOCS, false); 1210 gold_assert(this->irelative_rel_->output_section() 1211 == this->rel_->output_section()); 1212 1213 if (parameters->doing_static_link()) 1214 { 1215 // A statically linked executable will only have a .rel.plt 1216 // section to hold R_386_IRELATIVE relocs for STT_GNU_IFUNC 1217 // symbols. The library will use these symbols to locate 1218 // the IRELATIVE relocs at program startup time. 1219 symtab->define_in_output_data("__rel_iplt_start", NULL, 1220 Symbol_table::PREDEFINED, 1221 this->irelative_rel_, 0, 0, 1222 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1223 elfcpp::STV_HIDDEN, 0, false, true); 1224 symtab->define_in_output_data("__rel_iplt_end", NULL, 1225 Symbol_table::PREDEFINED, 1226 this->irelative_rel_, 0, 0, 1227 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1228 elfcpp::STV_HIDDEN, 0, true, true); 1229 } 1230 } 1231 return this->irelative_rel_; 1232} 1233 1234// Return the PLT address to use for a global symbol. 1235 1236uint64_t 1237Output_data_plt_i386::address_for_global(const Symbol* gsym) 1238{ 1239 uint64_t offset = 0; 1240 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1241 && gsym->can_use_relative_reloc(false)) 1242 offset = (this->count_ + 1) * this->get_plt_entry_size(); 1243 return this->address() + offset + gsym->plt_offset(); 1244} 1245 1246// Return the PLT address to use for a local symbol. These are always 1247// IRELATIVE relocs. 1248 1249uint64_t 1250Output_data_plt_i386::address_for_local(const Relobj* object, 1251 unsigned int r_sym) 1252{ 1253 return (this->address() 1254 + (this->count_ + 1) * this->get_plt_entry_size() 1255 + object->local_plt_offset(r_sym)); 1256} 1257 1258// The first entry in the PLT for an executable. 1259 1260const unsigned char Output_data_plt_i386_exec::first_plt_entry[plt_entry_size] = 1261{ 1262 0xff, 0x35, // pushl contents of memory address 1263 0, 0, 0, 0, // replaced with address of .got + 4 1264 0xff, 0x25, // jmp indirect 1265 0, 0, 0, 0, // replaced with address of .got + 8 1266 0, 0, 0, 0 // unused 1267}; 1268 1269void 1270Output_data_plt_i386_exec::do_fill_first_plt_entry( 1271 unsigned char* pov, 1272 elfcpp::Elf_types<32>::Elf_Addr got_address) 1273{ 1274 memcpy(pov, first_plt_entry, plt_entry_size); 1275 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4); 1276 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8); 1277} 1278 1279// The first entry in the PLT for a shared object. 1280 1281const unsigned char Output_data_plt_i386_dyn::first_plt_entry[plt_entry_size] = 1282{ 1283 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx) 1284 0xff, 0xa3, 8, 0, 0, 0, // jmp *8(%ebx) 1285 0, 0, 0, 0 // unused 1286}; 1287 1288void 1289Output_data_plt_i386_dyn::do_fill_first_plt_entry( 1290 unsigned char* pov, 1291 elfcpp::Elf_types<32>::Elf_Addr) 1292{ 1293 memcpy(pov, first_plt_entry, plt_entry_size); 1294} 1295 1296// Subsequent entries in the PLT for an executable. 1297 1298const unsigned char Output_data_plt_i386_exec::plt_entry[plt_entry_size] = 1299{ 1300 0xff, 0x25, // jmp indirect 1301 0, 0, 0, 0, // replaced with address of symbol in .got 1302 0x68, // pushl immediate 1303 0, 0, 0, 0, // replaced with offset into relocation table 1304 0xe9, // jmp relative 1305 0, 0, 0, 0 // replaced with offset to start of .plt 1306}; 1307 1308unsigned int 1309Output_data_plt_i386_exec::do_fill_plt_entry( 1310 unsigned char* pov, 1311 elfcpp::Elf_types<32>::Elf_Addr got_address, 1312 unsigned int got_offset, 1313 unsigned int plt_offset, 1314 unsigned int plt_rel_offset) 1315{ 1316 memcpy(pov, plt_entry, plt_entry_size); 1317 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 1318 got_address + got_offset); 1319 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset); 1320 elfcpp::Swap<32, false>::writeval(pov + 12, - (plt_offset + 12 + 4)); 1321 return 6; 1322} 1323 1324// Subsequent entries in the PLT for a shared object. 1325 1326const unsigned char Output_data_plt_i386_dyn::plt_entry[plt_entry_size] = 1327{ 1328 0xff, 0xa3, // jmp *offset(%ebx) 1329 0, 0, 0, 0, // replaced with offset of symbol in .got 1330 0x68, // pushl immediate 1331 0, 0, 0, 0, // replaced with offset into relocation table 1332 0xe9, // jmp relative 1333 0, 0, 0, 0 // replaced with offset to start of .plt 1334}; 1335 1336unsigned int 1337Output_data_plt_i386_dyn::do_fill_plt_entry(unsigned char* pov, 1338 elfcpp::Elf_types<32>::Elf_Addr, 1339 unsigned int got_offset, 1340 unsigned int plt_offset, 1341 unsigned int plt_rel_offset) 1342{ 1343 memcpy(pov, plt_entry, plt_entry_size); 1344 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset); 1345 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset); 1346 elfcpp::Swap<32, false>::writeval(pov + 12, - (plt_offset + 12 + 4)); 1347 return 6; 1348} 1349 1350// The .eh_frame unwind information for the PLT. 1351 1352const unsigned char 1353Output_data_plt_i386::plt_eh_frame_cie[plt_eh_frame_cie_size] = 1354{ 1355 1, // CIE version. 1356 'z', // Augmentation: augmentation size included. 1357 'R', // Augmentation: FDE encoding included. 1358 '\0', // End of augmentation string. 1359 1, // Code alignment factor. 1360 0x7c, // Data alignment factor. 1361 8, // Return address column. 1362 1, // Augmentation size. 1363 (elfcpp::DW_EH_PE_pcrel // FDE encoding. 1364 | elfcpp::DW_EH_PE_sdata4), 1365 elfcpp::DW_CFA_def_cfa, 4, 4, // DW_CFA_def_cfa: r4 (esp) ofs 4. 1366 elfcpp::DW_CFA_offset + 8, 1, // DW_CFA_offset: r8 (eip) at cfa-4. 1367 elfcpp::DW_CFA_nop, // Align to 16 bytes. 1368 elfcpp::DW_CFA_nop 1369}; 1370 1371const unsigned char 1372Output_data_plt_i386_standard::plt_eh_frame_fde[plt_eh_frame_fde_size] = 1373{ 1374 0, 0, 0, 0, // Replaced with offset to .plt. 1375 0, 0, 0, 0, // Replaced with size of .plt. 1376 0, // Augmentation size. 1377 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8. 1378 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 1379 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12. 1380 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16. 1381 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 1382 11, // Block length. 1383 elfcpp::DW_OP_breg4, 4, // Push %esp + 4. 1384 elfcpp::DW_OP_breg8, 0, // Push %eip. 1385 elfcpp::DW_OP_lit15, // Push 0xf. 1386 elfcpp::DW_OP_and, // & (%eip & 0xf). 1387 elfcpp::DW_OP_lit11, // Push 0xb. 1388 elfcpp::DW_OP_ge, // >= ((%eip & 0xf) >= 0xb) 1389 elfcpp::DW_OP_lit2, // Push 2. 1390 elfcpp::DW_OP_shl, // << (((%eip & 0xf) >= 0xb) << 2) 1391 elfcpp::DW_OP_plus, // + ((((%eip&0xf)>=0xb)<<2)+%esp+4 1392 elfcpp::DW_CFA_nop, // Align to 32 bytes. 1393 elfcpp::DW_CFA_nop, 1394 elfcpp::DW_CFA_nop, 1395 elfcpp::DW_CFA_nop 1396}; 1397 1398// Write out the PLT. This uses the hand-coded instructions above, 1399// and adjusts them as needed. This is all specified by the i386 ELF 1400// Processor Supplement. 1401 1402void 1403Output_data_plt_i386::do_write(Output_file* of) 1404{ 1405 const off_t offset = this->offset(); 1406 const section_size_type oview_size = 1407 convert_to_section_size_type(this->data_size()); 1408 unsigned char* const oview = of->get_output_view(offset, oview_size); 1409 1410 const off_t got_file_offset = this->got_plt_->offset(); 1411 gold_assert(parameters->incremental_update() 1412 || (got_file_offset + this->got_plt_->data_size() 1413 == this->got_irelative_->offset())); 1414 const section_size_type got_size = 1415 convert_to_section_size_type(this->got_plt_->data_size() 1416 + this->got_irelative_->data_size()); 1417 1418 unsigned char* const got_view = of->get_output_view(got_file_offset, 1419 got_size); 1420 1421 unsigned char* pov = oview; 1422 1423 elfcpp::Elf_types<32>::Elf_Addr plt_address = this->address(); 1424 elfcpp::Elf_types<32>::Elf_Addr got_address = this->got_plt_->address(); 1425 1426 this->fill_first_plt_entry(pov, got_address); 1427 pov += this->get_plt_entry_size(); 1428 1429 // The first three entries in the GOT are reserved, and are written 1430 // by Output_data_got_plt_i386::do_write. 1431 unsigned char* got_pov = got_view + 12; 1432 1433 const int rel_size = elfcpp::Elf_sizes<32>::rel_size; 1434 1435 unsigned int plt_offset = this->get_plt_entry_size(); 1436 unsigned int plt_rel_offset = 0; 1437 unsigned int got_offset = 12; 1438 const unsigned int count = this->count_ + this->irelative_count_; 1439 for (unsigned int i = 0; 1440 i < count; 1441 ++i, 1442 pov += this->get_plt_entry_size(), 1443 got_pov += 4, 1444 plt_offset += this->get_plt_entry_size(), 1445 plt_rel_offset += rel_size, 1446 got_offset += 4) 1447 { 1448 // Set and adjust the PLT entry itself. 1449 unsigned int lazy_offset = this->fill_plt_entry(pov, 1450 got_address, 1451 got_offset, 1452 plt_offset, 1453 plt_rel_offset); 1454 1455 // Set the entry in the GOT. 1456 elfcpp::Swap<32, false>::writeval(got_pov, 1457 plt_address + plt_offset + lazy_offset); 1458 } 1459 1460 // If any STT_GNU_IFUNC symbols have PLT entries, we need to change 1461 // the GOT to point to the actual symbol value, rather than point to 1462 // the PLT entry. That will let the dynamic linker call the right 1463 // function when resolving IRELATIVE relocations. 1464 unsigned char* got_irelative_view = got_view + this->got_plt_->data_size(); 1465 for (std::vector<Global_ifunc>::const_iterator p = 1466 this->global_ifuncs_.begin(); 1467 p != this->global_ifuncs_.end(); 1468 ++p) 1469 { 1470 const Sized_symbol<32>* ssym = 1471 static_cast<const Sized_symbol<32>*>(p->sym); 1472 elfcpp::Swap<32, false>::writeval(got_irelative_view + p->got_offset, 1473 ssym->value()); 1474 } 1475 1476 for (std::vector<Local_ifunc>::const_iterator p = 1477 this->local_ifuncs_.begin(); 1478 p != this->local_ifuncs_.end(); 1479 ++p) 1480 { 1481 const Symbol_value<32>* psymval = 1482 p->object->local_symbol(p->local_sym_index); 1483 elfcpp::Swap<32, false>::writeval(got_irelative_view + p->got_offset, 1484 psymval->value(p->object, 0)); 1485 } 1486 1487 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 1488 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); 1489 1490 of->write_output_view(offset, oview_size, oview); 1491 of->write_output_view(got_file_offset, got_size, got_view); 1492} 1493 1494// Create the PLT section. 1495 1496void 1497Target_i386::make_plt_section(Symbol_table* symtab, Layout* layout) 1498{ 1499 if (this->plt_ == NULL) 1500 { 1501 // Create the GOT sections first. 1502 this->got_section(symtab, layout); 1503 1504 const bool dyn = parameters->options().output_is_position_independent(); 1505 this->plt_ = this->make_data_plt(layout, 1506 this->got_plt_, 1507 this->got_irelative_, 1508 dyn); 1509 1510 // Add unwind information if requested. 1511 if (parameters->options().ld_generated_unwind_info()) 1512 this->plt_->add_eh_frame(layout); 1513 1514 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 1515 (elfcpp::SHF_ALLOC 1516 | elfcpp::SHF_EXECINSTR), 1517 this->plt_, ORDER_PLT, false); 1518 1519 // Make the sh_info field of .rel.plt point to .plt. 1520 Output_section* rel_plt_os = this->plt_->rel_plt()->output_section(); 1521 rel_plt_os->set_info_section(this->plt_->output_section()); 1522 } 1523} 1524 1525// Create a PLT entry for a global symbol. 1526 1527void 1528Target_i386::make_plt_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym) 1529{ 1530 if (gsym->has_plt_offset()) 1531 return; 1532 if (this->plt_ == NULL) 1533 this->make_plt_section(symtab, layout); 1534 this->plt_->add_entry(symtab, layout, gsym); 1535} 1536 1537// Make a PLT entry for a local STT_GNU_IFUNC symbol. 1538 1539void 1540Target_i386::make_local_ifunc_plt_entry(Symbol_table* symtab, Layout* layout, 1541 Sized_relobj_file<32, false>* relobj, 1542 unsigned int local_sym_index) 1543{ 1544 if (relobj->local_has_plt_offset(local_sym_index)) 1545 return; 1546 if (this->plt_ == NULL) 1547 this->make_plt_section(symtab, layout); 1548 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout, 1549 relobj, 1550 local_sym_index); 1551 relobj->set_local_plt_offset(local_sym_index, plt_offset); 1552} 1553 1554// Return the number of entries in the PLT. 1555 1556unsigned int 1557Target_i386::plt_entry_count() const 1558{ 1559 if (this->plt_ == NULL) 1560 return 0; 1561 return this->plt_->entry_count(); 1562} 1563 1564// Return the offset of the first non-reserved PLT entry. 1565 1566unsigned int 1567Target_i386::first_plt_entry_offset() const 1568{ 1569 if (this->plt_ == NULL) 1570 return 0; 1571 return this->plt_->first_plt_entry_offset(); 1572} 1573 1574// Return the size of each PLT entry. 1575 1576unsigned int 1577Target_i386::plt_entry_size() const 1578{ 1579 if (this->plt_ == NULL) 1580 return 0; 1581 return this->plt_->get_plt_entry_size(); 1582} 1583 1584// Get the section to use for TLS_DESC relocations. 1585 1586Target_i386::Reloc_section* 1587Target_i386::rel_tls_desc_section(Layout* layout) const 1588{ 1589 return this->plt_section()->rel_tls_desc(layout); 1590} 1591 1592// Define the _TLS_MODULE_BASE_ symbol in the TLS segment. 1593 1594void 1595Target_i386::define_tls_base_symbol(Symbol_table* symtab, Layout* layout) 1596{ 1597 if (this->tls_base_symbol_defined_) 1598 return; 1599 1600 Output_segment* tls_segment = layout->tls_segment(); 1601 if (tls_segment != NULL) 1602 { 1603 bool is_exec = parameters->options().output_is_executable(); 1604 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL, 1605 Symbol_table::PREDEFINED, 1606 tls_segment, 0, 0, 1607 elfcpp::STT_TLS, 1608 elfcpp::STB_LOCAL, 1609 elfcpp::STV_HIDDEN, 0, 1610 (is_exec 1611 ? Symbol::SEGMENT_END 1612 : Symbol::SEGMENT_START), 1613 true); 1614 } 1615 this->tls_base_symbol_defined_ = true; 1616} 1617 1618// Create a GOT entry for the TLS module index. 1619 1620unsigned int 1621Target_i386::got_mod_index_entry(Symbol_table* symtab, Layout* layout, 1622 Sized_relobj_file<32, false>* object) 1623{ 1624 if (this->got_mod_index_offset_ == -1U) 1625 { 1626 gold_assert(symtab != NULL && layout != NULL && object != NULL); 1627 Reloc_section* rel_dyn = this->rel_dyn_section(layout); 1628 Output_data_got<32, false>* got = this->got_section(symtab, layout); 1629 unsigned int got_offset = got->add_constant(0); 1630 rel_dyn->add_local(object, 0, elfcpp::R_386_TLS_DTPMOD32, got, 1631 got_offset); 1632 got->add_constant(0); 1633 this->got_mod_index_offset_ = got_offset; 1634 } 1635 return this->got_mod_index_offset_; 1636} 1637 1638// Optimize the TLS relocation type based on what we know about the 1639// symbol. IS_FINAL is true if the final address of this symbol is 1640// known at link time. 1641 1642tls::Tls_optimization 1643Target_i386::optimize_tls_reloc(bool is_final, int r_type) 1644{ 1645 // If we are generating a shared library, then we can't do anything 1646 // in the linker. 1647 if (parameters->options().shared()) 1648 return tls::TLSOPT_NONE; 1649 1650 switch (r_type) 1651 { 1652 case elfcpp::R_386_TLS_GD: 1653 case elfcpp::R_386_TLS_GOTDESC: 1654 case elfcpp::R_386_TLS_DESC_CALL: 1655 // These are General-Dynamic which permits fully general TLS 1656 // access. Since we know that we are generating an executable, 1657 // we can convert this to Initial-Exec. If we also know that 1658 // this is a local symbol, we can further switch to Local-Exec. 1659 if (is_final) 1660 return tls::TLSOPT_TO_LE; 1661 return tls::TLSOPT_TO_IE; 1662 1663 case elfcpp::R_386_TLS_LDM: 1664 // This is Local-Dynamic, which refers to a local symbol in the 1665 // dynamic TLS block. Since we know that we generating an 1666 // executable, we can switch to Local-Exec. 1667 return tls::TLSOPT_TO_LE; 1668 1669 case elfcpp::R_386_TLS_LDO_32: 1670 // Another type of Local-Dynamic relocation. 1671 return tls::TLSOPT_TO_LE; 1672 1673 case elfcpp::R_386_TLS_IE: 1674 case elfcpp::R_386_TLS_GOTIE: 1675 case elfcpp::R_386_TLS_IE_32: 1676 // These are Initial-Exec relocs which get the thread offset 1677 // from the GOT. If we know that we are linking against the 1678 // local symbol, we can switch to Local-Exec, which links the 1679 // thread offset into the instruction. 1680 if (is_final) 1681 return tls::TLSOPT_TO_LE; 1682 return tls::TLSOPT_NONE; 1683 1684 case elfcpp::R_386_TLS_LE: 1685 case elfcpp::R_386_TLS_LE_32: 1686 // When we already have Local-Exec, there is nothing further we 1687 // can do. 1688 return tls::TLSOPT_NONE; 1689 1690 default: 1691 gold_unreachable(); 1692 } 1693} 1694 1695// Get the Reference_flags for a particular relocation. 1696 1697int 1698Target_i386::Scan::get_reference_flags(unsigned int r_type) 1699{ 1700 switch (r_type) 1701 { 1702 case elfcpp::R_386_NONE: 1703 case elfcpp::R_386_GNU_VTINHERIT: 1704 case elfcpp::R_386_GNU_VTENTRY: 1705 case elfcpp::R_386_GOTPC: 1706 // No symbol reference. 1707 return 0; 1708 1709 case elfcpp::R_386_32: 1710 case elfcpp::R_386_16: 1711 case elfcpp::R_386_8: 1712 return Symbol::ABSOLUTE_REF; 1713 1714 case elfcpp::R_386_PC32: 1715 case elfcpp::R_386_PC16: 1716 case elfcpp::R_386_PC8: 1717 case elfcpp::R_386_GOTOFF: 1718 return Symbol::RELATIVE_REF; 1719 1720 case elfcpp::R_386_PLT32: 1721 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF; 1722 1723 case elfcpp::R_386_GOT32: 1724 case elfcpp::R_386_GOT32X: 1725 // Absolute in GOT. 1726 return Symbol::ABSOLUTE_REF; 1727 1728 case elfcpp::R_386_TLS_GD: // Global-dynamic 1729 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 1730 case elfcpp::R_386_TLS_DESC_CALL: 1731 case elfcpp::R_386_TLS_LDM: // Local-dynamic 1732 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 1733 case elfcpp::R_386_TLS_IE: // Initial-exec 1734 case elfcpp::R_386_TLS_IE_32: 1735 case elfcpp::R_386_TLS_GOTIE: 1736 case elfcpp::R_386_TLS_LE: // Local-exec 1737 case elfcpp::R_386_TLS_LE_32: 1738 return Symbol::TLS_REF; 1739 1740 case elfcpp::R_386_COPY: 1741 case elfcpp::R_386_GLOB_DAT: 1742 case elfcpp::R_386_JUMP_SLOT: 1743 case elfcpp::R_386_RELATIVE: 1744 case elfcpp::R_386_IRELATIVE: 1745 case elfcpp::R_386_TLS_TPOFF: 1746 case elfcpp::R_386_TLS_DTPMOD32: 1747 case elfcpp::R_386_TLS_DTPOFF32: 1748 case elfcpp::R_386_TLS_TPOFF32: 1749 case elfcpp::R_386_TLS_DESC: 1750 case elfcpp::R_386_32PLT: 1751 case elfcpp::R_386_TLS_GD_32: 1752 case elfcpp::R_386_TLS_GD_PUSH: 1753 case elfcpp::R_386_TLS_GD_CALL: 1754 case elfcpp::R_386_TLS_GD_POP: 1755 case elfcpp::R_386_TLS_LDM_32: 1756 case elfcpp::R_386_TLS_LDM_PUSH: 1757 case elfcpp::R_386_TLS_LDM_CALL: 1758 case elfcpp::R_386_TLS_LDM_POP: 1759 case elfcpp::R_386_USED_BY_INTEL_200: 1760 default: 1761 // Not expected. We will give an error later. 1762 return 0; 1763 } 1764} 1765 1766// Report an unsupported relocation against a local symbol. 1767 1768void 1769Target_i386::Scan::unsupported_reloc_local(Sized_relobj_file<32, false>* object, 1770 unsigned int r_type) 1771{ 1772 gold_error(_("%s: unsupported reloc %u against local symbol"), 1773 object->name().c_str(), r_type); 1774} 1775 1776// Return whether we need to make a PLT entry for a relocation of a 1777// given type against a STT_GNU_IFUNC symbol. 1778 1779bool 1780Target_i386::Scan::reloc_needs_plt_for_ifunc( 1781 Sized_relobj_file<32, false>* object, 1782 unsigned int r_type) 1783{ 1784 int flags = Scan::get_reference_flags(r_type); 1785 if (flags & Symbol::TLS_REF) 1786 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"), 1787 object->name().c_str(), r_type); 1788 return flags != 0; 1789} 1790 1791// Scan a relocation for a local symbol. 1792 1793inline void 1794Target_i386::Scan::local(Symbol_table* symtab, 1795 Layout* layout, 1796 Target_i386* target, 1797 Sized_relobj_file<32, false>* object, 1798 unsigned int data_shndx, 1799 Output_section* output_section, 1800 const elfcpp::Rel<32, false>& reloc, 1801 unsigned int r_type, 1802 const elfcpp::Sym<32, false>& lsym, 1803 bool is_discarded) 1804{ 1805 if (is_discarded) 1806 return; 1807 1808 // A local STT_GNU_IFUNC symbol may require a PLT entry. 1809 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC 1810 && this->reloc_needs_plt_for_ifunc(object, r_type)) 1811 { 1812 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1813 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym); 1814 } 1815 1816 switch (r_type) 1817 { 1818 case elfcpp::R_386_NONE: 1819 case elfcpp::R_386_GNU_VTINHERIT: 1820 case elfcpp::R_386_GNU_VTENTRY: 1821 break; 1822 1823 case elfcpp::R_386_32: 1824 // If building a shared library (or a position-independent 1825 // executable), we need to create a dynamic relocation for 1826 // this location. The relocation applied at link time will 1827 // apply the link-time value, so we flag the location with 1828 // an R_386_RELATIVE relocation so the dynamic loader can 1829 // relocate it easily. 1830 if (parameters->options().output_is_position_independent()) 1831 { 1832 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 1833 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1834 rel_dyn->add_local_relative(object, r_sym, elfcpp::R_386_RELATIVE, 1835 output_section, data_shndx, 1836 reloc.get_r_offset()); 1837 } 1838 break; 1839 1840 case elfcpp::R_386_16: 1841 case elfcpp::R_386_8: 1842 // If building a shared library (or a position-independent 1843 // executable), we need to create a dynamic relocation for 1844 // this location. Because the addend needs to remain in the 1845 // data section, we need to be careful not to apply this 1846 // relocation statically. 1847 if (parameters->options().output_is_position_independent()) 1848 { 1849 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 1850 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1851 if (lsym.get_st_type() != elfcpp::STT_SECTION) 1852 rel_dyn->add_local(object, r_sym, r_type, output_section, 1853 data_shndx, reloc.get_r_offset()); 1854 else 1855 { 1856 gold_assert(lsym.get_st_value() == 0); 1857 unsigned int shndx = lsym.get_st_shndx(); 1858 bool is_ordinary; 1859 shndx = object->adjust_sym_shndx(r_sym, shndx, 1860 &is_ordinary); 1861 if (!is_ordinary) 1862 object->error(_("section symbol %u has bad shndx %u"), 1863 r_sym, shndx); 1864 else 1865 rel_dyn->add_local_section(object, shndx, 1866 r_type, output_section, 1867 data_shndx, reloc.get_r_offset()); 1868 } 1869 } 1870 break; 1871 1872 case elfcpp::R_386_PC32: 1873 case elfcpp::R_386_PC16: 1874 case elfcpp::R_386_PC8: 1875 break; 1876 1877 case elfcpp::R_386_PLT32: 1878 // Since we know this is a local symbol, we can handle this as a 1879 // PC32 reloc. 1880 break; 1881 1882 case elfcpp::R_386_GOTOFF: 1883 case elfcpp::R_386_GOTPC: 1884 // We need a GOT section. 1885 target->got_section(symtab, layout); 1886 break; 1887 1888 case elfcpp::R_386_GOT32: 1889 case elfcpp::R_386_GOT32X: 1890 { 1891 // We need GOT section. 1892 Output_data_got<32, false>* got = target->got_section(symtab, layout); 1893 1894 // If the relocation symbol isn't IFUNC, 1895 // and is local, then we will convert 1896 // mov foo@GOT(%reg), %reg 1897 // to 1898 // lea foo@GOTOFF(%reg), %reg 1899 // in Relocate::relocate. 1900 if (reloc.get_r_offset() >= 2 1901 && lsym.get_st_type() != elfcpp::STT_GNU_IFUNC) 1902 { 1903 section_size_type stype; 1904 const unsigned char* view = object->section_contents(data_shndx, 1905 &stype, true); 1906 if (view[reloc.get_r_offset() - 2] == 0x8b) 1907 break; 1908 } 1909 1910 // Otherwise, the symbol requires a GOT entry. 1911 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1912 1913 // For a STT_GNU_IFUNC symbol we want the PLT offset. That 1914 // lets function pointers compare correctly with shared 1915 // libraries. Otherwise we would need an IRELATIVE reloc. 1916 bool is_new; 1917 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC) 1918 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD); 1919 else 1920 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD); 1921 if (is_new) 1922 { 1923 // If we are generating a shared object, we need to add a 1924 // dynamic RELATIVE relocation for this symbol's GOT entry. 1925 if (parameters->options().output_is_position_independent()) 1926 { 1927 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 1928 unsigned int got_offset = 1929 object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 1930 rel_dyn->add_local_relative(object, r_sym, 1931 elfcpp::R_386_RELATIVE, 1932 got, got_offset); 1933 } 1934 } 1935 } 1936 break; 1937 1938 // These are relocations which should only be seen by the 1939 // dynamic linker, and should never be seen here. 1940 case elfcpp::R_386_COPY: 1941 case elfcpp::R_386_GLOB_DAT: 1942 case elfcpp::R_386_JUMP_SLOT: 1943 case elfcpp::R_386_RELATIVE: 1944 case elfcpp::R_386_IRELATIVE: 1945 case elfcpp::R_386_TLS_TPOFF: 1946 case elfcpp::R_386_TLS_DTPMOD32: 1947 case elfcpp::R_386_TLS_DTPOFF32: 1948 case elfcpp::R_386_TLS_TPOFF32: 1949 case elfcpp::R_386_TLS_DESC: 1950 gold_error(_("%s: unexpected reloc %u in object file"), 1951 object->name().c_str(), r_type); 1952 break; 1953 1954 // These are initial TLS relocs, which are expected when 1955 // linking. 1956 case elfcpp::R_386_TLS_GD: // Global-dynamic 1957 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 1958 case elfcpp::R_386_TLS_DESC_CALL: 1959 case elfcpp::R_386_TLS_LDM: // Local-dynamic 1960 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 1961 case elfcpp::R_386_TLS_IE: // Initial-exec 1962 case elfcpp::R_386_TLS_IE_32: 1963 case elfcpp::R_386_TLS_GOTIE: 1964 case elfcpp::R_386_TLS_LE: // Local-exec 1965 case elfcpp::R_386_TLS_LE_32: 1966 { 1967 bool output_is_shared = parameters->options().shared(); 1968 const tls::Tls_optimization optimized_type 1969 = Target_i386::optimize_tls_reloc(!output_is_shared, r_type); 1970 switch (r_type) 1971 { 1972 case elfcpp::R_386_TLS_GD: // Global-dynamic 1973 if (optimized_type == tls::TLSOPT_NONE) 1974 { 1975 // Create a pair of GOT entries for the module index and 1976 // dtv-relative offset. 1977 Output_data_got<32, false>* got 1978 = target->got_section(symtab, layout); 1979 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 1980 unsigned int shndx = lsym.get_st_shndx(); 1981 bool is_ordinary; 1982 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary); 1983 if (!is_ordinary) 1984 object->error(_("local symbol %u has bad shndx %u"), 1985 r_sym, shndx); 1986 else 1987 got->add_local_pair_with_rel(object, r_sym, shndx, 1988 GOT_TYPE_TLS_PAIR, 1989 target->rel_dyn_section(layout), 1990 elfcpp::R_386_TLS_DTPMOD32); 1991 } 1992 else if (optimized_type != tls::TLSOPT_TO_LE) 1993 unsupported_reloc_local(object, r_type); 1994 break; 1995 1996 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva) 1997 target->define_tls_base_symbol(symtab, layout); 1998 if (optimized_type == tls::TLSOPT_NONE) 1999 { 2000 // Create a double GOT entry with an R_386_TLS_DESC 2001 // reloc. The R_386_TLS_DESC reloc is resolved 2002 // lazily, so the GOT entry needs to be in an area in 2003 // .got.plt, not .got. Call got_section to make sure 2004 // the section has been created. 2005 target->got_section(symtab, layout); 2006 Output_data_got<32, false>* got = target->got_tlsdesc_section(); 2007 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2008 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC)) 2009 { 2010 unsigned int got_offset = got->add_constant(0); 2011 // The local symbol value is stored in the second 2012 // GOT entry. 2013 got->add_local(object, r_sym, GOT_TYPE_TLS_DESC); 2014 // That set the GOT offset of the local symbol to 2015 // point to the second entry, but we want it to 2016 // point to the first. 2017 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC, 2018 got_offset); 2019 Reloc_section* rt = target->rel_tls_desc_section(layout); 2020 rt->add_absolute(elfcpp::R_386_TLS_DESC, got, got_offset); 2021 } 2022 } 2023 else if (optimized_type != tls::TLSOPT_TO_LE) 2024 unsupported_reloc_local(object, r_type); 2025 break; 2026 2027 case elfcpp::R_386_TLS_DESC_CALL: 2028 break; 2029 2030 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2031 if (optimized_type == tls::TLSOPT_NONE) 2032 { 2033 // Create a GOT entry for the module index. 2034 target->got_mod_index_entry(symtab, layout, object); 2035 } 2036 else if (optimized_type != tls::TLSOPT_TO_LE) 2037 unsupported_reloc_local(object, r_type); 2038 break; 2039 2040 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2041 break; 2042 2043 case elfcpp::R_386_TLS_IE: // Initial-exec 2044 case elfcpp::R_386_TLS_IE_32: 2045 case elfcpp::R_386_TLS_GOTIE: 2046 layout->set_has_static_tls(); 2047 if (optimized_type == tls::TLSOPT_NONE) 2048 { 2049 // For the R_386_TLS_IE relocation, we need to create a 2050 // dynamic relocation when building a shared library. 2051 if (r_type == elfcpp::R_386_TLS_IE 2052 && parameters->options().shared()) 2053 { 2054 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2055 unsigned int r_sym 2056 = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2057 rel_dyn->add_local_relative(object, r_sym, 2058 elfcpp::R_386_RELATIVE, 2059 output_section, data_shndx, 2060 reloc.get_r_offset()); 2061 } 2062 // Create a GOT entry for the tp-relative offset. 2063 Output_data_got<32, false>* got 2064 = target->got_section(symtab, layout); 2065 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2066 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32 2067 ? elfcpp::R_386_TLS_TPOFF32 2068 : elfcpp::R_386_TLS_TPOFF); 2069 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32 2070 ? GOT_TYPE_TLS_OFFSET 2071 : GOT_TYPE_TLS_NOFFSET); 2072 got->add_local_with_rel(object, r_sym, got_type, 2073 target->rel_dyn_section(layout), 2074 dyn_r_type); 2075 } 2076 else if (optimized_type != tls::TLSOPT_TO_LE) 2077 unsupported_reloc_local(object, r_type); 2078 break; 2079 2080 case elfcpp::R_386_TLS_LE: // Local-exec 2081 case elfcpp::R_386_TLS_LE_32: 2082 layout->set_has_static_tls(); 2083 if (output_is_shared) 2084 { 2085 // We need to create a dynamic relocation. 2086 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION); 2087 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); 2088 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32 2089 ? elfcpp::R_386_TLS_TPOFF32 2090 : elfcpp::R_386_TLS_TPOFF); 2091 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2092 rel_dyn->add_local(object, r_sym, dyn_r_type, output_section, 2093 data_shndx, reloc.get_r_offset()); 2094 } 2095 break; 2096 2097 default: 2098 gold_unreachable(); 2099 } 2100 } 2101 break; 2102 2103 case elfcpp::R_386_32PLT: 2104 case elfcpp::R_386_TLS_GD_32: 2105 case elfcpp::R_386_TLS_GD_PUSH: 2106 case elfcpp::R_386_TLS_GD_CALL: 2107 case elfcpp::R_386_TLS_GD_POP: 2108 case elfcpp::R_386_TLS_LDM_32: 2109 case elfcpp::R_386_TLS_LDM_PUSH: 2110 case elfcpp::R_386_TLS_LDM_CALL: 2111 case elfcpp::R_386_TLS_LDM_POP: 2112 case elfcpp::R_386_USED_BY_INTEL_200: 2113 default: 2114 unsupported_reloc_local(object, r_type); 2115 break; 2116 } 2117} 2118 2119// Report an unsupported relocation against a global symbol. 2120 2121void 2122Target_i386::Scan::unsupported_reloc_global( 2123 Sized_relobj_file<32, false>* object, 2124 unsigned int r_type, 2125 Symbol* gsym) 2126{ 2127 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 2128 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 2129} 2130 2131inline bool 2132Target_i386::Scan::possible_function_pointer_reloc(unsigned int r_type) 2133{ 2134 switch (r_type) 2135 { 2136 case elfcpp::R_386_32: 2137 case elfcpp::R_386_16: 2138 case elfcpp::R_386_8: 2139 case elfcpp::R_386_GOTOFF: 2140 case elfcpp::R_386_GOT32: 2141 case elfcpp::R_386_GOT32X: 2142 { 2143 return true; 2144 } 2145 default: 2146 return false; 2147 } 2148 return false; 2149} 2150 2151inline bool 2152Target_i386::Scan::local_reloc_may_be_function_pointer( 2153 Symbol_table* , 2154 Layout* , 2155 Target_i386* , 2156 Sized_relobj_file<32, false>* , 2157 unsigned int , 2158 Output_section* , 2159 const elfcpp::Rel<32, false>& , 2160 unsigned int r_type, 2161 const elfcpp::Sym<32, false>&) 2162{ 2163 return possible_function_pointer_reloc(r_type); 2164} 2165 2166inline bool 2167Target_i386::Scan::global_reloc_may_be_function_pointer( 2168 Symbol_table* , 2169 Layout* , 2170 Target_i386* , 2171 Sized_relobj_file<32, false>* , 2172 unsigned int , 2173 Output_section* , 2174 const elfcpp::Rel<32, false>& , 2175 unsigned int r_type, 2176 Symbol*) 2177{ 2178 return possible_function_pointer_reloc(r_type); 2179} 2180 2181// Scan a relocation for a global symbol. 2182 2183inline void 2184Target_i386::Scan::global(Symbol_table* symtab, 2185 Layout* layout, 2186 Target_i386* target, 2187 Sized_relobj_file<32, false>* object, 2188 unsigned int data_shndx, 2189 Output_section* output_section, 2190 const elfcpp::Rel<32, false>& reloc, 2191 unsigned int r_type, 2192 Symbol* gsym) 2193{ 2194 // A STT_GNU_IFUNC symbol may require a PLT entry. 2195 if (gsym->type() == elfcpp::STT_GNU_IFUNC 2196 && this->reloc_needs_plt_for_ifunc(object, r_type)) 2197 target->make_plt_entry(symtab, layout, gsym); 2198 2199 switch (r_type) 2200 { 2201 case elfcpp::R_386_NONE: 2202 case elfcpp::R_386_GNU_VTINHERIT: 2203 case elfcpp::R_386_GNU_VTENTRY: 2204 break; 2205 2206 case elfcpp::R_386_32: 2207 case elfcpp::R_386_16: 2208 case elfcpp::R_386_8: 2209 { 2210 // Make a PLT entry if necessary. 2211 if (gsym->needs_plt_entry()) 2212 { 2213 target->make_plt_entry(symtab, layout, gsym); 2214 // Since this is not a PC-relative relocation, we may be 2215 // taking the address of a function. In that case we need to 2216 // set the entry in the dynamic symbol table to the address of 2217 // the PLT entry. 2218 if (gsym->is_from_dynobj() && !parameters->options().shared()) 2219 gsym->set_needs_dynsym_value(); 2220 } 2221 // Make a dynamic relocation if necessary. 2222 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 2223 { 2224 if (!parameters->options().output_is_position_independent() 2225 && gsym->may_need_copy_reloc()) 2226 { 2227 target->copy_reloc(symtab, layout, object, 2228 data_shndx, output_section, gsym, reloc); 2229 } 2230 else if (r_type == elfcpp::R_386_32 2231 && gsym->type() == elfcpp::STT_GNU_IFUNC 2232 && gsym->can_use_relative_reloc(false) 2233 && !gsym->is_from_dynobj() 2234 && !gsym->is_undefined() 2235 && !gsym->is_preemptible()) 2236 { 2237 // Use an IRELATIVE reloc for a locally defined 2238 // STT_GNU_IFUNC symbol. This makes a function 2239 // address in a PIE executable match the address in a 2240 // shared library that it links against. 2241 Reloc_section* rel_dyn = target->rel_irelative_section(layout); 2242 rel_dyn->add_symbolless_global_addend(gsym, 2243 elfcpp::R_386_IRELATIVE, 2244 output_section, 2245 object, data_shndx, 2246 reloc.get_r_offset()); 2247 } 2248 else if (r_type == elfcpp::R_386_32 2249 && gsym->can_use_relative_reloc(false)) 2250 { 2251 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2252 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE, 2253 output_section, object, 2254 data_shndx, reloc.get_r_offset()); 2255 } 2256 else 2257 { 2258 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2259 rel_dyn->add_global(gsym, r_type, output_section, object, 2260 data_shndx, reloc.get_r_offset()); 2261 } 2262 } 2263 } 2264 break; 2265 2266 case elfcpp::R_386_PC32: 2267 case elfcpp::R_386_PC16: 2268 case elfcpp::R_386_PC8: 2269 { 2270 // Make a PLT entry if necessary. 2271 if (gsym->needs_plt_entry()) 2272 { 2273 // These relocations are used for function calls only in 2274 // non-PIC code. For a 32-bit relocation in a shared library, 2275 // we'll need a text relocation anyway, so we can skip the 2276 // PLT entry and let the dynamic linker bind the call directly 2277 // to the target. For smaller relocations, we should use a 2278 // PLT entry to ensure that the call can reach. 2279 if (!parameters->options().shared() 2280 || r_type != elfcpp::R_386_PC32) 2281 target->make_plt_entry(symtab, layout, gsym); 2282 } 2283 // Make a dynamic relocation if necessary. 2284 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 2285 { 2286 if (parameters->options().output_is_executable() 2287 && gsym->may_need_copy_reloc()) 2288 { 2289 target->copy_reloc(symtab, layout, object, 2290 data_shndx, output_section, gsym, reloc); 2291 } 2292 else 2293 { 2294 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2295 rel_dyn->add_global(gsym, r_type, output_section, object, 2296 data_shndx, reloc.get_r_offset()); 2297 } 2298 } 2299 } 2300 break; 2301 2302 case elfcpp::R_386_GOT32: 2303 case elfcpp::R_386_GOT32X: 2304 { 2305 // The symbol requires a GOT section. 2306 Output_data_got<32, false>* got = target->got_section(symtab, layout); 2307 2308 // If we convert this from 2309 // mov foo@GOT(%reg), %reg 2310 // to 2311 // lea foo@GOTOFF(%reg), %reg 2312 // in Relocate::relocate, then there is nothing to do here. 2313 if (reloc.get_r_offset() >= 2 2314 && Target_i386::can_convert_mov_to_lea(gsym)) 2315 { 2316 section_size_type stype; 2317 const unsigned char* view = object->section_contents(data_shndx, 2318 &stype, true); 2319 if (view[reloc.get_r_offset() - 2] == 0x8b) 2320 break; 2321 } 2322 2323 if (gsym->final_value_is_known()) 2324 { 2325 // For a STT_GNU_IFUNC symbol we want the PLT address. 2326 if (gsym->type() == elfcpp::STT_GNU_IFUNC) 2327 got->add_global_plt(gsym, GOT_TYPE_STANDARD); 2328 else 2329 got->add_global(gsym, GOT_TYPE_STANDARD); 2330 } 2331 else 2332 { 2333 // If this symbol is not fully resolved, we need to add a 2334 // GOT entry with a dynamic relocation. 2335 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2336 2337 // Use a GLOB_DAT rather than a RELATIVE reloc if: 2338 // 2339 // 1) The symbol may be defined in some other module. 2340 // 2341 // 2) We are building a shared library and this is a 2342 // protected symbol; using GLOB_DAT means that the dynamic 2343 // linker can use the address of the PLT in the main 2344 // executable when appropriate so that function address 2345 // comparisons work. 2346 // 2347 // 3) This is a STT_GNU_IFUNC symbol in position dependent 2348 // code, again so that function address comparisons work. 2349 if (gsym->is_from_dynobj() 2350 || gsym->is_undefined() 2351 || gsym->is_preemptible() 2352 || (gsym->visibility() == elfcpp::STV_PROTECTED 2353 && parameters->options().shared()) 2354 || (gsym->type() == elfcpp::STT_GNU_IFUNC 2355 && parameters->options().output_is_position_independent())) 2356 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, 2357 rel_dyn, elfcpp::R_386_GLOB_DAT); 2358 else 2359 { 2360 // For a STT_GNU_IFUNC symbol we want to write the PLT 2361 // offset into the GOT, so that function pointer 2362 // comparisons work correctly. 2363 bool is_new; 2364 if (gsym->type() != elfcpp::STT_GNU_IFUNC) 2365 is_new = got->add_global(gsym, GOT_TYPE_STANDARD); 2366 else 2367 { 2368 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD); 2369 // Tell the dynamic linker to use the PLT address 2370 // when resolving relocations. 2371 if (gsym->is_from_dynobj() 2372 && !parameters->options().shared()) 2373 gsym->set_needs_dynsym_value(); 2374 } 2375 if (is_new) 2376 { 2377 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD); 2378 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE, 2379 got, got_off); 2380 } 2381 } 2382 } 2383 } 2384 break; 2385 2386 case elfcpp::R_386_PLT32: 2387 // If the symbol is fully resolved, this is just a PC32 reloc. 2388 // Otherwise we need a PLT entry. 2389 if (gsym->final_value_is_known()) 2390 break; 2391 // If building a shared library, we can also skip the PLT entry 2392 // if the symbol is defined in the output file and is protected 2393 // or hidden. 2394 if (gsym->is_defined() 2395 && !gsym->is_from_dynobj() 2396 && !gsym->is_preemptible()) 2397 break; 2398 target->make_plt_entry(symtab, layout, gsym); 2399 break; 2400 2401 case elfcpp::R_386_GOTOFF: 2402 // A GOT-relative reference must resolve locally. 2403 if (!gsym->is_defined()) 2404 gold_error(_("%s: relocation R_386_GOTOFF against undefined symbol %s" 2405 " cannot be used when making a shared object"), 2406 object->name().c_str(), gsym->name()); 2407 else if (gsym->is_from_dynobj()) 2408 gold_error(_("%s: relocation R_386_GOTOFF against external symbol %s" 2409 " cannot be used when making a shared object"), 2410 object->name().c_str(), gsym->name()); 2411 else if (gsym->is_preemptible()) 2412 gold_error(_("%s: relocation R_386_GOTOFF against preemptible symbol %s" 2413 " cannot be used when making a shared object"), 2414 object->name().c_str(), gsym->name()); 2415 // We need a GOT section. 2416 target->got_section(symtab, layout); 2417 break; 2418 2419 case elfcpp::R_386_GOTPC: 2420 // We need a GOT section. 2421 target->got_section(symtab, layout); 2422 break; 2423 2424 // These are relocations which should only be seen by the 2425 // dynamic linker, and should never be seen here. 2426 case elfcpp::R_386_COPY: 2427 case elfcpp::R_386_GLOB_DAT: 2428 case elfcpp::R_386_JUMP_SLOT: 2429 case elfcpp::R_386_RELATIVE: 2430 case elfcpp::R_386_IRELATIVE: 2431 case elfcpp::R_386_TLS_TPOFF: 2432 case elfcpp::R_386_TLS_DTPMOD32: 2433 case elfcpp::R_386_TLS_DTPOFF32: 2434 case elfcpp::R_386_TLS_TPOFF32: 2435 case elfcpp::R_386_TLS_DESC: 2436 gold_error(_("%s: unexpected reloc %u in object file"), 2437 object->name().c_str(), r_type); 2438 break; 2439 2440 // These are initial tls relocs, which are expected when 2441 // linking. 2442 case elfcpp::R_386_TLS_GD: // Global-dynamic 2443 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url) 2444 case elfcpp::R_386_TLS_DESC_CALL: 2445 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2446 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2447 case elfcpp::R_386_TLS_IE: // Initial-exec 2448 case elfcpp::R_386_TLS_IE_32: 2449 case elfcpp::R_386_TLS_GOTIE: 2450 case elfcpp::R_386_TLS_LE: // Local-exec 2451 case elfcpp::R_386_TLS_LE_32: 2452 { 2453 const bool is_final = gsym->final_value_is_known(); 2454 const tls::Tls_optimization optimized_type 2455 = Target_i386::optimize_tls_reloc(is_final, r_type); 2456 switch (r_type) 2457 { 2458 case elfcpp::R_386_TLS_GD: // Global-dynamic 2459 if (optimized_type == tls::TLSOPT_NONE) 2460 { 2461 // Create a pair of GOT entries for the module index and 2462 // dtv-relative offset. 2463 Output_data_got<32, false>* got 2464 = target->got_section(symtab, layout); 2465 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR, 2466 target->rel_dyn_section(layout), 2467 elfcpp::R_386_TLS_DTPMOD32, 2468 elfcpp::R_386_TLS_DTPOFF32); 2469 } 2470 else if (optimized_type == tls::TLSOPT_TO_IE) 2471 { 2472 // Create a GOT entry for the tp-relative offset. 2473 Output_data_got<32, false>* got 2474 = target->got_section(symtab, layout); 2475 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET, 2476 target->rel_dyn_section(layout), 2477 elfcpp::R_386_TLS_TPOFF); 2478 } 2479 else if (optimized_type != tls::TLSOPT_TO_LE) 2480 unsupported_reloc_global(object, r_type, gsym); 2481 break; 2482 2483 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (~oliva url) 2484 target->define_tls_base_symbol(symtab, layout); 2485 if (optimized_type == tls::TLSOPT_NONE) 2486 { 2487 // Create a double GOT entry with an R_386_TLS_DESC 2488 // reloc. The R_386_TLS_DESC reloc is resolved 2489 // lazily, so the GOT entry needs to be in an area in 2490 // .got.plt, not .got. Call got_section to make sure 2491 // the section has been created. 2492 target->got_section(symtab, layout); 2493 Output_data_got<32, false>* got = target->got_tlsdesc_section(); 2494 Reloc_section* rt = target->rel_tls_desc_section(layout); 2495 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt, 2496 elfcpp::R_386_TLS_DESC, 0); 2497 } 2498 else if (optimized_type == tls::TLSOPT_TO_IE) 2499 { 2500 // Create a GOT entry for the tp-relative offset. 2501 Output_data_got<32, false>* got 2502 = target->got_section(symtab, layout); 2503 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET, 2504 target->rel_dyn_section(layout), 2505 elfcpp::R_386_TLS_TPOFF); 2506 } 2507 else if (optimized_type != tls::TLSOPT_TO_LE) 2508 unsupported_reloc_global(object, r_type, gsym); 2509 break; 2510 2511 case elfcpp::R_386_TLS_DESC_CALL: 2512 break; 2513 2514 case elfcpp::R_386_TLS_LDM: // Local-dynamic 2515 if (optimized_type == tls::TLSOPT_NONE) 2516 { 2517 // Create a GOT entry for the module index. 2518 target->got_mod_index_entry(symtab, layout, object); 2519 } 2520 else if (optimized_type != tls::TLSOPT_TO_LE) 2521 unsupported_reloc_global(object, r_type, gsym); 2522 break; 2523 2524 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic 2525 break; 2526 2527 case elfcpp::R_386_TLS_IE: // Initial-exec 2528 case elfcpp::R_386_TLS_IE_32: 2529 case elfcpp::R_386_TLS_GOTIE: 2530 layout->set_has_static_tls(); 2531 if (optimized_type == tls::TLSOPT_NONE) 2532 { 2533 // For the R_386_TLS_IE relocation, we need to create a 2534 // dynamic relocation when building a shared library. 2535 if (r_type == elfcpp::R_386_TLS_IE 2536 && parameters->options().shared()) 2537 { 2538 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2539 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE, 2540 output_section, object, 2541 data_shndx, 2542 reloc.get_r_offset()); 2543 } 2544 // Create a GOT entry for the tp-relative offset. 2545 Output_data_got<32, false>* got 2546 = target->got_section(symtab, layout); 2547 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32 2548 ? elfcpp::R_386_TLS_TPOFF32 2549 : elfcpp::R_386_TLS_TPOFF); 2550 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32 2551 ? GOT_TYPE_TLS_OFFSET 2552 : GOT_TYPE_TLS_NOFFSET); 2553 got->add_global_with_rel(gsym, got_type, 2554 target->rel_dyn_section(layout), 2555 dyn_r_type); 2556 } 2557 else if (optimized_type != tls::TLSOPT_TO_LE) 2558 unsupported_reloc_global(object, r_type, gsym); 2559 break; 2560 2561 case elfcpp::R_386_TLS_LE: // Local-exec 2562 case elfcpp::R_386_TLS_LE_32: 2563 layout->set_has_static_tls(); 2564 if (parameters->options().shared()) 2565 { 2566 // We need to create a dynamic relocation. 2567 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32 2568 ? elfcpp::R_386_TLS_TPOFF32 2569 : elfcpp::R_386_TLS_TPOFF); 2570 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 2571 rel_dyn->add_global(gsym, dyn_r_type, output_section, object, 2572 data_shndx, reloc.get_r_offset()); 2573 } 2574 break; 2575 2576 default: 2577 gold_unreachable(); 2578 } 2579 } 2580 break; 2581 2582 case elfcpp::R_386_32PLT: 2583 case elfcpp::R_386_TLS_GD_32: 2584 case elfcpp::R_386_TLS_GD_PUSH: 2585 case elfcpp::R_386_TLS_GD_CALL: 2586 case elfcpp::R_386_TLS_GD_POP: 2587 case elfcpp::R_386_TLS_LDM_32: 2588 case elfcpp::R_386_TLS_LDM_PUSH: 2589 case elfcpp::R_386_TLS_LDM_CALL: 2590 case elfcpp::R_386_TLS_LDM_POP: 2591 case elfcpp::R_386_USED_BY_INTEL_200: 2592 default: 2593 unsupported_reloc_global(object, r_type, gsym); 2594 break; 2595 } 2596} 2597 2598// Process relocations for gc. 2599 2600void 2601Target_i386::gc_process_relocs(Symbol_table* symtab, 2602 Layout* layout, 2603 Sized_relobj_file<32, false>* object, 2604 unsigned int data_shndx, 2605 unsigned int, 2606 const unsigned char* prelocs, 2607 size_t reloc_count, 2608 Output_section* output_section, 2609 bool needs_special_offset_handling, 2610 size_t local_symbol_count, 2611 const unsigned char* plocal_symbols) 2612{ 2613 gold::gc_process_relocs<32, false, Target_i386, Scan, Classify_reloc>( 2614 symtab, 2615 layout, 2616 this, 2617 object, 2618 data_shndx, 2619 prelocs, 2620 reloc_count, 2621 output_section, 2622 needs_special_offset_handling, 2623 local_symbol_count, 2624 plocal_symbols); 2625} 2626 2627// Scan relocations for a section. 2628 2629void 2630Target_i386::scan_relocs(Symbol_table* symtab, 2631 Layout* layout, 2632 Sized_relobj_file<32, false>* object, 2633 unsigned int data_shndx, 2634 unsigned int sh_type, 2635 const unsigned char* prelocs, 2636 size_t reloc_count, 2637 Output_section* output_section, 2638 bool needs_special_offset_handling, 2639 size_t local_symbol_count, 2640 const unsigned char* plocal_symbols) 2641{ 2642 if (sh_type == elfcpp::SHT_RELA) 2643 { 2644 gold_error(_("%s: unsupported RELA reloc section"), 2645 object->name().c_str()); 2646 return; 2647 } 2648 2649 gold::scan_relocs<32, false, Target_i386, Scan, Classify_reloc>( 2650 symtab, 2651 layout, 2652 this, 2653 object, 2654 data_shndx, 2655 prelocs, 2656 reloc_count, 2657 output_section, 2658 needs_special_offset_handling, 2659 local_symbol_count, 2660 plocal_symbols); 2661} 2662 2663// Finalize the sections. 2664 2665void 2666Target_i386::do_finalize_sections( 2667 Layout* layout, 2668 const Input_objects*, 2669 Symbol_table* symtab) 2670{ 2671 const Reloc_section* rel_plt = (this->plt_ == NULL 2672 ? NULL 2673 : this->plt_->rel_plt()); 2674 layout->add_target_dynamic_tags(true, this->got_plt_, rel_plt, 2675 this->rel_dyn_, true, false); 2676 2677 // Emit any relocs we saved in an attempt to avoid generating COPY 2678 // relocs. 2679 if (this->copy_relocs_.any_saved_relocs()) 2680 this->copy_relocs_.emit(this->rel_dyn_section(layout)); 2681 2682 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of 2683 // the .got.plt section. 2684 Symbol* sym = this->global_offset_table_; 2685 if (sym != NULL) 2686 { 2687 uint32_t data_size = this->got_plt_->current_data_size(); 2688 symtab->get_sized_symbol<32>(sym)->set_symsize(data_size); 2689 } 2690 2691 if (parameters->doing_static_link() 2692 && (this->plt_ == NULL || !this->plt_->has_irelative_section())) 2693 { 2694 // If linking statically, make sure that the __rel_iplt symbols 2695 // were defined if necessary, even if we didn't create a PLT. 2696 static const Define_symbol_in_segment syms[] = 2697 { 2698 { 2699 "__rel_iplt_start", // name 2700 elfcpp::PT_LOAD, // segment_type 2701 elfcpp::PF_W, // segment_flags_set 2702 elfcpp::PF(0), // segment_flags_clear 2703 0, // value 2704 0, // size 2705 elfcpp::STT_NOTYPE, // type 2706 elfcpp::STB_GLOBAL, // binding 2707 elfcpp::STV_HIDDEN, // visibility 2708 0, // nonvis 2709 Symbol::SEGMENT_START, // offset_from_base 2710 true // only_if_ref 2711 }, 2712 { 2713 "__rel_iplt_end", // name 2714 elfcpp::PT_LOAD, // segment_type 2715 elfcpp::PF_W, // segment_flags_set 2716 elfcpp::PF(0), // segment_flags_clear 2717 0, // value 2718 0, // size 2719 elfcpp::STT_NOTYPE, // type 2720 elfcpp::STB_GLOBAL, // binding 2721 elfcpp::STV_HIDDEN, // visibility 2722 0, // nonvis 2723 Symbol::SEGMENT_START, // offset_from_base 2724 true // only_if_ref 2725 } 2726 }; 2727 2728 symtab->define_symbols(layout, 2, syms, 2729 layout->script_options()->saw_sections_clause()); 2730 } 2731} 2732 2733// Return whether a direct absolute static relocation needs to be applied. 2734// In cases where Scan::local() or Scan::global() has created 2735// a dynamic relocation other than R_386_RELATIVE, the addend 2736// of the relocation is carried in the data, and we must not 2737// apply the static relocation. 2738 2739inline bool 2740Target_i386::Relocate::should_apply_static_reloc(const Sized_symbol<32>* gsym, 2741 unsigned int r_type, 2742 bool is_32bit, 2743 Output_section* output_section) 2744{ 2745 // If the output section is not allocated, then we didn't call 2746 // scan_relocs, we didn't create a dynamic reloc, and we must apply 2747 // the reloc here. 2748 if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0) 2749 return true; 2750 2751 int ref_flags = Scan::get_reference_flags(r_type); 2752 2753 // For local symbols, we will have created a non-RELATIVE dynamic 2754 // relocation only if (a) the output is position independent, 2755 // (b) the relocation is absolute (not pc- or segment-relative), and 2756 // (c) the relocation is not 32 bits wide. 2757 if (gsym == NULL) 2758 return !(parameters->options().output_is_position_independent() 2759 && (ref_flags & Symbol::ABSOLUTE_REF) 2760 && !is_32bit); 2761 2762 // For global symbols, we use the same helper routines used in the 2763 // scan pass. If we did not create a dynamic relocation, or if we 2764 // created a RELATIVE dynamic relocation, we should apply the static 2765 // relocation. 2766 bool has_dyn = gsym->needs_dynamic_reloc(ref_flags); 2767 bool is_rel = (ref_flags & Symbol::ABSOLUTE_REF) 2768 && gsym->can_use_relative_reloc(ref_flags 2769 & Symbol::FUNCTION_CALL); 2770 return !has_dyn || is_rel; 2771} 2772 2773// Perform a relocation. 2774 2775inline bool 2776Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, 2777 unsigned int, 2778 Target_i386* target, 2779 Output_section* output_section, 2780 size_t relnum, 2781 const unsigned char* preloc, 2782 const Sized_symbol<32>* gsym, 2783 const Symbol_value<32>* psymval, 2784 unsigned char* view, 2785 elfcpp::Elf_types<32>::Elf_Addr address, 2786 section_size_type view_size) 2787{ 2788 const elfcpp::Rel<32, false> rel(preloc); 2789 unsigned int r_type = elfcpp::elf_r_type<32>(rel.get_r_info()); 2790 2791 if (this->skip_call_tls_get_addr_) 2792 { 2793 if ((r_type != elfcpp::R_386_PLT32 2794 && r_type != elfcpp::R_386_GOT32X 2795 && r_type != elfcpp::R_386_PC32) 2796 || gsym == NULL 2797 || strcmp(gsym->name(), "___tls_get_addr") != 0) 2798 { 2799 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2800 _("missing expected TLS relocation")); 2801 this->skip_call_tls_get_addr_ = false; 2802 } 2803 else 2804 { 2805 this->skip_call_tls_get_addr_ = false; 2806 return false; 2807 } 2808 } 2809 2810 if (view == NULL) 2811 return true; 2812 2813 const Sized_relobj_file<32, false>* object = relinfo->object; 2814 2815 // Pick the value to use for symbols defined in shared objects. 2816 Symbol_value<32> symval; 2817 if (gsym != NULL 2818 && gsym->type() == elfcpp::STT_GNU_IFUNC 2819 && r_type == elfcpp::R_386_32 2820 && gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)) 2821 && gsym->can_use_relative_reloc(false) 2822 && !gsym->is_from_dynobj() 2823 && !gsym->is_undefined() 2824 && !gsym->is_preemptible()) 2825 { 2826 // In this case we are generating a R_386_IRELATIVE reloc. We 2827 // want to use the real value of the symbol, not the PLT offset. 2828 } 2829 else if (gsym != NULL 2830 && gsym->use_plt_offset(Scan::get_reference_flags(r_type))) 2831 { 2832 symval.set_output_value(target->plt_address_for_global(gsym)); 2833 psymval = &symval; 2834 } 2835 else if (gsym == NULL && psymval->is_ifunc_symbol()) 2836 { 2837 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 2838 if (object->local_has_plt_offset(r_sym)) 2839 { 2840 symval.set_output_value(target->plt_address_for_local(object, r_sym)); 2841 psymval = &symval; 2842 } 2843 } 2844 2845 bool baseless; 2846 2847 switch (r_type) 2848 { 2849 case elfcpp::R_386_NONE: 2850 case elfcpp::R_386_GNU_VTINHERIT: 2851 case elfcpp::R_386_GNU_VTENTRY: 2852 break; 2853 2854 case elfcpp::R_386_32: 2855 if (should_apply_static_reloc(gsym, r_type, true, output_section)) 2856 Relocate_functions<32, false>::rel32(view, object, psymval); 2857 break; 2858 2859 case elfcpp::R_386_PC32: 2860 if (should_apply_static_reloc(gsym, r_type, true, output_section)) 2861 Relocate_functions<32, false>::pcrel32(view, object, psymval, address); 2862 break; 2863 2864 case elfcpp::R_386_16: 2865 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2866 Relocate_functions<32, false>::rel16(view, object, psymval); 2867 break; 2868 2869 case elfcpp::R_386_PC16: 2870 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2871 Relocate_functions<32, false>::pcrel16(view, object, psymval, address); 2872 break; 2873 2874 case elfcpp::R_386_8: 2875 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2876 Relocate_functions<32, false>::rel8(view, object, psymval); 2877 break; 2878 2879 case elfcpp::R_386_PC8: 2880 if (should_apply_static_reloc(gsym, r_type, false, output_section)) 2881 Relocate_functions<32, false>::pcrel8(view, object, psymval, address); 2882 break; 2883 2884 case elfcpp::R_386_PLT32: 2885 gold_assert(gsym == NULL 2886 || gsym->has_plt_offset() 2887 || gsym->final_value_is_known() 2888 || (gsym->is_defined() 2889 && !gsym->is_from_dynobj() 2890 && !gsym->is_preemptible())); 2891 Relocate_functions<32, false>::pcrel32(view, object, psymval, address); 2892 break; 2893 2894 case elfcpp::R_386_GOT32: 2895 case elfcpp::R_386_GOT32X: 2896 baseless = (view[-1] & 0xc7) == 0x5; 2897 // R_386_GOT32 and R_386_GOT32X don't work without base register 2898 // when generating a position-independent output file. 2899 if (baseless 2900 && parameters->options().output_is_position_independent()) 2901 { 2902 if(gsym) 2903 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2904 _("unexpected reloc %u against global symbol %s without base register in object file when generating a position-independent output file"), 2905 r_type, gsym->demangled_name().c_str()); 2906 else 2907 gold_error_at_location(relinfo, relnum, rel.get_r_offset(), 2908 _("unexpected reloc %u against local symbol without base register in object file when generating a position-independent output file"), 2909 r_type); 2910 } 2911 2912 // Convert 2913 // mov foo@GOT(%reg), %reg 2914 // to 2915 // lea foo@GOTOFF(%reg), %reg 2916 // if possible. 2917 if (rel.get_r_offset() >= 2 2918 && view[-2] == 0x8b 2919 && ((gsym == NULL && !psymval->is_ifunc_symbol()) 2920 || (gsym != NULL 2921 && Target_i386::can_convert_mov_to_lea(gsym)))) 2922 { 2923 view[-2] = 0x8d; 2924 elfcpp::Elf_types<32>::Elf_Addr value; 2925 value = psymval->value(object, 0); 2926 // Don't subtract the .got.plt section address for baseless 2927 // addressing. 2928 if (!baseless) 2929 value -= target->got_plt_section()->address(); 2930 Relocate_functions<32, false>::rel32(view, value); 2931 } 2932 else 2933 { 2934 // The GOT pointer points to the end of the GOT section. 2935 // We need to subtract the size of the GOT section to get 2936 // the actual offset to use in the relocation. 2937 unsigned int got_offset = 0; 2938 if (gsym != NULL) 2939 { 2940 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 2941 got_offset = (gsym->got_offset(GOT_TYPE_STANDARD) 2942 - target->got_size()); 2943 } 2944 else 2945 { 2946 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info()); 2947 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 2948 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD) 2949 - target->got_size()); 2950 } 2951 // Add the .got.plt section address for baseless addressing. 2952 if (baseless) 2953 got_offset += target->got_plt_section()->address(); 2954 Relocate_functions<32, false>::rel32(view, got_offset); 2955 } 2956 break; 2957 2958 case elfcpp::R_386_GOTOFF: 2959 { 2960 elfcpp::Elf_types<32>::Elf_Addr reladdr; 2961 reladdr = target->got_plt_section()->address(); 2962 Relocate_functions<32, false>::pcrel32(view, object, psymval, reladdr); 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 elfcpp::SHT_PROGBITS, // unwind_section_type 4207}; 4208 4209#define NACLMASK 0xe0 // 32-byte alignment mask 4210 4211const unsigned char 4212Output_data_plt_i386_nacl_exec::first_plt_entry[plt_entry_size] = 4213{ 4214 0xff, 0x35, // pushl contents of memory address 4215 0, 0, 0, 0, // replaced with address of .got + 4 4216 0x8b, 0x0d, // movl contents of address, %ecx 4217 0, 0, 0, 0, // replaced with address of .got + 8 4218 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx 4219 0xff, 0xe1, // jmp *%ecx 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, 0x90, // nops 4227 0x90, 0x90, 0x90, 0x90, 0x90 4228}; 4229 4230void 4231Output_data_plt_i386_nacl_exec::do_fill_first_plt_entry( 4232 unsigned char* pov, 4233 elfcpp::Elf_types<32>::Elf_Addr got_address) 4234{ 4235 memcpy(pov, first_plt_entry, plt_entry_size); 4236 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4); 4237 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8); 4238} 4239 4240// The first entry in the PLT for a shared object. 4241 4242const unsigned char 4243Output_data_plt_i386_nacl_dyn::first_plt_entry[plt_entry_size] = 4244{ 4245 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx) 4246 0x8b, 0x4b, 0x08, // mov 0x8(%ebx), %ecx 4247 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx 4248 0xff, 0xe1, // jmp *%ecx 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 0x90, 0x90, 0x90, 0x90, 0x90 // nops 4259}; 4260 4261void 4262Output_data_plt_i386_nacl_dyn::do_fill_first_plt_entry( 4263 unsigned char* pov, 4264 elfcpp::Elf_types<32>::Elf_Addr) 4265{ 4266 memcpy(pov, first_plt_entry, plt_entry_size); 4267} 4268 4269// Subsequent entries in the PLT for an executable. 4270 4271const unsigned char 4272Output_data_plt_i386_nacl_exec::plt_entry[plt_entry_size] = 4273{ 4274 0x8b, 0x0d, // movl contents of address, %ecx */ 4275 0, 0, 0, 0, // replaced with address of symbol in .got 4276 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx 4277 0xff, 0xe1, // jmp *%ecx 4278 4279 // Pad to the next 32-byte boundary with nop instructions. 4280 0x90, 4281 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4282 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4283 4284 // Lazy GOT entries point here (32-byte aligned). 4285 0x68, // pushl immediate 4286 0, 0, 0, 0, // replaced with offset into relocation table 4287 0xe9, // jmp relative 4288 0, 0, 0, 0, // replaced with offset to start of .plt 4289 4290 // Pad to the next 32-byte boundary with nop instructions. 4291 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4292 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4293 0x90, 0x90 4294}; 4295 4296unsigned int 4297Output_data_plt_i386_nacl_exec::do_fill_plt_entry( 4298 unsigned char* pov, 4299 elfcpp::Elf_types<32>::Elf_Addr got_address, 4300 unsigned int got_offset, 4301 unsigned int plt_offset, 4302 unsigned int plt_rel_offset) 4303{ 4304 memcpy(pov, plt_entry, plt_entry_size); 4305 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 4306 got_address + got_offset); 4307 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset); 4308 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4)); 4309 return 32; 4310} 4311 4312// Subsequent entries in the PLT for a shared object. 4313 4314const unsigned char 4315Output_data_plt_i386_nacl_dyn::plt_entry[plt_entry_size] = 4316{ 4317 0x8b, 0x8b, // movl offset(%ebx), %ecx 4318 0, 0, 0, 0, // replaced with offset of symbol in .got 4319 0x83, 0xe1, 0xe0, // andl $NACLMASK, %ecx 4320 0xff, 0xe1, // jmp *%ecx 4321 4322 // Pad to the next 32-byte boundary with nop instructions. 4323 0x90, 4324 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4325 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4326 4327 // Lazy GOT entries point here (32-byte aligned). 4328 0x68, // pushl immediate 4329 0, 0, 0, 0, // replaced with offset into relocation table. 4330 0xe9, // jmp relative 4331 0, 0, 0, 0, // replaced with offset to start of .plt. 4332 4333 // Pad to the next 32-byte boundary with nop instructions. 4334 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4335 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 4336 0x90, 0x90 4337}; 4338 4339unsigned int 4340Output_data_plt_i386_nacl_dyn::do_fill_plt_entry( 4341 unsigned char* pov, 4342 elfcpp::Elf_types<32>::Elf_Addr, 4343 unsigned int got_offset, 4344 unsigned int plt_offset, 4345 unsigned int plt_rel_offset) 4346{ 4347 memcpy(pov, plt_entry, plt_entry_size); 4348 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset); 4349 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset); 4350 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4)); 4351 return 32; 4352} 4353 4354const unsigned char 4355Output_data_plt_i386_nacl::plt_eh_frame_fde[plt_eh_frame_fde_size] = 4356{ 4357 0, 0, 0, 0, // Replaced with offset to .plt. 4358 0, 0, 0, 0, // Replaced with size of .plt. 4359 0, // Augmentation size. 4360 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8. 4361 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 4362 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12. 4363 elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64. 4364 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 4365 13, // Block length. 4366 elfcpp::DW_OP_breg4, 4, // Push %esp + 4. 4367 elfcpp::DW_OP_breg8, 0, // Push %eip. 4368 elfcpp::DW_OP_const1u, 63, // Push 0x3f. 4369 elfcpp::DW_OP_and, // & (%eip & 0x3f). 4370 elfcpp::DW_OP_const1u, 37, // Push 0x25. 4371 elfcpp::DW_OP_ge, // >= ((%eip & 0x3f) >= 0x25) 4372 elfcpp::DW_OP_lit2, // Push 2. 4373 elfcpp::DW_OP_shl, // << (((%eip & 0x3f) >= 0x25) << 2) 4374 elfcpp::DW_OP_plus, // + ((((%eip&0x3f)>=0x25)<<2)+%esp+4 4375 elfcpp::DW_CFA_nop, // Align to 32 bytes. 4376 elfcpp::DW_CFA_nop 4377}; 4378 4379// Return a string used to fill a code section with nops. 4380// For NaCl, long NOPs are only valid if they do not cross 4381// bundle alignment boundaries, so keep it simple with one-byte NOPs. 4382std::string 4383Target_i386_nacl::do_code_fill(section_size_type length) const 4384{ 4385 return std::string(length, static_cast<char>(0x90)); 4386} 4387 4388// The selector for i386-nacl object files. 4389 4390class Target_selector_i386_nacl 4391 : public Target_selector_nacl<Target_selector_i386, Target_i386_nacl> 4392{ 4393 public: 4394 Target_selector_i386_nacl() 4395 : Target_selector_nacl<Target_selector_i386, 4396 Target_i386_nacl>("x86-32", 4397 "elf32-i386-nacl", 4398 "elf_i386_nacl") 4399 { } 4400}; 4401 4402Target_selector_i386_nacl target_selector_i386; 4403 4404// IAMCU variant. It uses EM_IAMCU, not EM_386. 4405 4406class Target_iamcu : public Target_i386 4407{ 4408 public: 4409 Target_iamcu() 4410 : Target_i386(&iamcu_info) 4411 { } 4412 4413 private: 4414 // Information about this specific target which we pass to the 4415 // general Target structure. 4416 static const Target::Target_info iamcu_info; 4417}; 4418 4419const Target::Target_info Target_iamcu::iamcu_info = 4420{ 4421 32, // size 4422 false, // is_big_endian 4423 elfcpp::EM_IAMCU, // machine_code 4424 false, // has_make_symbol 4425 false, // has_resolve 4426 true, // has_code_fill 4427 true, // is_default_stack_executable 4428 true, // can_icf_inline_merge_sections 4429 '\0', // wrap_char 4430 "/usr/lib/libc.so.1", // dynamic_linker 4431 0x08048000, // default_text_segment_address 4432 0x1000, // abi_pagesize (overridable by -z max-page-size) 4433 0x1000, // common_pagesize (overridable by -z common-page-size) 4434 false, // isolate_execinstr 4435 0, // rosegment_gap 4436 elfcpp::SHN_UNDEF, // small_common_shndx 4437 elfcpp::SHN_UNDEF, // large_common_shndx 4438 0, // small_common_section_flags 4439 0, // large_common_section_flags 4440 NULL, // attributes_section 4441 NULL, // attributes_vendor 4442 "_start", // entry_symbol_name 4443 32, // hash_entry_size 4444 elfcpp::SHT_PROGBITS, // unwind_section_type 4445}; 4446 4447class Target_selector_iamcu : public Target_selector 4448{ 4449public: 4450 Target_selector_iamcu() 4451 : Target_selector(elfcpp::EM_IAMCU, 32, false, "elf32-iamcu", 4452 "elf_iamcu") 4453 { } 4454 4455 Target* 4456 do_instantiate_target() 4457 { return new Target_iamcu(); } 4458}; 4459 4460Target_selector_iamcu target_selector_iamcu; 4461 4462} // End anonymous namespace. 4463