1 // x86_64.cc -- x86_64 target support for gold. 2 3 // Copyright (C) 2006-2020 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 "x86_64.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 #include "icf.h" 45 46 namespace 47 { 48 49 using namespace gold; 50 51 // A class to handle the .got.plt section. 52 53 class Output_data_got_plt_x86_64 : public Output_section_data_build 54 { 55 public: 56 Output_data_got_plt_x86_64(Layout* layout) 57 : Output_section_data_build(8), 58 layout_(layout) 59 { } 60 61 Output_data_got_plt_x86_64(Layout* layout, off_t data_size) 62 : Output_section_data_build(data_size, 8), 63 layout_(layout) 64 { } 65 66 protected: 67 // Write out the PLT data. 68 void 69 do_write(Output_file*); 70 71 // Write to a map file. 72 void 73 do_print_to_mapfile(Mapfile* mapfile) const 74 { mapfile->print_output_data(this, "** GOT PLT"); } 75 76 private: 77 // A pointer to the Layout class, so that we can find the .dynamic 78 // section when we write out the GOT PLT section. 79 Layout* layout_; 80 }; 81 82 // A class to handle the PLT data. 83 // This is an abstract base class that handles most of the linker details 84 // but does not know the actual contents of PLT entries. The derived 85 // classes below fill in those details. 86 87 template<int size> 88 class Output_data_plt_x86_64 : public Output_section_data 89 { 90 public: 91 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, false> Reloc_section; 92 93 Output_data_plt_x86_64(Layout* layout, uint64_t addralign, 94 Output_data_got<64, false>* got, 95 Output_data_got_plt_x86_64* got_plt, 96 Output_data_space* got_irelative) 97 : Output_section_data(addralign), tlsdesc_rel_(NULL), 98 irelative_rel_(NULL), got_(got), got_plt_(got_plt), 99 got_irelative_(got_irelative), count_(0), irelative_count_(0), 100 tlsdesc_got_offset_(-1U), free_list_() 101 { this->init(layout); } 102 103 Output_data_plt_x86_64(Layout* layout, uint64_t plt_entry_size, 104 Output_data_got<64, false>* got, 105 Output_data_got_plt_x86_64* got_plt, 106 Output_data_space* got_irelative, 107 unsigned int plt_count) 108 : Output_section_data((plt_count + 1) * plt_entry_size, 109 plt_entry_size, false), 110 tlsdesc_rel_(NULL), irelative_rel_(NULL), got_(got), 111 got_plt_(got_plt), got_irelative_(got_irelative), count_(plt_count), 112 irelative_count_(0), tlsdesc_got_offset_(-1U), free_list_() 113 { 114 this->init(layout); 115 116 // Initialize the free list and reserve the first entry. 117 this->free_list_.init((plt_count + 1) * plt_entry_size, false); 118 this->free_list_.remove(0, plt_entry_size); 119 } 120 121 // Initialize the PLT section. 122 void 123 init(Layout* layout); 124 125 // Add an entry to the PLT. 126 void 127 add_entry(Symbol_table*, Layout*, Symbol* gsym); 128 129 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. 130 unsigned int 131 add_local_ifunc_entry(Symbol_table* symtab, Layout*, 132 Sized_relobj_file<size, false>* relobj, 133 unsigned int local_sym_index); 134 135 // Add the relocation for a PLT entry. 136 void 137 add_relocation(Symbol_table*, Layout*, Symbol* gsym, 138 unsigned int got_offset); 139 140 // Add the reserved TLSDESC_PLT entry to the PLT. 141 void 142 reserve_tlsdesc_entry(unsigned int got_offset) 143 { this->tlsdesc_got_offset_ = got_offset; } 144 145 // Return true if a TLSDESC_PLT entry has been reserved. 146 bool 147 has_tlsdesc_entry() const 148 { return this->tlsdesc_got_offset_ != -1U; } 149 150 // Return the GOT offset for the reserved TLSDESC_PLT entry. 151 unsigned int 152 get_tlsdesc_got_offset() const 153 { return this->tlsdesc_got_offset_; } 154 155 // Return the offset of the reserved TLSDESC_PLT entry. 156 unsigned int 157 get_tlsdesc_plt_offset() const 158 { 159 return ((this->count_ + this->irelative_count_ + 1) 160 * this->get_plt_entry_size()); 161 } 162 163 // Return the .rela.plt section data. 164 Reloc_section* 165 rela_plt() 166 { return this->rel_; } 167 168 // Return where the TLSDESC relocations should go. 169 Reloc_section* 170 rela_tlsdesc(Layout*); 171 172 // Return where the IRELATIVE relocations should go in the PLT 173 // relocations. 174 Reloc_section* 175 rela_irelative(Symbol_table*, Layout*); 176 177 // Return whether we created a section for IRELATIVE relocations. 178 bool 179 has_irelative_section() const 180 { return this->irelative_rel_ != NULL; } 181 182 // Get count of regular PLT entries. 183 unsigned int 184 regular_count() const 185 { return this->count_; } 186 187 // Return the total number of PLT entries. 188 unsigned int 189 entry_count() const 190 { return this->count_ + this->irelative_count_; } 191 192 // Return the offset of the first non-reserved PLT entry. 193 unsigned int 194 first_plt_entry_offset() 195 { return this->get_plt_entry_size(); } 196 197 // Return the size of a PLT entry. 198 unsigned int 199 get_plt_entry_size() const 200 { return this->do_get_plt_entry_size(); } 201 202 // Reserve a slot in the PLT for an existing symbol in an incremental update. 203 void 204 reserve_slot(unsigned int plt_index) 205 { 206 this->free_list_.remove((plt_index + 1) * this->get_plt_entry_size(), 207 (plt_index + 2) * this->get_plt_entry_size()); 208 } 209 210 // Return the PLT address to use for a global symbol. 211 uint64_t 212 address_for_global(const Symbol* sym) 213 { return do_address_for_global(sym); } 214 215 // Return the PLT address to use for a local symbol. 216 uint64_t 217 address_for_local(const Relobj* obj, unsigned int symndx) 218 { return do_address_for_local(obj, symndx); } 219 220 // Add .eh_frame information for the PLT. 221 void 222 add_eh_frame(Layout* layout) 223 { this->do_add_eh_frame(layout); } 224 225 protected: 226 Output_data_got<64, false>* 227 got() const 228 { return this->got_; } 229 230 Output_data_got_plt_x86_64* 231 got_plt() const 232 { return this->got_plt_; } 233 234 Output_data_space* 235 got_irelative() const 236 { return this->got_irelative_; } 237 238 // Fill in the first PLT entry. 239 void 240 fill_first_plt_entry(unsigned char* pov, 241 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 242 typename elfcpp::Elf_types<size>::Elf_Addr plt_address) 243 { this->do_fill_first_plt_entry(pov, got_address, plt_address); } 244 245 // Fill in a normal PLT entry. Returns the offset into the entry that 246 // should be the initial GOT slot value. 247 unsigned int 248 fill_plt_entry(unsigned char* pov, 249 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 250 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 251 unsigned int got_offset, 252 unsigned int plt_offset, 253 unsigned int plt_index) 254 { 255 return this->do_fill_plt_entry(pov, got_address, plt_address, 256 got_offset, plt_offset, plt_index); 257 } 258 259 // Fill in the reserved TLSDESC PLT entry. 260 void 261 fill_tlsdesc_entry(unsigned char* pov, 262 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 263 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 264 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 265 unsigned int tlsdesc_got_offset, 266 unsigned int plt_offset) 267 { 268 this->do_fill_tlsdesc_entry(pov, got_address, plt_address, got_base, 269 tlsdesc_got_offset, plt_offset); 270 } 271 272 virtual unsigned int 273 do_get_plt_entry_size() const = 0; 274 275 virtual void 276 do_fill_first_plt_entry(unsigned char* pov, 277 typename elfcpp::Elf_types<size>::Elf_Addr got_addr, 278 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr) 279 = 0; 280 281 virtual unsigned int 282 do_fill_plt_entry(unsigned char* pov, 283 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 284 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 285 unsigned int got_offset, 286 unsigned int plt_offset, 287 unsigned int plt_index) = 0; 288 289 virtual void 290 do_fill_tlsdesc_entry(unsigned char* pov, 291 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 292 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 293 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 294 unsigned int tlsdesc_got_offset, 295 unsigned int plt_offset) = 0; 296 297 // Return the PLT address to use for a global symbol. 298 virtual uint64_t 299 do_address_for_global(const Symbol* sym); 300 301 // Return the PLT address to use for a local symbol. 302 virtual uint64_t 303 do_address_for_local(const Relobj* obj, unsigned int symndx); 304 305 virtual void 306 do_add_eh_frame(Layout* layout) = 0; 307 308 void 309 do_adjust_output_section(Output_section* os); 310 311 // Write to a map file. 312 void 313 do_print_to_mapfile(Mapfile* mapfile) const 314 { mapfile->print_output_data(this, _("** PLT")); } 315 316 // The CIE of the .eh_frame unwind information for the PLT. 317 static const int plt_eh_frame_cie_size = 16; 318 static const unsigned char plt_eh_frame_cie[plt_eh_frame_cie_size]; 319 320 private: 321 // Set the final size. 322 void 323 set_final_data_size(); 324 325 // Write out the PLT data. 326 void 327 do_write(Output_file*); 328 329 // The reloc section. 330 Reloc_section* rel_; 331 // The TLSDESC relocs, if necessary. These must follow the regular 332 // PLT relocs. 333 Reloc_section* tlsdesc_rel_; 334 // The IRELATIVE relocs, if necessary. These must follow the 335 // regular PLT relocations and the TLSDESC relocations. 336 Reloc_section* irelative_rel_; 337 // The .got section. 338 Output_data_got<64, false>* got_; 339 // The .got.plt section. 340 Output_data_got_plt_x86_64* got_plt_; 341 // The part of the .got.plt section used for IRELATIVE relocs. 342 Output_data_space* got_irelative_; 343 // The number of PLT entries. 344 unsigned int count_; 345 // Number of PLT entries with R_X86_64_IRELATIVE relocs. These 346 // follow the regular PLT entries. 347 unsigned int irelative_count_; 348 // Offset of the reserved TLSDESC_GOT entry when needed. 349 unsigned int tlsdesc_got_offset_; 350 // List of available regions within the section, for incremental 351 // update links. 352 Free_list free_list_; 353 }; 354 355 template<int size> 356 class Output_data_plt_x86_64_standard : public Output_data_plt_x86_64<size> 357 { 358 public: 359 Output_data_plt_x86_64_standard(Layout* layout, 360 Output_data_got<64, false>* got, 361 Output_data_got_plt_x86_64* got_plt, 362 Output_data_space* got_irelative) 363 : Output_data_plt_x86_64<size>(layout, plt_entry_size, 364 got, got_plt, got_irelative) 365 { } 366 367 Output_data_plt_x86_64_standard(Layout* layout, 368 Output_data_got<64, false>* got, 369 Output_data_got_plt_x86_64* got_plt, 370 Output_data_space* got_irelative, 371 unsigned int plt_count) 372 : Output_data_plt_x86_64<size>(layout, plt_entry_size, 373 got, got_plt, got_irelative, 374 plt_count) 375 { } 376 377 protected: 378 virtual unsigned int 379 do_get_plt_entry_size() const 380 { return plt_entry_size; } 381 382 virtual void 383 do_add_eh_frame(Layout* layout) 384 { 385 layout->add_eh_frame_for_plt(this, 386 this->plt_eh_frame_cie, 387 this->plt_eh_frame_cie_size, 388 plt_eh_frame_fde, 389 plt_eh_frame_fde_size); 390 } 391 392 virtual void 393 do_fill_first_plt_entry(unsigned char* pov, 394 typename elfcpp::Elf_types<size>::Elf_Addr got_addr, 395 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr); 396 397 virtual unsigned int 398 do_fill_plt_entry(unsigned char* pov, 399 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 400 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 401 unsigned int got_offset, 402 unsigned int plt_offset, 403 unsigned int plt_index); 404 405 virtual void 406 do_fill_tlsdesc_entry(unsigned char* pov, 407 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 408 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 409 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 410 unsigned int tlsdesc_got_offset, 411 unsigned int plt_offset); 412 413 private: 414 // The size of an entry in the PLT. 415 static const int plt_entry_size = 16; 416 417 // The first entry in the PLT. 418 // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same 419 // procedure linkage table for both programs and shared objects." 420 static const unsigned char first_plt_entry[plt_entry_size]; 421 422 // Other entries in the PLT for an executable. 423 static const unsigned char plt_entry[plt_entry_size]; 424 425 // The reserved TLSDESC entry in the PLT for an executable. 426 static const unsigned char tlsdesc_plt_entry[plt_entry_size]; 427 428 // The .eh_frame unwind information for the PLT. 429 static const int plt_eh_frame_fde_size = 32; 430 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size]; 431 }; 432 433 class Output_data_plt_x86_64_bnd : public Output_data_plt_x86_64<64> 434 { 435 public: 436 Output_data_plt_x86_64_bnd(Layout* layout, 437 Output_data_got<64, false>* got, 438 Output_data_got_plt_x86_64* got_plt, 439 Output_data_space* got_irelative) 440 : Output_data_plt_x86_64<64>(layout, plt_entry_size, 441 got, got_plt, got_irelative), 442 aplt_offset_(0) 443 { } 444 445 Output_data_plt_x86_64_bnd(Layout* layout, 446 Output_data_got<64, false>* got, 447 Output_data_got_plt_x86_64* got_plt, 448 Output_data_space* got_irelative, 449 unsigned int plt_count) 450 : Output_data_plt_x86_64<64>(layout, plt_entry_size, 451 got, got_plt, got_irelative, 452 plt_count), 453 aplt_offset_(0) 454 { } 455 456 protected: 457 virtual unsigned int 458 do_get_plt_entry_size() const 459 { return plt_entry_size; } 460 461 // Return the PLT address to use for a global symbol. 462 uint64_t 463 do_address_for_global(const Symbol*); 464 465 // Return the PLT address to use for a local symbol. 466 uint64_t 467 do_address_for_local(const Relobj*, unsigned int symndx); 468 469 virtual void 470 do_add_eh_frame(Layout* layout) 471 { 472 layout->add_eh_frame_for_plt(this, 473 this->plt_eh_frame_cie, 474 this->plt_eh_frame_cie_size, 475 plt_eh_frame_fde, 476 plt_eh_frame_fde_size); 477 } 478 479 virtual void 480 do_fill_first_plt_entry(unsigned char* pov, 481 elfcpp::Elf_types<64>::Elf_Addr got_addr, 482 elfcpp::Elf_types<64>::Elf_Addr plt_addr); 483 484 virtual unsigned int 485 do_fill_plt_entry(unsigned char* pov, 486 elfcpp::Elf_types<64>::Elf_Addr got_address, 487 elfcpp::Elf_types<64>::Elf_Addr plt_address, 488 unsigned int got_offset, 489 unsigned int plt_offset, 490 unsigned int plt_index); 491 492 virtual void 493 do_fill_tlsdesc_entry(unsigned char* pov, 494 elfcpp::Elf_types<64>::Elf_Addr got_address, 495 elfcpp::Elf_types<64>::Elf_Addr plt_address, 496 elfcpp::Elf_types<64>::Elf_Addr got_base, 497 unsigned int tlsdesc_got_offset, 498 unsigned int plt_offset); 499 500 void 501 fill_aplt_entry(unsigned char* pov, 502 elfcpp::Elf_types<64>::Elf_Addr got_address, 503 elfcpp::Elf_types<64>::Elf_Addr plt_address, 504 unsigned int got_offset, 505 unsigned int plt_offset, 506 unsigned int plt_index); 507 508 private: 509 // Set the final size. 510 void 511 set_final_data_size(); 512 513 // Write out the BND PLT data. 514 void 515 do_write(Output_file*); 516 517 // Offset of the Additional PLT (if using -z bndplt). 518 unsigned int aplt_offset_; 519 520 // The size of an entry in the PLT. 521 static const int plt_entry_size = 16; 522 523 // The size of an entry in the additional PLT. 524 static const int aplt_entry_size = 8; 525 526 // The first entry in the PLT. 527 // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same 528 // procedure linkage table for both programs and shared objects." 529 static const unsigned char first_plt_entry[plt_entry_size]; 530 531 // Other entries in the PLT for an executable. 532 static const unsigned char plt_entry[plt_entry_size]; 533 534 // Entries in the additional PLT. 535 static const unsigned char aplt_entry[aplt_entry_size]; 536 537 // The reserved TLSDESC entry in the PLT for an executable. 538 static const unsigned char tlsdesc_plt_entry[plt_entry_size]; 539 540 // The .eh_frame unwind information for the PLT. 541 static const int plt_eh_frame_fde_size = 32; 542 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size]; 543 }; 544 545 // We use this PLT when Indirect Branch Tracking (IBT) is enabled. 546 547 template <int size> 548 class Output_data_plt_x86_64_ibt : public Output_data_plt_x86_64<size> 549 { 550 public: 551 Output_data_plt_x86_64_ibt(Layout* layout, 552 Output_data_got<64, false>* got, 553 Output_data_got_plt_x86_64* got_plt, 554 Output_data_space* got_irelative) 555 : Output_data_plt_x86_64<size>(layout, plt_entry_size, 556 got, got_plt, got_irelative), 557 aplt_offset_(0) 558 { } 559 560 Output_data_plt_x86_64_ibt(Layout* layout, 561 Output_data_got<64, false>* got, 562 Output_data_got_plt_x86_64* got_plt, 563 Output_data_space* got_irelative, 564 unsigned int plt_count) 565 : Output_data_plt_x86_64<size>(layout, plt_entry_size, 566 got, got_plt, got_irelative, 567 plt_count), 568 aplt_offset_(0) 569 { } 570 571 protected: 572 virtual unsigned int 573 do_get_plt_entry_size() const 574 { return plt_entry_size; } 575 576 // Return the PLT address to use for a global symbol. 577 uint64_t 578 do_address_for_global(const Symbol*); 579 580 // Return the PLT address to use for a local symbol. 581 uint64_t 582 do_address_for_local(const Relobj*, unsigned int symndx); 583 584 virtual void 585 do_add_eh_frame(Layout* layout) 586 { 587 layout->add_eh_frame_for_plt(this, 588 this->plt_eh_frame_cie, 589 this->plt_eh_frame_cie_size, 590 plt_eh_frame_fde, 591 plt_eh_frame_fde_size); 592 } 593 594 virtual void 595 do_fill_first_plt_entry(unsigned char* pov, 596 typename elfcpp::Elf_types<size>::Elf_Addr got_addr, 597 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr); 598 599 virtual unsigned int 600 do_fill_plt_entry(unsigned char* pov, 601 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 602 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 603 unsigned int got_offset, 604 unsigned int plt_offset, 605 unsigned int plt_index); 606 607 virtual void 608 do_fill_tlsdesc_entry(unsigned char* pov, 609 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 610 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 611 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 612 unsigned int tlsdesc_got_offset, 613 unsigned int plt_offset); 614 615 void 616 fill_aplt_entry(unsigned char* pov, 617 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 618 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 619 unsigned int got_offset, 620 unsigned int plt_offset, 621 unsigned int plt_index); 622 623 private: 624 // Set the final size. 625 void 626 set_final_data_size(); 627 628 // Write out the BND PLT data. 629 void 630 do_write(Output_file*); 631 632 // Offset of the Additional PLT (if using -z bndplt). 633 unsigned int aplt_offset_; 634 635 // The size of an entry in the PLT. 636 static const int plt_entry_size = 16; 637 638 // The size of an entry in the additional PLT. 639 static const int aplt_entry_size = 16; 640 641 // The first entry in the PLT. 642 // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same 643 // procedure linkage table for both programs and shared objects." 644 static const unsigned char first_plt_entry[plt_entry_size]; 645 646 // Other entries in the PLT for an executable. 647 static const unsigned char plt_entry[plt_entry_size]; 648 649 // Entries in the additional PLT. 650 static const unsigned char aplt_entry[aplt_entry_size]; 651 652 // The reserved TLSDESC entry in the PLT for an executable. 653 static const unsigned char tlsdesc_plt_entry[plt_entry_size]; 654 655 // The .eh_frame unwind information for the PLT. 656 static const int plt_eh_frame_fde_size = 32; 657 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size]; 658 }; 659 660 template<int size> 661 class Lazy_view 662 { 663 public: 664 Lazy_view(Sized_relobj_file<size, false>* object, unsigned int data_shndx) 665 : object_(object), data_shndx_(data_shndx), view_(NULL), view_size_(0) 666 { } 667 668 inline unsigned char 669 operator[](size_t offset) 670 { 671 if (this->view_ == NULL) 672 this->view_ = this->object_->section_contents(this->data_shndx_, 673 &this->view_size_, 674 true); 675 if (offset >= this->view_size_) 676 return 0; 677 return this->view_[offset]; 678 } 679 680 private: 681 Sized_relobj_file<size, false>* object_; 682 unsigned int data_shndx_; 683 const unsigned char* view_; 684 section_size_type view_size_; 685 }; 686 687 // The x86_64 target class. 688 // See the ABI at 689 // http://www.x86-64.org/documentation/abi.pdf 690 // TLS info comes from 691 // http://people.redhat.com/drepper/tls.pdf 692 // http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt 693 694 template<int size> 695 class Target_x86_64 : public Sized_target<size, false> 696 { 697 public: 698 // In the x86_64 ABI (p 68), it says "The AMD64 ABI architectures 699 // uses only Elf64_Rela relocation entries with explicit addends." 700 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, false> Reloc_section; 701 702 Target_x86_64(const Target::Target_info* info = &x86_64_info) 703 : Sized_target<size, false>(info), 704 got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL), 705 got_tlsdesc_(NULL), global_offset_table_(NULL), rela_dyn_(NULL), 706 rela_irelative_(NULL), copy_relocs_(elfcpp::R_X86_64_COPY), 707 got_mod_index_offset_(-1U), tlsdesc_reloc_info_(), 708 tls_base_symbol_defined_(false), isa_1_used_(0), isa_1_needed_(0), 709 feature_1_(0), object_isa_1_used_(0), object_feature_1_(0), 710 seen_first_object_(false) 711 { } 712 713 // Hook for a new output section. 714 void 715 do_new_output_section(Output_section*) const; 716 717 // Scan the relocations to look for symbol adjustments. 718 void 719 gc_process_relocs(Symbol_table* symtab, 720 Layout* layout, 721 Sized_relobj_file<size, false>* object, 722 unsigned int data_shndx, 723 unsigned int sh_type, 724 const unsigned char* prelocs, 725 size_t reloc_count, 726 Output_section* output_section, 727 bool needs_special_offset_handling, 728 size_t local_symbol_count, 729 const unsigned char* plocal_symbols); 730 731 // Scan the relocations to look for symbol adjustments. 732 void 733 scan_relocs(Symbol_table* symtab, 734 Layout* layout, 735 Sized_relobj_file<size, false>* object, 736 unsigned int data_shndx, 737 unsigned int sh_type, 738 const unsigned char* prelocs, 739 size_t reloc_count, 740 Output_section* output_section, 741 bool needs_special_offset_handling, 742 size_t local_symbol_count, 743 const unsigned char* plocal_symbols); 744 745 // Finalize the sections. 746 void 747 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*); 748 749 // Return the value to use for a dynamic which requires special 750 // treatment. 751 uint64_t 752 do_dynsym_value(const Symbol*) const; 753 754 // Relocate a section. 755 void 756 relocate_section(const Relocate_info<size, false>*, 757 unsigned int sh_type, 758 const unsigned char* prelocs, 759 size_t reloc_count, 760 Output_section* output_section, 761 bool needs_special_offset_handling, 762 unsigned char* view, 763 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 764 section_size_type view_size, 765 const Reloc_symbol_changes*); 766 767 // Scan the relocs during a relocatable link. 768 void 769 scan_relocatable_relocs(Symbol_table* symtab, 770 Layout* layout, 771 Sized_relobj_file<size, false>* object, 772 unsigned int data_shndx, 773 unsigned int sh_type, 774 const unsigned char* prelocs, 775 size_t reloc_count, 776 Output_section* output_section, 777 bool needs_special_offset_handling, 778 size_t local_symbol_count, 779 const unsigned char* plocal_symbols, 780 Relocatable_relocs*); 781 782 // Scan the relocs for --emit-relocs. 783 void 784 emit_relocs_scan(Symbol_table* symtab, 785 Layout* layout, 786 Sized_relobj_file<size, false>* object, 787 unsigned int data_shndx, 788 unsigned int sh_type, 789 const unsigned char* prelocs, 790 size_t reloc_count, 791 Output_section* output_section, 792 bool needs_special_offset_handling, 793 size_t local_symbol_count, 794 const unsigned char* plocal_syms, 795 Relocatable_relocs* rr); 796 797 // Emit relocations for a section. 798 void 799 relocate_relocs( 800 const Relocate_info<size, false>*, 801 unsigned int sh_type, 802 const unsigned char* prelocs, 803 size_t reloc_count, 804 Output_section* output_section, 805 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section, 806 unsigned char* view, 807 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 808 section_size_type view_size, 809 unsigned char* reloc_view, 810 section_size_type reloc_view_size); 811 812 // Return a string used to fill a code section with nops. 813 std::string 814 do_code_fill(section_size_type length) const; 815 816 // Return whether SYM is defined by the ABI. 817 bool 818 do_is_defined_by_abi(const Symbol* sym) const 819 { return strcmp(sym->name(), "__tls_get_addr") == 0; } 820 821 // Return the symbol index to use for a target specific relocation. 822 // The only target specific relocation is R_X86_64_TLSDESC for a 823 // local symbol, which is an absolute reloc. 824 unsigned int 825 do_reloc_symbol_index(void*, unsigned int r_type) const 826 { 827 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC); 828 return 0; 829 } 830 831 // Return the addend to use for a target specific relocation. 832 uint64_t 833 do_reloc_addend(void* arg, unsigned int r_type, uint64_t addend) const; 834 835 // Return the PLT section. 836 uint64_t 837 do_plt_address_for_global(const Symbol* gsym) const 838 { return this->plt_section()->address_for_global(gsym); } 839 840 uint64_t 841 do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const 842 { return this->plt_section()->address_for_local(relobj, symndx); } 843 844 // This function should be defined in targets that can use relocation 845 // types to determine (implemented in local_reloc_may_be_function_pointer 846 // and global_reloc_may_be_function_pointer) 847 // if a function's pointer is taken. ICF uses this in safe mode to only 848 // fold those functions whose pointer is defintely not taken. For x86_64 849 // pie binaries, safe ICF cannot be done by looking at only relocation 850 // types, and for certain cases (e.g. R_X86_64_PC32), the instruction 851 // opcode is checked as well to distinguish a function call from taking 852 // a function's pointer. 853 bool 854 do_can_check_for_function_pointers() const 855 { return true; } 856 857 // Return the base for a DW_EH_PE_datarel encoding. 858 uint64_t 859 do_ehframe_datarel_base() const; 860 861 // Adjust -fsplit-stack code which calls non-split-stack code. 862 void 863 do_calls_non_split(Relobj* object, unsigned int shndx, 864 section_offset_type fnoffset, section_size_type fnsize, 865 const unsigned char* prelocs, size_t reloc_count, 866 unsigned char* view, section_size_type view_size, 867 std::string* from, std::string* to) const; 868 869 // Return the size of the GOT section. 870 section_size_type 871 got_size() const 872 { 873 gold_assert(this->got_ != NULL); 874 return this->got_->data_size(); 875 } 876 877 // Return the number of entries in the GOT. 878 unsigned int 879 got_entry_count() const 880 { 881 if (this->got_ == NULL) 882 return 0; 883 return this->got_size() / 8; 884 } 885 886 // Return the number of entries in the PLT. 887 unsigned int 888 plt_entry_count() const; 889 890 // Return the offset of the first non-reserved PLT entry. 891 unsigned int 892 first_plt_entry_offset() const; 893 894 // Return the size of each PLT entry. 895 unsigned int 896 plt_entry_size() const; 897 898 // Return the size of each GOT entry. 899 unsigned int 900 got_entry_size() const 901 { return 8; }; 902 903 // Create the GOT section for an incremental update. 904 Output_data_got_base* 905 init_got_plt_for_update(Symbol_table* symtab, 906 Layout* layout, 907 unsigned int got_count, 908 unsigned int plt_count); 909 910 // Reserve a GOT entry for a local symbol, and regenerate any 911 // necessary dynamic relocations. 912 void 913 reserve_local_got_entry(unsigned int got_index, 914 Sized_relobj<size, false>* obj, 915 unsigned int r_sym, 916 unsigned int got_type); 917 918 // Reserve a GOT entry for a global symbol, and regenerate any 919 // necessary dynamic relocations. 920 void 921 reserve_global_got_entry(unsigned int got_index, Symbol* gsym, 922 unsigned int got_type); 923 924 // Register an existing PLT entry for a global symbol. 925 void 926 register_global_plt_entry(Symbol_table*, Layout*, unsigned int plt_index, 927 Symbol* gsym); 928 929 // Force a COPY relocation for a given symbol. 930 void 931 emit_copy_reloc(Symbol_table*, Symbol*, Output_section*, off_t); 932 933 // Apply an incremental relocation. 934 void 935 apply_relocation(const Relocate_info<size, false>* relinfo, 936 typename elfcpp::Elf_types<size>::Elf_Addr r_offset, 937 unsigned int r_type, 938 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend, 939 const Symbol* gsym, 940 unsigned char* view, 941 typename elfcpp::Elf_types<size>::Elf_Addr address, 942 section_size_type view_size); 943 944 // Add a new reloc argument, returning the index in the vector. 945 size_t 946 add_tlsdesc_info(Sized_relobj_file<size, false>* object, unsigned int r_sym) 947 { 948 this->tlsdesc_reloc_info_.push_back(Tlsdesc_info(object, r_sym)); 949 return this->tlsdesc_reloc_info_.size() - 1; 950 } 951 952 Output_data_plt_x86_64<size>* 953 make_data_plt(Layout* layout, 954 Output_data_got<64, false>* got, 955 Output_data_got_plt_x86_64* got_plt, 956 Output_data_space* got_irelative) 957 { 958 return this->do_make_data_plt(layout, got, got_plt, got_irelative); 959 } 960 961 Output_data_plt_x86_64<size>* 962 make_data_plt(Layout* layout, 963 Output_data_got<64, false>* got, 964 Output_data_got_plt_x86_64* got_plt, 965 Output_data_space* got_irelative, 966 unsigned int plt_count) 967 { 968 return this->do_make_data_plt(layout, got, got_plt, got_irelative, 969 plt_count); 970 } 971 972 virtual Output_data_plt_x86_64<size>* 973 do_make_data_plt(Layout* layout, 974 Output_data_got<64, false>* got, 975 Output_data_got_plt_x86_64* got_plt, 976 Output_data_space* got_irelative); 977 978 virtual Output_data_plt_x86_64<size>* 979 do_make_data_plt(Layout* layout, 980 Output_data_got<64, false>* got, 981 Output_data_got_plt_x86_64* got_plt, 982 Output_data_space* got_irelative, 983 unsigned int plt_count); 984 985 private: 986 // The class which scans relocations. 987 class Scan 988 { 989 public: 990 Scan() 991 : issued_non_pic_error_(false) 992 { } 993 994 static inline int 995 get_reference_flags(unsigned int r_type); 996 997 inline void 998 local(Symbol_table* symtab, Layout* layout, Target_x86_64* target, 999 Sized_relobj_file<size, false>* object, 1000 unsigned int data_shndx, 1001 Output_section* output_section, 1002 const elfcpp::Rela<size, false>& reloc, unsigned int r_type, 1003 const elfcpp::Sym<size, false>& lsym, 1004 bool is_discarded); 1005 1006 inline void 1007 global(Symbol_table* symtab, Layout* layout, Target_x86_64* target, 1008 Sized_relobj_file<size, false>* object, 1009 unsigned int data_shndx, 1010 Output_section* output_section, 1011 const elfcpp::Rela<size, false>& reloc, unsigned int r_type, 1012 Symbol* gsym); 1013 1014 inline bool 1015 local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout, 1016 Target_x86_64* target, 1017 Sized_relobj_file<size, false>* object, 1018 unsigned int data_shndx, 1019 Output_section* output_section, 1020 const elfcpp::Rela<size, false>& reloc, 1021 unsigned int r_type, 1022 const elfcpp::Sym<size, false>& lsym); 1023 1024 inline bool 1025 global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout, 1026 Target_x86_64* target, 1027 Sized_relobj_file<size, false>* object, 1028 unsigned int data_shndx, 1029 Output_section* output_section, 1030 const elfcpp::Rela<size, false>& reloc, 1031 unsigned int r_type, 1032 Symbol* gsym); 1033 1034 private: 1035 static void 1036 unsupported_reloc_local(Sized_relobj_file<size, false>*, 1037 unsigned int r_type); 1038 1039 static void 1040 unsupported_reloc_global(Sized_relobj_file<size, false>*, 1041 unsigned int r_type, Symbol*); 1042 1043 void 1044 check_non_pic(Relobj*, unsigned int r_type, Symbol*); 1045 1046 inline bool 1047 possible_function_pointer_reloc(Sized_relobj_file<size, false>* src_obj, 1048 unsigned int src_indx, 1049 unsigned int r_offset, 1050 unsigned int r_type); 1051 1052 bool 1053 reloc_needs_plt_for_ifunc(Sized_relobj_file<size, false>*, 1054 unsigned int r_type); 1055 1056 // Whether we have issued an error about a non-PIC compilation. 1057 bool issued_non_pic_error_; 1058 }; 1059 1060 // The class which implements relocation. 1061 class Relocate 1062 { 1063 public: 1064 Relocate() 1065 : skip_call_tls_get_addr_(false) 1066 { } 1067 1068 ~Relocate() 1069 { 1070 if (this->skip_call_tls_get_addr_) 1071 { 1072 // FIXME: This needs to specify the location somehow. 1073 gold_error(_("missing expected TLS relocation")); 1074 } 1075 } 1076 1077 // Do a relocation. Return false if the caller should not issue 1078 // any warnings about this relocation. 1079 inline bool 1080 relocate(const Relocate_info<size, false>*, unsigned int, 1081 Target_x86_64*, Output_section*, size_t, const unsigned char*, 1082 const Sized_symbol<size>*, const Symbol_value<size>*, 1083 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr, 1084 section_size_type); 1085 1086 private: 1087 // Do a TLS relocation. 1088 inline void 1089 relocate_tls(const Relocate_info<size, false>*, Target_x86_64*, 1090 size_t relnum, const elfcpp::Rela<size, false>&, 1091 unsigned int r_type, const Sized_symbol<size>*, 1092 const Symbol_value<size>*, 1093 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr, 1094 section_size_type); 1095 1096 // Do a TLS General-Dynamic to Initial-Exec transition. 1097 inline void 1098 tls_gd_to_ie(const Relocate_info<size, false>*, size_t relnum, 1099 const elfcpp::Rela<size, false>&, unsigned int r_type, 1100 typename elfcpp::Elf_types<size>::Elf_Addr value, 1101 unsigned char* view, 1102 typename elfcpp::Elf_types<size>::Elf_Addr, 1103 section_size_type view_size); 1104 1105 // Do a TLS General-Dynamic to Local-Exec transition. 1106 inline void 1107 tls_gd_to_le(const Relocate_info<size, false>*, size_t relnum, 1108 Output_segment* tls_segment, 1109 const elfcpp::Rela<size, false>&, unsigned int r_type, 1110 typename elfcpp::Elf_types<size>::Elf_Addr value, 1111 unsigned char* view, 1112 section_size_type view_size); 1113 1114 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition. 1115 inline void 1116 tls_desc_gd_to_ie(const Relocate_info<size, false>*, size_t relnum, 1117 const elfcpp::Rela<size, false>&, unsigned int r_type, 1118 typename elfcpp::Elf_types<size>::Elf_Addr value, 1119 unsigned char* view, 1120 typename elfcpp::Elf_types<size>::Elf_Addr, 1121 section_size_type view_size); 1122 1123 // Do a TLSDESC-style General-Dynamic to Local-Exec transition. 1124 inline void 1125 tls_desc_gd_to_le(const Relocate_info<size, false>*, size_t relnum, 1126 Output_segment* tls_segment, 1127 const elfcpp::Rela<size, false>&, unsigned int r_type, 1128 typename elfcpp::Elf_types<size>::Elf_Addr value, 1129 unsigned char* view, 1130 section_size_type view_size); 1131 1132 // Do a TLS Local-Dynamic to Local-Exec transition. 1133 inline void 1134 tls_ld_to_le(const Relocate_info<size, false>*, size_t relnum, 1135 Output_segment* tls_segment, 1136 const elfcpp::Rela<size, false>&, unsigned int r_type, 1137 typename elfcpp::Elf_types<size>::Elf_Addr value, 1138 unsigned char* view, 1139 section_size_type view_size); 1140 1141 // Do a TLS Initial-Exec to Local-Exec transition. 1142 static inline void 1143 tls_ie_to_le(const Relocate_info<size, false>*, size_t relnum, 1144 Output_segment* tls_segment, 1145 const elfcpp::Rela<size, false>&, unsigned int r_type, 1146 typename elfcpp::Elf_types<size>::Elf_Addr value, 1147 unsigned char* view, 1148 section_size_type view_size); 1149 1150 // This is set if we should skip the next reloc, which should be a 1151 // PLT32 reloc against ___tls_get_addr. 1152 bool skip_call_tls_get_addr_; 1153 }; 1154 1155 // Check if relocation against this symbol is a candidate for 1156 // conversion from 1157 // mov foo@GOTPCREL(%rip), %reg 1158 // to lea foo(%rip), %reg. 1159 template<class View_type> 1160 static inline bool 1161 can_convert_mov_to_lea(const Symbol* gsym, unsigned int r_type, 1162 size_t r_offset, View_type* view) 1163 { 1164 gold_assert(gsym != NULL); 1165 // We cannot do the conversion unless it's one of these relocations. 1166 if (r_type != elfcpp::R_X86_64_GOTPCREL 1167 && r_type != elfcpp::R_X86_64_GOTPCRELX 1168 && r_type != elfcpp::R_X86_64_REX_GOTPCRELX) 1169 return false; 1170 // We cannot convert references to IFUNC symbols, or to symbols that 1171 // are not local to the current module. 1172 // We can't do predefined symbols because they may become undefined 1173 // (e.g., __ehdr_start when the headers aren't mapped to a segment). 1174 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1175 || gsym->is_undefined() 1176 || gsym->is_predefined() 1177 || gsym->is_from_dynobj() 1178 || gsym->is_preemptible()) 1179 return false; 1180 // If we are building a shared object and the symbol is protected, we may 1181 // need to go through the GOT. 1182 if (parameters->options().shared() 1183 && gsym->visibility() == elfcpp::STV_PROTECTED) 1184 return false; 1185 // We cannot convert references to the _DYNAMIC symbol. 1186 if (strcmp(gsym->name(), "_DYNAMIC") == 0) 1187 return false; 1188 // Check for a MOV opcode. 1189 return (*view)[r_offset - 2] == 0x8b; 1190 } 1191 1192 // Convert 1193 // callq *foo@GOTPCRELX(%rip) to 1194 // addr32 callq foo 1195 // and jmpq *foo@GOTPCRELX(%rip) to 1196 // jmpq foo 1197 // nop 1198 template<class View_type> 1199 static inline bool 1200 can_convert_callq_to_direct(const Symbol* gsym, unsigned int r_type, 1201 size_t r_offset, View_type* view) 1202 { 1203 gold_assert(gsym != NULL); 1204 // We cannot do the conversion unless it's a GOTPCRELX relocation. 1205 if (r_type != elfcpp::R_X86_64_GOTPCRELX) 1206 return false; 1207 // We cannot convert references to IFUNC symbols, or to symbols that 1208 // are not local to the current module. 1209 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1210 || gsym->is_undefined () 1211 || gsym->is_from_dynobj() 1212 || gsym->is_preemptible()) 1213 return false; 1214 // Check for a CALLQ or JMPQ opcode. 1215 return ((*view)[r_offset - 2] == 0xff 1216 && ((*view)[r_offset - 1] == 0x15 1217 || (*view)[r_offset - 1] == 0x25)); 1218 } 1219 1220 // Adjust TLS relocation type based on the options and whether this 1221 // is a local symbol. 1222 static tls::Tls_optimization 1223 optimize_tls_reloc(bool is_final, int r_type); 1224 1225 // Get the GOT section, creating it if necessary. 1226 Output_data_got<64, false>* 1227 got_section(Symbol_table*, Layout*); 1228 1229 // Get the GOT PLT section. 1230 Output_data_got_plt_x86_64* 1231 got_plt_section() const 1232 { 1233 gold_assert(this->got_plt_ != NULL); 1234 return this->got_plt_; 1235 } 1236 1237 // Get the GOT section for TLSDESC entries. 1238 Output_data_got<64, false>* 1239 got_tlsdesc_section() const 1240 { 1241 gold_assert(this->got_tlsdesc_ != NULL); 1242 return this->got_tlsdesc_; 1243 } 1244 1245 // Create the PLT section. 1246 void 1247 make_plt_section(Symbol_table* symtab, Layout* layout); 1248 1249 // Create a PLT entry for a global symbol. 1250 void 1251 make_plt_entry(Symbol_table*, Layout*, Symbol*); 1252 1253 // Create a PLT entry for a local STT_GNU_IFUNC symbol. 1254 void 1255 make_local_ifunc_plt_entry(Symbol_table*, Layout*, 1256 Sized_relobj_file<size, false>* relobj, 1257 unsigned int local_sym_index); 1258 1259 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment. 1260 void 1261 define_tls_base_symbol(Symbol_table*, Layout*); 1262 1263 // Create the reserved PLT and GOT entries for the TLS descriptor resolver. 1264 void 1265 reserve_tlsdesc_entries(Symbol_table* symtab, Layout* layout); 1266 1267 // Create a GOT entry for the TLS module index. 1268 unsigned int 1269 got_mod_index_entry(Symbol_table* symtab, Layout* layout, 1270 Sized_relobj_file<size, false>* object); 1271 1272 // Get the PLT section. 1273 Output_data_plt_x86_64<size>* 1274 plt_section() const 1275 { 1276 gold_assert(this->plt_ != NULL); 1277 return this->plt_; 1278 } 1279 1280 // Get the dynamic reloc section, creating it if necessary. 1281 Reloc_section* 1282 rela_dyn_section(Layout*); 1283 1284 // Get the section to use for TLSDESC relocations. 1285 Reloc_section* 1286 rela_tlsdesc_section(Layout*) const; 1287 1288 // Get the section to use for IRELATIVE relocations. 1289 Reloc_section* 1290 rela_irelative_section(Layout*); 1291 1292 // Add a potential copy relocation. 1293 void 1294 copy_reloc(Symbol_table* symtab, Layout* layout, 1295 Sized_relobj_file<size, false>* object, 1296 unsigned int shndx, Output_section* output_section, 1297 Symbol* sym, const elfcpp::Rela<size, false>& reloc) 1298 { 1299 unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info()); 1300 this->copy_relocs_.copy_reloc(symtab, layout, 1301 symtab->get_sized_symbol<size>(sym), 1302 object, shndx, output_section, 1303 r_type, reloc.get_r_offset(), 1304 reloc.get_r_addend(), 1305 this->rela_dyn_section(layout)); 1306 } 1307 1308 // Record a target-specific program property in the .note.gnu.property 1309 // section. 1310 void 1311 record_gnu_property(unsigned int, unsigned int, size_t, 1312 const unsigned char*, const Object*); 1313 1314 // Merge the target-specific program properties from the current object. 1315 void 1316 merge_gnu_properties(const Object*); 1317 1318 // Finalize the target-specific program properties and add them back to 1319 // the layout. 1320 void 1321 do_finalize_gnu_properties(Layout*) const; 1322 1323 // Information about this specific target which we pass to the 1324 // general Target structure. 1325 static const Target::Target_info x86_64_info; 1326 1327 // The types of GOT entries needed for this platform. 1328 // These values are exposed to the ABI in an incremental link. 1329 // Do not renumber existing values without changing the version 1330 // number of the .gnu_incremental_inputs section. 1331 enum Got_type 1332 { 1333 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol 1334 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset 1335 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair 1336 GOT_TYPE_TLS_DESC = 3 // GOT entry for TLS_DESC pair 1337 }; 1338 1339 // This type is used as the argument to the target specific 1340 // relocation routines. The only target specific reloc is 1341 // R_X86_64_TLSDESC against a local symbol. 1342 struct Tlsdesc_info 1343 { 1344 Tlsdesc_info(Sized_relobj_file<size, false>* a_object, unsigned int a_r_sym) 1345 : object(a_object), r_sym(a_r_sym) 1346 { } 1347 1348 // The object in which the local symbol is defined. 1349 Sized_relobj_file<size, false>* object; 1350 // The local symbol index in the object. 1351 unsigned int r_sym; 1352 }; 1353 1354 // The GOT section. 1355 Output_data_got<64, false>* got_; 1356 // The PLT section. 1357 Output_data_plt_x86_64<size>* plt_; 1358 // The GOT PLT section. 1359 Output_data_got_plt_x86_64* got_plt_; 1360 // The GOT section for IRELATIVE relocations. 1361 Output_data_space* got_irelative_; 1362 // The GOT section for TLSDESC relocations. 1363 Output_data_got<64, false>* got_tlsdesc_; 1364 // The _GLOBAL_OFFSET_TABLE_ symbol. 1365 Symbol* global_offset_table_; 1366 // The dynamic reloc section. 1367 Reloc_section* rela_dyn_; 1368 // The section to use for IRELATIVE relocs. 1369 Reloc_section* rela_irelative_; 1370 // Relocs saved to avoid a COPY reloc. 1371 Copy_relocs<elfcpp::SHT_RELA, size, false> copy_relocs_; 1372 // Offset of the GOT entry for the TLS module index. 1373 unsigned int got_mod_index_offset_; 1374 // We handle R_X86_64_TLSDESC against a local symbol as a target 1375 // specific relocation. Here we store the object and local symbol 1376 // index for the relocation. 1377 std::vector<Tlsdesc_info> tlsdesc_reloc_info_; 1378 // True if the _TLS_MODULE_BASE_ symbol has been defined. 1379 bool tls_base_symbol_defined_; 1380 // Target-specific program properties, from .note.gnu.property section. 1381 // Each bit represents a specific feature. 1382 uint32_t isa_1_used_; 1383 uint32_t isa_1_needed_; 1384 uint32_t feature_1_; 1385 // Target-specific properties from the current object. 1386 // These bits get ORed into ISA_1_USED_ after all properties for the object 1387 // have been processed. But if either is all zeroes (as when the property 1388 // is absent from an object), the result should be all zeroes. 1389 // (See PR ld/23486.) 1390 uint32_t object_isa_1_used_; 1391 // These bits get ANDed into FEATURE_1_ after all properties for the object 1392 // have been processed. 1393 uint32_t object_feature_1_; 1394 // Whether we have seen our first object, for use in initializing FEATURE_1_. 1395 bool seen_first_object_; 1396 }; 1397 1398 template<> 1399 const Target::Target_info Target_x86_64<64>::x86_64_info = 1400 { 1401 64, // size 1402 false, // is_big_endian 1403 elfcpp::EM_X86_64, // machine_code 1404 false, // has_make_symbol 1405 false, // has_resolve 1406 true, // has_code_fill 1407 true, // is_default_stack_executable 1408 true, // can_icf_inline_merge_sections 1409 '\0', // wrap_char 1410 "/libexec/ld-elf.so.2", // program interpreter 1411 0x400000, // default_text_segment_address 1412 0x1000, // abi_pagesize (overridable by -z max-page-size) 1413 0x1000, // common_pagesize (overridable by -z common-page-size) 1414 false, // isolate_execinstr 1415 0, // rosegment_gap 1416 elfcpp::SHN_UNDEF, // small_common_shndx 1417 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx 1418 0, // small_common_section_flags 1419 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags 1420 NULL, // attributes_section 1421 NULL, // attributes_vendor 1422 "_start", // entry_symbol_name 1423 32, // hash_entry_size 1424 elfcpp::SHT_X86_64_UNWIND, // unwind_section_type 1425 }; 1426 1427 template<> 1428 const Target::Target_info Target_x86_64<32>::x86_64_info = 1429 { 1430 32, // size 1431 false, // is_big_endian 1432 elfcpp::EM_X86_64, // machine_code 1433 false, // has_make_symbol 1434 false, // has_resolve 1435 true, // has_code_fill 1436 true, // is_default_stack_executable 1437 true, // can_icf_inline_merge_sections 1438 '\0', // wrap_char 1439 "/libexec/ldx32.so.1", // program interpreter 1440 0x400000, // default_text_segment_address 1441 0x1000, // abi_pagesize (overridable by -z max-page-size) 1442 0x1000, // common_pagesize (overridable by -z common-page-size) 1443 false, // isolate_execinstr 1444 0, // rosegment_gap 1445 elfcpp::SHN_UNDEF, // small_common_shndx 1446 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx 1447 0, // small_common_section_flags 1448 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags 1449 NULL, // attributes_section 1450 NULL, // attributes_vendor 1451 "_start", // entry_symbol_name 1452 32, // hash_entry_size 1453 elfcpp::SHT_X86_64_UNWIND, // unwind_section_type 1454 }; 1455 1456 // This is called when a new output section is created. This is where 1457 // we handle the SHF_X86_64_LARGE. 1458 1459 template<int size> 1460 void 1461 Target_x86_64<size>::do_new_output_section(Output_section* os) const 1462 { 1463 if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0) 1464 os->set_is_large_section(); 1465 } 1466 1467 // Get the GOT section, creating it if necessary. 1468 1469 template<int size> 1470 Output_data_got<64, false>* 1471 Target_x86_64<size>::got_section(Symbol_table* symtab, Layout* layout) 1472 { 1473 if (this->got_ == NULL) 1474 { 1475 gold_assert(symtab != NULL && layout != NULL); 1476 1477 // When using -z now, we can treat .got.plt as a relro section. 1478 // Without -z now, it is modified after program startup by lazy 1479 // PLT relocations. 1480 bool is_got_plt_relro = parameters->options().now(); 1481 Output_section_order got_order = (is_got_plt_relro 1482 ? ORDER_RELRO 1483 : ORDER_RELRO_LAST); 1484 Output_section_order got_plt_order = (is_got_plt_relro 1485 ? ORDER_RELRO 1486 : ORDER_NON_RELRO_FIRST); 1487 1488 this->got_ = new Output_data_got<64, false>(); 1489 1490 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 1491 (elfcpp::SHF_ALLOC 1492 | elfcpp::SHF_WRITE), 1493 this->got_, got_order, true); 1494 1495 this->got_plt_ = new Output_data_got_plt_x86_64(layout); 1496 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 1497 (elfcpp::SHF_ALLOC 1498 | elfcpp::SHF_WRITE), 1499 this->got_plt_, got_plt_order, 1500 is_got_plt_relro); 1501 1502 // The first three entries are reserved. 1503 this->got_plt_->set_current_data_size(3 * 8); 1504 1505 if (!is_got_plt_relro) 1506 { 1507 // Those bytes can go into the relro segment. 1508 layout->increase_relro(3 * 8); 1509 } 1510 1511 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT. 1512 this->global_offset_table_ = 1513 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 1514 Symbol_table::PREDEFINED, 1515 this->got_plt_, 1516 0, 0, elfcpp::STT_OBJECT, 1517 elfcpp::STB_LOCAL, 1518 elfcpp::STV_HIDDEN, 0, 1519 false, false); 1520 1521 // If there are any IRELATIVE relocations, they get GOT entries 1522 // in .got.plt after the jump slot entries. 1523 this->got_irelative_ = new Output_data_space(8, "** GOT IRELATIVE PLT"); 1524 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 1525 (elfcpp::SHF_ALLOC 1526 | elfcpp::SHF_WRITE), 1527 this->got_irelative_, 1528 got_plt_order, is_got_plt_relro); 1529 1530 // If there are any TLSDESC relocations, they get GOT entries in 1531 // .got.plt after the jump slot and IRELATIVE entries. 1532 this->got_tlsdesc_ = new Output_data_got<64, false>(); 1533 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 1534 (elfcpp::SHF_ALLOC 1535 | elfcpp::SHF_WRITE), 1536 this->got_tlsdesc_, 1537 got_plt_order, is_got_plt_relro); 1538 } 1539 1540 return this->got_; 1541 } 1542 1543 // Get the dynamic reloc section, creating it if necessary. 1544 1545 template<int size> 1546 typename Target_x86_64<size>::Reloc_section* 1547 Target_x86_64<size>::rela_dyn_section(Layout* layout) 1548 { 1549 if (this->rela_dyn_ == NULL) 1550 { 1551 gold_assert(layout != NULL); 1552 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc()); 1553 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA, 1554 elfcpp::SHF_ALLOC, this->rela_dyn_, 1555 ORDER_DYNAMIC_RELOCS, false); 1556 } 1557 return this->rela_dyn_; 1558 } 1559 1560 // Get the section to use for IRELATIVE relocs, creating it if 1561 // necessary. These go in .rela.dyn, but only after all other dynamic 1562 // relocations. They need to follow the other dynamic relocations so 1563 // that they can refer to global variables initialized by those 1564 // relocs. 1565 1566 template<int size> 1567 typename Target_x86_64<size>::Reloc_section* 1568 Target_x86_64<size>::rela_irelative_section(Layout* layout) 1569 { 1570 if (this->rela_irelative_ == NULL) 1571 { 1572 // Make sure we have already created the dynamic reloc section. 1573 this->rela_dyn_section(layout); 1574 this->rela_irelative_ = new Reloc_section(false); 1575 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA, 1576 elfcpp::SHF_ALLOC, this->rela_irelative_, 1577 ORDER_DYNAMIC_RELOCS, false); 1578 gold_assert(this->rela_dyn_->output_section() 1579 == this->rela_irelative_->output_section()); 1580 } 1581 return this->rela_irelative_; 1582 } 1583 1584 // Record a target-specific program property from the .note.gnu.property 1585 // section. 1586 template<int size> 1587 void 1588 Target_x86_64<size>::record_gnu_property( 1589 unsigned int, unsigned int pr_type, 1590 size_t pr_datasz, const unsigned char* pr_data, 1591 const Object* object) 1592 { 1593 uint32_t val = 0; 1594 1595 switch (pr_type) 1596 { 1597 case elfcpp::GNU_PROPERTY_X86_ISA_1_USED: 1598 case elfcpp::GNU_PROPERTY_X86_ISA_1_NEEDED: 1599 case elfcpp::GNU_PROPERTY_X86_FEATURE_1_AND: 1600 if (pr_datasz != 4) 1601 { 1602 gold_warning(_("%s: corrupt .note.gnu.property section " 1603 "(pr_datasz for property %d is not 4)"), 1604 object->name().c_str(), pr_type); 1605 return; 1606 } 1607 val = elfcpp::Swap<32, false>::readval(pr_data); 1608 break; 1609 default: 1610 gold_warning(_("%s: unknown program property type 0x%x " 1611 "in .note.gnu.property section"), 1612 object->name().c_str(), pr_type); 1613 break; 1614 } 1615 1616 switch (pr_type) 1617 { 1618 case elfcpp::GNU_PROPERTY_X86_ISA_1_USED: 1619 this->object_isa_1_used_ |= val; 1620 break; 1621 case elfcpp::GNU_PROPERTY_X86_ISA_1_NEEDED: 1622 this->isa_1_needed_ |= val; 1623 break; 1624 case elfcpp::GNU_PROPERTY_X86_FEATURE_1_AND: 1625 // If we see multiple feature props in one object, OR them together. 1626 this->object_feature_1_ |= val; 1627 break; 1628 } 1629 } 1630 1631 // Merge the target-specific program properties from the current object. 1632 template<int size> 1633 void 1634 Target_x86_64<size>::merge_gnu_properties(const Object*) 1635 { 1636 if (this->seen_first_object_) 1637 { 1638 // If any object is missing the ISA_1_USED property, we must omit 1639 // it from the output file. 1640 if (this->object_isa_1_used_ == 0) 1641 this->isa_1_used_ = 0; 1642 else if (this->isa_1_used_ != 0) 1643 this->isa_1_used_ |= this->object_isa_1_used_; 1644 this->feature_1_ &= this->object_feature_1_; 1645 } 1646 else 1647 { 1648 this->isa_1_used_ = this->object_isa_1_used_; 1649 this->feature_1_ = this->object_feature_1_; 1650 this->seen_first_object_ = true; 1651 } 1652 this->object_isa_1_used_ = 0; 1653 this->object_feature_1_ = 0; 1654 } 1655 1656 static inline void 1657 add_property(Layout* layout, unsigned int pr_type, uint32_t val) 1658 { 1659 unsigned char buf[4]; 1660 elfcpp::Swap<32, false>::writeval(buf, val); 1661 layout->add_gnu_property(elfcpp::NT_GNU_PROPERTY_TYPE_0, pr_type, 4, buf); 1662 } 1663 1664 // Finalize the target-specific program properties and add them back to 1665 // the layout. 1666 template<int size> 1667 void 1668 Target_x86_64<size>::do_finalize_gnu_properties(Layout* layout) const 1669 { 1670 if (this->isa_1_used_ != 0) 1671 add_property(layout, elfcpp::GNU_PROPERTY_X86_ISA_1_USED, 1672 this->isa_1_used_); 1673 if (this->isa_1_needed_ != 0) 1674 add_property(layout, elfcpp::GNU_PROPERTY_X86_ISA_1_NEEDED, 1675 this->isa_1_needed_); 1676 if (this->feature_1_ != 0) 1677 add_property(layout, elfcpp::GNU_PROPERTY_X86_FEATURE_1_AND, 1678 this->feature_1_); 1679 } 1680 1681 // Write the first three reserved words of the .got.plt section. 1682 // The remainder of the section is written while writing the PLT 1683 // in Output_data_plt_i386::do_write. 1684 1685 void 1686 Output_data_got_plt_x86_64::do_write(Output_file* of) 1687 { 1688 // The first entry in the GOT is the address of the .dynamic section 1689 // aka the PT_DYNAMIC segment. The next two entries are reserved. 1690 // We saved space for them when we created the section in 1691 // Target_x86_64::got_section. 1692 const off_t got_file_offset = this->offset(); 1693 gold_assert(this->data_size() >= 24); 1694 unsigned char* const got_view = of->get_output_view(got_file_offset, 24); 1695 Output_section* dynamic = this->layout_->dynamic_section(); 1696 uint64_t dynamic_addr = dynamic == NULL ? 0 : dynamic->address(); 1697 elfcpp::Swap<64, false>::writeval(got_view, dynamic_addr); 1698 memset(got_view + 8, 0, 16); 1699 of->write_output_view(got_file_offset, 24, got_view); 1700 } 1701 1702 // Initialize the PLT section. 1703 1704 template<int size> 1705 void 1706 Output_data_plt_x86_64<size>::init(Layout* layout) 1707 { 1708 this->rel_ = new Reloc_section(false); 1709 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 1710 elfcpp::SHF_ALLOC, this->rel_, 1711 ORDER_DYNAMIC_PLT_RELOCS, false); 1712 } 1713 1714 template<int size> 1715 void 1716 Output_data_plt_x86_64<size>::do_adjust_output_section(Output_section* os) 1717 { 1718 os->set_entsize(this->get_plt_entry_size()); 1719 } 1720 1721 // Add an entry to the PLT. 1722 1723 template<int size> 1724 void 1725 Output_data_plt_x86_64<size>::add_entry(Symbol_table* symtab, Layout* layout, 1726 Symbol* gsym) 1727 { 1728 gold_assert(!gsym->has_plt_offset()); 1729 1730 unsigned int plt_index; 1731 off_t plt_offset; 1732 section_offset_type got_offset; 1733 1734 unsigned int* pcount; 1735 unsigned int offset; 1736 unsigned int reserved; 1737 Output_section_data_build* got; 1738 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1739 && gsym->can_use_relative_reloc(false)) 1740 { 1741 pcount = &this->irelative_count_; 1742 offset = 0; 1743 reserved = 0; 1744 got = this->got_irelative_; 1745 } 1746 else 1747 { 1748 pcount = &this->count_; 1749 offset = 1; 1750 reserved = 3; 1751 got = this->got_plt_; 1752 } 1753 1754 if (!this->is_data_size_valid()) 1755 { 1756 // Note that when setting the PLT offset for a non-IRELATIVE 1757 // entry we skip the initial reserved PLT entry. 1758 plt_index = *pcount + offset; 1759 plt_offset = plt_index * this->get_plt_entry_size(); 1760 1761 ++*pcount; 1762 1763 got_offset = (plt_index - offset + reserved) * 8; 1764 gold_assert(got_offset == got->current_data_size()); 1765 1766 // Every PLT entry needs a GOT entry which points back to the PLT 1767 // entry (this will be changed by the dynamic linker, normally 1768 // lazily when the function is called). 1769 got->set_current_data_size(got_offset + 8); 1770 } 1771 else 1772 { 1773 // FIXME: This is probably not correct for IRELATIVE relocs. 1774 1775 // For incremental updates, find an available slot. 1776 plt_offset = this->free_list_.allocate(this->get_plt_entry_size(), 1777 this->get_plt_entry_size(), 0); 1778 if (plt_offset == -1) 1779 gold_fallback(_("out of patch space (PLT);" 1780 " relink with --incremental-full")); 1781 1782 // The GOT and PLT entries have a 1-1 correspondance, so the GOT offset 1783 // can be calculated from the PLT index, adjusting for the three 1784 // reserved entries at the beginning of the GOT. 1785 plt_index = plt_offset / this->get_plt_entry_size() - 1; 1786 got_offset = (plt_index - offset + reserved) * 8; 1787 } 1788 1789 gsym->set_plt_offset(plt_offset); 1790 1791 // Every PLT entry needs a reloc. 1792 this->add_relocation(symtab, layout, gsym, got_offset); 1793 1794 // Note that we don't need to save the symbol. The contents of the 1795 // PLT are independent of which symbols are used. The symbols only 1796 // appear in the relocations. 1797 } 1798 1799 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return 1800 // the PLT offset. 1801 1802 template<int size> 1803 unsigned int 1804 Output_data_plt_x86_64<size>::add_local_ifunc_entry( 1805 Symbol_table* symtab, 1806 Layout* layout, 1807 Sized_relobj_file<size, false>* relobj, 1808 unsigned int local_sym_index) 1809 { 1810 unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size(); 1811 ++this->irelative_count_; 1812 1813 section_offset_type got_offset = this->got_irelative_->current_data_size(); 1814 1815 // Every PLT entry needs a GOT entry which points back to the PLT 1816 // entry. 1817 this->got_irelative_->set_current_data_size(got_offset + 8); 1818 1819 // Every PLT entry needs a reloc. 1820 Reloc_section* rela = this->rela_irelative(symtab, layout); 1821 rela->add_symbolless_local_addend(relobj, local_sym_index, 1822 elfcpp::R_X86_64_IRELATIVE, 1823 this->got_irelative_, got_offset, 0); 1824 1825 return plt_offset; 1826 } 1827 1828 // Add the relocation for a PLT entry. 1829 1830 template<int size> 1831 void 1832 Output_data_plt_x86_64<size>::add_relocation(Symbol_table* symtab, 1833 Layout* layout, 1834 Symbol* gsym, 1835 unsigned int got_offset) 1836 { 1837 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1838 && gsym->can_use_relative_reloc(false)) 1839 { 1840 Reloc_section* rela = this->rela_irelative(symtab, layout); 1841 rela->add_symbolless_global_addend(gsym, elfcpp::R_X86_64_IRELATIVE, 1842 this->got_irelative_, got_offset, 0); 1843 } 1844 else 1845 { 1846 gsym->set_needs_dynsym_entry(); 1847 this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_, 1848 got_offset, 0); 1849 } 1850 } 1851 1852 // Return where the TLSDESC relocations should go, creating it if 1853 // necessary. These follow the JUMP_SLOT relocations. 1854 1855 template<int size> 1856 typename Output_data_plt_x86_64<size>::Reloc_section* 1857 Output_data_plt_x86_64<size>::rela_tlsdesc(Layout* layout) 1858 { 1859 if (this->tlsdesc_rel_ == NULL) 1860 { 1861 this->tlsdesc_rel_ = new Reloc_section(false); 1862 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 1863 elfcpp::SHF_ALLOC, this->tlsdesc_rel_, 1864 ORDER_DYNAMIC_PLT_RELOCS, false); 1865 gold_assert(this->tlsdesc_rel_->output_section() 1866 == this->rel_->output_section()); 1867 } 1868 return this->tlsdesc_rel_; 1869 } 1870 1871 // Return where the IRELATIVE relocations should go in the PLT. These 1872 // follow the JUMP_SLOT and the TLSDESC relocations. 1873 1874 template<int size> 1875 typename Output_data_plt_x86_64<size>::Reloc_section* 1876 Output_data_plt_x86_64<size>::rela_irelative(Symbol_table* symtab, 1877 Layout* layout) 1878 { 1879 if (this->irelative_rel_ == NULL) 1880 { 1881 // Make sure we have a place for the TLSDESC relocations, in 1882 // case we see any later on. 1883 this->rela_tlsdesc(layout); 1884 this->irelative_rel_ = new Reloc_section(false); 1885 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 1886 elfcpp::SHF_ALLOC, this->irelative_rel_, 1887 ORDER_DYNAMIC_PLT_RELOCS, false); 1888 gold_assert(this->irelative_rel_->output_section() 1889 == this->rel_->output_section()); 1890 1891 if (parameters->doing_static_link()) 1892 { 1893 // A statically linked executable will only have a .rela.plt 1894 // section to hold R_X86_64_IRELATIVE relocs for 1895 // STT_GNU_IFUNC symbols. The library will use these 1896 // symbols to locate the IRELATIVE relocs at program startup 1897 // time. 1898 symtab->define_in_output_data("__rela_iplt_start", NULL, 1899 Symbol_table::PREDEFINED, 1900 this->irelative_rel_, 0, 0, 1901 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1902 elfcpp::STV_HIDDEN, 0, false, true); 1903 symtab->define_in_output_data("__rela_iplt_end", NULL, 1904 Symbol_table::PREDEFINED, 1905 this->irelative_rel_, 0, 0, 1906 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1907 elfcpp::STV_HIDDEN, 0, true, true); 1908 } 1909 } 1910 return this->irelative_rel_; 1911 } 1912 1913 // Return the PLT address to use for a global symbol. 1914 1915 template<int size> 1916 uint64_t 1917 Output_data_plt_x86_64<size>::do_address_for_global(const Symbol* gsym) 1918 { 1919 uint64_t offset = 0; 1920 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1921 && gsym->can_use_relative_reloc(false)) 1922 offset = (this->count_ + 1) * this->get_plt_entry_size(); 1923 return this->address() + offset + gsym->plt_offset(); 1924 } 1925 1926 // Return the PLT address to use for a local symbol. These are always 1927 // IRELATIVE relocs. 1928 1929 template<int size> 1930 uint64_t 1931 Output_data_plt_x86_64<size>::do_address_for_local(const Relobj* object, 1932 unsigned int r_sym) 1933 { 1934 return (this->address() 1935 + (this->count_ + 1) * this->get_plt_entry_size() 1936 + object->local_plt_offset(r_sym)); 1937 } 1938 1939 // Set the final size. 1940 template<int size> 1941 void 1942 Output_data_plt_x86_64<size>::set_final_data_size() 1943 { 1944 // Number of regular and IFUNC PLT entries, plus the first entry. 1945 unsigned int count = this->count_ + this->irelative_count_ + 1; 1946 // Count the TLSDESC entry, if present. 1947 if (this->has_tlsdesc_entry()) 1948 ++count; 1949 this->set_data_size(count * this->get_plt_entry_size()); 1950 } 1951 1952 // The first entry in the PLT for an executable. 1953 1954 template<int size> 1955 const unsigned char 1956 Output_data_plt_x86_64_standard<size>::first_plt_entry[plt_entry_size] = 1957 { 1958 // From AMD64 ABI Draft 0.98, page 76 1959 0xff, 0x35, // pushq contents of memory address 1960 0, 0, 0, 0, // replaced with address of .got + 8 1961 0xff, 0x25, // jmp indirect 1962 0, 0, 0, 0, // replaced with address of .got + 16 1963 0x90, 0x90, 0x90, 0x90 // noop (x4) 1964 }; 1965 1966 template<int size> 1967 void 1968 Output_data_plt_x86_64_standard<size>::do_fill_first_plt_entry( 1969 unsigned char* pov, 1970 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 1971 typename elfcpp::Elf_types<size>::Elf_Addr plt_address) 1972 { 1973 memcpy(pov, first_plt_entry, plt_entry_size); 1974 // We do a jmp relative to the PC at the end of this instruction. 1975 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 1976 (got_address + 8 1977 - (plt_address + 6))); 1978 elfcpp::Swap<32, false>::writeval(pov + 8, 1979 (got_address + 16 1980 - (plt_address + 12))); 1981 } 1982 1983 // Subsequent entries in the PLT for an executable. 1984 1985 template<int size> 1986 const unsigned char 1987 Output_data_plt_x86_64_standard<size>::plt_entry[plt_entry_size] = 1988 { 1989 // From AMD64 ABI Draft 0.98, page 76 1990 0xff, 0x25, // jmpq indirect 1991 0, 0, 0, 0, // replaced with address of symbol in .got 1992 0x68, // pushq immediate 1993 0, 0, 0, 0, // replaced with offset into relocation table 1994 0xe9, // jmpq relative 1995 0, 0, 0, 0 // replaced with offset to start of .plt 1996 }; 1997 1998 template<int size> 1999 unsigned int 2000 Output_data_plt_x86_64_standard<size>::do_fill_plt_entry( 2001 unsigned char* pov, 2002 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 2003 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 2004 unsigned int got_offset, 2005 unsigned int plt_offset, 2006 unsigned int plt_index) 2007 { 2008 // Check PC-relative offset overflow in PLT entry. 2009 uint64_t plt_got_pcrel_offset = (got_address + got_offset 2010 - (plt_address + plt_offset + 6)); 2011 if (Bits<32>::has_overflow(plt_got_pcrel_offset)) 2012 gold_error(_("PC-relative offset overflow in PLT entry %d"), 2013 plt_index + 1); 2014 2015 memcpy(pov, plt_entry, plt_entry_size); 2016 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 2017 plt_got_pcrel_offset); 2018 2019 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_index); 2020 elfcpp::Swap<32, false>::writeval(pov + 12, 2021 - (plt_offset + plt_entry_size)); 2022 2023 return 6; 2024 } 2025 2026 // The reserved TLSDESC entry in the PLT for an executable. 2027 2028 template<int size> 2029 const unsigned char 2030 Output_data_plt_x86_64_standard<size>::tlsdesc_plt_entry[plt_entry_size] = 2031 { 2032 // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32 2033 // and AMD64/EM64T", Version 0.9.4 (2005-10-10). 2034 0xff, 0x35, // pushq x(%rip) 2035 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8) 2036 0xff, 0x25, // jmpq *y(%rip) 2037 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry 2038 0x0f, 0x1f, // nop 2039 0x40, 0 2040 }; 2041 2042 template<int size> 2043 void 2044 Output_data_plt_x86_64_standard<size>::do_fill_tlsdesc_entry( 2045 unsigned char* pov, 2046 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 2047 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 2048 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 2049 unsigned int tlsdesc_got_offset, 2050 unsigned int plt_offset) 2051 { 2052 memcpy(pov, tlsdesc_plt_entry, plt_entry_size); 2053 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 2054 (got_address + 8 2055 - (plt_address + plt_offset 2056 + 6))); 2057 elfcpp::Swap_unaligned<32, false>::writeval(pov + 8, 2058 (got_base 2059 + tlsdesc_got_offset 2060 - (plt_address + plt_offset 2061 + 12))); 2062 } 2063 2064 // Return the APLT address to use for a global symbol (for -z bndplt). 2065 2066 uint64_t 2067 Output_data_plt_x86_64_bnd::do_address_for_global(const Symbol* gsym) 2068 { 2069 uint64_t offset = this->aplt_offset_; 2070 // Convert the PLT offset into an APLT offset. 2071 unsigned int plt_offset = gsym->plt_offset(); 2072 if (gsym->type() == elfcpp::STT_GNU_IFUNC 2073 && gsym->can_use_relative_reloc(false)) 2074 offset += this->regular_count() * aplt_entry_size; 2075 else 2076 plt_offset -= plt_entry_size; 2077 plt_offset = plt_offset / (plt_entry_size / aplt_entry_size); 2078 return this->address() + offset + plt_offset; 2079 } 2080 2081 // Return the PLT address to use for a local symbol. These are always 2082 // IRELATIVE relocs. 2083 2084 uint64_t 2085 Output_data_plt_x86_64_bnd::do_address_for_local(const Relobj* object, 2086 unsigned int r_sym) 2087 { 2088 // Convert the PLT offset into an APLT offset. 2089 unsigned int plt_offset = ((object->local_plt_offset(r_sym) - plt_entry_size) 2090 / (plt_entry_size / aplt_entry_size)); 2091 return (this->address() 2092 + this->aplt_offset_ 2093 + this->regular_count() * aplt_entry_size 2094 + plt_offset); 2095 } 2096 2097 // Set the final size. 2098 void 2099 Output_data_plt_x86_64_bnd::set_final_data_size() 2100 { 2101 // Number of regular and IFUNC PLT entries. 2102 unsigned int count = this->entry_count(); 2103 // Count the first entry and the TLSDESC entry, if present. 2104 unsigned int extra = this->has_tlsdesc_entry() ? 2 : 1; 2105 unsigned int plt_size = (count + extra) * plt_entry_size; 2106 // Offset of the APLT. 2107 this->aplt_offset_ = plt_size; 2108 // Size of the APLT. 2109 plt_size += count * aplt_entry_size; 2110 this->set_data_size(plt_size); 2111 } 2112 2113 // The first entry in the BND PLT. 2114 2115 const unsigned char 2116 Output_data_plt_x86_64_bnd::first_plt_entry[plt_entry_size] = 2117 { 2118 // From AMD64 ABI Draft 0.98, page 76 2119 0xff, 0x35, // pushq contents of memory address 2120 0, 0, 0, 0, // replaced with address of .got + 8 2121 0xf2, 0xff, 0x25, // bnd jmp indirect 2122 0, 0, 0, 0, // replaced with address of .got + 16 2123 0x0f, 0x1f, 0x00 // nop 2124 }; 2125 2126 void 2127 Output_data_plt_x86_64_bnd::do_fill_first_plt_entry( 2128 unsigned char* pov, 2129 elfcpp::Elf_types<64>::Elf_Addr got_address, 2130 elfcpp::Elf_types<64>::Elf_Addr plt_address) 2131 { 2132 memcpy(pov, first_plt_entry, plt_entry_size); 2133 // We do a jmp relative to the PC at the end of this instruction. 2134 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 2135 (got_address + 8 2136 - (plt_address + 6))); 2137 elfcpp::Swap<32, false>::writeval(pov + 9, 2138 (got_address + 16 2139 - (plt_address + 13))); 2140 } 2141 2142 // Subsequent entries in the BND PLT. 2143 2144 const unsigned char 2145 Output_data_plt_x86_64_bnd::plt_entry[plt_entry_size] = 2146 { 2147 // From AMD64 ABI Draft 0.99.8, page 139 2148 0x68, // pushq immediate 2149 0, 0, 0, 0, // replaced with offset into relocation table 2150 0xf2, 0xe9, // bnd jmpq relative 2151 0, 0, 0, 0, // replaced with offset to start of .plt 2152 0x0f, 0x1f, 0x44, 0, 0 // nop 2153 }; 2154 2155 // Entries in the BND Additional PLT. 2156 2157 const unsigned char 2158 Output_data_plt_x86_64_bnd::aplt_entry[aplt_entry_size] = 2159 { 2160 // From AMD64 ABI Draft 0.99.8, page 139 2161 0xf2, 0xff, 0x25, // bnd jmpq indirect 2162 0, 0, 0, 0, // replaced with address of symbol in .got 2163 0x90, // nop 2164 }; 2165 2166 unsigned int 2167 Output_data_plt_x86_64_bnd::do_fill_plt_entry( 2168 unsigned char* pov, 2169 elfcpp::Elf_types<64>::Elf_Addr, 2170 elfcpp::Elf_types<64>::Elf_Addr, 2171 unsigned int, 2172 unsigned int plt_offset, 2173 unsigned int plt_index) 2174 { 2175 memcpy(pov, plt_entry, plt_entry_size); 2176 elfcpp::Swap_unaligned<32, false>::writeval(pov + 1, plt_index); 2177 elfcpp::Swap<32, false>::writeval(pov + 7, -(plt_offset + 11)); 2178 return 0; 2179 } 2180 2181 void 2182 Output_data_plt_x86_64_bnd::fill_aplt_entry( 2183 unsigned char* pov, 2184 elfcpp::Elf_types<64>::Elf_Addr got_address, 2185 elfcpp::Elf_types<64>::Elf_Addr plt_address, 2186 unsigned int got_offset, 2187 unsigned int plt_offset, 2188 unsigned int plt_index) 2189 { 2190 // Check PC-relative offset overflow in PLT entry. 2191 uint64_t plt_got_pcrel_offset = (got_address + got_offset 2192 - (plt_address + plt_offset + 7)); 2193 if (Bits<32>::has_overflow(plt_got_pcrel_offset)) 2194 gold_error(_("PC-relative offset overflow in APLT entry %d"), 2195 plt_index + 1); 2196 2197 memcpy(pov, aplt_entry, aplt_entry_size); 2198 elfcpp::Swap_unaligned<32, false>::writeval(pov + 3, plt_got_pcrel_offset); 2199 } 2200 2201 // The reserved TLSDESC entry in the PLT for an executable. 2202 2203 const unsigned char 2204 Output_data_plt_x86_64_bnd::tlsdesc_plt_entry[plt_entry_size] = 2205 { 2206 // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32 2207 // and AMD64/EM64T", Version 0.9.4 (2005-10-10). 2208 0xff, 0x35, // pushq x(%rip) 2209 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8) 2210 0xf2, 0xff, 0x25, // jmpq *y(%rip) 2211 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry 2212 0x0f, 0x1f, 0 // nop 2213 }; 2214 2215 void 2216 Output_data_plt_x86_64_bnd::do_fill_tlsdesc_entry( 2217 unsigned char* pov, 2218 elfcpp::Elf_types<64>::Elf_Addr got_address, 2219 elfcpp::Elf_types<64>::Elf_Addr plt_address, 2220 elfcpp::Elf_types<64>::Elf_Addr got_base, 2221 unsigned int tlsdesc_got_offset, 2222 unsigned int plt_offset) 2223 { 2224 memcpy(pov, tlsdesc_plt_entry, plt_entry_size); 2225 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 2226 (got_address + 8 2227 - (plt_address + plt_offset 2228 + 6))); 2229 elfcpp::Swap_unaligned<32, false>::writeval(pov + 9, 2230 (got_base 2231 + tlsdesc_got_offset 2232 - (plt_address + plt_offset 2233 + 13))); 2234 } 2235 2236 // Return the APLT address to use for a global symbol (for IBT). 2237 2238 template<int size> 2239 uint64_t 2240 Output_data_plt_x86_64_ibt<size>::do_address_for_global(const Symbol* gsym) 2241 { 2242 uint64_t offset = this->aplt_offset_; 2243 // Convert the PLT offset into an APLT offset. 2244 unsigned int plt_offset = gsym->plt_offset(); 2245 if (gsym->type() == elfcpp::STT_GNU_IFUNC 2246 && gsym->can_use_relative_reloc(false)) 2247 offset += this->regular_count() * aplt_entry_size; 2248 else 2249 plt_offset -= plt_entry_size; 2250 plt_offset = plt_offset / (plt_entry_size / aplt_entry_size); 2251 return this->address() + offset + plt_offset; 2252 } 2253 2254 // Return the PLT address to use for a local symbol. These are always 2255 // IRELATIVE relocs. 2256 2257 template<int size> 2258 uint64_t 2259 Output_data_plt_x86_64_ibt<size>::do_address_for_local(const Relobj* object, 2260 unsigned int r_sym) 2261 { 2262 // Convert the PLT offset into an APLT offset. 2263 unsigned int plt_offset = ((object->local_plt_offset(r_sym) - plt_entry_size) 2264 / (plt_entry_size / aplt_entry_size)); 2265 return (this->address() 2266 + this->aplt_offset_ 2267 + this->regular_count() * aplt_entry_size 2268 + plt_offset); 2269 } 2270 2271 // Set the final size. 2272 2273 template<int size> 2274 void 2275 Output_data_plt_x86_64_ibt<size>::set_final_data_size() 2276 { 2277 // Number of regular and IFUNC PLT entries. 2278 unsigned int count = this->entry_count(); 2279 // Count the first entry and the TLSDESC entry, if present. 2280 unsigned int extra = this->has_tlsdesc_entry() ? 2 : 1; 2281 unsigned int plt_size = (count + extra) * plt_entry_size; 2282 // Offset of the APLT. 2283 this->aplt_offset_ = plt_size; 2284 // Size of the APLT. 2285 plt_size += count * aplt_entry_size; 2286 this->set_data_size(plt_size); 2287 } 2288 2289 // The first entry in the IBT PLT. 2290 2291 template<> 2292 const unsigned char 2293 Output_data_plt_x86_64_ibt<32>::first_plt_entry[plt_entry_size] = 2294 { 2295 // MPX isn't supported for x32, so we don't need the BND prefix. 2296 // From AMD64 ABI Draft 0.98, page 76 2297 0xff, 0x35, // pushq contents of memory address 2298 0, 0, 0, 0, // replaced with address of .got + 8 2299 0xff, 0x25, // jmp indirect 2300 0, 0, 0, 0, // replaced with address of .got + 16 2301 0x90, 0x90, 0x90, 0x90 // noop (x4) 2302 }; 2303 2304 template<> 2305 const unsigned char 2306 Output_data_plt_x86_64_ibt<64>::first_plt_entry[plt_entry_size] = 2307 { 2308 // Use the BND prefix so that IBT is compatible with MPX. 2309 0xff, 0x35, // pushq contents of memory address 2310 0, 0, 0, 0, // replaced with address of .got + 8 2311 0xf2, 0xff, 0x25, // bnd jmp indirect 2312 0, 0, 0, 0, // replaced with address of .got + 16 2313 0x0f, 0x1f, 0x00 // nop 2314 }; 2315 2316 template<int size> 2317 void 2318 Output_data_plt_x86_64_ibt<size>::do_fill_first_plt_entry( 2319 unsigned char* pov, 2320 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 2321 typename elfcpp::Elf_types<size>::Elf_Addr plt_address) 2322 { 2323 // Offsets to the addresses needing relocation. 2324 const unsigned int roff1 = 2; 2325 const unsigned int roff2 = (size == 32) ? 8 : 9; 2326 2327 memcpy(pov, first_plt_entry, plt_entry_size); 2328 // We do a jmp relative to the PC at the end of this instruction. 2329 elfcpp::Swap_unaligned<32, false>::writeval(pov + roff1, 2330 (got_address + 8 2331 - (plt_address + roff1 + 4))); 2332 elfcpp::Swap<32, false>::writeval(pov + roff2, 2333 (got_address + 16 2334 - (plt_address + roff2 + 4))); 2335 } 2336 2337 // Subsequent entries in the IBT PLT. 2338 2339 template<> 2340 const unsigned char 2341 Output_data_plt_x86_64_ibt<32>::plt_entry[plt_entry_size] = 2342 { 2343 // From AMD64 ABI Draft 1.0-rc1, Chapter 13. 2344 0xf3, 0x0f, 0x1e, 0xfa, // endbr64 2345 0x68, // pushq immediate 2346 0, 0, 0, 0, // replaced with offset into relocation table 2347 0xe9, // jmpq relative 2348 0, 0, 0, 0, // replaced with offset to start of .plt 2349 0x90, 0x90 // nop 2350 }; 2351 2352 template<> 2353 const unsigned char 2354 Output_data_plt_x86_64_ibt<64>::plt_entry[plt_entry_size] = 2355 { 2356 // From AMD64 ABI Draft 1.0-rc1, Chapter 13. 2357 0xf3, 0x0f, 0x1e, 0xfa, // endbr64 2358 0x68, // pushq immediate 2359 0, 0, 0, 0, // replaced with offset into relocation table 2360 0xf2, 0xe9, // bnd jmpq relative 2361 0, 0, 0, 0, // replaced with offset to start of .plt 2362 0x90 // nop 2363 }; 2364 2365 // Entries in the IBT Additional PLT. 2366 2367 template<> 2368 const unsigned char 2369 Output_data_plt_x86_64_ibt<32>::aplt_entry[aplt_entry_size] = 2370 { 2371 // From AMD64 ABI Draft 1.0-rc1, Chapter 13. 2372 0xf3, 0x0f, 0x1e, 0xfa, // endbr64 2373 0xff, 0x25, // jmpq indirect 2374 0, 0, 0, 0, // replaced with address of symbol in .got 2375 0x0f, 0x1f, 0x04, 0x00, // nop 2376 0x90, 0x90 // nop 2377 }; 2378 2379 template<> 2380 const unsigned char 2381 Output_data_plt_x86_64_ibt<64>::aplt_entry[aplt_entry_size] = 2382 { 2383 // From AMD64 ABI Draft 1.0-rc1, Chapter 13. 2384 0xf3, 0x0f, 0x1e, 0xfa, // endbr64 2385 0xf2, 0xff, 0x25, // bnd jmpq indirect 2386 0, 0, 0, 0, // replaced with address of symbol in .got 2387 0x0f, 0x1f, 0x04, 0x00, // nop 2388 0x90, // nop 2389 }; 2390 2391 template<int size> 2392 unsigned int 2393 Output_data_plt_x86_64_ibt<size>::do_fill_plt_entry( 2394 unsigned char* pov, 2395 typename elfcpp::Elf_types<size>::Elf_Addr, 2396 typename elfcpp::Elf_types<size>::Elf_Addr, 2397 unsigned int, 2398 unsigned int plt_offset, 2399 unsigned int plt_index) 2400 { 2401 // Offsets to the addresses needing relocation. 2402 const unsigned int roff1 = 5; 2403 const unsigned int roff2 = (size == 32) ? 10 : 11; 2404 2405 memcpy(pov, plt_entry, plt_entry_size); 2406 elfcpp::Swap_unaligned<32, false>::writeval(pov + roff1, plt_index); 2407 elfcpp::Swap<32, false>::writeval(pov + roff2, -(plt_offset + roff2 + 4)); 2408 return 0; 2409 } 2410 2411 template<int size> 2412 void 2413 Output_data_plt_x86_64_ibt<size>::fill_aplt_entry( 2414 unsigned char* pov, 2415 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 2416 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 2417 unsigned int got_offset, 2418 unsigned int plt_offset, 2419 unsigned int plt_index) 2420 { 2421 // Offset to the address needing relocation. 2422 const unsigned int roff = (size == 32) ? 6 : 7; 2423 2424 // Check PC-relative offset overflow in PLT entry. 2425 uint64_t plt_got_pcrel_offset = (got_address + got_offset 2426 - (plt_address + plt_offset + roff + 4)); 2427 if (Bits<32>::has_overflow(plt_got_pcrel_offset)) 2428 gold_error(_("PC-relative offset overflow in APLT entry %d"), 2429 plt_index + 1); 2430 2431 memcpy(pov, aplt_entry, aplt_entry_size); 2432 elfcpp::Swap_unaligned<32, false>::writeval(pov + roff, plt_got_pcrel_offset); 2433 } 2434 2435 // The reserved TLSDESC entry in the IBT PLT for an executable. 2436 2437 template<int size> 2438 const unsigned char 2439 Output_data_plt_x86_64_ibt<size>::tlsdesc_plt_entry[plt_entry_size] = 2440 { 2441 // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32 2442 // and AMD64/EM64T", Version 0.9.4 (2005-10-10). 2443 0xff, 0x35, // pushq x(%rip) 2444 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8) 2445 0xf2, 0xff, 0x25, // jmpq *y(%rip) 2446 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry 2447 0x0f, 0x1f, 0 // nop 2448 }; 2449 2450 template<int size> 2451 void 2452 Output_data_plt_x86_64_ibt<size>::do_fill_tlsdesc_entry( 2453 unsigned char* pov, 2454 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 2455 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 2456 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 2457 unsigned int tlsdesc_got_offset, 2458 unsigned int plt_offset) 2459 { 2460 memcpy(pov, tlsdesc_plt_entry, plt_entry_size); 2461 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 2462 (got_address + 8 2463 - (plt_address + plt_offset 2464 + 6))); 2465 elfcpp::Swap_unaligned<32, false>::writeval(pov + 9, 2466 (got_base 2467 + tlsdesc_got_offset 2468 - (plt_address + plt_offset 2469 + 13))); 2470 } 2471 2472 // The .eh_frame unwind information for the PLT. 2473 2474 template<int size> 2475 const unsigned char 2476 Output_data_plt_x86_64<size>::plt_eh_frame_cie[plt_eh_frame_cie_size] = 2477 { 2478 1, // CIE version. 2479 'z', // Augmentation: augmentation size included. 2480 'R', // Augmentation: FDE encoding included. 2481 '\0', // End of augmentation string. 2482 1, // Code alignment factor. 2483 0x78, // Data alignment factor. 2484 16, // Return address column. 2485 1, // Augmentation size. 2486 (elfcpp::DW_EH_PE_pcrel // FDE encoding. 2487 | elfcpp::DW_EH_PE_sdata4), 2488 elfcpp::DW_CFA_def_cfa, 7, 8, // DW_CFA_def_cfa: r7 (rsp) ofs 8. 2489 elfcpp::DW_CFA_offset + 16, 1,// DW_CFA_offset: r16 (rip) at cfa-8. 2490 elfcpp::DW_CFA_nop, // Align to 16 bytes. 2491 elfcpp::DW_CFA_nop 2492 }; 2493 2494 template<int size> 2495 const unsigned char 2496 Output_data_plt_x86_64_standard<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] = 2497 { 2498 0, 0, 0, 0, // Replaced with offset to .plt. 2499 0, 0, 0, 0, // Replaced with size of .plt. 2500 0, // Augmentation size. 2501 elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16. 2502 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 2503 elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24. 2504 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16. 2505 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 2506 11, // Block length. 2507 elfcpp::DW_OP_breg7, 8, // Push %rsp + 8. 2508 elfcpp::DW_OP_breg16, 0, // Push %rip. 2509 elfcpp::DW_OP_lit15, // Push 0xf. 2510 elfcpp::DW_OP_and, // & (%rip & 0xf). 2511 elfcpp::DW_OP_lit11, // Push 0xb. 2512 elfcpp::DW_OP_ge, // >= ((%rip & 0xf) >= 0xb) 2513 elfcpp::DW_OP_lit3, // Push 3. 2514 elfcpp::DW_OP_shl, // << (((%rip & 0xf) >= 0xb) << 3) 2515 elfcpp::DW_OP_plus, // + ((((%rip&0xf)>=0xb)<<3)+%rsp+8 2516 elfcpp::DW_CFA_nop, // Align to 32 bytes. 2517 elfcpp::DW_CFA_nop, 2518 elfcpp::DW_CFA_nop, 2519 elfcpp::DW_CFA_nop 2520 }; 2521 2522 // The .eh_frame unwind information for the BND PLT. 2523 const unsigned char 2524 Output_data_plt_x86_64_bnd::plt_eh_frame_fde[plt_eh_frame_fde_size] = 2525 { 2526 0, 0, 0, 0, // Replaced with offset to .plt. 2527 0, 0, 0, 0, // Replaced with size of .plt. 2528 0, // Augmentation size. 2529 elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16. 2530 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 2531 elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24. 2532 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16. 2533 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 2534 11, // Block length. 2535 elfcpp::DW_OP_breg7, 8, // Push %rsp + 8. 2536 elfcpp::DW_OP_breg16, 0, // Push %rip. 2537 elfcpp::DW_OP_lit15, // Push 0xf. 2538 elfcpp::DW_OP_and, // & (%rip & 0xf). 2539 elfcpp::DW_OP_lit5, // Push 5. 2540 elfcpp::DW_OP_ge, // >= ((%rip & 0xf) >= 5) 2541 elfcpp::DW_OP_lit3, // Push 3. 2542 elfcpp::DW_OP_shl, // << (((%rip & 0xf) >= 5) << 3) 2543 elfcpp::DW_OP_plus, // + ((((%rip&0xf)>=5)<<3)+%rsp+8 2544 elfcpp::DW_CFA_nop, // Align to 32 bytes. 2545 elfcpp::DW_CFA_nop, 2546 elfcpp::DW_CFA_nop, 2547 elfcpp::DW_CFA_nop 2548 }; 2549 2550 // The .eh_frame unwind information for the BND PLT. 2551 template<int size> 2552 const unsigned char 2553 Output_data_plt_x86_64_ibt<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] = 2554 { 2555 0, 0, 0, 0, // Replaced with offset to .plt. 2556 0, 0, 0, 0, // Replaced with size of .plt. 2557 0, // Augmentation size. 2558 elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16. 2559 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 2560 elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24. 2561 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16. 2562 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 2563 11, // Block length. 2564 elfcpp::DW_OP_breg7, 8, // Push %rsp + 8. 2565 elfcpp::DW_OP_breg16, 0, // Push %rip. 2566 elfcpp::DW_OP_lit15, // Push 0xf. 2567 elfcpp::DW_OP_and, // & (%rip & 0xf). 2568 elfcpp::DW_OP_lit9, // Push 9. 2569 elfcpp::DW_OP_ge, // >= ((%rip & 0xf) >= 9) 2570 elfcpp::DW_OP_lit3, // Push 3. 2571 elfcpp::DW_OP_shl, // << (((%rip & 0xf) >= 9) << 3) 2572 elfcpp::DW_OP_plus, // + ((((%rip&0xf)>=9)<<3)+%rsp+8 2573 elfcpp::DW_CFA_nop, // Align to 32 bytes. 2574 elfcpp::DW_CFA_nop, 2575 elfcpp::DW_CFA_nop, 2576 elfcpp::DW_CFA_nop 2577 }; 2578 2579 // Write out the PLT. This uses the hand-coded instructions above, 2580 // and adjusts them as needed. This is specified by the AMD64 ABI. 2581 2582 template<int size> 2583 void 2584 Output_data_plt_x86_64<size>::do_write(Output_file* of) 2585 { 2586 const off_t offset = this->offset(); 2587 const section_size_type oview_size = 2588 convert_to_section_size_type(this->data_size()); 2589 unsigned char* const oview = of->get_output_view(offset, oview_size); 2590 2591 const off_t got_file_offset = this->got_plt_->offset(); 2592 gold_assert(parameters->incremental_update() 2593 || (got_file_offset + this->got_plt_->data_size() 2594 == this->got_irelative_->offset())); 2595 const section_size_type got_size = 2596 convert_to_section_size_type(this->got_plt_->data_size() 2597 + this->got_irelative_->data_size()); 2598 unsigned char* const got_view = of->get_output_view(got_file_offset, 2599 got_size); 2600 2601 unsigned char* pov = oview; 2602 2603 // The base address of the .plt section. 2604 typename elfcpp::Elf_types<size>::Elf_Addr plt_address = this->address(); 2605 // The base address of the .got section. 2606 typename elfcpp::Elf_types<size>::Elf_Addr got_base = this->got_->address(); 2607 // The base address of the PLT portion of the .got section, 2608 // which is where the GOT pointer will point, and where the 2609 // three reserved GOT entries are located. 2610 typename elfcpp::Elf_types<size>::Elf_Addr got_address 2611 = this->got_plt_->address(); 2612 2613 this->fill_first_plt_entry(pov, got_address, plt_address); 2614 pov += this->get_plt_entry_size(); 2615 2616 // The first three entries in the GOT are reserved, and are written 2617 // by Output_data_got_plt_x86_64::do_write. 2618 unsigned char* got_pov = got_view + 24; 2619 2620 unsigned int plt_offset = this->get_plt_entry_size(); 2621 unsigned int got_offset = 24; 2622 const unsigned int count = this->count_ + this->irelative_count_; 2623 for (unsigned int plt_index = 0; 2624 plt_index < count; 2625 ++plt_index, 2626 pov += this->get_plt_entry_size(), 2627 got_pov += 8, 2628 plt_offset += this->get_plt_entry_size(), 2629 got_offset += 8) 2630 { 2631 // Set and adjust the PLT entry itself. 2632 unsigned int lazy_offset = this->fill_plt_entry(pov, 2633 got_address, plt_address, 2634 got_offset, plt_offset, 2635 plt_index); 2636 2637 // Set the entry in the GOT. 2638 elfcpp::Swap<64, false>::writeval(got_pov, 2639 plt_address + plt_offset + lazy_offset); 2640 } 2641 2642 if (this->has_tlsdesc_entry()) 2643 { 2644 // Set and adjust the reserved TLSDESC PLT entry. 2645 unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset(); 2646 this->fill_tlsdesc_entry(pov, got_address, plt_address, got_base, 2647 tlsdesc_got_offset, plt_offset); 2648 pov += this->get_plt_entry_size(); 2649 } 2650 2651 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 2652 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); 2653 2654 of->write_output_view(offset, oview_size, oview); 2655 of->write_output_view(got_file_offset, got_size, got_view); 2656 } 2657 2658 // Write out the BND PLT. 2659 2660 void 2661 Output_data_plt_x86_64_bnd::do_write(Output_file* of) 2662 { 2663 const off_t offset = this->offset(); 2664 const section_size_type oview_size = 2665 convert_to_section_size_type(this->data_size()); 2666 unsigned char* const oview = of->get_output_view(offset, oview_size); 2667 2668 Output_data_got<64, false>* got = this->got(); 2669 Output_data_got_plt_x86_64* got_plt = this->got_plt(); 2670 Output_data_space* got_irelative = this->got_irelative(); 2671 2672 const off_t got_file_offset = got_plt->offset(); 2673 gold_assert(parameters->incremental_update() 2674 || (got_file_offset + got_plt->data_size() 2675 == got_irelative->offset())); 2676 const section_size_type got_size = 2677 convert_to_section_size_type(got_plt->data_size() 2678 + got_irelative->data_size()); 2679 unsigned char* const got_view = of->get_output_view(got_file_offset, 2680 got_size); 2681 2682 unsigned char* pov = oview; 2683 2684 // The base address of the .plt section. 2685 elfcpp::Elf_types<64>::Elf_Addr plt_address = this->address(); 2686 // The base address of the .got section. 2687 elfcpp::Elf_types<64>::Elf_Addr got_base = got->address(); 2688 // The base address of the PLT portion of the .got section, 2689 // which is where the GOT pointer will point, and where the 2690 // three reserved GOT entries are located. 2691 elfcpp::Elf_types<64>::Elf_Addr got_address = got_plt->address(); 2692 2693 this->fill_first_plt_entry(pov, got_address, plt_address); 2694 pov += plt_entry_size; 2695 2696 // The first three entries in the GOT are reserved, and are written 2697 // by Output_data_got_plt_x86_64::do_write. 2698 unsigned char* got_pov = got_view + 24; 2699 2700 unsigned int plt_offset = plt_entry_size; 2701 unsigned int got_offset = 24; 2702 const unsigned int count = this->entry_count(); 2703 for (unsigned int plt_index = 0; 2704 plt_index < count; 2705 ++plt_index, 2706 pov += plt_entry_size, 2707 got_pov += 8, 2708 plt_offset += plt_entry_size, 2709 got_offset += 8) 2710 { 2711 // Set and adjust the PLT entry itself. 2712 unsigned int lazy_offset = this->fill_plt_entry(pov, 2713 got_address, plt_address, 2714 got_offset, plt_offset, 2715 plt_index); 2716 2717 // Set the entry in the GOT. 2718 elfcpp::Swap<64, false>::writeval(got_pov, 2719 plt_address + plt_offset + lazy_offset); 2720 } 2721 2722 if (this->has_tlsdesc_entry()) 2723 { 2724 // Set and adjust the reserved TLSDESC PLT entry. 2725 unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset(); 2726 this->fill_tlsdesc_entry(pov, got_address, plt_address, got_base, 2727 tlsdesc_got_offset, plt_offset); 2728 pov += this->get_plt_entry_size(); 2729 } 2730 2731 // Write the additional PLT. 2732 got_offset = 24; 2733 for (unsigned int plt_index = 0; 2734 plt_index < count; 2735 ++plt_index, 2736 pov += aplt_entry_size, 2737 plt_offset += aplt_entry_size, 2738 got_offset += 8) 2739 { 2740 // Set and adjust the APLT entry. 2741 this->fill_aplt_entry(pov, got_address, plt_address, got_offset, 2742 plt_offset, plt_index); 2743 } 2744 2745 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 2746 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); 2747 2748 of->write_output_view(offset, oview_size, oview); 2749 of->write_output_view(got_file_offset, got_size, got_view); 2750 } 2751 2752 // Write out the IBT PLT. 2753 2754 template<int size> 2755 void 2756 Output_data_plt_x86_64_ibt<size>::do_write(Output_file* of) 2757 { 2758 const off_t offset = this->offset(); 2759 const section_size_type oview_size = 2760 convert_to_section_size_type(this->data_size()); 2761 unsigned char* const oview = of->get_output_view(offset, oview_size); 2762 2763 Output_data_got<64, false>* got = this->got(); 2764 Output_data_got_plt_x86_64* got_plt = this->got_plt(); 2765 Output_data_space* got_irelative = this->got_irelative(); 2766 2767 const off_t got_file_offset = got_plt->offset(); 2768 gold_assert(parameters->incremental_update() 2769 || (got_file_offset + got_plt->data_size() 2770 == got_irelative->offset())); 2771 const section_size_type got_size = 2772 convert_to_section_size_type(got_plt->data_size() 2773 + got_irelative->data_size()); 2774 unsigned char* const got_view = of->get_output_view(got_file_offset, 2775 got_size); 2776 2777 unsigned char* pov = oview; 2778 2779 // The base address of the .plt section. 2780 elfcpp::Elf_types<64>::Elf_Addr plt_address = this->address(); 2781 // The base address of the .got section. 2782 elfcpp::Elf_types<64>::Elf_Addr got_base = got->address(); 2783 // The base address of the PLT portion of the .got section, 2784 // which is where the GOT pointer will point, and where the 2785 // three reserved GOT entries are located. 2786 elfcpp::Elf_types<64>::Elf_Addr got_address = got_plt->address(); 2787 2788 this->fill_first_plt_entry(pov, got_address, plt_address); 2789 pov += plt_entry_size; 2790 2791 // The first three entries in the GOT are reserved, and are written 2792 // by Output_data_got_plt_x86_64::do_write. 2793 unsigned char* got_pov = got_view + 24; 2794 2795 unsigned int plt_offset = plt_entry_size; 2796 unsigned int got_offset = 24; 2797 const unsigned int count = this->entry_count(); 2798 for (unsigned int plt_index = 0; 2799 plt_index < count; 2800 ++plt_index, 2801 pov += plt_entry_size, 2802 got_pov += 8, 2803 plt_offset += plt_entry_size, 2804 got_offset += 8) 2805 { 2806 // Set and adjust the PLT entry itself. 2807 unsigned int lazy_offset = this->fill_plt_entry(pov, 2808 got_address, plt_address, 2809 got_offset, plt_offset, 2810 plt_index); 2811 2812 // Set the entry in the GOT. 2813 elfcpp::Swap<64, false>::writeval(got_pov, 2814 plt_address + plt_offset + lazy_offset); 2815 } 2816 2817 if (this->has_tlsdesc_entry()) 2818 { 2819 // Set and adjust the reserved TLSDESC PLT entry. 2820 unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset(); 2821 this->fill_tlsdesc_entry(pov, got_address, plt_address, got_base, 2822 tlsdesc_got_offset, plt_offset); 2823 pov += this->get_plt_entry_size(); 2824 } 2825 2826 // Write the additional PLT. 2827 got_offset = 24; 2828 for (unsigned int plt_index = 0; 2829 plt_index < count; 2830 ++plt_index, 2831 pov += aplt_entry_size, 2832 plt_offset += aplt_entry_size, 2833 got_offset += 8) 2834 { 2835 // Set and adjust the APLT entry. 2836 this->fill_aplt_entry(pov, got_address, plt_address, got_offset, 2837 plt_offset, plt_index); 2838 } 2839 2840 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 2841 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); 2842 2843 of->write_output_view(offset, oview_size, oview); 2844 of->write_output_view(got_file_offset, got_size, got_view); 2845 } 2846 2847 // Create the PLT section. 2848 2849 template<int size> 2850 void 2851 Target_x86_64<size>::make_plt_section(Symbol_table* symtab, Layout* layout) 2852 { 2853 if (this->plt_ == NULL) 2854 { 2855 // Create the GOT sections first. 2856 this->got_section(symtab, layout); 2857 2858 this->plt_ = this->make_data_plt(layout, this->got_, this->got_plt_, 2859 this->got_irelative_); 2860 2861 // Add unwind information if requested. 2862 if (parameters->options().ld_generated_unwind_info()) 2863 this->plt_->add_eh_frame(layout); 2864 2865 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 2866 (elfcpp::SHF_ALLOC 2867 | elfcpp::SHF_EXECINSTR), 2868 this->plt_, ORDER_PLT, false); 2869 2870 // Make the sh_info field of .rela.plt point to .plt. 2871 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section(); 2872 rela_plt_os->set_info_section(this->plt_->output_section()); 2873 } 2874 } 2875 2876 template<> 2877 Output_data_plt_x86_64<32>* 2878 Target_x86_64<32>::do_make_data_plt(Layout* layout, 2879 Output_data_got<64, false>* got, 2880 Output_data_got_plt_x86_64* got_plt, 2881 Output_data_space* got_irelative) 2882 { 2883 if (this->feature_1_ & elfcpp::GNU_PROPERTY_X86_FEATURE_1_IBT) 2884 return new Output_data_plt_x86_64_ibt<32>(layout, got, got_plt, 2885 got_irelative); 2886 return new Output_data_plt_x86_64_standard<32>(layout, got, got_plt, 2887 got_irelative); 2888 } 2889 2890 template<> 2891 Output_data_plt_x86_64<64>* 2892 Target_x86_64<64>::do_make_data_plt(Layout* layout, 2893 Output_data_got<64, false>* got, 2894 Output_data_got_plt_x86_64* got_plt, 2895 Output_data_space* got_irelative) 2896 { 2897 if (this->feature_1_ & elfcpp::GNU_PROPERTY_X86_FEATURE_1_IBT) 2898 return new Output_data_plt_x86_64_ibt<64>(layout, got, got_plt, 2899 got_irelative); 2900 else if (parameters->options().bndplt()) 2901 return new Output_data_plt_x86_64_bnd(layout, got, got_plt, 2902 got_irelative); 2903 else 2904 return new Output_data_plt_x86_64_standard<64>(layout, got, got_plt, 2905 got_irelative); 2906 } 2907 2908 template<> 2909 Output_data_plt_x86_64<32>* 2910 Target_x86_64<32>::do_make_data_plt(Layout* layout, 2911 Output_data_got<64, false>* got, 2912 Output_data_got_plt_x86_64* got_plt, 2913 Output_data_space* got_irelative, 2914 unsigned int plt_count) 2915 { 2916 if (this->feature_1_ & elfcpp::GNU_PROPERTY_X86_FEATURE_1_IBT) 2917 return new Output_data_plt_x86_64_ibt<32>(layout, got, got_plt, 2918 got_irelative, plt_count); 2919 return new Output_data_plt_x86_64_standard<32>(layout, got, got_plt, 2920 got_irelative, plt_count); 2921 } 2922 2923 template<> 2924 Output_data_plt_x86_64<64>* 2925 Target_x86_64<64>::do_make_data_plt(Layout* layout, 2926 Output_data_got<64, false>* got, 2927 Output_data_got_plt_x86_64* got_plt, 2928 Output_data_space* got_irelative, 2929 unsigned int plt_count) 2930 { 2931 if (this->feature_1_ & elfcpp::GNU_PROPERTY_X86_FEATURE_1_IBT) 2932 return new Output_data_plt_x86_64_ibt<64>(layout, got, got_plt, 2933 got_irelative, plt_count); 2934 else if (parameters->options().bndplt()) 2935 return new Output_data_plt_x86_64_bnd(layout, got, got_plt, 2936 got_irelative, plt_count); 2937 else 2938 return new Output_data_plt_x86_64_standard<64>(layout, got, got_plt, 2939 got_irelative, 2940 plt_count); 2941 } 2942 2943 // Return the section for TLSDESC relocations. 2944 2945 template<int size> 2946 typename Target_x86_64<size>::Reloc_section* 2947 Target_x86_64<size>::rela_tlsdesc_section(Layout* layout) const 2948 { 2949 return this->plt_section()->rela_tlsdesc(layout); 2950 } 2951 2952 // Create a PLT entry for a global symbol. 2953 2954 template<int size> 2955 void 2956 Target_x86_64<size>::make_plt_entry(Symbol_table* symtab, Layout* layout, 2957 Symbol* gsym) 2958 { 2959 if (gsym->has_plt_offset()) 2960 return; 2961 2962 if (this->plt_ == NULL) 2963 this->make_plt_section(symtab, layout); 2964 2965 this->plt_->add_entry(symtab, layout, gsym); 2966 } 2967 2968 // Make a PLT entry for a local STT_GNU_IFUNC symbol. 2969 2970 template<int size> 2971 void 2972 Target_x86_64<size>::make_local_ifunc_plt_entry( 2973 Symbol_table* symtab, Layout* layout, 2974 Sized_relobj_file<size, false>* relobj, 2975 unsigned int local_sym_index) 2976 { 2977 if (relobj->local_has_plt_offset(local_sym_index)) 2978 return; 2979 if (this->plt_ == NULL) 2980 this->make_plt_section(symtab, layout); 2981 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout, 2982 relobj, 2983 local_sym_index); 2984 relobj->set_local_plt_offset(local_sym_index, plt_offset); 2985 } 2986 2987 // Return the number of entries in the PLT. 2988 2989 template<int size> 2990 unsigned int 2991 Target_x86_64<size>::plt_entry_count() const 2992 { 2993 if (this->plt_ == NULL) 2994 return 0; 2995 return this->plt_->entry_count(); 2996 } 2997 2998 // Return the offset of the first non-reserved PLT entry. 2999 3000 template<int size> 3001 unsigned int 3002 Target_x86_64<size>::first_plt_entry_offset() const 3003 { 3004 if (this->plt_ == NULL) 3005 return 0; 3006 return this->plt_->first_plt_entry_offset(); 3007 } 3008 3009 // Return the size of each PLT entry. 3010 3011 template<int size> 3012 unsigned int 3013 Target_x86_64<size>::plt_entry_size() const 3014 { 3015 if (this->plt_ == NULL) 3016 return 0; 3017 return this->plt_->get_plt_entry_size(); 3018 } 3019 3020 // Create the GOT and PLT sections for an incremental update. 3021 3022 template<int size> 3023 Output_data_got_base* 3024 Target_x86_64<size>::init_got_plt_for_update(Symbol_table* symtab, 3025 Layout* layout, 3026 unsigned int got_count, 3027 unsigned int plt_count) 3028 { 3029 gold_assert(this->got_ == NULL); 3030 3031 this->got_ = new Output_data_got<64, false>(got_count * 8); 3032 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 3033 (elfcpp::SHF_ALLOC 3034 | elfcpp::SHF_WRITE), 3035 this->got_, ORDER_RELRO_LAST, 3036 true); 3037 3038 // Add the three reserved entries. 3039 this->got_plt_ = new Output_data_got_plt_x86_64(layout, (plt_count + 3) * 8); 3040 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 3041 (elfcpp::SHF_ALLOC 3042 | elfcpp::SHF_WRITE), 3043 this->got_plt_, ORDER_NON_RELRO_FIRST, 3044 false); 3045 3046 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT. 3047 this->global_offset_table_ = 3048 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 3049 Symbol_table::PREDEFINED, 3050 this->got_plt_, 3051 0, 0, elfcpp::STT_OBJECT, 3052 elfcpp::STB_LOCAL, 3053 elfcpp::STV_HIDDEN, 0, 3054 false, false); 3055 3056 // If there are any TLSDESC relocations, they get GOT entries in 3057 // .got.plt after the jump slot entries. 3058 // FIXME: Get the count for TLSDESC entries. 3059 this->got_tlsdesc_ = new Output_data_got<64, false>(0); 3060 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 3061 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 3062 this->got_tlsdesc_, 3063 ORDER_NON_RELRO_FIRST, false); 3064 3065 // If there are any IRELATIVE relocations, they get GOT entries in 3066 // .got.plt after the jump slot and TLSDESC entries. 3067 this->got_irelative_ = new Output_data_space(0, 8, "** GOT IRELATIVE PLT"); 3068 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 3069 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 3070 this->got_irelative_, 3071 ORDER_NON_RELRO_FIRST, false); 3072 3073 // Create the PLT section. 3074 this->plt_ = this->make_data_plt(layout, this->got_, 3075 this->got_plt_, 3076 this->got_irelative_, 3077 plt_count); 3078 3079 // Add unwind information if requested. 3080 if (parameters->options().ld_generated_unwind_info()) 3081 this->plt_->add_eh_frame(layout); 3082 3083 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 3084 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR, 3085 this->plt_, ORDER_PLT, false); 3086 3087 // Make the sh_info field of .rela.plt point to .plt. 3088 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section(); 3089 rela_plt_os->set_info_section(this->plt_->output_section()); 3090 3091 // Create the rela_dyn section. 3092 this->rela_dyn_section(layout); 3093 3094 return this->got_; 3095 } 3096 3097 // Reserve a GOT entry for a local symbol, and regenerate any 3098 // necessary dynamic relocations. 3099 3100 template<int size> 3101 void 3102 Target_x86_64<size>::reserve_local_got_entry( 3103 unsigned int got_index, 3104 Sized_relobj<size, false>* obj, 3105 unsigned int r_sym, 3106 unsigned int got_type) 3107 { 3108 unsigned int got_offset = got_index * 8; 3109 Reloc_section* rela_dyn = this->rela_dyn_section(NULL); 3110 3111 this->got_->reserve_local(got_index, obj, r_sym, got_type); 3112 switch (got_type) 3113 { 3114 case GOT_TYPE_STANDARD: 3115 if (parameters->options().output_is_position_independent()) 3116 rela_dyn->add_local_relative(obj, r_sym, elfcpp::R_X86_64_RELATIVE, 3117 this->got_, got_offset, 0, false); 3118 break; 3119 case GOT_TYPE_TLS_OFFSET: 3120 rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_TPOFF64, 3121 this->got_, got_offset, 0); 3122 break; 3123 case GOT_TYPE_TLS_PAIR: 3124 this->got_->reserve_slot(got_index + 1); 3125 rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_DTPMOD64, 3126 this->got_, got_offset, 0); 3127 break; 3128 case GOT_TYPE_TLS_DESC: 3129 gold_fatal(_("TLS_DESC not yet supported for incremental linking")); 3130 // this->got_->reserve_slot(got_index + 1); 3131 // rela_dyn->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg, 3132 // this->got_, got_offset, 0); 3133 break; 3134 default: 3135 gold_unreachable(); 3136 } 3137 } 3138 3139 // Reserve a GOT entry for a global symbol, and regenerate any 3140 // necessary dynamic relocations. 3141 3142 template<int size> 3143 void 3144 Target_x86_64<size>::reserve_global_got_entry(unsigned int got_index, 3145 Symbol* gsym, 3146 unsigned int got_type) 3147 { 3148 unsigned int got_offset = got_index * 8; 3149 Reloc_section* rela_dyn = this->rela_dyn_section(NULL); 3150 3151 this->got_->reserve_global(got_index, gsym, got_type); 3152 switch (got_type) 3153 { 3154 case GOT_TYPE_STANDARD: 3155 if (!gsym->final_value_is_known()) 3156 { 3157 if (gsym->is_from_dynobj() 3158 || gsym->is_undefined() 3159 || gsym->is_preemptible() 3160 || gsym->type() == elfcpp::STT_GNU_IFUNC) 3161 rela_dyn->add_global(gsym, elfcpp::R_X86_64_GLOB_DAT, 3162 this->got_, got_offset, 0); 3163 else 3164 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE, 3165 this->got_, got_offset, 0, false); 3166 } 3167 break; 3168 case GOT_TYPE_TLS_OFFSET: 3169 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TPOFF64, 3170 this->got_, got_offset, 0, false); 3171 break; 3172 case GOT_TYPE_TLS_PAIR: 3173 this->got_->reserve_slot(got_index + 1); 3174 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPMOD64, 3175 this->got_, got_offset, 0, false); 3176 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPOFF64, 3177 this->got_, got_offset + 8, 0, false); 3178 break; 3179 case GOT_TYPE_TLS_DESC: 3180 this->got_->reserve_slot(got_index + 1); 3181 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TLSDESC, 3182 this->got_, got_offset, 0, false); 3183 break; 3184 default: 3185 gold_unreachable(); 3186 } 3187 } 3188 3189 // Register an existing PLT entry for a global symbol. 3190 3191 template<int size> 3192 void 3193 Target_x86_64<size>::register_global_plt_entry(Symbol_table* symtab, 3194 Layout* layout, 3195 unsigned int plt_index, 3196 Symbol* gsym) 3197 { 3198 gold_assert(this->plt_ != NULL); 3199 gold_assert(!gsym->has_plt_offset()); 3200 3201 this->plt_->reserve_slot(plt_index); 3202 3203 gsym->set_plt_offset((plt_index + 1) * this->plt_entry_size()); 3204 3205 unsigned int got_offset = (plt_index + 3) * 8; 3206 this->plt_->add_relocation(symtab, layout, gsym, got_offset); 3207 } 3208 3209 // Force a COPY relocation for a given symbol. 3210 3211 template<int size> 3212 void 3213 Target_x86_64<size>::emit_copy_reloc( 3214 Symbol_table* symtab, Symbol* sym, Output_section* os, off_t offset) 3215 { 3216 this->copy_relocs_.emit_copy_reloc(symtab, 3217 symtab->get_sized_symbol<size>(sym), 3218 os, 3219 offset, 3220 this->rela_dyn_section(NULL)); 3221 } 3222 3223 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment. 3224 3225 template<int size> 3226 void 3227 Target_x86_64<size>::define_tls_base_symbol(Symbol_table* symtab, 3228 Layout* layout) 3229 { 3230 if (this->tls_base_symbol_defined_) 3231 return; 3232 3233 Output_segment* tls_segment = layout->tls_segment(); 3234 if (tls_segment != NULL) 3235 { 3236 bool is_exec = parameters->options().output_is_executable(); 3237 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL, 3238 Symbol_table::PREDEFINED, 3239 tls_segment, 0, 0, 3240 elfcpp::STT_TLS, 3241 elfcpp::STB_LOCAL, 3242 elfcpp::STV_HIDDEN, 0, 3243 (is_exec 3244 ? Symbol::SEGMENT_END 3245 : Symbol::SEGMENT_START), 3246 true); 3247 } 3248 this->tls_base_symbol_defined_ = true; 3249 } 3250 3251 // Create the reserved PLT and GOT entries for the TLS descriptor resolver. 3252 3253 template<int size> 3254 void 3255 Target_x86_64<size>::reserve_tlsdesc_entries(Symbol_table* symtab, 3256 Layout* layout) 3257 { 3258 if (this->plt_ == NULL) 3259 this->make_plt_section(symtab, layout); 3260 3261 if (!this->plt_->has_tlsdesc_entry()) 3262 { 3263 // Allocate the TLSDESC_GOT entry. 3264 Output_data_got<64, false>* got = this->got_section(symtab, layout); 3265 unsigned int got_offset = got->add_constant(0); 3266 3267 // Allocate the TLSDESC_PLT entry. 3268 this->plt_->reserve_tlsdesc_entry(got_offset); 3269 } 3270 } 3271 3272 // Create a GOT entry for the TLS module index. 3273 3274 template<int size> 3275 unsigned int 3276 Target_x86_64<size>::got_mod_index_entry(Symbol_table* symtab, Layout* layout, 3277 Sized_relobj_file<size, false>* object) 3278 { 3279 if (this->got_mod_index_offset_ == -1U) 3280 { 3281 gold_assert(symtab != NULL && layout != NULL && object != NULL); 3282 Reloc_section* rela_dyn = this->rela_dyn_section(layout); 3283 Output_data_got<64, false>* got = this->got_section(symtab, layout); 3284 unsigned int got_offset = got->add_constant(0); 3285 rela_dyn->add_local(object, 0, elfcpp::R_X86_64_DTPMOD64, got, 3286 got_offset, 0); 3287 got->add_constant(0); 3288 this->got_mod_index_offset_ = got_offset; 3289 } 3290 return this->got_mod_index_offset_; 3291 } 3292 3293 // Optimize the TLS relocation type based on what we know about the 3294 // symbol. IS_FINAL is true if the final address of this symbol is 3295 // known at link time. 3296 3297 template<int size> 3298 tls::Tls_optimization 3299 Target_x86_64<size>::optimize_tls_reloc(bool is_final, int r_type) 3300 { 3301 // If we are generating a shared library, then we can't do anything 3302 // in the linker. 3303 if (parameters->options().shared()) 3304 return tls::TLSOPT_NONE; 3305 3306 switch (r_type) 3307 { 3308 case elfcpp::R_X86_64_TLSGD: 3309 case elfcpp::R_X86_64_GOTPC32_TLSDESC: 3310 case elfcpp::R_X86_64_TLSDESC_CALL: 3311 // These are General-Dynamic which permits fully general TLS 3312 // access. Since we know that we are generating an executable, 3313 // we can convert this to Initial-Exec. If we also know that 3314 // this is a local symbol, we can further switch to Local-Exec. 3315 if (is_final) 3316 return tls::TLSOPT_TO_LE; 3317 return tls::TLSOPT_TO_IE; 3318 3319 case elfcpp::R_X86_64_TLSLD: 3320 // This is Local-Dynamic, which refers to a local symbol in the 3321 // dynamic TLS block. Since we know that we generating an 3322 // executable, we can switch to Local-Exec. 3323 return tls::TLSOPT_TO_LE; 3324 3325 case elfcpp::R_X86_64_DTPOFF32: 3326 case elfcpp::R_X86_64_DTPOFF64: 3327 // Another Local-Dynamic reloc. 3328 return tls::TLSOPT_TO_LE; 3329 3330 case elfcpp::R_X86_64_GOTTPOFF: 3331 // These are Initial-Exec relocs which get the thread offset 3332 // from the GOT. If we know that we are linking against the 3333 // local symbol, we can switch to Local-Exec, which links the 3334 // thread offset into the instruction. 3335 if (is_final) 3336 return tls::TLSOPT_TO_LE; 3337 return tls::TLSOPT_NONE; 3338 3339 case elfcpp::R_X86_64_TPOFF32: 3340 // When we already have Local-Exec, there is nothing further we 3341 // can do. 3342 return tls::TLSOPT_NONE; 3343 3344 default: 3345 gold_unreachable(); 3346 } 3347 } 3348 3349 // Get the Reference_flags for a particular relocation. 3350 3351 template<int size> 3352 int 3353 Target_x86_64<size>::Scan::get_reference_flags(unsigned int r_type) 3354 { 3355 switch (r_type) 3356 { 3357 case elfcpp::R_X86_64_NONE: 3358 case elfcpp::R_X86_64_GNU_VTINHERIT: 3359 case elfcpp::R_X86_64_GNU_VTENTRY: 3360 case elfcpp::R_X86_64_GOTPC32: 3361 case elfcpp::R_X86_64_GOTPC64: 3362 // No symbol reference. 3363 return 0; 3364 3365 case elfcpp::R_X86_64_64: 3366 case elfcpp::R_X86_64_32: 3367 case elfcpp::R_X86_64_32S: 3368 case elfcpp::R_X86_64_16: 3369 case elfcpp::R_X86_64_8: 3370 return Symbol::ABSOLUTE_REF; 3371 3372 case elfcpp::R_X86_64_PC64: 3373 case elfcpp::R_X86_64_PC32: 3374 case elfcpp::R_X86_64_PC32_BND: 3375 case elfcpp::R_X86_64_PC16: 3376 case elfcpp::R_X86_64_PC8: 3377 case elfcpp::R_X86_64_GOTOFF64: 3378 return Symbol::RELATIVE_REF; 3379 3380 case elfcpp::R_X86_64_PLT32: 3381 case elfcpp::R_X86_64_PLT32_BND: 3382 case elfcpp::R_X86_64_PLTOFF64: 3383 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF; 3384 3385 case elfcpp::R_X86_64_GOT64: 3386 case elfcpp::R_X86_64_GOT32: 3387 case elfcpp::R_X86_64_GOTPCREL64: 3388 case elfcpp::R_X86_64_GOTPCREL: 3389 case elfcpp::R_X86_64_GOTPCRELX: 3390 case elfcpp::R_X86_64_REX_GOTPCRELX: 3391 case elfcpp::R_X86_64_GOTPLT64: 3392 // Absolute in GOT. 3393 return Symbol::ABSOLUTE_REF; 3394 3395 case elfcpp::R_X86_64_TLSGD: // Global-dynamic 3396 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url) 3397 case elfcpp::R_X86_64_TLSDESC_CALL: 3398 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 3399 case elfcpp::R_X86_64_DTPOFF32: 3400 case elfcpp::R_X86_64_DTPOFF64: 3401 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 3402 case elfcpp::R_X86_64_TPOFF32: // Local-exec 3403 return Symbol::TLS_REF; 3404 3405 case elfcpp::R_X86_64_COPY: 3406 case elfcpp::R_X86_64_GLOB_DAT: 3407 case elfcpp::R_X86_64_JUMP_SLOT: 3408 case elfcpp::R_X86_64_RELATIVE: 3409 case elfcpp::R_X86_64_IRELATIVE: 3410 case elfcpp::R_X86_64_TPOFF64: 3411 case elfcpp::R_X86_64_DTPMOD64: 3412 case elfcpp::R_X86_64_TLSDESC: 3413 case elfcpp::R_X86_64_SIZE32: 3414 case elfcpp::R_X86_64_SIZE64: 3415 default: 3416 // Not expected. We will give an error later. 3417 return 0; 3418 } 3419 } 3420 3421 // Report an unsupported relocation against a local symbol. 3422 3423 template<int size> 3424 void 3425 Target_x86_64<size>::Scan::unsupported_reloc_local( 3426 Sized_relobj_file<size, false>* object, 3427 unsigned int r_type) 3428 { 3429 gold_error(_("%s: unsupported reloc %u against local symbol"), 3430 object->name().c_str(), r_type); 3431 } 3432 3433 // We are about to emit a dynamic relocation of type R_TYPE. If the 3434 // dynamic linker does not support it, issue an error. The GNU linker 3435 // only issues a non-PIC error for an allocated read-only section. 3436 // Here we know the section is allocated, but we don't know that it is 3437 // read-only. But we check for all the relocation types which the 3438 // glibc dynamic linker supports, so it seems appropriate to issue an 3439 // error even if the section is not read-only. If GSYM is not NULL, 3440 // it is the symbol the relocation is against; if it is NULL, the 3441 // relocation is against a local symbol. 3442 3443 template<int size> 3444 void 3445 Target_x86_64<size>::Scan::check_non_pic(Relobj* object, unsigned int r_type, 3446 Symbol* gsym) 3447 { 3448 switch (r_type) 3449 { 3450 // These are the relocation types supported by glibc for x86_64 3451 // which should always work. 3452 case elfcpp::R_X86_64_RELATIVE: 3453 case elfcpp::R_X86_64_IRELATIVE: 3454 case elfcpp::R_X86_64_GLOB_DAT: 3455 case elfcpp::R_X86_64_JUMP_SLOT: 3456 case elfcpp::R_X86_64_DTPMOD64: 3457 case elfcpp::R_X86_64_DTPOFF64: 3458 case elfcpp::R_X86_64_TPOFF64: 3459 case elfcpp::R_X86_64_64: 3460 case elfcpp::R_X86_64_COPY: 3461 return; 3462 3463 // glibc supports these reloc types, but they can overflow. 3464 case elfcpp::R_X86_64_PC32: 3465 case elfcpp::R_X86_64_PC32_BND: 3466 // A PC relative reference is OK against a local symbol or if 3467 // the symbol is defined locally. 3468 if (gsym == NULL 3469 || (!gsym->is_from_dynobj() 3470 && !gsym->is_undefined() 3471 && !gsym->is_preemptible())) 3472 return; 3473 // Fall through. 3474 case elfcpp::R_X86_64_32: 3475 // R_X86_64_32 is OK for x32. 3476 if (size == 32 && r_type == elfcpp::R_X86_64_32) 3477 return; 3478 if (this->issued_non_pic_error_) 3479 return; 3480 gold_assert(parameters->options().output_is_position_independent()); 3481 if (gsym == NULL) 3482 object->error(_("requires dynamic R_X86_64_32 reloc which may " 3483 "overflow at runtime; recompile with -fPIC")); 3484 else 3485 { 3486 const char *r_name; 3487 switch (r_type) 3488 { 3489 case elfcpp::R_X86_64_32: 3490 r_name = "R_X86_64_32"; 3491 break; 3492 case elfcpp::R_X86_64_PC32: 3493 r_name = "R_X86_64_PC32"; 3494 break; 3495 case elfcpp::R_X86_64_PC32_BND: 3496 r_name = "R_X86_64_PC32_BND"; 3497 break; 3498 default: 3499 gold_unreachable(); 3500 break; 3501 } 3502 object->error(_("requires dynamic %s reloc against '%s' " 3503 "which may overflow at runtime; recompile " 3504 "with -fPIC"), 3505 r_name, gsym->name()); 3506 } 3507 this->issued_non_pic_error_ = true; 3508 return; 3509 3510 default: 3511 // This prevents us from issuing more than one error per reloc 3512 // section. But we can still wind up issuing more than one 3513 // error per object file. 3514 if (this->issued_non_pic_error_) 3515 return; 3516 gold_assert(parameters->options().output_is_position_independent()); 3517 object->error(_("requires unsupported dynamic reloc %u; " 3518 "recompile with -fPIC"), 3519 r_type); 3520 this->issued_non_pic_error_ = true; 3521 return; 3522 3523 case elfcpp::R_X86_64_NONE: 3524 gold_unreachable(); 3525 } 3526 } 3527 3528 // Return whether we need to make a PLT entry for a relocation of the 3529 // given type against a STT_GNU_IFUNC symbol. 3530 3531 template<int size> 3532 bool 3533 Target_x86_64<size>::Scan::reloc_needs_plt_for_ifunc( 3534 Sized_relobj_file<size, false>* object, 3535 unsigned int r_type) 3536 { 3537 int flags = Scan::get_reference_flags(r_type); 3538 if (flags & Symbol::TLS_REF) 3539 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"), 3540 object->name().c_str(), r_type); 3541 return flags != 0; 3542 } 3543 3544 // Scan a relocation for a local symbol. 3545 3546 template<int size> 3547 inline void 3548 Target_x86_64<size>::Scan::local(Symbol_table* symtab, 3549 Layout* layout, 3550 Target_x86_64<size>* target, 3551 Sized_relobj_file<size, false>* object, 3552 unsigned int data_shndx, 3553 Output_section* output_section, 3554 const elfcpp::Rela<size, false>& reloc, 3555 unsigned int r_type, 3556 const elfcpp::Sym<size, false>& lsym, 3557 bool is_discarded) 3558 { 3559 if (is_discarded) 3560 return; 3561 3562 // A local STT_GNU_IFUNC symbol may require a PLT entry. 3563 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC; 3564 if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type)) 3565 { 3566 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3567 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym); 3568 } 3569 3570 switch (r_type) 3571 { 3572 case elfcpp::R_X86_64_NONE: 3573 case elfcpp::R_X86_64_GNU_VTINHERIT: 3574 case elfcpp::R_X86_64_GNU_VTENTRY: 3575 break; 3576 3577 case elfcpp::R_X86_64_64: 3578 // If building a shared library (or a position-independent 3579 // executable), we need to create a dynamic relocation for this 3580 // location. The relocation applied at link time will apply the 3581 // link-time value, so we flag the location with an 3582 // R_X86_64_RELATIVE relocation so the dynamic loader can 3583 // relocate it easily. 3584 if (parameters->options().output_is_position_independent()) 3585 { 3586 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3587 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 3588 rela_dyn->add_local_relative(object, r_sym, 3589 (size == 32 3590 ? elfcpp::R_X86_64_RELATIVE64 3591 : elfcpp::R_X86_64_RELATIVE), 3592 output_section, data_shndx, 3593 reloc.get_r_offset(), 3594 reloc.get_r_addend(), is_ifunc); 3595 } 3596 break; 3597 3598 case elfcpp::R_X86_64_32: 3599 case elfcpp::R_X86_64_32S: 3600 case elfcpp::R_X86_64_16: 3601 case elfcpp::R_X86_64_8: 3602 // If building a shared library (or a position-independent 3603 // executable), we need to create a dynamic relocation for this 3604 // location. We can't use an R_X86_64_RELATIVE relocation 3605 // because that is always a 64-bit relocation. 3606 if (parameters->options().output_is_position_independent()) 3607 { 3608 // Use R_X86_64_RELATIVE relocation for R_X86_64_32 under x32. 3609 if (size == 32 && r_type == elfcpp::R_X86_64_32) 3610 { 3611 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3612 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 3613 rela_dyn->add_local_relative(object, r_sym, 3614 elfcpp::R_X86_64_RELATIVE, 3615 output_section, data_shndx, 3616 reloc.get_r_offset(), 3617 reloc.get_r_addend(), is_ifunc); 3618 break; 3619 } 3620 3621 this->check_non_pic(object, r_type, NULL); 3622 3623 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 3624 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3625 if (lsym.get_st_type() != elfcpp::STT_SECTION) 3626 rela_dyn->add_local(object, r_sym, r_type, output_section, 3627 data_shndx, reloc.get_r_offset(), 3628 reloc.get_r_addend()); 3629 else 3630 { 3631 gold_assert(lsym.get_st_value() == 0); 3632 unsigned int shndx = lsym.get_st_shndx(); 3633 bool is_ordinary; 3634 shndx = object->adjust_sym_shndx(r_sym, shndx, 3635 &is_ordinary); 3636 if (!is_ordinary) 3637 object->error(_("section symbol %u has bad shndx %u"), 3638 r_sym, shndx); 3639 else 3640 rela_dyn->add_local_section(object, shndx, 3641 r_type, output_section, 3642 data_shndx, reloc.get_r_offset(), 3643 reloc.get_r_addend()); 3644 } 3645 } 3646 break; 3647 3648 case elfcpp::R_X86_64_PC64: 3649 case elfcpp::R_X86_64_PC32: 3650 case elfcpp::R_X86_64_PC32_BND: 3651 case elfcpp::R_X86_64_PC16: 3652 case elfcpp::R_X86_64_PC8: 3653 break; 3654 3655 case elfcpp::R_X86_64_PLT32: 3656 case elfcpp::R_X86_64_PLT32_BND: 3657 // Since we know this is a local symbol, we can handle this as a 3658 // PC32 reloc. 3659 break; 3660 3661 case elfcpp::R_X86_64_GOTPC32: 3662 case elfcpp::R_X86_64_GOTOFF64: 3663 case elfcpp::R_X86_64_GOTPC64: 3664 case elfcpp::R_X86_64_PLTOFF64: 3665 // We need a GOT section. 3666 target->got_section(symtab, layout); 3667 // For PLTOFF64, we'd normally want a PLT section, but since we 3668 // know this is a local symbol, no PLT is needed. 3669 break; 3670 3671 case elfcpp::R_X86_64_GOT64: 3672 case elfcpp::R_X86_64_GOT32: 3673 case elfcpp::R_X86_64_GOTPCREL64: 3674 case elfcpp::R_X86_64_GOTPCREL: 3675 case elfcpp::R_X86_64_GOTPCRELX: 3676 case elfcpp::R_X86_64_REX_GOTPCRELX: 3677 case elfcpp::R_X86_64_GOTPLT64: 3678 { 3679 // The symbol requires a GOT section. 3680 Output_data_got<64, false>* got = target->got_section(symtab, layout); 3681 3682 // If the relocation symbol isn't IFUNC, 3683 // and is local, then we will convert 3684 // mov foo@GOTPCREL(%rip), %reg 3685 // to lea foo(%rip), %reg. 3686 // in Relocate::relocate. 3687 if (!parameters->incremental() 3688 && (r_type == elfcpp::R_X86_64_GOTPCREL 3689 || r_type == elfcpp::R_X86_64_GOTPCRELX 3690 || r_type == elfcpp::R_X86_64_REX_GOTPCRELX) 3691 && reloc.get_r_offset() >= 2 3692 && !is_ifunc) 3693 { 3694 section_size_type stype; 3695 const unsigned char* view = object->section_contents(data_shndx, 3696 &stype, true); 3697 if (view[reloc.get_r_offset() - 2] == 0x8b) 3698 break; 3699 } 3700 3701 // The symbol requires a GOT entry. 3702 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3703 3704 // For a STT_GNU_IFUNC symbol we want the PLT offset. That 3705 // lets function pointers compare correctly with shared 3706 // libraries. Otherwise we would need an IRELATIVE reloc. 3707 bool is_new; 3708 if (is_ifunc) 3709 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD); 3710 else 3711 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD); 3712 if (is_new) 3713 { 3714 // If we are generating a shared object, we need to add a 3715 // dynamic relocation for this symbol's GOT entry. 3716 if (parameters->options().output_is_position_independent()) 3717 { 3718 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 3719 // R_X86_64_RELATIVE assumes a 64-bit relocation. 3720 if (r_type != elfcpp::R_X86_64_GOT32) 3721 { 3722 unsigned int got_offset = 3723 object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 3724 rela_dyn->add_local_relative(object, r_sym, 3725 elfcpp::R_X86_64_RELATIVE, 3726 got, got_offset, 0, is_ifunc); 3727 } 3728 else 3729 { 3730 this->check_non_pic(object, r_type, NULL); 3731 3732 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION); 3733 rela_dyn->add_local( 3734 object, r_sym, r_type, got, 3735 object->local_got_offset(r_sym, GOT_TYPE_STANDARD), 0); 3736 } 3737 } 3738 } 3739 // For GOTPLT64, we'd normally want a PLT section, but since 3740 // we know this is a local symbol, no PLT is needed. 3741 } 3742 break; 3743 3744 case elfcpp::R_X86_64_COPY: 3745 case elfcpp::R_X86_64_GLOB_DAT: 3746 case elfcpp::R_X86_64_JUMP_SLOT: 3747 case elfcpp::R_X86_64_RELATIVE: 3748 case elfcpp::R_X86_64_IRELATIVE: 3749 // These are outstanding tls relocs, which are unexpected when linking 3750 case elfcpp::R_X86_64_TPOFF64: 3751 case elfcpp::R_X86_64_DTPMOD64: 3752 case elfcpp::R_X86_64_TLSDESC: 3753 gold_error(_("%s: unexpected reloc %u in object file"), 3754 object->name().c_str(), r_type); 3755 break; 3756 3757 // These are initial tls relocs, which are expected when linking 3758 case elfcpp::R_X86_64_TLSGD: // Global-dynamic 3759 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url) 3760 case elfcpp::R_X86_64_TLSDESC_CALL: 3761 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 3762 case elfcpp::R_X86_64_DTPOFF32: 3763 case elfcpp::R_X86_64_DTPOFF64: 3764 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 3765 case elfcpp::R_X86_64_TPOFF32: // Local-exec 3766 { 3767 bool output_is_shared = parameters->options().shared(); 3768 const tls::Tls_optimization optimized_type 3769 = Target_x86_64<size>::optimize_tls_reloc(!output_is_shared, 3770 r_type); 3771 switch (r_type) 3772 { 3773 case elfcpp::R_X86_64_TLSGD: // General-dynamic 3774 if (optimized_type == tls::TLSOPT_NONE) 3775 { 3776 // Create a pair of GOT entries for the module index and 3777 // dtv-relative offset. 3778 Output_data_got<64, false>* got 3779 = target->got_section(symtab, layout); 3780 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3781 unsigned int shndx = lsym.get_st_shndx(); 3782 bool is_ordinary; 3783 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary); 3784 if (!is_ordinary) 3785 object->error(_("local symbol %u has bad shndx %u"), 3786 r_sym, shndx); 3787 else 3788 got->add_local_pair_with_rel(object, r_sym, 3789 shndx, 3790 GOT_TYPE_TLS_PAIR, 3791 target->rela_dyn_section(layout), 3792 elfcpp::R_X86_64_DTPMOD64); 3793 } 3794 else if (optimized_type != tls::TLSOPT_TO_LE) 3795 unsupported_reloc_local(object, r_type); 3796 break; 3797 3798 case elfcpp::R_X86_64_GOTPC32_TLSDESC: 3799 target->define_tls_base_symbol(symtab, layout); 3800 if (optimized_type == tls::TLSOPT_NONE) 3801 { 3802 // Create reserved PLT and GOT entries for the resolver. 3803 target->reserve_tlsdesc_entries(symtab, layout); 3804 3805 // Generate a double GOT entry with an 3806 // R_X86_64_TLSDESC reloc. The R_X86_64_TLSDESC reloc 3807 // is resolved lazily, so the GOT entry needs to be in 3808 // an area in .got.plt, not .got. Call got_section to 3809 // make sure the section has been created. 3810 target->got_section(symtab, layout); 3811 Output_data_got<64, false>* got = target->got_tlsdesc_section(); 3812 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3813 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC)) 3814 { 3815 unsigned int got_offset = got->add_constant(0); 3816 got->add_constant(0); 3817 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC, 3818 got_offset); 3819 Reloc_section* rt = target->rela_tlsdesc_section(layout); 3820 // We store the arguments we need in a vector, and 3821 // use the index into the vector as the parameter 3822 // to pass to the target specific routines. 3823 uintptr_t intarg = target->add_tlsdesc_info(object, r_sym); 3824 void* arg = reinterpret_cast<void*>(intarg); 3825 rt->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg, 3826 got, got_offset, 0); 3827 } 3828 } 3829 else if (optimized_type != tls::TLSOPT_TO_LE) 3830 unsupported_reloc_local(object, r_type); 3831 break; 3832 3833 case elfcpp::R_X86_64_TLSDESC_CALL: 3834 break; 3835 3836 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 3837 if (optimized_type == tls::TLSOPT_NONE) 3838 { 3839 // Create a GOT entry for the module index. 3840 target->got_mod_index_entry(symtab, layout, object); 3841 } 3842 else if (optimized_type != tls::TLSOPT_TO_LE) 3843 unsupported_reloc_local(object, r_type); 3844 break; 3845 3846 case elfcpp::R_X86_64_DTPOFF32: 3847 case elfcpp::R_X86_64_DTPOFF64: 3848 break; 3849 3850 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 3851 layout->set_has_static_tls(); 3852 if (optimized_type == tls::TLSOPT_NONE) 3853 { 3854 // Create a GOT entry for the tp-relative offset. 3855 Output_data_got<64, false>* got 3856 = target->got_section(symtab, layout); 3857 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 3858 got->add_local_with_rel(object, r_sym, GOT_TYPE_TLS_OFFSET, 3859 target->rela_dyn_section(layout), 3860 elfcpp::R_X86_64_TPOFF64); 3861 } 3862 else if (optimized_type != tls::TLSOPT_TO_LE) 3863 unsupported_reloc_local(object, r_type); 3864 break; 3865 3866 case elfcpp::R_X86_64_TPOFF32: // Local-exec 3867 layout->set_has_static_tls(); 3868 if (output_is_shared) 3869 unsupported_reloc_local(object, r_type); 3870 break; 3871 3872 default: 3873 gold_unreachable(); 3874 } 3875 } 3876 break; 3877 3878 case elfcpp::R_X86_64_SIZE32: 3879 case elfcpp::R_X86_64_SIZE64: 3880 default: 3881 gold_error(_("%s: unsupported reloc %u against local symbol"), 3882 object->name().c_str(), r_type); 3883 break; 3884 } 3885 } 3886 3887 3888 // Report an unsupported relocation against a global symbol. 3889 3890 template<int size> 3891 void 3892 Target_x86_64<size>::Scan::unsupported_reloc_global( 3893 Sized_relobj_file<size, false>* object, 3894 unsigned int r_type, 3895 Symbol* gsym) 3896 { 3897 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 3898 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 3899 } 3900 3901 // Returns true if this relocation type could be that of a function pointer. 3902 template<int size> 3903 inline bool 3904 Target_x86_64<size>::Scan::possible_function_pointer_reloc( 3905 Sized_relobj_file<size, false>* src_obj, 3906 unsigned int src_indx, 3907 unsigned int r_offset, 3908 unsigned int r_type) 3909 { 3910 switch (r_type) 3911 { 3912 case elfcpp::R_X86_64_64: 3913 case elfcpp::R_X86_64_32: 3914 case elfcpp::R_X86_64_32S: 3915 case elfcpp::R_X86_64_16: 3916 case elfcpp::R_X86_64_8: 3917 case elfcpp::R_X86_64_GOT64: 3918 case elfcpp::R_X86_64_GOT32: 3919 case elfcpp::R_X86_64_GOTPCREL64: 3920 case elfcpp::R_X86_64_GOTPCREL: 3921 case elfcpp::R_X86_64_GOTPCRELX: 3922 case elfcpp::R_X86_64_REX_GOTPCRELX: 3923 case elfcpp::R_X86_64_GOTPLT64: 3924 { 3925 return true; 3926 } 3927 case elfcpp::R_X86_64_PC32: 3928 { 3929 // This relocation may be used both for function calls and 3930 // for taking address of a function. We distinguish between 3931 // them by checking the opcodes. 3932 uint64_t sh_flags = src_obj->section_flags(src_indx); 3933 bool is_executable = (sh_flags & elfcpp::SHF_EXECINSTR) != 0; 3934 if (is_executable) 3935 { 3936 section_size_type stype; 3937 const unsigned char* view = src_obj->section_contents(src_indx, 3938 &stype, 3939 true); 3940 3941 // call 3942 if (r_offset >= 1 3943 && view[r_offset - 1] == 0xe8) 3944 return false; 3945 3946 // jmp 3947 if (r_offset >= 1 3948 && view[r_offset - 1] == 0xe9) 3949 return false; 3950 3951 // jo/jno/jb/jnb/je/jne/jna/ja/js/jns/jp/jnp/jl/jge/jle/jg 3952 if (r_offset >= 2 3953 && view[r_offset - 2] == 0x0f 3954 && view[r_offset - 1] >= 0x80 3955 && view[r_offset - 1] <= 0x8f) 3956 return false; 3957 } 3958 3959 // Be conservative and treat all others as function pointers. 3960 return true; 3961 } 3962 } 3963 return false; 3964 } 3965 3966 // For safe ICF, scan a relocation for a local symbol to check if it 3967 // corresponds to a function pointer being taken. In that case mark 3968 // the function whose pointer was taken as not foldable. 3969 3970 template<int size> 3971 inline bool 3972 Target_x86_64<size>::Scan::local_reloc_may_be_function_pointer( 3973 Symbol_table* , 3974 Layout* , 3975 Target_x86_64<size>* , 3976 Sized_relobj_file<size, false>* src_obj, 3977 unsigned int src_indx, 3978 Output_section* , 3979 const elfcpp::Rela<size, false>& reloc, 3980 unsigned int r_type, 3981 const elfcpp::Sym<size, false>&) 3982 { 3983 // When building a shared library, do not fold any local symbols as it is 3984 // not possible to distinguish pointer taken versus a call by looking at 3985 // the relocation types. 3986 if (parameters->options().shared()) 3987 return true; 3988 3989 return possible_function_pointer_reloc(src_obj, src_indx, 3990 reloc.get_r_offset(), r_type); 3991 } 3992 3993 // For safe ICF, scan a relocation for a global symbol to check if it 3994 // corresponds to a function pointer being taken. In that case mark 3995 // the function whose pointer was taken as not foldable. 3996 3997 template<int size> 3998 inline bool 3999 Target_x86_64<size>::Scan::global_reloc_may_be_function_pointer( 4000 Symbol_table*, 4001 Layout* , 4002 Target_x86_64<size>* , 4003 Sized_relobj_file<size, false>* src_obj, 4004 unsigned int src_indx, 4005 Output_section* , 4006 const elfcpp::Rela<size, false>& reloc, 4007 unsigned int r_type, 4008 Symbol* gsym) 4009 { 4010 // When building a shared library, do not fold symbols whose visibility 4011 // is hidden, internal or protected. 4012 if (parameters->options().shared() 4013 && (gsym->visibility() == elfcpp::STV_INTERNAL 4014 || gsym->visibility() == elfcpp::STV_PROTECTED 4015 || gsym->visibility() == elfcpp::STV_HIDDEN)) 4016 return true; 4017 4018 return possible_function_pointer_reloc(src_obj, src_indx, 4019 reloc.get_r_offset(), r_type); 4020 } 4021 4022 // Scan a relocation for a global symbol. 4023 4024 template<int size> 4025 inline void 4026 Target_x86_64<size>::Scan::global(Symbol_table* symtab, 4027 Layout* layout, 4028 Target_x86_64<size>* target, 4029 Sized_relobj_file<size, false>* object, 4030 unsigned int data_shndx, 4031 Output_section* output_section, 4032 const elfcpp::Rela<size, false>& reloc, 4033 unsigned int r_type, 4034 Symbol* gsym) 4035 { 4036 // A STT_GNU_IFUNC symbol may require a PLT entry. 4037 if (gsym->type() == elfcpp::STT_GNU_IFUNC 4038 && this->reloc_needs_plt_for_ifunc(object, r_type)) 4039 target->make_plt_entry(symtab, layout, gsym); 4040 4041 switch (r_type) 4042 { 4043 case elfcpp::R_X86_64_NONE: 4044 case elfcpp::R_X86_64_GNU_VTINHERIT: 4045 case elfcpp::R_X86_64_GNU_VTENTRY: 4046 break; 4047 4048 case elfcpp::R_X86_64_64: 4049 case elfcpp::R_X86_64_32: 4050 case elfcpp::R_X86_64_32S: 4051 case elfcpp::R_X86_64_16: 4052 case elfcpp::R_X86_64_8: 4053 { 4054 // Make a PLT entry if necessary. 4055 if (gsym->needs_plt_entry()) 4056 { 4057 target->make_plt_entry(symtab, layout, gsym); 4058 // Since this is not a PC-relative relocation, we may be 4059 // taking the address of a function. In that case we need to 4060 // set the entry in the dynamic symbol table to the address of 4061 // the PLT entry. 4062 if (gsym->is_from_dynobj() && !parameters->options().shared()) 4063 gsym->set_needs_dynsym_value(); 4064 } 4065 // Make a dynamic relocation if necessary. 4066 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 4067 { 4068 if (!parameters->options().output_is_position_independent() 4069 && gsym->may_need_copy_reloc()) 4070 { 4071 target->copy_reloc(symtab, layout, object, 4072 data_shndx, output_section, gsym, reloc); 4073 } 4074 else if (((size == 64 && r_type == elfcpp::R_X86_64_64) 4075 || (size == 32 && r_type == elfcpp::R_X86_64_32)) 4076 && gsym->type() == elfcpp::STT_GNU_IFUNC 4077 && gsym->can_use_relative_reloc(false) 4078 && !gsym->is_from_dynobj() 4079 && !gsym->is_undefined() 4080 && !gsym->is_preemptible()) 4081 { 4082 // Use an IRELATIVE reloc for a locally defined 4083 // STT_GNU_IFUNC symbol. This makes a function 4084 // address in a PIE executable match the address in a 4085 // shared library that it links against. 4086 Reloc_section* rela_dyn = 4087 target->rela_irelative_section(layout); 4088 unsigned int r_type = elfcpp::R_X86_64_IRELATIVE; 4089 rela_dyn->add_symbolless_global_addend(gsym, r_type, 4090 output_section, object, 4091 data_shndx, 4092 reloc.get_r_offset(), 4093 reloc.get_r_addend()); 4094 } 4095 else if (((size == 64 && r_type == elfcpp::R_X86_64_64) 4096 || (size == 32 && r_type == elfcpp::R_X86_64_32)) 4097 && gsym->can_use_relative_reloc(false)) 4098 { 4099 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 4100 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE, 4101 output_section, object, 4102 data_shndx, 4103 reloc.get_r_offset(), 4104 reloc.get_r_addend(), false); 4105 } 4106 else 4107 { 4108 this->check_non_pic(object, r_type, gsym); 4109 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 4110 rela_dyn->add_global(gsym, r_type, output_section, object, 4111 data_shndx, reloc.get_r_offset(), 4112 reloc.get_r_addend()); 4113 } 4114 } 4115 } 4116 break; 4117 4118 case elfcpp::R_X86_64_PC64: 4119 case elfcpp::R_X86_64_PC32: 4120 case elfcpp::R_X86_64_PC32_BND: 4121 case elfcpp::R_X86_64_PC16: 4122 case elfcpp::R_X86_64_PC8: 4123 { 4124 // Make a PLT entry if necessary. 4125 if (gsym->needs_plt_entry()) 4126 target->make_plt_entry(symtab, layout, gsym); 4127 // Make a dynamic relocation if necessary. 4128 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 4129 { 4130 if (parameters->options().output_is_executable() 4131 && gsym->may_need_copy_reloc()) 4132 { 4133 target->copy_reloc(symtab, layout, object, 4134 data_shndx, output_section, gsym, reloc); 4135 } 4136 else 4137 { 4138 this->check_non_pic(object, r_type, gsym); 4139 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 4140 rela_dyn->add_global(gsym, r_type, output_section, object, 4141 data_shndx, reloc.get_r_offset(), 4142 reloc.get_r_addend()); 4143 } 4144 } 4145 } 4146 break; 4147 4148 case elfcpp::R_X86_64_GOT64: 4149 case elfcpp::R_X86_64_GOT32: 4150 case elfcpp::R_X86_64_GOTPCREL64: 4151 case elfcpp::R_X86_64_GOTPCREL: 4152 case elfcpp::R_X86_64_GOTPCRELX: 4153 case elfcpp::R_X86_64_REX_GOTPCRELX: 4154 case elfcpp::R_X86_64_GOTPLT64: 4155 { 4156 // The symbol requires a GOT entry. 4157 Output_data_got<64, false>* got = target->got_section(symtab, layout); 4158 4159 // If we convert this from 4160 // mov foo@GOTPCREL(%rip), %reg 4161 // to lea foo(%rip), %reg. 4162 // OR 4163 // if we convert 4164 // (callq|jmpq) *foo@GOTPCRELX(%rip) to 4165 // (callq|jmpq) foo 4166 // in Relocate::relocate, then there is nothing to do here. 4167 // We cannot make these optimizations in incremental linking mode, 4168 // because we look at the opcode to decide whether or not to make 4169 // change, and during an incremental update, the change may have 4170 // already been applied. 4171 4172 Lazy_view<size> view(object, data_shndx); 4173 size_t r_offset = reloc.get_r_offset(); 4174 if (!parameters->incremental() 4175 && r_offset >= 2 4176 && Target_x86_64<size>::can_convert_mov_to_lea(gsym, r_type, 4177 r_offset, &view)) 4178 break; 4179 4180 if (!parameters->incremental() 4181 && r_offset >= 2 4182 && Target_x86_64<size>::can_convert_callq_to_direct(gsym, r_type, 4183 r_offset, 4184 &view)) 4185 break; 4186 4187 if (gsym->final_value_is_known()) 4188 { 4189 // For a STT_GNU_IFUNC symbol we want the PLT address. 4190 if (gsym->type() == elfcpp::STT_GNU_IFUNC) 4191 got->add_global_plt(gsym, GOT_TYPE_STANDARD); 4192 else 4193 got->add_global(gsym, GOT_TYPE_STANDARD); 4194 } 4195 else 4196 { 4197 // If this symbol is not fully resolved, we need to add a 4198 // dynamic relocation for it. 4199 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 4200 4201 // Use a GLOB_DAT rather than a RELATIVE reloc if: 4202 // 4203 // 1) The symbol may be defined in some other module. 4204 // 4205 // 2) We are building a shared library and this is a 4206 // protected symbol; using GLOB_DAT means that the dynamic 4207 // linker can use the address of the PLT in the main 4208 // executable when appropriate so that function address 4209 // comparisons work. 4210 // 4211 // 3) This is a STT_GNU_IFUNC symbol in position dependent 4212 // code, again so that function address comparisons work. 4213 if (gsym->is_from_dynobj() 4214 || gsym->is_undefined() 4215 || gsym->is_preemptible() 4216 || (gsym->visibility() == elfcpp::STV_PROTECTED 4217 && parameters->options().shared()) 4218 || (gsym->type() == elfcpp::STT_GNU_IFUNC 4219 && parameters->options().output_is_position_independent())) 4220 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, rela_dyn, 4221 elfcpp::R_X86_64_GLOB_DAT); 4222 else 4223 { 4224 // For a STT_GNU_IFUNC symbol we want to write the PLT 4225 // offset into the GOT, so that function pointer 4226 // comparisons work correctly. 4227 bool is_new; 4228 if (gsym->type() != elfcpp::STT_GNU_IFUNC) 4229 is_new = got->add_global(gsym, GOT_TYPE_STANDARD); 4230 else 4231 { 4232 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD); 4233 // Tell the dynamic linker to use the PLT address 4234 // when resolving relocations. 4235 if (gsym->is_from_dynobj() 4236 && !parameters->options().shared()) 4237 gsym->set_needs_dynsym_value(); 4238 } 4239 if (is_new) 4240 { 4241 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD); 4242 rela_dyn->add_global_relative(gsym, 4243 elfcpp::R_X86_64_RELATIVE, 4244 got, got_off, 0, false); 4245 } 4246 } 4247 } 4248 } 4249 break; 4250 4251 case elfcpp::R_X86_64_PLT32: 4252 case elfcpp::R_X86_64_PLT32_BND: 4253 // If the symbol is fully resolved, this is just a PC32 reloc. 4254 // Otherwise we need a PLT entry. 4255 if (gsym->final_value_is_known()) 4256 break; 4257 // If building a shared library, we can also skip the PLT entry 4258 // if the symbol is defined in the output file and is protected 4259 // or hidden. 4260 if (gsym->is_defined() 4261 && !gsym->is_from_dynobj() 4262 && !gsym->is_preemptible()) 4263 break; 4264 target->make_plt_entry(symtab, layout, gsym); 4265 break; 4266 4267 case elfcpp::R_X86_64_GOTPC32: 4268 case elfcpp::R_X86_64_GOTOFF64: 4269 case elfcpp::R_X86_64_GOTPC64: 4270 case elfcpp::R_X86_64_PLTOFF64: 4271 // We need a GOT section. 4272 target->got_section(symtab, layout); 4273 // For PLTOFF64, we also need a PLT entry (but only if the 4274 // symbol is not fully resolved). 4275 if (r_type == elfcpp::R_X86_64_PLTOFF64 4276 && !gsym->final_value_is_known()) 4277 target->make_plt_entry(symtab, layout, gsym); 4278 break; 4279 4280 case elfcpp::R_X86_64_COPY: 4281 case elfcpp::R_X86_64_GLOB_DAT: 4282 case elfcpp::R_X86_64_JUMP_SLOT: 4283 case elfcpp::R_X86_64_RELATIVE: 4284 case elfcpp::R_X86_64_IRELATIVE: 4285 // These are outstanding tls relocs, which are unexpected when linking 4286 case elfcpp::R_X86_64_TPOFF64: 4287 case elfcpp::R_X86_64_DTPMOD64: 4288 case elfcpp::R_X86_64_TLSDESC: 4289 gold_error(_("%s: unexpected reloc %u in object file"), 4290 object->name().c_str(), r_type); 4291 break; 4292 4293 // These are initial tls relocs, which are expected for global() 4294 case elfcpp::R_X86_64_TLSGD: // Global-dynamic 4295 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url) 4296 case elfcpp::R_X86_64_TLSDESC_CALL: 4297 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 4298 case elfcpp::R_X86_64_DTPOFF32: 4299 case elfcpp::R_X86_64_DTPOFF64: 4300 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 4301 case elfcpp::R_X86_64_TPOFF32: // Local-exec 4302 { 4303 // For the Initial-Exec model, we can treat undef symbols as final 4304 // when building an executable. 4305 const bool is_final = (gsym->final_value_is_known() || 4306 (r_type == elfcpp::R_X86_64_GOTTPOFF && 4307 gsym->is_undefined() && 4308 parameters->options().output_is_executable())); 4309 const tls::Tls_optimization optimized_type 4310 = Target_x86_64<size>::optimize_tls_reloc(is_final, r_type); 4311 switch (r_type) 4312 { 4313 case elfcpp::R_X86_64_TLSGD: // General-dynamic 4314 if (optimized_type == tls::TLSOPT_NONE) 4315 { 4316 // Create a pair of GOT entries for the module index and 4317 // dtv-relative offset. 4318 Output_data_got<64, false>* got 4319 = target->got_section(symtab, layout); 4320 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR, 4321 target->rela_dyn_section(layout), 4322 elfcpp::R_X86_64_DTPMOD64, 4323 elfcpp::R_X86_64_DTPOFF64); 4324 } 4325 else if (optimized_type == tls::TLSOPT_TO_IE) 4326 { 4327 // Create a GOT entry for the tp-relative offset. 4328 Output_data_got<64, false>* got 4329 = target->got_section(symtab, layout); 4330 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 4331 target->rela_dyn_section(layout), 4332 elfcpp::R_X86_64_TPOFF64); 4333 } 4334 else if (optimized_type != tls::TLSOPT_TO_LE) 4335 unsupported_reloc_global(object, r_type, gsym); 4336 break; 4337 4338 case elfcpp::R_X86_64_GOTPC32_TLSDESC: 4339 target->define_tls_base_symbol(symtab, layout); 4340 if (optimized_type == tls::TLSOPT_NONE) 4341 { 4342 // Create reserved PLT and GOT entries for the resolver. 4343 target->reserve_tlsdesc_entries(symtab, layout); 4344 4345 // Create a double GOT entry with an R_X86_64_TLSDESC 4346 // reloc. The R_X86_64_TLSDESC reloc is resolved 4347 // lazily, so the GOT entry needs to be in an area in 4348 // .got.plt, not .got. Call got_section to make sure 4349 // the section has been created. 4350 target->got_section(symtab, layout); 4351 Output_data_got<64, false>* got = target->got_tlsdesc_section(); 4352 Reloc_section* rt = target->rela_tlsdesc_section(layout); 4353 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt, 4354 elfcpp::R_X86_64_TLSDESC, 0); 4355 } 4356 else if (optimized_type == tls::TLSOPT_TO_IE) 4357 { 4358 // Create a GOT entry for the tp-relative offset. 4359 Output_data_got<64, false>* got 4360 = target->got_section(symtab, layout); 4361 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 4362 target->rela_dyn_section(layout), 4363 elfcpp::R_X86_64_TPOFF64); 4364 } 4365 else if (optimized_type != tls::TLSOPT_TO_LE) 4366 unsupported_reloc_global(object, r_type, gsym); 4367 break; 4368 4369 case elfcpp::R_X86_64_TLSDESC_CALL: 4370 break; 4371 4372 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 4373 if (optimized_type == tls::TLSOPT_NONE) 4374 { 4375 // Create a GOT entry for the module index. 4376 target->got_mod_index_entry(symtab, layout, object); 4377 } 4378 else if (optimized_type != tls::TLSOPT_TO_LE) 4379 unsupported_reloc_global(object, r_type, gsym); 4380 break; 4381 4382 case elfcpp::R_X86_64_DTPOFF32: 4383 case elfcpp::R_X86_64_DTPOFF64: 4384 break; 4385 4386 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 4387 layout->set_has_static_tls(); 4388 if (optimized_type == tls::TLSOPT_NONE) 4389 { 4390 // Create a GOT entry for the tp-relative offset. 4391 Output_data_got<64, false>* got 4392 = target->got_section(symtab, layout); 4393 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 4394 target->rela_dyn_section(layout), 4395 elfcpp::R_X86_64_TPOFF64); 4396 } 4397 else if (optimized_type != tls::TLSOPT_TO_LE) 4398 unsupported_reloc_global(object, r_type, gsym); 4399 break; 4400 4401 case elfcpp::R_X86_64_TPOFF32: // Local-exec 4402 layout->set_has_static_tls(); 4403 if (parameters->options().shared()) 4404 unsupported_reloc_global(object, r_type, gsym); 4405 break; 4406 4407 default: 4408 gold_unreachable(); 4409 } 4410 } 4411 break; 4412 4413 case elfcpp::R_X86_64_SIZE32: 4414 case elfcpp::R_X86_64_SIZE64: 4415 default: 4416 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 4417 object->name().c_str(), r_type, 4418 gsym->demangled_name().c_str()); 4419 break; 4420 } 4421 } 4422 4423 template<int size> 4424 void 4425 Target_x86_64<size>::gc_process_relocs(Symbol_table* symtab, 4426 Layout* layout, 4427 Sized_relobj_file<size, false>* object, 4428 unsigned int data_shndx, 4429 unsigned int sh_type, 4430 const unsigned char* prelocs, 4431 size_t reloc_count, 4432 Output_section* output_section, 4433 bool needs_special_offset_handling, 4434 size_t local_symbol_count, 4435 const unsigned char* plocal_symbols) 4436 { 4437 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, false> 4438 Classify_reloc; 4439 4440 if (sh_type == elfcpp::SHT_REL) 4441 { 4442 return; 4443 } 4444 4445 gold::gc_process_relocs<size, false, Target_x86_64<size>, Scan, 4446 Classify_reloc>( 4447 symtab, 4448 layout, 4449 this, 4450 object, 4451 data_shndx, 4452 prelocs, 4453 reloc_count, 4454 output_section, 4455 needs_special_offset_handling, 4456 local_symbol_count, 4457 plocal_symbols); 4458 4459 } 4460 // Scan relocations for a section. 4461 4462 template<int size> 4463 void 4464 Target_x86_64<size>::scan_relocs(Symbol_table* symtab, 4465 Layout* layout, 4466 Sized_relobj_file<size, false>* object, 4467 unsigned int data_shndx, 4468 unsigned int sh_type, 4469 const unsigned char* prelocs, 4470 size_t reloc_count, 4471 Output_section* output_section, 4472 bool needs_special_offset_handling, 4473 size_t local_symbol_count, 4474 const unsigned char* plocal_symbols) 4475 { 4476 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, false> 4477 Classify_reloc; 4478 4479 if (sh_type == elfcpp::SHT_REL) 4480 { 4481 gold_error(_("%s: unsupported REL reloc section"), 4482 object->name().c_str()); 4483 return; 4484 } 4485 4486 gold::scan_relocs<size, false, Target_x86_64<size>, Scan, Classify_reloc>( 4487 symtab, 4488 layout, 4489 this, 4490 object, 4491 data_shndx, 4492 prelocs, 4493 reloc_count, 4494 output_section, 4495 needs_special_offset_handling, 4496 local_symbol_count, 4497 plocal_symbols); 4498 } 4499 4500 // Finalize the sections. 4501 4502 template<int size> 4503 void 4504 Target_x86_64<size>::do_finalize_sections( 4505 Layout* layout, 4506 const Input_objects*, 4507 Symbol_table* symtab) 4508 { 4509 const Reloc_section* rel_plt = (this->plt_ == NULL 4510 ? NULL 4511 : this->plt_->rela_plt()); 4512 layout->add_target_dynamic_tags(false, this->got_plt_, rel_plt, 4513 this->rela_dyn_, true, false); 4514 4515 // Fill in some more dynamic tags. 4516 Output_data_dynamic* const odyn = layout->dynamic_data(); 4517 if (odyn != NULL) 4518 { 4519 if (this->plt_ != NULL 4520 && this->plt_->output_section() != NULL 4521 && this->plt_->has_tlsdesc_entry()) 4522 { 4523 unsigned int plt_offset = this->plt_->get_tlsdesc_plt_offset(); 4524 unsigned int got_offset = this->plt_->get_tlsdesc_got_offset(); 4525 this->got_->finalize_data_size(); 4526 odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_PLT, 4527 this->plt_, plt_offset); 4528 odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_GOT, 4529 this->got_, got_offset); 4530 } 4531 } 4532 4533 // Emit any relocs we saved in an attempt to avoid generating COPY 4534 // relocs. 4535 if (this->copy_relocs_.any_saved_relocs()) 4536 this->copy_relocs_.emit(this->rela_dyn_section(layout)); 4537 4538 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of 4539 // the .got.plt section. 4540 Symbol* sym = this->global_offset_table_; 4541 if (sym != NULL) 4542 { 4543 uint64_t data_size = this->got_plt_->current_data_size(); 4544 symtab->get_sized_symbol<size>(sym)->set_symsize(data_size); 4545 } 4546 4547 if (parameters->doing_static_link() 4548 && (this->plt_ == NULL || !this->plt_->has_irelative_section())) 4549 { 4550 // If linking statically, make sure that the __rela_iplt symbols 4551 // were defined if necessary, even if we didn't create a PLT. 4552 static const Define_symbol_in_segment syms[] = 4553 { 4554 { 4555 "__rela_iplt_start", // name 4556 elfcpp::PT_LOAD, // segment_type 4557 elfcpp::PF_W, // segment_flags_set 4558 elfcpp::PF(0), // segment_flags_clear 4559 0, // value 4560 0, // size 4561 elfcpp::STT_NOTYPE, // type 4562 elfcpp::STB_GLOBAL, // binding 4563 elfcpp::STV_HIDDEN, // visibility 4564 0, // nonvis 4565 Symbol::SEGMENT_START, // offset_from_base 4566 true // only_if_ref 4567 }, 4568 { 4569 "__rela_iplt_end", // name 4570 elfcpp::PT_LOAD, // segment_type 4571 elfcpp::PF_W, // segment_flags_set 4572 elfcpp::PF(0), // segment_flags_clear 4573 0, // value 4574 0, // size 4575 elfcpp::STT_NOTYPE, // type 4576 elfcpp::STB_GLOBAL, // binding 4577 elfcpp::STV_HIDDEN, // visibility 4578 0, // nonvis 4579 Symbol::SEGMENT_START, // offset_from_base 4580 true // only_if_ref 4581 } 4582 }; 4583 4584 symtab->define_symbols(layout, 2, syms, 4585 layout->script_options()->saw_sections_clause()); 4586 } 4587 } 4588 4589 // For x32, we need to handle PC-relative relocations using full 64-bit 4590 // arithmetic, so that we can detect relocation overflows properly. 4591 // This class overrides the pcrela32_check methods from the defaults in 4592 // Relocate_functions in reloc.h. 4593 4594 template<int size> 4595 class X86_64_relocate_functions : public Relocate_functions<size, false> 4596 { 4597 public: 4598 typedef Relocate_functions<size, false> Base; 4599 4600 // Do a simple PC relative relocation with the addend in the 4601 // relocation. 4602 static inline typename Base::Reloc_status 4603 pcrela32_check(unsigned char* view, 4604 typename elfcpp::Elf_types<64>::Elf_Addr value, 4605 typename elfcpp::Elf_types<64>::Elf_Swxword addend, 4606 typename elfcpp::Elf_types<64>::Elf_Addr address) 4607 { 4608 typedef typename elfcpp::Swap<32, false>::Valtype Valtype; 4609 Valtype* wv = reinterpret_cast<Valtype*>(view); 4610 value = value + addend - address; 4611 elfcpp::Swap<32, false>::writeval(wv, value); 4612 return (Bits<32>::has_overflow(value) 4613 ? Base::RELOC_OVERFLOW : Base::RELOC_OK); 4614 } 4615 4616 // Do a simple PC relative relocation with a Symbol_value with the 4617 // addend in the relocation. 4618 static inline typename Base::Reloc_status 4619 pcrela32_check(unsigned char* view, 4620 const Sized_relobj_file<size, false>* object, 4621 const Symbol_value<size>* psymval, 4622 typename elfcpp::Elf_types<64>::Elf_Swxword addend, 4623 typename elfcpp::Elf_types<64>::Elf_Addr address) 4624 { 4625 typedef typename elfcpp::Swap<32, false>::Valtype Valtype; 4626 Valtype* wv = reinterpret_cast<Valtype*>(view); 4627 typename elfcpp::Elf_types<64>::Elf_Addr value; 4628 if (addend >= 0) 4629 value = psymval->value(object, addend); 4630 else 4631 { 4632 // For negative addends, get the symbol value without 4633 // the addend, then add the addend using 64-bit arithmetic. 4634 value = psymval->value(object, 0); 4635 value += addend; 4636 } 4637 value -= address; 4638 elfcpp::Swap<32, false>::writeval(wv, value); 4639 return (Bits<32>::has_overflow(value) 4640 ? Base::RELOC_OVERFLOW : Base::RELOC_OK); 4641 } 4642 }; 4643 4644 // Perform a relocation. 4645 4646 template<int size> 4647 inline bool 4648 Target_x86_64<size>::Relocate::relocate( 4649 const Relocate_info<size, false>* relinfo, 4650 unsigned int, 4651 Target_x86_64<size>* target, 4652 Output_section*, 4653 size_t relnum, 4654 const unsigned char* preloc, 4655 const Sized_symbol<size>* gsym, 4656 const Symbol_value<size>* psymval, 4657 unsigned char* view, 4658 typename elfcpp::Elf_types<size>::Elf_Addr address, 4659 section_size_type view_size) 4660 { 4661 typedef X86_64_relocate_functions<size> Reloc_funcs; 4662 const elfcpp::Rela<size, false> rela(preloc); 4663 unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info()); 4664 4665 if (this->skip_call_tls_get_addr_) 4666 { 4667 if ((r_type != elfcpp::R_X86_64_PLT32 4668 && r_type != elfcpp::R_X86_64_GOTPCREL 4669 && r_type != elfcpp::R_X86_64_GOTPCRELX 4670 && r_type != elfcpp::R_X86_64_PLT32_BND 4671 && r_type != elfcpp::R_X86_64_PC32_BND 4672 && r_type != elfcpp::R_X86_64_PC32) 4673 || gsym == NULL 4674 || strcmp(gsym->name(), "__tls_get_addr") != 0) 4675 { 4676 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 4677 _("missing expected TLS relocation")); 4678 this->skip_call_tls_get_addr_ = false; 4679 } 4680 else 4681 { 4682 this->skip_call_tls_get_addr_ = false; 4683 return false; 4684 } 4685 } 4686 4687 if (view == NULL) 4688 return true; 4689 4690 const Sized_relobj_file<size, false>* object = relinfo->object; 4691 4692 // Pick the value to use for symbols defined in the PLT. 4693 Symbol_value<size> symval; 4694 if (gsym != NULL 4695 && gsym->use_plt_offset(Scan::get_reference_flags(r_type))) 4696 { 4697 symval.set_output_value(target->plt_address_for_global(gsym)); 4698 psymval = &symval; 4699 } 4700 else if (gsym == NULL && psymval->is_ifunc_symbol()) 4701 { 4702 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 4703 if (object->local_has_plt_offset(r_sym)) 4704 { 4705 symval.set_output_value(target->plt_address_for_local(object, r_sym)); 4706 psymval = &symval; 4707 } 4708 } 4709 4710 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 4711 4712 // Get the GOT offset if needed. 4713 // The GOT pointer points to the end of the GOT section. 4714 // We need to subtract the size of the GOT section to get 4715 // the actual offset to use in the relocation. 4716 bool have_got_offset = false; 4717 // Since the actual offset is always negative, we use signed int to 4718 // support 64-bit GOT relocations. 4719 int got_offset = 0; 4720 switch (r_type) 4721 { 4722 case elfcpp::R_X86_64_GOT32: 4723 case elfcpp::R_X86_64_GOT64: 4724 case elfcpp::R_X86_64_GOTPLT64: 4725 case elfcpp::R_X86_64_GOTPCREL64: 4726 if (gsym != NULL) 4727 { 4728 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 4729 got_offset = gsym->got_offset(GOT_TYPE_STANDARD) - target->got_size(); 4730 } 4731 else 4732 { 4733 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 4734 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 4735 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD) 4736 - target->got_size()); 4737 } 4738 have_got_offset = true; 4739 break; 4740 4741 default: 4742 break; 4743 } 4744 4745 typename Reloc_funcs::Reloc_status rstatus = Reloc_funcs::RELOC_OK; 4746 4747 switch (r_type) 4748 { 4749 case elfcpp::R_X86_64_NONE: 4750 case elfcpp::R_X86_64_GNU_VTINHERIT: 4751 case elfcpp::R_X86_64_GNU_VTENTRY: 4752 break; 4753 4754 case elfcpp::R_X86_64_64: 4755 Reloc_funcs::rela64(view, object, psymval, addend); 4756 break; 4757 4758 case elfcpp::R_X86_64_PC64: 4759 Reloc_funcs::pcrela64(view, object, psymval, addend, 4760 address); 4761 break; 4762 4763 case elfcpp::R_X86_64_32: 4764 rstatus = Reloc_funcs::rela32_check(view, object, psymval, addend, 4765 Reloc_funcs::CHECK_UNSIGNED); 4766 break; 4767 4768 case elfcpp::R_X86_64_32S: 4769 rstatus = Reloc_funcs::rela32_check(view, object, psymval, addend, 4770 Reloc_funcs::CHECK_SIGNED); 4771 break; 4772 4773 case elfcpp::R_X86_64_PC32: 4774 case elfcpp::R_X86_64_PC32_BND: 4775 rstatus = Reloc_funcs::pcrela32_check(view, object, psymval, addend, 4776 address); 4777 break; 4778 4779 case elfcpp::R_X86_64_16: 4780 Reloc_funcs::rela16(view, object, psymval, addend); 4781 break; 4782 4783 case elfcpp::R_X86_64_PC16: 4784 Reloc_funcs::pcrela16(view, object, psymval, addend, address); 4785 break; 4786 4787 case elfcpp::R_X86_64_8: 4788 Reloc_funcs::rela8(view, object, psymval, addend); 4789 break; 4790 4791 case elfcpp::R_X86_64_PC8: 4792 Reloc_funcs::pcrela8(view, object, psymval, addend, address); 4793 break; 4794 4795 case elfcpp::R_X86_64_PLT32: 4796 case elfcpp::R_X86_64_PLT32_BND: 4797 gold_assert(gsym == NULL 4798 || gsym->has_plt_offset() 4799 || gsym->final_value_is_known() 4800 || (gsym->is_defined() 4801 && !gsym->is_from_dynobj() 4802 && !gsym->is_preemptible())); 4803 // Note: while this code looks the same as for R_X86_64_PC32, it 4804 // behaves differently because psymval was set to point to 4805 // the PLT entry, rather than the symbol, in Scan::global(). 4806 rstatus = Reloc_funcs::pcrela32_check(view, object, psymval, addend, 4807 address); 4808 break; 4809 4810 case elfcpp::R_X86_64_PLTOFF64: 4811 { 4812 gold_assert(gsym); 4813 gold_assert(gsym->has_plt_offset() 4814 || gsym->final_value_is_known()); 4815 typename elfcpp::Elf_types<size>::Elf_Addr got_address; 4816 // This is the address of GLOBAL_OFFSET_TABLE. 4817 got_address = target->got_plt_section()->address(); 4818 Reloc_funcs::rela64(view, object, psymval, addend - got_address); 4819 } 4820 break; 4821 4822 case elfcpp::R_X86_64_GOT32: 4823 gold_assert(have_got_offset); 4824 Reloc_funcs::rela32(view, got_offset, addend); 4825 break; 4826 4827 case elfcpp::R_X86_64_GOTPC32: 4828 { 4829 gold_assert(gsym); 4830 typename elfcpp::Elf_types<size>::Elf_Addr value; 4831 value = target->got_plt_section()->address(); 4832 Reloc_funcs::pcrela32_check(view, value, addend, address); 4833 } 4834 break; 4835 4836 case elfcpp::R_X86_64_GOT64: 4837 case elfcpp::R_X86_64_GOTPLT64: 4838 // R_X86_64_GOTPLT64 is obsolete and treated the same as 4839 // GOT64. 4840 gold_assert(have_got_offset); 4841 Reloc_funcs::rela64(view, got_offset, addend); 4842 break; 4843 4844 case elfcpp::R_X86_64_GOTPC64: 4845 { 4846 gold_assert(gsym); 4847 typename elfcpp::Elf_types<size>::Elf_Addr value; 4848 value = target->got_plt_section()->address(); 4849 Reloc_funcs::pcrela64(view, value, addend, address); 4850 } 4851 break; 4852 4853 case elfcpp::R_X86_64_GOTOFF64: 4854 { 4855 typename elfcpp::Elf_types<size>::Elf_Addr reladdr; 4856 reladdr = target->got_plt_section()->address(); 4857 Reloc_funcs::pcrela64(view, object, psymval, addend, reladdr); 4858 } 4859 break; 4860 4861 case elfcpp::R_X86_64_GOTPCREL: 4862 case elfcpp::R_X86_64_GOTPCRELX: 4863 case elfcpp::R_X86_64_REX_GOTPCRELX: 4864 { 4865 // Convert 4866 // mov foo@GOTPCREL(%rip), %reg 4867 // to lea foo(%rip), %reg. 4868 // if possible. 4869 if (!parameters->incremental() 4870 && ((gsym == NULL 4871 && rela.get_r_offset() >= 2 4872 && view[-2] == 0x8b 4873 && !psymval->is_ifunc_symbol()) 4874 || (gsym != NULL 4875 && rela.get_r_offset() >= 2 4876 && Target_x86_64<size>::can_convert_mov_to_lea(gsym, r_type, 4877 0, &view)))) 4878 { 4879 view[-2] = 0x8d; 4880 Reloc_funcs::pcrela32(view, object, psymval, addend, address); 4881 } 4882 // Convert 4883 // callq *foo@GOTPCRELX(%rip) to 4884 // addr32 callq foo 4885 // and jmpq *foo@GOTPCRELX(%rip) to 4886 // jmpq foo 4887 // nop 4888 else if (!parameters->incremental() 4889 && gsym != NULL 4890 && rela.get_r_offset() >= 2 4891 && Target_x86_64<size>::can_convert_callq_to_direct(gsym, 4892 r_type, 4893 0, &view)) 4894 { 4895 if (view[-1] == 0x15) 4896 { 4897 // Convert callq *foo@GOTPCRELX(%rip) to addr32 callq. 4898 // Opcode of addr32 is 0x67 and opcode of direct callq is 0xe8. 4899 view[-2] = 0x67; 4900 view[-1] = 0xe8; 4901 // Convert GOTPCRELX to 32-bit pc relative reloc. 4902 Reloc_funcs::pcrela32(view, object, psymval, addend, address); 4903 } 4904 else 4905 { 4906 // Convert jmpq *foo@GOTPCRELX(%rip) to 4907 // jmpq foo 4908 // nop 4909 // The opcode of direct jmpq is 0xe9. 4910 view[-2] = 0xe9; 4911 // The opcode of nop is 0x90. 4912 view[3] = 0x90; 4913 // Convert GOTPCRELX to 32-bit pc relative reloc. jmpq is rip 4914 // relative and since the instruction following the jmpq is now 4915 // the nop, offset the address by 1 byte. The start of the 4916 // relocation also moves ahead by 1 byte. 4917 Reloc_funcs::pcrela32(&view[-1], object, psymval, addend, 4918 address - 1); 4919 } 4920 } 4921 else 4922 { 4923 if (gsym != NULL) 4924 { 4925 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 4926 got_offset = (gsym->got_offset(GOT_TYPE_STANDARD) 4927 - target->got_size()); 4928 } 4929 else 4930 { 4931 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 4932 gold_assert(object->local_has_got_offset(r_sym, 4933 GOT_TYPE_STANDARD)); 4934 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD) 4935 - target->got_size()); 4936 } 4937 typename elfcpp::Elf_types<size>::Elf_Addr value; 4938 value = target->got_plt_section()->address() + got_offset; 4939 Reloc_funcs::pcrela32_check(view, value, addend, address); 4940 } 4941 } 4942 break; 4943 4944 case elfcpp::R_X86_64_GOTPCREL64: 4945 { 4946 gold_assert(have_got_offset); 4947 typename elfcpp::Elf_types<size>::Elf_Addr value; 4948 value = target->got_plt_section()->address() + got_offset; 4949 Reloc_funcs::pcrela64(view, value, addend, address); 4950 } 4951 break; 4952 4953 case elfcpp::R_X86_64_COPY: 4954 case elfcpp::R_X86_64_GLOB_DAT: 4955 case elfcpp::R_X86_64_JUMP_SLOT: 4956 case elfcpp::R_X86_64_RELATIVE: 4957 case elfcpp::R_X86_64_IRELATIVE: 4958 // These are outstanding tls relocs, which are unexpected when linking 4959 case elfcpp::R_X86_64_TPOFF64: 4960 case elfcpp::R_X86_64_DTPMOD64: 4961 case elfcpp::R_X86_64_TLSDESC: 4962 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 4963 _("unexpected reloc %u in object file"), 4964 r_type); 4965 break; 4966 4967 // These are initial tls relocs, which are expected when linking 4968 case elfcpp::R_X86_64_TLSGD: // Global-dynamic 4969 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url) 4970 case elfcpp::R_X86_64_TLSDESC_CALL: 4971 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 4972 case elfcpp::R_X86_64_DTPOFF32: 4973 case elfcpp::R_X86_64_DTPOFF64: 4974 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 4975 case elfcpp::R_X86_64_TPOFF32: // Local-exec 4976 this->relocate_tls(relinfo, target, relnum, rela, r_type, gsym, psymval, 4977 view, address, view_size); 4978 break; 4979 4980 case elfcpp::R_X86_64_SIZE32: 4981 case elfcpp::R_X86_64_SIZE64: 4982 default: 4983 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 4984 _("unsupported reloc %u"), 4985 r_type); 4986 break; 4987 } 4988 4989 if (rstatus == Reloc_funcs::RELOC_OVERFLOW) 4990 { 4991 if (gsym == NULL) 4992 { 4993 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 4994 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 4995 _("relocation overflow: " 4996 "reference to local symbol %u in %s"), 4997 r_sym, object->name().c_str()); 4998 } 4999 else if (gsym->is_defined() && gsym->source() == Symbol::FROM_OBJECT) 5000 { 5001 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 5002 _("relocation overflow: " 5003 "reference to '%s' defined in %s"), 5004 gsym->name(), 5005 gsym->object()->name().c_str()); 5006 } 5007 else 5008 { 5009 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 5010 _("relocation overflow: reference to '%s'"), 5011 gsym->name()); 5012 } 5013 } 5014 5015 return true; 5016 } 5017 5018 // Perform a TLS relocation. 5019 5020 template<int size> 5021 inline void 5022 Target_x86_64<size>::Relocate::relocate_tls( 5023 const Relocate_info<size, false>* relinfo, 5024 Target_x86_64<size>* target, 5025 size_t relnum, 5026 const elfcpp::Rela<size, false>& rela, 5027 unsigned int r_type, 5028 const Sized_symbol<size>* gsym, 5029 const Symbol_value<size>* psymval, 5030 unsigned char* view, 5031 typename elfcpp::Elf_types<size>::Elf_Addr address, 5032 section_size_type view_size) 5033 { 5034 Output_segment* tls_segment = relinfo->layout->tls_segment(); 5035 5036 const Sized_relobj_file<size, false>* object = relinfo->object; 5037 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 5038 elfcpp::Shdr<size, false> data_shdr(relinfo->data_shdr); 5039 bool is_executable = (data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0; 5040 5041 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(relinfo->object, 0); 5042 5043 const bool is_final = (gsym == NULL 5044 ? !parameters->options().shared() 5045 : gsym->final_value_is_known()); 5046 tls::Tls_optimization optimized_type 5047 = Target_x86_64<size>::optimize_tls_reloc(is_final, r_type); 5048 switch (r_type) 5049 { 5050 case elfcpp::R_X86_64_TLSGD: // Global-dynamic 5051 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE) 5052 { 5053 // If this code sequence is used in a non-executable section, 5054 // we will not optimize the R_X86_64_DTPOFF32/64 relocation, 5055 // on the assumption that it's being used by itself in a debug 5056 // section. Therefore, in the unlikely event that the code 5057 // sequence appears in a non-executable section, we simply 5058 // leave it unoptimized. 5059 optimized_type = tls::TLSOPT_NONE; 5060 } 5061 if (optimized_type == tls::TLSOPT_TO_LE) 5062 { 5063 if (tls_segment == NULL) 5064 { 5065 gold_assert(parameters->errors()->error_count() > 0 5066 || issue_undefined_symbol_error(gsym)); 5067 return; 5068 } 5069 this->tls_gd_to_le(relinfo, relnum, tls_segment, 5070 rela, r_type, value, view, 5071 view_size); 5072 break; 5073 } 5074 else 5075 { 5076 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE 5077 ? GOT_TYPE_TLS_OFFSET 5078 : GOT_TYPE_TLS_PAIR); 5079 unsigned int got_offset; 5080 if (gsym != NULL) 5081 { 5082 gold_assert(gsym->has_got_offset(got_type)); 5083 got_offset = gsym->got_offset(got_type) - target->got_size(); 5084 } 5085 else 5086 { 5087 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 5088 gold_assert(object->local_has_got_offset(r_sym, got_type)); 5089 got_offset = (object->local_got_offset(r_sym, got_type) 5090 - target->got_size()); 5091 } 5092 if (optimized_type == tls::TLSOPT_TO_IE) 5093 { 5094 value = target->got_plt_section()->address() + got_offset; 5095 this->tls_gd_to_ie(relinfo, relnum, rela, r_type, 5096 value, view, address, view_size); 5097 break; 5098 } 5099 else if (optimized_type == tls::TLSOPT_NONE) 5100 { 5101 // Relocate the field with the offset of the pair of GOT 5102 // entries. 5103 value = target->got_plt_section()->address() + got_offset; 5104 Relocate_functions<size, false>::pcrela32(view, value, addend, 5105 address); 5106 break; 5107 } 5108 } 5109 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 5110 _("unsupported reloc %u"), r_type); 5111 break; 5112 5113 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url) 5114 case elfcpp::R_X86_64_TLSDESC_CALL: 5115 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE) 5116 { 5117 // See above comment for R_X86_64_TLSGD. 5118 optimized_type = tls::TLSOPT_NONE; 5119 } 5120 if (optimized_type == tls::TLSOPT_TO_LE) 5121 { 5122 if (tls_segment == NULL) 5123 { 5124 gold_assert(parameters->errors()->error_count() > 0 5125 || issue_undefined_symbol_error(gsym)); 5126 return; 5127 } 5128 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment, 5129 rela, r_type, value, view, 5130 view_size); 5131 break; 5132 } 5133 else 5134 { 5135 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE 5136 ? GOT_TYPE_TLS_OFFSET 5137 : GOT_TYPE_TLS_DESC); 5138 unsigned int got_offset = 0; 5139 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC 5140 && optimized_type == tls::TLSOPT_NONE) 5141 { 5142 // We created GOT entries in the .got.tlsdesc portion of 5143 // the .got.plt section, but the offset stored in the 5144 // symbol is the offset within .got.tlsdesc. 5145 got_offset = (target->got_size() 5146 + target->got_plt_section()->data_size()); 5147 } 5148 if (gsym != NULL) 5149 { 5150 gold_assert(gsym->has_got_offset(got_type)); 5151 got_offset += gsym->got_offset(got_type) - target->got_size(); 5152 } 5153 else 5154 { 5155 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 5156 gold_assert(object->local_has_got_offset(r_sym, got_type)); 5157 got_offset += (object->local_got_offset(r_sym, got_type) 5158 - target->got_size()); 5159 } 5160 if (optimized_type == tls::TLSOPT_TO_IE) 5161 { 5162 value = target->got_plt_section()->address() + got_offset; 5163 this->tls_desc_gd_to_ie(relinfo, relnum, 5164 rela, r_type, value, view, address, 5165 view_size); 5166 break; 5167 } 5168 else if (optimized_type == tls::TLSOPT_NONE) 5169 { 5170 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC) 5171 { 5172 // Relocate the field with the offset of the pair of GOT 5173 // entries. 5174 value = target->got_plt_section()->address() + got_offset; 5175 Relocate_functions<size, false>::pcrela32(view, value, addend, 5176 address); 5177 } 5178 break; 5179 } 5180 } 5181 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 5182 _("unsupported reloc %u"), r_type); 5183 break; 5184 5185 case elfcpp::R_X86_64_TLSLD: // Local-dynamic 5186 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE) 5187 { 5188 // See above comment for R_X86_64_TLSGD. 5189 optimized_type = tls::TLSOPT_NONE; 5190 } 5191 if (optimized_type == tls::TLSOPT_TO_LE) 5192 { 5193 if (tls_segment == NULL) 5194 { 5195 gold_assert(parameters->errors()->error_count() > 0 5196 || issue_undefined_symbol_error(gsym)); 5197 return; 5198 } 5199 this->tls_ld_to_le(relinfo, relnum, tls_segment, rela, r_type, 5200 value, view, view_size); 5201 break; 5202 } 5203 else if (optimized_type == tls::TLSOPT_NONE) 5204 { 5205 // Relocate the field with the offset of the GOT entry for 5206 // the module index. 5207 unsigned int got_offset; 5208 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL) 5209 - target->got_size()); 5210 value = target->got_plt_section()->address() + got_offset; 5211 Relocate_functions<size, false>::pcrela32(view, value, addend, 5212 address); 5213 break; 5214 } 5215 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 5216 _("unsupported reloc %u"), r_type); 5217 break; 5218 5219 case elfcpp::R_X86_64_DTPOFF32: 5220 // This relocation type is used in debugging information. 5221 // In that case we need to not optimize the value. If the 5222 // section is not executable, then we assume we should not 5223 // optimize this reloc. See comments above for R_X86_64_TLSGD, 5224 // R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and 5225 // R_X86_64_TLSLD. 5226 if (optimized_type == tls::TLSOPT_TO_LE && is_executable) 5227 { 5228 if (tls_segment == NULL) 5229 { 5230 gold_assert(parameters->errors()->error_count() > 0 5231 || issue_undefined_symbol_error(gsym)); 5232 return; 5233 } 5234 value -= tls_segment->memsz(); 5235 } 5236 Relocate_functions<size, false>::rela32(view, value, addend); 5237 break; 5238 5239 case elfcpp::R_X86_64_DTPOFF64: 5240 // See R_X86_64_DTPOFF32, just above, for why we check for is_executable. 5241 if (optimized_type == tls::TLSOPT_TO_LE && is_executable) 5242 { 5243 if (tls_segment == NULL) 5244 { 5245 gold_assert(parameters->errors()->error_count() > 0 5246 || issue_undefined_symbol_error(gsym)); 5247 return; 5248 } 5249 value -= tls_segment->memsz(); 5250 } 5251 Relocate_functions<size, false>::rela64(view, value, addend); 5252 break; 5253 5254 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec 5255 if (gsym != NULL 5256 && gsym->is_undefined() 5257 && parameters->options().output_is_executable()) 5258 { 5259 Target_x86_64<size>::Relocate::tls_ie_to_le(relinfo, relnum, 5260 NULL, rela, 5261 r_type, value, view, 5262 view_size); 5263 break; 5264 } 5265 else if (optimized_type == tls::TLSOPT_TO_LE) 5266 { 5267 if (tls_segment == NULL) 5268 { 5269 gold_assert(parameters->errors()->error_count() > 0 5270 || issue_undefined_symbol_error(gsym)); 5271 return; 5272 } 5273 Target_x86_64<size>::Relocate::tls_ie_to_le(relinfo, relnum, 5274 tls_segment, rela, 5275 r_type, value, view, 5276 view_size); 5277 break; 5278 } 5279 else if (optimized_type == tls::TLSOPT_NONE) 5280 { 5281 // Relocate the field with the offset of the GOT entry for 5282 // the tp-relative offset of the symbol. 5283 unsigned int got_offset; 5284 if (gsym != NULL) 5285 { 5286 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET)); 5287 got_offset = (gsym->got_offset(GOT_TYPE_TLS_OFFSET) 5288 - target->got_size()); 5289 } 5290 else 5291 { 5292 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 5293 gold_assert(object->local_has_got_offset(r_sym, 5294 GOT_TYPE_TLS_OFFSET)); 5295 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET) 5296 - target->got_size()); 5297 } 5298 value = target->got_plt_section()->address() + got_offset; 5299 Relocate_functions<size, false>::pcrela32(view, value, addend, 5300 address); 5301 break; 5302 } 5303 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 5304 _("unsupported reloc type %u"), 5305 r_type); 5306 break; 5307 5308 case elfcpp::R_X86_64_TPOFF32: // Local-exec 5309 if (tls_segment == NULL) 5310 { 5311 gold_assert(parameters->errors()->error_count() > 0 5312 || issue_undefined_symbol_error(gsym)); 5313 return; 5314 } 5315 value -= tls_segment->memsz(); 5316 Relocate_functions<size, false>::rela32(view, value, addend); 5317 break; 5318 } 5319 } 5320 5321 // Do a relocation in which we convert a TLS General-Dynamic to an 5322 // Initial-Exec. 5323 5324 template<int size> 5325 inline void 5326 Target_x86_64<size>::Relocate::tls_gd_to_ie( 5327 const Relocate_info<size, false>* relinfo, 5328 size_t relnum, 5329 const elfcpp::Rela<size, false>& rela, 5330 unsigned int, 5331 typename elfcpp::Elf_types<size>::Elf_Addr value, 5332 unsigned char* view, 5333 typename elfcpp::Elf_types<size>::Elf_Addr address, 5334 section_size_type view_size) 5335 { 5336 // For SIZE == 64: 5337 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi; 5338 // .word 0x6666; rex64; call __tls_get_addr@PLT 5339 // ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax 5340 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi; 5341 // .word 0x66; rex64; call *__tls_get_addr@GOTPCREL(%rip) 5342 // ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax 5343 // For SIZE == 32: 5344 // leaq foo@tlsgd(%rip),%rdi; 5345 // .word 0x6666; rex64; call __tls_get_addr@PLT 5346 // ==> movl %fs:0,%eax; addq x@gottpoff(%rip),%rax 5347 // leaq foo@tlsgd(%rip),%rdi; 5348 // .word 0x66; rex64; call *__tls_get_addr@GOTPCREL(%rip) 5349 // ==> movl %fs:0,%eax; addq x@gottpoff(%rip),%rax 5350 5351 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12); 5352 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5353 (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0 5354 || memcmp(view + 4, "\x66\x48\xff", 3) == 0)); 5355 5356 if (size == 64) 5357 { 5358 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 5359 -4); 5360 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5361 (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0)); 5362 memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0", 5363 16); 5364 } 5365 else 5366 { 5367 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 5368 -3); 5369 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5370 (memcmp(view - 3, "\x48\x8d\x3d", 3) == 0)); 5371 memcpy(view - 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0", 5372 15); 5373 } 5374 5375 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 5376 Relocate_functions<size, false>::pcrela32(view + 8, value, addend - 8, 5377 address); 5378 5379 // The next reloc should be a PLT32 reloc against __tls_get_addr. 5380 // We can skip it. 5381 this->skip_call_tls_get_addr_ = true; 5382 } 5383 5384 // Do a relocation in which we convert a TLS General-Dynamic to a 5385 // Local-Exec. 5386 5387 template<int size> 5388 inline void 5389 Target_x86_64<size>::Relocate::tls_gd_to_le( 5390 const Relocate_info<size, false>* relinfo, 5391 size_t relnum, 5392 Output_segment* tls_segment, 5393 const elfcpp::Rela<size, false>& rela, 5394 unsigned int, 5395 typename elfcpp::Elf_types<size>::Elf_Addr value, 5396 unsigned char* view, 5397 section_size_type view_size) 5398 { 5399 // For SIZE == 64: 5400 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi; 5401 // .word 0x6666; rex64; call __tls_get_addr@PLT 5402 // ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax 5403 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi; 5404 // .word 0x66; rex64; call *__tls_get_addr@GOTPCREL(%rip) 5405 // ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax 5406 // For SIZE == 32: 5407 // leaq foo@tlsgd(%rip),%rdi; 5408 // .word 0x6666; rex64; call __tls_get_addr@PLT 5409 // ==> movl %fs:0,%eax; leaq x@tpoff(%rax),%rax 5410 // leaq foo@tlsgd(%rip),%rdi; 5411 // .word 0x66; rex64; call *__tls_get_addr@GOTPCREL(%rip) 5412 // ==> movl %fs:0,%eax; leaq x@tpoff(%rax),%rax 5413 5414 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12); 5415 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5416 (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0 5417 || memcmp(view + 4, "\x66\x48\xff", 3) == 0)); 5418 5419 if (size == 64) 5420 { 5421 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 5422 -4); 5423 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5424 (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0)); 5425 memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0", 5426 16); 5427 } 5428 else 5429 { 5430 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 5431 -3); 5432 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5433 (memcmp(view - 3, "\x48\x8d\x3d", 3) == 0)); 5434 5435 memcpy(view - 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0", 5436 15); 5437 } 5438 5439 value -= tls_segment->memsz(); 5440 Relocate_functions<size, false>::rela32(view + 8, value, 0); 5441 5442 // The next reloc should be a PLT32 reloc against __tls_get_addr. 5443 // We can skip it. 5444 this->skip_call_tls_get_addr_ = true; 5445 } 5446 5447 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition. 5448 5449 template<int size> 5450 inline void 5451 Target_x86_64<size>::Relocate::tls_desc_gd_to_ie( 5452 const Relocate_info<size, false>* relinfo, 5453 size_t relnum, 5454 const elfcpp::Rela<size, false>& rela, 5455 unsigned int r_type, 5456 typename elfcpp::Elf_types<size>::Elf_Addr value, 5457 unsigned char* view, 5458 typename elfcpp::Elf_types<size>::Elf_Addr address, 5459 section_size_type view_size) 5460 { 5461 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC) 5462 { 5463 // leaq foo@tlsdesc(%rip), %rax 5464 // ==> movq foo@gottpoff(%rip), %rax 5465 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3); 5466 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4); 5467 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5468 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05); 5469 view[-2] = 0x8b; 5470 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 5471 Relocate_functions<size, false>::pcrela32(view, value, addend, address); 5472 } 5473 else 5474 { 5475 // call *foo@tlscall(%rax) 5476 // ==> nop; nop 5477 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL); 5478 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2); 5479 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5480 view[0] == 0xff && view[1] == 0x10); 5481 view[0] = 0x66; 5482 view[1] = 0x90; 5483 } 5484 } 5485 5486 // Do a TLSDESC-style General-Dynamic to Local-Exec transition. 5487 5488 template<int size> 5489 inline void 5490 Target_x86_64<size>::Relocate::tls_desc_gd_to_le( 5491 const Relocate_info<size, false>* relinfo, 5492 size_t relnum, 5493 Output_segment* tls_segment, 5494 const elfcpp::Rela<size, false>& rela, 5495 unsigned int r_type, 5496 typename elfcpp::Elf_types<size>::Elf_Addr value, 5497 unsigned char* view, 5498 section_size_type view_size) 5499 { 5500 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC) 5501 { 5502 // leaq foo@tlsdesc(%rip), %rax 5503 // ==> movq foo@tpoff, %rax 5504 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3); 5505 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4); 5506 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5507 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05); 5508 view[-2] = 0xc7; 5509 view[-1] = 0xc0; 5510 value -= tls_segment->memsz(); 5511 Relocate_functions<size, false>::rela32(view, value, 0); 5512 } 5513 else 5514 { 5515 // call *foo@tlscall(%rax) 5516 // ==> nop; nop 5517 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL); 5518 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2); 5519 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5520 view[0] == 0xff && view[1] == 0x10); 5521 view[0] = 0x66; 5522 view[1] = 0x90; 5523 } 5524 } 5525 5526 template<int size> 5527 inline void 5528 Target_x86_64<size>::Relocate::tls_ld_to_le( 5529 const Relocate_info<size, false>* relinfo, 5530 size_t relnum, 5531 Output_segment*, 5532 const elfcpp::Rela<size, false>& rela, 5533 unsigned int, 5534 typename elfcpp::Elf_types<size>::Elf_Addr, 5535 unsigned char* view, 5536 section_size_type view_size) 5537 { 5538 // leaq foo@tlsld(%rip),%rdi; call __tls_get_addr@plt; 5539 // For SIZE == 64: 5540 // ... leq foo@dtpoff(%rax),%reg 5541 // ==> .word 0x6666; .byte 0x66; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx 5542 // For SIZE == 32: 5543 // ... leq foo@dtpoff(%rax),%reg 5544 // ==> nopl 0x0(%rax); movl %fs:0,%eax ... leaq x@tpoff(%rax),%rdx 5545 // leaq foo@tlsld(%rip),%rdi; call *__tls_get_addr@GOTPCREL(%rip) 5546 // For SIZE == 64: 5547 // ... leq foo@dtpoff(%rax),%reg 5548 // ==> .word 0x6666; .byte 0x6666; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx 5549 // For SIZE == 32: 5550 // ... leq foo@dtpoff(%rax),%reg 5551 // ==> nopw 0x0(%rax); movl %fs:0,%eax ... leaq x@tpoff(%rax),%rdx 5552 5553 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3); 5554 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 9); 5555 5556 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5557 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x3d); 5558 5559 tls::check_tls(relinfo, relnum, rela.get_r_offset(), 5560 view[4] == 0xe8 || view[4] == 0xff); 5561 5562 if (view[4] == 0xe8) 5563 { 5564 if (size == 64) 5565 memcpy(view - 3, "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 12); 5566 else 5567 memcpy(view - 3, "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0\0", 12); 5568 } 5569 else 5570 { 5571 if (size == 64) 5572 memcpy(view - 3, "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 5573 13); 5574 else 5575 memcpy(view - 3, "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0\0", 5576 13); 5577 } 5578 5579 // The next reloc should be a PLT32 reloc against __tls_get_addr. 5580 // We can skip it. 5581 this->skip_call_tls_get_addr_ = true; 5582 } 5583 5584 // Do a relocation in which we convert a TLS Initial-Exec to a 5585 // Local-Exec. 5586 5587 template<int size> 5588 inline void 5589 Target_x86_64<size>::Relocate::tls_ie_to_le( 5590 const Relocate_info<size, false>* relinfo, 5591 size_t relnum, 5592 Output_segment* tls_segment, 5593 const elfcpp::Rela<size, false>& rela, 5594 unsigned int, 5595 typename elfcpp::Elf_types<size>::Elf_Addr value, 5596 unsigned char* view, 5597 section_size_type view_size) 5598 { 5599 // We need to examine the opcodes to figure out which instruction we 5600 // are looking at. 5601 5602 // movq foo@gottpoff(%rip),%reg ==> movq $YY,%reg 5603 // addq foo@gottpoff(%rip),%reg ==> addq $YY,%reg 5604 5605 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3); 5606 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4); 5607 5608 unsigned char op1 = view[-3]; 5609 unsigned char op2 = view[-2]; 5610 unsigned char op3 = view[-1]; 5611 unsigned char reg = op3 >> 3; 5612 5613 if (op2 == 0x8b) 5614 { 5615 // movq 5616 if (op1 == 0x4c) 5617 view[-3] = 0x49; 5618 else if (size == 32 && op1 == 0x44) 5619 view[-3] = 0x41; 5620 view[-2] = 0xc7; 5621 view[-1] = 0xc0 | reg; 5622 } 5623 else if (reg == 4) 5624 { 5625 // Special handling for %rsp. 5626 if (op1 == 0x4c) 5627 view[-3] = 0x49; 5628 else if (size == 32 && op1 == 0x44) 5629 view[-3] = 0x41; 5630 view[-2] = 0x81; 5631 view[-1] = 0xc0 | reg; 5632 } 5633 else 5634 { 5635 // addq 5636 if (op1 == 0x4c) 5637 view[-3] = 0x4d; 5638 else if (size == 32 && op1 == 0x44) 5639 view[-3] = 0x45; 5640 view[-2] = 0x8d; 5641 view[-1] = 0x80 | reg | (reg << 3); 5642 } 5643 5644 if (tls_segment != NULL) 5645 value -= tls_segment->memsz(); 5646 Relocate_functions<size, false>::rela32(view, value, 0); 5647 } 5648 5649 // Relocate section data. 5650 5651 template<int size> 5652 void 5653 Target_x86_64<size>::relocate_section( 5654 const Relocate_info<size, false>* relinfo, 5655 unsigned int sh_type, 5656 const unsigned char* prelocs, 5657 size_t reloc_count, 5658 Output_section* output_section, 5659 bool needs_special_offset_handling, 5660 unsigned char* view, 5661 typename elfcpp::Elf_types<size>::Elf_Addr address, 5662 section_size_type view_size, 5663 const Reloc_symbol_changes* reloc_symbol_changes) 5664 { 5665 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, false> 5666 Classify_reloc; 5667 5668 gold_assert(sh_type == elfcpp::SHT_RELA); 5669 5670 gold::relocate_section<size, false, Target_x86_64<size>, Relocate, 5671 gold::Default_comdat_behavior, Classify_reloc>( 5672 relinfo, 5673 this, 5674 prelocs, 5675 reloc_count, 5676 output_section, 5677 needs_special_offset_handling, 5678 view, 5679 address, 5680 view_size, 5681 reloc_symbol_changes); 5682 } 5683 5684 // Apply an incremental relocation. Incremental relocations always refer 5685 // to global symbols. 5686 5687 template<int size> 5688 void 5689 Target_x86_64<size>::apply_relocation( 5690 const Relocate_info<size, false>* relinfo, 5691 typename elfcpp::Elf_types<size>::Elf_Addr r_offset, 5692 unsigned int r_type, 5693 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend, 5694 const Symbol* gsym, 5695 unsigned char* view, 5696 typename elfcpp::Elf_types<size>::Elf_Addr address, 5697 section_size_type view_size) 5698 { 5699 gold::apply_relocation<size, false, Target_x86_64<size>, 5700 typename Target_x86_64<size>::Relocate>( 5701 relinfo, 5702 this, 5703 r_offset, 5704 r_type, 5705 r_addend, 5706 gsym, 5707 view, 5708 address, 5709 view_size); 5710 } 5711 5712 // Scan the relocs during a relocatable link. 5713 5714 template<int size> 5715 void 5716 Target_x86_64<size>::scan_relocatable_relocs( 5717 Symbol_table* symtab, 5718 Layout* layout, 5719 Sized_relobj_file<size, false>* object, 5720 unsigned int data_shndx, 5721 unsigned int sh_type, 5722 const unsigned char* prelocs, 5723 size_t reloc_count, 5724 Output_section* output_section, 5725 bool needs_special_offset_handling, 5726 size_t local_symbol_count, 5727 const unsigned char* plocal_symbols, 5728 Relocatable_relocs* rr) 5729 { 5730 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, false> 5731 Classify_reloc; 5732 typedef gold::Default_scan_relocatable_relocs<Classify_reloc> 5733 Scan_relocatable_relocs; 5734 5735 gold_assert(sh_type == elfcpp::SHT_RELA); 5736 5737 gold::scan_relocatable_relocs<size, false, Scan_relocatable_relocs>( 5738 symtab, 5739 layout, 5740 object, 5741 data_shndx, 5742 prelocs, 5743 reloc_count, 5744 output_section, 5745 needs_special_offset_handling, 5746 local_symbol_count, 5747 plocal_symbols, 5748 rr); 5749 } 5750 5751 // Scan the relocs for --emit-relocs. 5752 5753 template<int size> 5754 void 5755 Target_x86_64<size>::emit_relocs_scan( 5756 Symbol_table* symtab, 5757 Layout* layout, 5758 Sized_relobj_file<size, false>* object, 5759 unsigned int data_shndx, 5760 unsigned int sh_type, 5761 const unsigned char* prelocs, 5762 size_t reloc_count, 5763 Output_section* output_section, 5764 bool needs_special_offset_handling, 5765 size_t local_symbol_count, 5766 const unsigned char* plocal_syms, 5767 Relocatable_relocs* rr) 5768 { 5769 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, false> 5770 Classify_reloc; 5771 typedef gold::Default_emit_relocs_strategy<Classify_reloc> 5772 Emit_relocs_strategy; 5773 5774 gold_assert(sh_type == elfcpp::SHT_RELA); 5775 5776 gold::scan_relocatable_relocs<size, false, Emit_relocs_strategy>( 5777 symtab, 5778 layout, 5779 object, 5780 data_shndx, 5781 prelocs, 5782 reloc_count, 5783 output_section, 5784 needs_special_offset_handling, 5785 local_symbol_count, 5786 plocal_syms, 5787 rr); 5788 } 5789 5790 // Relocate a section during a relocatable link. 5791 5792 template<int size> 5793 void 5794 Target_x86_64<size>::relocate_relocs( 5795 const Relocate_info<size, false>* relinfo, 5796 unsigned int sh_type, 5797 const unsigned char* prelocs, 5798 size_t reloc_count, 5799 Output_section* output_section, 5800 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section, 5801 unsigned char* view, 5802 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 5803 section_size_type view_size, 5804 unsigned char* reloc_view, 5805 section_size_type reloc_view_size) 5806 { 5807 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, false> 5808 Classify_reloc; 5809 5810 gold_assert(sh_type == elfcpp::SHT_RELA); 5811 5812 gold::relocate_relocs<size, false, Classify_reloc>( 5813 relinfo, 5814 prelocs, 5815 reloc_count, 5816 output_section, 5817 offset_in_output_section, 5818 view, 5819 view_address, 5820 view_size, 5821 reloc_view, 5822 reloc_view_size); 5823 } 5824 5825 // Return the value to use for a dynamic which requires special 5826 // treatment. This is how we support equality comparisons of function 5827 // pointers across shared library boundaries, as described in the 5828 // processor specific ABI supplement. 5829 5830 template<int size> 5831 uint64_t 5832 Target_x86_64<size>::do_dynsym_value(const Symbol* gsym) const 5833 { 5834 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); 5835 return this->plt_address_for_global(gsym); 5836 } 5837 5838 // Return a string used to fill a code section with nops to take up 5839 // the specified length. 5840 5841 template<int size> 5842 std::string 5843 Target_x86_64<size>::do_code_fill(section_size_type length) const 5844 { 5845 if (length >= 16) 5846 { 5847 // Build a jmpq instruction to skip over the bytes. 5848 unsigned char jmp[5]; 5849 jmp[0] = 0xe9; 5850 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5); 5851 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5) 5852 + std::string(length - 5, static_cast<char>(0x90))); 5853 } 5854 5855 // Nop sequences of various lengths. 5856 const char nop1[1] = { '\x90' }; // nop 5857 const char nop2[2] = { '\x66', '\x90' }; // xchg %ax %ax 5858 const char nop3[3] = { '\x0f', '\x1f', '\x00' }; // nop (%rax) 5859 const char nop4[4] = { '\x0f', '\x1f', '\x40', // nop 0(%rax) 5860 '\x00'}; 5861 const char nop5[5] = { '\x0f', '\x1f', '\x44', // nop 0(%rax,%rax,1) 5862 '\x00', '\x00' }; 5863 const char nop6[6] = { '\x66', '\x0f', '\x1f', // nopw 0(%rax,%rax,1) 5864 '\x44', '\x00', '\x00' }; 5865 const char nop7[7] = { '\x0f', '\x1f', '\x80', // nopl 0L(%rax) 5866 '\x00', '\x00', '\x00', 5867 '\x00' }; 5868 const char nop8[8] = { '\x0f', '\x1f', '\x84', // nopl 0L(%rax,%rax,1) 5869 '\x00', '\x00', '\x00', 5870 '\x00', '\x00' }; 5871 const char nop9[9] = { '\x66', '\x0f', '\x1f', // nopw 0L(%rax,%rax,1) 5872 '\x84', '\x00', '\x00', 5873 '\x00', '\x00', '\x00' }; 5874 const char nop10[10] = { '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1) 5875 '\x1f', '\x84', '\x00', 5876 '\x00', '\x00', '\x00', 5877 '\x00' }; 5878 const char nop11[11] = { '\x66', '\x66', '\x2e', // data16 5879 '\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1) 5880 '\x00', '\x00', '\x00', 5881 '\x00', '\x00' }; 5882 const char nop12[12] = { '\x66', '\x66', '\x66', // data16; data16 5883 '\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1) 5884 '\x84', '\x00', '\x00', 5885 '\x00', '\x00', '\x00' }; 5886 const char nop13[13] = { '\x66', '\x66', '\x66', // data16; data16; data16 5887 '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1) 5888 '\x1f', '\x84', '\x00', 5889 '\x00', '\x00', '\x00', 5890 '\x00' }; 5891 const char nop14[14] = { '\x66', '\x66', '\x66', // data16; data16; data16 5892 '\x66', '\x66', '\x2e', // data16 5893 '\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1) 5894 '\x00', '\x00', '\x00', 5895 '\x00', '\x00' }; 5896 const char nop15[15] = { '\x66', '\x66', '\x66', // data16; data16; data16 5897 '\x66', '\x66', '\x66', // data16; data16 5898 '\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1) 5899 '\x84', '\x00', '\x00', 5900 '\x00', '\x00', '\x00' }; 5901 5902 const char* nops[16] = { 5903 NULL, 5904 nop1, nop2, nop3, nop4, nop5, nop6, nop7, 5905 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15 5906 }; 5907 5908 return std::string(nops[length], length); 5909 } 5910 5911 // Return the addend to use for a target specific relocation. The 5912 // only target specific relocation is R_X86_64_TLSDESC for a local 5913 // symbol. We want to set the addend is the offset of the local 5914 // symbol in the TLS segment. 5915 5916 template<int size> 5917 uint64_t 5918 Target_x86_64<size>::do_reloc_addend(void* arg, unsigned int r_type, 5919 uint64_t) const 5920 { 5921 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC); 5922 uintptr_t intarg = reinterpret_cast<uintptr_t>(arg); 5923 gold_assert(intarg < this->tlsdesc_reloc_info_.size()); 5924 const Tlsdesc_info& ti(this->tlsdesc_reloc_info_[intarg]); 5925 const Symbol_value<size>* psymval = ti.object->local_symbol(ti.r_sym); 5926 gold_assert(psymval->is_tls_symbol()); 5927 // The value of a TLS symbol is the offset in the TLS segment. 5928 return psymval->value(ti.object, 0); 5929 } 5930 5931 // Return the value to use for the base of a DW_EH_PE_datarel offset 5932 // in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their 5933 // assembler can not write out the difference between two labels in 5934 // different sections, so instead of using a pc-relative value they 5935 // use an offset from the GOT. 5936 5937 template<int size> 5938 uint64_t 5939 Target_x86_64<size>::do_ehframe_datarel_base() const 5940 { 5941 gold_assert(this->global_offset_table_ != NULL); 5942 Symbol* sym = this->global_offset_table_; 5943 Sized_symbol<size>* ssym = static_cast<Sized_symbol<size>*>(sym); 5944 return ssym->value(); 5945 } 5946 5947 // FNOFFSET in section SHNDX in OBJECT is the start of a function 5948 // compiled with -fsplit-stack. The function calls non-split-stack 5949 // code. We have to change the function so that it always ensures 5950 // that it has enough stack space to run some random function. 5951 5952 static const unsigned char cmp_insn_32[] = { 0x64, 0x3b, 0x24, 0x25 }; 5953 static const unsigned char lea_r10_insn_32[] = { 0x44, 0x8d, 0x94, 0x24 }; 5954 static const unsigned char lea_r11_insn_32[] = { 0x44, 0x8d, 0x9c, 0x24 }; 5955 5956 static const unsigned char cmp_insn_64[] = { 0x64, 0x48, 0x3b, 0x24, 0x25 }; 5957 static const unsigned char lea_r10_insn_64[] = { 0x4c, 0x8d, 0x94, 0x24 }; 5958 static const unsigned char lea_r11_insn_64[] = { 0x4c, 0x8d, 0x9c, 0x24 }; 5959 5960 template<int size> 5961 void 5962 Target_x86_64<size>::do_calls_non_split(Relobj* object, unsigned int shndx, 5963 section_offset_type fnoffset, 5964 section_size_type fnsize, 5965 const unsigned char*, 5966 size_t, 5967 unsigned char* view, 5968 section_size_type view_size, 5969 std::string* from, 5970 std::string* to) const 5971 { 5972 const char* const cmp_insn = reinterpret_cast<const char*> 5973 (size == 32 ? cmp_insn_32 : cmp_insn_64); 5974 const char* const lea_r10_insn = reinterpret_cast<const char*> 5975 (size == 32 ? lea_r10_insn_32 : lea_r10_insn_64); 5976 const char* const lea_r11_insn = reinterpret_cast<const char*> 5977 (size == 32 ? lea_r11_insn_32 : lea_r11_insn_64); 5978 5979 const size_t cmp_insn_len = 5980 (size == 32 ? sizeof(cmp_insn_32) : sizeof(cmp_insn_64)); 5981 const size_t lea_r10_insn_len = 5982 (size == 32 ? sizeof(lea_r10_insn_32) : sizeof(lea_r10_insn_64)); 5983 const size_t lea_r11_insn_len = 5984 (size == 32 ? sizeof(lea_r11_insn_32) : sizeof(lea_r11_insn_64)); 5985 const size_t nop_len = (size == 32 ? 7 : 8); 5986 5987 // The function starts with a comparison of the stack pointer and a 5988 // field in the TCB. This is followed by a jump. 5989 5990 // cmp %fs:NN,%rsp 5991 if (this->match_view(view, view_size, fnoffset, cmp_insn, cmp_insn_len) 5992 && fnsize > nop_len + 1) 5993 { 5994 // We will call __morestack if the carry flag is set after this 5995 // comparison. We turn the comparison into an stc instruction 5996 // and some nops. 5997 view[fnoffset] = '\xf9'; 5998 this->set_view_to_nop(view, view_size, fnoffset + 1, nop_len); 5999 } 6000 // lea NN(%rsp),%r10 6001 // lea NN(%rsp),%r11 6002 else if ((this->match_view(view, view_size, fnoffset, 6003 lea_r10_insn, lea_r10_insn_len) 6004 || this->match_view(view, view_size, fnoffset, 6005 lea_r11_insn, lea_r11_insn_len)) 6006 && fnsize > 8) 6007 { 6008 // This is loading an offset from the stack pointer for a 6009 // comparison. The offset is negative, so we decrease the 6010 // offset by the amount of space we need for the stack. This 6011 // means we will avoid calling __morestack if there happens to 6012 // be plenty of space on the stack already. 6013 unsigned char* pval = view + fnoffset + 4; 6014 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval); 6015 val -= parameters->options().split_stack_adjust_size(); 6016 elfcpp::Swap_unaligned<32, false>::writeval(pval, val); 6017 } 6018 else 6019 { 6020 if (!object->has_no_split_stack()) 6021 object->error(_("failed to match split-stack sequence at " 6022 "section %u offset %0zx"), 6023 shndx, static_cast<size_t>(fnoffset)); 6024 return; 6025 } 6026 6027 // We have to change the function so that it calls 6028 // __morestack_non_split instead of __morestack. The former will 6029 // allocate additional stack space. 6030 *from = "__morestack"; 6031 *to = "__morestack_non_split"; 6032 } 6033 6034 // The selector for x86_64 object files. Note this is never instantiated 6035 // directly. It's only used in Target_selector_x86_64_nacl, below. 6036 6037 template<int size> 6038 class Target_selector_x86_64 : public Target_selector_freebsd 6039 { 6040 public: 6041 Target_selector_x86_64() 6042 : Target_selector_freebsd(elfcpp::EM_X86_64, size, false, 6043 (size == 64 6044 ? "elf64-x86-64" : "elf32-x86-64"), 6045 (size == 64 6046 ? "elf64-x86-64-freebsd" 6047 : "elf32-x86-64-freebsd"), 6048 (size == 64 ? "elf_x86_64" : "elf32_x86_64")) 6049 { } 6050 6051 Target* 6052 do_instantiate_target() 6053 { return new Target_x86_64<size>(); } 6054 6055 }; 6056 6057 // NaCl variant. It uses different PLT contents. 6058 6059 template<int size> 6060 class Output_data_plt_x86_64_nacl : public Output_data_plt_x86_64<size> 6061 { 6062 public: 6063 Output_data_plt_x86_64_nacl(Layout* layout, 6064 Output_data_got<64, false>* got, 6065 Output_data_got_plt_x86_64* got_plt, 6066 Output_data_space* got_irelative) 6067 : Output_data_plt_x86_64<size>(layout, plt_entry_size, 6068 got, got_plt, got_irelative) 6069 { } 6070 6071 Output_data_plt_x86_64_nacl(Layout* layout, 6072 Output_data_got<64, false>* got, 6073 Output_data_got_plt_x86_64* got_plt, 6074 Output_data_space* got_irelative, 6075 unsigned int plt_count) 6076 : Output_data_plt_x86_64<size>(layout, plt_entry_size, 6077 got, got_plt, got_irelative, 6078 plt_count) 6079 { } 6080 6081 protected: 6082 virtual unsigned int 6083 do_get_plt_entry_size() const 6084 { return plt_entry_size; } 6085 6086 virtual void 6087 do_add_eh_frame(Layout* layout) 6088 { 6089 layout->add_eh_frame_for_plt(this, 6090 this->plt_eh_frame_cie, 6091 this->plt_eh_frame_cie_size, 6092 plt_eh_frame_fde, 6093 plt_eh_frame_fde_size); 6094 } 6095 6096 virtual void 6097 do_fill_first_plt_entry(unsigned char* pov, 6098 typename elfcpp::Elf_types<size>::Elf_Addr got_addr, 6099 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr); 6100 6101 virtual unsigned int 6102 do_fill_plt_entry(unsigned char* pov, 6103 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 6104 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 6105 unsigned int got_offset, 6106 unsigned int plt_offset, 6107 unsigned int plt_index); 6108 6109 virtual void 6110 do_fill_tlsdesc_entry(unsigned char* pov, 6111 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 6112 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 6113 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 6114 unsigned int tlsdesc_got_offset, 6115 unsigned int plt_offset); 6116 6117 private: 6118 // The size of an entry in the PLT. 6119 static const int plt_entry_size = 64; 6120 6121 // The first entry in the PLT. 6122 static const unsigned char first_plt_entry[plt_entry_size]; 6123 6124 // Other entries in the PLT for an executable. 6125 static const unsigned char plt_entry[plt_entry_size]; 6126 6127 // The reserved TLSDESC entry in the PLT for an executable. 6128 static const unsigned char tlsdesc_plt_entry[plt_entry_size]; 6129 6130 // The .eh_frame unwind information for the PLT. 6131 static const int plt_eh_frame_fde_size = 32; 6132 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size]; 6133 }; 6134 6135 template<int size> 6136 class Target_x86_64_nacl : public Target_x86_64<size> 6137 { 6138 public: 6139 Target_x86_64_nacl() 6140 : Target_x86_64<size>(&x86_64_nacl_info) 6141 { } 6142 6143 virtual Output_data_plt_x86_64<size>* 6144 do_make_data_plt(Layout* layout, 6145 Output_data_got<64, false>* got, 6146 Output_data_got_plt_x86_64* got_plt, 6147 Output_data_space* got_irelative) 6148 { 6149 return new Output_data_plt_x86_64_nacl<size>(layout, got, got_plt, 6150 got_irelative); 6151 } 6152 6153 virtual Output_data_plt_x86_64<size>* 6154 do_make_data_plt(Layout* layout, 6155 Output_data_got<64, false>* got, 6156 Output_data_got_plt_x86_64* got_plt, 6157 Output_data_space* got_irelative, 6158 unsigned int plt_count) 6159 { 6160 return new Output_data_plt_x86_64_nacl<size>(layout, got, got_plt, 6161 got_irelative, 6162 plt_count); 6163 } 6164 6165 virtual std::string 6166 do_code_fill(section_size_type length) const; 6167 6168 private: 6169 static const Target::Target_info x86_64_nacl_info; 6170 }; 6171 6172 template<> 6173 const Target::Target_info Target_x86_64_nacl<64>::x86_64_nacl_info = 6174 { 6175 64, // size 6176 false, // is_big_endian 6177 elfcpp::EM_X86_64, // machine_code 6178 false, // has_make_symbol 6179 false, // has_resolve 6180 true, // has_code_fill 6181 true, // is_default_stack_executable 6182 true, // can_icf_inline_merge_sections 6183 '\0', // wrap_char 6184 "/lib64/ld-nacl-x86-64.so.1", // dynamic_linker 6185 0x20000, // default_text_segment_address 6186 0x10000, // abi_pagesize (overridable by -z max-page-size) 6187 0x10000, // common_pagesize (overridable by -z common-page-size) 6188 true, // isolate_execinstr 6189 0x10000000, // rosegment_gap 6190 elfcpp::SHN_UNDEF, // small_common_shndx 6191 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx 6192 0, // small_common_section_flags 6193 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags 6194 NULL, // attributes_section 6195 NULL, // attributes_vendor 6196 "_start", // entry_symbol_name 6197 32, // hash_entry_size 6198 elfcpp::SHT_X86_64_UNWIND, // unwind_section_type 6199 }; 6200 6201 template<> 6202 const Target::Target_info Target_x86_64_nacl<32>::x86_64_nacl_info = 6203 { 6204 32, // size 6205 false, // is_big_endian 6206 elfcpp::EM_X86_64, // machine_code 6207 false, // has_make_symbol 6208 false, // has_resolve 6209 true, // has_code_fill 6210 true, // is_default_stack_executable 6211 true, // can_icf_inline_merge_sections 6212 '\0', // wrap_char 6213 "/lib/ld-nacl-x86-64.so.1", // dynamic_linker 6214 0x20000, // default_text_segment_address 6215 0x10000, // abi_pagesize (overridable by -z max-page-size) 6216 0x10000, // common_pagesize (overridable by -z common-page-size) 6217 true, // isolate_execinstr 6218 0x10000000, // rosegment_gap 6219 elfcpp::SHN_UNDEF, // small_common_shndx 6220 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx 6221 0, // small_common_section_flags 6222 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags 6223 NULL, // attributes_section 6224 NULL, // attributes_vendor 6225 "_start", // entry_symbol_name 6226 32, // hash_entry_size 6227 elfcpp::SHT_X86_64_UNWIND, // unwind_section_type 6228 }; 6229 6230 #define NACLMASK 0xe0 // 32-byte alignment mask. 6231 6232 // The first entry in the PLT. 6233 6234 template<int size> 6235 const unsigned char 6236 Output_data_plt_x86_64_nacl<size>::first_plt_entry[plt_entry_size] = 6237 { 6238 0xff, 0x35, // pushq contents of memory address 6239 0, 0, 0, 0, // replaced with address of .got + 8 6240 0x4c, 0x8b, 0x1d, // mov GOT+16(%rip), %r11 6241 0, 0, 0, 0, // replaced with address of .got + 16 6242 0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d 6243 0x4d, 0x01, 0xfb, // add %r15, %r11 6244 0x41, 0xff, 0xe3, // jmpq *%r11 6245 6246 // 9-byte nop sequence to pad out to the next 32-byte boundary. 6247 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw 0x0(%rax,%rax,1) 6248 6249 // 32 bytes of nop to pad out to the standard size 6250 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes 6251 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6252 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes 6253 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6254 0x66, // excess data32 prefix 6255 0x90 // nop 6256 }; 6257 6258 template<int size> 6259 void 6260 Output_data_plt_x86_64_nacl<size>::do_fill_first_plt_entry( 6261 unsigned char* pov, 6262 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 6263 typename elfcpp::Elf_types<size>::Elf_Addr plt_address) 6264 { 6265 memcpy(pov, first_plt_entry, plt_entry_size); 6266 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 6267 (got_address + 8 6268 - (plt_address + 2 + 4))); 6269 elfcpp::Swap_unaligned<32, false>::writeval(pov + 9, 6270 (got_address + 16 6271 - (plt_address + 9 + 4))); 6272 } 6273 6274 // Subsequent entries in the PLT. 6275 6276 template<int size> 6277 const unsigned char 6278 Output_data_plt_x86_64_nacl<size>::plt_entry[plt_entry_size] = 6279 { 6280 0x4c, 0x8b, 0x1d, // mov name@GOTPCREL(%rip),%r11 6281 0, 0, 0, 0, // replaced with address of symbol in .got 6282 0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d 6283 0x4d, 0x01, 0xfb, // add %r15, %r11 6284 0x41, 0xff, 0xe3, // jmpq *%r11 6285 6286 // 15-byte nop sequence to pad out to the next 32-byte boundary. 6287 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes 6288 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6289 6290 // Lazy GOT entries point here (32-byte aligned). 6291 0x68, // pushq immediate 6292 0, 0, 0, 0, // replaced with index into relocation table 6293 0xe9, // jmp relative 6294 0, 0, 0, 0, // replaced with offset to start of .plt0 6295 6296 // 22 bytes of nop to pad out to the standard size. 6297 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes 6298 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6299 0x0f, 0x1f, 0x80, 0, 0, 0, 0, // nopl 0x0(%rax) 6300 }; 6301 6302 template<int size> 6303 unsigned int 6304 Output_data_plt_x86_64_nacl<size>::do_fill_plt_entry( 6305 unsigned char* pov, 6306 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 6307 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 6308 unsigned int got_offset, 6309 unsigned int plt_offset, 6310 unsigned int plt_index) 6311 { 6312 memcpy(pov, plt_entry, plt_entry_size); 6313 elfcpp::Swap_unaligned<32, false>::writeval(pov + 3, 6314 (got_address + got_offset 6315 - (plt_address + plt_offset 6316 + 3 + 4))); 6317 6318 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_index); 6319 elfcpp::Swap_unaligned<32, false>::writeval(pov + 38, 6320 - (plt_offset + 38 + 4)); 6321 6322 return 32; 6323 } 6324 6325 // The reserved TLSDESC entry in the PLT. 6326 6327 template<int size> 6328 const unsigned char 6329 Output_data_plt_x86_64_nacl<size>::tlsdesc_plt_entry[plt_entry_size] = 6330 { 6331 0xff, 0x35, // pushq x(%rip) 6332 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8) 6333 0x4c, 0x8b, 0x1d, // mov y(%rip),%r11 6334 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry 6335 0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d 6336 0x4d, 0x01, 0xfb, // add %r15, %r11 6337 0x41, 0xff, 0xe3, // jmpq *%r11 6338 6339 // 41 bytes of nop to pad out to the standard size. 6340 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes 6341 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6342 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes 6343 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6344 0x66, 0x66, // excess data32 prefixes 6345 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1) 6346 }; 6347 6348 template<int size> 6349 void 6350 Output_data_plt_x86_64_nacl<size>::do_fill_tlsdesc_entry( 6351 unsigned char* pov, 6352 typename elfcpp::Elf_types<size>::Elf_Addr got_address, 6353 typename elfcpp::Elf_types<size>::Elf_Addr plt_address, 6354 typename elfcpp::Elf_types<size>::Elf_Addr got_base, 6355 unsigned int tlsdesc_got_offset, 6356 unsigned int plt_offset) 6357 { 6358 memcpy(pov, tlsdesc_plt_entry, plt_entry_size); 6359 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, 6360 (got_address + 8 6361 - (plt_address + plt_offset 6362 + 2 + 4))); 6363 elfcpp::Swap_unaligned<32, false>::writeval(pov + 9, 6364 (got_base 6365 + tlsdesc_got_offset 6366 - (plt_address + plt_offset 6367 + 9 + 4))); 6368 } 6369 6370 // The .eh_frame unwind information for the PLT. 6371 6372 template<int size> 6373 const unsigned char 6374 Output_data_plt_x86_64_nacl<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] = 6375 { 6376 0, 0, 0, 0, // Replaced with offset to .plt. 6377 0, 0, 0, 0, // Replaced with size of .plt. 6378 0, // Augmentation size. 6379 elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16. 6380 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6. 6381 elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24. 6382 elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64. 6383 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression. 6384 13, // Block length. 6385 elfcpp::DW_OP_breg7, 8, // Push %rsp + 8. 6386 elfcpp::DW_OP_breg16, 0, // Push %rip. 6387 elfcpp::DW_OP_const1u, 63, // Push 0x3f. 6388 elfcpp::DW_OP_and, // & (%rip & 0x3f). 6389 elfcpp::DW_OP_const1u, 37, // Push 0x25. 6390 elfcpp::DW_OP_ge, // >= ((%rip & 0x3f) >= 0x25) 6391 elfcpp::DW_OP_lit3, // Push 3. 6392 elfcpp::DW_OP_shl, // << (((%rip & 0x3f) >= 0x25) << 3) 6393 elfcpp::DW_OP_plus, // + ((((%rip&0x3f)>=0x25)<<3)+%rsp+8 6394 elfcpp::DW_CFA_nop, // Align to 32 bytes. 6395 elfcpp::DW_CFA_nop 6396 }; 6397 6398 // Return a string used to fill a code section with nops. 6399 // For NaCl, long NOPs are only valid if they do not cross 6400 // bundle alignment boundaries, so keep it simple with one-byte NOPs. 6401 template<int size> 6402 std::string 6403 Target_x86_64_nacl<size>::do_code_fill(section_size_type length) const 6404 { 6405 return std::string(length, static_cast<char>(0x90)); 6406 } 6407 6408 // The selector for x86_64-nacl object files. 6409 6410 template<int size> 6411 class Target_selector_x86_64_nacl 6412 : public Target_selector_nacl<Target_selector_x86_64<size>, 6413 Target_x86_64_nacl<size> > 6414 { 6415 public: 6416 Target_selector_x86_64_nacl() 6417 : Target_selector_nacl<Target_selector_x86_64<size>, 6418 Target_x86_64_nacl<size> >("x86-64", 6419 size == 64 6420 ? "elf64-x86-64-nacl" 6421 : "elf32-x86-64-nacl", 6422 size == 64 6423 ? "elf_x86_64_nacl" 6424 : "elf32_x86_64_nacl") 6425 { } 6426 }; 6427 6428 Target_selector_x86_64_nacl<64> target_selector_x86_64; 6429 Target_selector_x86_64_nacl<32> target_selector_x32; 6430 6431 } // End anonymous namespace. 6432