1 // powerpc.cc -- powerpc target support for gold. 2 3 // Copyright (C) 2008-2016 Free Software Foundation, Inc. 4 // Written by David S. Miller <davem@davemloft.net> 5 // and David Edelsohn <edelsohn@gnu.org> 6 7 // This file is part of gold. 8 9 // This program is free software; you can redistribute it and/or modify 10 // it under the terms of the GNU General Public License as published by 11 // the Free Software Foundation; either version 3 of the License, or 12 // (at your option) any later version. 13 14 // This program is distributed in the hope that it will be useful, 15 // but WITHOUT ANY WARRANTY; without even the implied warranty of 16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 // GNU General Public License for more details. 18 19 // You should have received a copy of the GNU General Public License 20 // along with this program; if not, write to the Free Software 21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 // MA 02110-1301, USA. 23 24 #include "gold.h" 25 26 #include <set> 27 #include <algorithm> 28 #include "elfcpp.h" 29 #include "dwarf.h" 30 #include "parameters.h" 31 #include "reloc.h" 32 #include "powerpc.h" 33 #include "object.h" 34 #include "symtab.h" 35 #include "layout.h" 36 #include "output.h" 37 #include "copy-relocs.h" 38 #include "target.h" 39 #include "target-reloc.h" 40 #include "target-select.h" 41 #include "tls.h" 42 #include "errors.h" 43 #include "gc.h" 44 45 namespace 46 { 47 48 using namespace gold; 49 50 template<int size, bool big_endian> 51 class Output_data_plt_powerpc; 52 53 template<int size, bool big_endian> 54 class Output_data_brlt_powerpc; 55 56 template<int size, bool big_endian> 57 class Output_data_got_powerpc; 58 59 template<int size, bool big_endian> 60 class Output_data_glink; 61 62 template<int size, bool big_endian> 63 class Stub_table; 64 65 template<int size, bool big_endian> 66 class Output_data_save_res; 67 68 template<int size, bool big_endian> 69 class Target_powerpc; 70 71 struct Stub_table_owner 72 { 73 Output_section* output_section; 74 const Output_section::Input_section* owner; 75 }; 76 77 inline bool 78 is_branch_reloc(unsigned int r_type); 79 80 template<int size, bool big_endian> 81 class Powerpc_relobj : public Sized_relobj_file<size, big_endian> 82 { 83 public: 84 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 85 typedef Unordered_set<Section_id, Section_id_hash> Section_refs; 86 typedef Unordered_map<Address, Section_refs> Access_from; 87 88 Powerpc_relobj(const std::string& name, Input_file* input_file, off_t offset, 89 const typename elfcpp::Ehdr<size, big_endian>& ehdr) 90 : Sized_relobj_file<size, big_endian>(name, input_file, offset, ehdr), 91 special_(0), has_small_toc_reloc_(false), opd_valid_(false), 92 opd_ent_(), access_from_map_(), has14_(), stub_table_index_(), 93 e_flags_(ehdr.get_e_flags()), st_other_() 94 { 95 this->set_abiversion(0); 96 } 97 98 ~Powerpc_relobj() 99 { } 100 101 // Read the symbols then set up st_other vector. 102 void 103 do_read_symbols(Read_symbols_data*); 104 105 // The .got2 section shndx. 106 unsigned int 107 got2_shndx() const 108 { 109 if (size == 32) 110 return this->special_; 111 else 112 return 0; 113 } 114 115 // The .opd section shndx. 116 unsigned int 117 opd_shndx() const 118 { 119 if (size == 32) 120 return 0; 121 else 122 return this->special_; 123 } 124 125 // Init OPD entry arrays. 126 void 127 init_opd(size_t opd_size) 128 { 129 size_t count = this->opd_ent_ndx(opd_size); 130 this->opd_ent_.resize(count); 131 } 132 133 // Return section and offset of function entry for .opd + R_OFF. 134 unsigned int 135 get_opd_ent(Address r_off, Address* value = NULL) const 136 { 137 size_t ndx = this->opd_ent_ndx(r_off); 138 gold_assert(ndx < this->opd_ent_.size()); 139 gold_assert(this->opd_ent_[ndx].shndx != 0); 140 if (value != NULL) 141 *value = this->opd_ent_[ndx].off; 142 return this->opd_ent_[ndx].shndx; 143 } 144 145 // Set section and offset of function entry for .opd + R_OFF. 146 void 147 set_opd_ent(Address r_off, unsigned int shndx, Address value) 148 { 149 size_t ndx = this->opd_ent_ndx(r_off); 150 gold_assert(ndx < this->opd_ent_.size()); 151 this->opd_ent_[ndx].shndx = shndx; 152 this->opd_ent_[ndx].off = value; 153 } 154 155 // Return discard flag for .opd + R_OFF. 156 bool 157 get_opd_discard(Address r_off) const 158 { 159 size_t ndx = this->opd_ent_ndx(r_off); 160 gold_assert(ndx < this->opd_ent_.size()); 161 return this->opd_ent_[ndx].discard; 162 } 163 164 // Set discard flag for .opd + R_OFF. 165 void 166 set_opd_discard(Address r_off) 167 { 168 size_t ndx = this->opd_ent_ndx(r_off); 169 gold_assert(ndx < this->opd_ent_.size()); 170 this->opd_ent_[ndx].discard = true; 171 } 172 173 bool 174 opd_valid() const 175 { return this->opd_valid_; } 176 177 void 178 set_opd_valid() 179 { this->opd_valid_ = true; } 180 181 // Examine .rela.opd to build info about function entry points. 182 void 183 scan_opd_relocs(size_t reloc_count, 184 const unsigned char* prelocs, 185 const unsigned char* plocal_syms); 186 187 // Perform the Sized_relobj_file method, then set up opd info from 188 // .opd relocs. 189 void 190 do_read_relocs(Read_relocs_data*); 191 192 bool 193 do_find_special_sections(Read_symbols_data* sd); 194 195 // Adjust this local symbol value. Return false if the symbol 196 // should be discarded from the output file. 197 bool 198 do_adjust_local_symbol(Symbol_value<size>* lv) const 199 { 200 if (size == 64 && this->opd_shndx() != 0) 201 { 202 bool is_ordinary; 203 if (lv->input_shndx(&is_ordinary) != this->opd_shndx()) 204 return true; 205 if (this->get_opd_discard(lv->input_value())) 206 return false; 207 } 208 return true; 209 } 210 211 Access_from* 212 access_from_map() 213 { return &this->access_from_map_; } 214 215 // Add a reference from SRC_OBJ, SRC_INDX to this object's .opd 216 // section at DST_OFF. 217 void 218 add_reference(Relobj* src_obj, 219 unsigned int src_indx, 220 typename elfcpp::Elf_types<size>::Elf_Addr dst_off) 221 { 222 Section_id src_id(src_obj, src_indx); 223 this->access_from_map_[dst_off].insert(src_id); 224 } 225 226 // Add a reference to the code section specified by the .opd entry 227 // at DST_OFF 228 void 229 add_gc_mark(typename elfcpp::Elf_types<size>::Elf_Addr dst_off) 230 { 231 size_t ndx = this->opd_ent_ndx(dst_off); 232 if (ndx >= this->opd_ent_.size()) 233 this->opd_ent_.resize(ndx + 1); 234 this->opd_ent_[ndx].gc_mark = true; 235 } 236 237 void 238 process_gc_mark(Symbol_table* symtab) 239 { 240 for (size_t i = 0; i < this->opd_ent_.size(); i++) 241 if (this->opd_ent_[i].gc_mark) 242 { 243 unsigned int shndx = this->opd_ent_[i].shndx; 244 symtab->gc()->worklist().push_back(Section_id(this, shndx)); 245 } 246 } 247 248 // Return offset in output GOT section that this object will use 249 // as a TOC pointer. Won't be just a constant with multi-toc support. 250 Address 251 toc_base_offset() const 252 { return 0x8000; } 253 254 void 255 set_has_small_toc_reloc() 256 { has_small_toc_reloc_ = true; } 257 258 bool 259 has_small_toc_reloc() const 260 { return has_small_toc_reloc_; } 261 262 void 263 set_has_14bit_branch(unsigned int shndx) 264 { 265 if (shndx >= this->has14_.size()) 266 this->has14_.resize(shndx + 1); 267 this->has14_[shndx] = true; 268 } 269 270 bool 271 has_14bit_branch(unsigned int shndx) const 272 { return shndx < this->has14_.size() && this->has14_[shndx]; } 273 274 void 275 set_stub_table(unsigned int shndx, unsigned int stub_index) 276 { 277 if (shndx >= this->stub_table_index_.size()) 278 this->stub_table_index_.resize(shndx + 1); 279 this->stub_table_index_[shndx] = stub_index; 280 } 281 282 Stub_table<size, big_endian>* 283 stub_table(unsigned int shndx) 284 { 285 if (shndx < this->stub_table_index_.size()) 286 { 287 Target_powerpc<size, big_endian>* target 288 = static_cast<Target_powerpc<size, big_endian>*>( 289 parameters->sized_target<size, big_endian>()); 290 unsigned int indx = this->stub_table_index_[shndx]; 291 gold_assert(indx < target->stub_tables().size()); 292 return target->stub_tables()[indx]; 293 } 294 return NULL; 295 } 296 297 void 298 clear_stub_table() 299 { 300 this->stub_table_index_.clear(); 301 } 302 303 int 304 abiversion() const 305 { return this->e_flags_ & elfcpp::EF_PPC64_ABI; } 306 307 // Set ABI version for input and output 308 void 309 set_abiversion(int ver); 310 311 unsigned int 312 ppc64_local_entry_offset(const Symbol* sym) const 313 { return elfcpp::ppc64_decode_local_entry(sym->nonvis() >> 3); } 314 315 unsigned int 316 ppc64_local_entry_offset(unsigned int symndx) const 317 { return elfcpp::ppc64_decode_local_entry(this->st_other_[symndx] >> 5); } 318 319 private: 320 struct Opd_ent 321 { 322 unsigned int shndx; 323 bool discard : 1; 324 bool gc_mark : 1; 325 Address off; 326 }; 327 328 // Return index into opd_ent_ array for .opd entry at OFF. 329 // .opd entries are 24 bytes long, but they can be spaced 16 bytes 330 // apart when the language doesn't use the last 8-byte word, the 331 // environment pointer. Thus dividing the entry section offset by 332 // 16 will give an index into opd_ent_ that works for either layout 333 // of .opd. (It leaves some elements of the vector unused when .opd 334 // entries are spaced 24 bytes apart, but we don't know the spacing 335 // until relocations are processed, and in any case it is possible 336 // for an object to have some entries spaced 16 bytes apart and 337 // others 24 bytes apart.) 338 size_t 339 opd_ent_ndx(size_t off) const 340 { return off >> 4;} 341 342 // For 32-bit the .got2 section shdnx, for 64-bit the .opd section shndx. 343 unsigned int special_; 344 345 // For 64-bit, whether this object uses small model relocs to access 346 // the toc. 347 bool has_small_toc_reloc_; 348 349 // Set at the start of gc_process_relocs, when we know opd_ent_ 350 // vector is valid. The flag could be made atomic and set in 351 // do_read_relocs with memory_order_release and then tested with 352 // memory_order_acquire, potentially resulting in fewer entries in 353 // access_from_map_. 354 bool opd_valid_; 355 356 // The first 8-byte word of an OPD entry gives the address of the 357 // entry point of the function. Relocatable object files have a 358 // relocation on this word. The following vector records the 359 // section and offset specified by these relocations. 360 std::vector<Opd_ent> opd_ent_; 361 362 // References made to this object's .opd section when running 363 // gc_process_relocs for another object, before the opd_ent_ vector 364 // is valid for this object. 365 Access_from access_from_map_; 366 367 // Whether input section has a 14-bit branch reloc. 368 std::vector<bool> has14_; 369 370 // The stub table to use for a given input section. 371 std::vector<unsigned int> stub_table_index_; 372 373 // Header e_flags 374 elfcpp::Elf_Word e_flags_; 375 376 // ELF st_other field for local symbols. 377 std::vector<unsigned char> st_other_; 378 }; 379 380 template<int size, bool big_endian> 381 class Powerpc_dynobj : public Sized_dynobj<size, big_endian> 382 { 383 public: 384 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 385 386 Powerpc_dynobj(const std::string& name, Input_file* input_file, off_t offset, 387 const typename elfcpp::Ehdr<size, big_endian>& ehdr) 388 : Sized_dynobj<size, big_endian>(name, input_file, offset, ehdr), 389 opd_shndx_(0), opd_ent_(), e_flags_(ehdr.get_e_flags()) 390 { 391 this->set_abiversion(0); 392 } 393 394 ~Powerpc_dynobj() 395 { } 396 397 // Call Sized_dynobj::do_read_symbols to read the symbols then 398 // read .opd from a dynamic object, filling in opd_ent_ vector, 399 void 400 do_read_symbols(Read_symbols_data*); 401 402 // The .opd section shndx. 403 unsigned int 404 opd_shndx() const 405 { 406 return this->opd_shndx_; 407 } 408 409 // The .opd section address. 410 Address 411 opd_address() const 412 { 413 return this->opd_address_; 414 } 415 416 // Init OPD entry arrays. 417 void 418 init_opd(size_t opd_size) 419 { 420 size_t count = this->opd_ent_ndx(opd_size); 421 this->opd_ent_.resize(count); 422 } 423 424 // Return section and offset of function entry for .opd + R_OFF. 425 unsigned int 426 get_opd_ent(Address r_off, Address* value = NULL) const 427 { 428 size_t ndx = this->opd_ent_ndx(r_off); 429 gold_assert(ndx < this->opd_ent_.size()); 430 gold_assert(this->opd_ent_[ndx].shndx != 0); 431 if (value != NULL) 432 *value = this->opd_ent_[ndx].off; 433 return this->opd_ent_[ndx].shndx; 434 } 435 436 // Set section and offset of function entry for .opd + R_OFF. 437 void 438 set_opd_ent(Address r_off, unsigned int shndx, Address value) 439 { 440 size_t ndx = this->opd_ent_ndx(r_off); 441 gold_assert(ndx < this->opd_ent_.size()); 442 this->opd_ent_[ndx].shndx = shndx; 443 this->opd_ent_[ndx].off = value; 444 } 445 446 int 447 abiversion() const 448 { return this->e_flags_ & elfcpp::EF_PPC64_ABI; } 449 450 // Set ABI version for input and output. 451 void 452 set_abiversion(int ver); 453 454 private: 455 // Used to specify extent of executable sections. 456 struct Sec_info 457 { 458 Sec_info(Address start_, Address len_, unsigned int shndx_) 459 : start(start_), len(len_), shndx(shndx_) 460 { } 461 462 bool 463 operator<(const Sec_info& that) const 464 { return this->start < that.start; } 465 466 Address start; 467 Address len; 468 unsigned int shndx; 469 }; 470 471 struct Opd_ent 472 { 473 unsigned int shndx; 474 Address off; 475 }; 476 477 // Return index into opd_ent_ array for .opd entry at OFF. 478 size_t 479 opd_ent_ndx(size_t off) const 480 { return off >> 4;} 481 482 // For 64-bit the .opd section shndx and address. 483 unsigned int opd_shndx_; 484 Address opd_address_; 485 486 // The first 8-byte word of an OPD entry gives the address of the 487 // entry point of the function. Records the section and offset 488 // corresponding to the address. Note that in dynamic objects, 489 // offset is *not* relative to the section. 490 std::vector<Opd_ent> opd_ent_; 491 492 // Header e_flags 493 elfcpp::Elf_Word e_flags_; 494 }; 495 496 template<int size, bool big_endian> 497 class Target_powerpc : public Sized_target<size, big_endian> 498 { 499 public: 500 typedef 501 Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section; 502 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 503 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Signed_address; 504 static const Address invalid_address = static_cast<Address>(0) - 1; 505 // Offset of tp and dtp pointers from start of TLS block. 506 static const Address tp_offset = 0x7000; 507 static const Address dtp_offset = 0x8000; 508 509 Target_powerpc() 510 : Sized_target<size, big_endian>(&powerpc_info), 511 got_(NULL), plt_(NULL), iplt_(NULL), brlt_section_(NULL), 512 glink_(NULL), rela_dyn_(NULL), copy_relocs_(elfcpp::R_POWERPC_COPY), 513 tlsld_got_offset_(-1U), 514 stub_tables_(), branch_lookup_table_(), branch_info_(), 515 plt_thread_safe_(false), relax_failed_(false), relax_fail_count_(0), 516 stub_group_size_(0), savres_section_(0) 517 { 518 } 519 520 // Process the relocations to determine unreferenced sections for 521 // garbage collection. 522 void 523 gc_process_relocs(Symbol_table* symtab, 524 Layout* layout, 525 Sized_relobj_file<size, big_endian>* object, 526 unsigned int data_shndx, 527 unsigned int sh_type, 528 const unsigned char* prelocs, 529 size_t reloc_count, 530 Output_section* output_section, 531 bool needs_special_offset_handling, 532 size_t local_symbol_count, 533 const unsigned char* plocal_symbols); 534 535 // Scan the relocations to look for symbol adjustments. 536 void 537 scan_relocs(Symbol_table* symtab, 538 Layout* layout, 539 Sized_relobj_file<size, big_endian>* object, 540 unsigned int data_shndx, 541 unsigned int sh_type, 542 const unsigned char* prelocs, 543 size_t reloc_count, 544 Output_section* output_section, 545 bool needs_special_offset_handling, 546 size_t local_symbol_count, 547 const unsigned char* plocal_symbols); 548 549 // Map input .toc section to output .got section. 550 const char* 551 do_output_section_name(const Relobj*, const char* name, size_t* plen) const 552 { 553 if (size == 64 && strcmp(name, ".toc") == 0) 554 { 555 *plen = 4; 556 return ".got"; 557 } 558 return NULL; 559 } 560 561 // Provide linker defined save/restore functions. 562 void 563 define_save_restore_funcs(Layout*, Symbol_table*); 564 565 // No stubs unless a final link. 566 bool 567 do_may_relax() const 568 { return !parameters->options().relocatable(); } 569 570 bool 571 do_relax(int, const Input_objects*, Symbol_table*, Layout*, const Task*); 572 573 void 574 do_plt_fde_location(const Output_data*, unsigned char*, 575 uint64_t*, off_t*) const; 576 577 // Stash info about branches, for stub generation. 578 void 579 push_branch(Powerpc_relobj<size, big_endian>* ppc_object, 580 unsigned int data_shndx, Address r_offset, 581 unsigned int r_type, unsigned int r_sym, Address addend) 582 { 583 Branch_info info(ppc_object, data_shndx, r_offset, r_type, r_sym, addend); 584 this->branch_info_.push_back(info); 585 if (r_type == elfcpp::R_POWERPC_REL14 586 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN 587 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN) 588 ppc_object->set_has_14bit_branch(data_shndx); 589 } 590 591 void 592 do_define_standard_symbols(Symbol_table*, Layout*); 593 594 // Finalize the sections. 595 void 596 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*); 597 598 // Return the value to use for a dynamic which requires special 599 // treatment. 600 uint64_t 601 do_dynsym_value(const Symbol*) const; 602 603 // Return the PLT address to use for a local symbol. 604 uint64_t 605 do_plt_address_for_local(const Relobj*, unsigned int) const; 606 607 // Return the PLT address to use for a global symbol. 608 uint64_t 609 do_plt_address_for_global(const Symbol*) const; 610 611 // Return the offset to use for the GOT_INDX'th got entry which is 612 // for a local tls symbol specified by OBJECT, SYMNDX. 613 int64_t 614 do_tls_offset_for_local(const Relobj* object, 615 unsigned int symndx, 616 unsigned int got_indx) const; 617 618 // Return the offset to use for the GOT_INDX'th got entry which is 619 // for global tls symbol GSYM. 620 int64_t 621 do_tls_offset_for_global(Symbol* gsym, unsigned int got_indx) const; 622 623 void 624 do_function_location(Symbol_location*) const; 625 626 bool 627 do_can_check_for_function_pointers() const 628 { return true; } 629 630 // Adjust -fsplit-stack code which calls non-split-stack code. 631 void 632 do_calls_non_split(Relobj* object, unsigned int shndx, 633 section_offset_type fnoffset, section_size_type fnsize, 634 const unsigned char* prelocs, size_t reloc_count, 635 unsigned char* view, section_size_type view_size, 636 std::string* from, std::string* to) const; 637 638 // Relocate a section. 639 void 640 relocate_section(const Relocate_info<size, big_endian>*, 641 unsigned int sh_type, 642 const unsigned char* prelocs, 643 size_t reloc_count, 644 Output_section* output_section, 645 bool needs_special_offset_handling, 646 unsigned char* view, 647 Address view_address, 648 section_size_type view_size, 649 const Reloc_symbol_changes*); 650 651 // Scan the relocs during a relocatable link. 652 void 653 scan_relocatable_relocs(Symbol_table* symtab, 654 Layout* layout, 655 Sized_relobj_file<size, big_endian>* object, 656 unsigned int data_shndx, 657 unsigned int sh_type, 658 const unsigned char* prelocs, 659 size_t reloc_count, 660 Output_section* output_section, 661 bool needs_special_offset_handling, 662 size_t local_symbol_count, 663 const unsigned char* plocal_symbols, 664 Relocatable_relocs*); 665 666 // Scan the relocs for --emit-relocs. 667 void 668 emit_relocs_scan(Symbol_table* symtab, 669 Layout* layout, 670 Sized_relobj_file<size, big_endian>* object, 671 unsigned int data_shndx, 672 unsigned int sh_type, 673 const unsigned char* prelocs, 674 size_t reloc_count, 675 Output_section* output_section, 676 bool needs_special_offset_handling, 677 size_t local_symbol_count, 678 const unsigned char* plocal_syms, 679 Relocatable_relocs* rr); 680 681 // Emit relocations for a section. 682 void 683 relocate_relocs(const Relocate_info<size, big_endian>*, 684 unsigned int sh_type, 685 const unsigned char* prelocs, 686 size_t reloc_count, 687 Output_section* output_section, 688 typename elfcpp::Elf_types<size>::Elf_Off 689 offset_in_output_section, 690 unsigned char*, 691 Address view_address, 692 section_size_type, 693 unsigned char* reloc_view, 694 section_size_type reloc_view_size); 695 696 // Return whether SYM is defined by the ABI. 697 bool 698 do_is_defined_by_abi(const Symbol* sym) const 699 { 700 return strcmp(sym->name(), "__tls_get_addr") == 0; 701 } 702 703 // Return the size of the GOT section. 704 section_size_type 705 got_size() const 706 { 707 gold_assert(this->got_ != NULL); 708 return this->got_->data_size(); 709 } 710 711 // Get the PLT section. 712 const Output_data_plt_powerpc<size, big_endian>* 713 plt_section() const 714 { 715 gold_assert(this->plt_ != NULL); 716 return this->plt_; 717 } 718 719 // Get the IPLT section. 720 const Output_data_plt_powerpc<size, big_endian>* 721 iplt_section() const 722 { 723 gold_assert(this->iplt_ != NULL); 724 return this->iplt_; 725 } 726 727 // Get the .glink section. 728 const Output_data_glink<size, big_endian>* 729 glink_section() const 730 { 731 gold_assert(this->glink_ != NULL); 732 return this->glink_; 733 } 734 735 Output_data_glink<size, big_endian>* 736 glink_section() 737 { 738 gold_assert(this->glink_ != NULL); 739 return this->glink_; 740 } 741 742 bool has_glink() const 743 { return this->glink_ != NULL; } 744 745 // Get the GOT section. 746 const Output_data_got_powerpc<size, big_endian>* 747 got_section() const 748 { 749 gold_assert(this->got_ != NULL); 750 return this->got_; 751 } 752 753 // Get the GOT section, creating it if necessary. 754 Output_data_got_powerpc<size, big_endian>* 755 got_section(Symbol_table*, Layout*); 756 757 Object* 758 do_make_elf_object(const std::string&, Input_file*, off_t, 759 const elfcpp::Ehdr<size, big_endian>&); 760 761 // Return the number of entries in the GOT. 762 unsigned int 763 got_entry_count() const 764 { 765 if (this->got_ == NULL) 766 return 0; 767 return this->got_size() / (size / 8); 768 } 769 770 // Return the number of entries in the PLT. 771 unsigned int 772 plt_entry_count() const; 773 774 // Return the offset of the first non-reserved PLT entry. 775 unsigned int 776 first_plt_entry_offset() const 777 { 778 if (size == 32) 779 return 0; 780 if (this->abiversion() >= 2) 781 return 16; 782 return 24; 783 } 784 785 // Return the size of each PLT entry. 786 unsigned int 787 plt_entry_size() const 788 { 789 if (size == 32) 790 return 4; 791 if (this->abiversion() >= 2) 792 return 8; 793 return 24; 794 } 795 796 Output_data_save_res<size, big_endian>* 797 savres_section() const 798 { 799 return this->savres_section_; 800 } 801 802 // Add any special sections for this symbol to the gc work list. 803 // For powerpc64, this adds the code section of a function 804 // descriptor. 805 void 806 do_gc_mark_symbol(Symbol_table* symtab, Symbol* sym) const; 807 808 // Handle target specific gc actions when adding a gc reference from 809 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX 810 // and DST_OFF. For powerpc64, this adds a referenc to the code 811 // section of a function descriptor. 812 void 813 do_gc_add_reference(Symbol_table* symtab, 814 Relobj* src_obj, 815 unsigned int src_shndx, 816 Relobj* dst_obj, 817 unsigned int dst_shndx, 818 Address dst_off) const; 819 820 typedef std::vector<Stub_table<size, big_endian>*> Stub_tables; 821 const Stub_tables& 822 stub_tables() const 823 { return this->stub_tables_; } 824 825 const Output_data_brlt_powerpc<size, big_endian>* 826 brlt_section() const 827 { return this->brlt_section_; } 828 829 void 830 add_branch_lookup_table(Address to) 831 { 832 unsigned int off = this->branch_lookup_table_.size() * (size / 8); 833 this->branch_lookup_table_.insert(std::make_pair(to, off)); 834 } 835 836 Address 837 find_branch_lookup_table(Address to) 838 { 839 typename Branch_lookup_table::const_iterator p 840 = this->branch_lookup_table_.find(to); 841 return p == this->branch_lookup_table_.end() ? invalid_address : p->second; 842 } 843 844 void 845 write_branch_lookup_table(unsigned char *oview) 846 { 847 for (typename Branch_lookup_table::const_iterator p 848 = this->branch_lookup_table_.begin(); 849 p != this->branch_lookup_table_.end(); 850 ++p) 851 { 852 elfcpp::Swap<size, big_endian>::writeval(oview + p->second, p->first); 853 } 854 } 855 856 bool 857 plt_thread_safe() const 858 { return this->plt_thread_safe_; } 859 860 int 861 abiversion () const 862 { return this->processor_specific_flags() & elfcpp::EF_PPC64_ABI; } 863 864 void 865 set_abiversion (int ver) 866 { 867 elfcpp::Elf_Word flags = this->processor_specific_flags(); 868 flags &= ~elfcpp::EF_PPC64_ABI; 869 flags |= ver & elfcpp::EF_PPC64_ABI; 870 this->set_processor_specific_flags(flags); 871 } 872 873 // Offset to to save stack slot 874 int 875 stk_toc () const 876 { return this->abiversion() < 2 ? 40 : 24; } 877 878 private: 879 880 class Track_tls 881 { 882 public: 883 enum Tls_get_addr 884 { 885 NOT_EXPECTED = 0, 886 EXPECTED = 1, 887 SKIP = 2, 888 NORMAL = 3 889 }; 890 891 Track_tls() 892 : tls_get_addr_(NOT_EXPECTED), 893 relinfo_(NULL), relnum_(0), r_offset_(0) 894 { } 895 896 ~Track_tls() 897 { 898 if (this->tls_get_addr_ != NOT_EXPECTED) 899 this->missing(); 900 } 901 902 void 903 missing(void) 904 { 905 if (this->relinfo_ != NULL) 906 gold_error_at_location(this->relinfo_, this->relnum_, this->r_offset_, 907 _("missing expected __tls_get_addr call")); 908 } 909 910 void 911 expect_tls_get_addr_call( 912 const Relocate_info<size, big_endian>* relinfo, 913 size_t relnum, 914 Address r_offset) 915 { 916 this->tls_get_addr_ = EXPECTED; 917 this->relinfo_ = relinfo; 918 this->relnum_ = relnum; 919 this->r_offset_ = r_offset; 920 } 921 922 void 923 expect_tls_get_addr_call() 924 { this->tls_get_addr_ = EXPECTED; } 925 926 void 927 skip_next_tls_get_addr_call() 928 {this->tls_get_addr_ = SKIP; } 929 930 Tls_get_addr 931 maybe_skip_tls_get_addr_call(unsigned int r_type, const Symbol* gsym) 932 { 933 bool is_tls_call = ((r_type == elfcpp::R_POWERPC_REL24 934 || r_type == elfcpp::R_PPC_PLTREL24) 935 && gsym != NULL 936 && strcmp(gsym->name(), "__tls_get_addr") == 0); 937 Tls_get_addr last_tls = this->tls_get_addr_; 938 this->tls_get_addr_ = NOT_EXPECTED; 939 if (is_tls_call && last_tls != EXPECTED) 940 return last_tls; 941 else if (!is_tls_call && last_tls != NOT_EXPECTED) 942 { 943 this->missing(); 944 return EXPECTED; 945 } 946 return NORMAL; 947 } 948 949 private: 950 // What we're up to regarding calls to __tls_get_addr. 951 // On powerpc, the branch and link insn making a call to 952 // __tls_get_addr is marked with a relocation, R_PPC64_TLSGD, 953 // R_PPC64_TLSLD, R_PPC_TLSGD or R_PPC_TLSLD, in addition to the 954 // usual R_POWERPC_REL24 or R_PPC_PLTREL25 relocation on a call. 955 // The marker relocation always comes first, and has the same 956 // symbol as the reloc on the insn setting up the __tls_get_addr 957 // argument. This ties the arg setup insn with the call insn, 958 // allowing ld to safely optimize away the call. We check that 959 // every call to __tls_get_addr has a marker relocation, and that 960 // every marker relocation is on a call to __tls_get_addr. 961 Tls_get_addr tls_get_addr_; 962 // Info about the last reloc for error message. 963 const Relocate_info<size, big_endian>* relinfo_; 964 size_t relnum_; 965 Address r_offset_; 966 }; 967 968 // The class which scans relocations. 969 class Scan : protected Track_tls 970 { 971 public: 972 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 973 974 Scan() 975 : Track_tls(), issued_non_pic_error_(false) 976 { } 977 978 static inline int 979 get_reference_flags(unsigned int r_type, const Target_powerpc* target); 980 981 inline void 982 local(Symbol_table* symtab, Layout* layout, Target_powerpc* target, 983 Sized_relobj_file<size, big_endian>* object, 984 unsigned int data_shndx, 985 Output_section* output_section, 986 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type, 987 const elfcpp::Sym<size, big_endian>& lsym, 988 bool is_discarded); 989 990 inline void 991 global(Symbol_table* symtab, Layout* layout, Target_powerpc* target, 992 Sized_relobj_file<size, big_endian>* object, 993 unsigned int data_shndx, 994 Output_section* output_section, 995 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type, 996 Symbol* gsym); 997 998 inline bool 999 local_reloc_may_be_function_pointer(Symbol_table* , Layout* , 1000 Target_powerpc* , 1001 Sized_relobj_file<size, big_endian>* relobj, 1002 unsigned int , 1003 Output_section* , 1004 const elfcpp::Rela<size, big_endian>& , 1005 unsigned int r_type, 1006 const elfcpp::Sym<size, big_endian>&) 1007 { 1008 // PowerPC64 .opd is not folded, so any identical function text 1009 // may be folded and we'll still keep function addresses distinct. 1010 // That means no reloc is of concern here. 1011 if (size == 64) 1012 { 1013 Powerpc_relobj<size, big_endian>* ppcobj = static_cast 1014 <Powerpc_relobj<size, big_endian>*>(relobj); 1015 if (ppcobj->abiversion() == 1) 1016 return false; 1017 } 1018 // For 32-bit and ELFv2, conservatively assume anything but calls to 1019 // function code might be taking the address of the function. 1020 return !is_branch_reloc(r_type); 1021 } 1022 1023 inline bool 1024 global_reloc_may_be_function_pointer(Symbol_table* , Layout* , 1025 Target_powerpc* , 1026 Sized_relobj_file<size, big_endian>* relobj, 1027 unsigned int , 1028 Output_section* , 1029 const elfcpp::Rela<size, big_endian>& , 1030 unsigned int r_type, 1031 Symbol*) 1032 { 1033 // As above. 1034 if (size == 64) 1035 { 1036 Powerpc_relobj<size, big_endian>* ppcobj = static_cast 1037 <Powerpc_relobj<size, big_endian>*>(relobj); 1038 if (ppcobj->abiversion() == 1) 1039 return false; 1040 } 1041 return !is_branch_reloc(r_type); 1042 } 1043 1044 static bool 1045 reloc_needs_plt_for_ifunc(Target_powerpc<size, big_endian>* target, 1046 Sized_relobj_file<size, big_endian>* object, 1047 unsigned int r_type, bool report_err); 1048 1049 private: 1050 static void 1051 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*, 1052 unsigned int r_type); 1053 1054 static void 1055 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*, 1056 unsigned int r_type, Symbol*); 1057 1058 static void 1059 generate_tls_call(Symbol_table* symtab, Layout* layout, 1060 Target_powerpc* target); 1061 1062 void 1063 check_non_pic(Relobj*, unsigned int r_type); 1064 1065 // Whether we have issued an error about a non-PIC compilation. 1066 bool issued_non_pic_error_; 1067 }; 1068 1069 bool 1070 symval_for_branch(const Symbol_table* symtab, 1071 const Sized_symbol<size>* gsym, 1072 Powerpc_relobj<size, big_endian>* object, 1073 Address *value, unsigned int *dest_shndx); 1074 1075 // The class which implements relocation. 1076 class Relocate : protected Track_tls 1077 { 1078 public: 1079 // Use 'at' branch hints when true, 'y' when false. 1080 // FIXME maybe: set this with an option. 1081 static const bool is_isa_v2 = true; 1082 1083 Relocate() 1084 : Track_tls() 1085 { } 1086 1087 // Do a relocation. Return false if the caller should not issue 1088 // any warnings about this relocation. 1089 inline bool 1090 relocate(const Relocate_info<size, big_endian>*, unsigned int, 1091 Target_powerpc*, Output_section*, size_t, const unsigned char*, 1092 const Sized_symbol<size>*, const Symbol_value<size>*, 1093 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr, 1094 section_size_type); 1095 }; 1096 1097 class Relocate_comdat_behavior 1098 { 1099 public: 1100 // Decide what the linker should do for relocations that refer to 1101 // discarded comdat sections. 1102 inline Comdat_behavior 1103 get(const char* name) 1104 { 1105 gold::Default_comdat_behavior default_behavior; 1106 Comdat_behavior ret = default_behavior.get(name); 1107 if (ret == CB_WARNING) 1108 { 1109 if (size == 32 1110 && (strcmp(name, ".fixup") == 0 1111 || strcmp(name, ".got2") == 0)) 1112 ret = CB_IGNORE; 1113 if (size == 64 1114 && (strcmp(name, ".opd") == 0 1115 || strcmp(name, ".toc") == 0 1116 || strcmp(name, ".toc1") == 0)) 1117 ret = CB_IGNORE; 1118 } 1119 return ret; 1120 } 1121 }; 1122 1123 // Optimize the TLS relocation type based on what we know about the 1124 // symbol. IS_FINAL is true if the final address of this symbol is 1125 // known at link time. 1126 1127 tls::Tls_optimization 1128 optimize_tls_gd(bool is_final) 1129 { 1130 // If we are generating a shared library, then we can't do anything 1131 // in the linker. 1132 if (parameters->options().shared()) 1133 return tls::TLSOPT_NONE; 1134 1135 if (!is_final) 1136 return tls::TLSOPT_TO_IE; 1137 return tls::TLSOPT_TO_LE; 1138 } 1139 1140 tls::Tls_optimization 1141 optimize_tls_ld() 1142 { 1143 if (parameters->options().shared()) 1144 return tls::TLSOPT_NONE; 1145 1146 return tls::TLSOPT_TO_LE; 1147 } 1148 1149 tls::Tls_optimization 1150 optimize_tls_ie(bool is_final) 1151 { 1152 if (!is_final || parameters->options().shared()) 1153 return tls::TLSOPT_NONE; 1154 1155 return tls::TLSOPT_TO_LE; 1156 } 1157 1158 // Create glink. 1159 void 1160 make_glink_section(Layout*); 1161 1162 // Create the PLT section. 1163 void 1164 make_plt_section(Symbol_table*, Layout*); 1165 1166 void 1167 make_iplt_section(Symbol_table*, Layout*); 1168 1169 void 1170 make_brlt_section(Layout*); 1171 1172 // Create a PLT entry for a global symbol. 1173 void 1174 make_plt_entry(Symbol_table*, Layout*, Symbol*); 1175 1176 // Create a PLT entry for a local IFUNC symbol. 1177 void 1178 make_local_ifunc_plt_entry(Symbol_table*, Layout*, 1179 Sized_relobj_file<size, big_endian>*, 1180 unsigned int); 1181 1182 1183 // Create a GOT entry for local dynamic __tls_get_addr. 1184 unsigned int 1185 tlsld_got_offset(Symbol_table* symtab, Layout* layout, 1186 Sized_relobj_file<size, big_endian>* object); 1187 1188 unsigned int 1189 tlsld_got_offset() const 1190 { 1191 return this->tlsld_got_offset_; 1192 } 1193 1194 // Get the dynamic reloc section, creating it if necessary. 1195 Reloc_section* 1196 rela_dyn_section(Layout*); 1197 1198 // Similarly, but for ifunc symbols get the one for ifunc. 1199 Reloc_section* 1200 rela_dyn_section(Symbol_table*, Layout*, bool for_ifunc); 1201 1202 // Copy a relocation against a global symbol. 1203 void 1204 copy_reloc(Symbol_table* symtab, Layout* layout, 1205 Sized_relobj_file<size, big_endian>* object, 1206 unsigned int shndx, Output_section* output_section, 1207 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc) 1208 { 1209 unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info()); 1210 this->copy_relocs_.copy_reloc(symtab, layout, 1211 symtab->get_sized_symbol<size>(sym), 1212 object, shndx, output_section, 1213 r_type, reloc.get_r_offset(), 1214 reloc.get_r_addend(), 1215 this->rela_dyn_section(layout)); 1216 } 1217 1218 // Look over all the input sections, deciding where to place stubs. 1219 void 1220 group_sections(Layout*, const Task*, bool); 1221 1222 // Sort output sections by address. 1223 struct Sort_sections 1224 { 1225 bool 1226 operator()(const Output_section* sec1, const Output_section* sec2) 1227 { return sec1->address() < sec2->address(); } 1228 }; 1229 1230 class Branch_info 1231 { 1232 public: 1233 Branch_info(Powerpc_relobj<size, big_endian>* ppc_object, 1234 unsigned int data_shndx, 1235 Address r_offset, 1236 unsigned int r_type, 1237 unsigned int r_sym, 1238 Address addend) 1239 : object_(ppc_object), shndx_(data_shndx), offset_(r_offset), 1240 r_type_(r_type), r_sym_(r_sym), addend_(addend) 1241 { } 1242 1243 ~Branch_info() 1244 { } 1245 1246 // If this branch needs a plt call stub, or a long branch stub, make one. 1247 bool 1248 make_stub(Stub_table<size, big_endian>*, 1249 Stub_table<size, big_endian>*, 1250 Symbol_table*) const; 1251 1252 private: 1253 // The branch location.. 1254 Powerpc_relobj<size, big_endian>* object_; 1255 unsigned int shndx_; 1256 Address offset_; 1257 // ..and the branch type and destination. 1258 unsigned int r_type_; 1259 unsigned int r_sym_; 1260 Address addend_; 1261 }; 1262 1263 // Information about this specific target which we pass to the 1264 // general Target structure. 1265 static Target::Target_info powerpc_info; 1266 1267 // The types of GOT entries needed for this platform. 1268 // These values are exposed to the ABI in an incremental link. 1269 // Do not renumber existing values without changing the version 1270 // number of the .gnu_incremental_inputs section. 1271 enum Got_type 1272 { 1273 GOT_TYPE_STANDARD, 1274 GOT_TYPE_TLSGD, // double entry for @got@tlsgd 1275 GOT_TYPE_DTPREL, // entry for @got@dtprel 1276 GOT_TYPE_TPREL // entry for @got@tprel 1277 }; 1278 1279 // The GOT section. 1280 Output_data_got_powerpc<size, big_endian>* got_; 1281 // The PLT section. This is a container for a table of addresses, 1282 // and their relocations. Each address in the PLT has a dynamic 1283 // relocation (R_*_JMP_SLOT) and each address will have a 1284 // corresponding entry in .glink for lazy resolution of the PLT. 1285 // ppc32 initialises the PLT to point at the .glink entry, while 1286 // ppc64 leaves this to ld.so. To make a call via the PLT, the 1287 // linker adds a stub that loads the PLT entry into ctr then 1288 // branches to ctr. There may be more than one stub for each PLT 1289 // entry. DT_JMPREL points at the first PLT dynamic relocation and 1290 // DT_PLTRELSZ gives the total size of PLT dynamic relocations. 1291 Output_data_plt_powerpc<size, big_endian>* plt_; 1292 // The IPLT section. Like plt_, this is a container for a table of 1293 // addresses and their relocations, specifically for STT_GNU_IFUNC 1294 // functions that resolve locally (STT_GNU_IFUNC functions that 1295 // don't resolve locally go in PLT). Unlike plt_, these have no 1296 // entry in .glink for lazy resolution, and the relocation section 1297 // does not have a 1-1 correspondence with IPLT addresses. In fact, 1298 // the relocation section may contain relocations against 1299 // STT_GNU_IFUNC symbols at locations outside of IPLT. The 1300 // relocation section will appear at the end of other dynamic 1301 // relocations, so that ld.so applies these relocations after other 1302 // dynamic relocations. In a static executable, the relocation 1303 // section is emitted and marked with __rela_iplt_start and 1304 // __rela_iplt_end symbols. 1305 Output_data_plt_powerpc<size, big_endian>* iplt_; 1306 // Section holding long branch destinations. 1307 Output_data_brlt_powerpc<size, big_endian>* brlt_section_; 1308 // The .glink section. 1309 Output_data_glink<size, big_endian>* glink_; 1310 // The dynamic reloc section. 1311 Reloc_section* rela_dyn_; 1312 // Relocs saved to avoid a COPY reloc. 1313 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_; 1314 // Offset of the GOT entry for local dynamic __tls_get_addr calls. 1315 unsigned int tlsld_got_offset_; 1316 1317 Stub_tables stub_tables_; 1318 typedef Unordered_map<Address, unsigned int> Branch_lookup_table; 1319 Branch_lookup_table branch_lookup_table_; 1320 1321 typedef std::vector<Branch_info> Branches; 1322 Branches branch_info_; 1323 1324 bool plt_thread_safe_; 1325 1326 bool relax_failed_; 1327 int relax_fail_count_; 1328 int32_t stub_group_size_; 1329 1330 Output_data_save_res<size, big_endian> *savres_section_; 1331 }; 1332 1333 template<> 1334 Target::Target_info Target_powerpc<32, true>::powerpc_info = 1335 { 1336 32, // size 1337 true, // is_big_endian 1338 elfcpp::EM_PPC, // machine_code 1339 false, // has_make_symbol 1340 false, // has_resolve 1341 false, // has_code_fill 1342 true, // is_default_stack_executable 1343 false, // can_icf_inline_merge_sections 1344 '\0', // wrap_char 1345 "/usr/lib/ld.so.1", // dynamic_linker 1346 0x10000000, // default_text_segment_address 1347 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 1348 4 * 1024, // common_pagesize (overridable by -z common-page-size) 1349 false, // isolate_execinstr 1350 0, // rosegment_gap 1351 elfcpp::SHN_UNDEF, // small_common_shndx 1352 elfcpp::SHN_UNDEF, // large_common_shndx 1353 0, // small_common_section_flags 1354 0, // large_common_section_flags 1355 NULL, // attributes_section 1356 NULL, // attributes_vendor 1357 "_start", // entry_symbol_name 1358 32, // hash_entry_size 1359 }; 1360 1361 template<> 1362 Target::Target_info Target_powerpc<32, false>::powerpc_info = 1363 { 1364 32, // size 1365 false, // is_big_endian 1366 elfcpp::EM_PPC, // machine_code 1367 false, // has_make_symbol 1368 false, // has_resolve 1369 false, // has_code_fill 1370 true, // is_default_stack_executable 1371 false, // can_icf_inline_merge_sections 1372 '\0', // wrap_char 1373 "/usr/lib/ld.so.1", // dynamic_linker 1374 0x10000000, // default_text_segment_address 1375 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 1376 4 * 1024, // common_pagesize (overridable by -z common-page-size) 1377 false, // isolate_execinstr 1378 0, // rosegment_gap 1379 elfcpp::SHN_UNDEF, // small_common_shndx 1380 elfcpp::SHN_UNDEF, // large_common_shndx 1381 0, // small_common_section_flags 1382 0, // large_common_section_flags 1383 NULL, // attributes_section 1384 NULL, // attributes_vendor 1385 "_start", // entry_symbol_name 1386 32, // hash_entry_size 1387 }; 1388 1389 template<> 1390 Target::Target_info Target_powerpc<64, true>::powerpc_info = 1391 { 1392 64, // size 1393 true, // is_big_endian 1394 elfcpp::EM_PPC64, // machine_code 1395 false, // has_make_symbol 1396 false, // has_resolve 1397 false, // has_code_fill 1398 true, // is_default_stack_executable 1399 false, // can_icf_inline_merge_sections 1400 '\0', // wrap_char 1401 "/usr/lib/ld.so.1", // dynamic_linker 1402 0x10000000, // default_text_segment_address 1403 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 1404 4 * 1024, // common_pagesize (overridable by -z common-page-size) 1405 false, // isolate_execinstr 1406 0, // rosegment_gap 1407 elfcpp::SHN_UNDEF, // small_common_shndx 1408 elfcpp::SHN_UNDEF, // large_common_shndx 1409 0, // small_common_section_flags 1410 0, // large_common_section_flags 1411 NULL, // attributes_section 1412 NULL, // attributes_vendor 1413 "_start", // entry_symbol_name 1414 32, // hash_entry_size 1415 }; 1416 1417 template<> 1418 Target::Target_info Target_powerpc<64, false>::powerpc_info = 1419 { 1420 64, // size 1421 false, // is_big_endian 1422 elfcpp::EM_PPC64, // machine_code 1423 false, // has_make_symbol 1424 false, // has_resolve 1425 false, // has_code_fill 1426 true, // is_default_stack_executable 1427 false, // can_icf_inline_merge_sections 1428 '\0', // wrap_char 1429 "/usr/lib/ld.so.1", // dynamic_linker 1430 0x10000000, // default_text_segment_address 1431 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 1432 4 * 1024, // common_pagesize (overridable by -z common-page-size) 1433 false, // isolate_execinstr 1434 0, // rosegment_gap 1435 elfcpp::SHN_UNDEF, // small_common_shndx 1436 elfcpp::SHN_UNDEF, // large_common_shndx 1437 0, // small_common_section_flags 1438 0, // large_common_section_flags 1439 NULL, // attributes_section 1440 NULL, // attributes_vendor 1441 "_start", // entry_symbol_name 1442 32, // hash_entry_size 1443 }; 1444 1445 inline bool 1446 is_branch_reloc(unsigned int r_type) 1447 { 1448 return (r_type == elfcpp::R_POWERPC_REL24 1449 || r_type == elfcpp::R_PPC_PLTREL24 1450 || r_type == elfcpp::R_PPC_LOCAL24PC 1451 || r_type == elfcpp::R_POWERPC_REL14 1452 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN 1453 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN 1454 || r_type == elfcpp::R_POWERPC_ADDR24 1455 || r_type == elfcpp::R_POWERPC_ADDR14 1456 || r_type == elfcpp::R_POWERPC_ADDR14_BRTAKEN 1457 || r_type == elfcpp::R_POWERPC_ADDR14_BRNTAKEN); 1458 } 1459 1460 // If INSN is an opcode that may be used with an @tls operand, return 1461 // the transformed insn for TLS optimisation, otherwise return 0. If 1462 // REG is non-zero only match an insn with RB or RA equal to REG. 1463 uint32_t 1464 at_tls_transform(uint32_t insn, unsigned int reg) 1465 { 1466 if ((insn & (0x3f << 26)) != 31 << 26) 1467 return 0; 1468 1469 unsigned int rtra; 1470 if (reg == 0 || ((insn >> 11) & 0x1f) == reg) 1471 rtra = insn & ((1 << 26) - (1 << 16)); 1472 else if (((insn >> 16) & 0x1f) == reg) 1473 rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5); 1474 else 1475 return 0; 1476 1477 if ((insn & (0x3ff << 1)) == 266 << 1) 1478 // add -> addi 1479 insn = 14 << 26; 1480 else if ((insn & (0x1f << 1)) == 23 << 1 1481 && ((insn & (0x1f << 6)) < 14 << 6 1482 || ((insn & (0x1f << 6)) >= 16 << 6 1483 && (insn & (0x1f << 6)) < 24 << 6))) 1484 // load and store indexed -> dform 1485 insn = (32 | ((insn >> 6) & 0x1f)) << 26; 1486 else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1) 1487 // ldx, ldux, stdx, stdux -> ld, ldu, std, stdu 1488 insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1); 1489 else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1) 1490 // lwax -> lwa 1491 insn = (58 << 26) | 2; 1492 else 1493 return 0; 1494 insn |= rtra; 1495 return insn; 1496 } 1497 1498 1499 template<int size, bool big_endian> 1500 class Powerpc_relocate_functions 1501 { 1502 public: 1503 enum Overflow_check 1504 { 1505 CHECK_NONE, 1506 CHECK_SIGNED, 1507 CHECK_UNSIGNED, 1508 CHECK_BITFIELD, 1509 CHECK_LOW_INSN, 1510 CHECK_HIGH_INSN 1511 }; 1512 1513 enum Status 1514 { 1515 STATUS_OK, 1516 STATUS_OVERFLOW 1517 }; 1518 1519 private: 1520 typedef Powerpc_relocate_functions<size, big_endian> This; 1521 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 1522 typedef typename elfcpp::Elf_types<size>::Elf_Swxword SignedAddress; 1523 1524 template<int valsize> 1525 static inline bool 1526 has_overflow_signed(Address value) 1527 { 1528 // limit = 1 << (valsize - 1) without shift count exceeding size of type 1529 Address limit = static_cast<Address>(1) << ((valsize - 1) >> 1); 1530 limit <<= ((valsize - 1) >> 1); 1531 limit <<= ((valsize - 1) - 2 * ((valsize - 1) >> 1)); 1532 return value + limit > (limit << 1) - 1; 1533 } 1534 1535 template<int valsize> 1536 static inline bool 1537 has_overflow_unsigned(Address value) 1538 { 1539 Address limit = static_cast<Address>(1) << ((valsize - 1) >> 1); 1540 limit <<= ((valsize - 1) >> 1); 1541 limit <<= ((valsize - 1) - 2 * ((valsize - 1) >> 1)); 1542 return value > (limit << 1) - 1; 1543 } 1544 1545 template<int valsize> 1546 static inline bool 1547 has_overflow_bitfield(Address value) 1548 { 1549 return (has_overflow_unsigned<valsize>(value) 1550 && has_overflow_signed<valsize>(value)); 1551 } 1552 1553 template<int valsize> 1554 static inline Status 1555 overflowed(Address value, Overflow_check overflow) 1556 { 1557 if (overflow == CHECK_SIGNED) 1558 { 1559 if (has_overflow_signed<valsize>(value)) 1560 return STATUS_OVERFLOW; 1561 } 1562 else if (overflow == CHECK_UNSIGNED) 1563 { 1564 if (has_overflow_unsigned<valsize>(value)) 1565 return STATUS_OVERFLOW; 1566 } 1567 else if (overflow == CHECK_BITFIELD) 1568 { 1569 if (has_overflow_bitfield<valsize>(value)) 1570 return STATUS_OVERFLOW; 1571 } 1572 return STATUS_OK; 1573 } 1574 1575 // Do a simple RELA relocation 1576 template<int fieldsize, int valsize> 1577 static inline Status 1578 rela(unsigned char* view, Address value, Overflow_check overflow) 1579 { 1580 typedef typename elfcpp::Swap<fieldsize, big_endian>::Valtype Valtype; 1581 Valtype* wv = reinterpret_cast<Valtype*>(view); 1582 elfcpp::Swap<fieldsize, big_endian>::writeval(wv, value); 1583 return overflowed<valsize>(value, overflow); 1584 } 1585 1586 template<int fieldsize, int valsize> 1587 static inline Status 1588 rela(unsigned char* view, 1589 unsigned int right_shift, 1590 typename elfcpp::Valtype_base<fieldsize>::Valtype dst_mask, 1591 Address value, 1592 Overflow_check overflow) 1593 { 1594 typedef typename elfcpp::Swap<fieldsize, big_endian>::Valtype Valtype; 1595 Valtype* wv = reinterpret_cast<Valtype*>(view); 1596 Valtype val = elfcpp::Swap<fieldsize, big_endian>::readval(wv); 1597 Valtype reloc = value >> right_shift; 1598 val &= ~dst_mask; 1599 reloc &= dst_mask; 1600 elfcpp::Swap<fieldsize, big_endian>::writeval(wv, val | reloc); 1601 return overflowed<valsize>(value >> right_shift, overflow); 1602 } 1603 1604 // Do a simple RELA relocation, unaligned. 1605 template<int fieldsize, int valsize> 1606 static inline Status 1607 rela_ua(unsigned char* view, Address value, Overflow_check overflow) 1608 { 1609 elfcpp::Swap_unaligned<fieldsize, big_endian>::writeval(view, value); 1610 return overflowed<valsize>(value, overflow); 1611 } 1612 1613 template<int fieldsize, int valsize> 1614 static inline Status 1615 rela_ua(unsigned char* view, 1616 unsigned int right_shift, 1617 typename elfcpp::Valtype_base<fieldsize>::Valtype dst_mask, 1618 Address value, 1619 Overflow_check overflow) 1620 { 1621 typedef typename elfcpp::Swap_unaligned<fieldsize, big_endian>::Valtype 1622 Valtype; 1623 Valtype val = elfcpp::Swap<fieldsize, big_endian>::readval(view); 1624 Valtype reloc = value >> right_shift; 1625 val &= ~dst_mask; 1626 reloc &= dst_mask; 1627 elfcpp::Swap_unaligned<fieldsize, big_endian>::writeval(view, val | reloc); 1628 return overflowed<valsize>(value >> right_shift, overflow); 1629 } 1630 1631 public: 1632 // R_PPC64_ADDR64: (Symbol + Addend) 1633 static inline void 1634 addr64(unsigned char* view, Address value) 1635 { This::template rela<64,64>(view, value, CHECK_NONE); } 1636 1637 // R_PPC64_UADDR64: (Symbol + Addend) unaligned 1638 static inline void 1639 addr64_u(unsigned char* view, Address value) 1640 { This::template rela_ua<64,64>(view, value, CHECK_NONE); } 1641 1642 // R_POWERPC_ADDR32: (Symbol + Addend) 1643 static inline Status 1644 addr32(unsigned char* view, Address value, Overflow_check overflow) 1645 { return This::template rela<32,32>(view, value, overflow); } 1646 1647 // R_POWERPC_UADDR32: (Symbol + Addend) unaligned 1648 static inline Status 1649 addr32_u(unsigned char* view, Address value, Overflow_check overflow) 1650 { return This::template rela_ua<32,32>(view, value, overflow); } 1651 1652 // R_POWERPC_ADDR24: (Symbol + Addend) & 0x3fffffc 1653 static inline Status 1654 addr24(unsigned char* view, Address value, Overflow_check overflow) 1655 { 1656 Status stat = This::template rela<32,26>(view, 0, 0x03fffffc, 1657 value, overflow); 1658 if (overflow != CHECK_NONE && (value & 3) != 0) 1659 stat = STATUS_OVERFLOW; 1660 return stat; 1661 } 1662 1663 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff 1664 static inline Status 1665 addr16(unsigned char* view, Address value, Overflow_check overflow) 1666 { return This::template rela<16,16>(view, value, overflow); } 1667 1668 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff, unaligned 1669 static inline Status 1670 addr16_u(unsigned char* view, Address value, Overflow_check overflow) 1671 { return This::template rela_ua<16,16>(view, value, overflow); } 1672 1673 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc 1674 static inline Status 1675 addr16_ds(unsigned char* view, Address value, Overflow_check overflow) 1676 { 1677 Status stat = This::template rela<16,16>(view, 0, 0xfffc, value, overflow); 1678 if ((value & 3) != 0) 1679 stat = STATUS_OVERFLOW; 1680 return stat; 1681 } 1682 1683 // R_POWERPC_ADDR16_DQ: (Symbol + Addend) & 0xfff0 1684 static inline Status 1685 addr16_dq(unsigned char* view, Address value, Overflow_check overflow) 1686 { 1687 Status stat = This::template rela<16,16>(view, 0, 0xfff0, value, overflow); 1688 if ((value & 15) != 0) 1689 stat = STATUS_OVERFLOW; 1690 return stat; 1691 } 1692 1693 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff 1694 static inline void 1695 addr16_hi(unsigned char* view, Address value) 1696 { This::template rela<16,16>(view, 16, 0xffff, value, CHECK_NONE); } 1697 1698 // R_POWERPC_ADDR16_HA: ((Symbol + Addend + 0x8000) >> 16) & 0xffff 1699 static inline void 1700 addr16_ha(unsigned char* view, Address value) 1701 { This::addr16_hi(view, value + 0x8000); } 1702 1703 // R_POWERPC_ADDR16_HIGHER: ((Symbol + Addend) >> 32) & 0xffff 1704 static inline void 1705 addr16_hi2(unsigned char* view, Address value) 1706 { This::template rela<16,16>(view, 32, 0xffff, value, CHECK_NONE); } 1707 1708 // R_POWERPC_ADDR16_HIGHERA: ((Symbol + Addend + 0x8000) >> 32) & 0xffff 1709 static inline void 1710 addr16_ha2(unsigned char* view, Address value) 1711 { This::addr16_hi2(view, value + 0x8000); } 1712 1713 // R_POWERPC_ADDR16_HIGHEST: ((Symbol + Addend) >> 48) & 0xffff 1714 static inline void 1715 addr16_hi3(unsigned char* view, Address value) 1716 { This::template rela<16,16>(view, 48, 0xffff, value, CHECK_NONE); } 1717 1718 // R_POWERPC_ADDR16_HIGHESTA: ((Symbol + Addend + 0x8000) >> 48) & 0xffff 1719 static inline void 1720 addr16_ha3(unsigned char* view, Address value) 1721 { This::addr16_hi3(view, value + 0x8000); } 1722 1723 // R_POWERPC_ADDR14: (Symbol + Addend) & 0xfffc 1724 static inline Status 1725 addr14(unsigned char* view, Address value, Overflow_check overflow) 1726 { 1727 Status stat = This::template rela<32,16>(view, 0, 0xfffc, value, overflow); 1728 if (overflow != CHECK_NONE && (value & 3) != 0) 1729 stat = STATUS_OVERFLOW; 1730 return stat; 1731 } 1732 1733 // R_POWERPC_REL16DX_HA 1734 static inline Status 1735 addr16dx_ha(unsigned char *view, Address value, Overflow_check overflow) 1736 { 1737 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype; 1738 Valtype* wv = reinterpret_cast<Valtype*>(view); 1739 Valtype val = elfcpp::Swap<32, big_endian>::readval(wv); 1740 value += 0x8000; 1741 value = static_cast<SignedAddress>(value) >> 16; 1742 val |= (value & 0xffc1) | ((value & 0x3e) << 15); 1743 elfcpp::Swap<32, big_endian>::writeval(wv, val); 1744 return overflowed<16>(value, overflow); 1745 } 1746 }; 1747 1748 // Set ABI version for input and output. 1749 1750 template<int size, bool big_endian> 1751 void 1752 Powerpc_relobj<size, big_endian>::set_abiversion(int ver) 1753 { 1754 this->e_flags_ |= ver; 1755 if (this->abiversion() != 0) 1756 { 1757 Target_powerpc<size, big_endian>* target = 1758 static_cast<Target_powerpc<size, big_endian>*>( 1759 parameters->sized_target<size, big_endian>()); 1760 if (target->abiversion() == 0) 1761 target->set_abiversion(this->abiversion()); 1762 else if (target->abiversion() != this->abiversion()) 1763 gold_error(_("%s: ABI version %d is not compatible " 1764 "with ABI version %d output"), 1765 this->name().c_str(), 1766 this->abiversion(), target->abiversion()); 1767 1768 } 1769 } 1770 1771 // Stash away the index of .got2 or .opd in a relocatable object, if 1772 // such a section exists. 1773 1774 template<int size, bool big_endian> 1775 bool 1776 Powerpc_relobj<size, big_endian>::do_find_special_sections( 1777 Read_symbols_data* sd) 1778 { 1779 const unsigned char* const pshdrs = sd->section_headers->data(); 1780 const unsigned char* namesu = sd->section_names->data(); 1781 const char* names = reinterpret_cast<const char*>(namesu); 1782 section_size_type names_size = sd->section_names_size; 1783 const unsigned char* s; 1784 1785 s = this->template find_shdr<size, big_endian>(pshdrs, 1786 size == 32 ? ".got2" : ".opd", 1787 names, names_size, NULL); 1788 if (s != NULL) 1789 { 1790 unsigned int ndx = (s - pshdrs) / elfcpp::Elf_sizes<size>::shdr_size; 1791 this->special_ = ndx; 1792 if (size == 64) 1793 { 1794 if (this->abiversion() == 0) 1795 this->set_abiversion(1); 1796 else if (this->abiversion() > 1) 1797 gold_error(_("%s: .opd invalid in abiv%d"), 1798 this->name().c_str(), this->abiversion()); 1799 } 1800 } 1801 return Sized_relobj_file<size, big_endian>::do_find_special_sections(sd); 1802 } 1803 1804 // Examine .rela.opd to build info about function entry points. 1805 1806 template<int size, bool big_endian> 1807 void 1808 Powerpc_relobj<size, big_endian>::scan_opd_relocs( 1809 size_t reloc_count, 1810 const unsigned char* prelocs, 1811 const unsigned char* plocal_syms) 1812 { 1813 if (size == 64) 1814 { 1815 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc 1816 Reltype; 1817 const int reloc_size 1818 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size; 1819 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 1820 Address expected_off = 0; 1821 bool regular = true; 1822 unsigned int opd_ent_size = 0; 1823 1824 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) 1825 { 1826 Reltype reloc(prelocs); 1827 typename elfcpp::Elf_types<size>::Elf_WXword r_info 1828 = reloc.get_r_info(); 1829 unsigned int r_type = elfcpp::elf_r_type<size>(r_info); 1830 if (r_type == elfcpp::R_PPC64_ADDR64) 1831 { 1832 unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info); 1833 typename elfcpp::Elf_types<size>::Elf_Addr value; 1834 bool is_ordinary; 1835 unsigned int shndx; 1836 if (r_sym < this->local_symbol_count()) 1837 { 1838 typename elfcpp::Sym<size, big_endian> 1839 lsym(plocal_syms + r_sym * sym_size); 1840 shndx = lsym.get_st_shndx(); 1841 shndx = this->adjust_sym_shndx(r_sym, shndx, &is_ordinary); 1842 value = lsym.get_st_value(); 1843 } 1844 else 1845 shndx = this->symbol_section_and_value(r_sym, &value, 1846 &is_ordinary); 1847 this->set_opd_ent(reloc.get_r_offset(), shndx, 1848 value + reloc.get_r_addend()); 1849 if (i == 2) 1850 { 1851 expected_off = reloc.get_r_offset(); 1852 opd_ent_size = expected_off; 1853 } 1854 else if (expected_off != reloc.get_r_offset()) 1855 regular = false; 1856 expected_off += opd_ent_size; 1857 } 1858 else if (r_type == elfcpp::R_PPC64_TOC) 1859 { 1860 if (expected_off - opd_ent_size + 8 != reloc.get_r_offset()) 1861 regular = false; 1862 } 1863 else 1864 { 1865 gold_warning(_("%s: unexpected reloc type %u in .opd section"), 1866 this->name().c_str(), r_type); 1867 regular = false; 1868 } 1869 } 1870 if (reloc_count <= 2) 1871 opd_ent_size = this->section_size(this->opd_shndx()); 1872 if (opd_ent_size != 24 && opd_ent_size != 16) 1873 regular = false; 1874 if (!regular) 1875 { 1876 gold_warning(_("%s: .opd is not a regular array of opd entries"), 1877 this->name().c_str()); 1878 opd_ent_size = 0; 1879 } 1880 } 1881 } 1882 1883 template<int size, bool big_endian> 1884 void 1885 Powerpc_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd) 1886 { 1887 Sized_relobj_file<size, big_endian>::do_read_relocs(rd); 1888 if (size == 64) 1889 { 1890 for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin(); 1891 p != rd->relocs.end(); 1892 ++p) 1893 { 1894 if (p->data_shndx == this->opd_shndx()) 1895 { 1896 uint64_t opd_size = this->section_size(this->opd_shndx()); 1897 gold_assert(opd_size == static_cast<size_t>(opd_size)); 1898 if (opd_size != 0) 1899 { 1900 this->init_opd(opd_size); 1901 this->scan_opd_relocs(p->reloc_count, p->contents->data(), 1902 rd->local_symbols->data()); 1903 } 1904 break; 1905 } 1906 } 1907 } 1908 } 1909 1910 // Read the symbols then set up st_other vector. 1911 1912 template<int size, bool big_endian> 1913 void 1914 Powerpc_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd) 1915 { 1916 this->base_read_symbols(sd); 1917 if (size == 64) 1918 { 1919 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 1920 const unsigned char* const pshdrs = sd->section_headers->data(); 1921 const unsigned int loccount = this->do_local_symbol_count(); 1922 if (loccount != 0) 1923 { 1924 this->st_other_.resize(loccount); 1925 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 1926 off_t locsize = loccount * sym_size; 1927 const unsigned int symtab_shndx = this->symtab_shndx(); 1928 const unsigned char *psymtab = pshdrs + symtab_shndx * shdr_size; 1929 typename elfcpp::Shdr<size, big_endian> shdr(psymtab); 1930 const unsigned char* psyms = this->get_view(shdr.get_sh_offset(), 1931 locsize, true, false); 1932 psyms += sym_size; 1933 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) 1934 { 1935 elfcpp::Sym<size, big_endian> sym(psyms); 1936 unsigned char st_other = sym.get_st_other(); 1937 this->st_other_[i] = st_other; 1938 if ((st_other & elfcpp::STO_PPC64_LOCAL_MASK) != 0) 1939 { 1940 if (this->abiversion() == 0) 1941 this->set_abiversion(2); 1942 else if (this->abiversion() < 2) 1943 gold_error(_("%s: local symbol %d has invalid st_other" 1944 " for ABI version 1"), 1945 this->name().c_str(), i); 1946 } 1947 } 1948 } 1949 } 1950 } 1951 1952 template<int size, bool big_endian> 1953 void 1954 Powerpc_dynobj<size, big_endian>::set_abiversion(int ver) 1955 { 1956 this->e_flags_ |= ver; 1957 if (this->abiversion() != 0) 1958 { 1959 Target_powerpc<size, big_endian>* target = 1960 static_cast<Target_powerpc<size, big_endian>*>( 1961 parameters->sized_target<size, big_endian>()); 1962 if (target->abiversion() == 0) 1963 target->set_abiversion(this->abiversion()); 1964 else if (target->abiversion() != this->abiversion()) 1965 gold_error(_("%s: ABI version %d is not compatible " 1966 "with ABI version %d output"), 1967 this->name().c_str(), 1968 this->abiversion(), target->abiversion()); 1969 1970 } 1971 } 1972 1973 // Call Sized_dynobj::base_read_symbols to read the symbols then 1974 // read .opd from a dynamic object, filling in opd_ent_ vector, 1975 1976 template<int size, bool big_endian> 1977 void 1978 Powerpc_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd) 1979 { 1980 this->base_read_symbols(sd); 1981 if (size == 64) 1982 { 1983 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 1984 const unsigned char* const pshdrs = sd->section_headers->data(); 1985 const unsigned char* namesu = sd->section_names->data(); 1986 const char* names = reinterpret_cast<const char*>(namesu); 1987 const unsigned char* s = NULL; 1988 const unsigned char* opd; 1989 section_size_type opd_size; 1990 1991 // Find and read .opd section. 1992 while (1) 1993 { 1994 s = this->template find_shdr<size, big_endian>(pshdrs, ".opd", names, 1995 sd->section_names_size, 1996 s); 1997 if (s == NULL) 1998 return; 1999 2000 typename elfcpp::Shdr<size, big_endian> shdr(s); 2001 if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS 2002 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0) 2003 { 2004 if (this->abiversion() == 0) 2005 this->set_abiversion(1); 2006 else if (this->abiversion() > 1) 2007 gold_error(_("%s: .opd invalid in abiv%d"), 2008 this->name().c_str(), this->abiversion()); 2009 2010 this->opd_shndx_ = (s - pshdrs) / shdr_size; 2011 this->opd_address_ = shdr.get_sh_addr(); 2012 opd_size = convert_to_section_size_type(shdr.get_sh_size()); 2013 opd = this->get_view(shdr.get_sh_offset(), opd_size, 2014 true, false); 2015 break; 2016 } 2017 } 2018 2019 // Build set of executable sections. 2020 // Using a set is probably overkill. There is likely to be only 2021 // a few executable sections, typically .init, .text and .fini, 2022 // and they are generally grouped together. 2023 typedef std::set<Sec_info> Exec_sections; 2024 Exec_sections exec_sections; 2025 s = pshdrs; 2026 for (unsigned int i = 1; i < this->shnum(); ++i, s += shdr_size) 2027 { 2028 typename elfcpp::Shdr<size, big_endian> shdr(s); 2029 if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS 2030 && ((shdr.get_sh_flags() 2031 & (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR)) 2032 == (elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR)) 2033 && shdr.get_sh_size() != 0) 2034 { 2035 exec_sections.insert(Sec_info(shdr.get_sh_addr(), 2036 shdr.get_sh_size(), i)); 2037 } 2038 } 2039 if (exec_sections.empty()) 2040 return; 2041 2042 // Look over the OPD entries. This is complicated by the fact 2043 // that some binaries will use two-word entries while others 2044 // will use the standard three-word entries. In most cases 2045 // the third word (the environment pointer for languages like 2046 // Pascal) is unused and will be zero. If the third word is 2047 // used it should not be pointing into executable sections, 2048 // I think. 2049 this->init_opd(opd_size); 2050 for (const unsigned char* p = opd; p < opd + opd_size; p += 8) 2051 { 2052 typedef typename elfcpp::Swap<64, big_endian>::Valtype Valtype; 2053 const Valtype* valp = reinterpret_cast<const Valtype*>(p); 2054 Valtype val = elfcpp::Swap<64, big_endian>::readval(valp); 2055 if (val == 0) 2056 // Chances are that this is the third word of an OPD entry. 2057 continue; 2058 typename Exec_sections::const_iterator e 2059 = exec_sections.upper_bound(Sec_info(val, 0, 0)); 2060 if (e != exec_sections.begin()) 2061 { 2062 --e; 2063 if (e->start <= val && val < e->start + e->len) 2064 { 2065 // We have an address in an executable section. 2066 // VAL ought to be the function entry, set it up. 2067 this->set_opd_ent(p - opd, e->shndx, val); 2068 // Skip second word of OPD entry, the TOC pointer. 2069 p += 8; 2070 } 2071 } 2072 // If we didn't match any executable sections, we likely 2073 // have a non-zero third word in the OPD entry. 2074 } 2075 } 2076 } 2077 2078 // Set up some symbols. 2079 2080 template<int size, bool big_endian> 2081 void 2082 Target_powerpc<size, big_endian>::do_define_standard_symbols( 2083 Symbol_table* symtab, 2084 Layout* layout) 2085 { 2086 if (size == 32) 2087 { 2088 // Define _GLOBAL_OFFSET_TABLE_ to ensure it isn't seen as 2089 // undefined when scanning relocs (and thus requires 2090 // non-relative dynamic relocs). The proper value will be 2091 // updated later. 2092 Symbol *gotsym = symtab->lookup("_GLOBAL_OFFSET_TABLE_", NULL); 2093 if (gotsym != NULL && gotsym->is_undefined()) 2094 { 2095 Target_powerpc<size, big_endian>* target = 2096 static_cast<Target_powerpc<size, big_endian>*>( 2097 parameters->sized_target<size, big_endian>()); 2098 Output_data_got_powerpc<size, big_endian>* got 2099 = target->got_section(symtab, layout); 2100 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 2101 Symbol_table::PREDEFINED, 2102 got, 0, 0, 2103 elfcpp::STT_OBJECT, 2104 elfcpp::STB_LOCAL, 2105 elfcpp::STV_HIDDEN, 0, 2106 false, false); 2107 } 2108 2109 // Define _SDA_BASE_ at the start of the .sdata section + 32768. 2110 Symbol *sdasym = symtab->lookup("_SDA_BASE_", NULL); 2111 if (sdasym != NULL && sdasym->is_undefined()) 2112 { 2113 Output_data_space* sdata = new Output_data_space(4, "** sdata"); 2114 Output_section* os 2115 = layout->add_output_section_data(".sdata", 0, 2116 elfcpp::SHF_ALLOC 2117 | elfcpp::SHF_WRITE, 2118 sdata, ORDER_SMALL_DATA, false); 2119 symtab->define_in_output_data("_SDA_BASE_", NULL, 2120 Symbol_table::PREDEFINED, 2121 os, 32768, 0, elfcpp::STT_OBJECT, 2122 elfcpp::STB_LOCAL, elfcpp::STV_HIDDEN, 2123 0, false, false); 2124 } 2125 } 2126 else 2127 { 2128 // Define .TOC. as for 32-bit _GLOBAL_OFFSET_TABLE_ 2129 Symbol *gotsym = symtab->lookup(".TOC.", NULL); 2130 if (gotsym != NULL && gotsym->is_undefined()) 2131 { 2132 Target_powerpc<size, big_endian>* target = 2133 static_cast<Target_powerpc<size, big_endian>*>( 2134 parameters->sized_target<size, big_endian>()); 2135 Output_data_got_powerpc<size, big_endian>* got 2136 = target->got_section(symtab, layout); 2137 symtab->define_in_output_data(".TOC.", NULL, 2138 Symbol_table::PREDEFINED, 2139 got, 0x8000, 0, 2140 elfcpp::STT_OBJECT, 2141 elfcpp::STB_LOCAL, 2142 elfcpp::STV_HIDDEN, 0, 2143 false, false); 2144 } 2145 } 2146 } 2147 2148 // Set up PowerPC target specific relobj. 2149 2150 template<int size, bool big_endian> 2151 Object* 2152 Target_powerpc<size, big_endian>::do_make_elf_object( 2153 const std::string& name, 2154 Input_file* input_file, 2155 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr) 2156 { 2157 int et = ehdr.get_e_type(); 2158 // ET_EXEC files are valid input for --just-symbols/-R, 2159 // and we treat them as relocatable objects. 2160 if (et == elfcpp::ET_REL 2161 || (et == elfcpp::ET_EXEC && input_file->just_symbols())) 2162 { 2163 Powerpc_relobj<size, big_endian>* obj = 2164 new Powerpc_relobj<size, big_endian>(name, input_file, offset, ehdr); 2165 obj->setup(); 2166 return obj; 2167 } 2168 else if (et == elfcpp::ET_DYN) 2169 { 2170 Powerpc_dynobj<size, big_endian>* obj = 2171 new Powerpc_dynobj<size, big_endian>(name, input_file, offset, ehdr); 2172 obj->setup(); 2173 return obj; 2174 } 2175 else 2176 { 2177 gold_error(_("%s: unsupported ELF file type %d"), name.c_str(), et); 2178 return NULL; 2179 } 2180 } 2181 2182 template<int size, bool big_endian> 2183 class Output_data_got_powerpc : public Output_data_got<size, big_endian> 2184 { 2185 public: 2186 typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype; 2187 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Rela_dyn; 2188 2189 Output_data_got_powerpc(Symbol_table* symtab, Layout* layout) 2190 : Output_data_got<size, big_endian>(), 2191 symtab_(symtab), layout_(layout), 2192 header_ent_cnt_(size == 32 ? 3 : 1), 2193 header_index_(size == 32 ? 0x2000 : 0) 2194 { 2195 if (size == 64) 2196 this->set_addralign(256); 2197 } 2198 2199 // Override all the Output_data_got methods we use so as to first call 2200 // reserve_ent(). 2201 bool 2202 add_global(Symbol* gsym, unsigned int got_type) 2203 { 2204 this->reserve_ent(); 2205 return Output_data_got<size, big_endian>::add_global(gsym, got_type); 2206 } 2207 2208 bool 2209 add_global_plt(Symbol* gsym, unsigned int got_type) 2210 { 2211 this->reserve_ent(); 2212 return Output_data_got<size, big_endian>::add_global_plt(gsym, got_type); 2213 } 2214 2215 bool 2216 add_global_tls(Symbol* gsym, unsigned int got_type) 2217 { return this->add_global_plt(gsym, got_type); } 2218 2219 void 2220 add_global_with_rel(Symbol* gsym, unsigned int got_type, 2221 Output_data_reloc_generic* rel_dyn, unsigned int r_type) 2222 { 2223 this->reserve_ent(); 2224 Output_data_got<size, big_endian>:: 2225 add_global_with_rel(gsym, got_type, rel_dyn, r_type); 2226 } 2227 2228 void 2229 add_global_pair_with_rel(Symbol* gsym, unsigned int got_type, 2230 Output_data_reloc_generic* rel_dyn, 2231 unsigned int r_type_1, unsigned int r_type_2) 2232 { 2233 this->reserve_ent(2); 2234 Output_data_got<size, big_endian>:: 2235 add_global_pair_with_rel(gsym, got_type, rel_dyn, r_type_1, r_type_2); 2236 } 2237 2238 bool 2239 add_local(Relobj* object, unsigned int sym_index, unsigned int got_type) 2240 { 2241 this->reserve_ent(); 2242 return Output_data_got<size, big_endian>::add_local(object, sym_index, 2243 got_type); 2244 } 2245 2246 bool 2247 add_local_plt(Relobj* object, unsigned int sym_index, unsigned int got_type) 2248 { 2249 this->reserve_ent(); 2250 return Output_data_got<size, big_endian>::add_local_plt(object, sym_index, 2251 got_type); 2252 } 2253 2254 bool 2255 add_local_tls(Relobj* object, unsigned int sym_index, unsigned int got_type) 2256 { return this->add_local_plt(object, sym_index, got_type); } 2257 2258 void 2259 add_local_tls_pair(Relobj* object, unsigned int sym_index, 2260 unsigned int got_type, 2261 Output_data_reloc_generic* rel_dyn, 2262 unsigned int r_type) 2263 { 2264 this->reserve_ent(2); 2265 Output_data_got<size, big_endian>:: 2266 add_local_tls_pair(object, sym_index, got_type, rel_dyn, r_type); 2267 } 2268 2269 unsigned int 2270 add_constant(Valtype constant) 2271 { 2272 this->reserve_ent(); 2273 return Output_data_got<size, big_endian>::add_constant(constant); 2274 } 2275 2276 unsigned int 2277 add_constant_pair(Valtype c1, Valtype c2) 2278 { 2279 this->reserve_ent(2); 2280 return Output_data_got<size, big_endian>::add_constant_pair(c1, c2); 2281 } 2282 2283 // Offset of _GLOBAL_OFFSET_TABLE_. 2284 unsigned int 2285 g_o_t() const 2286 { 2287 return this->got_offset(this->header_index_); 2288 } 2289 2290 // Offset of base used to access the GOT/TOC. 2291 // The got/toc pointer reg will be set to this value. 2292 Valtype 2293 got_base_offset(const Powerpc_relobj<size, big_endian>* object) const 2294 { 2295 if (size == 32) 2296 return this->g_o_t(); 2297 else 2298 return (this->output_section()->address() 2299 + object->toc_base_offset() 2300 - this->address()); 2301 } 2302 2303 // Ensure our GOT has a header. 2304 void 2305 set_final_data_size() 2306 { 2307 if (this->header_ent_cnt_ != 0) 2308 this->make_header(); 2309 Output_data_got<size, big_endian>::set_final_data_size(); 2310 } 2311 2312 // First word of GOT header needs some values that are not 2313 // handled by Output_data_got so poke them in here. 2314 // For 32-bit, address of .dynamic, for 64-bit, address of TOCbase. 2315 void 2316 do_write(Output_file* of) 2317 { 2318 Valtype val = 0; 2319 if (size == 32 && this->layout_->dynamic_data() != NULL) 2320 val = this->layout_->dynamic_section()->address(); 2321 if (size == 64) 2322 val = this->output_section()->address() + 0x8000; 2323 this->replace_constant(this->header_index_, val); 2324 Output_data_got<size, big_endian>::do_write(of); 2325 } 2326 2327 private: 2328 void 2329 reserve_ent(unsigned int cnt = 1) 2330 { 2331 if (this->header_ent_cnt_ == 0) 2332 return; 2333 if (this->num_entries() + cnt > this->header_index_) 2334 this->make_header(); 2335 } 2336 2337 void 2338 make_header() 2339 { 2340 this->header_ent_cnt_ = 0; 2341 this->header_index_ = this->num_entries(); 2342 if (size == 32) 2343 { 2344 Output_data_got<size, big_endian>::add_constant(0); 2345 Output_data_got<size, big_endian>::add_constant(0); 2346 Output_data_got<size, big_endian>::add_constant(0); 2347 2348 // Define _GLOBAL_OFFSET_TABLE_ at the header 2349 Symbol *gotsym = this->symtab_->lookup("_GLOBAL_OFFSET_TABLE_", NULL); 2350 if (gotsym != NULL) 2351 { 2352 Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(gotsym); 2353 sym->set_value(this->g_o_t()); 2354 } 2355 else 2356 this->symtab_->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 2357 Symbol_table::PREDEFINED, 2358 this, this->g_o_t(), 0, 2359 elfcpp::STT_OBJECT, 2360 elfcpp::STB_LOCAL, 2361 elfcpp::STV_HIDDEN, 0, 2362 false, false); 2363 } 2364 else 2365 Output_data_got<size, big_endian>::add_constant(0); 2366 } 2367 2368 // Stashed pointers. 2369 Symbol_table* symtab_; 2370 Layout* layout_; 2371 2372 // GOT header size. 2373 unsigned int header_ent_cnt_; 2374 // GOT header index. 2375 unsigned int header_index_; 2376 }; 2377 2378 // Get the GOT section, creating it if necessary. 2379 2380 template<int size, bool big_endian> 2381 Output_data_got_powerpc<size, big_endian>* 2382 Target_powerpc<size, big_endian>::got_section(Symbol_table* symtab, 2383 Layout* layout) 2384 { 2385 if (this->got_ == NULL) 2386 { 2387 gold_assert(symtab != NULL && layout != NULL); 2388 2389 this->got_ 2390 = new Output_data_got_powerpc<size, big_endian>(symtab, layout); 2391 2392 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 2393 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 2394 this->got_, ORDER_DATA, false); 2395 } 2396 2397 return this->got_; 2398 } 2399 2400 // Get the dynamic reloc section, creating it if necessary. 2401 2402 template<int size, bool big_endian> 2403 typename Target_powerpc<size, big_endian>::Reloc_section* 2404 Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout) 2405 { 2406 if (this->rela_dyn_ == NULL) 2407 { 2408 gold_assert(layout != NULL); 2409 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc()); 2410 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA, 2411 elfcpp::SHF_ALLOC, this->rela_dyn_, 2412 ORDER_DYNAMIC_RELOCS, false); 2413 } 2414 return this->rela_dyn_; 2415 } 2416 2417 // Similarly, but for ifunc symbols get the one for ifunc. 2418 2419 template<int size, bool big_endian> 2420 typename Target_powerpc<size, big_endian>::Reloc_section* 2421 Target_powerpc<size, big_endian>::rela_dyn_section(Symbol_table* symtab, 2422 Layout* layout, 2423 bool for_ifunc) 2424 { 2425 if (!for_ifunc) 2426 return this->rela_dyn_section(layout); 2427 2428 if (this->iplt_ == NULL) 2429 this->make_iplt_section(symtab, layout); 2430 return this->iplt_->rel_plt(); 2431 } 2432 2433 class Stub_control 2434 { 2435 public: 2436 // Determine the stub group size. The group size is the absolute 2437 // value of the parameter --stub-group-size. If --stub-group-size 2438 // is passed a negative value, we restrict stubs to be always before 2439 // the stubbed branches. 2440 Stub_control(int32_t size, bool no_size_errors) 2441 : state_(NO_GROUP), stub_group_size_(abs(size)), 2442 stub14_group_size_(abs(size) >> 10), 2443 stubs_always_before_branch_(size < 0), 2444 suppress_size_errors_(no_size_errors), 2445 group_end_addr_(0), owner_(NULL), output_section_(NULL) 2446 { 2447 } 2448 2449 // Return true iff input section can be handled by current stub 2450 // group. 2451 bool 2452 can_add_to_stub_group(Output_section* o, 2453 const Output_section::Input_section* i, 2454 bool has14); 2455 2456 const Output_section::Input_section* 2457 owner() 2458 { return owner_; } 2459 2460 Output_section* 2461 output_section() 2462 { return output_section_; } 2463 2464 void 2465 set_output_and_owner(Output_section* o, 2466 const Output_section::Input_section* i) 2467 { 2468 this->output_section_ = o; 2469 this->owner_ = i; 2470 } 2471 2472 private: 2473 typedef enum 2474 { 2475 NO_GROUP, 2476 FINDING_STUB_SECTION, 2477 HAS_STUB_SECTION 2478 } State; 2479 2480 State state_; 2481 uint32_t stub_group_size_; 2482 uint32_t stub14_group_size_; 2483 bool stubs_always_before_branch_; 2484 bool suppress_size_errors_; 2485 uint64_t group_end_addr_; 2486 const Output_section::Input_section* owner_; 2487 Output_section* output_section_; 2488 }; 2489 2490 // Return true iff input section can be handled by current stub 2491 // group. 2492 2493 bool 2494 Stub_control::can_add_to_stub_group(Output_section* o, 2495 const Output_section::Input_section* i, 2496 bool has14) 2497 { 2498 uint32_t group_size 2499 = has14 ? this->stub14_group_size_ : this->stub_group_size_; 2500 bool whole_sec = o->order() == ORDER_INIT || o->order() == ORDER_FINI; 2501 uint64_t this_size; 2502 uint64_t start_addr = o->address(); 2503 2504 if (whole_sec) 2505 // .init and .fini sections are pasted together to form a single 2506 // function. We can't be adding stubs in the middle of the function. 2507 this_size = o->data_size(); 2508 else 2509 { 2510 start_addr += i->relobj()->output_section_offset(i->shndx()); 2511 this_size = i->data_size(); 2512 } 2513 uint64_t end_addr = start_addr + this_size; 2514 bool toobig = this_size > group_size; 2515 2516 if (toobig && !this->suppress_size_errors_) 2517 gold_warning(_("%s:%s exceeds group size"), 2518 i->relobj()->name().c_str(), 2519 i->relobj()->section_name(i->shndx()).c_str()); 2520 2521 if (this->state_ != HAS_STUB_SECTION 2522 && (!whole_sec || this->output_section_ != o) 2523 && (this->state_ == NO_GROUP 2524 || this->group_end_addr_ - end_addr < group_size)) 2525 { 2526 this->owner_ = i; 2527 this->output_section_ = o; 2528 } 2529 2530 if (this->state_ == NO_GROUP) 2531 { 2532 this->state_ = FINDING_STUB_SECTION; 2533 this->group_end_addr_ = end_addr; 2534 } 2535 else if (this->group_end_addr_ - start_addr < group_size) 2536 ; 2537 // Adding this section would make the group larger than GROUP_SIZE. 2538 else if (this->state_ == FINDING_STUB_SECTION 2539 && !this->stubs_always_before_branch_ 2540 && !toobig) 2541 { 2542 // But wait, there's more! Input sections up to GROUP_SIZE 2543 // bytes before the stub table can be handled by it too. 2544 this->state_ = HAS_STUB_SECTION; 2545 this->group_end_addr_ = end_addr; 2546 } 2547 else 2548 { 2549 this->state_ = NO_GROUP; 2550 return false; 2551 } 2552 return true; 2553 } 2554 2555 // Look over all the input sections, deciding where to place stubs. 2556 2557 template<int size, bool big_endian> 2558 void 2559 Target_powerpc<size, big_endian>::group_sections(Layout* layout, 2560 const Task*, 2561 bool no_size_errors) 2562 { 2563 Stub_control stub_control(this->stub_group_size_, no_size_errors); 2564 2565 // Group input sections and insert stub table 2566 Stub_table_owner* table_owner = NULL; 2567 std::vector<Stub_table_owner*> tables; 2568 Layout::Section_list section_list; 2569 layout->get_executable_sections(§ion_list); 2570 std::stable_sort(section_list.begin(), section_list.end(), Sort_sections()); 2571 for (Layout::Section_list::reverse_iterator o = section_list.rbegin(); 2572 o != section_list.rend(); 2573 ++o) 2574 { 2575 typedef Output_section::Input_section_list Input_section_list; 2576 for (Input_section_list::const_reverse_iterator i 2577 = (*o)->input_sections().rbegin(); 2578 i != (*o)->input_sections().rend(); 2579 ++i) 2580 { 2581 if (i->is_input_section() 2582 || i->is_relaxed_input_section()) 2583 { 2584 Powerpc_relobj<size, big_endian>* ppcobj = static_cast 2585 <Powerpc_relobj<size, big_endian>*>(i->relobj()); 2586 bool has14 = ppcobj->has_14bit_branch(i->shndx()); 2587 if (!stub_control.can_add_to_stub_group(*o, &*i, has14)) 2588 { 2589 table_owner->output_section = stub_control.output_section(); 2590 table_owner->owner = stub_control.owner(); 2591 stub_control.set_output_and_owner(*o, &*i); 2592 table_owner = NULL; 2593 } 2594 if (table_owner == NULL) 2595 { 2596 table_owner = new Stub_table_owner; 2597 tables.push_back(table_owner); 2598 } 2599 ppcobj->set_stub_table(i->shndx(), tables.size() - 1); 2600 } 2601 } 2602 } 2603 if (table_owner != NULL) 2604 { 2605 const Output_section::Input_section* i = stub_control.owner(); 2606 2607 if (tables.size() >= 2 && tables[tables.size() - 2]->owner == i) 2608 { 2609 // Corner case. A new stub group was made for the first 2610 // section (last one looked at here) for some reason, but 2611 // the first section is already being used as the owner for 2612 // a stub table for following sections. Force it into that 2613 // stub group. 2614 tables.pop_back(); 2615 delete table_owner; 2616 Powerpc_relobj<size, big_endian>* ppcobj = static_cast 2617 <Powerpc_relobj<size, big_endian>*>(i->relobj()); 2618 ppcobj->set_stub_table(i->shndx(), tables.size() - 1); 2619 } 2620 else 2621 { 2622 table_owner->output_section = stub_control.output_section(); 2623 table_owner->owner = i; 2624 } 2625 } 2626 for (typename std::vector<Stub_table_owner*>::iterator t = tables.begin(); 2627 t != tables.end(); 2628 ++t) 2629 { 2630 Stub_table<size, big_endian>* stub_table; 2631 2632 if ((*t)->owner->is_input_section()) 2633 stub_table = new Stub_table<size, big_endian>(this, 2634 (*t)->output_section, 2635 (*t)->owner); 2636 else if ((*t)->owner->is_relaxed_input_section()) 2637 stub_table = static_cast<Stub_table<size, big_endian>*>( 2638 (*t)->owner->relaxed_input_section()); 2639 else 2640 gold_unreachable(); 2641 this->stub_tables_.push_back(stub_table); 2642 delete *t; 2643 } 2644 } 2645 2646 static unsigned long 2647 max_branch_delta (unsigned int r_type) 2648 { 2649 if (r_type == elfcpp::R_POWERPC_REL14 2650 || r_type == elfcpp::R_POWERPC_REL14_BRTAKEN 2651 || r_type == elfcpp::R_POWERPC_REL14_BRNTAKEN) 2652 return 1L << 15; 2653 if (r_type == elfcpp::R_POWERPC_REL24 2654 || r_type == elfcpp::R_PPC_PLTREL24 2655 || r_type == elfcpp::R_PPC_LOCAL24PC) 2656 return 1L << 25; 2657 return 0; 2658 } 2659 2660 // If this branch needs a plt call stub, or a long branch stub, make one. 2661 2662 template<int size, bool big_endian> 2663 bool 2664 Target_powerpc<size, big_endian>::Branch_info::make_stub( 2665 Stub_table<size, big_endian>* stub_table, 2666 Stub_table<size, big_endian>* ifunc_stub_table, 2667 Symbol_table* symtab) const 2668 { 2669 Symbol* sym = this->object_->global_symbol(this->r_sym_); 2670 if (sym != NULL && sym->is_forwarder()) 2671 sym = symtab->resolve_forwards(sym); 2672 const Sized_symbol<size>* gsym = static_cast<const Sized_symbol<size>*>(sym); 2673 Target_powerpc<size, big_endian>* target = 2674 static_cast<Target_powerpc<size, big_endian>*>( 2675 parameters->sized_target<size, big_endian>()); 2676 if (gsym != NULL 2677 ? gsym->use_plt_offset(Scan::get_reference_flags(this->r_type_, target)) 2678 : this->object_->local_has_plt_offset(this->r_sym_)) 2679 { 2680 if (size == 64 2681 && gsym != NULL 2682 && target->abiversion() >= 2 2683 && !parameters->options().output_is_position_independent() 2684 && !is_branch_reloc(this->r_type_)) 2685 target->glink_section()->add_global_entry(gsym); 2686 else 2687 { 2688 if (stub_table == NULL) 2689 stub_table = this->object_->stub_table(this->shndx_); 2690 if (stub_table == NULL) 2691 { 2692 // This is a ref from a data section to an ifunc symbol. 2693 stub_table = ifunc_stub_table; 2694 } 2695 gold_assert(stub_table != NULL); 2696 Address from = this->object_->get_output_section_offset(this->shndx_); 2697 if (from != invalid_address) 2698 from += (this->object_->output_section(this->shndx_)->address() 2699 + this->offset_); 2700 if (gsym != NULL) 2701 return stub_table->add_plt_call_entry(from, 2702 this->object_, gsym, 2703 this->r_type_, this->addend_); 2704 else 2705 return stub_table->add_plt_call_entry(from, 2706 this->object_, this->r_sym_, 2707 this->r_type_, this->addend_); 2708 } 2709 } 2710 else 2711 { 2712 Address max_branch_offset = max_branch_delta(this->r_type_); 2713 if (max_branch_offset == 0) 2714 return true; 2715 Address from = this->object_->get_output_section_offset(this->shndx_); 2716 gold_assert(from != invalid_address); 2717 from += (this->object_->output_section(this->shndx_)->address() 2718 + this->offset_); 2719 Address to; 2720 if (gsym != NULL) 2721 { 2722 switch (gsym->source()) 2723 { 2724 case Symbol::FROM_OBJECT: 2725 { 2726 Object* symobj = gsym->object(); 2727 if (symobj->is_dynamic() 2728 || symobj->pluginobj() != NULL) 2729 return true; 2730 bool is_ordinary; 2731 unsigned int shndx = gsym->shndx(&is_ordinary); 2732 if (shndx == elfcpp::SHN_UNDEF) 2733 return true; 2734 } 2735 break; 2736 2737 case Symbol::IS_UNDEFINED: 2738 return true; 2739 2740 default: 2741 break; 2742 } 2743 Symbol_table::Compute_final_value_status status; 2744 to = symtab->compute_final_value<size>(gsym, &status); 2745 if (status != Symbol_table::CFVS_OK) 2746 return true; 2747 if (size == 64) 2748 to += this->object_->ppc64_local_entry_offset(gsym); 2749 } 2750 else 2751 { 2752 const Symbol_value<size>* psymval 2753 = this->object_->local_symbol(this->r_sym_); 2754 Symbol_value<size> symval; 2755 typedef Sized_relobj_file<size, big_endian> ObjType; 2756 typename ObjType::Compute_final_local_value_status status 2757 = this->object_->compute_final_local_value(this->r_sym_, psymval, 2758 &symval, symtab); 2759 if (status != ObjType::CFLV_OK 2760 || !symval.has_output_value()) 2761 return true; 2762 to = symval.value(this->object_, 0); 2763 if (size == 64) 2764 to += this->object_->ppc64_local_entry_offset(this->r_sym_); 2765 } 2766 if (!(size == 32 && this->r_type_ == elfcpp::R_PPC_PLTREL24)) 2767 to += this->addend_; 2768 if (stub_table == NULL) 2769 stub_table = this->object_->stub_table(this->shndx_); 2770 if (size == 64 && target->abiversion() < 2) 2771 { 2772 unsigned int dest_shndx; 2773 if (!target->symval_for_branch(symtab, gsym, this->object_, 2774 &to, &dest_shndx)) 2775 return true; 2776 } 2777 Address delta = to - from; 2778 if (delta + max_branch_offset >= 2 * max_branch_offset) 2779 { 2780 if (stub_table == NULL) 2781 { 2782 gold_warning(_("%s:%s: branch in non-executable section," 2783 " no long branch stub for you"), 2784 this->object_->name().c_str(), 2785 this->object_->section_name(this->shndx_).c_str()); 2786 return true; 2787 } 2788 bool save_res = (size == 64 2789 && gsym != NULL 2790 && gsym->source() == Symbol::IN_OUTPUT_DATA 2791 && gsym->output_data() == target->savres_section()); 2792 return stub_table->add_long_branch_entry(this->object_, 2793 this->r_type_, 2794 from, to, save_res); 2795 } 2796 } 2797 return true; 2798 } 2799 2800 // Relaxation hook. This is where we do stub generation. 2801 2802 template<int size, bool big_endian> 2803 bool 2804 Target_powerpc<size, big_endian>::do_relax(int pass, 2805 const Input_objects*, 2806 Symbol_table* symtab, 2807 Layout* layout, 2808 const Task* task) 2809 { 2810 unsigned int prev_brlt_size = 0; 2811 if (pass == 1) 2812 { 2813 bool thread_safe 2814 = this->abiversion() < 2 && parameters->options().plt_thread_safe(); 2815 if (size == 64 2816 && this->abiversion() < 2 2817 && !thread_safe 2818 && !parameters->options().user_set_plt_thread_safe()) 2819 { 2820 static const char* const thread_starter[] = 2821 { 2822 "pthread_create", 2823 /* libstdc++ */ 2824 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE", 2825 /* librt */ 2826 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio", 2827 "mq_notify", "create_timer", 2828 /* libanl */ 2829 "getaddrinfo_a", 2830 /* libgomp */ 2831 "GOMP_parallel", 2832 "GOMP_parallel_start", 2833 "GOMP_parallel_loop_static", 2834 "GOMP_parallel_loop_static_start", 2835 "GOMP_parallel_loop_dynamic", 2836 "GOMP_parallel_loop_dynamic_start", 2837 "GOMP_parallel_loop_guided", 2838 "GOMP_parallel_loop_guided_start", 2839 "GOMP_parallel_loop_runtime", 2840 "GOMP_parallel_loop_runtime_start", 2841 "GOMP_parallel_sections", 2842 "GOMP_parallel_sections_start", 2843 /* libgo */ 2844 "__go_go", 2845 }; 2846 2847 if (parameters->options().shared()) 2848 thread_safe = true; 2849 else 2850 { 2851 for (unsigned int i = 0; 2852 i < sizeof(thread_starter) / sizeof(thread_starter[0]); 2853 i++) 2854 { 2855 Symbol* sym = symtab->lookup(thread_starter[i], NULL); 2856 thread_safe = (sym != NULL 2857 && sym->in_reg() 2858 && sym->in_real_elf()); 2859 if (thread_safe) 2860 break; 2861 } 2862 } 2863 } 2864 this->plt_thread_safe_ = thread_safe; 2865 } 2866 2867 if (pass == 1) 2868 { 2869 this->stub_group_size_ = parameters->options().stub_group_size(); 2870 bool no_size_errors = true; 2871 if (this->stub_group_size_ == 1) 2872 this->stub_group_size_ = 0x1c00000; 2873 else if (this->stub_group_size_ == -1) 2874 this->stub_group_size_ = -0x1e00000; 2875 else 2876 no_size_errors = false; 2877 this->group_sections(layout, task, no_size_errors); 2878 } 2879 else if (this->relax_failed_ && this->relax_fail_count_ < 3) 2880 { 2881 this->branch_lookup_table_.clear(); 2882 for (typename Stub_tables::iterator p = this->stub_tables_.begin(); 2883 p != this->stub_tables_.end(); 2884 ++p) 2885 { 2886 (*p)->clear_stubs(true); 2887 } 2888 this->stub_tables_.clear(); 2889 this->stub_group_size_ = this->stub_group_size_ / 4 * 3; 2890 gold_info(_("%s: stub group size is too large; retrying with %d"), 2891 program_name, this->stub_group_size_); 2892 this->group_sections(layout, task, true); 2893 } 2894 2895 // We need address of stub tables valid for make_stub. 2896 for (typename Stub_tables::iterator p = this->stub_tables_.begin(); 2897 p != this->stub_tables_.end(); 2898 ++p) 2899 { 2900 const Powerpc_relobj<size, big_endian>* object 2901 = static_cast<const Powerpc_relobj<size, big_endian>*>((*p)->relobj()); 2902 Address off = object->get_output_section_offset((*p)->shndx()); 2903 gold_assert(off != invalid_address); 2904 Output_section* os = (*p)->output_section(); 2905 (*p)->set_address_and_size(os, off); 2906 } 2907 2908 if (pass != 1) 2909 { 2910 // Clear plt call stubs, long branch stubs and branch lookup table. 2911 prev_brlt_size = this->branch_lookup_table_.size(); 2912 this->branch_lookup_table_.clear(); 2913 for (typename Stub_tables::iterator p = this->stub_tables_.begin(); 2914 p != this->stub_tables_.end(); 2915 ++p) 2916 { 2917 (*p)->clear_stubs(false); 2918 } 2919 } 2920 2921 // Build all the stubs. 2922 this->relax_failed_ = false; 2923 Stub_table<size, big_endian>* ifunc_stub_table 2924 = this->stub_tables_.size() == 0 ? NULL : this->stub_tables_[0]; 2925 Stub_table<size, big_endian>* one_stub_table 2926 = this->stub_tables_.size() != 1 ? NULL : ifunc_stub_table; 2927 for (typename Branches::const_iterator b = this->branch_info_.begin(); 2928 b != this->branch_info_.end(); 2929 b++) 2930 { 2931 if (!b->make_stub(one_stub_table, ifunc_stub_table, symtab) 2932 && !this->relax_failed_) 2933 { 2934 this->relax_failed_ = true; 2935 this->relax_fail_count_++; 2936 if (this->relax_fail_count_ < 3) 2937 return true; 2938 } 2939 } 2940 2941 // Did anything change size? 2942 unsigned int num_huge_branches = this->branch_lookup_table_.size(); 2943 bool again = num_huge_branches != prev_brlt_size; 2944 if (size == 64 && num_huge_branches != 0) 2945 this->make_brlt_section(layout); 2946 if (size == 64 && again) 2947 this->brlt_section_->set_current_size(num_huge_branches); 2948 2949 typedef Unordered_set<Output_section*> Output_sections; 2950 Output_sections os_need_update; 2951 for (typename Stub_tables::iterator p = this->stub_tables_.begin(); 2952 p != this->stub_tables_.end(); 2953 ++p) 2954 { 2955 if ((*p)->size_update()) 2956 { 2957 again = true; 2958 (*p)->add_eh_frame(layout); 2959 os_need_update.insert((*p)->output_section()); 2960 } 2961 } 2962 2963 // Set output section offsets for all input sections in an output 2964 // section that just changed size. Anything past the stubs will 2965 // need updating. 2966 for (typename Output_sections::iterator p = os_need_update.begin(); 2967 p != os_need_update.end(); 2968 p++) 2969 { 2970 Output_section* os = *p; 2971 Address off = 0; 2972 typedef Output_section::Input_section_list Input_section_list; 2973 for (Input_section_list::const_iterator i = os->input_sections().begin(); 2974 i != os->input_sections().end(); 2975 ++i) 2976 { 2977 off = align_address(off, i->addralign()); 2978 if (i->is_input_section() || i->is_relaxed_input_section()) 2979 i->relobj()->set_section_offset(i->shndx(), off); 2980 if (i->is_relaxed_input_section()) 2981 { 2982 Stub_table<size, big_endian>* stub_table 2983 = static_cast<Stub_table<size, big_endian>*>( 2984 i->relaxed_input_section()); 2985 off += stub_table->set_address_and_size(os, off); 2986 } 2987 else 2988 off += i->data_size(); 2989 } 2990 // If .branch_lt is part of this output section, then we have 2991 // just done the offset adjustment. 2992 os->clear_section_offsets_need_adjustment(); 2993 } 2994 2995 if (size == 64 2996 && !again 2997 && num_huge_branches != 0 2998 && parameters->options().output_is_position_independent()) 2999 { 3000 // Fill in the BRLT relocs. 3001 this->brlt_section_->reset_brlt_sizes(); 3002 for (typename Branch_lookup_table::const_iterator p 3003 = this->branch_lookup_table_.begin(); 3004 p != this->branch_lookup_table_.end(); 3005 ++p) 3006 { 3007 this->brlt_section_->add_reloc(p->first, p->second); 3008 } 3009 this->brlt_section_->finalize_brlt_sizes(); 3010 } 3011 return again; 3012 } 3013 3014 template<int size, bool big_endian> 3015 void 3016 Target_powerpc<size, big_endian>::do_plt_fde_location(const Output_data* plt, 3017 unsigned char* oview, 3018 uint64_t* paddress, 3019 off_t* plen) const 3020 { 3021 uint64_t address = plt->address(); 3022 off_t len = plt->data_size(); 3023 3024 if (plt == this->glink_) 3025 { 3026 // See Output_data_glink::do_write() for glink contents. 3027 if (len == 0) 3028 { 3029 gold_assert(parameters->doing_static_link()); 3030 // Static linking may need stubs, to support ifunc and long 3031 // branches. We need to create an output section for 3032 // .eh_frame early in the link process, to have a place to 3033 // attach stub .eh_frame info. We also need to have 3034 // registered a CIE that matches the stub CIE. Both of 3035 // these requirements are satisfied by creating an FDE and 3036 // CIE for .glink, even though static linking will leave 3037 // .glink zero length. 3038 // ??? Hopefully generating an FDE with a zero address range 3039 // won't confuse anything that consumes .eh_frame info. 3040 } 3041 else if (size == 64) 3042 { 3043 // There is one word before __glink_PLTresolve 3044 address += 8; 3045 len -= 8; 3046 } 3047 else if (parameters->options().output_is_position_independent()) 3048 { 3049 // There are two FDEs for a position independent glink. 3050 // The first covers the branch table, the second 3051 // __glink_PLTresolve at the end of glink. 3052 off_t resolve_size = this->glink_->pltresolve_size; 3053 if (oview[9] == elfcpp::DW_CFA_nop) 3054 len -= resolve_size; 3055 else 3056 { 3057 address += len - resolve_size; 3058 len = resolve_size; 3059 } 3060 } 3061 } 3062 else 3063 { 3064 // Must be a stub table. 3065 const Stub_table<size, big_endian>* stub_table 3066 = static_cast<const Stub_table<size, big_endian>*>(plt); 3067 uint64_t stub_address = stub_table->stub_address(); 3068 len -= stub_address - address; 3069 address = stub_address; 3070 } 3071 3072 *paddress = address; 3073 *plen = len; 3074 } 3075 3076 // A class to handle the PLT data. 3077 3078 template<int size, bool big_endian> 3079 class Output_data_plt_powerpc : public Output_section_data_build 3080 { 3081 public: 3082 typedef Output_data_reloc<elfcpp::SHT_RELA, true, 3083 size, big_endian> Reloc_section; 3084 3085 Output_data_plt_powerpc(Target_powerpc<size, big_endian>* targ, 3086 Reloc_section* plt_rel, 3087 const char* name) 3088 : Output_section_data_build(size == 32 ? 4 : 8), 3089 rel_(plt_rel), 3090 targ_(targ), 3091 name_(name) 3092 { } 3093 3094 // Add an entry to the PLT. 3095 void 3096 add_entry(Symbol*); 3097 3098 void 3099 add_ifunc_entry(Symbol*); 3100 3101 void 3102 add_local_ifunc_entry(Sized_relobj_file<size, big_endian>*, unsigned int); 3103 3104 // Return the .rela.plt section data. 3105 Reloc_section* 3106 rel_plt() const 3107 { 3108 return this->rel_; 3109 } 3110 3111 // Return the number of PLT entries. 3112 unsigned int 3113 entry_count() const 3114 { 3115 if (this->current_data_size() == 0) 3116 return 0; 3117 return ((this->current_data_size() - this->first_plt_entry_offset()) 3118 / this->plt_entry_size()); 3119 } 3120 3121 protected: 3122 void 3123 do_adjust_output_section(Output_section* os) 3124 { 3125 os->set_entsize(0); 3126 } 3127 3128 // Write to a map file. 3129 void 3130 do_print_to_mapfile(Mapfile* mapfile) const 3131 { mapfile->print_output_data(this, this->name_); } 3132 3133 private: 3134 // Return the offset of the first non-reserved PLT entry. 3135 unsigned int 3136 first_plt_entry_offset() const 3137 { 3138 // IPLT has no reserved entry. 3139 if (this->name_[3] == 'I') 3140 return 0; 3141 return this->targ_->first_plt_entry_offset(); 3142 } 3143 3144 // Return the size of each PLT entry. 3145 unsigned int 3146 plt_entry_size() const 3147 { 3148 return this->targ_->plt_entry_size(); 3149 } 3150 3151 // Write out the PLT data. 3152 void 3153 do_write(Output_file*); 3154 3155 // The reloc section. 3156 Reloc_section* rel_; 3157 // Allows access to .glink for do_write. 3158 Target_powerpc<size, big_endian>* targ_; 3159 // What to report in map file. 3160 const char *name_; 3161 }; 3162 3163 // Add an entry to the PLT. 3164 3165 template<int size, bool big_endian> 3166 void 3167 Output_data_plt_powerpc<size, big_endian>::add_entry(Symbol* gsym) 3168 { 3169 if (!gsym->has_plt_offset()) 3170 { 3171 section_size_type off = this->current_data_size(); 3172 if (off == 0) 3173 off += this->first_plt_entry_offset(); 3174 gsym->set_plt_offset(off); 3175 gsym->set_needs_dynsym_entry(); 3176 unsigned int dynrel = elfcpp::R_POWERPC_JMP_SLOT; 3177 this->rel_->add_global(gsym, dynrel, this, off, 0); 3178 off += this->plt_entry_size(); 3179 this->set_current_data_size(off); 3180 } 3181 } 3182 3183 // Add an entry for a global ifunc symbol that resolves locally, to the IPLT. 3184 3185 template<int size, bool big_endian> 3186 void 3187 Output_data_plt_powerpc<size, big_endian>::add_ifunc_entry(Symbol* gsym) 3188 { 3189 if (!gsym->has_plt_offset()) 3190 { 3191 section_size_type off = this->current_data_size(); 3192 gsym->set_plt_offset(off); 3193 unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE; 3194 if (size == 64 && this->targ_->abiversion() < 2) 3195 dynrel = elfcpp::R_PPC64_JMP_IREL; 3196 this->rel_->add_symbolless_global_addend(gsym, dynrel, this, off, 0); 3197 off += this->plt_entry_size(); 3198 this->set_current_data_size(off); 3199 } 3200 } 3201 3202 // Add an entry for a local ifunc symbol to the IPLT. 3203 3204 template<int size, bool big_endian> 3205 void 3206 Output_data_plt_powerpc<size, big_endian>::add_local_ifunc_entry( 3207 Sized_relobj_file<size, big_endian>* relobj, 3208 unsigned int local_sym_index) 3209 { 3210 if (!relobj->local_has_plt_offset(local_sym_index)) 3211 { 3212 section_size_type off = this->current_data_size(); 3213 relobj->set_local_plt_offset(local_sym_index, off); 3214 unsigned int dynrel = elfcpp::R_POWERPC_IRELATIVE; 3215 if (size == 64 && this->targ_->abiversion() < 2) 3216 dynrel = elfcpp::R_PPC64_JMP_IREL; 3217 this->rel_->add_symbolless_local_addend(relobj, local_sym_index, dynrel, 3218 this, off, 0); 3219 off += this->plt_entry_size(); 3220 this->set_current_data_size(off); 3221 } 3222 } 3223 3224 static const uint32_t add_0_11_11 = 0x7c0b5a14; 3225 static const uint32_t add_2_2_11 = 0x7c425a14; 3226 static const uint32_t add_2_2_12 = 0x7c426214; 3227 static const uint32_t add_3_3_2 = 0x7c631214; 3228 static const uint32_t add_3_3_13 = 0x7c636a14; 3229 static const uint32_t add_11_0_11 = 0x7d605a14; 3230 static const uint32_t add_11_2_11 = 0x7d625a14; 3231 static const uint32_t add_11_11_2 = 0x7d6b1214; 3232 static const uint32_t addi_0_12 = 0x380c0000; 3233 static const uint32_t addi_2_2 = 0x38420000; 3234 static const uint32_t addi_3_3 = 0x38630000; 3235 static const uint32_t addi_11_11 = 0x396b0000; 3236 static const uint32_t addi_12_1 = 0x39810000; 3237 static const uint32_t addi_12_12 = 0x398c0000; 3238 static const uint32_t addis_0_2 = 0x3c020000; 3239 static const uint32_t addis_0_13 = 0x3c0d0000; 3240 static const uint32_t addis_2_12 = 0x3c4c0000; 3241 static const uint32_t addis_11_2 = 0x3d620000; 3242 static const uint32_t addis_11_11 = 0x3d6b0000; 3243 static const uint32_t addis_11_30 = 0x3d7e0000; 3244 static const uint32_t addis_12_1 = 0x3d810000; 3245 static const uint32_t addis_12_2 = 0x3d820000; 3246 static const uint32_t addis_12_12 = 0x3d8c0000; 3247 static const uint32_t b = 0x48000000; 3248 static const uint32_t bcl_20_31 = 0x429f0005; 3249 static const uint32_t bctr = 0x4e800420; 3250 static const uint32_t blr = 0x4e800020; 3251 static const uint32_t bnectr_p4 = 0x4ce20420; 3252 static const uint32_t cmpld_7_12_0 = 0x7fac0040; 3253 static const uint32_t cmpldi_2_0 = 0x28220000; 3254 static const uint32_t cror_15_15_15 = 0x4def7b82; 3255 static const uint32_t cror_31_31_31 = 0x4ffffb82; 3256 static const uint32_t ld_0_1 = 0xe8010000; 3257 static const uint32_t ld_0_12 = 0xe80c0000; 3258 static const uint32_t ld_2_1 = 0xe8410000; 3259 static const uint32_t ld_2_2 = 0xe8420000; 3260 static const uint32_t ld_2_11 = 0xe84b0000; 3261 static const uint32_t ld_2_12 = 0xe84c0000; 3262 static const uint32_t ld_11_2 = 0xe9620000; 3263 static const uint32_t ld_11_11 = 0xe96b0000; 3264 static const uint32_t ld_12_2 = 0xe9820000; 3265 static const uint32_t ld_12_11 = 0xe98b0000; 3266 static const uint32_t ld_12_12 = 0xe98c0000; 3267 static const uint32_t lfd_0_1 = 0xc8010000; 3268 static const uint32_t li_0_0 = 0x38000000; 3269 static const uint32_t li_12_0 = 0x39800000; 3270 static const uint32_t lis_0 = 0x3c000000; 3271 static const uint32_t lis_2 = 0x3c400000; 3272 static const uint32_t lis_11 = 0x3d600000; 3273 static const uint32_t lis_12 = 0x3d800000; 3274 static const uint32_t lvx_0_12_0 = 0x7c0c00ce; 3275 static const uint32_t lwz_0_12 = 0x800c0000; 3276 static const uint32_t lwz_11_11 = 0x816b0000; 3277 static const uint32_t lwz_11_30 = 0x817e0000; 3278 static const uint32_t lwz_12_12 = 0x818c0000; 3279 static const uint32_t lwzu_0_12 = 0x840c0000; 3280 static const uint32_t mflr_0 = 0x7c0802a6; 3281 static const uint32_t mflr_11 = 0x7d6802a6; 3282 static const uint32_t mflr_12 = 0x7d8802a6; 3283 static const uint32_t mtctr_0 = 0x7c0903a6; 3284 static const uint32_t mtctr_11 = 0x7d6903a6; 3285 static const uint32_t mtctr_12 = 0x7d8903a6; 3286 static const uint32_t mtlr_0 = 0x7c0803a6; 3287 static const uint32_t mtlr_12 = 0x7d8803a6; 3288 static const uint32_t nop = 0x60000000; 3289 static const uint32_t ori_0_0_0 = 0x60000000; 3290 static const uint32_t srdi_0_0_2 = 0x7800f082; 3291 static const uint32_t std_0_1 = 0xf8010000; 3292 static const uint32_t std_0_12 = 0xf80c0000; 3293 static const uint32_t std_2_1 = 0xf8410000; 3294 static const uint32_t stfd_0_1 = 0xd8010000; 3295 static const uint32_t stvx_0_12_0 = 0x7c0c01ce; 3296 static const uint32_t sub_11_11_12 = 0x7d6c5850; 3297 static const uint32_t sub_12_12_11 = 0x7d8b6050; 3298 static const uint32_t xor_2_12_12 = 0x7d826278; 3299 static const uint32_t xor_11_12_12 = 0x7d8b6278; 3300 3301 // Write out the PLT. 3302 3303 template<int size, bool big_endian> 3304 void 3305 Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of) 3306 { 3307 if (size == 32 && this->name_[3] != 'I') 3308 { 3309 const section_size_type offset = this->offset(); 3310 const section_size_type oview_size 3311 = convert_to_section_size_type(this->data_size()); 3312 unsigned char* const oview = of->get_output_view(offset, oview_size); 3313 unsigned char* pov = oview; 3314 unsigned char* endpov = oview + oview_size; 3315 3316 // The address of the .glink branch table 3317 const Output_data_glink<size, big_endian>* glink 3318 = this->targ_->glink_section(); 3319 elfcpp::Elf_types<32>::Elf_Addr branch_tab = glink->address(); 3320 3321 while (pov < endpov) 3322 { 3323 elfcpp::Swap<32, big_endian>::writeval(pov, branch_tab); 3324 pov += 4; 3325 branch_tab += 4; 3326 } 3327 3328 of->write_output_view(offset, oview_size, oview); 3329 } 3330 } 3331 3332 // Create the PLT section. 3333 3334 template<int size, bool big_endian> 3335 void 3336 Target_powerpc<size, big_endian>::make_plt_section(Symbol_table* symtab, 3337 Layout* layout) 3338 { 3339 if (this->plt_ == NULL) 3340 { 3341 if (this->got_ == NULL) 3342 this->got_section(symtab, layout); 3343 3344 if (this->glink_ == NULL) 3345 make_glink_section(layout); 3346 3347 // Ensure that .rela.dyn always appears before .rela.plt This is 3348 // necessary due to how, on PowerPC and some other targets, .rela.dyn 3349 // needs to include .rela.plt in its range. 3350 this->rela_dyn_section(layout); 3351 3352 Reloc_section* plt_rel = new Reloc_section(false); 3353 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 3354 elfcpp::SHF_ALLOC, plt_rel, 3355 ORDER_DYNAMIC_PLT_RELOCS, false); 3356 this->plt_ 3357 = new Output_data_plt_powerpc<size, big_endian>(this, plt_rel, 3358 "** PLT"); 3359 layout->add_output_section_data(".plt", 3360 (size == 32 3361 ? elfcpp::SHT_PROGBITS 3362 : elfcpp::SHT_NOBITS), 3363 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 3364 this->plt_, 3365 (size == 32 3366 ? ORDER_SMALL_DATA 3367 : ORDER_SMALL_BSS), 3368 false); 3369 } 3370 } 3371 3372 // Create the IPLT section. 3373 3374 template<int size, bool big_endian> 3375 void 3376 Target_powerpc<size, big_endian>::make_iplt_section(Symbol_table* symtab, 3377 Layout* layout) 3378 { 3379 if (this->iplt_ == NULL) 3380 { 3381 this->make_plt_section(symtab, layout); 3382 3383 Reloc_section* iplt_rel = new Reloc_section(false); 3384 this->rela_dyn_->output_section()->add_output_section_data(iplt_rel); 3385 this->iplt_ 3386 = new Output_data_plt_powerpc<size, big_endian>(this, iplt_rel, 3387 "** IPLT"); 3388 this->plt_->output_section()->add_output_section_data(this->iplt_); 3389 } 3390 } 3391 3392 // A section for huge long branch addresses, similar to plt section. 3393 3394 template<int size, bool big_endian> 3395 class Output_data_brlt_powerpc : public Output_section_data_build 3396 { 3397 public: 3398 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 3399 typedef Output_data_reloc<elfcpp::SHT_RELA, true, 3400 size, big_endian> Reloc_section; 3401 3402 Output_data_brlt_powerpc(Target_powerpc<size, big_endian>* targ, 3403 Reloc_section* brlt_rel) 3404 : Output_section_data_build(size == 32 ? 4 : 8), 3405 rel_(brlt_rel), 3406 targ_(targ) 3407 { } 3408 3409 void 3410 reset_brlt_sizes() 3411 { 3412 this->reset_data_size(); 3413 this->rel_->reset_data_size(); 3414 } 3415 3416 void 3417 finalize_brlt_sizes() 3418 { 3419 this->finalize_data_size(); 3420 this->rel_->finalize_data_size(); 3421 } 3422 3423 // Add a reloc for an entry in the BRLT. 3424 void 3425 add_reloc(Address to, unsigned int off) 3426 { this->rel_->add_relative(elfcpp::R_POWERPC_RELATIVE, this, off, to); } 3427 3428 // Update section and reloc section size. 3429 void 3430 set_current_size(unsigned int num_branches) 3431 { 3432 this->reset_address_and_file_offset(); 3433 this->set_current_data_size(num_branches * 16); 3434 this->finalize_data_size(); 3435 Output_section* os = this->output_section(); 3436 os->set_section_offsets_need_adjustment(); 3437 if (this->rel_ != NULL) 3438 { 3439 unsigned int reloc_size 3440 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size; 3441 this->rel_->reset_address_and_file_offset(); 3442 this->rel_->set_current_data_size(num_branches * reloc_size); 3443 this->rel_->finalize_data_size(); 3444 Output_section* os = this->rel_->output_section(); 3445 os->set_section_offsets_need_adjustment(); 3446 } 3447 } 3448 3449 protected: 3450 void 3451 do_adjust_output_section(Output_section* os) 3452 { 3453 os->set_entsize(0); 3454 } 3455 3456 // Write to a map file. 3457 void 3458 do_print_to_mapfile(Mapfile* mapfile) const 3459 { mapfile->print_output_data(this, "** BRLT"); } 3460 3461 private: 3462 // Write out the BRLT data. 3463 void 3464 do_write(Output_file*); 3465 3466 // The reloc section. 3467 Reloc_section* rel_; 3468 Target_powerpc<size, big_endian>* targ_; 3469 }; 3470 3471 // Make the branch lookup table section. 3472 3473 template<int size, bool big_endian> 3474 void 3475 Target_powerpc<size, big_endian>::make_brlt_section(Layout* layout) 3476 { 3477 if (size == 64 && this->brlt_section_ == NULL) 3478 { 3479 Reloc_section* brlt_rel = NULL; 3480 bool is_pic = parameters->options().output_is_position_independent(); 3481 if (is_pic) 3482 { 3483 // When PIC we can't fill in .branch_lt (like .plt it can be 3484 // a bss style section) but must initialise at runtime via 3485 // dynamic relocats. 3486 this->rela_dyn_section(layout); 3487 brlt_rel = new Reloc_section(false); 3488 this->rela_dyn_->output_section()->add_output_section_data(brlt_rel); 3489 } 3490 this->brlt_section_ 3491 = new Output_data_brlt_powerpc<size, big_endian>(this, brlt_rel); 3492 if (this->plt_ && is_pic) 3493 this->plt_->output_section() 3494 ->add_output_section_data(this->brlt_section_); 3495 else 3496 layout->add_output_section_data(".branch_lt", 3497 (is_pic ? elfcpp::SHT_NOBITS 3498 : elfcpp::SHT_PROGBITS), 3499 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 3500 this->brlt_section_, 3501 (is_pic ? ORDER_SMALL_BSS 3502 : ORDER_SMALL_DATA), 3503 false); 3504 } 3505 } 3506 3507 // Write out .branch_lt when non-PIC. 3508 3509 template<int size, bool big_endian> 3510 void 3511 Output_data_brlt_powerpc<size, big_endian>::do_write(Output_file* of) 3512 { 3513 if (size == 64 && !parameters->options().output_is_position_independent()) 3514 { 3515 const section_size_type offset = this->offset(); 3516 const section_size_type oview_size 3517 = convert_to_section_size_type(this->data_size()); 3518 unsigned char* const oview = of->get_output_view(offset, oview_size); 3519 3520 this->targ_->write_branch_lookup_table(oview); 3521 of->write_output_view(offset, oview_size, oview); 3522 } 3523 } 3524 3525 static inline uint32_t 3526 l(uint32_t a) 3527 { 3528 return a & 0xffff; 3529 } 3530 3531 static inline uint32_t 3532 hi(uint32_t a) 3533 { 3534 return l(a >> 16); 3535 } 3536 3537 static inline uint32_t 3538 ha(uint32_t a) 3539 { 3540 return hi(a + 0x8000); 3541 } 3542 3543 template<int size> 3544 struct Eh_cie 3545 { 3546 static const unsigned char eh_frame_cie[12]; 3547 }; 3548 3549 template<int size> 3550 const unsigned char Eh_cie<size>::eh_frame_cie[] = 3551 { 3552 1, // CIE version. 3553 'z', 'R', 0, // Augmentation string. 3554 4, // Code alignment. 3555 0x80 - size / 8 , // Data alignment. 3556 65, // RA reg. 3557 1, // Augmentation size. 3558 (elfcpp::DW_EH_PE_pcrel 3559 | elfcpp::DW_EH_PE_sdata4), // FDE encoding. 3560 elfcpp::DW_CFA_def_cfa, 1, 0 // def_cfa: r1 offset 0. 3561 }; 3562 3563 // Describe __glink_PLTresolve use of LR, 64-bit version ABIv1. 3564 static const unsigned char glink_eh_frame_fde_64v1[] = 3565 { 3566 0, 0, 0, 0, // Replaced with offset to .glink. 3567 0, 0, 0, 0, // Replaced with size of .glink. 3568 0, // Augmentation size. 3569 elfcpp::DW_CFA_advance_loc + 1, 3570 elfcpp::DW_CFA_register, 65, 12, 3571 elfcpp::DW_CFA_advance_loc + 4, 3572 elfcpp::DW_CFA_restore_extended, 65 3573 }; 3574 3575 // Describe __glink_PLTresolve use of LR, 64-bit version ABIv2. 3576 static const unsigned char glink_eh_frame_fde_64v2[] = 3577 { 3578 0, 0, 0, 0, // Replaced with offset to .glink. 3579 0, 0, 0, 0, // Replaced with size of .glink. 3580 0, // Augmentation size. 3581 elfcpp::DW_CFA_advance_loc + 1, 3582 elfcpp::DW_CFA_register, 65, 0, 3583 elfcpp::DW_CFA_advance_loc + 4, 3584 elfcpp::DW_CFA_restore_extended, 65 3585 }; 3586 3587 // Describe __glink_PLTresolve use of LR, 32-bit version. 3588 static const unsigned char glink_eh_frame_fde_32[] = 3589 { 3590 0, 0, 0, 0, // Replaced with offset to .glink. 3591 0, 0, 0, 0, // Replaced with size of .glink. 3592 0, // Augmentation size. 3593 elfcpp::DW_CFA_advance_loc + 2, 3594 elfcpp::DW_CFA_register, 65, 0, 3595 elfcpp::DW_CFA_advance_loc + 4, 3596 elfcpp::DW_CFA_restore_extended, 65 3597 }; 3598 3599 static const unsigned char default_fde[] = 3600 { 3601 0, 0, 0, 0, // Replaced with offset to stubs. 3602 0, 0, 0, 0, // Replaced with size of stubs. 3603 0, // Augmentation size. 3604 elfcpp::DW_CFA_nop, // Pad. 3605 elfcpp::DW_CFA_nop, 3606 elfcpp::DW_CFA_nop 3607 }; 3608 3609 template<bool big_endian> 3610 static inline void 3611 write_insn(unsigned char* p, uint32_t v) 3612 { 3613 elfcpp::Swap<32, big_endian>::writeval(p, v); 3614 } 3615 3616 // Stub_table holds information about plt and long branch stubs. 3617 // Stubs are built in an area following some input section determined 3618 // by group_sections(). This input section is converted to a relaxed 3619 // input section allowing it to be resized to accommodate the stubs 3620 3621 template<int size, bool big_endian> 3622 class Stub_table : public Output_relaxed_input_section 3623 { 3624 public: 3625 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 3626 static const Address invalid_address = static_cast<Address>(0) - 1; 3627 3628 Stub_table(Target_powerpc<size, big_endian>* targ, 3629 Output_section* output_section, 3630 const Output_section::Input_section* owner) 3631 : Output_relaxed_input_section(owner->relobj(), owner->shndx(), 3632 owner->relobj() 3633 ->section_addralign(owner->shndx())), 3634 targ_(targ), plt_call_stubs_(), long_branch_stubs_(), 3635 orig_data_size_(owner->current_data_size()), 3636 plt_size_(0), last_plt_size_(0), 3637 branch_size_(0), last_branch_size_(0), eh_frame_added_(false), 3638 need_save_res_(false) 3639 { 3640 this->set_output_section(output_section); 3641 3642 std::vector<Output_relaxed_input_section*> new_relaxed; 3643 new_relaxed.push_back(this); 3644 output_section->convert_input_sections_to_relaxed_sections(new_relaxed); 3645 } 3646 3647 // Add a plt call stub. 3648 bool 3649 add_plt_call_entry(Address, 3650 const Sized_relobj_file<size, big_endian>*, 3651 const Symbol*, 3652 unsigned int, 3653 Address); 3654 3655 bool 3656 add_plt_call_entry(Address, 3657 const Sized_relobj_file<size, big_endian>*, 3658 unsigned int, 3659 unsigned int, 3660 Address); 3661 3662 // Find a given plt call stub. 3663 Address 3664 find_plt_call_entry(const Symbol*) const; 3665 3666 Address 3667 find_plt_call_entry(const Sized_relobj_file<size, big_endian>*, 3668 unsigned int) const; 3669 3670 Address 3671 find_plt_call_entry(const Sized_relobj_file<size, big_endian>*, 3672 const Symbol*, 3673 unsigned int, 3674 Address) const; 3675 3676 Address 3677 find_plt_call_entry(const Sized_relobj_file<size, big_endian>*, 3678 unsigned int, 3679 unsigned int, 3680 Address) const; 3681 3682 // Add a long branch stub. 3683 bool 3684 add_long_branch_entry(const Powerpc_relobj<size, big_endian>*, 3685 unsigned int, Address, Address, bool); 3686 3687 Address 3688 find_long_branch_entry(const Powerpc_relobj<size, big_endian>*, 3689 Address) const; 3690 3691 bool 3692 can_reach_stub(Address from, unsigned int off, unsigned int r_type) 3693 { 3694 Address max_branch_offset = max_branch_delta(r_type); 3695 if (max_branch_offset == 0) 3696 return true; 3697 gold_assert(from != invalid_address); 3698 Address loc = off + this->stub_address(); 3699 return loc - from + max_branch_offset < 2 * max_branch_offset; 3700 } 3701 3702 void 3703 clear_stubs(bool all) 3704 { 3705 this->plt_call_stubs_.clear(); 3706 this->plt_size_ = 0; 3707 this->long_branch_stubs_.clear(); 3708 this->branch_size_ = 0; 3709 this->need_save_res_ = false; 3710 if (all) 3711 { 3712 this->last_plt_size_ = 0; 3713 this->last_branch_size_ = 0; 3714 } 3715 } 3716 3717 Address 3718 set_address_and_size(const Output_section* os, Address off) 3719 { 3720 Address start_off = off; 3721 off += this->orig_data_size_; 3722 Address my_size = this->plt_size_ + this->branch_size_; 3723 if (this->need_save_res_) 3724 my_size += this->targ_->savres_section()->data_size(); 3725 if (my_size != 0) 3726 off = align_address(off, this->stub_align()); 3727 // Include original section size and alignment padding in size 3728 my_size += off - start_off; 3729 this->reset_address_and_file_offset(); 3730 this->set_current_data_size(my_size); 3731 this->set_address_and_file_offset(os->address() + start_off, 3732 os->offset() + start_off); 3733 return my_size; 3734 } 3735 3736 Address 3737 stub_address() const 3738 { 3739 return align_address(this->address() + this->orig_data_size_, 3740 this->stub_align()); 3741 } 3742 3743 Address 3744 stub_offset() const 3745 { 3746 return align_address(this->offset() + this->orig_data_size_, 3747 this->stub_align()); 3748 } 3749 3750 section_size_type 3751 plt_size() const 3752 { return this->plt_size_; } 3753 3754 bool 3755 size_update() 3756 { 3757 Output_section* os = this->output_section(); 3758 if (os->addralign() < this->stub_align()) 3759 { 3760 os->set_addralign(this->stub_align()); 3761 // FIXME: get rid of the insane checkpointing. 3762 // We can't increase alignment of the input section to which 3763 // stubs are attached; The input section may be .init which 3764 // is pasted together with other .init sections to form a 3765 // function. Aligning might insert zero padding resulting in 3766 // sigill. However we do need to increase alignment of the 3767 // output section so that the align_address() on offset in 3768 // set_address_and_size() adds the same padding as the 3769 // align_address() on address in stub_address(). 3770 // What's more, we need this alignment for the layout done in 3771 // relaxation_loop_body() so that the output section starts at 3772 // a suitably aligned address. 3773 os->checkpoint_set_addralign(this->stub_align()); 3774 } 3775 if (this->last_plt_size_ != this->plt_size_ 3776 || this->last_branch_size_ != this->branch_size_) 3777 { 3778 this->last_plt_size_ = this->plt_size_; 3779 this->last_branch_size_ = this->branch_size_; 3780 return true; 3781 } 3782 return false; 3783 } 3784 3785 // Add .eh_frame info for this stub section. Unlike other linker 3786 // generated .eh_frame this is added late in the link, because we 3787 // only want the .eh_frame info if this particular stub section is 3788 // non-empty. 3789 void 3790 add_eh_frame(Layout* layout) 3791 { 3792 if (!this->eh_frame_added_) 3793 { 3794 if (!parameters->options().ld_generated_unwind_info()) 3795 return; 3796 3797 // Since we add stub .eh_frame info late, it must be placed 3798 // after all other linker generated .eh_frame info so that 3799 // merge mapping need not be updated for input sections. 3800 // There is no provision to use a different CIE to that used 3801 // by .glink. 3802 if (!this->targ_->has_glink()) 3803 return; 3804 3805 layout->add_eh_frame_for_plt(this, 3806 Eh_cie<size>::eh_frame_cie, 3807 sizeof (Eh_cie<size>::eh_frame_cie), 3808 default_fde, 3809 sizeof (default_fde)); 3810 this->eh_frame_added_ = true; 3811 } 3812 } 3813 3814 Target_powerpc<size, big_endian>* 3815 targ() const 3816 { return targ_; } 3817 3818 private: 3819 class Plt_stub_ent; 3820 class Plt_stub_ent_hash; 3821 typedef Unordered_map<Plt_stub_ent, unsigned int, 3822 Plt_stub_ent_hash> Plt_stub_entries; 3823 3824 // Alignment of stub section. 3825 unsigned int 3826 stub_align() const 3827 { 3828 if (size == 32) 3829 return 16; 3830 unsigned int min_align = 32; 3831 unsigned int user_align = 1 << parameters->options().plt_align(); 3832 return std::max(user_align, min_align); 3833 } 3834 3835 // Return the plt offset for the given call stub. 3836 Address 3837 plt_off(typename Plt_stub_entries::const_iterator p, bool* is_iplt) const 3838 { 3839 const Symbol* gsym = p->first.sym_; 3840 if (gsym != NULL) 3841 { 3842 *is_iplt = (gsym->type() == elfcpp::STT_GNU_IFUNC 3843 && gsym->can_use_relative_reloc(false)); 3844 return gsym->plt_offset(); 3845 } 3846 else 3847 { 3848 *is_iplt = true; 3849 const Sized_relobj_file<size, big_endian>* relobj = p->first.object_; 3850 unsigned int local_sym_index = p->first.locsym_; 3851 return relobj->local_plt_offset(local_sym_index); 3852 } 3853 } 3854 3855 // Size of a given plt call stub. 3856 unsigned int 3857 plt_call_size(typename Plt_stub_entries::const_iterator p) const 3858 { 3859 if (size == 32) 3860 return 16; 3861 3862 bool is_iplt; 3863 Address plt_addr = this->plt_off(p, &is_iplt); 3864 if (is_iplt) 3865 plt_addr += this->targ_->iplt_section()->address(); 3866 else 3867 plt_addr += this->targ_->plt_section()->address(); 3868 Address got_addr = this->targ_->got_section()->output_section()->address(); 3869 const Powerpc_relobj<size, big_endian>* ppcobj = static_cast 3870 <const Powerpc_relobj<size, big_endian>*>(p->first.object_); 3871 got_addr += ppcobj->toc_base_offset(); 3872 Address off = plt_addr - got_addr; 3873 unsigned int bytes = 4 * 4 + 4 * (ha(off) != 0); 3874 if (this->targ_->abiversion() < 2) 3875 { 3876 bool static_chain = parameters->options().plt_static_chain(); 3877 bool thread_safe = this->targ_->plt_thread_safe(); 3878 bytes += (4 3879 + 4 * static_chain 3880 + 8 * thread_safe 3881 + 4 * (ha(off + 8 + 8 * static_chain) != ha(off))); 3882 } 3883 unsigned int align = 1 << parameters->options().plt_align(); 3884 if (align > 1) 3885 bytes = (bytes + align - 1) & -align; 3886 return bytes; 3887 } 3888 3889 // Return long branch stub size. 3890 unsigned int 3891 branch_stub_size(Address to) 3892 { 3893 Address loc 3894 = this->stub_address() + this->last_plt_size_ + this->branch_size_; 3895 if (to - loc + (1 << 25) < 2 << 25) 3896 return 4; 3897 if (size == 64 || !parameters->options().output_is_position_independent()) 3898 return 16; 3899 return 32; 3900 } 3901 3902 // Write out stubs. 3903 void 3904 do_write(Output_file*); 3905 3906 // Plt call stub keys. 3907 class Plt_stub_ent 3908 { 3909 public: 3910 Plt_stub_ent(const Symbol* sym) 3911 : sym_(sym), object_(0), addend_(0), locsym_(0) 3912 { } 3913 3914 Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object, 3915 unsigned int locsym_index) 3916 : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index) 3917 { } 3918 3919 Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object, 3920 const Symbol* sym, 3921 unsigned int r_type, 3922 Address addend) 3923 : sym_(sym), object_(0), addend_(0), locsym_(0) 3924 { 3925 if (size != 32) 3926 this->addend_ = addend; 3927 else if (parameters->options().output_is_position_independent() 3928 && r_type == elfcpp::R_PPC_PLTREL24) 3929 { 3930 this->addend_ = addend; 3931 if (this->addend_ >= 32768) 3932 this->object_ = object; 3933 } 3934 } 3935 3936 Plt_stub_ent(const Sized_relobj_file<size, big_endian>* object, 3937 unsigned int locsym_index, 3938 unsigned int r_type, 3939 Address addend) 3940 : sym_(NULL), object_(object), addend_(0), locsym_(locsym_index) 3941 { 3942 if (size != 32) 3943 this->addend_ = addend; 3944 else if (parameters->options().output_is_position_independent() 3945 && r_type == elfcpp::R_PPC_PLTREL24) 3946 this->addend_ = addend; 3947 } 3948 3949 bool operator==(const Plt_stub_ent& that) const 3950 { 3951 return (this->sym_ == that.sym_ 3952 && this->object_ == that.object_ 3953 && this->addend_ == that.addend_ 3954 && this->locsym_ == that.locsym_); 3955 } 3956 3957 const Symbol* sym_; 3958 const Sized_relobj_file<size, big_endian>* object_; 3959 typename elfcpp::Elf_types<size>::Elf_Addr addend_; 3960 unsigned int locsym_; 3961 }; 3962 3963 class Plt_stub_ent_hash 3964 { 3965 public: 3966 size_t operator()(const Plt_stub_ent& ent) const 3967 { 3968 return (reinterpret_cast<uintptr_t>(ent.sym_) 3969 ^ reinterpret_cast<uintptr_t>(ent.object_) 3970 ^ ent.addend_ 3971 ^ ent.locsym_); 3972 } 3973 }; 3974 3975 // Long branch stub keys. 3976 class Branch_stub_ent 3977 { 3978 public: 3979 Branch_stub_ent(const Powerpc_relobj<size, big_endian>* obj, 3980 Address to, bool save_res) 3981 : dest_(to), toc_base_off_(0), save_res_(save_res) 3982 { 3983 if (size == 64) 3984 toc_base_off_ = obj->toc_base_offset(); 3985 } 3986 3987 bool operator==(const Branch_stub_ent& that) const 3988 { 3989 return (this->dest_ == that.dest_ 3990 && (size == 32 3991 || this->toc_base_off_ == that.toc_base_off_)); 3992 } 3993 3994 Address dest_; 3995 unsigned int toc_base_off_; 3996 bool save_res_; 3997 }; 3998 3999 class Branch_stub_ent_hash 4000 { 4001 public: 4002 size_t operator()(const Branch_stub_ent& ent) const 4003 { return ent.dest_ ^ ent.toc_base_off_; } 4004 }; 4005 4006 // In a sane world this would be a global. 4007 Target_powerpc<size, big_endian>* targ_; 4008 // Map sym/object/addend to stub offset. 4009 Plt_stub_entries plt_call_stubs_; 4010 // Map destination address to stub offset. 4011 typedef Unordered_map<Branch_stub_ent, unsigned int, 4012 Branch_stub_ent_hash> Branch_stub_entries; 4013 Branch_stub_entries long_branch_stubs_; 4014 // size of input section 4015 section_size_type orig_data_size_; 4016 // size of stubs 4017 section_size_type plt_size_, last_plt_size_, branch_size_, last_branch_size_; 4018 // Whether .eh_frame info has been created for this stub section. 4019 bool eh_frame_added_; 4020 // Set if this stub group needs a copy of out-of-line register 4021 // save/restore functions. 4022 bool need_save_res_; 4023 }; 4024 4025 // Add a plt call stub, if we do not already have one for this 4026 // sym/object/addend combo. 4027 4028 template<int size, bool big_endian> 4029 bool 4030 Stub_table<size, big_endian>::add_plt_call_entry( 4031 Address from, 4032 const Sized_relobj_file<size, big_endian>* object, 4033 const Symbol* gsym, 4034 unsigned int r_type, 4035 Address addend) 4036 { 4037 Plt_stub_ent ent(object, gsym, r_type, addend); 4038 unsigned int off = this->plt_size_; 4039 std::pair<typename Plt_stub_entries::iterator, bool> p 4040 = this->plt_call_stubs_.insert(std::make_pair(ent, off)); 4041 if (p.second) 4042 this->plt_size_ = off + this->plt_call_size(p.first); 4043 return this->can_reach_stub(from, off, r_type); 4044 } 4045 4046 template<int size, bool big_endian> 4047 bool 4048 Stub_table<size, big_endian>::add_plt_call_entry( 4049 Address from, 4050 const Sized_relobj_file<size, big_endian>* object, 4051 unsigned int locsym_index, 4052 unsigned int r_type, 4053 Address addend) 4054 { 4055 Plt_stub_ent ent(object, locsym_index, r_type, addend); 4056 unsigned int off = this->plt_size_; 4057 std::pair<typename Plt_stub_entries::iterator, bool> p 4058 = this->plt_call_stubs_.insert(std::make_pair(ent, off)); 4059 if (p.second) 4060 this->plt_size_ = off + this->plt_call_size(p.first); 4061 return this->can_reach_stub(from, off, r_type); 4062 } 4063 4064 // Find a plt call stub. 4065 4066 template<int size, bool big_endian> 4067 typename Stub_table<size, big_endian>::Address 4068 Stub_table<size, big_endian>::find_plt_call_entry( 4069 const Sized_relobj_file<size, big_endian>* object, 4070 const Symbol* gsym, 4071 unsigned int r_type, 4072 Address addend) const 4073 { 4074 Plt_stub_ent ent(object, gsym, r_type, addend); 4075 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent); 4076 return p == this->plt_call_stubs_.end() ? invalid_address : p->second; 4077 } 4078 4079 template<int size, bool big_endian> 4080 typename Stub_table<size, big_endian>::Address 4081 Stub_table<size, big_endian>::find_plt_call_entry(const Symbol* gsym) const 4082 { 4083 Plt_stub_ent ent(gsym); 4084 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent); 4085 return p == this->plt_call_stubs_.end() ? invalid_address : p->second; 4086 } 4087 4088 template<int size, bool big_endian> 4089 typename Stub_table<size, big_endian>::Address 4090 Stub_table<size, big_endian>::find_plt_call_entry( 4091 const Sized_relobj_file<size, big_endian>* object, 4092 unsigned int locsym_index, 4093 unsigned int r_type, 4094 Address addend) const 4095 { 4096 Plt_stub_ent ent(object, locsym_index, r_type, addend); 4097 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent); 4098 return p == this->plt_call_stubs_.end() ? invalid_address : p->second; 4099 } 4100 4101 template<int size, bool big_endian> 4102 typename Stub_table<size, big_endian>::Address 4103 Stub_table<size, big_endian>::find_plt_call_entry( 4104 const Sized_relobj_file<size, big_endian>* object, 4105 unsigned int locsym_index) const 4106 { 4107 Plt_stub_ent ent(object, locsym_index); 4108 typename Plt_stub_entries::const_iterator p = this->plt_call_stubs_.find(ent); 4109 return p == this->plt_call_stubs_.end() ? invalid_address : p->second; 4110 } 4111 4112 // Add a long branch stub if we don't already have one to given 4113 // destination. 4114 4115 template<int size, bool big_endian> 4116 bool 4117 Stub_table<size, big_endian>::add_long_branch_entry( 4118 const Powerpc_relobj<size, big_endian>* object, 4119 unsigned int r_type, 4120 Address from, 4121 Address to, 4122 bool save_res) 4123 { 4124 Branch_stub_ent ent(object, to, save_res); 4125 Address off = this->branch_size_; 4126 if (this->long_branch_stubs_.insert(std::make_pair(ent, off)).second) 4127 { 4128 if (save_res) 4129 this->need_save_res_ = true; 4130 else 4131 { 4132 unsigned int stub_size = this->branch_stub_size(to); 4133 this->branch_size_ = off + stub_size; 4134 if (size == 64 && stub_size != 4) 4135 this->targ_->add_branch_lookup_table(to); 4136 } 4137 } 4138 return this->can_reach_stub(from, off, r_type); 4139 } 4140 4141 // Find long branch stub offset. 4142 4143 template<int size, bool big_endian> 4144 typename Stub_table<size, big_endian>::Address 4145 Stub_table<size, big_endian>::find_long_branch_entry( 4146 const Powerpc_relobj<size, big_endian>* object, 4147 Address to) const 4148 { 4149 Branch_stub_ent ent(object, to, false); 4150 typename Branch_stub_entries::const_iterator p 4151 = this->long_branch_stubs_.find(ent); 4152 if (p == this->long_branch_stubs_.end()) 4153 return invalid_address; 4154 if (p->first.save_res_) 4155 return to - this->targ_->savres_section()->address() + this->branch_size_; 4156 return p->second; 4157 } 4158 4159 // A class to handle .glink. 4160 4161 template<int size, bool big_endian> 4162 class Output_data_glink : public Output_section_data 4163 { 4164 public: 4165 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 4166 static const Address invalid_address = static_cast<Address>(0) - 1; 4167 static const int pltresolve_size = 16*4; 4168 4169 Output_data_glink(Target_powerpc<size, big_endian>* targ) 4170 : Output_section_data(16), targ_(targ), global_entry_stubs_(), 4171 end_branch_table_(), ge_size_(0) 4172 { } 4173 4174 void 4175 add_eh_frame(Layout* layout); 4176 4177 void 4178 add_global_entry(const Symbol*); 4179 4180 Address 4181 find_global_entry(const Symbol*) const; 4182 4183 Address 4184 global_entry_address() const 4185 { 4186 gold_assert(this->is_data_size_valid()); 4187 unsigned int global_entry_off = (this->end_branch_table_ + 15) & -16; 4188 return this->address() + global_entry_off; 4189 } 4190 4191 protected: 4192 // Write to a map file. 4193 void 4194 do_print_to_mapfile(Mapfile* mapfile) const 4195 { mapfile->print_output_data(this, _("** glink")); } 4196 4197 private: 4198 void 4199 set_final_data_size(); 4200 4201 // Write out .glink 4202 void 4203 do_write(Output_file*); 4204 4205 // Allows access to .got and .plt for do_write. 4206 Target_powerpc<size, big_endian>* targ_; 4207 4208 // Map sym to stub offset. 4209 typedef Unordered_map<const Symbol*, unsigned int> Global_entry_stub_entries; 4210 Global_entry_stub_entries global_entry_stubs_; 4211 4212 unsigned int end_branch_table_, ge_size_; 4213 }; 4214 4215 template<int size, bool big_endian> 4216 void 4217 Output_data_glink<size, big_endian>::add_eh_frame(Layout* layout) 4218 { 4219 if (!parameters->options().ld_generated_unwind_info()) 4220 return; 4221 4222 if (size == 64) 4223 { 4224 if (this->targ_->abiversion() < 2) 4225 layout->add_eh_frame_for_plt(this, 4226 Eh_cie<64>::eh_frame_cie, 4227 sizeof (Eh_cie<64>::eh_frame_cie), 4228 glink_eh_frame_fde_64v1, 4229 sizeof (glink_eh_frame_fde_64v1)); 4230 else 4231 layout->add_eh_frame_for_plt(this, 4232 Eh_cie<64>::eh_frame_cie, 4233 sizeof (Eh_cie<64>::eh_frame_cie), 4234 glink_eh_frame_fde_64v2, 4235 sizeof (glink_eh_frame_fde_64v2)); 4236 } 4237 else 4238 { 4239 // 32-bit .glink can use the default since the CIE return 4240 // address reg, LR, is valid. 4241 layout->add_eh_frame_for_plt(this, 4242 Eh_cie<32>::eh_frame_cie, 4243 sizeof (Eh_cie<32>::eh_frame_cie), 4244 default_fde, 4245 sizeof (default_fde)); 4246 // Except where LR is used in a PIC __glink_PLTresolve. 4247 if (parameters->options().output_is_position_independent()) 4248 layout->add_eh_frame_for_plt(this, 4249 Eh_cie<32>::eh_frame_cie, 4250 sizeof (Eh_cie<32>::eh_frame_cie), 4251 glink_eh_frame_fde_32, 4252 sizeof (glink_eh_frame_fde_32)); 4253 } 4254 } 4255 4256 template<int size, bool big_endian> 4257 void 4258 Output_data_glink<size, big_endian>::add_global_entry(const Symbol* gsym) 4259 { 4260 std::pair<typename Global_entry_stub_entries::iterator, bool> p 4261 = this->global_entry_stubs_.insert(std::make_pair(gsym, this->ge_size_)); 4262 if (p.second) 4263 this->ge_size_ += 16; 4264 } 4265 4266 template<int size, bool big_endian> 4267 typename Output_data_glink<size, big_endian>::Address 4268 Output_data_glink<size, big_endian>::find_global_entry(const Symbol* gsym) const 4269 { 4270 typename Global_entry_stub_entries::const_iterator p 4271 = this->global_entry_stubs_.find(gsym); 4272 return p == this->global_entry_stubs_.end() ? invalid_address : p->second; 4273 } 4274 4275 template<int size, bool big_endian> 4276 void 4277 Output_data_glink<size, big_endian>::set_final_data_size() 4278 { 4279 unsigned int count = this->targ_->plt_entry_count(); 4280 section_size_type total = 0; 4281 4282 if (count != 0) 4283 { 4284 if (size == 32) 4285 { 4286 // space for branch table 4287 total += 4 * (count - 1); 4288 4289 total += -total & 15; 4290 total += this->pltresolve_size; 4291 } 4292 else 4293 { 4294 total += this->pltresolve_size; 4295 4296 // space for branch table 4297 total += 4 * count; 4298 if (this->targ_->abiversion() < 2) 4299 { 4300 total += 4 * count; 4301 if (count > 0x8000) 4302 total += 4 * (count - 0x8000); 4303 } 4304 } 4305 } 4306 this->end_branch_table_ = total; 4307 total = (total + 15) & -16; 4308 total += this->ge_size_; 4309 4310 this->set_data_size(total); 4311 } 4312 4313 // Write out plt and long branch stub code. 4314 4315 template<int size, bool big_endian> 4316 void 4317 Stub_table<size, big_endian>::do_write(Output_file* of) 4318 { 4319 if (this->plt_call_stubs_.empty() 4320 && this->long_branch_stubs_.empty()) 4321 return; 4322 4323 const section_size_type start_off = this->offset(); 4324 const section_size_type off = this->stub_offset(); 4325 const section_size_type oview_size = 4326 convert_to_section_size_type(this->data_size() - (off - start_off)); 4327 unsigned char* const oview = of->get_output_view(off, oview_size); 4328 unsigned char* p; 4329 4330 if (size == 64) 4331 { 4332 const Output_data_got_powerpc<size, big_endian>* got 4333 = this->targ_->got_section(); 4334 Address got_os_addr = got->output_section()->address(); 4335 4336 if (!this->plt_call_stubs_.empty()) 4337 { 4338 // The base address of the .plt section. 4339 Address plt_base = this->targ_->plt_section()->address(); 4340 Address iplt_base = invalid_address; 4341 4342 // Write out plt call stubs. 4343 typename Plt_stub_entries::const_iterator cs; 4344 for (cs = this->plt_call_stubs_.begin(); 4345 cs != this->plt_call_stubs_.end(); 4346 ++cs) 4347 { 4348 bool is_iplt; 4349 Address pltoff = this->plt_off(cs, &is_iplt); 4350 Address plt_addr = pltoff; 4351 if (is_iplt) 4352 { 4353 if (iplt_base == invalid_address) 4354 iplt_base = this->targ_->iplt_section()->address(); 4355 plt_addr += iplt_base; 4356 } 4357 else 4358 plt_addr += plt_base; 4359 const Powerpc_relobj<size, big_endian>* ppcobj = static_cast 4360 <const Powerpc_relobj<size, big_endian>*>(cs->first.object_); 4361 Address got_addr = got_os_addr + ppcobj->toc_base_offset(); 4362 Address off = plt_addr - got_addr; 4363 4364 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0) 4365 gold_error(_("%s: linkage table error against `%s'"), 4366 cs->first.object_->name().c_str(), 4367 cs->first.sym_->demangled_name().c_str()); 4368 4369 bool plt_load_toc = this->targ_->abiversion() < 2; 4370 bool static_chain 4371 = plt_load_toc && parameters->options().plt_static_chain(); 4372 bool thread_safe 4373 = plt_load_toc && this->targ_->plt_thread_safe(); 4374 bool use_fake_dep = false; 4375 Address cmp_branch_off = 0; 4376 if (thread_safe) 4377 { 4378 unsigned int pltindex 4379 = ((pltoff - this->targ_->first_plt_entry_offset()) 4380 / this->targ_->plt_entry_size()); 4381 Address glinkoff 4382 = (this->targ_->glink_section()->pltresolve_size 4383 + pltindex * 8); 4384 if (pltindex > 32768) 4385 glinkoff += (pltindex - 32768) * 4; 4386 Address to 4387 = this->targ_->glink_section()->address() + glinkoff; 4388 Address from 4389 = (this->stub_address() + cs->second + 24 4390 + 4 * (ha(off) != 0) 4391 + 4 * (ha(off + 8 + 8 * static_chain) != ha(off)) 4392 + 4 * static_chain); 4393 cmp_branch_off = to - from; 4394 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26); 4395 } 4396 4397 p = oview + cs->second; 4398 if (ha(off) != 0) 4399 { 4400 write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc()); 4401 p += 4; 4402 if (plt_load_toc) 4403 { 4404 write_insn<big_endian>(p, addis_11_2 + ha(off)); 4405 p += 4; 4406 write_insn<big_endian>(p, ld_12_11 + l(off)); 4407 p += 4; 4408 } 4409 else 4410 { 4411 write_insn<big_endian>(p, addis_12_2 + ha(off)); 4412 p += 4; 4413 write_insn<big_endian>(p, ld_12_12 + l(off)); 4414 p += 4; 4415 } 4416 if (plt_load_toc 4417 && ha(off + 8 + 8 * static_chain) != ha(off)) 4418 { 4419 write_insn<big_endian>(p, addi_11_11 + l(off)); 4420 p += 4; 4421 off = 0; 4422 } 4423 write_insn<big_endian>(p, mtctr_12); 4424 p += 4; 4425 if (plt_load_toc) 4426 { 4427 if (use_fake_dep) 4428 { 4429 write_insn<big_endian>(p, xor_2_12_12); 4430 p += 4; 4431 write_insn<big_endian>(p, add_11_11_2); 4432 p += 4; 4433 } 4434 write_insn<big_endian>(p, ld_2_11 + l(off + 8)); 4435 p += 4; 4436 if (static_chain) 4437 { 4438 write_insn<big_endian>(p, ld_11_11 + l(off + 16)); 4439 p += 4; 4440 } 4441 } 4442 } 4443 else 4444 { 4445 write_insn<big_endian>(p, std_2_1 + this->targ_->stk_toc()); 4446 p += 4; 4447 write_insn<big_endian>(p, ld_12_2 + l(off)); 4448 p += 4; 4449 if (plt_load_toc 4450 && ha(off + 8 + 8 * static_chain) != ha(off)) 4451 { 4452 write_insn<big_endian>(p, addi_2_2 + l(off)); 4453 p += 4; 4454 off = 0; 4455 } 4456 write_insn<big_endian>(p, mtctr_12); 4457 p += 4; 4458 if (plt_load_toc) 4459 { 4460 if (use_fake_dep) 4461 { 4462 write_insn<big_endian>(p, xor_11_12_12); 4463 p += 4; 4464 write_insn<big_endian>(p, add_2_2_11); 4465 p += 4; 4466 } 4467 if (static_chain) 4468 { 4469 write_insn<big_endian>(p, ld_11_2 + l(off + 16)); 4470 p += 4; 4471 } 4472 write_insn<big_endian>(p, ld_2_2 + l(off + 8)); 4473 p += 4; 4474 } 4475 } 4476 if (thread_safe && !use_fake_dep) 4477 { 4478 write_insn<big_endian>(p, cmpldi_2_0); 4479 p += 4; 4480 write_insn<big_endian>(p, bnectr_p4); 4481 p += 4; 4482 write_insn<big_endian>(p, b | (cmp_branch_off & 0x3fffffc)); 4483 } 4484 else 4485 write_insn<big_endian>(p, bctr); 4486 } 4487 } 4488 4489 // Write out long branch stubs. 4490 typename Branch_stub_entries::const_iterator bs; 4491 for (bs = this->long_branch_stubs_.begin(); 4492 bs != this->long_branch_stubs_.end(); 4493 ++bs) 4494 { 4495 if (bs->first.save_res_) 4496 continue; 4497 p = oview + this->plt_size_ + bs->second; 4498 Address loc = this->stub_address() + this->plt_size_ + bs->second; 4499 Address delta = bs->first.dest_ - loc; 4500 if (delta + (1 << 25) < 2 << 25) 4501 write_insn<big_endian>(p, b | (delta & 0x3fffffc)); 4502 else 4503 { 4504 Address brlt_addr 4505 = this->targ_->find_branch_lookup_table(bs->first.dest_); 4506 gold_assert(brlt_addr != invalid_address); 4507 brlt_addr += this->targ_->brlt_section()->address(); 4508 Address got_addr = got_os_addr + bs->first.toc_base_off_; 4509 Address brltoff = brlt_addr - got_addr; 4510 if (ha(brltoff) == 0) 4511 { 4512 write_insn<big_endian>(p, ld_12_2 + l(brltoff)), p += 4; 4513 } 4514 else 4515 { 4516 write_insn<big_endian>(p, addis_12_2 + ha(brltoff)), p += 4; 4517 write_insn<big_endian>(p, ld_12_12 + l(brltoff)), p += 4; 4518 } 4519 write_insn<big_endian>(p, mtctr_12), p += 4; 4520 write_insn<big_endian>(p, bctr); 4521 } 4522 } 4523 } 4524 else 4525 { 4526 if (!this->plt_call_stubs_.empty()) 4527 { 4528 // The base address of the .plt section. 4529 Address plt_base = this->targ_->plt_section()->address(); 4530 Address iplt_base = invalid_address; 4531 // The address of _GLOBAL_OFFSET_TABLE_. 4532 Address g_o_t = invalid_address; 4533 4534 // Write out plt call stubs. 4535 typename Plt_stub_entries::const_iterator cs; 4536 for (cs = this->plt_call_stubs_.begin(); 4537 cs != this->plt_call_stubs_.end(); 4538 ++cs) 4539 { 4540 bool is_iplt; 4541 Address plt_addr = this->plt_off(cs, &is_iplt); 4542 if (is_iplt) 4543 { 4544 if (iplt_base == invalid_address) 4545 iplt_base = this->targ_->iplt_section()->address(); 4546 plt_addr += iplt_base; 4547 } 4548 else 4549 plt_addr += plt_base; 4550 4551 p = oview + cs->second; 4552 if (parameters->options().output_is_position_independent()) 4553 { 4554 Address got_addr; 4555 const Powerpc_relobj<size, big_endian>* ppcobj 4556 = (static_cast<const Powerpc_relobj<size, big_endian>*> 4557 (cs->first.object_)); 4558 if (ppcobj != NULL && cs->first.addend_ >= 32768) 4559 { 4560 unsigned int got2 = ppcobj->got2_shndx(); 4561 got_addr = ppcobj->get_output_section_offset(got2); 4562 gold_assert(got_addr != invalid_address); 4563 got_addr += (ppcobj->output_section(got2)->address() 4564 + cs->first.addend_); 4565 } 4566 else 4567 { 4568 if (g_o_t == invalid_address) 4569 { 4570 const Output_data_got_powerpc<size, big_endian>* got 4571 = this->targ_->got_section(); 4572 g_o_t = got->address() + got->g_o_t(); 4573 } 4574 got_addr = g_o_t; 4575 } 4576 4577 Address off = plt_addr - got_addr; 4578 if (ha(off) == 0) 4579 { 4580 write_insn<big_endian>(p + 0, lwz_11_30 + l(off)); 4581 write_insn<big_endian>(p + 4, mtctr_11); 4582 write_insn<big_endian>(p + 8, bctr); 4583 } 4584 else 4585 { 4586 write_insn<big_endian>(p + 0, addis_11_30 + ha(off)); 4587 write_insn<big_endian>(p + 4, lwz_11_11 + l(off)); 4588 write_insn<big_endian>(p + 8, mtctr_11); 4589 write_insn<big_endian>(p + 12, bctr); 4590 } 4591 } 4592 else 4593 { 4594 write_insn<big_endian>(p + 0, lis_11 + ha(plt_addr)); 4595 write_insn<big_endian>(p + 4, lwz_11_11 + l(plt_addr)); 4596 write_insn<big_endian>(p + 8, mtctr_11); 4597 write_insn<big_endian>(p + 12, bctr); 4598 } 4599 } 4600 } 4601 4602 // Write out long branch stubs. 4603 typename Branch_stub_entries::const_iterator bs; 4604 for (bs = this->long_branch_stubs_.begin(); 4605 bs != this->long_branch_stubs_.end(); 4606 ++bs) 4607 { 4608 if (bs->first.save_res_) 4609 continue; 4610 p = oview + this->plt_size_ + bs->second; 4611 Address loc = this->stub_address() + this->plt_size_ + bs->second; 4612 Address delta = bs->first.dest_ - loc; 4613 if (delta + (1 << 25) < 2 << 25) 4614 write_insn<big_endian>(p, b | (delta & 0x3fffffc)); 4615 else if (!parameters->options().output_is_position_independent()) 4616 { 4617 write_insn<big_endian>(p + 0, lis_12 + ha(bs->first.dest_)); 4618 write_insn<big_endian>(p + 4, addi_12_12 + l(bs->first.dest_)); 4619 write_insn<big_endian>(p + 8, mtctr_12); 4620 write_insn<big_endian>(p + 12, bctr); 4621 } 4622 else 4623 { 4624 delta -= 8; 4625 write_insn<big_endian>(p + 0, mflr_0); 4626 write_insn<big_endian>(p + 4, bcl_20_31); 4627 write_insn<big_endian>(p + 8, mflr_12); 4628 write_insn<big_endian>(p + 12, addis_12_12 + ha(delta)); 4629 write_insn<big_endian>(p + 16, addi_12_12 + l(delta)); 4630 write_insn<big_endian>(p + 20, mtlr_0); 4631 write_insn<big_endian>(p + 24, mtctr_12); 4632 write_insn<big_endian>(p + 28, bctr); 4633 } 4634 } 4635 } 4636 if (this->need_save_res_) 4637 { 4638 p = oview + this->plt_size_ + this->branch_size_; 4639 memcpy (p, this->targ_->savres_section()->contents(), 4640 this->targ_->savres_section()->data_size()); 4641 } 4642 } 4643 4644 // Write out .glink. 4645 4646 template<int size, bool big_endian> 4647 void 4648 Output_data_glink<size, big_endian>::do_write(Output_file* of) 4649 { 4650 const section_size_type off = this->offset(); 4651 const section_size_type oview_size = 4652 convert_to_section_size_type(this->data_size()); 4653 unsigned char* const oview = of->get_output_view(off, oview_size); 4654 unsigned char* p; 4655 4656 // The base address of the .plt section. 4657 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 4658 Address plt_base = this->targ_->plt_section()->address(); 4659 4660 if (size == 64) 4661 { 4662 if (this->end_branch_table_ != 0) 4663 { 4664 // Write pltresolve stub. 4665 p = oview; 4666 Address after_bcl = this->address() + 16; 4667 Address pltoff = plt_base - after_bcl; 4668 4669 elfcpp::Swap<64, big_endian>::writeval(p, pltoff), p += 8; 4670 4671 if (this->targ_->abiversion() < 2) 4672 { 4673 write_insn<big_endian>(p, mflr_12), p += 4; 4674 write_insn<big_endian>(p, bcl_20_31), p += 4; 4675 write_insn<big_endian>(p, mflr_11), p += 4; 4676 write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4; 4677 write_insn<big_endian>(p, mtlr_12), p += 4; 4678 write_insn<big_endian>(p, add_11_2_11), p += 4; 4679 write_insn<big_endian>(p, ld_12_11 + 0), p += 4; 4680 write_insn<big_endian>(p, ld_2_11 + 8), p += 4; 4681 write_insn<big_endian>(p, mtctr_12), p += 4; 4682 write_insn<big_endian>(p, ld_11_11 + 16), p += 4; 4683 } 4684 else 4685 { 4686 write_insn<big_endian>(p, mflr_0), p += 4; 4687 write_insn<big_endian>(p, bcl_20_31), p += 4; 4688 write_insn<big_endian>(p, mflr_11), p += 4; 4689 write_insn<big_endian>(p, ld_2_11 + l(-16)), p += 4; 4690 write_insn<big_endian>(p, mtlr_0), p += 4; 4691 write_insn<big_endian>(p, sub_12_12_11), p += 4; 4692 write_insn<big_endian>(p, add_11_2_11), p += 4; 4693 write_insn<big_endian>(p, addi_0_12 + l(-48)), p += 4; 4694 write_insn<big_endian>(p, ld_12_11 + 0), p += 4; 4695 write_insn<big_endian>(p, srdi_0_0_2), p += 4; 4696 write_insn<big_endian>(p, mtctr_12), p += 4; 4697 write_insn<big_endian>(p, ld_11_11 + 8), p += 4; 4698 } 4699 write_insn<big_endian>(p, bctr), p += 4; 4700 while (p < oview + this->pltresolve_size) 4701 write_insn<big_endian>(p, nop), p += 4; 4702 4703 // Write lazy link call stubs. 4704 uint32_t indx = 0; 4705 while (p < oview + this->end_branch_table_) 4706 { 4707 if (this->targ_->abiversion() < 2) 4708 { 4709 if (indx < 0x8000) 4710 { 4711 write_insn<big_endian>(p, li_0_0 + indx), p += 4; 4712 } 4713 else 4714 { 4715 write_insn<big_endian>(p, lis_0 + hi(indx)), p += 4; 4716 write_insn<big_endian>(p, ori_0_0_0 + l(indx)), p += 4; 4717 } 4718 } 4719 uint32_t branch_off = 8 - (p - oview); 4720 write_insn<big_endian>(p, b + (branch_off & 0x3fffffc)), p += 4; 4721 indx++; 4722 } 4723 } 4724 4725 Address plt_base = this->targ_->plt_section()->address(); 4726 Address iplt_base = invalid_address; 4727 unsigned int global_entry_off = (this->end_branch_table_ + 15) & -16; 4728 Address global_entry_base = this->address() + global_entry_off; 4729 typename Global_entry_stub_entries::const_iterator ge; 4730 for (ge = this->global_entry_stubs_.begin(); 4731 ge != this->global_entry_stubs_.end(); 4732 ++ge) 4733 { 4734 p = oview + global_entry_off + ge->second; 4735 Address plt_addr = ge->first->plt_offset(); 4736 if (ge->first->type() == elfcpp::STT_GNU_IFUNC 4737 && ge->first->can_use_relative_reloc(false)) 4738 { 4739 if (iplt_base == invalid_address) 4740 iplt_base = this->targ_->iplt_section()->address(); 4741 plt_addr += iplt_base; 4742 } 4743 else 4744 plt_addr += plt_base; 4745 Address my_addr = global_entry_base + ge->second; 4746 Address off = plt_addr - my_addr; 4747 4748 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0) 4749 gold_error(_("%s: linkage table error against `%s'"), 4750 ge->first->object()->name().c_str(), 4751 ge->first->demangled_name().c_str()); 4752 4753 write_insn<big_endian>(p, addis_12_12 + ha(off)), p += 4; 4754 write_insn<big_endian>(p, ld_12_12 + l(off)), p += 4; 4755 write_insn<big_endian>(p, mtctr_12), p += 4; 4756 write_insn<big_endian>(p, bctr); 4757 } 4758 } 4759 else 4760 { 4761 const Output_data_got_powerpc<size, big_endian>* got 4762 = this->targ_->got_section(); 4763 // The address of _GLOBAL_OFFSET_TABLE_. 4764 Address g_o_t = got->address() + got->g_o_t(); 4765 4766 // Write out pltresolve branch table. 4767 p = oview; 4768 unsigned int the_end = oview_size - this->pltresolve_size; 4769 unsigned char* end_p = oview + the_end; 4770 while (p < end_p - 8 * 4) 4771 write_insn<big_endian>(p, b + end_p - p), p += 4; 4772 while (p < end_p) 4773 write_insn<big_endian>(p, nop), p += 4; 4774 4775 // Write out pltresolve call stub. 4776 if (parameters->options().output_is_position_independent()) 4777 { 4778 Address res0_off = 0; 4779 Address after_bcl_off = the_end + 12; 4780 Address bcl_res0 = after_bcl_off - res0_off; 4781 4782 write_insn<big_endian>(p + 0, addis_11_11 + ha(bcl_res0)); 4783 write_insn<big_endian>(p + 4, mflr_0); 4784 write_insn<big_endian>(p + 8, bcl_20_31); 4785 write_insn<big_endian>(p + 12, addi_11_11 + l(bcl_res0)); 4786 write_insn<big_endian>(p + 16, mflr_12); 4787 write_insn<big_endian>(p + 20, mtlr_0); 4788 write_insn<big_endian>(p + 24, sub_11_11_12); 4789 4790 Address got_bcl = g_o_t + 4 - (after_bcl_off + this->address()); 4791 4792 write_insn<big_endian>(p + 28, addis_12_12 + ha(got_bcl)); 4793 if (ha(got_bcl) == ha(got_bcl + 4)) 4794 { 4795 write_insn<big_endian>(p + 32, lwz_0_12 + l(got_bcl)); 4796 write_insn<big_endian>(p + 36, lwz_12_12 + l(got_bcl + 4)); 4797 } 4798 else 4799 { 4800 write_insn<big_endian>(p + 32, lwzu_0_12 + l(got_bcl)); 4801 write_insn<big_endian>(p + 36, lwz_12_12 + 4); 4802 } 4803 write_insn<big_endian>(p + 40, mtctr_0); 4804 write_insn<big_endian>(p + 44, add_0_11_11); 4805 write_insn<big_endian>(p + 48, add_11_0_11); 4806 write_insn<big_endian>(p + 52, bctr); 4807 write_insn<big_endian>(p + 56, nop); 4808 write_insn<big_endian>(p + 60, nop); 4809 } 4810 else 4811 { 4812 Address res0 = this->address(); 4813 4814 write_insn<big_endian>(p + 0, lis_12 + ha(g_o_t + 4)); 4815 write_insn<big_endian>(p + 4, addis_11_11 + ha(-res0)); 4816 if (ha(g_o_t + 4) == ha(g_o_t + 8)) 4817 write_insn<big_endian>(p + 8, lwz_0_12 + l(g_o_t + 4)); 4818 else 4819 write_insn<big_endian>(p + 8, lwzu_0_12 + l(g_o_t + 4)); 4820 write_insn<big_endian>(p + 12, addi_11_11 + l(-res0)); 4821 write_insn<big_endian>(p + 16, mtctr_0); 4822 write_insn<big_endian>(p + 20, add_0_11_11); 4823 if (ha(g_o_t + 4) == ha(g_o_t + 8)) 4824 write_insn<big_endian>(p + 24, lwz_12_12 + l(g_o_t + 8)); 4825 else 4826 write_insn<big_endian>(p + 24, lwz_12_12 + 4); 4827 write_insn<big_endian>(p + 28, add_11_0_11); 4828 write_insn<big_endian>(p + 32, bctr); 4829 write_insn<big_endian>(p + 36, nop); 4830 write_insn<big_endian>(p + 40, nop); 4831 write_insn<big_endian>(p + 44, nop); 4832 write_insn<big_endian>(p + 48, nop); 4833 write_insn<big_endian>(p + 52, nop); 4834 write_insn<big_endian>(p + 56, nop); 4835 write_insn<big_endian>(p + 60, nop); 4836 } 4837 p += 64; 4838 } 4839 4840 of->write_output_view(off, oview_size, oview); 4841 } 4842 4843 4844 // A class to handle linker generated save/restore functions. 4845 4846 template<int size, bool big_endian> 4847 class Output_data_save_res : public Output_section_data_build 4848 { 4849 public: 4850 Output_data_save_res(Symbol_table* symtab); 4851 4852 const unsigned char* 4853 contents() const 4854 { 4855 return contents_; 4856 } 4857 4858 protected: 4859 // Write to a map file. 4860 void 4861 do_print_to_mapfile(Mapfile* mapfile) const 4862 { mapfile->print_output_data(this, _("** save/restore")); } 4863 4864 void 4865 do_write(Output_file*); 4866 4867 private: 4868 // The maximum size of save/restore contents. 4869 static const unsigned int savres_max = 218*4; 4870 4871 void 4872 savres_define(Symbol_table* symtab, 4873 const char *name, 4874 unsigned int lo, unsigned int hi, 4875 unsigned char* write_ent(unsigned char*, int), 4876 unsigned char* write_tail(unsigned char*, int)); 4877 4878 unsigned char *contents_; 4879 }; 4880 4881 template<bool big_endian> 4882 static unsigned char* 4883 savegpr0(unsigned char* p, int r) 4884 { 4885 uint32_t insn = std_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8; 4886 write_insn<big_endian>(p, insn); 4887 return p + 4; 4888 } 4889 4890 template<bool big_endian> 4891 static unsigned char* 4892 savegpr0_tail(unsigned char* p, int r) 4893 { 4894 p = savegpr0<big_endian>(p, r); 4895 uint32_t insn = std_0_1 + 16; 4896 write_insn<big_endian>(p, insn); 4897 p = p + 4; 4898 write_insn<big_endian>(p, blr); 4899 return p + 4; 4900 } 4901 4902 template<bool big_endian> 4903 static unsigned char* 4904 restgpr0(unsigned char* p, int r) 4905 { 4906 uint32_t insn = ld_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8; 4907 write_insn<big_endian>(p, insn); 4908 return p + 4; 4909 } 4910 4911 template<bool big_endian> 4912 static unsigned char* 4913 restgpr0_tail(unsigned char* p, int r) 4914 { 4915 uint32_t insn = ld_0_1 + 16; 4916 write_insn<big_endian>(p, insn); 4917 p = p + 4; 4918 p = restgpr0<big_endian>(p, r); 4919 write_insn<big_endian>(p, mtlr_0); 4920 p = p + 4; 4921 if (r == 29) 4922 { 4923 p = restgpr0<big_endian>(p, 30); 4924 p = restgpr0<big_endian>(p, 31); 4925 } 4926 write_insn<big_endian>(p, blr); 4927 return p + 4; 4928 } 4929 4930 template<bool big_endian> 4931 static unsigned char* 4932 savegpr1(unsigned char* p, int r) 4933 { 4934 uint32_t insn = std_0_12 + (r << 21) + (1 << 16) - (32 - r) * 8; 4935 write_insn<big_endian>(p, insn); 4936 return p + 4; 4937 } 4938 4939 template<bool big_endian> 4940 static unsigned char* 4941 savegpr1_tail(unsigned char* p, int r) 4942 { 4943 p = savegpr1<big_endian>(p, r); 4944 write_insn<big_endian>(p, blr); 4945 return p + 4; 4946 } 4947 4948 template<bool big_endian> 4949 static unsigned char* 4950 restgpr1(unsigned char* p, int r) 4951 { 4952 uint32_t insn = ld_0_12 + (r << 21) + (1 << 16) - (32 - r) * 8; 4953 write_insn<big_endian>(p, insn); 4954 return p + 4; 4955 } 4956 4957 template<bool big_endian> 4958 static unsigned char* 4959 restgpr1_tail(unsigned char* p, int r) 4960 { 4961 p = restgpr1<big_endian>(p, r); 4962 write_insn<big_endian>(p, blr); 4963 return p + 4; 4964 } 4965 4966 template<bool big_endian> 4967 static unsigned char* 4968 savefpr(unsigned char* p, int r) 4969 { 4970 uint32_t insn = stfd_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8; 4971 write_insn<big_endian>(p, insn); 4972 return p + 4; 4973 } 4974 4975 template<bool big_endian> 4976 static unsigned char* 4977 savefpr0_tail(unsigned char* p, int r) 4978 { 4979 p = savefpr<big_endian>(p, r); 4980 write_insn<big_endian>(p, std_0_1 + 16); 4981 p = p + 4; 4982 write_insn<big_endian>(p, blr); 4983 return p + 4; 4984 } 4985 4986 template<bool big_endian> 4987 static unsigned char* 4988 restfpr(unsigned char* p, int r) 4989 { 4990 uint32_t insn = lfd_0_1 + (r << 21) + (1 << 16) - (32 - r) * 8; 4991 write_insn<big_endian>(p, insn); 4992 return p + 4; 4993 } 4994 4995 template<bool big_endian> 4996 static unsigned char* 4997 restfpr0_tail(unsigned char* p, int r) 4998 { 4999 write_insn<big_endian>(p, ld_0_1 + 16); 5000 p = p + 4; 5001 p = restfpr<big_endian>(p, r); 5002 write_insn<big_endian>(p, mtlr_0); 5003 p = p + 4; 5004 if (r == 29) 5005 { 5006 p = restfpr<big_endian>(p, 30); 5007 p = restfpr<big_endian>(p, 31); 5008 } 5009 write_insn<big_endian>(p, blr); 5010 return p + 4; 5011 } 5012 5013 template<bool big_endian> 5014 static unsigned char* 5015 savefpr1_tail(unsigned char* p, int r) 5016 { 5017 p = savefpr<big_endian>(p, r); 5018 write_insn<big_endian>(p, blr); 5019 return p + 4; 5020 } 5021 5022 template<bool big_endian> 5023 static unsigned char* 5024 restfpr1_tail(unsigned char* p, int r) 5025 { 5026 p = restfpr<big_endian>(p, r); 5027 write_insn<big_endian>(p, blr); 5028 return p + 4; 5029 } 5030 5031 template<bool big_endian> 5032 static unsigned char* 5033 savevr(unsigned char* p, int r) 5034 { 5035 uint32_t insn = li_12_0 + (1 << 16) - (32 - r) * 16; 5036 write_insn<big_endian>(p, insn); 5037 p = p + 4; 5038 insn = stvx_0_12_0 + (r << 21); 5039 write_insn<big_endian>(p, insn); 5040 return p + 4; 5041 } 5042 5043 template<bool big_endian> 5044 static unsigned char* 5045 savevr_tail(unsigned char* p, int r) 5046 { 5047 p = savevr<big_endian>(p, r); 5048 write_insn<big_endian>(p, blr); 5049 return p + 4; 5050 } 5051 5052 template<bool big_endian> 5053 static unsigned char* 5054 restvr(unsigned char* p, int r) 5055 { 5056 uint32_t insn = li_12_0 + (1 << 16) - (32 - r) * 16; 5057 write_insn<big_endian>(p, insn); 5058 p = p + 4; 5059 insn = lvx_0_12_0 + (r << 21); 5060 write_insn<big_endian>(p, insn); 5061 return p + 4; 5062 } 5063 5064 template<bool big_endian> 5065 static unsigned char* 5066 restvr_tail(unsigned char* p, int r) 5067 { 5068 p = restvr<big_endian>(p, r); 5069 write_insn<big_endian>(p, blr); 5070 return p + 4; 5071 } 5072 5073 5074 template<int size, bool big_endian> 5075 Output_data_save_res<size, big_endian>::Output_data_save_res( 5076 Symbol_table* symtab) 5077 : Output_section_data_build(4), 5078 contents_(NULL) 5079 { 5080 this->savres_define(symtab, 5081 "_savegpr0_", 14, 31, 5082 savegpr0<big_endian>, savegpr0_tail<big_endian>); 5083 this->savres_define(symtab, 5084 "_restgpr0_", 14, 29, 5085 restgpr0<big_endian>, restgpr0_tail<big_endian>); 5086 this->savres_define(symtab, 5087 "_restgpr0_", 30, 31, 5088 restgpr0<big_endian>, restgpr0_tail<big_endian>); 5089 this->savres_define(symtab, 5090 "_savegpr1_", 14, 31, 5091 savegpr1<big_endian>, savegpr1_tail<big_endian>); 5092 this->savres_define(symtab, 5093 "_restgpr1_", 14, 31, 5094 restgpr1<big_endian>, restgpr1_tail<big_endian>); 5095 this->savres_define(symtab, 5096 "_savefpr_", 14, 31, 5097 savefpr<big_endian>, savefpr0_tail<big_endian>); 5098 this->savres_define(symtab, 5099 "_restfpr_", 14, 29, 5100 restfpr<big_endian>, restfpr0_tail<big_endian>); 5101 this->savres_define(symtab, 5102 "_restfpr_", 30, 31, 5103 restfpr<big_endian>, restfpr0_tail<big_endian>); 5104 this->savres_define(symtab, 5105 "._savef", 14, 31, 5106 savefpr<big_endian>, savefpr1_tail<big_endian>); 5107 this->savres_define(symtab, 5108 "._restf", 14, 31, 5109 restfpr<big_endian>, restfpr1_tail<big_endian>); 5110 this->savres_define(symtab, 5111 "_savevr_", 20, 31, 5112 savevr<big_endian>, savevr_tail<big_endian>); 5113 this->savres_define(symtab, 5114 "_restvr_", 20, 31, 5115 restvr<big_endian>, restvr_tail<big_endian>); 5116 } 5117 5118 template<int size, bool big_endian> 5119 void 5120 Output_data_save_res<size, big_endian>::savres_define( 5121 Symbol_table* symtab, 5122 const char *name, 5123 unsigned int lo, unsigned int hi, 5124 unsigned char* write_ent(unsigned char*, int), 5125 unsigned char* write_tail(unsigned char*, int)) 5126 { 5127 size_t len = strlen(name); 5128 bool writing = false; 5129 char sym[16]; 5130 5131 memcpy(sym, name, len); 5132 sym[len + 2] = 0; 5133 5134 for (unsigned int i = lo; i <= hi; i++) 5135 { 5136 sym[len + 0] = i / 10 + '0'; 5137 sym[len + 1] = i % 10 + '0'; 5138 Symbol* gsym = symtab->lookup(sym); 5139 bool refd = gsym != NULL && gsym->is_undefined(); 5140 writing = writing || refd; 5141 if (writing) 5142 { 5143 if (this->contents_ == NULL) 5144 this->contents_ = new unsigned char[this->savres_max]; 5145 5146 section_size_type value = this->current_data_size(); 5147 unsigned char* p = this->contents_ + value; 5148 if (i != hi) 5149 p = write_ent(p, i); 5150 else 5151 p = write_tail(p, i); 5152 section_size_type cur_size = p - this->contents_; 5153 this->set_current_data_size(cur_size); 5154 if (refd) 5155 symtab->define_in_output_data(sym, NULL, Symbol_table::PREDEFINED, 5156 this, value, cur_size - value, 5157 elfcpp::STT_FUNC, elfcpp::STB_GLOBAL, 5158 elfcpp::STV_HIDDEN, 0, false, false); 5159 } 5160 } 5161 } 5162 5163 // Write out save/restore. 5164 5165 template<int size, bool big_endian> 5166 void 5167 Output_data_save_res<size, big_endian>::do_write(Output_file* of) 5168 { 5169 const section_size_type off = this->offset(); 5170 const section_size_type oview_size = 5171 convert_to_section_size_type(this->data_size()); 5172 unsigned char* const oview = of->get_output_view(off, oview_size); 5173 memcpy(oview, this->contents_, oview_size); 5174 of->write_output_view(off, oview_size, oview); 5175 } 5176 5177 5178 // Create the glink section. 5179 5180 template<int size, bool big_endian> 5181 void 5182 Target_powerpc<size, big_endian>::make_glink_section(Layout* layout) 5183 { 5184 if (this->glink_ == NULL) 5185 { 5186 this->glink_ = new Output_data_glink<size, big_endian>(this); 5187 this->glink_->add_eh_frame(layout); 5188 layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS, 5189 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR, 5190 this->glink_, ORDER_TEXT, false); 5191 } 5192 } 5193 5194 // Create a PLT entry for a global symbol. 5195 5196 template<int size, bool big_endian> 5197 void 5198 Target_powerpc<size, big_endian>::make_plt_entry(Symbol_table* symtab, 5199 Layout* layout, 5200 Symbol* gsym) 5201 { 5202 if (gsym->type() == elfcpp::STT_GNU_IFUNC 5203 && gsym->can_use_relative_reloc(false)) 5204 { 5205 if (this->iplt_ == NULL) 5206 this->make_iplt_section(symtab, layout); 5207 this->iplt_->add_ifunc_entry(gsym); 5208 } 5209 else 5210 { 5211 if (this->plt_ == NULL) 5212 this->make_plt_section(symtab, layout); 5213 this->plt_->add_entry(gsym); 5214 } 5215 } 5216 5217 // Make a PLT entry for a local STT_GNU_IFUNC symbol. 5218 5219 template<int size, bool big_endian> 5220 void 5221 Target_powerpc<size, big_endian>::make_local_ifunc_plt_entry( 5222 Symbol_table* symtab, 5223 Layout* layout, 5224 Sized_relobj_file<size, big_endian>* relobj, 5225 unsigned int r_sym) 5226 { 5227 if (this->iplt_ == NULL) 5228 this->make_iplt_section(symtab, layout); 5229 this->iplt_->add_local_ifunc_entry(relobj, r_sym); 5230 } 5231 5232 // Return the number of entries in the PLT. 5233 5234 template<int size, bool big_endian> 5235 unsigned int 5236 Target_powerpc<size, big_endian>::plt_entry_count() const 5237 { 5238 if (this->plt_ == NULL) 5239 return 0; 5240 return this->plt_->entry_count(); 5241 } 5242 5243 // Create a GOT entry for local dynamic __tls_get_addr calls. 5244 5245 template<int size, bool big_endian> 5246 unsigned int 5247 Target_powerpc<size, big_endian>::tlsld_got_offset( 5248 Symbol_table* symtab, 5249 Layout* layout, 5250 Sized_relobj_file<size, big_endian>* object) 5251 { 5252 if (this->tlsld_got_offset_ == -1U) 5253 { 5254 gold_assert(symtab != NULL && layout != NULL && object != NULL); 5255 Reloc_section* rela_dyn = this->rela_dyn_section(layout); 5256 Output_data_got_powerpc<size, big_endian>* got 5257 = this->got_section(symtab, layout); 5258 unsigned int got_offset = got->add_constant_pair(0, 0); 5259 rela_dyn->add_local(object, 0, elfcpp::R_POWERPC_DTPMOD, got, 5260 got_offset, 0); 5261 this->tlsld_got_offset_ = got_offset; 5262 } 5263 return this->tlsld_got_offset_; 5264 } 5265 5266 // Get the Reference_flags for a particular relocation. 5267 5268 template<int size, bool big_endian> 5269 int 5270 Target_powerpc<size, big_endian>::Scan::get_reference_flags( 5271 unsigned int r_type, 5272 const Target_powerpc* target) 5273 { 5274 int ref = 0; 5275 5276 switch (r_type) 5277 { 5278 case elfcpp::R_POWERPC_NONE: 5279 case elfcpp::R_POWERPC_GNU_VTINHERIT: 5280 case elfcpp::R_POWERPC_GNU_VTENTRY: 5281 case elfcpp::R_PPC64_TOC: 5282 // No symbol reference. 5283 break; 5284 5285 case elfcpp::R_PPC64_ADDR64: 5286 case elfcpp::R_PPC64_UADDR64: 5287 case elfcpp::R_POWERPC_ADDR32: 5288 case elfcpp::R_POWERPC_UADDR32: 5289 case elfcpp::R_POWERPC_ADDR16: 5290 case elfcpp::R_POWERPC_UADDR16: 5291 case elfcpp::R_POWERPC_ADDR16_LO: 5292 case elfcpp::R_POWERPC_ADDR16_HI: 5293 case elfcpp::R_POWERPC_ADDR16_HA: 5294 ref = Symbol::ABSOLUTE_REF; 5295 break; 5296 5297 case elfcpp::R_POWERPC_ADDR24: 5298 case elfcpp::R_POWERPC_ADDR14: 5299 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 5300 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 5301 ref = Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF; 5302 break; 5303 5304 case elfcpp::R_PPC64_REL64: 5305 case elfcpp::R_POWERPC_REL32: 5306 case elfcpp::R_PPC_LOCAL24PC: 5307 case elfcpp::R_POWERPC_REL16: 5308 case elfcpp::R_POWERPC_REL16_LO: 5309 case elfcpp::R_POWERPC_REL16_HI: 5310 case elfcpp::R_POWERPC_REL16_HA: 5311 ref = Symbol::RELATIVE_REF; 5312 break; 5313 5314 case elfcpp::R_POWERPC_REL24: 5315 case elfcpp::R_PPC_PLTREL24: 5316 case elfcpp::R_POWERPC_REL14: 5317 case elfcpp::R_POWERPC_REL14_BRTAKEN: 5318 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 5319 ref = Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF; 5320 break; 5321 5322 case elfcpp::R_POWERPC_GOT16: 5323 case elfcpp::R_POWERPC_GOT16_LO: 5324 case elfcpp::R_POWERPC_GOT16_HI: 5325 case elfcpp::R_POWERPC_GOT16_HA: 5326 case elfcpp::R_PPC64_GOT16_DS: 5327 case elfcpp::R_PPC64_GOT16_LO_DS: 5328 case elfcpp::R_PPC64_TOC16: 5329 case elfcpp::R_PPC64_TOC16_LO: 5330 case elfcpp::R_PPC64_TOC16_HI: 5331 case elfcpp::R_PPC64_TOC16_HA: 5332 case elfcpp::R_PPC64_TOC16_DS: 5333 case elfcpp::R_PPC64_TOC16_LO_DS: 5334 ref = Symbol::RELATIVE_REF; 5335 break; 5336 5337 case elfcpp::R_POWERPC_GOT_TPREL16: 5338 case elfcpp::R_POWERPC_TLS: 5339 ref = Symbol::TLS_REF; 5340 break; 5341 5342 case elfcpp::R_POWERPC_COPY: 5343 case elfcpp::R_POWERPC_GLOB_DAT: 5344 case elfcpp::R_POWERPC_JMP_SLOT: 5345 case elfcpp::R_POWERPC_RELATIVE: 5346 case elfcpp::R_POWERPC_DTPMOD: 5347 default: 5348 // Not expected. We will give an error later. 5349 break; 5350 } 5351 5352 if (size == 64 && target->abiversion() < 2) 5353 ref |= Symbol::FUNC_DESC_ABI; 5354 return ref; 5355 } 5356 5357 // Report an unsupported relocation against a local symbol. 5358 5359 template<int size, bool big_endian> 5360 void 5361 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_local( 5362 Sized_relobj_file<size, big_endian>* object, 5363 unsigned int r_type) 5364 { 5365 gold_error(_("%s: unsupported reloc %u against local symbol"), 5366 object->name().c_str(), r_type); 5367 } 5368 5369 // We are about to emit a dynamic relocation of type R_TYPE. If the 5370 // dynamic linker does not support it, issue an error. 5371 5372 template<int size, bool big_endian> 5373 void 5374 Target_powerpc<size, big_endian>::Scan::check_non_pic(Relobj* object, 5375 unsigned int r_type) 5376 { 5377 gold_assert(r_type != elfcpp::R_POWERPC_NONE); 5378 5379 // These are the relocation types supported by glibc for both 32-bit 5380 // and 64-bit powerpc. 5381 switch (r_type) 5382 { 5383 case elfcpp::R_POWERPC_NONE: 5384 case elfcpp::R_POWERPC_RELATIVE: 5385 case elfcpp::R_POWERPC_GLOB_DAT: 5386 case elfcpp::R_POWERPC_DTPMOD: 5387 case elfcpp::R_POWERPC_DTPREL: 5388 case elfcpp::R_POWERPC_TPREL: 5389 case elfcpp::R_POWERPC_JMP_SLOT: 5390 case elfcpp::R_POWERPC_COPY: 5391 case elfcpp::R_POWERPC_IRELATIVE: 5392 case elfcpp::R_POWERPC_ADDR32: 5393 case elfcpp::R_POWERPC_UADDR32: 5394 case elfcpp::R_POWERPC_ADDR24: 5395 case elfcpp::R_POWERPC_ADDR16: 5396 case elfcpp::R_POWERPC_UADDR16: 5397 case elfcpp::R_POWERPC_ADDR16_LO: 5398 case elfcpp::R_POWERPC_ADDR16_HI: 5399 case elfcpp::R_POWERPC_ADDR16_HA: 5400 case elfcpp::R_POWERPC_ADDR14: 5401 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 5402 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 5403 case elfcpp::R_POWERPC_REL32: 5404 case elfcpp::R_POWERPC_REL24: 5405 case elfcpp::R_POWERPC_TPREL16: 5406 case elfcpp::R_POWERPC_TPREL16_LO: 5407 case elfcpp::R_POWERPC_TPREL16_HI: 5408 case elfcpp::R_POWERPC_TPREL16_HA: 5409 return; 5410 5411 default: 5412 break; 5413 } 5414 5415 if (size == 64) 5416 { 5417 switch (r_type) 5418 { 5419 // These are the relocation types supported only on 64-bit. 5420 case elfcpp::R_PPC64_ADDR64: 5421 case elfcpp::R_PPC64_UADDR64: 5422 case elfcpp::R_PPC64_JMP_IREL: 5423 case elfcpp::R_PPC64_ADDR16_DS: 5424 case elfcpp::R_PPC64_ADDR16_LO_DS: 5425 case elfcpp::R_PPC64_ADDR16_HIGH: 5426 case elfcpp::R_PPC64_ADDR16_HIGHA: 5427 case elfcpp::R_PPC64_ADDR16_HIGHER: 5428 case elfcpp::R_PPC64_ADDR16_HIGHEST: 5429 case elfcpp::R_PPC64_ADDR16_HIGHERA: 5430 case elfcpp::R_PPC64_ADDR16_HIGHESTA: 5431 case elfcpp::R_PPC64_REL64: 5432 case elfcpp::R_POWERPC_ADDR30: 5433 case elfcpp::R_PPC64_TPREL16_DS: 5434 case elfcpp::R_PPC64_TPREL16_LO_DS: 5435 case elfcpp::R_PPC64_TPREL16_HIGH: 5436 case elfcpp::R_PPC64_TPREL16_HIGHA: 5437 case elfcpp::R_PPC64_TPREL16_HIGHER: 5438 case elfcpp::R_PPC64_TPREL16_HIGHEST: 5439 case elfcpp::R_PPC64_TPREL16_HIGHERA: 5440 case elfcpp::R_PPC64_TPREL16_HIGHESTA: 5441 return; 5442 5443 default: 5444 break; 5445 } 5446 } 5447 else 5448 { 5449 switch (r_type) 5450 { 5451 // These are the relocation types supported only on 32-bit. 5452 // ??? glibc ld.so doesn't need to support these. 5453 case elfcpp::R_POWERPC_DTPREL16: 5454 case elfcpp::R_POWERPC_DTPREL16_LO: 5455 case elfcpp::R_POWERPC_DTPREL16_HI: 5456 case elfcpp::R_POWERPC_DTPREL16_HA: 5457 return; 5458 5459 default: 5460 break; 5461 } 5462 } 5463 5464 // This prevents us from issuing more than one error per reloc 5465 // section. But we can still wind up issuing more than one 5466 // error per object file. 5467 if (this->issued_non_pic_error_) 5468 return; 5469 gold_assert(parameters->options().output_is_position_independent()); 5470 object->error(_("requires unsupported dynamic reloc; " 5471 "recompile with -fPIC")); 5472 this->issued_non_pic_error_ = true; 5473 return; 5474 } 5475 5476 // Return whether we need to make a PLT entry for a relocation of the 5477 // given type against a STT_GNU_IFUNC symbol. 5478 5479 template<int size, bool big_endian> 5480 bool 5481 Target_powerpc<size, big_endian>::Scan::reloc_needs_plt_for_ifunc( 5482 Target_powerpc<size, big_endian>* target, 5483 Sized_relobj_file<size, big_endian>* object, 5484 unsigned int r_type, 5485 bool report_err) 5486 { 5487 // In non-pic code any reference will resolve to the plt call stub 5488 // for the ifunc symbol. 5489 if ((size == 32 || target->abiversion() >= 2) 5490 && !parameters->options().output_is_position_independent()) 5491 return true; 5492 5493 switch (r_type) 5494 { 5495 // Word size refs from data sections are OK, but don't need a PLT entry. 5496 case elfcpp::R_POWERPC_ADDR32: 5497 case elfcpp::R_POWERPC_UADDR32: 5498 if (size == 32) 5499 return false; 5500 break; 5501 5502 case elfcpp::R_PPC64_ADDR64: 5503 case elfcpp::R_PPC64_UADDR64: 5504 if (size == 64) 5505 return false; 5506 break; 5507 5508 // GOT refs are good, but also don't need a PLT entry. 5509 case elfcpp::R_POWERPC_GOT16: 5510 case elfcpp::R_POWERPC_GOT16_LO: 5511 case elfcpp::R_POWERPC_GOT16_HI: 5512 case elfcpp::R_POWERPC_GOT16_HA: 5513 case elfcpp::R_PPC64_GOT16_DS: 5514 case elfcpp::R_PPC64_GOT16_LO_DS: 5515 return false; 5516 5517 // Function calls are good, and these do need a PLT entry. 5518 case elfcpp::R_POWERPC_ADDR24: 5519 case elfcpp::R_POWERPC_ADDR14: 5520 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 5521 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 5522 case elfcpp::R_POWERPC_REL24: 5523 case elfcpp::R_PPC_PLTREL24: 5524 case elfcpp::R_POWERPC_REL14: 5525 case elfcpp::R_POWERPC_REL14_BRTAKEN: 5526 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 5527 return true; 5528 5529 default: 5530 break; 5531 } 5532 5533 // Anything else is a problem. 5534 // If we are building a static executable, the libc startup function 5535 // responsible for applying indirect function relocations is going 5536 // to complain about the reloc type. 5537 // If we are building a dynamic executable, we will have a text 5538 // relocation. The dynamic loader will set the text segment 5539 // writable and non-executable to apply text relocations. So we'll 5540 // segfault when trying to run the indirection function to resolve 5541 // the reloc. 5542 if (report_err) 5543 gold_error(_("%s: unsupported reloc %u for IFUNC symbol"), 5544 object->name().c_str(), r_type); 5545 return false; 5546 } 5547 5548 // Scan a relocation for a local symbol. 5549 5550 template<int size, bool big_endian> 5551 inline void 5552 Target_powerpc<size, big_endian>::Scan::local( 5553 Symbol_table* symtab, 5554 Layout* layout, 5555 Target_powerpc<size, big_endian>* target, 5556 Sized_relobj_file<size, big_endian>* object, 5557 unsigned int data_shndx, 5558 Output_section* output_section, 5559 const elfcpp::Rela<size, big_endian>& reloc, 5560 unsigned int r_type, 5561 const elfcpp::Sym<size, big_endian>& lsym, 5562 bool is_discarded) 5563 { 5564 this->maybe_skip_tls_get_addr_call(r_type, NULL); 5565 5566 if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD) 5567 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD)) 5568 { 5569 this->expect_tls_get_addr_call(); 5570 const tls::Tls_optimization tls_type = target->optimize_tls_gd(true); 5571 if (tls_type != tls::TLSOPT_NONE) 5572 this->skip_next_tls_get_addr_call(); 5573 } 5574 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD) 5575 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD)) 5576 { 5577 this->expect_tls_get_addr_call(); 5578 const tls::Tls_optimization tls_type = target->optimize_tls_ld(); 5579 if (tls_type != tls::TLSOPT_NONE) 5580 this->skip_next_tls_get_addr_call(); 5581 } 5582 5583 Powerpc_relobj<size, big_endian>* ppc_object 5584 = static_cast<Powerpc_relobj<size, big_endian>*>(object); 5585 5586 if (is_discarded) 5587 { 5588 if (size == 64 5589 && data_shndx == ppc_object->opd_shndx() 5590 && r_type == elfcpp::R_PPC64_ADDR64) 5591 ppc_object->set_opd_discard(reloc.get_r_offset()); 5592 return; 5593 } 5594 5595 // A local STT_GNU_IFUNC symbol may require a PLT entry. 5596 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC; 5597 if (is_ifunc && this->reloc_needs_plt_for_ifunc(target, object, r_type, true)) 5598 { 5599 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 5600 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(), 5601 r_type, r_sym, reloc.get_r_addend()); 5602 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym); 5603 } 5604 5605 switch (r_type) 5606 { 5607 case elfcpp::R_POWERPC_NONE: 5608 case elfcpp::R_POWERPC_GNU_VTINHERIT: 5609 case elfcpp::R_POWERPC_GNU_VTENTRY: 5610 case elfcpp::R_PPC64_TOCSAVE: 5611 case elfcpp::R_POWERPC_TLS: 5612 case elfcpp::R_PPC64_ENTRY: 5613 break; 5614 5615 case elfcpp::R_PPC64_TOC: 5616 { 5617 Output_data_got_powerpc<size, big_endian>* got 5618 = target->got_section(symtab, layout); 5619 if (parameters->options().output_is_position_independent()) 5620 { 5621 Address off = reloc.get_r_offset(); 5622 if (size == 64 5623 && target->abiversion() < 2 5624 && data_shndx == ppc_object->opd_shndx() 5625 && ppc_object->get_opd_discard(off - 8)) 5626 break; 5627 5628 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 5629 Powerpc_relobj<size, big_endian>* symobj = ppc_object; 5630 rela_dyn->add_output_section_relative(got->output_section(), 5631 elfcpp::R_POWERPC_RELATIVE, 5632 output_section, 5633 object, data_shndx, off, 5634 symobj->toc_base_offset()); 5635 } 5636 } 5637 break; 5638 5639 case elfcpp::R_PPC64_ADDR64: 5640 case elfcpp::R_PPC64_UADDR64: 5641 case elfcpp::R_POWERPC_ADDR32: 5642 case elfcpp::R_POWERPC_UADDR32: 5643 case elfcpp::R_POWERPC_ADDR24: 5644 case elfcpp::R_POWERPC_ADDR16: 5645 case elfcpp::R_POWERPC_ADDR16_LO: 5646 case elfcpp::R_POWERPC_ADDR16_HI: 5647 case elfcpp::R_POWERPC_ADDR16_HA: 5648 case elfcpp::R_POWERPC_UADDR16: 5649 case elfcpp::R_PPC64_ADDR16_HIGH: 5650 case elfcpp::R_PPC64_ADDR16_HIGHA: 5651 case elfcpp::R_PPC64_ADDR16_HIGHER: 5652 case elfcpp::R_PPC64_ADDR16_HIGHERA: 5653 case elfcpp::R_PPC64_ADDR16_HIGHEST: 5654 case elfcpp::R_PPC64_ADDR16_HIGHESTA: 5655 case elfcpp::R_PPC64_ADDR16_DS: 5656 case elfcpp::R_PPC64_ADDR16_LO_DS: 5657 case elfcpp::R_POWERPC_ADDR14: 5658 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 5659 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 5660 // If building a shared library (or a position-independent 5661 // executable), we need to create a dynamic relocation for 5662 // this location. 5663 if (parameters->options().output_is_position_independent() 5664 || (size == 64 && is_ifunc && target->abiversion() < 2)) 5665 { 5666 Reloc_section* rela_dyn = target->rela_dyn_section(symtab, layout, 5667 is_ifunc); 5668 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 5669 if ((size == 32 && r_type == elfcpp::R_POWERPC_ADDR32) 5670 || (size == 64 && r_type == elfcpp::R_PPC64_ADDR64)) 5671 { 5672 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE 5673 : elfcpp::R_POWERPC_RELATIVE); 5674 rela_dyn->add_local_relative(object, r_sym, dynrel, 5675 output_section, data_shndx, 5676 reloc.get_r_offset(), 5677 reloc.get_r_addend(), false); 5678 } 5679 else if (lsym.get_st_type() != elfcpp::STT_SECTION) 5680 { 5681 check_non_pic(object, r_type); 5682 rela_dyn->add_local(object, r_sym, r_type, output_section, 5683 data_shndx, reloc.get_r_offset(), 5684 reloc.get_r_addend()); 5685 } 5686 else 5687 { 5688 gold_assert(lsym.get_st_value() == 0); 5689 unsigned int shndx = lsym.get_st_shndx(); 5690 bool is_ordinary; 5691 shndx = object->adjust_sym_shndx(r_sym, shndx, 5692 &is_ordinary); 5693 if (!is_ordinary) 5694 object->error(_("section symbol %u has bad shndx %u"), 5695 r_sym, shndx); 5696 else 5697 rela_dyn->add_local_section(object, shndx, r_type, 5698 output_section, data_shndx, 5699 reloc.get_r_offset()); 5700 } 5701 } 5702 break; 5703 5704 case elfcpp::R_POWERPC_REL24: 5705 case elfcpp::R_PPC_PLTREL24: 5706 case elfcpp::R_PPC_LOCAL24PC: 5707 case elfcpp::R_POWERPC_REL14: 5708 case elfcpp::R_POWERPC_REL14_BRTAKEN: 5709 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 5710 if (!is_ifunc) 5711 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(), 5712 r_type, elfcpp::elf_r_sym<size>(reloc.get_r_info()), 5713 reloc.get_r_addend()); 5714 break; 5715 5716 case elfcpp::R_PPC64_REL64: 5717 case elfcpp::R_POWERPC_REL32: 5718 case elfcpp::R_POWERPC_REL16: 5719 case elfcpp::R_POWERPC_REL16_LO: 5720 case elfcpp::R_POWERPC_REL16_HI: 5721 case elfcpp::R_POWERPC_REL16_HA: 5722 case elfcpp::R_POWERPC_REL16DX_HA: 5723 case elfcpp::R_POWERPC_SECTOFF: 5724 case elfcpp::R_POWERPC_SECTOFF_LO: 5725 case elfcpp::R_POWERPC_SECTOFF_HI: 5726 case elfcpp::R_POWERPC_SECTOFF_HA: 5727 case elfcpp::R_PPC64_SECTOFF_DS: 5728 case elfcpp::R_PPC64_SECTOFF_LO_DS: 5729 case elfcpp::R_POWERPC_TPREL16: 5730 case elfcpp::R_POWERPC_TPREL16_LO: 5731 case elfcpp::R_POWERPC_TPREL16_HI: 5732 case elfcpp::R_POWERPC_TPREL16_HA: 5733 case elfcpp::R_PPC64_TPREL16_DS: 5734 case elfcpp::R_PPC64_TPREL16_LO_DS: 5735 case elfcpp::R_PPC64_TPREL16_HIGH: 5736 case elfcpp::R_PPC64_TPREL16_HIGHA: 5737 case elfcpp::R_PPC64_TPREL16_HIGHER: 5738 case elfcpp::R_PPC64_TPREL16_HIGHERA: 5739 case elfcpp::R_PPC64_TPREL16_HIGHEST: 5740 case elfcpp::R_PPC64_TPREL16_HIGHESTA: 5741 case elfcpp::R_POWERPC_DTPREL16: 5742 case elfcpp::R_POWERPC_DTPREL16_LO: 5743 case elfcpp::R_POWERPC_DTPREL16_HI: 5744 case elfcpp::R_POWERPC_DTPREL16_HA: 5745 case elfcpp::R_PPC64_DTPREL16_DS: 5746 case elfcpp::R_PPC64_DTPREL16_LO_DS: 5747 case elfcpp::R_PPC64_DTPREL16_HIGH: 5748 case elfcpp::R_PPC64_DTPREL16_HIGHA: 5749 case elfcpp::R_PPC64_DTPREL16_HIGHER: 5750 case elfcpp::R_PPC64_DTPREL16_HIGHERA: 5751 case elfcpp::R_PPC64_DTPREL16_HIGHEST: 5752 case elfcpp::R_PPC64_DTPREL16_HIGHESTA: 5753 case elfcpp::R_PPC64_TLSGD: 5754 case elfcpp::R_PPC64_TLSLD: 5755 case elfcpp::R_PPC64_ADDR64_LOCAL: 5756 break; 5757 5758 case elfcpp::R_POWERPC_GOT16: 5759 case elfcpp::R_POWERPC_GOT16_LO: 5760 case elfcpp::R_POWERPC_GOT16_HI: 5761 case elfcpp::R_POWERPC_GOT16_HA: 5762 case elfcpp::R_PPC64_GOT16_DS: 5763 case elfcpp::R_PPC64_GOT16_LO_DS: 5764 { 5765 // The symbol requires a GOT entry. 5766 Output_data_got_powerpc<size, big_endian>* got 5767 = target->got_section(symtab, layout); 5768 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 5769 5770 if (!parameters->options().output_is_position_independent()) 5771 { 5772 if (is_ifunc 5773 && (size == 32 || target->abiversion() >= 2)) 5774 got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD); 5775 else 5776 got->add_local(object, r_sym, GOT_TYPE_STANDARD); 5777 } 5778 else if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)) 5779 { 5780 // If we are generating a shared object or a pie, this 5781 // symbol's GOT entry will be set by a dynamic relocation. 5782 unsigned int off; 5783 off = got->add_constant(0); 5784 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off); 5785 5786 Reloc_section* rela_dyn = target->rela_dyn_section(symtab, layout, 5787 is_ifunc); 5788 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE 5789 : elfcpp::R_POWERPC_RELATIVE); 5790 rela_dyn->add_local_relative(object, r_sym, dynrel, 5791 got, off, 0, false); 5792 } 5793 } 5794 break; 5795 5796 case elfcpp::R_PPC64_TOC16: 5797 case elfcpp::R_PPC64_TOC16_LO: 5798 case elfcpp::R_PPC64_TOC16_HI: 5799 case elfcpp::R_PPC64_TOC16_HA: 5800 case elfcpp::R_PPC64_TOC16_DS: 5801 case elfcpp::R_PPC64_TOC16_LO_DS: 5802 // We need a GOT section. 5803 target->got_section(symtab, layout); 5804 break; 5805 5806 case elfcpp::R_POWERPC_GOT_TLSGD16: 5807 case elfcpp::R_POWERPC_GOT_TLSGD16_LO: 5808 case elfcpp::R_POWERPC_GOT_TLSGD16_HI: 5809 case elfcpp::R_POWERPC_GOT_TLSGD16_HA: 5810 { 5811 const tls::Tls_optimization tls_type = target->optimize_tls_gd(true); 5812 if (tls_type == tls::TLSOPT_NONE) 5813 { 5814 Output_data_got_powerpc<size, big_endian>* got 5815 = target->got_section(symtab, layout); 5816 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 5817 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 5818 got->add_local_tls_pair(object, r_sym, GOT_TYPE_TLSGD, 5819 rela_dyn, elfcpp::R_POWERPC_DTPMOD); 5820 } 5821 else if (tls_type == tls::TLSOPT_TO_LE) 5822 { 5823 // no GOT relocs needed for Local Exec. 5824 } 5825 else 5826 gold_unreachable(); 5827 } 5828 break; 5829 5830 case elfcpp::R_POWERPC_GOT_TLSLD16: 5831 case elfcpp::R_POWERPC_GOT_TLSLD16_LO: 5832 case elfcpp::R_POWERPC_GOT_TLSLD16_HI: 5833 case elfcpp::R_POWERPC_GOT_TLSLD16_HA: 5834 { 5835 const tls::Tls_optimization tls_type = target->optimize_tls_ld(); 5836 if (tls_type == tls::TLSOPT_NONE) 5837 target->tlsld_got_offset(symtab, layout, object); 5838 else if (tls_type == tls::TLSOPT_TO_LE) 5839 { 5840 // no GOT relocs needed for Local Exec. 5841 if (parameters->options().emit_relocs()) 5842 { 5843 Output_section* os = layout->tls_segment()->first_section(); 5844 gold_assert(os != NULL); 5845 os->set_needs_symtab_index(); 5846 } 5847 } 5848 else 5849 gold_unreachable(); 5850 } 5851 break; 5852 5853 case elfcpp::R_POWERPC_GOT_DTPREL16: 5854 case elfcpp::R_POWERPC_GOT_DTPREL16_LO: 5855 case elfcpp::R_POWERPC_GOT_DTPREL16_HI: 5856 case elfcpp::R_POWERPC_GOT_DTPREL16_HA: 5857 { 5858 Output_data_got_powerpc<size, big_endian>* got 5859 = target->got_section(symtab, layout); 5860 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 5861 got->add_local_tls(object, r_sym, GOT_TYPE_DTPREL); 5862 } 5863 break; 5864 5865 case elfcpp::R_POWERPC_GOT_TPREL16: 5866 case elfcpp::R_POWERPC_GOT_TPREL16_LO: 5867 case elfcpp::R_POWERPC_GOT_TPREL16_HI: 5868 case elfcpp::R_POWERPC_GOT_TPREL16_HA: 5869 { 5870 const tls::Tls_optimization tls_type = target->optimize_tls_ie(true); 5871 if (tls_type == tls::TLSOPT_NONE) 5872 { 5873 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 5874 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TPREL)) 5875 { 5876 Output_data_got_powerpc<size, big_endian>* got 5877 = target->got_section(symtab, layout); 5878 unsigned int off = got->add_constant(0); 5879 object->set_local_got_offset(r_sym, GOT_TYPE_TPREL, off); 5880 5881 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 5882 rela_dyn->add_symbolless_local_addend(object, r_sym, 5883 elfcpp::R_POWERPC_TPREL, 5884 got, off, 0); 5885 } 5886 } 5887 else if (tls_type == tls::TLSOPT_TO_LE) 5888 { 5889 // no GOT relocs needed for Local Exec. 5890 } 5891 else 5892 gold_unreachable(); 5893 } 5894 break; 5895 5896 default: 5897 unsupported_reloc_local(object, r_type); 5898 break; 5899 } 5900 5901 switch (r_type) 5902 { 5903 case elfcpp::R_POWERPC_GOT_TLSLD16: 5904 case elfcpp::R_POWERPC_GOT_TLSGD16: 5905 case elfcpp::R_POWERPC_GOT_TPREL16: 5906 case elfcpp::R_POWERPC_GOT_DTPREL16: 5907 case elfcpp::R_POWERPC_GOT16: 5908 case elfcpp::R_PPC64_GOT16_DS: 5909 case elfcpp::R_PPC64_TOC16: 5910 case elfcpp::R_PPC64_TOC16_DS: 5911 ppc_object->set_has_small_toc_reloc(); 5912 default: 5913 break; 5914 } 5915 } 5916 5917 // Report an unsupported relocation against a global symbol. 5918 5919 template<int size, bool big_endian> 5920 void 5921 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_global( 5922 Sized_relobj_file<size, big_endian>* object, 5923 unsigned int r_type, 5924 Symbol* gsym) 5925 { 5926 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 5927 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 5928 } 5929 5930 // Scan a relocation for a global symbol. 5931 5932 template<int size, bool big_endian> 5933 inline void 5934 Target_powerpc<size, big_endian>::Scan::global( 5935 Symbol_table* symtab, 5936 Layout* layout, 5937 Target_powerpc<size, big_endian>* target, 5938 Sized_relobj_file<size, big_endian>* object, 5939 unsigned int data_shndx, 5940 Output_section* output_section, 5941 const elfcpp::Rela<size, big_endian>& reloc, 5942 unsigned int r_type, 5943 Symbol* gsym) 5944 { 5945 if (this->maybe_skip_tls_get_addr_call(r_type, gsym) == Track_tls::SKIP) 5946 return; 5947 5948 if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD) 5949 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD)) 5950 { 5951 this->expect_tls_get_addr_call(); 5952 const bool final = gsym->final_value_is_known(); 5953 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final); 5954 if (tls_type != tls::TLSOPT_NONE) 5955 this->skip_next_tls_get_addr_call(); 5956 } 5957 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD) 5958 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD)) 5959 { 5960 this->expect_tls_get_addr_call(); 5961 const tls::Tls_optimization tls_type = target->optimize_tls_ld(); 5962 if (tls_type != tls::TLSOPT_NONE) 5963 this->skip_next_tls_get_addr_call(); 5964 } 5965 5966 Powerpc_relobj<size, big_endian>* ppc_object 5967 = static_cast<Powerpc_relobj<size, big_endian>*>(object); 5968 5969 // A STT_GNU_IFUNC symbol may require a PLT entry. 5970 bool is_ifunc = gsym->type() == elfcpp::STT_GNU_IFUNC; 5971 bool pushed_ifunc = false; 5972 if (is_ifunc && this->reloc_needs_plt_for_ifunc(target, object, r_type, true)) 5973 { 5974 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(), 5975 r_type, elfcpp::elf_r_sym<size>(reloc.get_r_info()), 5976 reloc.get_r_addend()); 5977 target->make_plt_entry(symtab, layout, gsym); 5978 pushed_ifunc = true; 5979 } 5980 5981 switch (r_type) 5982 { 5983 case elfcpp::R_POWERPC_NONE: 5984 case elfcpp::R_POWERPC_GNU_VTINHERIT: 5985 case elfcpp::R_POWERPC_GNU_VTENTRY: 5986 case elfcpp::R_PPC_LOCAL24PC: 5987 case elfcpp::R_POWERPC_TLS: 5988 case elfcpp::R_PPC64_ENTRY: 5989 break; 5990 5991 case elfcpp::R_PPC64_TOC: 5992 { 5993 Output_data_got_powerpc<size, big_endian>* got 5994 = target->got_section(symtab, layout); 5995 if (parameters->options().output_is_position_independent()) 5996 { 5997 Address off = reloc.get_r_offset(); 5998 if (size == 64 5999 && data_shndx == ppc_object->opd_shndx() 6000 && ppc_object->get_opd_discard(off - 8)) 6001 break; 6002 6003 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 6004 Powerpc_relobj<size, big_endian>* symobj = ppc_object; 6005 if (data_shndx != ppc_object->opd_shndx()) 6006 symobj = static_cast 6007 <Powerpc_relobj<size, big_endian>*>(gsym->object()); 6008 rela_dyn->add_output_section_relative(got->output_section(), 6009 elfcpp::R_POWERPC_RELATIVE, 6010 output_section, 6011 object, data_shndx, off, 6012 symobj->toc_base_offset()); 6013 } 6014 } 6015 break; 6016 6017 case elfcpp::R_PPC64_ADDR64: 6018 if (size == 64 6019 && target->abiversion() < 2 6020 && data_shndx == ppc_object->opd_shndx() 6021 && (gsym->is_defined_in_discarded_section() 6022 || gsym->object() != object)) 6023 { 6024 ppc_object->set_opd_discard(reloc.get_r_offset()); 6025 break; 6026 } 6027 // Fall thru 6028 case elfcpp::R_PPC64_UADDR64: 6029 case elfcpp::R_POWERPC_ADDR32: 6030 case elfcpp::R_POWERPC_UADDR32: 6031 case elfcpp::R_POWERPC_ADDR24: 6032 case elfcpp::R_POWERPC_ADDR16: 6033 case elfcpp::R_POWERPC_ADDR16_LO: 6034 case elfcpp::R_POWERPC_ADDR16_HI: 6035 case elfcpp::R_POWERPC_ADDR16_HA: 6036 case elfcpp::R_POWERPC_UADDR16: 6037 case elfcpp::R_PPC64_ADDR16_HIGH: 6038 case elfcpp::R_PPC64_ADDR16_HIGHA: 6039 case elfcpp::R_PPC64_ADDR16_HIGHER: 6040 case elfcpp::R_PPC64_ADDR16_HIGHERA: 6041 case elfcpp::R_PPC64_ADDR16_HIGHEST: 6042 case elfcpp::R_PPC64_ADDR16_HIGHESTA: 6043 case elfcpp::R_PPC64_ADDR16_DS: 6044 case elfcpp::R_PPC64_ADDR16_LO_DS: 6045 case elfcpp::R_POWERPC_ADDR14: 6046 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 6047 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 6048 { 6049 // Make a PLT entry if necessary. 6050 if (gsym->needs_plt_entry()) 6051 { 6052 // Since this is not a PC-relative relocation, we may be 6053 // taking the address of a function. In that case we need to 6054 // set the entry in the dynamic symbol table to the address of 6055 // the PLT call stub. 6056 bool need_ifunc_plt = false; 6057 if ((size == 32 || target->abiversion() >= 2) 6058 && gsym->is_from_dynobj() 6059 && !parameters->options().output_is_position_independent()) 6060 { 6061 gsym->set_needs_dynsym_value(); 6062 need_ifunc_plt = true; 6063 } 6064 if (!is_ifunc || (!pushed_ifunc && need_ifunc_plt)) 6065 { 6066 target->push_branch(ppc_object, data_shndx, 6067 reloc.get_r_offset(), r_type, 6068 elfcpp::elf_r_sym<size>(reloc.get_r_info()), 6069 reloc.get_r_addend()); 6070 target->make_plt_entry(symtab, layout, gsym); 6071 } 6072 } 6073 // Make a dynamic relocation if necessary. 6074 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type, target)) 6075 || (size == 64 && is_ifunc && target->abiversion() < 2)) 6076 { 6077 if (!parameters->options().output_is_position_independent() 6078 && gsym->may_need_copy_reloc()) 6079 { 6080 target->copy_reloc(symtab, layout, object, 6081 data_shndx, output_section, gsym, reloc); 6082 } 6083 else if ((((size == 32 6084 && r_type == elfcpp::R_POWERPC_ADDR32) 6085 || (size == 64 6086 && r_type == elfcpp::R_PPC64_ADDR64 6087 && target->abiversion() >= 2)) 6088 && gsym->can_use_relative_reloc(false) 6089 && !(gsym->visibility() == elfcpp::STV_PROTECTED 6090 && parameters->options().shared())) 6091 || (size == 64 6092 && r_type == elfcpp::R_PPC64_ADDR64 6093 && target->abiversion() < 2 6094 && (gsym->can_use_relative_reloc(false) 6095 || data_shndx == ppc_object->opd_shndx()))) 6096 { 6097 Reloc_section* rela_dyn 6098 = target->rela_dyn_section(symtab, layout, is_ifunc); 6099 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE 6100 : elfcpp::R_POWERPC_RELATIVE); 6101 rela_dyn->add_symbolless_global_addend( 6102 gsym, dynrel, output_section, object, data_shndx, 6103 reloc.get_r_offset(), reloc.get_r_addend()); 6104 } 6105 else 6106 { 6107 Reloc_section* rela_dyn 6108 = target->rela_dyn_section(symtab, layout, is_ifunc); 6109 check_non_pic(object, r_type); 6110 rela_dyn->add_global(gsym, r_type, output_section, 6111 object, data_shndx, 6112 reloc.get_r_offset(), 6113 reloc.get_r_addend()); 6114 } 6115 } 6116 } 6117 break; 6118 6119 case elfcpp::R_PPC_PLTREL24: 6120 case elfcpp::R_POWERPC_REL24: 6121 if (!is_ifunc) 6122 { 6123 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(), 6124 r_type, 6125 elfcpp::elf_r_sym<size>(reloc.get_r_info()), 6126 reloc.get_r_addend()); 6127 if (gsym->needs_plt_entry() 6128 || (!gsym->final_value_is_known() 6129 && (gsym->is_undefined() 6130 || gsym->is_from_dynobj() 6131 || gsym->is_preemptible()))) 6132 target->make_plt_entry(symtab, layout, gsym); 6133 } 6134 // Fall thru 6135 6136 case elfcpp::R_PPC64_REL64: 6137 case elfcpp::R_POWERPC_REL32: 6138 // Make a dynamic relocation if necessary. 6139 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type, target))) 6140 { 6141 if (!parameters->options().output_is_position_independent() 6142 && gsym->may_need_copy_reloc()) 6143 { 6144 target->copy_reloc(symtab, layout, object, 6145 data_shndx, output_section, gsym, 6146 reloc); 6147 } 6148 else 6149 { 6150 Reloc_section* rela_dyn 6151 = target->rela_dyn_section(symtab, layout, is_ifunc); 6152 check_non_pic(object, r_type); 6153 rela_dyn->add_global(gsym, r_type, output_section, object, 6154 data_shndx, reloc.get_r_offset(), 6155 reloc.get_r_addend()); 6156 } 6157 } 6158 break; 6159 6160 case elfcpp::R_POWERPC_REL14: 6161 case elfcpp::R_POWERPC_REL14_BRTAKEN: 6162 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 6163 if (!is_ifunc) 6164 target->push_branch(ppc_object, data_shndx, reloc.get_r_offset(), 6165 r_type, elfcpp::elf_r_sym<size>(reloc.get_r_info()), 6166 reloc.get_r_addend()); 6167 break; 6168 6169 case elfcpp::R_POWERPC_REL16: 6170 case elfcpp::R_POWERPC_REL16_LO: 6171 case elfcpp::R_POWERPC_REL16_HI: 6172 case elfcpp::R_POWERPC_REL16_HA: 6173 case elfcpp::R_POWERPC_REL16DX_HA: 6174 case elfcpp::R_POWERPC_SECTOFF: 6175 case elfcpp::R_POWERPC_SECTOFF_LO: 6176 case elfcpp::R_POWERPC_SECTOFF_HI: 6177 case elfcpp::R_POWERPC_SECTOFF_HA: 6178 case elfcpp::R_PPC64_SECTOFF_DS: 6179 case elfcpp::R_PPC64_SECTOFF_LO_DS: 6180 case elfcpp::R_POWERPC_TPREL16: 6181 case elfcpp::R_POWERPC_TPREL16_LO: 6182 case elfcpp::R_POWERPC_TPREL16_HI: 6183 case elfcpp::R_POWERPC_TPREL16_HA: 6184 case elfcpp::R_PPC64_TPREL16_DS: 6185 case elfcpp::R_PPC64_TPREL16_LO_DS: 6186 case elfcpp::R_PPC64_TPREL16_HIGH: 6187 case elfcpp::R_PPC64_TPREL16_HIGHA: 6188 case elfcpp::R_PPC64_TPREL16_HIGHER: 6189 case elfcpp::R_PPC64_TPREL16_HIGHERA: 6190 case elfcpp::R_PPC64_TPREL16_HIGHEST: 6191 case elfcpp::R_PPC64_TPREL16_HIGHESTA: 6192 case elfcpp::R_POWERPC_DTPREL16: 6193 case elfcpp::R_POWERPC_DTPREL16_LO: 6194 case elfcpp::R_POWERPC_DTPREL16_HI: 6195 case elfcpp::R_POWERPC_DTPREL16_HA: 6196 case elfcpp::R_PPC64_DTPREL16_DS: 6197 case elfcpp::R_PPC64_DTPREL16_LO_DS: 6198 case elfcpp::R_PPC64_DTPREL16_HIGH: 6199 case elfcpp::R_PPC64_DTPREL16_HIGHA: 6200 case elfcpp::R_PPC64_DTPREL16_HIGHER: 6201 case elfcpp::R_PPC64_DTPREL16_HIGHERA: 6202 case elfcpp::R_PPC64_DTPREL16_HIGHEST: 6203 case elfcpp::R_PPC64_DTPREL16_HIGHESTA: 6204 case elfcpp::R_PPC64_TLSGD: 6205 case elfcpp::R_PPC64_TLSLD: 6206 case elfcpp::R_PPC64_ADDR64_LOCAL: 6207 break; 6208 6209 case elfcpp::R_POWERPC_GOT16: 6210 case elfcpp::R_POWERPC_GOT16_LO: 6211 case elfcpp::R_POWERPC_GOT16_HI: 6212 case elfcpp::R_POWERPC_GOT16_HA: 6213 case elfcpp::R_PPC64_GOT16_DS: 6214 case elfcpp::R_PPC64_GOT16_LO_DS: 6215 { 6216 // The symbol requires a GOT entry. 6217 Output_data_got_powerpc<size, big_endian>* got; 6218 6219 got = target->got_section(symtab, layout); 6220 if (gsym->final_value_is_known()) 6221 { 6222 if (is_ifunc 6223 && (size == 32 || target->abiversion() >= 2)) 6224 got->add_global_plt(gsym, GOT_TYPE_STANDARD); 6225 else 6226 got->add_global(gsym, GOT_TYPE_STANDARD); 6227 } 6228 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD)) 6229 { 6230 // If we are generating a shared object or a pie, this 6231 // symbol's GOT entry will be set by a dynamic relocation. 6232 unsigned int off = got->add_constant(0); 6233 gsym->set_got_offset(GOT_TYPE_STANDARD, off); 6234 6235 Reloc_section* rela_dyn 6236 = target->rela_dyn_section(symtab, layout, is_ifunc); 6237 6238 if (gsym->can_use_relative_reloc(false) 6239 && !((size == 32 6240 || target->abiversion() >= 2) 6241 && gsym->visibility() == elfcpp::STV_PROTECTED 6242 && parameters->options().shared())) 6243 { 6244 unsigned int dynrel = (is_ifunc ? elfcpp::R_POWERPC_IRELATIVE 6245 : elfcpp::R_POWERPC_RELATIVE); 6246 rela_dyn->add_global_relative(gsym, dynrel, got, off, 0, false); 6247 } 6248 else 6249 { 6250 unsigned int dynrel = elfcpp::R_POWERPC_GLOB_DAT; 6251 rela_dyn->add_global(gsym, dynrel, got, off, 0); 6252 } 6253 } 6254 } 6255 break; 6256 6257 case elfcpp::R_PPC64_TOC16: 6258 case elfcpp::R_PPC64_TOC16_LO: 6259 case elfcpp::R_PPC64_TOC16_HI: 6260 case elfcpp::R_PPC64_TOC16_HA: 6261 case elfcpp::R_PPC64_TOC16_DS: 6262 case elfcpp::R_PPC64_TOC16_LO_DS: 6263 // We need a GOT section. 6264 target->got_section(symtab, layout); 6265 break; 6266 6267 case elfcpp::R_POWERPC_GOT_TLSGD16: 6268 case elfcpp::R_POWERPC_GOT_TLSGD16_LO: 6269 case elfcpp::R_POWERPC_GOT_TLSGD16_HI: 6270 case elfcpp::R_POWERPC_GOT_TLSGD16_HA: 6271 { 6272 const bool final = gsym->final_value_is_known(); 6273 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final); 6274 if (tls_type == tls::TLSOPT_NONE) 6275 { 6276 Output_data_got_powerpc<size, big_endian>* got 6277 = target->got_section(symtab, layout); 6278 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 6279 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLSGD, rela_dyn, 6280 elfcpp::R_POWERPC_DTPMOD, 6281 elfcpp::R_POWERPC_DTPREL); 6282 } 6283 else if (tls_type == tls::TLSOPT_TO_IE) 6284 { 6285 if (!gsym->has_got_offset(GOT_TYPE_TPREL)) 6286 { 6287 Output_data_got_powerpc<size, big_endian>* got 6288 = target->got_section(symtab, layout); 6289 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 6290 if (gsym->is_undefined() 6291 || gsym->is_from_dynobj()) 6292 { 6293 got->add_global_with_rel(gsym, GOT_TYPE_TPREL, rela_dyn, 6294 elfcpp::R_POWERPC_TPREL); 6295 } 6296 else 6297 { 6298 unsigned int off = got->add_constant(0); 6299 gsym->set_got_offset(GOT_TYPE_TPREL, off); 6300 unsigned int dynrel = elfcpp::R_POWERPC_TPREL; 6301 rela_dyn->add_symbolless_global_addend(gsym, dynrel, 6302 got, off, 0); 6303 } 6304 } 6305 } 6306 else if (tls_type == tls::TLSOPT_TO_LE) 6307 { 6308 // no GOT relocs needed for Local Exec. 6309 } 6310 else 6311 gold_unreachable(); 6312 } 6313 break; 6314 6315 case elfcpp::R_POWERPC_GOT_TLSLD16: 6316 case elfcpp::R_POWERPC_GOT_TLSLD16_LO: 6317 case elfcpp::R_POWERPC_GOT_TLSLD16_HI: 6318 case elfcpp::R_POWERPC_GOT_TLSLD16_HA: 6319 { 6320 const tls::Tls_optimization tls_type = target->optimize_tls_ld(); 6321 if (tls_type == tls::TLSOPT_NONE) 6322 target->tlsld_got_offset(symtab, layout, object); 6323 else if (tls_type == tls::TLSOPT_TO_LE) 6324 { 6325 // no GOT relocs needed for Local Exec. 6326 if (parameters->options().emit_relocs()) 6327 { 6328 Output_section* os = layout->tls_segment()->first_section(); 6329 gold_assert(os != NULL); 6330 os->set_needs_symtab_index(); 6331 } 6332 } 6333 else 6334 gold_unreachable(); 6335 } 6336 break; 6337 6338 case elfcpp::R_POWERPC_GOT_DTPREL16: 6339 case elfcpp::R_POWERPC_GOT_DTPREL16_LO: 6340 case elfcpp::R_POWERPC_GOT_DTPREL16_HI: 6341 case elfcpp::R_POWERPC_GOT_DTPREL16_HA: 6342 { 6343 Output_data_got_powerpc<size, big_endian>* got 6344 = target->got_section(symtab, layout); 6345 if (!gsym->final_value_is_known() 6346 && (gsym->is_from_dynobj() 6347 || gsym->is_undefined() 6348 || gsym->is_preemptible())) 6349 got->add_global_with_rel(gsym, GOT_TYPE_DTPREL, 6350 target->rela_dyn_section(layout), 6351 elfcpp::R_POWERPC_DTPREL); 6352 else 6353 got->add_global_tls(gsym, GOT_TYPE_DTPREL); 6354 } 6355 break; 6356 6357 case elfcpp::R_POWERPC_GOT_TPREL16: 6358 case elfcpp::R_POWERPC_GOT_TPREL16_LO: 6359 case elfcpp::R_POWERPC_GOT_TPREL16_HI: 6360 case elfcpp::R_POWERPC_GOT_TPREL16_HA: 6361 { 6362 const bool final = gsym->final_value_is_known(); 6363 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final); 6364 if (tls_type == tls::TLSOPT_NONE) 6365 { 6366 if (!gsym->has_got_offset(GOT_TYPE_TPREL)) 6367 { 6368 Output_data_got_powerpc<size, big_endian>* got 6369 = target->got_section(symtab, layout); 6370 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 6371 if (gsym->is_undefined() 6372 || gsym->is_from_dynobj()) 6373 { 6374 got->add_global_with_rel(gsym, GOT_TYPE_TPREL, rela_dyn, 6375 elfcpp::R_POWERPC_TPREL); 6376 } 6377 else 6378 { 6379 unsigned int off = got->add_constant(0); 6380 gsym->set_got_offset(GOT_TYPE_TPREL, off); 6381 unsigned int dynrel = elfcpp::R_POWERPC_TPREL; 6382 rela_dyn->add_symbolless_global_addend(gsym, dynrel, 6383 got, off, 0); 6384 } 6385 } 6386 } 6387 else if (tls_type == tls::TLSOPT_TO_LE) 6388 { 6389 // no GOT relocs needed for Local Exec. 6390 } 6391 else 6392 gold_unreachable(); 6393 } 6394 break; 6395 6396 default: 6397 unsupported_reloc_global(object, r_type, gsym); 6398 break; 6399 } 6400 6401 switch (r_type) 6402 { 6403 case elfcpp::R_POWERPC_GOT_TLSLD16: 6404 case elfcpp::R_POWERPC_GOT_TLSGD16: 6405 case elfcpp::R_POWERPC_GOT_TPREL16: 6406 case elfcpp::R_POWERPC_GOT_DTPREL16: 6407 case elfcpp::R_POWERPC_GOT16: 6408 case elfcpp::R_PPC64_GOT16_DS: 6409 case elfcpp::R_PPC64_TOC16: 6410 case elfcpp::R_PPC64_TOC16_DS: 6411 ppc_object->set_has_small_toc_reloc(); 6412 default: 6413 break; 6414 } 6415 } 6416 6417 // Process relocations for gc. 6418 6419 template<int size, bool big_endian> 6420 void 6421 Target_powerpc<size, big_endian>::gc_process_relocs( 6422 Symbol_table* symtab, 6423 Layout* layout, 6424 Sized_relobj_file<size, big_endian>* object, 6425 unsigned int data_shndx, 6426 unsigned int, 6427 const unsigned char* prelocs, 6428 size_t reloc_count, 6429 Output_section* output_section, 6430 bool needs_special_offset_handling, 6431 size_t local_symbol_count, 6432 const unsigned char* plocal_symbols) 6433 { 6434 typedef Target_powerpc<size, big_endian> Powerpc; 6435 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 6436 Classify_reloc; 6437 6438 Powerpc_relobj<size, big_endian>* ppc_object 6439 = static_cast<Powerpc_relobj<size, big_endian>*>(object); 6440 if (size == 64) 6441 ppc_object->set_opd_valid(); 6442 if (size == 64 && data_shndx == ppc_object->opd_shndx()) 6443 { 6444 typename Powerpc_relobj<size, big_endian>::Access_from::iterator p; 6445 for (p = ppc_object->access_from_map()->begin(); 6446 p != ppc_object->access_from_map()->end(); 6447 ++p) 6448 { 6449 Address dst_off = p->first; 6450 unsigned int dst_indx = ppc_object->get_opd_ent(dst_off); 6451 typename Powerpc_relobj<size, big_endian>::Section_refs::iterator s; 6452 for (s = p->second.begin(); s != p->second.end(); ++s) 6453 { 6454 Relobj* src_obj = s->first; 6455 unsigned int src_indx = s->second; 6456 symtab->gc()->add_reference(src_obj, src_indx, 6457 ppc_object, dst_indx); 6458 } 6459 p->second.clear(); 6460 } 6461 ppc_object->access_from_map()->clear(); 6462 ppc_object->process_gc_mark(symtab); 6463 // Don't look at .opd relocs as .opd will reference everything. 6464 return; 6465 } 6466 6467 gold::gc_process_relocs<size, big_endian, Powerpc, Scan, Classify_reloc>( 6468 symtab, 6469 layout, 6470 this, 6471 object, 6472 data_shndx, 6473 prelocs, 6474 reloc_count, 6475 output_section, 6476 needs_special_offset_handling, 6477 local_symbol_count, 6478 plocal_symbols); 6479 } 6480 6481 // Handle target specific gc actions when adding a gc reference from 6482 // SRC_OBJ, SRC_SHNDX to a location specified by DST_OBJ, DST_SHNDX 6483 // and DST_OFF. For powerpc64, this adds a referenc to the code 6484 // section of a function descriptor. 6485 6486 template<int size, bool big_endian> 6487 void 6488 Target_powerpc<size, big_endian>::do_gc_add_reference( 6489 Symbol_table* symtab, 6490 Relobj* src_obj, 6491 unsigned int src_shndx, 6492 Relobj* dst_obj, 6493 unsigned int dst_shndx, 6494 Address dst_off) const 6495 { 6496 if (size != 64 || dst_obj->is_dynamic()) 6497 return; 6498 6499 Powerpc_relobj<size, big_endian>* ppc_object 6500 = static_cast<Powerpc_relobj<size, big_endian>*>(dst_obj); 6501 if (dst_shndx != 0 && dst_shndx == ppc_object->opd_shndx()) 6502 { 6503 if (ppc_object->opd_valid()) 6504 { 6505 dst_shndx = ppc_object->get_opd_ent(dst_off); 6506 symtab->gc()->add_reference(src_obj, src_shndx, dst_obj, dst_shndx); 6507 } 6508 else 6509 { 6510 // If we haven't run scan_opd_relocs, we must delay 6511 // processing this function descriptor reference. 6512 ppc_object->add_reference(src_obj, src_shndx, dst_off); 6513 } 6514 } 6515 } 6516 6517 // Add any special sections for this symbol to the gc work list. 6518 // For powerpc64, this adds the code section of a function 6519 // descriptor. 6520 6521 template<int size, bool big_endian> 6522 void 6523 Target_powerpc<size, big_endian>::do_gc_mark_symbol( 6524 Symbol_table* symtab, 6525 Symbol* sym) const 6526 { 6527 if (size == 64) 6528 { 6529 Powerpc_relobj<size, big_endian>* ppc_object 6530 = static_cast<Powerpc_relobj<size, big_endian>*>(sym->object()); 6531 bool is_ordinary; 6532 unsigned int shndx = sym->shndx(&is_ordinary); 6533 if (is_ordinary && shndx != 0 && shndx == ppc_object->opd_shndx()) 6534 { 6535 Sized_symbol<size>* gsym = symtab->get_sized_symbol<size>(sym); 6536 Address dst_off = gsym->value(); 6537 if (ppc_object->opd_valid()) 6538 { 6539 unsigned int dst_indx = ppc_object->get_opd_ent(dst_off); 6540 symtab->gc()->worklist().push_back(Section_id(ppc_object, 6541 dst_indx)); 6542 } 6543 else 6544 ppc_object->add_gc_mark(dst_off); 6545 } 6546 } 6547 } 6548 6549 // For a symbol location in .opd, set LOC to the location of the 6550 // function entry. 6551 6552 template<int size, bool big_endian> 6553 void 6554 Target_powerpc<size, big_endian>::do_function_location( 6555 Symbol_location* loc) const 6556 { 6557 if (size == 64 && loc->shndx != 0) 6558 { 6559 if (loc->object->is_dynamic()) 6560 { 6561 Powerpc_dynobj<size, big_endian>* ppc_object 6562 = static_cast<Powerpc_dynobj<size, big_endian>*>(loc->object); 6563 if (loc->shndx == ppc_object->opd_shndx()) 6564 { 6565 Address dest_off; 6566 Address off = loc->offset - ppc_object->opd_address(); 6567 loc->shndx = ppc_object->get_opd_ent(off, &dest_off); 6568 loc->offset = dest_off; 6569 } 6570 } 6571 else 6572 { 6573 const Powerpc_relobj<size, big_endian>* ppc_object 6574 = static_cast<const Powerpc_relobj<size, big_endian>*>(loc->object); 6575 if (loc->shndx == ppc_object->opd_shndx()) 6576 { 6577 Address dest_off; 6578 loc->shndx = ppc_object->get_opd_ent(loc->offset, &dest_off); 6579 loc->offset = dest_off; 6580 } 6581 } 6582 } 6583 } 6584 6585 // FNOFFSET in section SHNDX in OBJECT is the start of a function 6586 // compiled with -fsplit-stack. The function calls non-split-stack 6587 // code. Change the function to ensure it has enough stack space to 6588 // call some random function. 6589 6590 template<int size, bool big_endian> 6591 void 6592 Target_powerpc<size, big_endian>::do_calls_non_split( 6593 Relobj* object, 6594 unsigned int shndx, 6595 section_offset_type fnoffset, 6596 section_size_type fnsize, 6597 const unsigned char* prelocs, 6598 size_t reloc_count, 6599 unsigned char* view, 6600 section_size_type view_size, 6601 std::string* from, 6602 std::string* to) const 6603 { 6604 // 32-bit not supported. 6605 if (size == 32) 6606 { 6607 // warn 6608 Target::do_calls_non_split(object, shndx, fnoffset, fnsize, 6609 prelocs, reloc_count, view, view_size, 6610 from, to); 6611 return; 6612 } 6613 6614 // The function always starts with 6615 // ld %r0,-0x7000-64(%r13) # tcbhead_t.__private_ss 6616 // addis %r12,%r1,-allocate@ha 6617 // addi %r12,%r12,-allocate@l 6618 // cmpld %r12,%r0 6619 // but note that the addis or addi may be replaced with a nop 6620 6621 unsigned char *entry = view + fnoffset; 6622 uint32_t insn = elfcpp::Swap<32, big_endian>::readval(entry); 6623 6624 if ((insn & 0xffff0000) == addis_2_12) 6625 { 6626 /* Skip ELFv2 global entry code. */ 6627 entry += 8; 6628 insn = elfcpp::Swap<32, big_endian>::readval(entry); 6629 } 6630 6631 unsigned char *pinsn = entry; 6632 bool ok = false; 6633 const uint32_t ld_private_ss = 0xe80d8fc0; 6634 if (insn == ld_private_ss) 6635 { 6636 int32_t allocate = 0; 6637 while (1) 6638 { 6639 pinsn += 4; 6640 insn = elfcpp::Swap<32, big_endian>::readval(pinsn); 6641 if ((insn & 0xffff0000) == addis_12_1) 6642 allocate += (insn & 0xffff) << 16; 6643 else if ((insn & 0xffff0000) == addi_12_1 6644 || (insn & 0xffff0000) == addi_12_12) 6645 allocate += ((insn & 0xffff) ^ 0x8000) - 0x8000; 6646 else if (insn != nop) 6647 break; 6648 } 6649 if (insn == cmpld_7_12_0 && pinsn == entry + 12) 6650 { 6651 int extra = parameters->options().split_stack_adjust_size(); 6652 allocate -= extra; 6653 if (allocate >= 0 || extra < 0) 6654 { 6655 object->error(_("split-stack stack size overflow at " 6656 "section %u offset %0zx"), 6657 shndx, static_cast<size_t>(fnoffset)); 6658 return; 6659 } 6660 pinsn = entry + 4; 6661 insn = addis_12_1 | (((allocate + 0x8000) >> 16) & 0xffff); 6662 if (insn != addis_12_1) 6663 { 6664 elfcpp::Swap<32, big_endian>::writeval(pinsn, insn); 6665 pinsn += 4; 6666 insn = addi_12_12 | (allocate & 0xffff); 6667 if (insn != addi_12_12) 6668 { 6669 elfcpp::Swap<32, big_endian>::writeval(pinsn, insn); 6670 pinsn += 4; 6671 } 6672 } 6673 else 6674 { 6675 insn = addi_12_1 | (allocate & 0xffff); 6676 elfcpp::Swap<32, big_endian>::writeval(pinsn, insn); 6677 pinsn += 4; 6678 } 6679 if (pinsn != entry + 12) 6680 elfcpp::Swap<32, big_endian>::writeval(pinsn, nop); 6681 6682 ok = true; 6683 } 6684 } 6685 6686 if (!ok) 6687 { 6688 if (!object->has_no_split_stack()) 6689 object->error(_("failed to match split-stack sequence at " 6690 "section %u offset %0zx"), 6691 shndx, static_cast<size_t>(fnoffset)); 6692 } 6693 } 6694 6695 // Scan relocations for a section. 6696 6697 template<int size, bool big_endian> 6698 void 6699 Target_powerpc<size, big_endian>::scan_relocs( 6700 Symbol_table* symtab, 6701 Layout* layout, 6702 Sized_relobj_file<size, big_endian>* object, 6703 unsigned int data_shndx, 6704 unsigned int sh_type, 6705 const unsigned char* prelocs, 6706 size_t reloc_count, 6707 Output_section* output_section, 6708 bool needs_special_offset_handling, 6709 size_t local_symbol_count, 6710 const unsigned char* plocal_symbols) 6711 { 6712 typedef Target_powerpc<size, big_endian> Powerpc; 6713 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 6714 Classify_reloc; 6715 6716 if (sh_type == elfcpp::SHT_REL) 6717 { 6718 gold_error(_("%s: unsupported REL reloc section"), 6719 object->name().c_str()); 6720 return; 6721 } 6722 6723 gold::scan_relocs<size, big_endian, Powerpc, Scan, Classify_reloc>( 6724 symtab, 6725 layout, 6726 this, 6727 object, 6728 data_shndx, 6729 prelocs, 6730 reloc_count, 6731 output_section, 6732 needs_special_offset_handling, 6733 local_symbol_count, 6734 plocal_symbols); 6735 } 6736 6737 // Functor class for processing the global symbol table. 6738 // Removes symbols defined on discarded opd entries. 6739 6740 template<bool big_endian> 6741 class Global_symbol_visitor_opd 6742 { 6743 public: 6744 Global_symbol_visitor_opd() 6745 { } 6746 6747 void 6748 operator()(Sized_symbol<64>* sym) 6749 { 6750 if (sym->has_symtab_index() 6751 || sym->source() != Symbol::FROM_OBJECT 6752 || !sym->in_real_elf()) 6753 return; 6754 6755 if (sym->object()->is_dynamic()) 6756 return; 6757 6758 Powerpc_relobj<64, big_endian>* symobj 6759 = static_cast<Powerpc_relobj<64, big_endian>*>(sym->object()); 6760 if (symobj->opd_shndx() == 0) 6761 return; 6762 6763 bool is_ordinary; 6764 unsigned int shndx = sym->shndx(&is_ordinary); 6765 if (shndx == symobj->opd_shndx() 6766 && symobj->get_opd_discard(sym->value())) 6767 { 6768 sym->set_undefined(); 6769 sym->set_visibility(elfcpp::STV_DEFAULT); 6770 sym->set_is_defined_in_discarded_section(); 6771 sym->set_symtab_index(-1U); 6772 } 6773 } 6774 }; 6775 6776 template<int size, bool big_endian> 6777 void 6778 Target_powerpc<size, big_endian>::define_save_restore_funcs( 6779 Layout* layout, 6780 Symbol_table* symtab) 6781 { 6782 if (size == 64) 6783 { 6784 Output_data_save_res<size, big_endian>* savres 6785 = new Output_data_save_res<size, big_endian>(symtab); 6786 this->savres_section_ = savres; 6787 layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS, 6788 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR, 6789 savres, ORDER_TEXT, false); 6790 } 6791 } 6792 6793 // Sort linker created .got section first (for the header), then input 6794 // sections belonging to files using small model code. 6795 6796 template<bool big_endian> 6797 class Sort_toc_sections 6798 { 6799 public: 6800 bool 6801 operator()(const Output_section::Input_section& is1, 6802 const Output_section::Input_section& is2) const 6803 { 6804 if (!is1.is_input_section() && is2.is_input_section()) 6805 return true; 6806 bool small1 6807 = (is1.is_input_section() 6808 && (static_cast<const Powerpc_relobj<64, big_endian>*>(is1.relobj()) 6809 ->has_small_toc_reloc())); 6810 bool small2 6811 = (is2.is_input_section() 6812 && (static_cast<const Powerpc_relobj<64, big_endian>*>(is2.relobj()) 6813 ->has_small_toc_reloc())); 6814 return small1 && !small2; 6815 } 6816 }; 6817 6818 // Finalize the sections. 6819 6820 template<int size, bool big_endian> 6821 void 6822 Target_powerpc<size, big_endian>::do_finalize_sections( 6823 Layout* layout, 6824 const Input_objects*, 6825 Symbol_table* symtab) 6826 { 6827 if (parameters->doing_static_link()) 6828 { 6829 // At least some versions of glibc elf-init.o have a strong 6830 // reference to __rela_iplt marker syms. A weak ref would be 6831 // better.. 6832 if (this->iplt_ != NULL) 6833 { 6834 Reloc_section* rel = this->iplt_->rel_plt(); 6835 symtab->define_in_output_data("__rela_iplt_start", NULL, 6836 Symbol_table::PREDEFINED, rel, 0, 0, 6837 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 6838 elfcpp::STV_HIDDEN, 0, false, true); 6839 symtab->define_in_output_data("__rela_iplt_end", NULL, 6840 Symbol_table::PREDEFINED, rel, 0, 0, 6841 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 6842 elfcpp::STV_HIDDEN, 0, true, true); 6843 } 6844 else 6845 { 6846 symtab->define_as_constant("__rela_iplt_start", NULL, 6847 Symbol_table::PREDEFINED, 0, 0, 6848 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 6849 elfcpp::STV_HIDDEN, 0, true, false); 6850 symtab->define_as_constant("__rela_iplt_end", NULL, 6851 Symbol_table::PREDEFINED, 0, 0, 6852 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 6853 elfcpp::STV_HIDDEN, 0, true, false); 6854 } 6855 } 6856 6857 if (size == 64) 6858 { 6859 typedef Global_symbol_visitor_opd<big_endian> Symbol_visitor; 6860 symtab->for_all_symbols<64, Symbol_visitor>(Symbol_visitor()); 6861 6862 if (!parameters->options().relocatable()) 6863 { 6864 this->define_save_restore_funcs(layout, symtab); 6865 6866 // Annoyingly, we need to make these sections now whether or 6867 // not we need them. If we delay until do_relax then we 6868 // need to mess with the relaxation machinery checkpointing. 6869 this->got_section(symtab, layout); 6870 this->make_brlt_section(layout); 6871 6872 if (parameters->options().toc_sort()) 6873 { 6874 Output_section* os = this->got_->output_section(); 6875 if (os != NULL && os->input_sections().size() > 1) 6876 std::stable_sort(os->input_sections().begin(), 6877 os->input_sections().end(), 6878 Sort_toc_sections<big_endian>()); 6879 } 6880 } 6881 } 6882 6883 // Fill in some more dynamic tags. 6884 Output_data_dynamic* odyn = layout->dynamic_data(); 6885 if (odyn != NULL) 6886 { 6887 const Reloc_section* rel_plt = (this->plt_ == NULL 6888 ? NULL 6889 : this->plt_->rel_plt()); 6890 layout->add_target_dynamic_tags(false, this->plt_, rel_plt, 6891 this->rela_dyn_, true, size == 32); 6892 6893 if (size == 32) 6894 { 6895 if (this->got_ != NULL) 6896 { 6897 this->got_->finalize_data_size(); 6898 odyn->add_section_plus_offset(elfcpp::DT_PPC_GOT, 6899 this->got_, this->got_->g_o_t()); 6900 } 6901 } 6902 else 6903 { 6904 if (this->glink_ != NULL) 6905 { 6906 this->glink_->finalize_data_size(); 6907 odyn->add_section_plus_offset(elfcpp::DT_PPC64_GLINK, 6908 this->glink_, 6909 (this->glink_->pltresolve_size 6910 - 32)); 6911 } 6912 } 6913 } 6914 6915 // Emit any relocs we saved in an attempt to avoid generating COPY 6916 // relocs. 6917 if (this->copy_relocs_.any_saved_relocs()) 6918 this->copy_relocs_.emit(this->rela_dyn_section(layout)); 6919 } 6920 6921 // Return TRUE iff INSN is one we expect on a _LO variety toc/got 6922 // reloc. 6923 6924 static bool 6925 ok_lo_toc_insn(uint32_t insn) 6926 { 6927 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */ 6928 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */ 6929 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */ 6930 || (insn & (0x3f << 26)) == 36u << 26 /* stw */ 6931 || (insn & (0x3f << 26)) == 38u << 26 /* stb */ 6932 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */ 6933 || (insn & (0x3f << 26)) == 42u << 26 /* lha */ 6934 || (insn & (0x3f << 26)) == 44u << 26 /* sth */ 6935 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */ 6936 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */ 6937 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */ 6938 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */ 6939 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */ 6940 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */ 6941 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */ 6942 && (insn & 3) != 1) 6943 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */ 6944 && ((insn & 3) == 0 || (insn & 3) == 3)) 6945 || (insn & (0x3f << 26)) == 12u << 26 /* addic */); 6946 } 6947 6948 // Return the value to use for a branch relocation. 6949 6950 template<int size, bool big_endian> 6951 bool 6952 Target_powerpc<size, big_endian>::symval_for_branch( 6953 const Symbol_table* symtab, 6954 const Sized_symbol<size>* gsym, 6955 Powerpc_relobj<size, big_endian>* object, 6956 Address *value, 6957 unsigned int *dest_shndx) 6958 { 6959 if (size == 32 || this->abiversion() >= 2) 6960 gold_unreachable(); 6961 *dest_shndx = 0; 6962 6963 // If the symbol is defined in an opd section, ie. is a function 6964 // descriptor, use the function descriptor code entry address 6965 Powerpc_relobj<size, big_endian>* symobj = object; 6966 if (gsym != NULL 6967 && gsym->source() != Symbol::FROM_OBJECT) 6968 return true; 6969 if (gsym != NULL) 6970 symobj = static_cast<Powerpc_relobj<size, big_endian>*>(gsym->object()); 6971 unsigned int shndx = symobj->opd_shndx(); 6972 if (shndx == 0) 6973 return true; 6974 Address opd_addr = symobj->get_output_section_offset(shndx); 6975 if (opd_addr == invalid_address) 6976 return true; 6977 opd_addr += symobj->output_section_address(shndx); 6978 if (*value >= opd_addr && *value < opd_addr + symobj->section_size(shndx)) 6979 { 6980 Address sec_off; 6981 *dest_shndx = symobj->get_opd_ent(*value - opd_addr, &sec_off); 6982 if (symtab->is_section_folded(symobj, *dest_shndx)) 6983 { 6984 Section_id folded 6985 = symtab->icf()->get_folded_section(symobj, *dest_shndx); 6986 symobj = static_cast<Powerpc_relobj<size, big_endian>*>(folded.first); 6987 *dest_shndx = folded.second; 6988 } 6989 Address sec_addr = symobj->get_output_section_offset(*dest_shndx); 6990 if (sec_addr == invalid_address) 6991 return false; 6992 6993 sec_addr += symobj->output_section(*dest_shndx)->address(); 6994 *value = sec_addr + sec_off; 6995 } 6996 return true; 6997 } 6998 6999 // Perform a relocation. 7000 7001 template<int size, bool big_endian> 7002 inline bool 7003 Target_powerpc<size, big_endian>::Relocate::relocate( 7004 const Relocate_info<size, big_endian>* relinfo, 7005 unsigned int, 7006 Target_powerpc* target, 7007 Output_section* os, 7008 size_t relnum, 7009 const unsigned char* preloc, 7010 const Sized_symbol<size>* gsym, 7011 const Symbol_value<size>* psymval, 7012 unsigned char* view, 7013 Address address, 7014 section_size_type view_size) 7015 { 7016 if (view == NULL) 7017 return true; 7018 7019 const elfcpp::Rela<size, big_endian> rela(preloc); 7020 unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info()); 7021 switch (this->maybe_skip_tls_get_addr_call(r_type, gsym)) 7022 { 7023 case Track_tls::NOT_EXPECTED: 7024 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 7025 _("__tls_get_addr call lacks marker reloc")); 7026 break; 7027 case Track_tls::EXPECTED: 7028 // We have already complained. 7029 break; 7030 case Track_tls::SKIP: 7031 return true; 7032 case Track_tls::NORMAL: 7033 break; 7034 } 7035 7036 typedef Powerpc_relocate_functions<size, big_endian> Reloc; 7037 typedef typename elfcpp::Swap<32, big_endian>::Valtype Insn; 7038 typedef typename Reloc_types<elfcpp::SHT_RELA, 7039 size, big_endian>::Reloc Reltype; 7040 // Offset from start of insn to d-field reloc. 7041 const int d_offset = big_endian ? 2 : 0; 7042 7043 Powerpc_relobj<size, big_endian>* const object 7044 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object); 7045 Address value = 0; 7046 bool has_stub_value = false; 7047 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 7048 if ((gsym != NULL 7049 ? gsym->use_plt_offset(Scan::get_reference_flags(r_type, target)) 7050 : object->local_has_plt_offset(r_sym)) 7051 && (!psymval->is_ifunc_symbol() 7052 || Scan::reloc_needs_plt_for_ifunc(target, object, r_type, false))) 7053 { 7054 if (size == 64 7055 && gsym != NULL 7056 && target->abiversion() >= 2 7057 && !parameters->options().output_is_position_independent() 7058 && !is_branch_reloc(r_type)) 7059 { 7060 Address off = target->glink_section()->find_global_entry(gsym); 7061 if (off != invalid_address) 7062 { 7063 value = target->glink_section()->global_entry_address() + off; 7064 has_stub_value = true; 7065 } 7066 } 7067 else 7068 { 7069 Stub_table<size, big_endian>* stub_table 7070 = object->stub_table(relinfo->data_shndx); 7071 if (stub_table == NULL) 7072 { 7073 // This is a ref from a data section to an ifunc symbol. 7074 if (target->stub_tables().size() != 0) 7075 stub_table = target->stub_tables()[0]; 7076 } 7077 if (stub_table != NULL) 7078 { 7079 Address off; 7080 if (gsym != NULL) 7081 off = stub_table->find_plt_call_entry(object, gsym, r_type, 7082 rela.get_r_addend()); 7083 else 7084 off = stub_table->find_plt_call_entry(object, r_sym, r_type, 7085 rela.get_r_addend()); 7086 if (off != invalid_address) 7087 { 7088 value = stub_table->stub_address() + off; 7089 has_stub_value = true; 7090 } 7091 } 7092 } 7093 // We don't care too much about bogus debug references to 7094 // non-local functions, but otherwise there had better be a plt 7095 // call stub or global entry stub as appropriate. 7096 gold_assert(has_stub_value || !(os->flags() & elfcpp::SHF_ALLOC)); 7097 } 7098 7099 if (r_type == elfcpp::R_POWERPC_GOT16 7100 || r_type == elfcpp::R_POWERPC_GOT16_LO 7101 || r_type == elfcpp::R_POWERPC_GOT16_HI 7102 || r_type == elfcpp::R_POWERPC_GOT16_HA 7103 || r_type == elfcpp::R_PPC64_GOT16_DS 7104 || r_type == elfcpp::R_PPC64_GOT16_LO_DS) 7105 { 7106 if (gsym != NULL) 7107 { 7108 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 7109 value = gsym->got_offset(GOT_TYPE_STANDARD); 7110 } 7111 else 7112 { 7113 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 7114 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 7115 value = object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 7116 } 7117 value -= target->got_section()->got_base_offset(object); 7118 } 7119 else if (r_type == elfcpp::R_PPC64_TOC) 7120 { 7121 value = (target->got_section()->output_section()->address() 7122 + object->toc_base_offset()); 7123 } 7124 else if (gsym != NULL 7125 && (r_type == elfcpp::R_POWERPC_REL24 7126 || r_type == elfcpp::R_PPC_PLTREL24) 7127 && has_stub_value) 7128 { 7129 if (size == 64) 7130 { 7131 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype; 7132 Valtype* wv = reinterpret_cast<Valtype*>(view); 7133 bool can_plt_call = false; 7134 if (rela.get_r_offset() + 8 <= view_size) 7135 { 7136 Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv); 7137 Valtype insn2 = elfcpp::Swap<32, big_endian>::readval(wv + 1); 7138 if ((insn & 1) != 0 7139 && (insn2 == nop 7140 || insn2 == cror_15_15_15 || insn2 == cror_31_31_31)) 7141 { 7142 elfcpp::Swap<32, big_endian>:: 7143 writeval(wv + 1, ld_2_1 + target->stk_toc()); 7144 can_plt_call = true; 7145 } 7146 } 7147 if (!can_plt_call) 7148 { 7149 // If we don't have a branch and link followed by a nop, 7150 // we can't go via the plt because there is no place to 7151 // put a toc restoring instruction. 7152 // Unless we know we won't be returning. 7153 if (strcmp(gsym->name(), "__libc_start_main") == 0) 7154 can_plt_call = true; 7155 } 7156 if (!can_plt_call) 7157 { 7158 // g++ as of 20130507 emits self-calls without a 7159 // following nop. This is arguably wrong since we have 7160 // conflicting information. On the one hand a global 7161 // symbol and on the other a local call sequence, but 7162 // don't error for this special case. 7163 // It isn't possible to cheaply verify we have exactly 7164 // such a call. Allow all calls to the same section. 7165 bool ok = false; 7166 Address code = value; 7167 if (gsym->source() == Symbol::FROM_OBJECT 7168 && gsym->object() == object) 7169 { 7170 unsigned int dest_shndx = 0; 7171 if (target->abiversion() < 2) 7172 { 7173 Address addend = rela.get_r_addend(); 7174 code = psymval->value(object, addend); 7175 target->symval_for_branch(relinfo->symtab, gsym, object, 7176 &code, &dest_shndx); 7177 } 7178 bool is_ordinary; 7179 if (dest_shndx == 0) 7180 dest_shndx = gsym->shndx(&is_ordinary); 7181 ok = dest_shndx == relinfo->data_shndx; 7182 } 7183 if (!ok) 7184 { 7185 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 7186 _("call lacks nop, can't restore toc; " 7187 "recompile with -fPIC")); 7188 value = code; 7189 } 7190 } 7191 } 7192 } 7193 else if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 7194 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO 7195 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HI 7196 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HA) 7197 { 7198 // First instruction of a global dynamic sequence, arg setup insn. 7199 const bool final = gsym == NULL || gsym->final_value_is_known(); 7200 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final); 7201 enum Got_type got_type = GOT_TYPE_STANDARD; 7202 if (tls_type == tls::TLSOPT_NONE) 7203 got_type = GOT_TYPE_TLSGD; 7204 else if (tls_type == tls::TLSOPT_TO_IE) 7205 got_type = GOT_TYPE_TPREL; 7206 if (got_type != GOT_TYPE_STANDARD) 7207 { 7208 if (gsym != NULL) 7209 { 7210 gold_assert(gsym->has_got_offset(got_type)); 7211 value = gsym->got_offset(got_type); 7212 } 7213 else 7214 { 7215 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 7216 gold_assert(object->local_has_got_offset(r_sym, got_type)); 7217 value = object->local_got_offset(r_sym, got_type); 7218 } 7219 value -= target->got_section()->got_base_offset(object); 7220 } 7221 if (tls_type == tls::TLSOPT_TO_IE) 7222 { 7223 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 7224 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO) 7225 { 7226 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7227 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7228 insn &= (1 << 26) - (1 << 16); // extract rt,ra from addi 7229 if (size == 32) 7230 insn |= 32 << 26; // lwz 7231 else 7232 insn |= 58 << 26; // ld 7233 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7234 } 7235 r_type += (elfcpp::R_POWERPC_GOT_TPREL16 7236 - elfcpp::R_POWERPC_GOT_TLSGD16); 7237 } 7238 else if (tls_type == tls::TLSOPT_TO_LE) 7239 { 7240 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 7241 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO) 7242 { 7243 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7244 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7245 insn &= (1 << 26) - (1 << 21); // extract rt 7246 if (size == 32) 7247 insn |= addis_0_2; 7248 else 7249 insn |= addis_0_13; 7250 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7251 r_type = elfcpp::R_POWERPC_TPREL16_HA; 7252 value = psymval->value(object, rela.get_r_addend()); 7253 } 7254 else 7255 { 7256 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7257 Insn insn = nop; 7258 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7259 r_type = elfcpp::R_POWERPC_NONE; 7260 } 7261 } 7262 } 7263 else if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16 7264 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO 7265 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HI 7266 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HA) 7267 { 7268 // First instruction of a local dynamic sequence, arg setup insn. 7269 const tls::Tls_optimization tls_type = target->optimize_tls_ld(); 7270 if (tls_type == tls::TLSOPT_NONE) 7271 { 7272 value = target->tlsld_got_offset(); 7273 value -= target->got_section()->got_base_offset(object); 7274 } 7275 else 7276 { 7277 gold_assert(tls_type == tls::TLSOPT_TO_LE); 7278 if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16 7279 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO) 7280 { 7281 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7282 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7283 insn &= (1 << 26) - (1 << 21); // extract rt 7284 if (size == 32) 7285 insn |= addis_0_2; 7286 else 7287 insn |= addis_0_13; 7288 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7289 r_type = elfcpp::R_POWERPC_TPREL16_HA; 7290 value = dtp_offset; 7291 } 7292 else 7293 { 7294 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7295 Insn insn = nop; 7296 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7297 r_type = elfcpp::R_POWERPC_NONE; 7298 } 7299 } 7300 } 7301 else if (r_type == elfcpp::R_POWERPC_GOT_DTPREL16 7302 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_LO 7303 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_HI 7304 || r_type == elfcpp::R_POWERPC_GOT_DTPREL16_HA) 7305 { 7306 // Accesses relative to a local dynamic sequence address, 7307 // no optimisation here. 7308 if (gsym != NULL) 7309 { 7310 gold_assert(gsym->has_got_offset(GOT_TYPE_DTPREL)); 7311 value = gsym->got_offset(GOT_TYPE_DTPREL); 7312 } 7313 else 7314 { 7315 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 7316 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_DTPREL)); 7317 value = object->local_got_offset(r_sym, GOT_TYPE_DTPREL); 7318 } 7319 value -= target->got_section()->got_base_offset(object); 7320 } 7321 else if (r_type == elfcpp::R_POWERPC_GOT_TPREL16 7322 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO 7323 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HI 7324 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HA) 7325 { 7326 // First instruction of initial exec sequence. 7327 const bool final = gsym == NULL || gsym->final_value_is_known(); 7328 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final); 7329 if (tls_type == tls::TLSOPT_NONE) 7330 { 7331 if (gsym != NULL) 7332 { 7333 gold_assert(gsym->has_got_offset(GOT_TYPE_TPREL)); 7334 value = gsym->got_offset(GOT_TYPE_TPREL); 7335 } 7336 else 7337 { 7338 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 7339 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_TPREL)); 7340 value = object->local_got_offset(r_sym, GOT_TYPE_TPREL); 7341 } 7342 value -= target->got_section()->got_base_offset(object); 7343 } 7344 else 7345 { 7346 gold_assert(tls_type == tls::TLSOPT_TO_LE); 7347 if (r_type == elfcpp::R_POWERPC_GOT_TPREL16 7348 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO) 7349 { 7350 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7351 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7352 insn &= (1 << 26) - (1 << 21); // extract rt from ld 7353 if (size == 32) 7354 insn |= addis_0_2; 7355 else 7356 insn |= addis_0_13; 7357 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7358 r_type = elfcpp::R_POWERPC_TPREL16_HA; 7359 value = psymval->value(object, rela.get_r_addend()); 7360 } 7361 else 7362 { 7363 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7364 Insn insn = nop; 7365 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7366 r_type = elfcpp::R_POWERPC_NONE; 7367 } 7368 } 7369 } 7370 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD) 7371 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD)) 7372 { 7373 // Second instruction of a global dynamic sequence, 7374 // the __tls_get_addr call 7375 this->expect_tls_get_addr_call(relinfo, relnum, rela.get_r_offset()); 7376 const bool final = gsym == NULL || gsym->final_value_is_known(); 7377 const tls::Tls_optimization tls_type = target->optimize_tls_gd(final); 7378 if (tls_type != tls::TLSOPT_NONE) 7379 { 7380 if (tls_type == tls::TLSOPT_TO_IE) 7381 { 7382 Insn* iview = reinterpret_cast<Insn*>(view); 7383 Insn insn = add_3_3_13; 7384 if (size == 32) 7385 insn = add_3_3_2; 7386 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7387 r_type = elfcpp::R_POWERPC_NONE; 7388 } 7389 else 7390 { 7391 Insn* iview = reinterpret_cast<Insn*>(view); 7392 Insn insn = addi_3_3; 7393 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7394 r_type = elfcpp::R_POWERPC_TPREL16_LO; 7395 view += d_offset; 7396 value = psymval->value(object, rela.get_r_addend()); 7397 } 7398 this->skip_next_tls_get_addr_call(); 7399 } 7400 } 7401 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD) 7402 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD)) 7403 { 7404 // Second instruction of a local dynamic sequence, 7405 // the __tls_get_addr call 7406 this->expect_tls_get_addr_call(relinfo, relnum, rela.get_r_offset()); 7407 const tls::Tls_optimization tls_type = target->optimize_tls_ld(); 7408 if (tls_type == tls::TLSOPT_TO_LE) 7409 { 7410 Insn* iview = reinterpret_cast<Insn*>(view); 7411 Insn insn = addi_3_3; 7412 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7413 this->skip_next_tls_get_addr_call(); 7414 r_type = elfcpp::R_POWERPC_TPREL16_LO; 7415 view += d_offset; 7416 value = dtp_offset; 7417 } 7418 } 7419 else if (r_type == elfcpp::R_POWERPC_TLS) 7420 { 7421 // Second instruction of an initial exec sequence 7422 const bool final = gsym == NULL || gsym->final_value_is_known(); 7423 const tls::Tls_optimization tls_type = target->optimize_tls_ie(final); 7424 if (tls_type == tls::TLSOPT_TO_LE) 7425 { 7426 Insn* iview = reinterpret_cast<Insn*>(view); 7427 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7428 unsigned int reg = size == 32 ? 2 : 13; 7429 insn = at_tls_transform(insn, reg); 7430 gold_assert(insn != 0); 7431 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7432 r_type = elfcpp::R_POWERPC_TPREL16_LO; 7433 view += d_offset; 7434 value = psymval->value(object, rela.get_r_addend()); 7435 } 7436 } 7437 else if (!has_stub_value) 7438 { 7439 Address addend = 0; 7440 if (!(size == 32 && r_type == elfcpp::R_PPC_PLTREL24)) 7441 addend = rela.get_r_addend(); 7442 value = psymval->value(object, addend); 7443 if (size == 64 && is_branch_reloc(r_type)) 7444 { 7445 if (target->abiversion() >= 2) 7446 { 7447 if (gsym != NULL) 7448 value += object->ppc64_local_entry_offset(gsym); 7449 else 7450 value += object->ppc64_local_entry_offset(r_sym); 7451 } 7452 else 7453 { 7454 unsigned int dest_shndx; 7455 target->symval_for_branch(relinfo->symtab, gsym, object, 7456 &value, &dest_shndx); 7457 } 7458 } 7459 Address max_branch_offset = max_branch_delta(r_type); 7460 if (max_branch_offset != 0 7461 && value - address + max_branch_offset >= 2 * max_branch_offset) 7462 { 7463 Stub_table<size, big_endian>* stub_table 7464 = object->stub_table(relinfo->data_shndx); 7465 if (stub_table != NULL) 7466 { 7467 Address off = stub_table->find_long_branch_entry(object, value); 7468 if (off != invalid_address) 7469 { 7470 value = (stub_table->stub_address() + stub_table->plt_size() 7471 + off); 7472 has_stub_value = true; 7473 } 7474 } 7475 } 7476 } 7477 7478 switch (r_type) 7479 { 7480 case elfcpp::R_PPC64_REL64: 7481 case elfcpp::R_POWERPC_REL32: 7482 case elfcpp::R_POWERPC_REL24: 7483 case elfcpp::R_PPC_PLTREL24: 7484 case elfcpp::R_PPC_LOCAL24PC: 7485 case elfcpp::R_POWERPC_REL16: 7486 case elfcpp::R_POWERPC_REL16_LO: 7487 case elfcpp::R_POWERPC_REL16_HI: 7488 case elfcpp::R_POWERPC_REL16_HA: 7489 case elfcpp::R_POWERPC_REL16DX_HA: 7490 case elfcpp::R_POWERPC_REL14: 7491 case elfcpp::R_POWERPC_REL14_BRTAKEN: 7492 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 7493 value -= address; 7494 break; 7495 7496 case elfcpp::R_PPC64_TOC16: 7497 case elfcpp::R_PPC64_TOC16_LO: 7498 case elfcpp::R_PPC64_TOC16_HI: 7499 case elfcpp::R_PPC64_TOC16_HA: 7500 case elfcpp::R_PPC64_TOC16_DS: 7501 case elfcpp::R_PPC64_TOC16_LO_DS: 7502 // Subtract the TOC base address. 7503 value -= (target->got_section()->output_section()->address() 7504 + object->toc_base_offset()); 7505 break; 7506 7507 case elfcpp::R_POWERPC_SECTOFF: 7508 case elfcpp::R_POWERPC_SECTOFF_LO: 7509 case elfcpp::R_POWERPC_SECTOFF_HI: 7510 case elfcpp::R_POWERPC_SECTOFF_HA: 7511 case elfcpp::R_PPC64_SECTOFF_DS: 7512 case elfcpp::R_PPC64_SECTOFF_LO_DS: 7513 if (os != NULL) 7514 value -= os->address(); 7515 break; 7516 7517 case elfcpp::R_PPC64_TPREL16_DS: 7518 case elfcpp::R_PPC64_TPREL16_LO_DS: 7519 case elfcpp::R_PPC64_TPREL16_HIGH: 7520 case elfcpp::R_PPC64_TPREL16_HIGHA: 7521 if (size != 64) 7522 // R_PPC_TLSGD, R_PPC_TLSLD, R_PPC_EMB_RELST_LO, R_PPC_EMB_RELST_HI 7523 break; 7524 case elfcpp::R_POWERPC_TPREL16: 7525 case elfcpp::R_POWERPC_TPREL16_LO: 7526 case elfcpp::R_POWERPC_TPREL16_HI: 7527 case elfcpp::R_POWERPC_TPREL16_HA: 7528 case elfcpp::R_POWERPC_TPREL: 7529 case elfcpp::R_PPC64_TPREL16_HIGHER: 7530 case elfcpp::R_PPC64_TPREL16_HIGHERA: 7531 case elfcpp::R_PPC64_TPREL16_HIGHEST: 7532 case elfcpp::R_PPC64_TPREL16_HIGHESTA: 7533 // tls symbol values are relative to tls_segment()->vaddr() 7534 value -= tp_offset; 7535 break; 7536 7537 case elfcpp::R_PPC64_DTPREL16_DS: 7538 case elfcpp::R_PPC64_DTPREL16_LO_DS: 7539 case elfcpp::R_PPC64_DTPREL16_HIGHER: 7540 case elfcpp::R_PPC64_DTPREL16_HIGHERA: 7541 case elfcpp::R_PPC64_DTPREL16_HIGHEST: 7542 case elfcpp::R_PPC64_DTPREL16_HIGHESTA: 7543 if (size != 64) 7544 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16, R_PPC_EMB_NADDR16_LO 7545 // R_PPC_EMB_NADDR16_HI, R_PPC_EMB_NADDR16_HA, R_PPC_EMB_SDAI16 7546 break; 7547 case elfcpp::R_POWERPC_DTPREL16: 7548 case elfcpp::R_POWERPC_DTPREL16_LO: 7549 case elfcpp::R_POWERPC_DTPREL16_HI: 7550 case elfcpp::R_POWERPC_DTPREL16_HA: 7551 case elfcpp::R_POWERPC_DTPREL: 7552 case elfcpp::R_PPC64_DTPREL16_HIGH: 7553 case elfcpp::R_PPC64_DTPREL16_HIGHA: 7554 // tls symbol values are relative to tls_segment()->vaddr() 7555 value -= dtp_offset; 7556 break; 7557 7558 case elfcpp::R_PPC64_ADDR64_LOCAL: 7559 if (gsym != NULL) 7560 value += object->ppc64_local_entry_offset(gsym); 7561 else 7562 value += object->ppc64_local_entry_offset(r_sym); 7563 break; 7564 7565 default: 7566 break; 7567 } 7568 7569 Insn branch_bit = 0; 7570 switch (r_type) 7571 { 7572 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 7573 case elfcpp::R_POWERPC_REL14_BRTAKEN: 7574 branch_bit = 1 << 21; 7575 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 7576 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 7577 { 7578 Insn* iview = reinterpret_cast<Insn*>(view); 7579 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7580 insn &= ~(1 << 21); 7581 insn |= branch_bit; 7582 if (this->is_isa_v2) 7583 { 7584 // Set 'a' bit. This is 0b00010 in BO field for branch 7585 // on CR(BI) insns (BO == 001at or 011at), and 0b01000 7586 // for branch on CTR insns (BO == 1a00t or 1a01t). 7587 if ((insn & (0x14 << 21)) == (0x04 << 21)) 7588 insn |= 0x02 << 21; 7589 else if ((insn & (0x14 << 21)) == (0x10 << 21)) 7590 insn |= 0x08 << 21; 7591 else 7592 break; 7593 } 7594 else 7595 { 7596 // Invert 'y' bit if not the default. 7597 if (static_cast<Signed_address>(value) < 0) 7598 insn ^= 1 << 21; 7599 } 7600 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7601 } 7602 break; 7603 7604 default: 7605 break; 7606 } 7607 7608 if (size == 64) 7609 { 7610 // Multi-instruction sequences that access the TOC can be 7611 // optimized, eg. addis ra,r2,0; addi rb,ra,x; 7612 // to nop; addi rb,r2,x; 7613 switch (r_type) 7614 { 7615 default: 7616 break; 7617 7618 case elfcpp::R_POWERPC_GOT_TLSLD16_HA: 7619 case elfcpp::R_POWERPC_GOT_TLSGD16_HA: 7620 case elfcpp::R_POWERPC_GOT_TPREL16_HA: 7621 case elfcpp::R_POWERPC_GOT_DTPREL16_HA: 7622 case elfcpp::R_POWERPC_GOT16_HA: 7623 case elfcpp::R_PPC64_TOC16_HA: 7624 if (parameters->options().toc_optimize()) 7625 { 7626 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7627 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7628 if ((insn & ((0x3f << 26) | 0x1f << 16)) 7629 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */) 7630 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 7631 _("toc optimization is not supported " 7632 "for %#08x instruction"), insn); 7633 else if (value + 0x8000 < 0x10000) 7634 { 7635 elfcpp::Swap<32, big_endian>::writeval(iview, nop); 7636 return true; 7637 } 7638 } 7639 break; 7640 7641 case elfcpp::R_POWERPC_GOT_TLSLD16_LO: 7642 case elfcpp::R_POWERPC_GOT_TLSGD16_LO: 7643 case elfcpp::R_POWERPC_GOT_TPREL16_LO: 7644 case elfcpp::R_POWERPC_GOT_DTPREL16_LO: 7645 case elfcpp::R_POWERPC_GOT16_LO: 7646 case elfcpp::R_PPC64_GOT16_LO_DS: 7647 case elfcpp::R_PPC64_TOC16_LO: 7648 case elfcpp::R_PPC64_TOC16_LO_DS: 7649 if (parameters->options().toc_optimize()) 7650 { 7651 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7652 Insn insn = elfcpp::Swap<32, big_endian>::readval(iview); 7653 if (!ok_lo_toc_insn(insn)) 7654 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 7655 _("toc optimization is not supported " 7656 "for %#08x instruction"), insn); 7657 else if (value + 0x8000 < 0x10000) 7658 { 7659 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */) 7660 { 7661 // Transform addic to addi when we change reg. 7662 insn &= ~((0x3f << 26) | (0x1f << 16)); 7663 insn |= (14u << 26) | (2 << 16); 7664 } 7665 else 7666 { 7667 insn &= ~(0x1f << 16); 7668 insn |= 2 << 16; 7669 } 7670 elfcpp::Swap<32, big_endian>::writeval(iview, insn); 7671 } 7672 } 7673 break; 7674 7675 case elfcpp::R_PPC64_ENTRY: 7676 value = (target->got_section()->output_section()->address() 7677 + object->toc_base_offset()); 7678 if (value + 0x80008000 <= 0xffffffff 7679 && !parameters->options().output_is_position_independent()) 7680 { 7681 Insn* iview = reinterpret_cast<Insn*>(view); 7682 Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview); 7683 Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview + 1); 7684 7685 if ((insn1 & ~0xfffc) == ld_2_12 7686 && insn2 == add_2_2_12) 7687 { 7688 insn1 = lis_2 + ha(value); 7689 elfcpp::Swap<32, big_endian>::writeval(iview, insn1); 7690 insn2 = addi_2_2 + l(value); 7691 elfcpp::Swap<32, big_endian>::writeval(iview + 1, insn2); 7692 return true; 7693 } 7694 } 7695 else 7696 { 7697 value -= address; 7698 if (value + 0x80008000 <= 0xffffffff) 7699 { 7700 Insn* iview = reinterpret_cast<Insn*>(view); 7701 Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview); 7702 Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview + 1); 7703 7704 if ((insn1 & ~0xfffc) == ld_2_12 7705 && insn2 == add_2_2_12) 7706 { 7707 insn1 = addis_2_12 + ha(value); 7708 elfcpp::Swap<32, big_endian>::writeval(iview, insn1); 7709 insn2 = addi_2_2 + l(value); 7710 elfcpp::Swap<32, big_endian>::writeval(iview + 1, insn2); 7711 return true; 7712 } 7713 } 7714 } 7715 break; 7716 7717 case elfcpp::R_POWERPC_REL16_LO: 7718 // If we are generating a non-PIC executable, edit 7719 // 0: addis 2,12,.TOC.-0b@ha 7720 // addi 2,2,.TOC.-0b@l 7721 // used by ELFv2 global entry points to set up r2, to 7722 // lis 2,.TOC.@ha 7723 // addi 2,2,.TOC.@l 7724 // if .TOC. is in range. */ 7725 if (value + address - 4 + 0x80008000 <= 0xffffffff 7726 && relnum != 0 7727 && preloc != NULL 7728 && target->abiversion() >= 2 7729 && !parameters->options().output_is_position_independent() 7730 && rela.get_r_addend() == d_offset + 4 7731 && gsym != NULL 7732 && strcmp(gsym->name(), ".TOC.") == 0) 7733 { 7734 const int reloc_size 7735 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size; 7736 Reltype prev_rela(preloc - reloc_size); 7737 if ((prev_rela.get_r_info() 7738 == elfcpp::elf_r_info<size>(r_sym, 7739 elfcpp::R_POWERPC_REL16_HA)) 7740 && prev_rela.get_r_offset() + 4 == rela.get_r_offset() 7741 && prev_rela.get_r_addend() + 4 == rela.get_r_addend()) 7742 { 7743 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7744 Insn insn1 = elfcpp::Swap<32, big_endian>::readval(iview - 1); 7745 Insn insn2 = elfcpp::Swap<32, big_endian>::readval(iview); 7746 7747 if ((insn1 & 0xffff0000) == addis_2_12 7748 && (insn2 & 0xffff0000) == addi_2_2) 7749 { 7750 insn1 = lis_2 + ha(value + address - 4); 7751 elfcpp::Swap<32, big_endian>::writeval(iview - 1, insn1); 7752 insn2 = addi_2_2 + l(value + address - 4); 7753 elfcpp::Swap<32, big_endian>::writeval(iview, insn2); 7754 if (relinfo->rr) 7755 { 7756 relinfo->rr->set_strategy(relnum - 1, 7757 Relocatable_relocs::RELOC_SPECIAL); 7758 relinfo->rr->set_strategy(relnum, 7759 Relocatable_relocs::RELOC_SPECIAL); 7760 } 7761 return true; 7762 } 7763 } 7764 } 7765 break; 7766 } 7767 } 7768 7769 typename Reloc::Overflow_check overflow = Reloc::CHECK_NONE; 7770 elfcpp::Shdr<size, big_endian> shdr(relinfo->data_shdr); 7771 switch (r_type) 7772 { 7773 case elfcpp::R_POWERPC_ADDR32: 7774 case elfcpp::R_POWERPC_UADDR32: 7775 if (size == 64) 7776 overflow = Reloc::CHECK_BITFIELD; 7777 break; 7778 7779 case elfcpp::R_POWERPC_REL32: 7780 case elfcpp::R_POWERPC_REL16DX_HA: 7781 if (size == 64) 7782 overflow = Reloc::CHECK_SIGNED; 7783 break; 7784 7785 case elfcpp::R_POWERPC_UADDR16: 7786 overflow = Reloc::CHECK_BITFIELD; 7787 break; 7788 7789 case elfcpp::R_POWERPC_ADDR16: 7790 // We really should have three separate relocations, 7791 // one for 16-bit data, one for insns with 16-bit signed fields, 7792 // and one for insns with 16-bit unsigned fields. 7793 overflow = Reloc::CHECK_BITFIELD; 7794 if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0) 7795 overflow = Reloc::CHECK_LOW_INSN; 7796 break; 7797 7798 case elfcpp::R_POWERPC_ADDR16_HI: 7799 case elfcpp::R_POWERPC_ADDR16_HA: 7800 case elfcpp::R_POWERPC_GOT16_HI: 7801 case elfcpp::R_POWERPC_GOT16_HA: 7802 case elfcpp::R_POWERPC_PLT16_HI: 7803 case elfcpp::R_POWERPC_PLT16_HA: 7804 case elfcpp::R_POWERPC_SECTOFF_HI: 7805 case elfcpp::R_POWERPC_SECTOFF_HA: 7806 case elfcpp::R_PPC64_TOC16_HI: 7807 case elfcpp::R_PPC64_TOC16_HA: 7808 case elfcpp::R_PPC64_PLTGOT16_HI: 7809 case elfcpp::R_PPC64_PLTGOT16_HA: 7810 case elfcpp::R_POWERPC_TPREL16_HI: 7811 case elfcpp::R_POWERPC_TPREL16_HA: 7812 case elfcpp::R_POWERPC_DTPREL16_HI: 7813 case elfcpp::R_POWERPC_DTPREL16_HA: 7814 case elfcpp::R_POWERPC_GOT_TLSGD16_HI: 7815 case elfcpp::R_POWERPC_GOT_TLSGD16_HA: 7816 case elfcpp::R_POWERPC_GOT_TLSLD16_HI: 7817 case elfcpp::R_POWERPC_GOT_TLSLD16_HA: 7818 case elfcpp::R_POWERPC_GOT_TPREL16_HI: 7819 case elfcpp::R_POWERPC_GOT_TPREL16_HA: 7820 case elfcpp::R_POWERPC_GOT_DTPREL16_HI: 7821 case elfcpp::R_POWERPC_GOT_DTPREL16_HA: 7822 case elfcpp::R_POWERPC_REL16_HI: 7823 case elfcpp::R_POWERPC_REL16_HA: 7824 if (size != 32) 7825 overflow = Reloc::CHECK_HIGH_INSN; 7826 break; 7827 7828 case elfcpp::R_POWERPC_REL16: 7829 case elfcpp::R_PPC64_TOC16: 7830 case elfcpp::R_POWERPC_GOT16: 7831 case elfcpp::R_POWERPC_SECTOFF: 7832 case elfcpp::R_POWERPC_TPREL16: 7833 case elfcpp::R_POWERPC_DTPREL16: 7834 case elfcpp::R_POWERPC_GOT_TLSGD16: 7835 case elfcpp::R_POWERPC_GOT_TLSLD16: 7836 case elfcpp::R_POWERPC_GOT_TPREL16: 7837 case elfcpp::R_POWERPC_GOT_DTPREL16: 7838 overflow = Reloc::CHECK_LOW_INSN; 7839 break; 7840 7841 case elfcpp::R_POWERPC_ADDR24: 7842 case elfcpp::R_POWERPC_ADDR14: 7843 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 7844 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 7845 case elfcpp::R_PPC64_ADDR16_DS: 7846 case elfcpp::R_POWERPC_REL24: 7847 case elfcpp::R_PPC_PLTREL24: 7848 case elfcpp::R_PPC_LOCAL24PC: 7849 case elfcpp::R_PPC64_TPREL16_DS: 7850 case elfcpp::R_PPC64_DTPREL16_DS: 7851 case elfcpp::R_PPC64_TOC16_DS: 7852 case elfcpp::R_PPC64_GOT16_DS: 7853 case elfcpp::R_PPC64_SECTOFF_DS: 7854 case elfcpp::R_POWERPC_REL14: 7855 case elfcpp::R_POWERPC_REL14_BRTAKEN: 7856 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 7857 overflow = Reloc::CHECK_SIGNED; 7858 break; 7859 } 7860 7861 Insn* iview = reinterpret_cast<Insn*>(view - d_offset); 7862 Insn insn = 0; 7863 7864 if (overflow == Reloc::CHECK_LOW_INSN 7865 || overflow == Reloc::CHECK_HIGH_INSN) 7866 { 7867 insn = elfcpp::Swap<32, big_endian>::readval(iview); 7868 7869 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */) 7870 overflow = Reloc::CHECK_BITFIELD; 7871 else if (overflow == Reloc::CHECK_LOW_INSN 7872 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */ 7873 || (insn & (0x3f << 26)) == 24u << 26 /* ori */ 7874 || (insn & (0x3f << 26)) == 26u << 26 /* xori */) 7875 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */ 7876 || (insn & (0x3f << 26)) == 25u << 26 /* oris */ 7877 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */)) 7878 overflow = Reloc::CHECK_UNSIGNED; 7879 else 7880 overflow = Reloc::CHECK_SIGNED; 7881 } 7882 7883 bool maybe_dq_reloc = false; 7884 typename Powerpc_relocate_functions<size, big_endian>::Status status 7885 = Powerpc_relocate_functions<size, big_endian>::STATUS_OK; 7886 switch (r_type) 7887 { 7888 case elfcpp::R_POWERPC_NONE: 7889 case elfcpp::R_POWERPC_TLS: 7890 case elfcpp::R_POWERPC_GNU_VTINHERIT: 7891 case elfcpp::R_POWERPC_GNU_VTENTRY: 7892 break; 7893 7894 case elfcpp::R_PPC64_ADDR64: 7895 case elfcpp::R_PPC64_REL64: 7896 case elfcpp::R_PPC64_TOC: 7897 case elfcpp::R_PPC64_ADDR64_LOCAL: 7898 Reloc::addr64(view, value); 7899 break; 7900 7901 case elfcpp::R_POWERPC_TPREL: 7902 case elfcpp::R_POWERPC_DTPREL: 7903 if (size == 64) 7904 Reloc::addr64(view, value); 7905 else 7906 status = Reloc::addr32(view, value, overflow); 7907 break; 7908 7909 case elfcpp::R_PPC64_UADDR64: 7910 Reloc::addr64_u(view, value); 7911 break; 7912 7913 case elfcpp::R_POWERPC_ADDR32: 7914 status = Reloc::addr32(view, value, overflow); 7915 break; 7916 7917 case elfcpp::R_POWERPC_REL32: 7918 case elfcpp::R_POWERPC_UADDR32: 7919 status = Reloc::addr32_u(view, value, overflow); 7920 break; 7921 7922 case elfcpp::R_POWERPC_ADDR24: 7923 case elfcpp::R_POWERPC_REL24: 7924 case elfcpp::R_PPC_PLTREL24: 7925 case elfcpp::R_PPC_LOCAL24PC: 7926 status = Reloc::addr24(view, value, overflow); 7927 break; 7928 7929 case elfcpp::R_POWERPC_GOT_DTPREL16: 7930 case elfcpp::R_POWERPC_GOT_DTPREL16_LO: 7931 case elfcpp::R_POWERPC_GOT_TPREL16: 7932 case elfcpp::R_POWERPC_GOT_TPREL16_LO: 7933 if (size == 64) 7934 { 7935 // On ppc64 these are all ds form 7936 maybe_dq_reloc = true; 7937 break; 7938 } 7939 case elfcpp::R_POWERPC_ADDR16: 7940 case elfcpp::R_POWERPC_REL16: 7941 case elfcpp::R_PPC64_TOC16: 7942 case elfcpp::R_POWERPC_GOT16: 7943 case elfcpp::R_POWERPC_SECTOFF: 7944 case elfcpp::R_POWERPC_TPREL16: 7945 case elfcpp::R_POWERPC_DTPREL16: 7946 case elfcpp::R_POWERPC_GOT_TLSGD16: 7947 case elfcpp::R_POWERPC_GOT_TLSLD16: 7948 case elfcpp::R_POWERPC_ADDR16_LO: 7949 case elfcpp::R_POWERPC_REL16_LO: 7950 case elfcpp::R_PPC64_TOC16_LO: 7951 case elfcpp::R_POWERPC_GOT16_LO: 7952 case elfcpp::R_POWERPC_SECTOFF_LO: 7953 case elfcpp::R_POWERPC_TPREL16_LO: 7954 case elfcpp::R_POWERPC_DTPREL16_LO: 7955 case elfcpp::R_POWERPC_GOT_TLSGD16_LO: 7956 case elfcpp::R_POWERPC_GOT_TLSLD16_LO: 7957 if (size == 64) 7958 status = Reloc::addr16(view, value, overflow); 7959 else 7960 maybe_dq_reloc = true; 7961 break; 7962 7963 case elfcpp::R_POWERPC_UADDR16: 7964 status = Reloc::addr16_u(view, value, overflow); 7965 break; 7966 7967 case elfcpp::R_PPC64_ADDR16_HIGH: 7968 case elfcpp::R_PPC64_TPREL16_HIGH: 7969 case elfcpp::R_PPC64_DTPREL16_HIGH: 7970 if (size == 32) 7971 // R_PPC_EMB_MRKREF, R_PPC_EMB_RELST_LO, R_PPC_EMB_RELST_HA 7972 goto unsupp; 7973 case elfcpp::R_POWERPC_ADDR16_HI: 7974 case elfcpp::R_POWERPC_REL16_HI: 7975 case elfcpp::R_PPC64_TOC16_HI: 7976 case elfcpp::R_POWERPC_GOT16_HI: 7977 case elfcpp::R_POWERPC_SECTOFF_HI: 7978 case elfcpp::R_POWERPC_TPREL16_HI: 7979 case elfcpp::R_POWERPC_DTPREL16_HI: 7980 case elfcpp::R_POWERPC_GOT_TLSGD16_HI: 7981 case elfcpp::R_POWERPC_GOT_TLSLD16_HI: 7982 case elfcpp::R_POWERPC_GOT_TPREL16_HI: 7983 case elfcpp::R_POWERPC_GOT_DTPREL16_HI: 7984 Reloc::addr16_hi(view, value); 7985 break; 7986 7987 case elfcpp::R_PPC64_ADDR16_HIGHA: 7988 case elfcpp::R_PPC64_TPREL16_HIGHA: 7989 case elfcpp::R_PPC64_DTPREL16_HIGHA: 7990 if (size == 32) 7991 // R_PPC_EMB_RELSEC16, R_PPC_EMB_RELST_HI, R_PPC_EMB_BIT_FLD 7992 goto unsupp; 7993 case elfcpp::R_POWERPC_ADDR16_HA: 7994 case elfcpp::R_POWERPC_REL16_HA: 7995 case elfcpp::R_PPC64_TOC16_HA: 7996 case elfcpp::R_POWERPC_GOT16_HA: 7997 case elfcpp::R_POWERPC_SECTOFF_HA: 7998 case elfcpp::R_POWERPC_TPREL16_HA: 7999 case elfcpp::R_POWERPC_DTPREL16_HA: 8000 case elfcpp::R_POWERPC_GOT_TLSGD16_HA: 8001 case elfcpp::R_POWERPC_GOT_TLSLD16_HA: 8002 case elfcpp::R_POWERPC_GOT_TPREL16_HA: 8003 case elfcpp::R_POWERPC_GOT_DTPREL16_HA: 8004 Reloc::addr16_ha(view, value); 8005 break; 8006 8007 case elfcpp::R_POWERPC_REL16DX_HA: 8008 status = Reloc::addr16dx_ha(view, value, overflow); 8009 break; 8010 8011 case elfcpp::R_PPC64_DTPREL16_HIGHER: 8012 if (size == 32) 8013 // R_PPC_EMB_NADDR16_LO 8014 goto unsupp; 8015 case elfcpp::R_PPC64_ADDR16_HIGHER: 8016 case elfcpp::R_PPC64_TPREL16_HIGHER: 8017 Reloc::addr16_hi2(view, value); 8018 break; 8019 8020 case elfcpp::R_PPC64_DTPREL16_HIGHERA: 8021 if (size == 32) 8022 // R_PPC_EMB_NADDR16_HI 8023 goto unsupp; 8024 case elfcpp::R_PPC64_ADDR16_HIGHERA: 8025 case elfcpp::R_PPC64_TPREL16_HIGHERA: 8026 Reloc::addr16_ha2(view, value); 8027 break; 8028 8029 case elfcpp::R_PPC64_DTPREL16_HIGHEST: 8030 if (size == 32) 8031 // R_PPC_EMB_NADDR16_HA 8032 goto unsupp; 8033 case elfcpp::R_PPC64_ADDR16_HIGHEST: 8034 case elfcpp::R_PPC64_TPREL16_HIGHEST: 8035 Reloc::addr16_hi3(view, value); 8036 break; 8037 8038 case elfcpp::R_PPC64_DTPREL16_HIGHESTA: 8039 if (size == 32) 8040 // R_PPC_EMB_SDAI16 8041 goto unsupp; 8042 case elfcpp::R_PPC64_ADDR16_HIGHESTA: 8043 case elfcpp::R_PPC64_TPREL16_HIGHESTA: 8044 Reloc::addr16_ha3(view, value); 8045 break; 8046 8047 case elfcpp::R_PPC64_DTPREL16_DS: 8048 case elfcpp::R_PPC64_DTPREL16_LO_DS: 8049 if (size == 32) 8050 // R_PPC_EMB_NADDR32, R_PPC_EMB_NADDR16 8051 goto unsupp; 8052 case elfcpp::R_PPC64_TPREL16_DS: 8053 case elfcpp::R_PPC64_TPREL16_LO_DS: 8054 if (size == 32) 8055 // R_PPC_TLSGD, R_PPC_TLSLD 8056 break; 8057 case elfcpp::R_PPC64_ADDR16_DS: 8058 case elfcpp::R_PPC64_ADDR16_LO_DS: 8059 case elfcpp::R_PPC64_TOC16_DS: 8060 case elfcpp::R_PPC64_TOC16_LO_DS: 8061 case elfcpp::R_PPC64_GOT16_DS: 8062 case elfcpp::R_PPC64_GOT16_LO_DS: 8063 case elfcpp::R_PPC64_SECTOFF_DS: 8064 case elfcpp::R_PPC64_SECTOFF_LO_DS: 8065 maybe_dq_reloc = true; 8066 break; 8067 8068 case elfcpp::R_POWERPC_ADDR14: 8069 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 8070 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 8071 case elfcpp::R_POWERPC_REL14: 8072 case elfcpp::R_POWERPC_REL14_BRTAKEN: 8073 case elfcpp::R_POWERPC_REL14_BRNTAKEN: 8074 status = Reloc::addr14(view, value, overflow); 8075 break; 8076 8077 case elfcpp::R_POWERPC_COPY: 8078 case elfcpp::R_POWERPC_GLOB_DAT: 8079 case elfcpp::R_POWERPC_JMP_SLOT: 8080 case elfcpp::R_POWERPC_RELATIVE: 8081 case elfcpp::R_POWERPC_DTPMOD: 8082 case elfcpp::R_PPC64_JMP_IREL: 8083 case elfcpp::R_POWERPC_IRELATIVE: 8084 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 8085 _("unexpected reloc %u in object file"), 8086 r_type); 8087 break; 8088 8089 case elfcpp::R_PPC_EMB_SDA21: 8090 if (size == 32) 8091 goto unsupp; 8092 else 8093 { 8094 // R_PPC64_TOCSAVE. For the time being this can be ignored. 8095 } 8096 break; 8097 8098 case elfcpp::R_PPC_EMB_SDA2I16: 8099 case elfcpp::R_PPC_EMB_SDA2REL: 8100 if (size == 32) 8101 goto unsupp; 8102 // R_PPC64_TLSGD, R_PPC64_TLSLD 8103 break; 8104 8105 case elfcpp::R_POWERPC_PLT32: 8106 case elfcpp::R_POWERPC_PLTREL32: 8107 case elfcpp::R_POWERPC_PLT16_LO: 8108 case elfcpp::R_POWERPC_PLT16_HI: 8109 case elfcpp::R_POWERPC_PLT16_HA: 8110 case elfcpp::R_PPC_SDAREL16: 8111 case elfcpp::R_POWERPC_ADDR30: 8112 case elfcpp::R_PPC64_PLT64: 8113 case elfcpp::R_PPC64_PLTREL64: 8114 case elfcpp::R_PPC64_PLTGOT16: 8115 case elfcpp::R_PPC64_PLTGOT16_LO: 8116 case elfcpp::R_PPC64_PLTGOT16_HI: 8117 case elfcpp::R_PPC64_PLTGOT16_HA: 8118 case elfcpp::R_PPC64_PLT16_LO_DS: 8119 case elfcpp::R_PPC64_PLTGOT16_DS: 8120 case elfcpp::R_PPC64_PLTGOT16_LO_DS: 8121 case elfcpp::R_PPC_EMB_RELSDA: 8122 case elfcpp::R_PPC_TOC16: 8123 default: 8124 unsupp: 8125 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 8126 _("unsupported reloc %u"), 8127 r_type); 8128 break; 8129 } 8130 8131 if (maybe_dq_reloc) 8132 { 8133 if (insn == 0) 8134 insn = elfcpp::Swap<32, big_endian>::readval(iview); 8135 8136 if ((insn & (0x3f << 26)) == 56u << 26 /* lq */ 8137 || ((insn & (0x3f << 26)) == (61u << 26) /* lxv, stxv */ 8138 && (insn & 3) == 1)) 8139 status = Reloc::addr16_dq(view, value, overflow); 8140 else if (size == 64 8141 || (insn & (0x3f << 26)) == 58u << 26 /* ld,ldu,lwa */ 8142 || (insn & (0x3f << 26)) == 62u << 26 /* std,stdu,stq */ 8143 || (insn & (0x3f << 26)) == 57u << 26 /* lfdp */ 8144 || (insn & (0x3f << 26)) == 61u << 26 /* stfdp */) 8145 status = Reloc::addr16_ds(view, value, overflow); 8146 else 8147 status = Reloc::addr16(view, value, overflow); 8148 } 8149 8150 if (status != Powerpc_relocate_functions<size, big_endian>::STATUS_OK 8151 && (has_stub_value 8152 || !(gsym != NULL 8153 && gsym->is_undefined() 8154 && is_branch_reloc(r_type)))) 8155 { 8156 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 8157 _("relocation overflow")); 8158 if (has_stub_value) 8159 gold_info(_("try relinking with a smaller --stub-group-size")); 8160 } 8161 8162 return true; 8163 } 8164 8165 // Relocate section data. 8166 8167 template<int size, bool big_endian> 8168 void 8169 Target_powerpc<size, big_endian>::relocate_section( 8170 const Relocate_info<size, big_endian>* relinfo, 8171 unsigned int sh_type, 8172 const unsigned char* prelocs, 8173 size_t reloc_count, 8174 Output_section* output_section, 8175 bool needs_special_offset_handling, 8176 unsigned char* view, 8177 Address address, 8178 section_size_type view_size, 8179 const Reloc_symbol_changes* reloc_symbol_changes) 8180 { 8181 typedef Target_powerpc<size, big_endian> Powerpc; 8182 typedef typename Target_powerpc<size, big_endian>::Relocate Powerpc_relocate; 8183 typedef typename Target_powerpc<size, big_endian>::Relocate_comdat_behavior 8184 Powerpc_comdat_behavior; 8185 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 8186 Classify_reloc; 8187 8188 gold_assert(sh_type == elfcpp::SHT_RELA); 8189 8190 gold::relocate_section<size, big_endian, Powerpc, Powerpc_relocate, 8191 Powerpc_comdat_behavior, Classify_reloc>( 8192 relinfo, 8193 this, 8194 prelocs, 8195 reloc_count, 8196 output_section, 8197 needs_special_offset_handling, 8198 view, 8199 address, 8200 view_size, 8201 reloc_symbol_changes); 8202 } 8203 8204 template<int size, bool big_endian> 8205 class Powerpc_scan_relocatable_reloc 8206 { 8207 public: 8208 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc 8209 Reltype; 8210 static const int reloc_size = 8211 Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size; 8212 static const int sh_type = elfcpp::SHT_RELA; 8213 8214 // Return the symbol referred to by the relocation. 8215 static inline unsigned int 8216 get_r_sym(const Reltype* reloc) 8217 { return elfcpp::elf_r_sym<size>(reloc->get_r_info()); } 8218 8219 // Return the type of the relocation. 8220 static inline unsigned int 8221 get_r_type(const Reltype* reloc) 8222 { return elfcpp::elf_r_type<size>(reloc->get_r_info()); } 8223 8224 // Return the strategy to use for a local symbol which is not a 8225 // section symbol, given the relocation type. 8226 inline Relocatable_relocs::Reloc_strategy 8227 local_non_section_strategy(unsigned int r_type, Relobj*, unsigned int r_sym) 8228 { 8229 if (r_type == 0 && r_sym == 0) 8230 return Relocatable_relocs::RELOC_DISCARD; 8231 return Relocatable_relocs::RELOC_COPY; 8232 } 8233 8234 // Return the strategy to use for a local symbol which is a section 8235 // symbol, given the relocation type. 8236 inline Relocatable_relocs::Reloc_strategy 8237 local_section_strategy(unsigned int, Relobj*) 8238 { 8239 return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA; 8240 } 8241 8242 // Return the strategy to use for a global symbol, given the 8243 // relocation type, the object, and the symbol index. 8244 inline Relocatable_relocs::Reloc_strategy 8245 global_strategy(unsigned int r_type, Relobj*, unsigned int) 8246 { 8247 if (r_type == elfcpp::R_PPC_PLTREL24) 8248 return Relocatable_relocs::RELOC_SPECIAL; 8249 return Relocatable_relocs::RELOC_COPY; 8250 } 8251 }; 8252 8253 // Scan the relocs during a relocatable link. 8254 8255 template<int size, bool big_endian> 8256 void 8257 Target_powerpc<size, big_endian>::scan_relocatable_relocs( 8258 Symbol_table* symtab, 8259 Layout* layout, 8260 Sized_relobj_file<size, big_endian>* object, 8261 unsigned int data_shndx, 8262 unsigned int sh_type, 8263 const unsigned char* prelocs, 8264 size_t reloc_count, 8265 Output_section* output_section, 8266 bool needs_special_offset_handling, 8267 size_t local_symbol_count, 8268 const unsigned char* plocal_symbols, 8269 Relocatable_relocs* rr) 8270 { 8271 typedef Powerpc_scan_relocatable_reloc<size, big_endian> Scan_strategy; 8272 8273 gold_assert(sh_type == elfcpp::SHT_RELA); 8274 8275 gold::scan_relocatable_relocs<size, big_endian, Scan_strategy>( 8276 symtab, 8277 layout, 8278 object, 8279 data_shndx, 8280 prelocs, 8281 reloc_count, 8282 output_section, 8283 needs_special_offset_handling, 8284 local_symbol_count, 8285 plocal_symbols, 8286 rr); 8287 } 8288 8289 // Scan the relocs for --emit-relocs. 8290 8291 template<int size, bool big_endian> 8292 void 8293 Target_powerpc<size, big_endian>::emit_relocs_scan( 8294 Symbol_table* symtab, 8295 Layout* layout, 8296 Sized_relobj_file<size, big_endian>* object, 8297 unsigned int data_shndx, 8298 unsigned int sh_type, 8299 const unsigned char* prelocs, 8300 size_t reloc_count, 8301 Output_section* output_section, 8302 bool needs_special_offset_handling, 8303 size_t local_symbol_count, 8304 const unsigned char* plocal_syms, 8305 Relocatable_relocs* rr) 8306 { 8307 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 8308 Classify_reloc; 8309 typedef gold::Default_emit_relocs_strategy<Classify_reloc> 8310 Emit_relocs_strategy; 8311 8312 gold_assert(sh_type == elfcpp::SHT_RELA); 8313 8314 gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>( 8315 symtab, 8316 layout, 8317 object, 8318 data_shndx, 8319 prelocs, 8320 reloc_count, 8321 output_section, 8322 needs_special_offset_handling, 8323 local_symbol_count, 8324 plocal_syms, 8325 rr); 8326 } 8327 8328 // Emit relocations for a section. 8329 // This is a modified version of the function by the same name in 8330 // target-reloc.h. Using relocate_special_relocatable for 8331 // R_PPC_PLTREL24 would require duplication of the entire body of the 8332 // loop, so we may as well duplicate the whole thing. 8333 8334 template<int size, bool big_endian> 8335 void 8336 Target_powerpc<size, big_endian>::relocate_relocs( 8337 const Relocate_info<size, big_endian>* relinfo, 8338 unsigned int sh_type, 8339 const unsigned char* prelocs, 8340 size_t reloc_count, 8341 Output_section* output_section, 8342 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section, 8343 unsigned char*, 8344 Address view_address, 8345 section_size_type, 8346 unsigned char* reloc_view, 8347 section_size_type reloc_view_size) 8348 { 8349 gold_assert(sh_type == elfcpp::SHT_RELA); 8350 8351 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc 8352 Reltype; 8353 typedef typename Reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc_write 8354 Reltype_write; 8355 const int reloc_size 8356 = Reloc_types<elfcpp::SHT_RELA, size, big_endian>::reloc_size; 8357 // Offset from start of insn to d-field reloc. 8358 const int d_offset = big_endian ? 2 : 0; 8359 8360 Powerpc_relobj<size, big_endian>* const object 8361 = static_cast<Powerpc_relobj<size, big_endian>*>(relinfo->object); 8362 const unsigned int local_count = object->local_symbol_count(); 8363 unsigned int got2_shndx = object->got2_shndx(); 8364 Address got2_addend = 0; 8365 if (got2_shndx != 0) 8366 { 8367 got2_addend = object->get_output_section_offset(got2_shndx); 8368 gold_assert(got2_addend != invalid_address); 8369 } 8370 8371 unsigned char* pwrite = reloc_view; 8372 bool zap_next = false; 8373 for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) 8374 { 8375 Relocatable_relocs::Reloc_strategy strategy = relinfo->rr->strategy(i); 8376 if (strategy == Relocatable_relocs::RELOC_DISCARD) 8377 continue; 8378 8379 Reltype reloc(prelocs); 8380 Reltype_write reloc_write(pwrite); 8381 8382 Address offset = reloc.get_r_offset(); 8383 typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info(); 8384 unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info); 8385 unsigned int r_type = elfcpp::elf_r_type<size>(r_info); 8386 const unsigned int orig_r_sym = r_sym; 8387 typename elfcpp::Elf_types<size>::Elf_Swxword addend 8388 = reloc.get_r_addend(); 8389 const Symbol* gsym = NULL; 8390 8391 if (zap_next) 8392 { 8393 // We could arrange to discard these and other relocs for 8394 // tls optimised sequences in the strategy methods, but for 8395 // now do as BFD ld does. 8396 r_type = elfcpp::R_POWERPC_NONE; 8397 zap_next = false; 8398 } 8399 8400 // Get the new symbol index. 8401 Output_section* os = NULL; 8402 if (r_sym < local_count) 8403 { 8404 switch (strategy) 8405 { 8406 case Relocatable_relocs::RELOC_COPY: 8407 case Relocatable_relocs::RELOC_SPECIAL: 8408 if (r_sym != 0) 8409 { 8410 r_sym = object->symtab_index(r_sym); 8411 gold_assert(r_sym != -1U); 8412 } 8413 break; 8414 8415 case Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA: 8416 { 8417 // We are adjusting a section symbol. We need to find 8418 // the symbol table index of the section symbol for 8419 // the output section corresponding to input section 8420 // in which this symbol is defined. 8421 gold_assert(r_sym < local_count); 8422 bool is_ordinary; 8423 unsigned int shndx = 8424 object->local_symbol_input_shndx(r_sym, &is_ordinary); 8425 gold_assert(is_ordinary); 8426 os = object->output_section(shndx); 8427 gold_assert(os != NULL); 8428 gold_assert(os->needs_symtab_index()); 8429 r_sym = os->symtab_index(); 8430 } 8431 break; 8432 8433 default: 8434 gold_unreachable(); 8435 } 8436 } 8437 else 8438 { 8439 gsym = object->global_symbol(r_sym); 8440 gold_assert(gsym != NULL); 8441 if (gsym->is_forwarder()) 8442 gsym = relinfo->symtab->resolve_forwards(gsym); 8443 8444 gold_assert(gsym->has_symtab_index()); 8445 r_sym = gsym->symtab_index(); 8446 } 8447 8448 // Get the new offset--the location in the output section where 8449 // this relocation should be applied. 8450 if (static_cast<Address>(offset_in_output_section) != invalid_address) 8451 offset += offset_in_output_section; 8452 else 8453 { 8454 section_offset_type sot_offset = 8455 convert_types<section_offset_type, Address>(offset); 8456 section_offset_type new_sot_offset = 8457 output_section->output_offset(object, relinfo->data_shndx, 8458 sot_offset); 8459 gold_assert(new_sot_offset != -1); 8460 offset = new_sot_offset; 8461 } 8462 8463 // In an object file, r_offset is an offset within the section. 8464 // In an executable or dynamic object, generated by 8465 // --emit-relocs, r_offset is an absolute address. 8466 if (!parameters->options().relocatable()) 8467 { 8468 offset += view_address; 8469 if (static_cast<Address>(offset_in_output_section) != invalid_address) 8470 offset -= offset_in_output_section; 8471 } 8472 8473 // Handle the reloc addend based on the strategy. 8474 if (strategy == Relocatable_relocs::RELOC_COPY) 8475 ; 8476 else if (strategy == Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA) 8477 { 8478 const Symbol_value<size>* psymval = object->local_symbol(orig_r_sym); 8479 gold_assert(os != NULL); 8480 addend = psymval->value(object, addend) - os->address(); 8481 } 8482 else if (strategy == Relocatable_relocs::RELOC_SPECIAL) 8483 { 8484 if (size == 32) 8485 { 8486 if (addend >= 32768) 8487 addend += got2_addend; 8488 } 8489 else if (r_type == elfcpp::R_POWERPC_REL16_HA) 8490 { 8491 r_type = elfcpp::R_POWERPC_ADDR16_HA; 8492 addend -= d_offset; 8493 } 8494 else if (r_type == elfcpp::R_POWERPC_REL16_LO) 8495 { 8496 r_type = elfcpp::R_POWERPC_ADDR16_LO; 8497 addend -= d_offset + 4; 8498 } 8499 } 8500 else 8501 gold_unreachable(); 8502 8503 if (!parameters->options().relocatable()) 8504 { 8505 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 8506 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO 8507 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HI 8508 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_HA) 8509 { 8510 // First instruction of a global dynamic sequence, 8511 // arg setup insn. 8512 const bool final = gsym == NULL || gsym->final_value_is_known(); 8513 switch (this->optimize_tls_gd(final)) 8514 { 8515 case tls::TLSOPT_TO_IE: 8516 r_type += (elfcpp::R_POWERPC_GOT_TPREL16 8517 - elfcpp::R_POWERPC_GOT_TLSGD16); 8518 break; 8519 case tls::TLSOPT_TO_LE: 8520 if (r_type == elfcpp::R_POWERPC_GOT_TLSGD16 8521 || r_type == elfcpp::R_POWERPC_GOT_TLSGD16_LO) 8522 r_type = elfcpp::R_POWERPC_TPREL16_HA; 8523 else 8524 { 8525 r_type = elfcpp::R_POWERPC_NONE; 8526 offset -= d_offset; 8527 } 8528 break; 8529 default: 8530 break; 8531 } 8532 } 8533 else if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16 8534 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO 8535 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HI 8536 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_HA) 8537 { 8538 // First instruction of a local dynamic sequence, 8539 // arg setup insn. 8540 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE) 8541 { 8542 if (r_type == elfcpp::R_POWERPC_GOT_TLSLD16 8543 || r_type == elfcpp::R_POWERPC_GOT_TLSLD16_LO) 8544 { 8545 r_type = elfcpp::R_POWERPC_TPREL16_HA; 8546 const Output_section* os = relinfo->layout->tls_segment() 8547 ->first_section(); 8548 gold_assert(os != NULL); 8549 gold_assert(os->needs_symtab_index()); 8550 r_sym = os->symtab_index(); 8551 addend = dtp_offset; 8552 } 8553 else 8554 { 8555 r_type = elfcpp::R_POWERPC_NONE; 8556 offset -= d_offset; 8557 } 8558 } 8559 } 8560 else if (r_type == elfcpp::R_POWERPC_GOT_TPREL16 8561 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO 8562 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HI 8563 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_HA) 8564 { 8565 // First instruction of initial exec sequence. 8566 const bool final = gsym == NULL || gsym->final_value_is_known(); 8567 if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE) 8568 { 8569 if (r_type == elfcpp::R_POWERPC_GOT_TPREL16 8570 || r_type == elfcpp::R_POWERPC_GOT_TPREL16_LO) 8571 r_type = elfcpp::R_POWERPC_TPREL16_HA; 8572 else 8573 { 8574 r_type = elfcpp::R_POWERPC_NONE; 8575 offset -= d_offset; 8576 } 8577 } 8578 } 8579 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSGD) 8580 || (size == 32 && r_type == elfcpp::R_PPC_TLSGD)) 8581 { 8582 // Second instruction of a global dynamic sequence, 8583 // the __tls_get_addr call 8584 const bool final = gsym == NULL || gsym->final_value_is_known(); 8585 switch (this->optimize_tls_gd(final)) 8586 { 8587 case tls::TLSOPT_TO_IE: 8588 r_type = elfcpp::R_POWERPC_NONE; 8589 zap_next = true; 8590 break; 8591 case tls::TLSOPT_TO_LE: 8592 r_type = elfcpp::R_POWERPC_TPREL16_LO; 8593 offset += d_offset; 8594 zap_next = true; 8595 break; 8596 default: 8597 break; 8598 } 8599 } 8600 else if ((size == 64 && r_type == elfcpp::R_PPC64_TLSLD) 8601 || (size == 32 && r_type == elfcpp::R_PPC_TLSLD)) 8602 { 8603 // Second instruction of a local dynamic sequence, 8604 // the __tls_get_addr call 8605 if (this->optimize_tls_ld() == tls::TLSOPT_TO_LE) 8606 { 8607 const Output_section* os = relinfo->layout->tls_segment() 8608 ->first_section(); 8609 gold_assert(os != NULL); 8610 gold_assert(os->needs_symtab_index()); 8611 r_sym = os->symtab_index(); 8612 addend = dtp_offset; 8613 r_type = elfcpp::R_POWERPC_TPREL16_LO; 8614 offset += d_offset; 8615 zap_next = true; 8616 } 8617 } 8618 else if (r_type == elfcpp::R_POWERPC_TLS) 8619 { 8620 // Second instruction of an initial exec sequence 8621 const bool final = gsym == NULL || gsym->final_value_is_known(); 8622 if (this->optimize_tls_ie(final) == tls::TLSOPT_TO_LE) 8623 { 8624 r_type = elfcpp::R_POWERPC_TPREL16_LO; 8625 offset += d_offset; 8626 } 8627 } 8628 } 8629 8630 reloc_write.put_r_offset(offset); 8631 reloc_write.put_r_info(elfcpp::elf_r_info<size>(r_sym, r_type)); 8632 reloc_write.put_r_addend(addend); 8633 8634 pwrite += reloc_size; 8635 } 8636 8637 gold_assert(static_cast<section_size_type>(pwrite - reloc_view) 8638 == reloc_view_size); 8639 } 8640 8641 // Return the value to use for a dynamic symbol which requires special 8642 // treatment. This is how we support equality comparisons of function 8643 // pointers across shared library boundaries, as described in the 8644 // processor specific ABI supplement. 8645 8646 template<int size, bool big_endian> 8647 uint64_t 8648 Target_powerpc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const 8649 { 8650 if (size == 32) 8651 { 8652 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); 8653 for (typename Stub_tables::const_iterator p = this->stub_tables_.begin(); 8654 p != this->stub_tables_.end(); 8655 ++p) 8656 { 8657 Address off = (*p)->find_plt_call_entry(gsym); 8658 if (off != invalid_address) 8659 return (*p)->stub_address() + off; 8660 } 8661 } 8662 else if (this->abiversion() >= 2) 8663 { 8664 Address off = this->glink_section()->find_global_entry(gsym); 8665 if (off != invalid_address) 8666 return this->glink_section()->global_entry_address() + off; 8667 } 8668 gold_unreachable(); 8669 } 8670 8671 // Return the PLT address to use for a local symbol. 8672 template<int size, bool big_endian> 8673 uint64_t 8674 Target_powerpc<size, big_endian>::do_plt_address_for_local( 8675 const Relobj* object, 8676 unsigned int symndx) const 8677 { 8678 if (size == 32) 8679 { 8680 const Sized_relobj<size, big_endian>* relobj 8681 = static_cast<const Sized_relobj<size, big_endian>*>(object); 8682 for (typename Stub_tables::const_iterator p = this->stub_tables_.begin(); 8683 p != this->stub_tables_.end(); 8684 ++p) 8685 { 8686 Address off = (*p)->find_plt_call_entry(relobj->sized_relobj(), 8687 symndx); 8688 if (off != invalid_address) 8689 return (*p)->stub_address() + off; 8690 } 8691 } 8692 gold_unreachable(); 8693 } 8694 8695 // Return the PLT address to use for a global symbol. 8696 template<int size, bool big_endian> 8697 uint64_t 8698 Target_powerpc<size, big_endian>::do_plt_address_for_global( 8699 const Symbol* gsym) const 8700 { 8701 if (size == 32) 8702 { 8703 for (typename Stub_tables::const_iterator p = this->stub_tables_.begin(); 8704 p != this->stub_tables_.end(); 8705 ++p) 8706 { 8707 Address off = (*p)->find_plt_call_entry(gsym); 8708 if (off != invalid_address) 8709 return (*p)->stub_address() + off; 8710 } 8711 } 8712 else if (this->abiversion() >= 2) 8713 { 8714 Address off = this->glink_section()->find_global_entry(gsym); 8715 if (off != invalid_address) 8716 return this->glink_section()->global_entry_address() + off; 8717 } 8718 gold_unreachable(); 8719 } 8720 8721 // Return the offset to use for the GOT_INDX'th got entry which is 8722 // for a local tls symbol specified by OBJECT, SYMNDX. 8723 template<int size, bool big_endian> 8724 int64_t 8725 Target_powerpc<size, big_endian>::do_tls_offset_for_local( 8726 const Relobj* object, 8727 unsigned int symndx, 8728 unsigned int got_indx) const 8729 { 8730 const Powerpc_relobj<size, big_endian>* ppc_object 8731 = static_cast<const Powerpc_relobj<size, big_endian>*>(object); 8732 if (ppc_object->local_symbol(symndx)->is_tls_symbol()) 8733 { 8734 for (Got_type got_type = GOT_TYPE_TLSGD; 8735 got_type <= GOT_TYPE_TPREL; 8736 got_type = Got_type(got_type + 1)) 8737 if (ppc_object->local_has_got_offset(symndx, got_type)) 8738 { 8739 unsigned int off = ppc_object->local_got_offset(symndx, got_type); 8740 if (got_type == GOT_TYPE_TLSGD) 8741 off += size / 8; 8742 if (off == got_indx * (size / 8)) 8743 { 8744 if (got_type == GOT_TYPE_TPREL) 8745 return -tp_offset; 8746 else 8747 return -dtp_offset; 8748 } 8749 } 8750 } 8751 gold_unreachable(); 8752 } 8753 8754 // Return the offset to use for the GOT_INDX'th got entry which is 8755 // for global tls symbol GSYM. 8756 template<int size, bool big_endian> 8757 int64_t 8758 Target_powerpc<size, big_endian>::do_tls_offset_for_global( 8759 Symbol* gsym, 8760 unsigned int got_indx) const 8761 { 8762 if (gsym->type() == elfcpp::STT_TLS) 8763 { 8764 for (Got_type got_type = GOT_TYPE_TLSGD; 8765 got_type <= GOT_TYPE_TPREL; 8766 got_type = Got_type(got_type + 1)) 8767 if (gsym->has_got_offset(got_type)) 8768 { 8769 unsigned int off = gsym->got_offset(got_type); 8770 if (got_type == GOT_TYPE_TLSGD) 8771 off += size / 8; 8772 if (off == got_indx * (size / 8)) 8773 { 8774 if (got_type == GOT_TYPE_TPREL) 8775 return -tp_offset; 8776 else 8777 return -dtp_offset; 8778 } 8779 } 8780 } 8781 gold_unreachable(); 8782 } 8783 8784 // The selector for powerpc object files. 8785 8786 template<int size, bool big_endian> 8787 class Target_selector_powerpc : public Target_selector 8788 { 8789 public: 8790 Target_selector_powerpc() 8791 : Target_selector(size == 64 ? elfcpp::EM_PPC64 : elfcpp::EM_PPC, 8792 size, big_endian, 8793 (size == 64 8794 ? (big_endian ? "elf64-powerpc" : "elf64-powerpcle") 8795 : (big_endian ? "elf32-powerpc" : "elf32-powerpcle")), 8796 (size == 64 8797 ? (big_endian ? "elf64ppc" : "elf64lppc") 8798 : (big_endian ? "elf32ppc" : "elf32lppc"))) 8799 { } 8800 8801 virtual Target* 8802 do_instantiate_target() 8803 { return new Target_powerpc<size, big_endian>(); } 8804 }; 8805 8806 Target_selector_powerpc<32, true> target_selector_ppc32; 8807 Target_selector_powerpc<32, false> target_selector_ppc32le; 8808 Target_selector_powerpc<64, true> target_selector_ppc64; 8809 Target_selector_powerpc<64, false> target_selector_ppc64le; 8810 8811 // Instantiate these constants for -O0 8812 template<int size, bool big_endian> 8813 const int Output_data_glink<size, big_endian>::pltresolve_size; 8814 template<int size, bool big_endian> 8815 const typename Output_data_glink<size, big_endian>::Address 8816 Output_data_glink<size, big_endian>::invalid_address; 8817 template<int size, bool big_endian> 8818 const typename Stub_table<size, big_endian>::Address 8819 Stub_table<size, big_endian>::invalid_address; 8820 template<int size, bool big_endian> 8821 const typename Target_powerpc<size, big_endian>::Address 8822 Target_powerpc<size, big_endian>::invalid_address; 8823 8824 } // End anonymous namespace. 8825