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