1 // powerpc.cc -- powerpc target support for gold. 2 3 // Copyright 2008, 2009, 2010 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 "elfcpp.h" 27 #include "parameters.h" 28 #include "reloc.h" 29 #include "powerpc.h" 30 #include "object.h" 31 #include "symtab.h" 32 #include "layout.h" 33 #include "output.h" 34 #include "copy-relocs.h" 35 #include "target.h" 36 #include "target-reloc.h" 37 #include "target-select.h" 38 #include "tls.h" 39 #include "errors.h" 40 #include "gc.h" 41 42 namespace 43 { 44 45 using namespace gold; 46 47 template<int size, bool big_endian> 48 class Output_data_plt_powerpc; 49 50 template<int size, bool big_endian> 51 class Target_powerpc : public Sized_target<size, big_endian> 52 { 53 public: 54 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section; 55 56 Target_powerpc() 57 : Sized_target<size, big_endian>(&powerpc_info), 58 got_(NULL), got2_(NULL), toc_(NULL), 59 plt_(NULL), rela_dyn_(NULL), 60 copy_relocs_(elfcpp::R_POWERPC_COPY), 61 dynbss_(NULL), got_mod_index_offset_(-1U) 62 { 63 } 64 65 // Process the relocations to determine unreferenced sections for 66 // garbage collection. 67 void 68 gc_process_relocs(Symbol_table* symtab, 69 Layout* layout, 70 Sized_relobj<size, big_endian>* object, 71 unsigned int data_shndx, 72 unsigned int sh_type, 73 const unsigned char* prelocs, 74 size_t reloc_count, 75 Output_section* output_section, 76 bool needs_special_offset_handling, 77 size_t local_symbol_count, 78 const unsigned char* plocal_symbols); 79 80 // Scan the relocations to look for symbol adjustments. 81 void 82 scan_relocs(Symbol_table* symtab, 83 Layout* layout, 84 Sized_relobj<size, big_endian>* object, 85 unsigned int data_shndx, 86 unsigned int sh_type, 87 const unsigned char* prelocs, 88 size_t reloc_count, 89 Output_section* output_section, 90 bool needs_special_offset_handling, 91 size_t local_symbol_count, 92 const unsigned char* plocal_symbols); 93 // Finalize the sections. 94 void 95 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*); 96 97 // Return the value to use for a dynamic which requires special 98 // treatment. 99 uint64_t 100 do_dynsym_value(const Symbol*) const; 101 102 // Relocate a section. 103 void 104 relocate_section(const Relocate_info<size, big_endian>*, 105 unsigned int sh_type, 106 const unsigned char* prelocs, 107 size_t reloc_count, 108 Output_section* output_section, 109 bool needs_special_offset_handling, 110 unsigned char* view, 111 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 112 section_size_type view_size, 113 const Reloc_symbol_changes*); 114 115 // Scan the relocs during a relocatable link. 116 void 117 scan_relocatable_relocs(Symbol_table* symtab, 118 Layout* layout, 119 Sized_relobj<size, big_endian>* object, 120 unsigned int data_shndx, 121 unsigned int sh_type, 122 const unsigned char* prelocs, 123 size_t reloc_count, 124 Output_section* output_section, 125 bool needs_special_offset_handling, 126 size_t local_symbol_count, 127 const unsigned char* plocal_symbols, 128 Relocatable_relocs*); 129 130 // Relocate a section during a relocatable link. 131 void 132 relocate_for_relocatable(const Relocate_info<size, big_endian>*, 133 unsigned int sh_type, 134 const unsigned char* prelocs, 135 size_t reloc_count, 136 Output_section* output_section, 137 off_t offset_in_output_section, 138 const Relocatable_relocs*, 139 unsigned char* view, 140 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 141 section_size_type view_size, 142 unsigned char* reloc_view, 143 section_size_type reloc_view_size); 144 145 // Return whether SYM is defined by the ABI. 146 bool 147 do_is_defined_by_abi(const Symbol* sym) const 148 { 149 return strcmp(sym->name(), "___tls_get_addr") == 0; 150 } 151 152 // Return the size of the GOT section. 153 section_size_type 154 got_size() const 155 { 156 gold_assert(this->got_ != NULL); 157 return this->got_->data_size(); 158 } 159 160 // Return the number of entries in the GOT. 161 unsigned int 162 got_entry_count() const 163 { 164 if (this->got_ == NULL) 165 return 0; 166 return this->got_size() / (size / 8); 167 } 168 169 // Return the number of entries in the PLT. 170 unsigned int 171 plt_entry_count() const; 172 173 // Return the offset of the first non-reserved PLT entry. 174 unsigned int 175 first_plt_entry_offset() const; 176 177 // Return the size of each PLT entry. 178 unsigned int 179 plt_entry_size() const; 180 181 private: 182 183 // The class which scans relocations. 184 class Scan 185 { 186 public: 187 Scan() 188 : issued_non_pic_error_(false) 189 { } 190 191 inline void 192 local(Symbol_table* symtab, Layout* layout, Target_powerpc* target, 193 Sized_relobj<size, big_endian>* object, 194 unsigned int data_shndx, 195 Output_section* output_section, 196 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type, 197 const elfcpp::Sym<size, big_endian>& lsym); 198 199 inline void 200 global(Symbol_table* symtab, Layout* layout, Target_powerpc* target, 201 Sized_relobj<size, big_endian>* object, 202 unsigned int data_shndx, 203 Output_section* output_section, 204 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type, 205 Symbol* gsym); 206 207 inline bool 208 local_reloc_may_be_function_pointer(Symbol_table* , Layout* , 209 Target_powerpc* , 210 Sized_relobj<size, big_endian>* , 211 unsigned int , 212 Output_section* , 213 const elfcpp::Rela<size, big_endian>& , 214 unsigned int , 215 const elfcpp::Sym<size, big_endian>&) 216 { return false; } 217 218 inline bool 219 global_reloc_may_be_function_pointer(Symbol_table* , Layout* , 220 Target_powerpc* , 221 Sized_relobj<size, big_endian>* , 222 unsigned int , 223 Output_section* , 224 const elfcpp::Rela<size, 225 big_endian>& , 226 unsigned int , Symbol*) 227 { return false; } 228 229 private: 230 static void 231 unsupported_reloc_local(Sized_relobj<size, big_endian>*, 232 unsigned int r_type); 233 234 static void 235 unsupported_reloc_global(Sized_relobj<size, big_endian>*, 236 unsigned int r_type, Symbol*); 237 238 static void 239 generate_tls_call(Symbol_table* symtab, Layout* layout, 240 Target_powerpc* target); 241 242 void 243 check_non_pic(Relobj*, unsigned int r_type); 244 245 // Whether we have issued an error about a non-PIC compilation. 246 bool issued_non_pic_error_; 247 }; 248 249 // The class which implements relocation. 250 class Relocate 251 { 252 public: 253 // Do a relocation. Return false if the caller should not issue 254 // any warnings about this relocation. 255 inline bool 256 relocate(const Relocate_info<size, big_endian>*, Target_powerpc*, 257 Output_section*, size_t relnum, 258 const elfcpp::Rela<size, big_endian>&, 259 unsigned int r_type, const Sized_symbol<size>*, 260 const Symbol_value<size>*, 261 unsigned char*, 262 typename elfcpp::Elf_types<size>::Elf_Addr, 263 section_size_type); 264 265 private: 266 // Do a TLS relocation. 267 inline void 268 relocate_tls(const Relocate_info<size, big_endian>*, 269 Target_powerpc* target, 270 size_t relnum, const elfcpp::Rela<size, big_endian>&, 271 unsigned int r_type, const Sized_symbol<size>*, 272 const Symbol_value<size>*, 273 unsigned char*, 274 typename elfcpp::Elf_types<size>::Elf_Addr, 275 section_size_type); 276 }; 277 278 // A class which returns the size required for a relocation type, 279 // used while scanning relocs during a relocatable link. 280 class Relocatable_size_for_reloc 281 { 282 public: 283 unsigned int 284 get_size_for_reloc(unsigned int, Relobj*); 285 }; 286 287 // Get the GOT section, creating it if necessary. 288 Output_data_got<size, big_endian>* 289 got_section(Symbol_table*, Layout*); 290 291 Output_data_space* 292 got2_section() const 293 { 294 gold_assert(this->got2_ != NULL); 295 return this->got2_; 296 } 297 298 // Get the TOC section. 299 Output_data_space* 300 toc_section() const 301 { 302 gold_assert(this->toc_ != NULL); 303 return this->toc_; 304 } 305 306 // Create a PLT entry for a global symbol. 307 void 308 make_plt_entry(Symbol_table*, Layout*, Symbol*); 309 310 // Create a GOT entry for the TLS module index. 311 unsigned int 312 got_mod_index_entry(Symbol_table* symtab, Layout* layout, 313 Sized_relobj<size, big_endian>* object); 314 315 // Get the PLT section. 316 const Output_data_plt_powerpc<size, big_endian>* 317 plt_section() const 318 { 319 gold_assert(this->plt_ != NULL); 320 return this->plt_; 321 } 322 323 // Get the dynamic reloc section, creating it if necessary. 324 Reloc_section* 325 rela_dyn_section(Layout*); 326 327 // Copy a relocation against a global symbol. 328 void 329 copy_reloc(Symbol_table* symtab, Layout* layout, 330 Sized_relobj<size, big_endian>* object, 331 unsigned int shndx, Output_section* output_section, 332 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc) 333 { 334 this->copy_relocs_.copy_reloc(symtab, layout, 335 symtab->get_sized_symbol<size>(sym), 336 object, shndx, output_section, 337 reloc, this->rela_dyn_section(layout)); 338 } 339 340 // Information about this specific target which we pass to the 341 // general Target structure. 342 static Target::Target_info powerpc_info; 343 344 // The types of GOT entries needed for this platform. 345 // These values are exposed to the ABI in an incremental link. 346 // Do not renumber existing values without changing the version 347 // number of the .gnu_incremental_inputs section. 348 enum Got_type 349 { 350 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol 351 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset 352 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair 353 }; 354 355 // The GOT section. 356 Output_data_got<size, big_endian>* got_; 357 // The GOT2 section. 358 Output_data_space* got2_; 359 // The TOC section. 360 Output_data_space* toc_; 361 // The PLT section. 362 Output_data_plt_powerpc<size, big_endian>* plt_; 363 // The dynamic reloc section. 364 Reloc_section* rela_dyn_; 365 // Relocs saved to avoid a COPY reloc. 366 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_; 367 // Space for variables copied with a COPY reloc. 368 Output_data_space* dynbss_; 369 // Offset of the GOT entry for the TLS module index; 370 unsigned int got_mod_index_offset_; 371 }; 372 373 template<> 374 Target::Target_info Target_powerpc<32, true>::powerpc_info = 375 { 376 32, // size 377 true, // is_big_endian 378 elfcpp::EM_PPC, // machine_code 379 false, // has_make_symbol 380 false, // has_resolve 381 false, // has_code_fill 382 true, // is_default_stack_executable 383 '\0', // wrap_char 384 "/usr/lib/ld.so.1", // dynamic_linker 385 0x10000000, // default_text_segment_address 386 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 387 4 * 1024, // common_pagesize (overridable by -z common-page-size) 388 elfcpp::SHN_UNDEF, // small_common_shndx 389 elfcpp::SHN_UNDEF, // large_common_shndx 390 0, // small_common_section_flags 391 0, // large_common_section_flags 392 NULL, // attributes_section 393 NULL // attributes_vendor 394 }; 395 396 template<> 397 Target::Target_info Target_powerpc<32, false>::powerpc_info = 398 { 399 32, // size 400 false, // is_big_endian 401 elfcpp::EM_PPC, // machine_code 402 false, // has_make_symbol 403 false, // has_resolve 404 false, // has_code_fill 405 true, // is_default_stack_executable 406 '\0', // wrap_char 407 "/usr/lib/ld.so.1", // dynamic_linker 408 0x10000000, // default_text_segment_address 409 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 410 4 * 1024, // common_pagesize (overridable by -z common-page-size) 411 elfcpp::SHN_UNDEF, // small_common_shndx 412 elfcpp::SHN_UNDEF, // large_common_shndx 413 0, // small_common_section_flags 414 0, // large_common_section_flags 415 NULL, // attributes_section 416 NULL // attributes_vendor 417 }; 418 419 template<> 420 Target::Target_info Target_powerpc<64, true>::powerpc_info = 421 { 422 64, // size 423 true, // is_big_endian 424 elfcpp::EM_PPC64, // machine_code 425 false, // has_make_symbol 426 false, // has_resolve 427 false, // has_code_fill 428 true, // is_default_stack_executable 429 '\0', // wrap_char 430 "/usr/lib/ld.so.1", // dynamic_linker 431 0x10000000, // default_text_segment_address 432 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 433 8 * 1024, // common_pagesize (overridable by -z common-page-size) 434 elfcpp::SHN_UNDEF, // small_common_shndx 435 elfcpp::SHN_UNDEF, // large_common_shndx 436 0, // small_common_section_flags 437 0, // large_common_section_flags 438 NULL, // attributes_section 439 NULL // attributes_vendor 440 }; 441 442 template<> 443 Target::Target_info Target_powerpc<64, false>::powerpc_info = 444 { 445 64, // size 446 false, // is_big_endian 447 elfcpp::EM_PPC64, // machine_code 448 false, // has_make_symbol 449 false, // has_resolve 450 false, // has_code_fill 451 true, // is_default_stack_executable 452 '\0', // wrap_char 453 "/usr/lib/ld.so.1", // dynamic_linker 454 0x10000000, // default_text_segment_address 455 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 456 8 * 1024, // common_pagesize (overridable by -z common-page-size) 457 elfcpp::SHN_UNDEF, // small_common_shndx 458 elfcpp::SHN_UNDEF, // large_common_shndx 459 0, // small_common_section_flags 460 0, // large_common_section_flags 461 NULL, // attributes_section 462 NULL // attributes_vendor 463 }; 464 465 template<int size, bool big_endian> 466 class Powerpc_relocate_functions 467 { 468 private: 469 // Do a simple relocation with the addend in the relocation. 470 template<int valsize> 471 static inline void 472 rela(unsigned char* view, 473 unsigned int right_shift, 474 elfcpp::Elf_Xword dst_mask, 475 typename elfcpp::Swap<size, big_endian>::Valtype value, 476 typename elfcpp::Swap<size, big_endian>::Valtype addend) 477 { 478 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; 479 Valtype* wv = reinterpret_cast<Valtype*>(view); 480 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); 481 Valtype reloc = ((value + addend) >> right_shift); 482 483 val &= ~dst_mask; 484 reloc &= dst_mask; 485 486 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc); 487 } 488 489 // Do a simple relocation using a symbol value with the addend in 490 // the relocation. 491 template<int valsize> 492 static inline void 493 rela(unsigned char* view, 494 unsigned int right_shift, 495 elfcpp::Elf_Xword dst_mask, 496 const Sized_relobj<size, big_endian>* object, 497 const Symbol_value<size>* psymval, 498 typename elfcpp::Swap<valsize, big_endian>::Valtype addend) 499 { 500 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; 501 Valtype* wv = reinterpret_cast<Valtype*>(view); 502 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); 503 Valtype reloc = (psymval->value(object, addend) >> right_shift); 504 505 val &= ~dst_mask; 506 reloc &= dst_mask; 507 508 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc); 509 } 510 511 // Do a simple relocation using a symbol value with the addend in 512 // the relocation, unaligned. 513 template<int valsize> 514 static inline void 515 rela_ua(unsigned char* view, unsigned int right_shift, 516 elfcpp::Elf_Xword dst_mask, 517 const Sized_relobj<size, big_endian>* object, 518 const Symbol_value<size>* psymval, 519 typename elfcpp::Swap<size, big_endian>::Valtype addend) 520 { 521 typedef typename elfcpp::Swap_unaligned<valsize, 522 big_endian>::Valtype Valtype; 523 unsigned char* wv = view; 524 Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv); 525 Valtype reloc = (psymval->value(object, addend) >> right_shift); 526 527 val &= ~dst_mask; 528 reloc &= dst_mask; 529 530 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc); 531 } 532 533 // Do a simple PC relative relocation with a Symbol_value with the 534 // addend in the relocation. 535 template<int valsize> 536 static inline void 537 pcrela(unsigned char* view, unsigned int right_shift, 538 elfcpp::Elf_Xword dst_mask, 539 const Sized_relobj<size, big_endian>* object, 540 const Symbol_value<size>* psymval, 541 typename elfcpp::Swap<size, big_endian>::Valtype addend, 542 typename elfcpp::Elf_types<size>::Elf_Addr address) 543 { 544 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; 545 Valtype* wv = reinterpret_cast<Valtype*>(view); 546 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); 547 Valtype reloc = ((psymval->value(object, addend) - address) 548 >> right_shift); 549 550 val &= ~dst_mask; 551 reloc &= dst_mask; 552 553 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc); 554 } 555 556 template<int valsize> 557 static inline void 558 pcrela_unaligned(unsigned char* view, 559 const Sized_relobj<size, big_endian>* object, 560 const Symbol_value<size>* psymval, 561 typename elfcpp::Swap<size, big_endian>::Valtype addend, 562 typename elfcpp::Elf_types<size>::Elf_Addr address) 563 { 564 typedef typename elfcpp::Swap_unaligned<valsize, 565 big_endian>::Valtype Valtype; 566 unsigned char* wv = view; 567 Valtype reloc = (psymval->value(object, addend) - address); 568 569 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc); 570 } 571 572 typedef Powerpc_relocate_functions<size, big_endian> This; 573 typedef Relocate_functions<size, big_endian> This_reloc; 574 public: 575 // R_POWERPC_REL32: (Symbol + Addend - Address) 576 static inline void 577 rel32(unsigned char* view, 578 const Sized_relobj<size, big_endian>* object, 579 const Symbol_value<size>* psymval, 580 typename elfcpp::Elf_types<size>::Elf_Addr addend, 581 typename elfcpp::Elf_types<size>::Elf_Addr address) 582 { This_reloc::pcrela32(view, object, psymval, addend, address); } 583 584 // R_POWERPC_REL24: (Symbol + Addend - Address) & 0x3fffffc 585 static inline void 586 rel24(unsigned char* view, 587 const Sized_relobj<size, big_endian>* object, 588 const Symbol_value<size>* psymval, 589 typename elfcpp::Elf_types<size>::Elf_Addr addend, 590 typename elfcpp::Elf_types<size>::Elf_Addr address) 591 { 592 This::template pcrela<32>(view, 0, 0x03fffffc, object, 593 psymval, addend, address); 594 } 595 596 // R_POWERPC_REL14: (Symbol + Addend - Address) & 0xfffc 597 static inline void 598 rel14(unsigned char* view, 599 const Sized_relobj<size, big_endian>* object, 600 const Symbol_value<size>* psymval, 601 typename elfcpp::Elf_types<size>::Elf_Addr addend, 602 typename elfcpp::Elf_types<size>::Elf_Addr address) 603 { 604 This::template pcrela<32>(view, 0, 0x0000fffc, object, 605 psymval, addend, address); 606 } 607 608 // R_POWERPC_ADDR16: (Symbol + Addend) & 0xffff 609 static inline void 610 addr16(unsigned char* view, 611 typename elfcpp::Elf_types<size>::Elf_Addr value, 612 typename elfcpp::Elf_types<size>::Elf_Addr addend) 613 { This_reloc::rela16(view, value, addend); } 614 615 static inline void 616 addr16(unsigned char* view, 617 const Sized_relobj<size, big_endian>* object, 618 const Symbol_value<size>* psymval, 619 typename elfcpp::Elf_types<size>::Elf_Addr addend) 620 { This_reloc::rela16(view, object, psymval, addend); } 621 622 // R_POWERPC_ADDR16_DS: (Symbol + Addend) & 0xfffc 623 static inline void 624 addr16_ds(unsigned char* view, 625 typename elfcpp::Elf_types<size>::Elf_Addr value, 626 typename elfcpp::Elf_types<size>::Elf_Addr addend) 627 { 628 This::template rela<16>(view, 0, 0xfffc, value, addend); 629 } 630 631 // R_POWERPC_ADDR16_LO: (Symbol + Addend) & 0xffff 632 static inline void 633 addr16_lo(unsigned char* view, 634 typename elfcpp::Elf_types<size>::Elf_Addr value, 635 typename elfcpp::Elf_types<size>::Elf_Addr addend) 636 { This_reloc::rela16(view, value, addend); } 637 638 static inline void 639 addr16_lo(unsigned char* view, 640 const Sized_relobj<size, big_endian>* object, 641 const Symbol_value<size>* psymval, 642 typename elfcpp::Elf_types<size>::Elf_Addr addend) 643 { This_reloc::rela16(view, object, psymval, addend); } 644 645 // R_POWERPC_ADDR16_HI: ((Symbol + Addend) >> 16) & 0xffff 646 static inline void 647 addr16_hi(unsigned char* view, 648 typename elfcpp::Elf_types<size>::Elf_Addr value, 649 typename elfcpp::Elf_types<size>::Elf_Addr addend) 650 { 651 This::template rela<16>(view, 16, 0xffff, value, addend); 652 } 653 654 static inline void 655 addr16_hi(unsigned char* view, 656 const Sized_relobj<size, big_endian>* object, 657 const Symbol_value<size>* psymval, 658 typename elfcpp::Elf_types<size>::Elf_Addr addend) 659 { 660 This::template rela<16>(view, 16, 0xffff, object, psymval, addend); 661 } 662 663 // R_POWERPC_ADDR16_HA: Same as R_POWERPC_ADDR16_HI except that if the 664 // final value of the low 16 bits of the 665 // relocation is negative, add one. 666 static inline void 667 addr16_ha(unsigned char* view, 668 typename elfcpp::Elf_types<size>::Elf_Addr value, 669 typename elfcpp::Elf_types<size>::Elf_Addr addend) 670 { 671 typename elfcpp::Elf_types<size>::Elf_Addr reloc; 672 673 reloc = value + addend; 674 675 if (reloc & 0x8000) 676 reloc += 0x10000; 677 reloc >>= 16; 678 679 elfcpp::Swap<16, big_endian>::writeval(view, reloc); 680 } 681 682 static inline void 683 addr16_ha(unsigned char* view, 684 const Sized_relobj<size, big_endian>* object, 685 const Symbol_value<size>* psymval, 686 typename elfcpp::Elf_types<size>::Elf_Addr addend) 687 { 688 typename elfcpp::Elf_types<size>::Elf_Addr reloc; 689 690 reloc = psymval->value(object, addend); 691 692 if (reloc & 0x8000) 693 reloc += 0x10000; 694 reloc >>= 16; 695 696 elfcpp::Swap<16, big_endian>::writeval(view, reloc); 697 } 698 699 // R_PPC_REL16: (Symbol + Addend - Address) & 0xffff 700 static inline void 701 rel16(unsigned char* view, 702 const Sized_relobj<size, big_endian>* object, 703 const Symbol_value<size>* psymval, 704 typename elfcpp::Elf_types<size>::Elf_Addr addend, 705 typename elfcpp::Elf_types<size>::Elf_Addr address) 706 { This_reloc::pcrela16(view, object, psymval, addend, address); } 707 708 // R_PPC_REL16_LO: (Symbol + Addend - Address) & 0xffff 709 static inline void 710 rel16_lo(unsigned char* view, 711 const Sized_relobj<size, big_endian>* object, 712 const Symbol_value<size>* psymval, 713 typename elfcpp::Elf_types<size>::Elf_Addr addend, 714 typename elfcpp::Elf_types<size>::Elf_Addr address) 715 { This_reloc::pcrela16(view, object, psymval, addend, address); } 716 717 // R_PPC_REL16_HI: ((Symbol + Addend - Address) >> 16) & 0xffff 718 static inline void 719 rel16_hi(unsigned char* view, 720 const Sized_relobj<size, big_endian>* object, 721 const Symbol_value<size>* psymval, 722 typename elfcpp::Elf_types<size>::Elf_Addr addend, 723 typename elfcpp::Elf_types<size>::Elf_Addr address) 724 { 725 This::template pcrela<16>(view, 16, 0xffff, object, 726 psymval, addend, address); 727 } 728 729 // R_PPC_REL16_HA: Same as R_PPC_REL16_HI except that if the 730 // final value of the low 16 bits of the 731 // relocation is negative, add one. 732 static inline void 733 rel16_ha(unsigned char* view, 734 const Sized_relobj<size, big_endian>* object, 735 const Symbol_value<size>* psymval, 736 typename elfcpp::Elf_types<size>::Elf_Addr addend, 737 typename elfcpp::Elf_types<size>::Elf_Addr address) 738 { 739 typename elfcpp::Elf_types<size>::Elf_Addr reloc; 740 741 reloc = (psymval->value(object, addend) - address); 742 if (reloc & 0x8000) 743 reloc += 0x10000; 744 reloc >>= 16; 745 746 elfcpp::Swap<16, big_endian>::writeval(view, reloc); 747 } 748 }; 749 750 // Get the GOT section, creating it if necessary. 751 752 template<int size, bool big_endian> 753 Output_data_got<size, big_endian>* 754 Target_powerpc<size, big_endian>::got_section(Symbol_table* symtab, 755 Layout* layout) 756 { 757 if (this->got_ == NULL) 758 { 759 gold_assert(symtab != NULL && layout != NULL); 760 761 this->got_ = new Output_data_got<size, big_endian>(); 762 763 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 764 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, 765 this->got_, ORDER_DATA, false); 766 767 // Create the GOT2 or TOC in the .got section. 768 if (size == 32) 769 { 770 this->got2_ = new Output_data_space(4, "** GOT2"); 771 layout->add_output_section_data(".got2", elfcpp::SHT_PROGBITS, 772 elfcpp::SHF_ALLOC 773 | elfcpp::SHF_WRITE, 774 this->got2_, ORDER_DATA, false); 775 } 776 else 777 { 778 this->toc_ = new Output_data_space(8, "** TOC"); 779 layout->add_output_section_data(".toc", elfcpp::SHT_PROGBITS, 780 elfcpp::SHF_ALLOC 781 | elfcpp::SHF_WRITE, 782 this->toc_, ORDER_DATA, false); 783 } 784 785 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section. 786 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 787 Symbol_table::PREDEFINED, 788 this->got_, 789 0, 0, elfcpp::STT_OBJECT, 790 elfcpp::STB_LOCAL, 791 elfcpp::STV_HIDDEN, 0, 792 false, false); 793 } 794 795 return this->got_; 796 } 797 798 // Get the dynamic reloc section, creating it if necessary. 799 800 template<int size, bool big_endian> 801 typename Target_powerpc<size, big_endian>::Reloc_section* 802 Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout) 803 { 804 if (this->rela_dyn_ == NULL) 805 { 806 gold_assert(layout != NULL); 807 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc()); 808 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA, 809 elfcpp::SHF_ALLOC, this->rela_dyn_, 810 ORDER_DYNAMIC_RELOCS, false); 811 } 812 return this->rela_dyn_; 813 } 814 815 // A class to handle the PLT data. 816 817 template<int size, bool big_endian> 818 class Output_data_plt_powerpc : public Output_section_data 819 { 820 public: 821 typedef Output_data_reloc<elfcpp::SHT_RELA, true, 822 size, big_endian> Reloc_section; 823 824 Output_data_plt_powerpc(Layout*); 825 826 // Add an entry to the PLT. 827 void add_entry(Symbol* gsym); 828 829 // Return the .rela.plt section data. 830 const Reloc_section* rel_plt() const 831 { 832 return this->rel_; 833 } 834 835 // Return the number of PLT entries. 836 unsigned int 837 entry_count() const 838 { return this->count_; } 839 840 // Return the offset of the first non-reserved PLT entry. 841 static unsigned int 842 first_plt_entry_offset() 843 { return 4 * base_plt_entry_size; } 844 845 // Return the size of a PLT entry. 846 static unsigned int 847 get_plt_entry_size() 848 { return base_plt_entry_size; } 849 850 protected: 851 void do_adjust_output_section(Output_section* os); 852 853 private: 854 // The size of an entry in the PLT. 855 static const int base_plt_entry_size = (size == 32 ? 16 : 24); 856 857 // Set the final size. 858 void 859 set_final_data_size() 860 { 861 unsigned int full_count = this->count_ + 4; 862 863 this->set_data_size(full_count * base_plt_entry_size); 864 } 865 866 // Write out the PLT data. 867 void 868 do_write(Output_file*); 869 870 // The reloc section. 871 Reloc_section* rel_; 872 // The number of PLT entries. 873 unsigned int count_; 874 }; 875 876 // Create the PLT section. The ordinary .got section is an argument, 877 // since we need to refer to the start. 878 879 template<int size, bool big_endian> 880 Output_data_plt_powerpc<size, big_endian>::Output_data_plt_powerpc(Layout* layout) 881 : Output_section_data(size == 32 ? 4 : 8), count_(0) 882 { 883 this->rel_ = new Reloc_section(false); 884 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 885 elfcpp::SHF_ALLOC, this->rel_, 886 ORDER_DYNAMIC_PLT_RELOCS, false); 887 } 888 889 template<int size, bool big_endian> 890 void 891 Output_data_plt_powerpc<size, big_endian>::do_adjust_output_section(Output_section* os) 892 { 893 os->set_entsize(0); 894 } 895 896 // Add an entry to the PLT. 897 898 template<int size, bool big_endian> 899 void 900 Output_data_plt_powerpc<size, big_endian>::add_entry(Symbol* gsym) 901 { 902 gold_assert(!gsym->has_plt_offset()); 903 unsigned int index = this->count_+ + 4; 904 section_offset_type plt_offset; 905 906 if (index < 8192) 907 plt_offset = index * base_plt_entry_size; 908 else 909 gold_unreachable(); 910 911 gsym->set_plt_offset(plt_offset); 912 913 ++this->count_; 914 915 gsym->set_needs_dynsym_entry(); 916 this->rel_->add_global(gsym, elfcpp::R_POWERPC_JMP_SLOT, this, 917 plt_offset, 0); 918 } 919 920 static const unsigned int addis_11_11 = 0x3d6b0000; 921 static const unsigned int addis_11_30 = 0x3d7e0000; 922 static const unsigned int addis_12_12 = 0x3d8c0000; 923 static const unsigned int addi_11_11 = 0x396b0000; 924 static const unsigned int add_0_11_11 = 0x7c0b5a14; 925 static const unsigned int add_11_0_11 = 0x7d605a14; 926 static const unsigned int b = 0x48000000; 927 static const unsigned int bcl_20_31 = 0x429f0005; 928 static const unsigned int bctr = 0x4e800420; 929 static const unsigned int lis_11 = 0x3d600000; 930 static const unsigned int lis_12 = 0x3d800000; 931 static const unsigned int lwzu_0_12 = 0x840c0000; 932 static const unsigned int lwz_0_12 = 0x800c0000; 933 static const unsigned int lwz_11_11 = 0x816b0000; 934 static const unsigned int lwz_11_30 = 0x817e0000; 935 static const unsigned int lwz_12_12 = 0x818c0000; 936 static const unsigned int mflr_0 = 0x7c0802a6; 937 static const unsigned int mflr_12 = 0x7d8802a6; 938 static const unsigned int mtctr_0 = 0x7c0903a6; 939 static const unsigned int mtctr_11 = 0x7d6903a6; 940 static const unsigned int mtlr_0 = 0x7c0803a6; 941 static const unsigned int nop = 0x60000000; 942 static const unsigned int sub_11_11_12 = 0x7d6c5850; 943 944 static const unsigned int addis_r12_r2 = 0x3d820000; /* addis %r12,%r2,xxx@ha */ 945 static const unsigned int std_r2_40r1 = 0xf8410028; /* std %r2,40(%r1) */ 946 static const unsigned int ld_r11_0r12 = 0xe96c0000; /* ld %r11,xxx+0@l(%r12) */ 947 static const unsigned int ld_r2_0r12 = 0xe84c0000; /* ld %r2,xxx+8@l(%r12) */ 948 /* ld %r11,xxx+16@l(%r12) */ 949 950 951 // Write out the PLT. 952 953 template<int size, bool big_endian> 954 void 955 Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of) 956 { 957 const off_t offset = this->offset(); 958 const section_size_type oview_size = 959 convert_to_section_size_type(this->data_size()); 960 unsigned char* const oview = of->get_output_view(offset, oview_size); 961 unsigned char* pov = oview; 962 963 memset(pov, 0, base_plt_entry_size * 4); 964 pov += base_plt_entry_size * 4; 965 966 unsigned int plt_offset = base_plt_entry_size * 4; 967 const unsigned int count = this->count_; 968 969 if (size == 64) 970 { 971 for (unsigned int i = 0; i < count; i++) 972 { 973 } 974 } 975 else 976 { 977 for (unsigned int i = 0; i < count; i++) 978 { 979 elfcpp::Swap<32, true>::writeval(pov + 0x00, 980 lwz_11_30 + plt_offset); 981 elfcpp::Swap<32, true>::writeval(pov + 0x04, mtctr_11); 982 elfcpp::Swap<32, true>::writeval(pov + 0x08, bctr); 983 elfcpp::Swap<32, true>::writeval(pov + 0x0c, nop); 984 pov += base_plt_entry_size; 985 plt_offset += base_plt_entry_size; 986 } 987 } 988 989 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 990 991 of->write_output_view(offset, oview_size, oview); 992 } 993 994 // Create a PLT entry for a global symbol. 995 996 template<int size, bool big_endian> 997 void 998 Target_powerpc<size, big_endian>::make_plt_entry(Symbol_table* symtab, 999 Layout* layout, 1000 Symbol* gsym) 1001 { 1002 if (gsym->has_plt_offset()) 1003 return; 1004 1005 if (this->plt_ == NULL) 1006 { 1007 // Create the GOT section first. 1008 this->got_section(symtab, layout); 1009 1010 // Ensure that .rela.dyn always appears before .rela.plt This is 1011 // necessary due to how, on PowerPC and some other targets, .rela.dyn 1012 // needs to include .rela.plt in it's range. 1013 this->rela_dyn_section(layout); 1014 1015 this->plt_ = new Output_data_plt_powerpc<size, big_endian>(layout); 1016 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 1017 (elfcpp::SHF_ALLOC 1018 | elfcpp::SHF_EXECINSTR 1019 | elfcpp::SHF_WRITE), 1020 this->plt_, ORDER_PLT, false); 1021 1022 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section. 1023 symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL, 1024 Symbol_table::PREDEFINED, 1025 this->plt_, 1026 0, 0, elfcpp::STT_OBJECT, 1027 elfcpp::STB_LOCAL, 1028 elfcpp::STV_HIDDEN, 0, 1029 false, false); 1030 } 1031 1032 this->plt_->add_entry(gsym); 1033 } 1034 1035 // Return the number of entries in the PLT. 1036 1037 template<int size, bool big_endian> 1038 unsigned int 1039 Target_powerpc<size, big_endian>::plt_entry_count() const 1040 { 1041 if (this->plt_ == NULL) 1042 return 0; 1043 return this->plt_->entry_count(); 1044 } 1045 1046 // Return the offset of the first non-reserved PLT entry. 1047 1048 template<int size, bool big_endian> 1049 unsigned int 1050 Target_powerpc<size, big_endian>::first_plt_entry_offset() const 1051 { 1052 return Output_data_plt_powerpc<size, big_endian>::first_plt_entry_offset(); 1053 } 1054 1055 // Return the size of each PLT entry. 1056 1057 template<int size, bool big_endian> 1058 unsigned int 1059 Target_powerpc<size, big_endian>::plt_entry_size() const 1060 { 1061 return Output_data_plt_powerpc<size, big_endian>::get_plt_entry_size(); 1062 } 1063 1064 // Create a GOT entry for the TLS module index. 1065 1066 template<int size, bool big_endian> 1067 unsigned int 1068 Target_powerpc<size, big_endian>::got_mod_index_entry(Symbol_table* symtab, 1069 Layout* layout, 1070 Sized_relobj<size, big_endian>* object) 1071 { 1072 if (this->got_mod_index_offset_ == -1U) 1073 { 1074 gold_assert(symtab != NULL && layout != NULL && object != NULL); 1075 Reloc_section* rela_dyn = this->rela_dyn_section(layout); 1076 Output_data_got<size, big_endian>* got; 1077 unsigned int got_offset; 1078 1079 got = this->got_section(symtab, layout); 1080 got_offset = got->add_constant(0); 1081 rela_dyn->add_local(object, 0, elfcpp::R_POWERPC_DTPMOD, got, 1082 got_offset, 0); 1083 got->add_constant(0); 1084 this->got_mod_index_offset_ = got_offset; 1085 } 1086 return this->got_mod_index_offset_; 1087 } 1088 1089 // Optimize the TLS relocation type based on what we know about the 1090 // symbol. IS_FINAL is true if the final address of this symbol is 1091 // known at link time. 1092 1093 static tls::Tls_optimization 1094 optimize_tls_reloc(bool /* is_final */, int r_type) 1095 { 1096 // If we are generating a shared library, then we can't do anything 1097 // in the linker. 1098 if (parameters->options().shared()) 1099 return tls::TLSOPT_NONE; 1100 switch (r_type) 1101 { 1102 // XXX 1103 default: 1104 gold_unreachable(); 1105 } 1106 } 1107 1108 // Report an unsupported relocation against a local symbol. 1109 1110 template<int size, bool big_endian> 1111 void 1112 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_local( 1113 Sized_relobj<size, big_endian>* object, 1114 unsigned int r_type) 1115 { 1116 gold_error(_("%s: unsupported reloc %u against local symbol"), 1117 object->name().c_str(), r_type); 1118 } 1119 1120 // We are about to emit a dynamic relocation of type R_TYPE. If the 1121 // dynamic linker does not support it, issue an error. 1122 1123 template<int size, bool big_endian> 1124 void 1125 Target_powerpc<size, big_endian>::Scan::check_non_pic(Relobj* object, 1126 unsigned int r_type) 1127 { 1128 gold_assert(r_type != elfcpp::R_POWERPC_NONE); 1129 1130 // These are the relocation types supported by glibc for both 32-bit 1131 // and 64-bit powerpc. 1132 switch (r_type) 1133 { 1134 case elfcpp::R_POWERPC_RELATIVE: 1135 case elfcpp::R_POWERPC_GLOB_DAT: 1136 case elfcpp::R_POWERPC_DTPMOD: 1137 case elfcpp::R_POWERPC_DTPREL: 1138 case elfcpp::R_POWERPC_TPREL: 1139 case elfcpp::R_POWERPC_JMP_SLOT: 1140 case elfcpp::R_POWERPC_COPY: 1141 case elfcpp::R_POWERPC_ADDR32: 1142 case elfcpp::R_POWERPC_ADDR24: 1143 case elfcpp::R_POWERPC_REL24: 1144 return; 1145 1146 default: 1147 break; 1148 } 1149 1150 if (size == 64) 1151 { 1152 switch (r_type) 1153 { 1154 // These are the relocation types supported only on 64-bit. 1155 case elfcpp::R_PPC64_ADDR64: 1156 case elfcpp::R_PPC64_TPREL16_LO_DS: 1157 case elfcpp::R_PPC64_TPREL16_DS: 1158 case elfcpp::R_POWERPC_TPREL16: 1159 case elfcpp::R_POWERPC_TPREL16_LO: 1160 case elfcpp::R_POWERPC_TPREL16_HI: 1161 case elfcpp::R_POWERPC_TPREL16_HA: 1162 case elfcpp::R_PPC64_TPREL16_HIGHER: 1163 case elfcpp::R_PPC64_TPREL16_HIGHEST: 1164 case elfcpp::R_PPC64_TPREL16_HIGHERA: 1165 case elfcpp::R_PPC64_TPREL16_HIGHESTA: 1166 case elfcpp::R_PPC64_ADDR16_LO_DS: 1167 case elfcpp::R_POWERPC_ADDR16_LO: 1168 case elfcpp::R_POWERPC_ADDR16_HI: 1169 case elfcpp::R_POWERPC_ADDR16_HA: 1170 case elfcpp::R_POWERPC_ADDR30: 1171 case elfcpp::R_PPC64_UADDR64: 1172 case elfcpp::R_POWERPC_UADDR32: 1173 case elfcpp::R_POWERPC_ADDR16: 1174 case elfcpp::R_POWERPC_UADDR16: 1175 case elfcpp::R_PPC64_ADDR16_DS: 1176 case elfcpp::R_PPC64_ADDR16_HIGHER: 1177 case elfcpp::R_PPC64_ADDR16_HIGHEST: 1178 case elfcpp::R_PPC64_ADDR16_HIGHERA: 1179 case elfcpp::R_PPC64_ADDR16_HIGHESTA: 1180 case elfcpp::R_POWERPC_ADDR14_BRTAKEN: 1181 case elfcpp::R_POWERPC_ADDR14_BRNTAKEN: 1182 case elfcpp::R_POWERPC_REL32: 1183 case elfcpp::R_PPC64_REL64: 1184 return; 1185 1186 default: 1187 break; 1188 } 1189 } 1190 else 1191 { 1192 switch (r_type) 1193 { 1194 // These are the relocation types supported only on 32-bit. 1195 1196 default: 1197 break; 1198 } 1199 } 1200 1201 // This prevents us from issuing more than one error per reloc 1202 // section. But we can still wind up issuing more than one 1203 // error per object file. 1204 if (this->issued_non_pic_error_) 1205 return; 1206 gold_assert(parameters->options().output_is_position_independent()); 1207 object->error(_("requires unsupported dynamic reloc; " 1208 "recompile with -fPIC")); 1209 this->issued_non_pic_error_ = true; 1210 return; 1211 } 1212 1213 // Scan a relocation for a local symbol. 1214 1215 template<int size, bool big_endian> 1216 inline void 1217 Target_powerpc<size, big_endian>::Scan::local( 1218 Symbol_table* symtab, 1219 Layout* layout, 1220 Target_powerpc<size, big_endian>* target, 1221 Sized_relobj<size, big_endian>* object, 1222 unsigned int data_shndx, 1223 Output_section* output_section, 1224 const elfcpp::Rela<size, big_endian>& reloc, 1225 unsigned int r_type, 1226 const elfcpp::Sym<size, big_endian>& lsym) 1227 { 1228 switch (r_type) 1229 { 1230 case elfcpp::R_POWERPC_NONE: 1231 case elfcpp::R_POWERPC_GNU_VTINHERIT: 1232 case elfcpp::R_POWERPC_GNU_VTENTRY: 1233 break; 1234 1235 case elfcpp::R_PPC64_ADDR64: 1236 case elfcpp::R_POWERPC_ADDR32: 1237 case elfcpp::R_POWERPC_ADDR16_HA: 1238 case elfcpp::R_POWERPC_ADDR16_LO: 1239 // If building a shared library (or a position-independent 1240 // executable), we need to create a dynamic relocation for 1241 // this location. 1242 if (parameters->options().output_is_position_independent()) 1243 { 1244 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 1245 1246 check_non_pic(object, r_type); 1247 if (lsym.get_st_type() != elfcpp::STT_SECTION) 1248 { 1249 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 1250 rela_dyn->add_local(object, r_sym, r_type, output_section, 1251 data_shndx, reloc.get_r_offset(), 1252 reloc.get_r_addend()); 1253 } 1254 else 1255 { 1256 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 1257 gold_assert(lsym.get_st_value() == 0); 1258 rela_dyn->add_local_relative(object, r_sym, r_type, 1259 output_section, data_shndx, 1260 reloc.get_r_offset(), 1261 reloc.get_r_addend()); 1262 } 1263 } 1264 break; 1265 1266 case elfcpp::R_POWERPC_REL24: 1267 case elfcpp::R_PPC_LOCAL24PC: 1268 case elfcpp::R_POWERPC_REL32: 1269 case elfcpp::R_PPC_REL16_LO: 1270 case elfcpp::R_PPC_REL16_HA: 1271 break; 1272 1273 case elfcpp::R_POWERPC_GOT16: 1274 case elfcpp::R_POWERPC_GOT16_LO: 1275 case elfcpp::R_POWERPC_GOT16_HI: 1276 case elfcpp::R_POWERPC_GOT16_HA: 1277 case elfcpp::R_PPC64_TOC16: 1278 case elfcpp::R_PPC64_TOC16_LO: 1279 case elfcpp::R_PPC64_TOC16_HI: 1280 case elfcpp::R_PPC64_TOC16_HA: 1281 case elfcpp::R_PPC64_TOC16_DS: 1282 case elfcpp::R_PPC64_TOC16_LO_DS: 1283 { 1284 // The symbol requires a GOT entry. 1285 Output_data_got<size, big_endian>* got; 1286 unsigned int r_sym; 1287 1288 got = target->got_section(symtab, layout); 1289 r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 1290 1291 // If we are generating a shared object, we need to add a 1292 // dynamic relocation for this symbol's GOT entry. 1293 if (parameters->options().output_is_position_independent()) 1294 { 1295 if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)) 1296 { 1297 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 1298 unsigned int off; 1299 1300 off = got->add_constant(0); 1301 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off); 1302 rela_dyn->add_local_relative(object, r_sym, 1303 elfcpp::R_POWERPC_RELATIVE, 1304 got, off, 0); 1305 } 1306 } 1307 else 1308 got->add_local(object, r_sym, GOT_TYPE_STANDARD); 1309 } 1310 break; 1311 1312 case elfcpp::R_PPC64_TOC: 1313 // We need a GOT section. 1314 target->got_section(symtab, layout); 1315 break; 1316 1317 // These are relocations which should only be seen by the 1318 // dynamic linker, and should never be seen here. 1319 case elfcpp::R_POWERPC_COPY: 1320 case elfcpp::R_POWERPC_GLOB_DAT: 1321 case elfcpp::R_POWERPC_JMP_SLOT: 1322 case elfcpp::R_POWERPC_RELATIVE: 1323 case elfcpp::R_POWERPC_DTPMOD: 1324 gold_error(_("%s: unexpected reloc %u in object file"), 1325 object->name().c_str(), r_type); 1326 break; 1327 1328 default: 1329 unsupported_reloc_local(object, r_type); 1330 break; 1331 } 1332 } 1333 1334 // Report an unsupported relocation against a global symbol. 1335 1336 template<int size, bool big_endian> 1337 void 1338 Target_powerpc<size, big_endian>::Scan::unsupported_reloc_global( 1339 Sized_relobj<size, big_endian>* object, 1340 unsigned int r_type, 1341 Symbol* gsym) 1342 { 1343 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 1344 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 1345 } 1346 1347 // Scan a relocation for a global symbol. 1348 1349 template<int size, bool big_endian> 1350 inline void 1351 Target_powerpc<size, big_endian>::Scan::global( 1352 Symbol_table* symtab, 1353 Layout* layout, 1354 Target_powerpc<size, big_endian>* target, 1355 Sized_relobj<size, big_endian>* object, 1356 unsigned int data_shndx, 1357 Output_section* output_section, 1358 const elfcpp::Rela<size, big_endian>& reloc, 1359 unsigned int r_type, 1360 Symbol* gsym) 1361 { 1362 switch (r_type) 1363 { 1364 case elfcpp::R_POWERPC_NONE: 1365 case elfcpp::R_POWERPC_GNU_VTINHERIT: 1366 case elfcpp::R_POWERPC_GNU_VTENTRY: 1367 break; 1368 1369 case elfcpp::R_PPC_PLTREL24: 1370 // If the symbol is fully resolved, this is just a PC32 reloc. 1371 // Otherwise we need a PLT entry. 1372 if (gsym->final_value_is_known()) 1373 break; 1374 // If building a shared library, we can also skip the PLT entry 1375 // if the symbol is defined in the output file and is protected 1376 // or hidden. 1377 if (gsym->is_defined() 1378 && !gsym->is_from_dynobj() 1379 && !gsym->is_preemptible()) 1380 break; 1381 target->make_plt_entry(symtab, layout, gsym); 1382 break; 1383 1384 case elfcpp::R_POWERPC_ADDR16: 1385 case elfcpp::R_POWERPC_ADDR16_LO: 1386 case elfcpp::R_POWERPC_ADDR16_HI: 1387 case elfcpp::R_POWERPC_ADDR16_HA: 1388 case elfcpp::R_POWERPC_ADDR32: 1389 case elfcpp::R_PPC64_ADDR64: 1390 { 1391 // Make a PLT entry if necessary. 1392 if (gsym->needs_plt_entry()) 1393 { 1394 target->make_plt_entry(symtab, layout, gsym); 1395 // Since this is not a PC-relative relocation, we may be 1396 // taking the address of a function. In that case we need to 1397 // set the entry in the dynamic symbol table to the address of 1398 // the PLT entry. 1399 if (gsym->is_from_dynobj() && !parameters->options().shared()) 1400 gsym->set_needs_dynsym_value(); 1401 } 1402 // Make a dynamic relocation if necessary. 1403 if (gsym->needs_dynamic_reloc(Symbol::ABSOLUTE_REF)) 1404 { 1405 if (gsym->may_need_copy_reloc()) 1406 { 1407 target->copy_reloc(symtab, layout, object, 1408 data_shndx, output_section, gsym, reloc); 1409 } 1410 else if ((r_type == elfcpp::R_POWERPC_ADDR32 1411 || r_type == elfcpp::R_PPC64_ADDR64) 1412 && gsym->can_use_relative_reloc(false)) 1413 { 1414 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 1415 rela_dyn->add_global_relative(gsym, elfcpp::R_POWERPC_RELATIVE, 1416 output_section, object, 1417 data_shndx, reloc.get_r_offset(), 1418 reloc.get_r_addend()); 1419 } 1420 else 1421 { 1422 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 1423 1424 check_non_pic(object, r_type); 1425 if (gsym->is_from_dynobj() 1426 || gsym->is_undefined() 1427 || gsym->is_preemptible()) 1428 rela_dyn->add_global(gsym, r_type, output_section, 1429 object, data_shndx, 1430 reloc.get_r_offset(), 1431 reloc.get_r_addend()); 1432 else 1433 rela_dyn->add_global_relative(gsym, r_type, 1434 output_section, object, 1435 data_shndx, 1436 reloc.get_r_offset(), 1437 reloc.get_r_addend()); 1438 } 1439 } 1440 } 1441 break; 1442 1443 case elfcpp::R_POWERPC_REL24: 1444 case elfcpp::R_PPC_LOCAL24PC: 1445 case elfcpp::R_PPC_REL16: 1446 case elfcpp::R_PPC_REL16_LO: 1447 case elfcpp::R_PPC_REL16_HI: 1448 case elfcpp::R_PPC_REL16_HA: 1449 { 1450 if (gsym->needs_plt_entry()) 1451 target->make_plt_entry(symtab, layout, gsym); 1452 // Make a dynamic relocation if necessary. 1453 int flags = Symbol::NON_PIC_REF; 1454 if (gsym->type() == elfcpp::STT_FUNC) 1455 flags |= Symbol::FUNCTION_CALL; 1456 if (gsym->needs_dynamic_reloc(flags)) 1457 { 1458 if (gsym->may_need_copy_reloc()) 1459 { 1460 target->copy_reloc(symtab, layout, object, 1461 data_shndx, output_section, gsym, 1462 reloc); 1463 } 1464 else 1465 { 1466 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 1467 check_non_pic(object, r_type); 1468 rela_dyn->add_global(gsym, r_type, output_section, object, 1469 data_shndx, reloc.get_r_offset(), 1470 reloc.get_r_addend()); 1471 } 1472 } 1473 } 1474 break; 1475 1476 case elfcpp::R_POWERPC_GOT16: 1477 case elfcpp::R_POWERPC_GOT16_LO: 1478 case elfcpp::R_POWERPC_GOT16_HI: 1479 case elfcpp::R_POWERPC_GOT16_HA: 1480 case elfcpp::R_PPC64_TOC16: 1481 case elfcpp::R_PPC64_TOC16_LO: 1482 case elfcpp::R_PPC64_TOC16_HI: 1483 case elfcpp::R_PPC64_TOC16_HA: 1484 case elfcpp::R_PPC64_TOC16_DS: 1485 case elfcpp::R_PPC64_TOC16_LO_DS: 1486 { 1487 // The symbol requires a GOT entry. 1488 Output_data_got<size, big_endian>* got; 1489 1490 got = target->got_section(symtab, layout); 1491 if (gsym->final_value_is_known()) 1492 got->add_global(gsym, GOT_TYPE_STANDARD); 1493 else 1494 { 1495 // If this symbol is not fully resolved, we need to add a 1496 // dynamic relocation for it. 1497 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 1498 if (gsym->is_from_dynobj() 1499 || gsym->is_undefined() 1500 || gsym->is_preemptible()) 1501 got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn, 1502 elfcpp::R_POWERPC_GLOB_DAT); 1503 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD)) 1504 { 1505 unsigned int off = got->add_constant(0); 1506 1507 gsym->set_got_offset(GOT_TYPE_STANDARD, off); 1508 rela_dyn->add_global_relative(gsym, elfcpp::R_POWERPC_RELATIVE, 1509 got, off, 0); 1510 } 1511 } 1512 } 1513 break; 1514 1515 case elfcpp::R_PPC64_TOC: 1516 // We need a GOT section. 1517 target->got_section(symtab, layout); 1518 break; 1519 1520 case elfcpp::R_POWERPC_GOT_TPREL16: 1521 case elfcpp::R_POWERPC_TLS: 1522 // XXX TLS 1523 break; 1524 1525 // These are relocations which should only be seen by the 1526 // dynamic linker, and should never be seen here. 1527 case elfcpp::R_POWERPC_COPY: 1528 case elfcpp::R_POWERPC_GLOB_DAT: 1529 case elfcpp::R_POWERPC_JMP_SLOT: 1530 case elfcpp::R_POWERPC_RELATIVE: 1531 case elfcpp::R_POWERPC_DTPMOD: 1532 gold_error(_("%s: unexpected reloc %u in object file"), 1533 object->name().c_str(), r_type); 1534 break; 1535 1536 default: 1537 unsupported_reloc_global(object, r_type, gsym); 1538 break; 1539 } 1540 } 1541 1542 // Process relocations for gc. 1543 1544 template<int size, bool big_endian> 1545 void 1546 Target_powerpc<size, big_endian>::gc_process_relocs( 1547 Symbol_table* symtab, 1548 Layout* layout, 1549 Sized_relobj<size, big_endian>* object, 1550 unsigned int data_shndx, 1551 unsigned int, 1552 const unsigned char* prelocs, 1553 size_t reloc_count, 1554 Output_section* output_section, 1555 bool needs_special_offset_handling, 1556 size_t local_symbol_count, 1557 const unsigned char* plocal_symbols) 1558 { 1559 typedef Target_powerpc<size, big_endian> Powerpc; 1560 typedef typename Target_powerpc<size, big_endian>::Scan Scan; 1561 1562 gold::gc_process_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan, 1563 typename Target_powerpc::Relocatable_size_for_reloc>( 1564 symtab, 1565 layout, 1566 this, 1567 object, 1568 data_shndx, 1569 prelocs, 1570 reloc_count, 1571 output_section, 1572 needs_special_offset_handling, 1573 local_symbol_count, 1574 plocal_symbols); 1575 } 1576 1577 // Scan relocations for a section. 1578 1579 template<int size, bool big_endian> 1580 void 1581 Target_powerpc<size, big_endian>::scan_relocs( 1582 Symbol_table* symtab, 1583 Layout* layout, 1584 Sized_relobj<size, big_endian>* object, 1585 unsigned int data_shndx, 1586 unsigned int sh_type, 1587 const unsigned char* prelocs, 1588 size_t reloc_count, 1589 Output_section* output_section, 1590 bool needs_special_offset_handling, 1591 size_t local_symbol_count, 1592 const unsigned char* plocal_symbols) 1593 { 1594 typedef Target_powerpc<size, big_endian> Powerpc; 1595 typedef typename Target_powerpc<size, big_endian>::Scan Scan; 1596 static Output_data_space* sdata; 1597 1598 if (sh_type == elfcpp::SHT_REL) 1599 { 1600 gold_error(_("%s: unsupported REL reloc section"), 1601 object->name().c_str()); 1602 return; 1603 } 1604 1605 // Define _SDA_BASE_ at the start of the .sdata section. 1606 if (sdata == NULL) 1607 { 1608 // layout->find_output_section(".sdata") == NULL 1609 sdata = new Output_data_space(4, "** sdata"); 1610 Output_section* os = layout->add_output_section_data(".sdata", 0, 1611 elfcpp::SHF_ALLOC 1612 | elfcpp::SHF_WRITE, 1613 sdata, 1614 ORDER_SMALL_DATA, 1615 false); 1616 symtab->define_in_output_data("_SDA_BASE_", NULL, 1617 Symbol_table::PREDEFINED, 1618 os, 1619 32768, 0, 1620 elfcpp::STT_OBJECT, 1621 elfcpp::STB_LOCAL, 1622 elfcpp::STV_HIDDEN, 0, 1623 false, false); 1624 } 1625 1626 gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>( 1627 symtab, 1628 layout, 1629 this, 1630 object, 1631 data_shndx, 1632 prelocs, 1633 reloc_count, 1634 output_section, 1635 needs_special_offset_handling, 1636 local_symbol_count, 1637 plocal_symbols); 1638 } 1639 1640 // Finalize the sections. 1641 1642 template<int size, bool big_endian> 1643 void 1644 Target_powerpc<size, big_endian>::do_finalize_sections( 1645 Layout* layout, 1646 const Input_objects*, 1647 Symbol_table*) 1648 { 1649 // Fill in some more dynamic tags. 1650 const Reloc_section* rel_plt = (this->plt_ == NULL 1651 ? NULL 1652 : this->plt_->rel_plt()); 1653 layout->add_target_dynamic_tags(false, this->plt_, rel_plt, 1654 this->rela_dyn_, true, size == 32); 1655 1656 // Emit any relocs we saved in an attempt to avoid generating COPY 1657 // relocs. 1658 if (this->copy_relocs_.any_saved_relocs()) 1659 this->copy_relocs_.emit(this->rela_dyn_section(layout)); 1660 } 1661 1662 // Perform a relocation. 1663 1664 template<int size, bool big_endian> 1665 inline bool 1666 Target_powerpc<size, big_endian>::Relocate::relocate( 1667 const Relocate_info<size, big_endian>* relinfo, 1668 Target_powerpc* target, 1669 Output_section*, 1670 size_t relnum, 1671 const elfcpp::Rela<size, big_endian>& rela, 1672 unsigned int r_type, 1673 const Sized_symbol<size>* gsym, 1674 const Symbol_value<size>* psymval, 1675 unsigned char* view, 1676 typename elfcpp::Elf_types<size>::Elf_Addr address, 1677 section_size_type /* view_size */) 1678 { 1679 const unsigned int toc_base_offset = 0x8000; 1680 typedef Powerpc_relocate_functions<size, big_endian> Reloc; 1681 1682 // Pick the value to use for symbols defined in shared objects. 1683 Symbol_value<size> symval; 1684 if (gsym != NULL 1685 && gsym->use_plt_offset(r_type == elfcpp::R_POWERPC_REL24 1686 || r_type == elfcpp::R_PPC_LOCAL24PC 1687 || r_type == elfcpp::R_PPC_REL16 1688 || r_type == elfcpp::R_PPC_REL16_LO 1689 || r_type == elfcpp::R_PPC_REL16_HI 1690 || r_type == elfcpp::R_PPC_REL16_HA)) 1691 { 1692 elfcpp::Elf_Xword value; 1693 1694 value = target->plt_section()->address() + gsym->plt_offset(); 1695 1696 symval.set_output_value(value); 1697 1698 psymval = &symval; 1699 } 1700 1701 const Sized_relobj<size, big_endian>* object = relinfo->object; 1702 elfcpp::Elf_Xword addend = rela.get_r_addend(); 1703 1704 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT 1705 // pointer points to the beginning, not the end, of the table. 1706 // So we just use the plain offset. 1707 unsigned int got_offset = 0; 1708 unsigned int got2_offset = 0; 1709 switch (r_type) 1710 { 1711 case elfcpp::R_PPC64_TOC16: 1712 case elfcpp::R_PPC64_TOC16_LO: 1713 case elfcpp::R_PPC64_TOC16_HI: 1714 case elfcpp::R_PPC64_TOC16_HA: 1715 case elfcpp::R_PPC64_TOC16_DS: 1716 case elfcpp::R_PPC64_TOC16_LO_DS: 1717 // Subtract the TOC base address. 1718 addend -= target->toc_section()->address() + toc_base_offset; 1719 /* FALLTHRU */ 1720 1721 case elfcpp::R_POWERPC_GOT16: 1722 case elfcpp::R_POWERPC_GOT16_LO: 1723 case elfcpp::R_POWERPC_GOT16_HI: 1724 case elfcpp::R_POWERPC_GOT16_HA: 1725 case elfcpp::R_PPC64_GOT16_DS: 1726 case elfcpp::R_PPC64_GOT16_LO_DS: 1727 if (gsym != NULL) 1728 { 1729 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 1730 got_offset = gsym->got_offset(GOT_TYPE_STANDARD); 1731 } 1732 else 1733 { 1734 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 1735 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 1736 got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 1737 } 1738 break; 1739 1740 // R_PPC_PLTREL24 is rather special. If non-zero, 1741 // the addend specifies the GOT pointer offset within .got2. 1742 case elfcpp::R_PPC_PLTREL24: 1743 if (addend >= 32768) 1744 { 1745 Output_data_space* got2; 1746 got2 = target->got2_section(); 1747 got2_offset = got2->offset(); 1748 addend += got2_offset; 1749 } 1750 break; 1751 1752 default: 1753 break; 1754 } 1755 1756 switch (r_type) 1757 { 1758 case elfcpp::R_POWERPC_NONE: 1759 case elfcpp::R_POWERPC_GNU_VTINHERIT: 1760 case elfcpp::R_POWERPC_GNU_VTENTRY: 1761 break; 1762 1763 case elfcpp::R_POWERPC_REL32: 1764 Reloc::rel32(view, object, psymval, addend, address); 1765 break; 1766 1767 case elfcpp::R_POWERPC_REL24: 1768 Reloc::rel24(view, object, psymval, addend, address); 1769 break; 1770 1771 case elfcpp::R_POWERPC_REL14: 1772 Reloc::rel14(view, object, psymval, addend, address); 1773 break; 1774 1775 case elfcpp::R_PPC_PLTREL24: 1776 Reloc::rel24(view, object, psymval, addend, address); 1777 break; 1778 1779 case elfcpp::R_PPC_LOCAL24PC: 1780 Reloc::rel24(view, object, psymval, addend, address); 1781 break; 1782 1783 case elfcpp::R_PPC64_ADDR64: 1784 if (!parameters->options().output_is_position_independent()) 1785 Relocate_functions<size, big_endian>::rela64(view, object, 1786 psymval, addend); 1787 break; 1788 1789 case elfcpp::R_POWERPC_ADDR32: 1790 if (!parameters->options().output_is_position_independent()) 1791 Relocate_functions<size, big_endian>::rela32(view, object, 1792 psymval, addend); 1793 break; 1794 1795 case elfcpp::R_POWERPC_ADDR16_LO: 1796 Reloc::addr16_lo(view, object, psymval, addend); 1797 break; 1798 1799 case elfcpp::R_POWERPC_ADDR16_HI: 1800 Reloc::addr16_hi(view, object, psymval, addend); 1801 break; 1802 1803 case elfcpp::R_POWERPC_ADDR16_HA: 1804 Reloc::addr16_ha(view, object, psymval, addend); 1805 break; 1806 1807 case elfcpp::R_PPC_REL16_LO: 1808 Reloc::rel16_lo(view, object, psymval, addend, address); 1809 break; 1810 1811 case elfcpp::R_PPC_REL16_HI: 1812 Reloc::rel16_lo(view, object, psymval, addend, address); 1813 break; 1814 1815 case elfcpp::R_PPC_REL16_HA: 1816 Reloc::rel16_ha(view, object, psymval, addend, address); 1817 break; 1818 1819 case elfcpp::R_POWERPC_GOT16: 1820 Reloc::addr16(view, got_offset, addend); 1821 break; 1822 1823 case elfcpp::R_POWERPC_GOT16_LO: 1824 Reloc::addr16_lo(view, got_offset, addend); 1825 break; 1826 1827 case elfcpp::R_POWERPC_GOT16_HI: 1828 Reloc::addr16_hi(view, got_offset, addend); 1829 break; 1830 1831 case elfcpp::R_POWERPC_GOT16_HA: 1832 Reloc::addr16_ha(view, got_offset, addend); 1833 break; 1834 1835 case elfcpp::R_PPC64_TOC16: 1836 Reloc::addr16(view, got_offset, addend); 1837 break; 1838 1839 case elfcpp::R_PPC64_TOC16_LO: 1840 Reloc::addr16_lo(view, got_offset, addend); 1841 break; 1842 1843 case elfcpp::R_PPC64_TOC16_HI: 1844 Reloc::addr16_hi(view, got_offset, addend); 1845 break; 1846 1847 case elfcpp::R_PPC64_TOC16_HA: 1848 Reloc::addr16_ha(view, got_offset, addend); 1849 break; 1850 1851 case elfcpp::R_PPC64_TOC16_DS: 1852 case elfcpp::R_PPC64_TOC16_LO_DS: 1853 Reloc::addr16_ds(view, got_offset, addend); 1854 break; 1855 1856 case elfcpp::R_PPC64_TOC: 1857 { 1858 elfcpp::Elf_types<64>::Elf_Addr value; 1859 value = target->toc_section()->address() + toc_base_offset; 1860 Relocate_functions<64, false>::rela64(view, value, addend); 1861 } 1862 break; 1863 1864 case elfcpp::R_POWERPC_COPY: 1865 case elfcpp::R_POWERPC_GLOB_DAT: 1866 case elfcpp::R_POWERPC_JMP_SLOT: 1867 case elfcpp::R_POWERPC_RELATIVE: 1868 // This is an outstanding tls reloc, which is unexpected when 1869 // linking. 1870 case elfcpp::R_POWERPC_DTPMOD: 1871 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 1872 _("unexpected reloc %u in object file"), 1873 r_type); 1874 break; 1875 1876 default: 1877 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 1878 _("unsupported reloc %u"), 1879 r_type); 1880 break; 1881 } 1882 1883 return true; 1884 } 1885 1886 // Perform a TLS relocation. 1887 1888 template<int size, bool big_endian> 1889 inline void 1890 Target_powerpc<size, big_endian>::Relocate::relocate_tls( 1891 const Relocate_info<size, big_endian>* relinfo, 1892 Target_powerpc<size, big_endian>* target, 1893 size_t relnum, 1894 const elfcpp::Rela<size, big_endian>& rela, 1895 unsigned int r_type, 1896 const Sized_symbol<size>* gsym, 1897 const Symbol_value<size>* psymval, 1898 unsigned char* view, 1899 typename elfcpp::Elf_types<size>::Elf_Addr address, 1900 section_size_type) 1901 { 1902 Output_segment* tls_segment = relinfo->layout->tls_segment(); 1903 typedef Powerpc_relocate_functions<size, big_endian> Reloc; 1904 const Sized_relobj<size, big_endian>* object = relinfo->object; 1905 1906 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 1907 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0); 1908 1909 const bool is_final = 1910 (gsym == NULL 1911 ? !parameters->options().output_is_position_independent() 1912 : gsym->final_value_is_known()); 1913 const tls::Tls_optimization optimized_type 1914 = optimize_tls_reloc(is_final, r_type); 1915 1916 switch (r_type) 1917 { 1918 // XXX 1919 } 1920 } 1921 1922 // Relocate section data. 1923 1924 template<int size, bool big_endian> 1925 void 1926 Target_powerpc<size, big_endian>::relocate_section( 1927 const Relocate_info<size, big_endian>* relinfo, 1928 unsigned int sh_type, 1929 const unsigned char* prelocs, 1930 size_t reloc_count, 1931 Output_section* output_section, 1932 bool needs_special_offset_handling, 1933 unsigned char* view, 1934 typename elfcpp::Elf_types<size>::Elf_Addr address, 1935 section_size_type view_size, 1936 const Reloc_symbol_changes* reloc_symbol_changes) 1937 { 1938 typedef Target_powerpc<size, big_endian> Powerpc; 1939 typedef typename Target_powerpc<size, big_endian>::Relocate Powerpc_relocate; 1940 1941 gold_assert(sh_type == elfcpp::SHT_RELA); 1942 1943 gold::relocate_section<size, big_endian, Powerpc, elfcpp::SHT_RELA, 1944 Powerpc_relocate>( 1945 relinfo, 1946 this, 1947 prelocs, 1948 reloc_count, 1949 output_section, 1950 needs_special_offset_handling, 1951 view, 1952 address, 1953 view_size, 1954 reloc_symbol_changes); 1955 } 1956 1957 // Return the size of a relocation while scanning during a relocatable 1958 // link. 1959 1960 template<int size, bool big_endian> 1961 unsigned int 1962 Target_powerpc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc( 1963 unsigned int, 1964 Relobj*) 1965 { 1966 // We are always SHT_RELA, so we should never get here. 1967 gold_unreachable(); 1968 return 0; 1969 } 1970 1971 // Scan the relocs during a relocatable link. 1972 1973 template<int size, bool big_endian> 1974 void 1975 Target_powerpc<size, big_endian>::scan_relocatable_relocs( 1976 Symbol_table* symtab, 1977 Layout* layout, 1978 Sized_relobj<size, big_endian>* object, 1979 unsigned int data_shndx, 1980 unsigned int sh_type, 1981 const unsigned char* prelocs, 1982 size_t reloc_count, 1983 Output_section* output_section, 1984 bool needs_special_offset_handling, 1985 size_t local_symbol_count, 1986 const unsigned char* plocal_symbols, 1987 Relocatable_relocs* rr) 1988 { 1989 gold_assert(sh_type == elfcpp::SHT_RELA); 1990 1991 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA, 1992 Relocatable_size_for_reloc> Scan_relocatable_relocs; 1993 1994 gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA, 1995 Scan_relocatable_relocs>( 1996 symtab, 1997 layout, 1998 object, 1999 data_shndx, 2000 prelocs, 2001 reloc_count, 2002 output_section, 2003 needs_special_offset_handling, 2004 local_symbol_count, 2005 plocal_symbols, 2006 rr); 2007 } 2008 2009 // Relocate a section during a relocatable link. 2010 2011 template<int size, bool big_endian> 2012 void 2013 Target_powerpc<size, big_endian>::relocate_for_relocatable( 2014 const Relocate_info<size, big_endian>* relinfo, 2015 unsigned int sh_type, 2016 const unsigned char* prelocs, 2017 size_t reloc_count, 2018 Output_section* output_section, 2019 off_t offset_in_output_section, 2020 const Relocatable_relocs* rr, 2021 unsigned char* view, 2022 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 2023 section_size_type view_size, 2024 unsigned char* reloc_view, 2025 section_size_type reloc_view_size) 2026 { 2027 gold_assert(sh_type == elfcpp::SHT_RELA); 2028 2029 gold::relocate_for_relocatable<size, big_endian, elfcpp::SHT_RELA>( 2030 relinfo, 2031 prelocs, 2032 reloc_count, 2033 output_section, 2034 offset_in_output_section, 2035 rr, 2036 view, 2037 view_address, 2038 view_size, 2039 reloc_view, 2040 reloc_view_size); 2041 } 2042 2043 // Return the value to use for a dynamic which requires special 2044 // treatment. This is how we support equality comparisons of function 2045 // pointers across shared library boundaries, as described in the 2046 // processor specific ABI supplement. 2047 2048 template<int size, bool big_endian> 2049 uint64_t 2050 Target_powerpc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const 2051 { 2052 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); 2053 return this->plt_section()->address() + gsym->plt_offset(); 2054 } 2055 2056 // The selector for powerpc object files. 2057 2058 template<int size, bool big_endian> 2059 class Target_selector_powerpc : public Target_selector 2060 { 2061 public: 2062 Target_selector_powerpc() 2063 : Target_selector(elfcpp::EM_NONE, size, big_endian, 2064 (size == 64 ? 2065 (big_endian ? "elf64-powerpc" : "elf64-powerpcle") : 2066 (big_endian ? "elf32-powerpc" : "elf32-powerpcle"))) 2067 { } 2068 2069 Target* do_recognize(int machine, int, int) 2070 { 2071 switch (size) 2072 { 2073 case 64: 2074 if (machine != elfcpp::EM_PPC64) 2075 return NULL; 2076 break; 2077 2078 case 32: 2079 if (machine != elfcpp::EM_PPC) 2080 return NULL; 2081 break; 2082 2083 default: 2084 return NULL; 2085 } 2086 2087 return this->instantiate_target(); 2088 } 2089 2090 Target* do_instantiate_target() 2091 { return new Target_powerpc<size, big_endian>(); } 2092 }; 2093 2094 Target_selector_powerpc<32, true> target_selector_ppc32; 2095 Target_selector_powerpc<32, false> target_selector_ppc32le; 2096 Target_selector_powerpc<64, true> target_selector_ppc64; 2097 Target_selector_powerpc<64, false> target_selector_ppc64le; 2098 2099 } // End anonymous namespace. 2100