1 // sparc.cc -- sparc target support for gold. 2 3 // Copyright (C) 2008-2016 Free Software Foundation, Inc. 4 // Written by David S. Miller <davem (at) davemloft.net>. 5 6 // This file is part of gold. 7 8 // This program is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3 of the License, or 11 // (at your option) any later version. 12 13 // This program is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // You should have received a copy of the GNU General Public License 19 // along with this program; if not, write to the Free Software 20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 // MA 02110-1301, USA. 22 23 #include "gold.h" 24 25 #include <cstdlib> 26 #include <cstdio> 27 #include <cstring> 28 29 #include "elfcpp.h" 30 #include "parameters.h" 31 #include "reloc.h" 32 #include "sparc.h" 33 #include "object.h" 34 #include "symtab.h" 35 #include "layout.h" 36 #include "output.h" 37 #include "copy-relocs.h" 38 #include "target.h" 39 #include "target-reloc.h" 40 #include "target-select.h" 41 #include "tls.h" 42 #include "errors.h" 43 #include "gc.h" 44 45 namespace 46 { 47 48 using namespace gold; 49 50 template<int size, bool big_endian> 51 class Output_data_plt_sparc; 52 53 template<int size, bool big_endian> 54 class Target_sparc : public Sized_target<size, big_endian> 55 { 56 public: 57 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section; 58 59 Target_sparc() 60 : Sized_target<size, big_endian>(&sparc_info), 61 got_(NULL), plt_(NULL), rela_dyn_(NULL), rela_ifunc_(NULL), 62 copy_relocs_(elfcpp::R_SPARC_COPY), 63 got_mod_index_offset_(-1U), tls_get_addr_sym_(NULL), 64 elf_machine_(sparc_info.machine_code), elf_flags_(0), 65 elf_flags_set_(false), register_syms_() 66 { 67 } 68 69 // Make a new symbol table entry. 70 Sized_symbol<size>* 71 make_symbol(const char*, elfcpp::STT, Object*, unsigned int, uint64_t); 72 73 // Process the relocations to determine unreferenced sections for 74 // garbage collection. 75 void 76 gc_process_relocs(Symbol_table* symtab, 77 Layout* layout, 78 Sized_relobj_file<size, big_endian>* object, 79 unsigned int data_shndx, 80 unsigned int sh_type, 81 const unsigned char* prelocs, 82 size_t reloc_count, 83 Output_section* output_section, 84 bool needs_special_offset_handling, 85 size_t local_symbol_count, 86 const unsigned char* plocal_symbols); 87 88 // Scan the relocations to look for symbol adjustments. 89 void 90 scan_relocs(Symbol_table* symtab, 91 Layout* layout, 92 Sized_relobj_file<size, big_endian>* object, 93 unsigned int data_shndx, 94 unsigned int sh_type, 95 const unsigned char* prelocs, 96 size_t reloc_count, 97 Output_section* output_section, 98 bool needs_special_offset_handling, 99 size_t local_symbol_count, 100 const unsigned char* plocal_symbols); 101 // Finalize the sections. 102 void 103 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*); 104 105 // Return the value to use for a dynamic which requires special 106 // treatment. 107 uint64_t 108 do_dynsym_value(const Symbol*) const; 109 110 // Relocate a section. 111 void 112 relocate_section(const Relocate_info<size, big_endian>*, 113 unsigned int sh_type, 114 const unsigned char* prelocs, 115 size_t reloc_count, 116 Output_section* output_section, 117 bool needs_special_offset_handling, 118 unsigned char* view, 119 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 120 section_size_type view_size, 121 const Reloc_symbol_changes*); 122 123 // Scan the relocs during a relocatable link. 124 void 125 scan_relocatable_relocs(Symbol_table* symtab, 126 Layout* layout, 127 Sized_relobj_file<size, big_endian>* object, 128 unsigned int data_shndx, 129 unsigned int sh_type, 130 const unsigned char* prelocs, 131 size_t reloc_count, 132 Output_section* output_section, 133 bool needs_special_offset_handling, 134 size_t local_symbol_count, 135 const unsigned char* plocal_symbols, 136 Relocatable_relocs*); 137 138 // Scan the relocs for --emit-relocs. 139 void 140 emit_relocs_scan(Symbol_table* symtab, 141 Layout* layout, 142 Sized_relobj_file<size, big_endian>* object, 143 unsigned int data_shndx, 144 unsigned int sh_type, 145 const unsigned char* prelocs, 146 size_t reloc_count, 147 Output_section* output_section, 148 bool needs_special_offset_handling, 149 size_t local_symbol_count, 150 const unsigned char* plocal_syms, 151 Relocatable_relocs* rr); 152 153 // Emit relocations for a section. 154 void 155 relocate_relocs(const Relocate_info<size, big_endian>*, 156 unsigned int sh_type, 157 const unsigned char* prelocs, 158 size_t reloc_count, 159 Output_section* output_section, 160 typename elfcpp::Elf_types<size>::Elf_Off 161 offset_in_output_section, 162 unsigned char* view, 163 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 164 section_size_type view_size, 165 unsigned char* reloc_view, 166 section_size_type reloc_view_size); 167 168 // Return whether SYM is defined by the ABI. 169 bool 170 do_is_defined_by_abi(const Symbol* sym) const 171 { return strcmp(sym->name(), "___tls_get_addr") == 0; } 172 173 // Return the PLT address to use for a global symbol. 174 uint64_t 175 do_plt_address_for_global(const Symbol* gsym) const 176 { return this->plt_section()->address_for_global(gsym); } 177 178 uint64_t 179 do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const 180 { return this->plt_section()->address_for_local(relobj, symndx); } 181 182 // Return whether there is a GOT section. 183 bool 184 has_got_section() const 185 { return this->got_ != NULL; } 186 187 // Return the size of the GOT section. 188 section_size_type 189 got_size() const 190 { 191 gold_assert(this->got_ != NULL); 192 return this->got_->data_size(); 193 } 194 195 // Return the number of entries in the GOT. 196 unsigned int 197 got_entry_count() const 198 { 199 if (this->got_ == NULL) 200 return 0; 201 return this->got_size() / (size / 8); 202 } 203 204 // Return the address of the GOT. 205 uint64_t 206 got_address() const 207 { 208 if (this->got_ == NULL) 209 return 0; 210 return this->got_->address(); 211 } 212 213 // Return the number of entries in the PLT. 214 unsigned int 215 plt_entry_count() const; 216 217 // Return the offset of the first non-reserved PLT entry. 218 unsigned int 219 first_plt_entry_offset() const; 220 221 // Return the size of each PLT entry. 222 unsigned int 223 plt_entry_size() const; 224 225 protected: 226 // Make an ELF object. 227 Object* 228 do_make_elf_object(const std::string&, Input_file*, off_t, 229 const elfcpp::Ehdr<size, big_endian>& ehdr); 230 231 void 232 do_adjust_elf_header(unsigned char* view, int len); 233 234 private: 235 236 // The class which scans relocations. 237 class Scan 238 { 239 public: 240 Scan() 241 : issued_non_pic_error_(false) 242 { } 243 244 static inline int 245 get_reference_flags(unsigned int r_type); 246 247 inline void 248 local(Symbol_table* symtab, Layout* layout, Target_sparc* target, 249 Sized_relobj_file<size, big_endian>* object, 250 unsigned int data_shndx, 251 Output_section* output_section, 252 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type, 253 const elfcpp::Sym<size, big_endian>& lsym, 254 bool is_discarded); 255 256 inline void 257 global(Symbol_table* symtab, Layout* layout, Target_sparc* target, 258 Sized_relobj_file<size, big_endian>* object, 259 unsigned int data_shndx, 260 Output_section* output_section, 261 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type, 262 Symbol* gsym); 263 264 inline bool 265 local_reloc_may_be_function_pointer(Symbol_table* , Layout* , 266 Target_sparc* , 267 Sized_relobj_file<size, big_endian>* , 268 unsigned int , 269 Output_section* , 270 const elfcpp::Rela<size, big_endian>& , 271 unsigned int , 272 const elfcpp::Sym<size, big_endian>&) 273 { return false; } 274 275 inline bool 276 global_reloc_may_be_function_pointer(Symbol_table* , Layout* , 277 Target_sparc* , 278 Sized_relobj_file<size, big_endian>* , 279 unsigned int , 280 Output_section* , 281 const elfcpp::Rela<size, 282 big_endian>& , 283 unsigned int , Symbol*) 284 { return false; } 285 286 287 private: 288 static void 289 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*, 290 unsigned int r_type); 291 292 static void 293 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*, 294 unsigned int r_type, Symbol*); 295 296 static void 297 generate_tls_call(Symbol_table* symtab, Layout* layout, 298 Target_sparc* target); 299 300 void 301 check_non_pic(Relobj*, unsigned int r_type); 302 303 bool 304 reloc_needs_plt_for_ifunc(Sized_relobj_file<size, big_endian>*, 305 unsigned int r_type); 306 307 // Whether we have issued an error about a non-PIC compilation. 308 bool issued_non_pic_error_; 309 }; 310 311 // The class which implements relocation. 312 class Relocate 313 { 314 public: 315 Relocate() 316 : ignore_gd_add_(false), reloc_adjust_addr_(NULL) 317 { } 318 319 ~Relocate() 320 { 321 if (this->ignore_gd_add_) 322 { 323 // FIXME: This needs to specify the location somehow. 324 gold_error(_("missing expected TLS relocation")); 325 } 326 } 327 328 // Do a relocation. Return false if the caller should not issue 329 // any warnings about this relocation. 330 inline bool 331 relocate(const Relocate_info<size, big_endian>*, unsigned int, 332 Target_sparc*, Output_section*, size_t, const unsigned char*, 333 const Sized_symbol<size>*, const Symbol_value<size>*, 334 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr, 335 section_size_type); 336 337 private: 338 // Do a TLS relocation. 339 inline void 340 relocate_tls(const Relocate_info<size, big_endian>*, Target_sparc* target, 341 size_t relnum, const elfcpp::Rela<size, big_endian>&, 342 unsigned int r_type, const Sized_symbol<size>*, 343 const Symbol_value<size>*, 344 unsigned char*, 345 typename elfcpp::Elf_types<size>::Elf_Addr, 346 section_size_type); 347 348 inline void 349 relax_call(Target_sparc<size, big_endian>* target, 350 unsigned char* view, 351 const elfcpp::Rela<size, big_endian>& rela, 352 section_size_type view_size); 353 354 // Ignore the next relocation which should be R_SPARC_TLS_GD_ADD 355 bool ignore_gd_add_; 356 357 // If we hit a reloc at this view address, adjust it back by 4 bytes. 358 unsigned char *reloc_adjust_addr_; 359 }; 360 361 // Get the GOT section, creating it if necessary. 362 Output_data_got<size, big_endian>* 363 got_section(Symbol_table*, Layout*); 364 365 // Create the PLT section. 366 void 367 make_plt_section(Symbol_table* symtab, Layout* layout); 368 369 // Create a PLT entry for a global symbol. 370 void 371 make_plt_entry(Symbol_table*, Layout*, Symbol*); 372 373 // Create a PLT entry for a local STT_GNU_IFUNC symbol. 374 void 375 make_local_ifunc_plt_entry(Symbol_table*, Layout*, 376 Sized_relobj_file<size, big_endian>* relobj, 377 unsigned int local_sym_index); 378 379 // Create a GOT entry for the TLS module index. 380 unsigned int 381 got_mod_index_entry(Symbol_table* symtab, Layout* layout, 382 Sized_relobj_file<size, big_endian>* object); 383 384 // Return the gsym for "__tls_get_addr". Cache if not already 385 // cached. 386 Symbol* 387 tls_get_addr_sym(Symbol_table* symtab) 388 { 389 if (!this->tls_get_addr_sym_) 390 this->tls_get_addr_sym_ = symtab->lookup("__tls_get_addr", NULL); 391 gold_assert(this->tls_get_addr_sym_); 392 return this->tls_get_addr_sym_; 393 } 394 395 // Get the PLT section. 396 Output_data_plt_sparc<size, big_endian>* 397 plt_section() const 398 { 399 gold_assert(this->plt_ != NULL); 400 return this->plt_; 401 } 402 403 // Get the dynamic reloc section, creating it if necessary. 404 Reloc_section* 405 rela_dyn_section(Layout*); 406 407 // Get the section to use for IFUNC relocations. 408 Reloc_section* 409 rela_ifunc_section(Layout*); 410 411 // Copy a relocation against a global symbol. 412 void 413 copy_reloc(Symbol_table* symtab, Layout* layout, 414 Sized_relobj_file<size, big_endian>* object, 415 unsigned int shndx, Output_section* output_section, 416 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc) 417 { 418 unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info()); 419 this->copy_relocs_.copy_reloc(symtab, layout, 420 symtab->get_sized_symbol<size>(sym), 421 object, shndx, output_section, 422 r_type, reloc.get_r_offset(), 423 reloc.get_r_addend(), 424 this->rela_dyn_section(layout)); 425 } 426 427 // Information about this specific target which we pass to the 428 // general Target structure. 429 static Target::Target_info sparc_info; 430 431 // The types of GOT entries needed for this platform. 432 // These values are exposed to the ABI in an incremental link. 433 // Do not renumber existing values without changing the version 434 // number of the .gnu_incremental_inputs section. 435 enum Got_type 436 { 437 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol 438 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset 439 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair 440 }; 441 442 struct Register_symbol 443 { 444 Register_symbol() 445 : name(NULL), shndx(0), obj(NULL) 446 { } 447 const char* name; 448 unsigned int shndx; 449 Object* obj; 450 }; 451 452 // The GOT section. 453 Output_data_got<size, big_endian>* got_; 454 // The PLT section. 455 Output_data_plt_sparc<size, big_endian>* plt_; 456 // The dynamic reloc section. 457 Reloc_section* rela_dyn_; 458 // The section to use for IFUNC relocs. 459 Reloc_section* rela_ifunc_; 460 // Relocs saved to avoid a COPY reloc. 461 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_; 462 // Offset of the GOT entry for the TLS module index; 463 unsigned int got_mod_index_offset_; 464 // Cached pointer to __tls_get_addr symbol 465 Symbol* tls_get_addr_sym_; 466 // Accumulated elf machine type 467 elfcpp::Elf_Half elf_machine_; 468 // Accumulated elf header flags 469 elfcpp::Elf_Word elf_flags_; 470 // Whether elf_flags_ has been set for the first time yet 471 bool elf_flags_set_; 472 // STT_SPARC_REGISTER symbols (%g2, %g3, %g6, %g7). 473 Register_symbol register_syms_[4]; 474 }; 475 476 template<> 477 Target::Target_info Target_sparc<32, true>::sparc_info = 478 { 479 32, // size 480 true, // is_big_endian 481 elfcpp::EM_SPARC, // machine_code 482 false, // has_make_symbol 483 false, // has_resolve 484 false, // has_code_fill 485 true, // is_default_stack_executable 486 false, // can_icf_inline_merge_sections 487 '\0', // wrap_char 488 "/usr/lib/ld.so.1", // dynamic_linker 489 0x00010000, // default_text_segment_address 490 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 491 8 * 1024, // common_pagesize (overridable by -z common-page-size) 492 false, // isolate_execinstr 493 0, // rosegment_gap 494 elfcpp::SHN_UNDEF, // small_common_shndx 495 elfcpp::SHN_UNDEF, // large_common_shndx 496 0, // small_common_section_flags 497 0, // large_common_section_flags 498 NULL, // attributes_section 499 NULL, // attributes_vendor 500 "_start", // entry_symbol_name 501 32, // hash_entry_size 502 }; 503 504 template<> 505 Target::Target_info Target_sparc<64, true>::sparc_info = 506 { 507 64, // size 508 true, // is_big_endian 509 elfcpp::EM_SPARCV9, // machine_code 510 true, // has_make_symbol 511 false, // has_resolve 512 false, // has_code_fill 513 true, // is_default_stack_executable 514 false, // can_icf_inline_merge_sections 515 '\0', // wrap_char 516 "/usr/lib/sparcv9/ld.so.1", // dynamic_linker 517 0x100000, // default_text_segment_address 518 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 519 8 * 1024, // common_pagesize (overridable by -z common-page-size) 520 false, // isolate_execinstr 521 0, // rosegment_gap 522 elfcpp::SHN_UNDEF, // small_common_shndx 523 elfcpp::SHN_UNDEF, // large_common_shndx 524 0, // small_common_section_flags 525 0, // large_common_section_flags 526 NULL, // attributes_section 527 NULL, // attributes_vendor 528 "_start", // entry_symbol_name 529 32, // hash_entry_size 530 }; 531 532 // We have to take care here, even when operating in little-endian 533 // mode, sparc instructions are still big endian. 534 template<int size, bool big_endian> 535 class Sparc_relocate_functions 536 { 537 private: 538 // Do a simple relocation with the addend in the relocation. 539 template<int valsize> 540 static inline void 541 rela(unsigned char* view, 542 unsigned int right_shift, 543 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask, 544 typename elfcpp::Swap<size, big_endian>::Valtype value, 545 typename elfcpp::Swap<size, big_endian>::Valtype addend) 546 { 547 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; 548 Valtype* wv = reinterpret_cast<Valtype*>(view); 549 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); 550 Valtype reloc = ((value + addend) >> right_shift); 551 552 val &= ~dst_mask; 553 reloc &= dst_mask; 554 555 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc); 556 } 557 558 // Do a simple relocation using a symbol value with the addend in 559 // the relocation. 560 template<int valsize> 561 static inline void 562 rela(unsigned char* view, 563 unsigned int right_shift, 564 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask, 565 const Sized_relobj_file<size, big_endian>* object, 566 const Symbol_value<size>* psymval, 567 typename elfcpp::Swap<valsize, big_endian>::Valtype addend) 568 { 569 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; 570 Valtype* wv = reinterpret_cast<Valtype*>(view); 571 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); 572 Valtype reloc = (psymval->value(object, addend) >> right_shift); 573 574 val &= ~dst_mask; 575 reloc &= dst_mask; 576 577 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc); 578 } 579 580 // Do a simple relocation using a symbol value with the addend in 581 // the relocation, unaligned. 582 template<int valsize> 583 static inline void 584 rela_ua(unsigned char* view, 585 unsigned int right_shift, elfcpp::Elf_Xword dst_mask, 586 const Sized_relobj_file<size, big_endian>* object, 587 const Symbol_value<size>* psymval, 588 typename elfcpp::Swap<size, big_endian>::Valtype addend) 589 { 590 typedef typename elfcpp::Swap_unaligned<valsize, 591 big_endian>::Valtype Valtype; 592 unsigned char* wv = view; 593 Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv); 594 Valtype reloc = (psymval->value(object, addend) >> right_shift); 595 596 val &= ~dst_mask; 597 reloc &= dst_mask; 598 599 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc); 600 } 601 602 // Do a simple PC relative relocation with a Symbol_value with the 603 // addend in the relocation. 604 template<int valsize> 605 static inline void 606 pcrela(unsigned char* view, 607 unsigned int right_shift, 608 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask, 609 const Sized_relobj_file<size, big_endian>* object, 610 const Symbol_value<size>* psymval, 611 typename elfcpp::Swap<size, big_endian>::Valtype addend, 612 typename elfcpp::Elf_types<size>::Elf_Addr address) 613 { 614 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; 615 Valtype* wv = reinterpret_cast<Valtype*>(view); 616 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); 617 Valtype reloc = ((psymval->value(object, addend) - address) 618 >> right_shift); 619 620 val &= ~dst_mask; 621 reloc &= dst_mask; 622 623 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc); 624 } 625 626 template<int valsize> 627 static inline void 628 pcrela_unaligned(unsigned char* view, 629 const Sized_relobj_file<size, big_endian>* object, 630 const Symbol_value<size>* psymval, 631 typename elfcpp::Swap<size, big_endian>::Valtype addend, 632 typename elfcpp::Elf_types<size>::Elf_Addr address) 633 { 634 typedef typename elfcpp::Swap_unaligned<valsize, 635 big_endian>::Valtype Valtype; 636 unsigned char* wv = view; 637 Valtype reloc = (psymval->value(object, addend) - address); 638 639 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc); 640 } 641 642 typedef Sparc_relocate_functions<size, big_endian> This; 643 typedef Sparc_relocate_functions<size, true> This_insn; 644 645 public: 646 // R_SPARC_WDISP30: (Symbol + Addend - Address) >> 2 647 static inline void 648 wdisp30(unsigned char* view, 649 const Sized_relobj_file<size, big_endian>* object, 650 const Symbol_value<size>* psymval, 651 typename elfcpp::Elf_types<size>::Elf_Addr addend, 652 typename elfcpp::Elf_types<size>::Elf_Addr address) 653 { 654 This_insn::template pcrela<32>(view, 2, 0x3fffffff, object, 655 psymval, addend, address); 656 } 657 658 // R_SPARC_WDISP22: (Symbol + Addend - Address) >> 2 659 static inline void 660 wdisp22(unsigned char* view, 661 const Sized_relobj_file<size, big_endian>* object, 662 const Symbol_value<size>* psymval, 663 typename elfcpp::Elf_types<size>::Elf_Addr addend, 664 typename elfcpp::Elf_types<size>::Elf_Addr address) 665 { 666 This_insn::template pcrela<32>(view, 2, 0x003fffff, object, 667 psymval, addend, address); 668 } 669 670 // R_SPARC_WDISP19: (Symbol + Addend - Address) >> 2 671 static inline void 672 wdisp19(unsigned char* view, 673 const Sized_relobj_file<size, big_endian>* object, 674 const Symbol_value<size>* psymval, 675 typename elfcpp::Elf_types<size>::Elf_Addr addend, 676 typename elfcpp::Elf_types<size>::Elf_Addr address) 677 { 678 This_insn::template pcrela<32>(view, 2, 0x0007ffff, object, 679 psymval, addend, address); 680 } 681 682 // R_SPARC_WDISP16: (Symbol + Addend - Address) >> 2 683 static inline void 684 wdisp16(unsigned char* view, 685 const Sized_relobj_file<size, big_endian>* object, 686 const Symbol_value<size>* psymval, 687 typename elfcpp::Elf_types<size>::Elf_Addr addend, 688 typename elfcpp::Elf_types<size>::Elf_Addr address) 689 { 690 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 691 Valtype* wv = reinterpret_cast<Valtype*>(view); 692 Valtype val = elfcpp::Swap<32, true>::readval(wv); 693 Valtype reloc = ((psymval->value(object, addend) - address) 694 >> 2); 695 696 // The relocation value is split between the low 14 bits, 697 // and bits 20-21. 698 val &= ~((0x3 << 20) | 0x3fff); 699 reloc = (((reloc & 0xc000) << (20 - 14)) 700 | (reloc & 0x3ffff)); 701 702 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 703 } 704 705 // R_SPARC_WDISP10: (Symbol + Addend - Address) >> 2 706 static inline void 707 wdisp10(unsigned char* view, 708 const Sized_relobj_file<size, big_endian>* object, 709 const Symbol_value<size>* psymval, 710 typename elfcpp::Elf_types<size>::Elf_Addr addend, 711 typename elfcpp::Elf_types<size>::Elf_Addr address) 712 { 713 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 714 Valtype* wv = reinterpret_cast<Valtype*>(view); 715 Valtype val = elfcpp::Swap<32, true>::readval(wv); 716 Valtype reloc = ((psymval->value(object, addend) - address) 717 >> 2); 718 719 // The relocation value is split between the low bits 5-12, 720 // and high bits 19-20. 721 val &= ~((0x3 << 19) | (0xff << 5)); 722 reloc = (((reloc & 0x300) << (19 - 8)) 723 | ((reloc & 0xff) << (5 - 0))); 724 725 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 726 } 727 728 // R_SPARC_PC22: (Symbol + Addend - Address) >> 10 729 static inline void 730 pc22(unsigned char* view, 731 const Sized_relobj_file<size, big_endian>* object, 732 const Symbol_value<size>* psymval, 733 typename elfcpp::Elf_types<size>::Elf_Addr addend, 734 typename elfcpp::Elf_types<size>::Elf_Addr address) 735 { 736 This_insn::template pcrela<32>(view, 10, 0x003fffff, object, 737 psymval, addend, address); 738 } 739 740 // R_SPARC_PC10: (Symbol + Addend - Address) & 0x3ff 741 static inline void 742 pc10(unsigned char* view, 743 const Sized_relobj_file<size, big_endian>* object, 744 const Symbol_value<size>* psymval, 745 typename elfcpp::Elf_types<size>::Elf_Addr addend, 746 typename elfcpp::Elf_types<size>::Elf_Addr address) 747 { 748 This_insn::template pcrela<32>(view, 0, 0x000003ff, object, 749 psymval, addend, address); 750 } 751 752 // R_SPARC_HI22: (Symbol + Addend) >> 10 753 static inline void 754 hi22(unsigned char* view, 755 typename elfcpp::Elf_types<size>::Elf_Addr value, 756 typename elfcpp::Elf_types<size>::Elf_Addr addend) 757 { 758 This_insn::template rela<32>(view, 10, 0x003fffff, value, addend); 759 } 760 761 // R_SPARC_HI22: (Symbol + Addend) >> 10 762 static inline void 763 hi22(unsigned char* view, 764 const Sized_relobj_file<size, big_endian>* object, 765 const Symbol_value<size>* psymval, 766 typename elfcpp::Elf_types<size>::Elf_Addr addend) 767 { 768 This_insn::template rela<32>(view, 10, 0x003fffff, object, psymval, addend); 769 } 770 771 // R_SPARC_PCPLT22: (Symbol + Addend - Address) >> 10 772 static inline void 773 pcplt22(unsigned char* view, 774 const Sized_relobj_file<size, big_endian>* object, 775 const Symbol_value<size>* psymval, 776 typename elfcpp::Elf_types<size>::Elf_Addr addend, 777 typename elfcpp::Elf_types<size>::Elf_Addr address) 778 { 779 This_insn::template pcrela<32>(view, 10, 0x003fffff, object, 780 psymval, addend, address); 781 } 782 783 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff 784 static inline void 785 lo10(unsigned char* view, 786 typename elfcpp::Elf_types<size>::Elf_Addr value, 787 typename elfcpp::Elf_types<size>::Elf_Addr addend) 788 { 789 This_insn::template rela<32>(view, 0, 0x000003ff, value, addend); 790 } 791 792 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff 793 static inline void 794 lo10(unsigned char* view, 795 const Sized_relobj_file<size, big_endian>* object, 796 const Symbol_value<size>* psymval, 797 typename elfcpp::Elf_types<size>::Elf_Addr addend) 798 { 799 This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend); 800 } 801 802 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff 803 static inline void 804 lo10(unsigned char* view, 805 const Sized_relobj_file<size, big_endian>* object, 806 const Symbol_value<size>* psymval, 807 typename elfcpp::Elf_types<size>::Elf_Addr addend, 808 typename elfcpp::Elf_types<size>::Elf_Addr address) 809 { 810 This_insn::template pcrela<32>(view, 0, 0x000003ff, object, 811 psymval, addend, address); 812 } 813 814 // R_SPARC_OLO10: ((Symbol + Addend) & 0x3ff) + Addend2 815 static inline void 816 olo10(unsigned char* view, 817 const Sized_relobj_file<size, big_endian>* object, 818 const Symbol_value<size>* psymval, 819 typename elfcpp::Elf_types<size>::Elf_Addr addend, 820 typename elfcpp::Elf_types<size>::Elf_Addr addend2) 821 { 822 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 823 Valtype* wv = reinterpret_cast<Valtype*>(view); 824 Valtype val = elfcpp::Swap<32, true>::readval(wv); 825 Valtype reloc = psymval->value(object, addend); 826 827 val &= ~0x1fff; 828 reloc &= 0x3ff; 829 reloc += addend2; 830 reloc &= 0x1fff; 831 832 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 833 } 834 835 // R_SPARC_22: (Symbol + Addend) 836 static inline void 837 rela32_22(unsigned char* view, 838 const Sized_relobj_file<size, big_endian>* object, 839 const Symbol_value<size>* psymval, 840 typename elfcpp::Elf_types<size>::Elf_Addr addend) 841 { 842 This_insn::template rela<32>(view, 0, 0x003fffff, object, psymval, addend); 843 } 844 845 // R_SPARC_13: (Symbol + Addend) 846 static inline void 847 rela32_13(unsigned char* view, 848 typename elfcpp::Elf_types<size>::Elf_Addr value, 849 typename elfcpp::Elf_types<size>::Elf_Addr addend) 850 { 851 This_insn::template rela<32>(view, 0, 0x00001fff, value, addend); 852 } 853 854 // R_SPARC_13: (Symbol + Addend) 855 static inline void 856 rela32_13(unsigned char* view, 857 const Sized_relobj_file<size, big_endian>* object, 858 const Symbol_value<size>* psymval, 859 typename elfcpp::Elf_types<size>::Elf_Addr addend) 860 { 861 This_insn::template rela<32>(view, 0, 0x00001fff, object, psymval, addend); 862 } 863 864 // R_SPARC_UA16: (Symbol + Addend) 865 static inline void 866 ua16(unsigned char* view, 867 const Sized_relobj_file<size, big_endian>* object, 868 const Symbol_value<size>* psymval, 869 typename elfcpp::Elf_types<size>::Elf_Addr addend) 870 { 871 This::template rela_ua<16>(view, 0, 0xffff, object, psymval, addend); 872 } 873 874 // R_SPARC_UA32: (Symbol + Addend) 875 static inline void 876 ua32(unsigned char* view, 877 const Sized_relobj_file<size, big_endian>* object, 878 const Symbol_value<size>* psymval, 879 typename elfcpp::Elf_types<size>::Elf_Addr addend) 880 { 881 This::template rela_ua<32>(view, 0, 0xffffffff, object, psymval, addend); 882 } 883 884 // R_SPARC_UA64: (Symbol + Addend) 885 static inline void 886 ua64(unsigned char* view, 887 const Sized_relobj_file<size, big_endian>* object, 888 const Symbol_value<size>* psymval, 889 typename elfcpp::Elf_types<size>::Elf_Addr addend) 890 { 891 This::template rela_ua<64>(view, 0, ~(elfcpp::Elf_Xword) 0, 892 object, psymval, addend); 893 } 894 895 // R_SPARC_DISP8: (Symbol + Addend - Address) 896 static inline void 897 disp8(unsigned char* view, 898 const Sized_relobj_file<size, big_endian>* object, 899 const Symbol_value<size>* psymval, 900 typename elfcpp::Elf_types<size>::Elf_Addr addend, 901 typename elfcpp::Elf_types<size>::Elf_Addr address) 902 { 903 This::template pcrela_unaligned<8>(view, object, psymval, 904 addend, address); 905 } 906 907 // R_SPARC_DISP16: (Symbol + Addend - Address) 908 static inline void 909 disp16(unsigned char* view, 910 const Sized_relobj_file<size, big_endian>* object, 911 const Symbol_value<size>* psymval, 912 typename elfcpp::Elf_types<size>::Elf_Addr addend, 913 typename elfcpp::Elf_types<size>::Elf_Addr address) 914 { 915 This::template pcrela_unaligned<16>(view, object, psymval, 916 addend, address); 917 } 918 919 // R_SPARC_DISP32: (Symbol + Addend - Address) 920 static inline void 921 disp32(unsigned char* view, 922 const Sized_relobj_file<size, big_endian>* object, 923 const Symbol_value<size>* psymval, 924 typename elfcpp::Elf_types<size>::Elf_Addr addend, 925 typename elfcpp::Elf_types<size>::Elf_Addr address) 926 { 927 This::template pcrela_unaligned<32>(view, object, psymval, 928 addend, address); 929 } 930 931 // R_SPARC_DISP64: (Symbol + Addend - Address) 932 static inline void 933 disp64(unsigned char* view, 934 const Sized_relobj_file<size, big_endian>* object, 935 const Symbol_value<size>* psymval, 936 elfcpp::Elf_Xword addend, 937 typename elfcpp::Elf_types<size>::Elf_Addr address) 938 { 939 This::template pcrela_unaligned<64>(view, object, psymval, 940 addend, address); 941 } 942 943 // R_SPARC_H34: (Symbol + Addend) >> 12 944 static inline void 945 h34(unsigned char* view, 946 const Sized_relobj_file<size, big_endian>* object, 947 const Symbol_value<size>* psymval, 948 typename elfcpp::Elf_types<size>::Elf_Addr addend) 949 { 950 This_insn::template rela<32>(view, 12, 0x003fffff, object, psymval, addend); 951 } 952 953 // R_SPARC_H44: (Symbol + Addend) >> 22 954 static inline void 955 h44(unsigned char* view, 956 const Sized_relobj_file<size, big_endian>* object, 957 const Symbol_value<size>* psymval, 958 typename elfcpp::Elf_types<size>::Elf_Addr addend) 959 { 960 This_insn::template rela<32>(view, 22, 0x003fffff, object, psymval, addend); 961 } 962 963 // R_SPARC_M44: ((Symbol + Addend) >> 12) & 0x3ff 964 static inline void 965 m44(unsigned char* view, 966 const Sized_relobj_file<size, big_endian>* object, 967 const Symbol_value<size>* psymval, 968 typename elfcpp::Elf_types<size>::Elf_Addr addend) 969 { 970 This_insn::template rela<32>(view, 12, 0x000003ff, object, psymval, addend); 971 } 972 973 // R_SPARC_L44: (Symbol + Addend) & 0xfff 974 static inline void 975 l44(unsigned char* view, 976 const Sized_relobj_file<size, big_endian>* object, 977 const Symbol_value<size>* psymval, 978 typename elfcpp::Elf_types<size>::Elf_Addr addend) 979 { 980 This_insn::template rela<32>(view, 0, 0x00000fff, object, psymval, addend); 981 } 982 983 // R_SPARC_HH22: (Symbol + Addend) >> 42 984 static inline void 985 hh22(unsigned char* view, 986 const Sized_relobj_file<size, big_endian>* object, 987 const Symbol_value<size>* psymval, 988 typename elfcpp::Elf_types<size>::Elf_Addr addend) 989 { 990 This_insn::template rela<32>(view, 42, 0x003fffff, object, psymval, addend); 991 } 992 993 // R_SPARC_PC_HH22: (Symbol + Addend - Address) >> 42 994 static inline void 995 pc_hh22(unsigned char* view, 996 const Sized_relobj_file<size, big_endian>* object, 997 const Symbol_value<size>* psymval, 998 typename elfcpp::Elf_types<size>::Elf_Addr addend, 999 typename elfcpp::Elf_types<size>::Elf_Addr address) 1000 { 1001 This_insn::template pcrela<32>(view, 42, 0x003fffff, object, 1002 psymval, addend, address); 1003 } 1004 1005 // R_SPARC_HM10: ((Symbol + Addend) >> 32) & 0x3ff 1006 static inline void 1007 hm10(unsigned char* view, 1008 const Sized_relobj_file<size, big_endian>* object, 1009 const Symbol_value<size>* psymval, 1010 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1011 { 1012 This_insn::template rela<32>(view, 32, 0x000003ff, object, psymval, addend); 1013 } 1014 1015 // R_SPARC_PC_HM10: ((Symbol + Addend - Address) >> 32) & 0x3ff 1016 static inline void 1017 pc_hm10(unsigned char* view, 1018 const Sized_relobj_file<size, big_endian>* object, 1019 const Symbol_value<size>* psymval, 1020 typename elfcpp::Elf_types<size>::Elf_Addr addend, 1021 typename elfcpp::Elf_types<size>::Elf_Addr address) 1022 { 1023 This_insn::template pcrela<32>(view, 32, 0x000003ff, object, 1024 psymval, addend, address); 1025 } 1026 1027 // R_SPARC_11: (Symbol + Addend) 1028 static inline void 1029 rela32_11(unsigned char* view, 1030 const Sized_relobj_file<size, big_endian>* object, 1031 const Symbol_value<size>* psymval, 1032 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1033 { 1034 This_insn::template rela<32>(view, 0, 0x000007ff, object, psymval, addend); 1035 } 1036 1037 // R_SPARC_10: (Symbol + Addend) 1038 static inline void 1039 rela32_10(unsigned char* view, 1040 const Sized_relobj_file<size, big_endian>* object, 1041 const Symbol_value<size>* psymval, 1042 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1043 { 1044 This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend); 1045 } 1046 1047 // R_SPARC_7: (Symbol + Addend) 1048 static inline void 1049 rela32_7(unsigned char* view, 1050 const Sized_relobj_file<size, big_endian>* object, 1051 const Symbol_value<size>* psymval, 1052 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1053 { 1054 This_insn::template rela<32>(view, 0, 0x0000007f, object, psymval, addend); 1055 } 1056 1057 // R_SPARC_6: (Symbol + Addend) 1058 static inline void 1059 rela32_6(unsigned char* view, 1060 const Sized_relobj_file<size, big_endian>* object, 1061 const Symbol_value<size>* psymval, 1062 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1063 { 1064 This_insn::template rela<32>(view, 0, 0x0000003f, object, psymval, addend); 1065 } 1066 1067 // R_SPARC_5: (Symbol + Addend) 1068 static inline void 1069 rela32_5(unsigned char* view, 1070 const Sized_relobj_file<size, big_endian>* object, 1071 const Symbol_value<size>* psymval, 1072 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1073 { 1074 This_insn::template rela<32>(view, 0, 0x0000001f, object, psymval, addend); 1075 } 1076 1077 // R_SPARC_TLS_LDO_HIX22: @dtpoff(Symbol + Addend) >> 10 1078 static inline void 1079 ldo_hix22(unsigned char* view, 1080 typename elfcpp::Elf_types<size>::Elf_Addr value, 1081 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1082 { 1083 This_insn::hi22(view, value, addend); 1084 } 1085 1086 // R_SPARC_TLS_LDO_LOX10: @dtpoff(Symbol + Addend) & 0x3ff 1087 static inline void 1088 ldo_lox10(unsigned char* view, 1089 typename elfcpp::Elf_types<size>::Elf_Addr value, 1090 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1091 { 1092 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1093 Valtype* wv = reinterpret_cast<Valtype*>(view); 1094 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1095 Valtype reloc = (value + addend); 1096 1097 val &= ~0x1fff; 1098 reloc &= 0x3ff; 1099 1100 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1101 } 1102 1103 // R_SPARC_TLS_LE_HIX22: (@tpoff(Symbol + Addend) ^ 0xffffffffffffffff) >> 10 1104 static inline void 1105 hix22(unsigned char* view, 1106 typename elfcpp::Elf_types<size>::Elf_Addr value, 1107 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1108 { 1109 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1110 Valtype* wv = reinterpret_cast<Valtype*>(view); 1111 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1112 Valtype reloc = (value + addend); 1113 1114 val &= ~0x3fffff; 1115 1116 reloc ^= ~(Valtype)0; 1117 reloc >>= 10; 1118 1119 reloc &= 0x3fffff; 1120 1121 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1122 } 1123 1124 // R_SPARC_GOTDATA_OP_HIX22: @gdopoff(Symbol + Addend) >> 10 1125 static inline void 1126 gdop_hix22(unsigned char* view, 1127 typename elfcpp::Elf_types<size>::Elf_Addr value) 1128 { 1129 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1130 Valtype* wv = reinterpret_cast<Valtype*>(view); 1131 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1132 int32_t reloc = static_cast<int32_t>(value); 1133 1134 val &= ~0x3fffff; 1135 1136 if (reloc < 0) 1137 reloc ^= ~static_cast<int32_t>(0); 1138 reloc >>= 10; 1139 1140 reloc &= 0x3fffff; 1141 1142 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1143 } 1144 1145 // R_SPARC_HIX22: ((Symbol + Addend) ^ 0xffffffffffffffff) >> 10 1146 static inline void 1147 hix22(unsigned char* view, 1148 const Sized_relobj_file<size, big_endian>* object, 1149 const Symbol_value<size>* psymval, 1150 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1151 { 1152 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1153 Valtype* wv = reinterpret_cast<Valtype*>(view); 1154 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1155 Valtype reloc = psymval->value(object, addend); 1156 1157 val &= ~0x3fffff; 1158 1159 reloc ^= ~(Valtype)0; 1160 reloc >>= 10; 1161 1162 reloc &= 0x3fffff; 1163 1164 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1165 } 1166 1167 1168 // R_SPARC_TLS_LE_LOX10: (@tpoff(Symbol + Addend) & 0x3ff) | 0x1c00 1169 static inline void 1170 lox10(unsigned char* view, 1171 typename elfcpp::Elf_types<size>::Elf_Addr value, 1172 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1173 { 1174 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1175 Valtype* wv = reinterpret_cast<Valtype*>(view); 1176 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1177 Valtype reloc = (value + addend); 1178 1179 val &= ~0x1fff; 1180 reloc &= 0x3ff; 1181 reloc |= 0x1c00; 1182 1183 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1184 } 1185 1186 // R_SPARC_GOTDATA_OP_LOX10: (@gdopoff(Symbol + Addend) & 0x3ff) | 0x1c00 1187 static inline void 1188 gdop_lox10(unsigned char* view, 1189 typename elfcpp::Elf_types<size>::Elf_Addr value) 1190 { 1191 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1192 Valtype* wv = reinterpret_cast<Valtype*>(view); 1193 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1194 int32_t reloc = static_cast<int32_t>(value); 1195 1196 if (reloc < 0) 1197 reloc = (reloc & 0x3ff) | 0x1c00; 1198 else 1199 reloc = (reloc & 0x3ff); 1200 1201 val &= ~0x1fff; 1202 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1203 } 1204 1205 // R_SPARC_LOX10: ((Symbol + Addend) & 0x3ff) | 0x1c00 1206 static inline void 1207 lox10(unsigned char* view, 1208 const Sized_relobj_file<size, big_endian>* object, 1209 const Symbol_value<size>* psymval, 1210 typename elfcpp::Elf_types<size>::Elf_Addr addend) 1211 { 1212 typedef typename elfcpp::Swap<32, true>::Valtype Valtype; 1213 Valtype* wv = reinterpret_cast<Valtype*>(view); 1214 Valtype val = elfcpp::Swap<32, true>::readval(wv); 1215 Valtype reloc = psymval->value(object, addend); 1216 1217 val &= ~0x1fff; 1218 reloc &= 0x3ff; 1219 reloc |= 0x1c00; 1220 1221 elfcpp::Swap<32, true>::writeval(wv, val | reloc); 1222 } 1223 }; 1224 1225 // Get the GOT section, creating it if necessary. 1226 1227 template<int size, bool big_endian> 1228 Output_data_got<size, big_endian>* 1229 Target_sparc<size, big_endian>::got_section(Symbol_table* symtab, 1230 Layout* layout) 1231 { 1232 if (this->got_ == NULL) 1233 { 1234 gold_assert(symtab != NULL && layout != NULL); 1235 1236 this->got_ = new Output_data_got<size, big_endian>(); 1237 1238 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 1239 (elfcpp::SHF_ALLOC 1240 | elfcpp::SHF_WRITE), 1241 this->got_, ORDER_RELRO, true); 1242 1243 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section. 1244 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 1245 Symbol_table::PREDEFINED, 1246 this->got_, 1247 0, 0, elfcpp::STT_OBJECT, 1248 elfcpp::STB_LOCAL, 1249 elfcpp::STV_HIDDEN, 0, 1250 false, false); 1251 } 1252 1253 return this->got_; 1254 } 1255 1256 // Get the dynamic reloc section, creating it if necessary. 1257 1258 template<int size, bool big_endian> 1259 typename Target_sparc<size, big_endian>::Reloc_section* 1260 Target_sparc<size, big_endian>::rela_dyn_section(Layout* layout) 1261 { 1262 if (this->rela_dyn_ == NULL) 1263 { 1264 gold_assert(layout != NULL); 1265 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc()); 1266 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA, 1267 elfcpp::SHF_ALLOC, this->rela_dyn_, 1268 ORDER_DYNAMIC_RELOCS, false); 1269 } 1270 return this->rela_dyn_; 1271 } 1272 1273 // Get the section to use for IFUNC relocs, creating it if 1274 // necessary. These go in .rela.dyn, but only after all other dynamic 1275 // relocations. They need to follow the other dynamic relocations so 1276 // that they can refer to global variables initialized by those 1277 // relocs. 1278 1279 template<int size, bool big_endian> 1280 typename Target_sparc<size, big_endian>::Reloc_section* 1281 Target_sparc<size, big_endian>::rela_ifunc_section(Layout* layout) 1282 { 1283 if (this->rela_ifunc_ == NULL) 1284 { 1285 // Make sure we have already created the dynamic reloc section. 1286 this->rela_dyn_section(layout); 1287 this->rela_ifunc_ = new Reloc_section(false); 1288 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA, 1289 elfcpp::SHF_ALLOC, this->rela_ifunc_, 1290 ORDER_DYNAMIC_RELOCS, false); 1291 gold_assert(this->rela_dyn_->output_section() 1292 == this->rela_ifunc_->output_section()); 1293 } 1294 return this->rela_ifunc_; 1295 } 1296 1297 // A class to handle the PLT data. 1298 1299 template<int size, bool big_endian> 1300 class Output_data_plt_sparc : public Output_section_data 1301 { 1302 public: 1303 typedef Output_data_reloc<elfcpp::SHT_RELA, true, 1304 size, big_endian> Reloc_section; 1305 1306 Output_data_plt_sparc(Layout*); 1307 1308 // Add an entry to the PLT. 1309 void add_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym); 1310 1311 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. 1312 unsigned int 1313 add_local_ifunc_entry(Symbol_table*, Layout*, 1314 Sized_relobj_file<size, big_endian>* relobj, 1315 unsigned int local_sym_index); 1316 1317 // Return the .rela.plt section data. 1318 const Reloc_section* rel_plt() const 1319 { 1320 return this->rel_; 1321 } 1322 1323 // Return where the IFUNC relocations should go. 1324 Reloc_section* 1325 rela_ifunc(Symbol_table*, Layout*); 1326 1327 void 1328 emit_pending_ifunc_relocs(); 1329 1330 // Return whether we created a section for IFUNC relocations. 1331 bool 1332 has_ifunc_section() const 1333 { return this->ifunc_rel_ != NULL; } 1334 1335 // Return the number of PLT entries. 1336 unsigned int 1337 entry_count() const 1338 { return this->count_ + this->ifunc_count_; } 1339 1340 // Return the offset of the first non-reserved PLT entry. 1341 static unsigned int 1342 first_plt_entry_offset() 1343 { return 4 * base_plt_entry_size; } 1344 1345 // Return the size of a PLT entry. 1346 static unsigned int 1347 get_plt_entry_size() 1348 { return base_plt_entry_size; } 1349 1350 // Return the PLT address to use for a global symbol. 1351 uint64_t 1352 address_for_global(const Symbol*); 1353 1354 // Return the PLT address to use for a local symbol. 1355 uint64_t 1356 address_for_local(const Relobj*, unsigned int symndx); 1357 1358 protected: 1359 void do_adjust_output_section(Output_section* os); 1360 1361 // Write to a map file. 1362 void 1363 do_print_to_mapfile(Mapfile* mapfile) const 1364 { mapfile->print_output_data(this, _("** PLT")); } 1365 1366 private: 1367 // The size of an entry in the PLT. 1368 static const int base_plt_entry_size = (size == 32 ? 12 : 32); 1369 1370 static const unsigned int plt_entries_per_block = 160; 1371 static const unsigned int plt_insn_chunk_size = 24; 1372 static const unsigned int plt_pointer_chunk_size = 8; 1373 static const unsigned int plt_block_size = 1374 (plt_entries_per_block 1375 * (plt_insn_chunk_size + plt_pointer_chunk_size)); 1376 1377 section_offset_type 1378 plt_index_to_offset(unsigned int index) 1379 { 1380 section_offset_type offset; 1381 1382 if (size == 32 || index < 32768) 1383 offset = index * base_plt_entry_size; 1384 else 1385 { 1386 unsigned int ext_index = index - 32768; 1387 1388 offset = (32768 * base_plt_entry_size) 1389 + ((ext_index / plt_entries_per_block) 1390 * plt_block_size) 1391 + ((ext_index % plt_entries_per_block) 1392 * plt_insn_chunk_size); 1393 } 1394 return offset; 1395 } 1396 1397 // Set the final size. 1398 void 1399 set_final_data_size() 1400 { 1401 unsigned int full_count = this->entry_count() + 4; 1402 unsigned int extra = (size == 32 ? 4 : 0); 1403 section_offset_type sz = plt_index_to_offset(full_count) + extra; 1404 1405 return this->set_data_size(sz); 1406 } 1407 1408 // Write out the PLT data. 1409 void 1410 do_write(Output_file*); 1411 1412 struct Global_ifunc 1413 { 1414 Reloc_section* rel; 1415 Symbol* gsym; 1416 unsigned int plt_index; 1417 }; 1418 1419 struct Local_ifunc 1420 { 1421 Reloc_section* rel; 1422 Sized_relobj_file<size, big_endian>* object; 1423 unsigned int local_sym_index; 1424 unsigned int plt_index; 1425 }; 1426 1427 // The reloc section. 1428 Reloc_section* rel_; 1429 // The IFUNC relocations, if necessary. These must follow the 1430 // regular relocations. 1431 Reloc_section* ifunc_rel_; 1432 // The number of PLT entries. 1433 unsigned int count_; 1434 // The number of PLT entries for IFUNC symbols. 1435 unsigned int ifunc_count_; 1436 // Global STT_GNU_IFUNC symbols. 1437 std::vector<Global_ifunc> global_ifuncs_; 1438 // Local STT_GNU_IFUNC symbols. 1439 std::vector<Local_ifunc> local_ifuncs_; 1440 }; 1441 1442 // Define the constants as required by C++ standard. 1443 1444 template<int size, bool big_endian> 1445 const int Output_data_plt_sparc<size, big_endian>::base_plt_entry_size; 1446 1447 template<int size, bool big_endian> 1448 const unsigned int 1449 Output_data_plt_sparc<size, big_endian>::plt_entries_per_block; 1450 1451 template<int size, bool big_endian> 1452 const unsigned int Output_data_plt_sparc<size, big_endian>::plt_insn_chunk_size; 1453 1454 template<int size, bool big_endian> 1455 const unsigned int 1456 Output_data_plt_sparc<size, big_endian>::plt_pointer_chunk_size; 1457 1458 template<int size, bool big_endian> 1459 const unsigned int Output_data_plt_sparc<size, big_endian>::plt_block_size; 1460 1461 // Create the PLT section. The ordinary .got section is an argument, 1462 // since we need to refer to the start. 1463 1464 template<int size, bool big_endian> 1465 Output_data_plt_sparc<size, big_endian>::Output_data_plt_sparc(Layout* layout) 1466 : Output_section_data(size == 32 ? 4 : 8), ifunc_rel_(NULL), 1467 count_(0), ifunc_count_(0), global_ifuncs_(), local_ifuncs_() 1468 { 1469 this->rel_ = new Reloc_section(false); 1470 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 1471 elfcpp::SHF_ALLOC, this->rel_, 1472 ORDER_DYNAMIC_PLT_RELOCS, false); 1473 } 1474 1475 template<int size, bool big_endian> 1476 void 1477 Output_data_plt_sparc<size, big_endian>::do_adjust_output_section(Output_section* os) 1478 { 1479 os->set_entsize(0); 1480 } 1481 1482 // Add an entry to the PLT. 1483 1484 template<int size, bool big_endian> 1485 void 1486 Output_data_plt_sparc<size, big_endian>::add_entry(Symbol_table* symtab, 1487 Layout* layout, 1488 Symbol* gsym) 1489 { 1490 gold_assert(!gsym->has_plt_offset()); 1491 1492 section_offset_type plt_offset; 1493 unsigned int index; 1494 1495 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1496 && gsym->can_use_relative_reloc(false)) 1497 { 1498 index = this->ifunc_count_; 1499 plt_offset = plt_index_to_offset(index); 1500 gsym->set_plt_offset(plt_offset); 1501 ++this->ifunc_count_; 1502 Reloc_section* rel = this->rela_ifunc(symtab, layout); 1503 1504 struct Global_ifunc gi; 1505 gi.rel = rel; 1506 gi.gsym = gsym; 1507 gi.plt_index = index; 1508 this->global_ifuncs_.push_back(gi); 1509 } 1510 else 1511 { 1512 plt_offset = plt_index_to_offset(this->count_ + 4); 1513 gsym->set_plt_offset(plt_offset); 1514 ++this->count_; 1515 gsym->set_needs_dynsym_entry(); 1516 this->rel_->add_global(gsym, elfcpp::R_SPARC_JMP_SLOT, this, 1517 plt_offset, 0); 1518 } 1519 1520 // Note that we don't need to save the symbol. The contents of the 1521 // PLT are independent of which symbols are used. The symbols only 1522 // appear in the relocations. 1523 } 1524 1525 template<int size, bool big_endian> 1526 unsigned int 1527 Output_data_plt_sparc<size, big_endian>::add_local_ifunc_entry( 1528 Symbol_table* symtab, 1529 Layout* layout, 1530 Sized_relobj_file<size, big_endian>* relobj, 1531 unsigned int local_sym_index) 1532 { 1533 unsigned int index = this->ifunc_count_; 1534 section_offset_type plt_offset; 1535 1536 plt_offset = plt_index_to_offset(index); 1537 ++this->ifunc_count_; 1538 1539 Reloc_section* rel = this->rela_ifunc(symtab, layout); 1540 1541 struct Local_ifunc li; 1542 li.rel = rel; 1543 li.object = relobj; 1544 li.local_sym_index = local_sym_index; 1545 li.plt_index = index; 1546 this->local_ifuncs_.push_back(li); 1547 1548 return plt_offset; 1549 } 1550 1551 // Emit any pending IFUNC plt relocations. 1552 1553 template<int size, bool big_endian> 1554 void 1555 Output_data_plt_sparc<size, big_endian>::emit_pending_ifunc_relocs() 1556 { 1557 // Emit any pending IFUNC relocs. 1558 for (typename std::vector<Global_ifunc>::const_iterator p = 1559 this->global_ifuncs_.begin(); 1560 p != this->global_ifuncs_.end(); 1561 ++p) 1562 { 1563 section_offset_type plt_offset; 1564 unsigned int index; 1565 1566 index = this->count_ + p->plt_index + 4; 1567 plt_offset = this->plt_index_to_offset(index); 1568 p->rel->add_symbolless_global_addend(p->gsym, elfcpp::R_SPARC_JMP_IREL, 1569 this, plt_offset, 0); 1570 } 1571 1572 for (typename std::vector<Local_ifunc>::const_iterator p = 1573 this->local_ifuncs_.begin(); 1574 p != this->local_ifuncs_.end(); 1575 ++p) 1576 { 1577 section_offset_type plt_offset; 1578 unsigned int index; 1579 1580 index = this->count_ + p->plt_index + 4; 1581 plt_offset = this->plt_index_to_offset(index); 1582 p->rel->add_symbolless_local_addend(p->object, p->local_sym_index, 1583 elfcpp::R_SPARC_JMP_IREL, 1584 this, plt_offset, 0); 1585 } 1586 } 1587 1588 // Return where the IFUNC relocations should go in the PLT. These 1589 // follow the non-IFUNC relocations. 1590 1591 template<int size, bool big_endian> 1592 typename Output_data_plt_sparc<size, big_endian>::Reloc_section* 1593 Output_data_plt_sparc<size, big_endian>::rela_ifunc( 1594 Symbol_table* symtab, 1595 Layout* layout) 1596 { 1597 if (this->ifunc_rel_ == NULL) 1598 { 1599 this->ifunc_rel_ = new Reloc_section(false); 1600 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA, 1601 elfcpp::SHF_ALLOC, this->ifunc_rel_, 1602 ORDER_DYNAMIC_PLT_RELOCS, false); 1603 gold_assert(this->ifunc_rel_->output_section() 1604 == this->rel_->output_section()); 1605 1606 if (parameters->doing_static_link()) 1607 { 1608 // A statically linked executable will only have a .rel.plt 1609 // section to hold R_SPARC_IRELATIVE and R_SPARC_JMP_IREL 1610 // relocs for STT_GNU_IFUNC symbols. The library will use 1611 // these symbols to locate the IRELATIVE and JMP_IREL relocs 1612 // at program startup time. 1613 symtab->define_in_output_data("__rela_iplt_start", NULL, 1614 Symbol_table::PREDEFINED, 1615 this->ifunc_rel_, 0, 0, 1616 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1617 elfcpp::STV_HIDDEN, 0, false, true); 1618 symtab->define_in_output_data("__rela_iplt_end", NULL, 1619 Symbol_table::PREDEFINED, 1620 this->ifunc_rel_, 0, 0, 1621 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, 1622 elfcpp::STV_HIDDEN, 0, true, true); 1623 } 1624 } 1625 return this->ifunc_rel_; 1626 } 1627 1628 // Return the PLT address to use for a global symbol. 1629 1630 template<int size, bool big_endian> 1631 uint64_t 1632 Output_data_plt_sparc<size, big_endian>::address_for_global(const Symbol* gsym) 1633 { 1634 uint64_t offset = 0; 1635 if (gsym->type() == elfcpp::STT_GNU_IFUNC 1636 && gsym->can_use_relative_reloc(false)) 1637 offset = plt_index_to_offset(this->count_ + 4); 1638 return this->address() + offset + gsym->plt_offset(); 1639 } 1640 1641 // Return the PLT address to use for a local symbol. These are always 1642 // IRELATIVE relocs. 1643 1644 template<int size, bool big_endian> 1645 uint64_t 1646 Output_data_plt_sparc<size, big_endian>::address_for_local( 1647 const Relobj* object, 1648 unsigned int r_sym) 1649 { 1650 return (this->address() 1651 + plt_index_to_offset(this->count_ + 4) 1652 + object->local_plt_offset(r_sym)); 1653 } 1654 1655 static const unsigned int sparc_nop = 0x01000000; 1656 static const unsigned int sparc_sethi_g1 = 0x03000000; 1657 static const unsigned int sparc_branch_always = 0x30800000; 1658 static const unsigned int sparc_branch_always_pt = 0x30680000; 1659 static const unsigned int sparc_mov = 0x80100000; 1660 static const unsigned int sparc_mov_g0_o0 = 0x90100000; 1661 static const unsigned int sparc_mov_o7_g5 = 0x8a10000f; 1662 static const unsigned int sparc_call_plus_8 = 0x40000002; 1663 static const unsigned int sparc_ldx_o7_imm_g1 = 0xc25be000; 1664 static const unsigned int sparc_jmpl_o7_g1_g1 = 0x83c3c001; 1665 static const unsigned int sparc_mov_g5_o7 = 0x9e100005; 1666 1667 // Write out the PLT. 1668 1669 template<int size, bool big_endian> 1670 void 1671 Output_data_plt_sparc<size, big_endian>::do_write(Output_file* of) 1672 { 1673 const off_t offset = this->offset(); 1674 const section_size_type oview_size = 1675 convert_to_section_size_type(this->data_size()); 1676 unsigned char* const oview = of->get_output_view(offset, oview_size); 1677 unsigned char* pov = oview; 1678 1679 memset(pov, 0, base_plt_entry_size * 4); 1680 pov += this->first_plt_entry_offset(); 1681 1682 unsigned int plt_offset = base_plt_entry_size * 4; 1683 const unsigned int count = this->entry_count(); 1684 1685 if (size == 64) 1686 { 1687 unsigned int limit; 1688 1689 limit = (count > 32768 ? 32768 : count); 1690 1691 for (unsigned int i = 0; i < limit; ++i) 1692 { 1693 elfcpp::Swap<32, true>::writeval(pov + 0x00, 1694 sparc_sethi_g1 + plt_offset); 1695 elfcpp::Swap<32, true>::writeval(pov + 0x04, 1696 sparc_branch_always_pt + 1697 (((base_plt_entry_size - 1698 (plt_offset + 4)) >> 2) & 1699 0x7ffff)); 1700 elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop); 1701 elfcpp::Swap<32, true>::writeval(pov + 0x0c, sparc_nop); 1702 elfcpp::Swap<32, true>::writeval(pov + 0x10, sparc_nop); 1703 elfcpp::Swap<32, true>::writeval(pov + 0x14, sparc_nop); 1704 elfcpp::Swap<32, true>::writeval(pov + 0x18, sparc_nop); 1705 elfcpp::Swap<32, true>::writeval(pov + 0x1c, sparc_nop); 1706 1707 pov += base_plt_entry_size; 1708 plt_offset += base_plt_entry_size; 1709 } 1710 1711 if (count > 32768) 1712 { 1713 unsigned int ext_cnt = count - 32768; 1714 unsigned int blks = ext_cnt / plt_entries_per_block; 1715 1716 for (unsigned int i = 0; i < blks; ++i) 1717 { 1718 unsigned int data_off = (plt_entries_per_block 1719 * plt_insn_chunk_size) - 4; 1720 1721 for (unsigned int j = 0; j < plt_entries_per_block; ++j) 1722 { 1723 elfcpp::Swap<32, true>::writeval(pov + 0x00, 1724 sparc_mov_o7_g5); 1725 elfcpp::Swap<32, true>::writeval(pov + 0x04, 1726 sparc_call_plus_8); 1727 elfcpp::Swap<32, true>::writeval(pov + 0x08, 1728 sparc_nop); 1729 elfcpp::Swap<32, true>::writeval(pov + 0x0c, 1730 sparc_ldx_o7_imm_g1 + 1731 (data_off & 0x1fff)); 1732 elfcpp::Swap<32, true>::writeval(pov + 0x10, 1733 sparc_jmpl_o7_g1_g1); 1734 elfcpp::Swap<32, true>::writeval(pov + 0x14, 1735 sparc_mov_g5_o7); 1736 1737 elfcpp::Swap<64, big_endian>::writeval( 1738 pov + 0x4 + data_off, 1739 (elfcpp::Elf_Xword) (oview - (pov + 0x04))); 1740 1741 pov += plt_insn_chunk_size; 1742 data_off -= 16; 1743 } 1744 } 1745 1746 unsigned int sub_blk_cnt = ext_cnt % plt_entries_per_block; 1747 for (unsigned int i = 0; i < sub_blk_cnt; ++i) 1748 { 1749 unsigned int data_off = (sub_blk_cnt 1750 * plt_insn_chunk_size) - 4; 1751 1752 for (unsigned int j = 0; j < plt_entries_per_block; ++j) 1753 { 1754 elfcpp::Swap<32, true>::writeval(pov + 0x00, 1755 sparc_mov_o7_g5); 1756 elfcpp::Swap<32, true>::writeval(pov + 0x04, 1757 sparc_call_plus_8); 1758 elfcpp::Swap<32, true>::writeval(pov + 0x08, 1759 sparc_nop); 1760 elfcpp::Swap<32, true>::writeval(pov + 0x0c, 1761 sparc_ldx_o7_imm_g1 + 1762 (data_off & 0x1fff)); 1763 elfcpp::Swap<32, true>::writeval(pov + 0x10, 1764 sparc_jmpl_o7_g1_g1); 1765 elfcpp::Swap<32, true>::writeval(pov + 0x14, 1766 sparc_mov_g5_o7); 1767 1768 elfcpp::Swap<64, big_endian>::writeval( 1769 pov + 0x4 + data_off, 1770 (elfcpp::Elf_Xword) (oview - (pov + 0x04))); 1771 1772 pov += plt_insn_chunk_size; 1773 data_off -= 16; 1774 } 1775 } 1776 } 1777 } 1778 else 1779 { 1780 for (unsigned int i = 0; i < count; ++i) 1781 { 1782 elfcpp::Swap<32, true>::writeval(pov + 0x00, 1783 sparc_sethi_g1 + plt_offset); 1784 elfcpp::Swap<32, true>::writeval(pov + 0x04, 1785 sparc_branch_always + 1786 (((- (plt_offset + 4)) >> 2) & 1787 0x003fffff)); 1788 elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop); 1789 1790 pov += base_plt_entry_size; 1791 plt_offset += base_plt_entry_size; 1792 } 1793 1794 elfcpp::Swap<32, true>::writeval(pov, sparc_nop); 1795 pov += 4; 1796 } 1797 1798 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); 1799 1800 of->write_output_view(offset, oview_size, oview); 1801 } 1802 1803 // Create the PLT section. 1804 1805 template<int size, bool big_endian> 1806 void 1807 Target_sparc<size, big_endian>::make_plt_section(Symbol_table* symtab, 1808 Layout* layout) 1809 { 1810 // Create the GOT sections first. 1811 this->got_section(symtab, layout); 1812 1813 // Ensure that .rela.dyn always appears before .rela.plt This is 1814 // necessary due to how, on Sparc and some other targets, .rela.dyn 1815 // needs to include .rela.plt in it's range. 1816 this->rela_dyn_section(layout); 1817 1818 this->plt_ = new Output_data_plt_sparc<size, big_endian>(layout); 1819 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 1820 (elfcpp::SHF_ALLOC 1821 | elfcpp::SHF_EXECINSTR 1822 | elfcpp::SHF_WRITE), 1823 this->plt_, ORDER_NON_RELRO_FIRST, false); 1824 1825 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section. 1826 symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL, 1827 Symbol_table::PREDEFINED, 1828 this->plt_, 1829 0, 0, elfcpp::STT_OBJECT, 1830 elfcpp::STB_LOCAL, 1831 elfcpp::STV_HIDDEN, 0, 1832 false, false); 1833 } 1834 1835 // Create a PLT entry for a global symbol. 1836 1837 template<int size, bool big_endian> 1838 void 1839 Target_sparc<size, big_endian>::make_plt_entry(Symbol_table* symtab, 1840 Layout* layout, 1841 Symbol* gsym) 1842 { 1843 if (gsym->has_plt_offset()) 1844 return; 1845 1846 if (this->plt_ == NULL) 1847 this->make_plt_section(symtab, layout); 1848 1849 this->plt_->add_entry(symtab, layout, gsym); 1850 } 1851 1852 // Make a PLT entry for a local STT_GNU_IFUNC symbol. 1853 1854 template<int size, bool big_endian> 1855 void 1856 Target_sparc<size, big_endian>::make_local_ifunc_plt_entry( 1857 Symbol_table* symtab, 1858 Layout* layout, 1859 Sized_relobj_file<size, big_endian>* relobj, 1860 unsigned int local_sym_index) 1861 { 1862 if (relobj->local_has_plt_offset(local_sym_index)) 1863 return; 1864 if (this->plt_ == NULL) 1865 this->make_plt_section(symtab, layout); 1866 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout, 1867 relobj, 1868 local_sym_index); 1869 relobj->set_local_plt_offset(local_sym_index, plt_offset); 1870 } 1871 1872 // Return the number of entries in the PLT. 1873 1874 template<int size, bool big_endian> 1875 unsigned int 1876 Target_sparc<size, big_endian>::plt_entry_count() const 1877 { 1878 if (this->plt_ == NULL) 1879 return 0; 1880 return this->plt_->entry_count(); 1881 } 1882 1883 // Return the offset of the first non-reserved PLT entry. 1884 1885 template<int size, bool big_endian> 1886 unsigned int 1887 Target_sparc<size, big_endian>::first_plt_entry_offset() const 1888 { 1889 return Output_data_plt_sparc<size, big_endian>::first_plt_entry_offset(); 1890 } 1891 1892 // Return the size of each PLT entry. 1893 1894 template<int size, bool big_endian> 1895 unsigned int 1896 Target_sparc<size, big_endian>::plt_entry_size() const 1897 { 1898 return Output_data_plt_sparc<size, big_endian>::get_plt_entry_size(); 1899 } 1900 1901 // Create a GOT entry for the TLS module index. 1902 1903 template<int size, bool big_endian> 1904 unsigned int 1905 Target_sparc<size, big_endian>::got_mod_index_entry( 1906 Symbol_table* symtab, 1907 Layout* layout, 1908 Sized_relobj_file<size, big_endian>* object) 1909 { 1910 if (this->got_mod_index_offset_ == -1U) 1911 { 1912 gold_assert(symtab != NULL && layout != NULL && object != NULL); 1913 Reloc_section* rela_dyn = this->rela_dyn_section(layout); 1914 Output_data_got<size, big_endian>* got; 1915 unsigned int got_offset; 1916 1917 got = this->got_section(symtab, layout); 1918 got_offset = got->add_constant(0); 1919 rela_dyn->add_local(object, 0, 1920 (size == 64 ? 1921 elfcpp::R_SPARC_TLS_DTPMOD64 : 1922 elfcpp::R_SPARC_TLS_DTPMOD32), got, 1923 got_offset, 0); 1924 got->add_constant(0); 1925 this->got_mod_index_offset_ = got_offset; 1926 } 1927 return this->got_mod_index_offset_; 1928 } 1929 1930 // Optimize the TLS relocation type based on what we know about the 1931 // symbol. IS_FINAL is true if the final address of this symbol is 1932 // known at link time. 1933 1934 static tls::Tls_optimization 1935 optimize_tls_reloc(bool is_final, int r_type) 1936 { 1937 // If we are generating a shared library, then we can't do anything 1938 // in the linker. 1939 if (parameters->options().shared()) 1940 return tls::TLSOPT_NONE; 1941 1942 switch (r_type) 1943 { 1944 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 1945 case elfcpp::R_SPARC_TLS_GD_LO10: 1946 case elfcpp::R_SPARC_TLS_GD_ADD: 1947 case elfcpp::R_SPARC_TLS_GD_CALL: 1948 // These are General-Dynamic which permits fully general TLS 1949 // access. Since we know that we are generating an executable, 1950 // we can convert this to Initial-Exec. If we also know that 1951 // this is a local symbol, we can further switch to Local-Exec. 1952 if (is_final) 1953 return tls::TLSOPT_TO_LE; 1954 return tls::TLSOPT_TO_IE; 1955 1956 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic 1957 case elfcpp::R_SPARC_TLS_LDM_LO10: 1958 case elfcpp::R_SPARC_TLS_LDM_ADD: 1959 case elfcpp::R_SPARC_TLS_LDM_CALL: 1960 // This is Local-Dynamic, which refers to a local symbol in the 1961 // dynamic TLS block. Since we know that we generating an 1962 // executable, we can switch to Local-Exec. 1963 return tls::TLSOPT_TO_LE; 1964 1965 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 1966 case elfcpp::R_SPARC_TLS_LDO_LOX10: 1967 case elfcpp::R_SPARC_TLS_LDO_ADD: 1968 // Another type of Local-Dynamic relocation. 1969 return tls::TLSOPT_TO_LE; 1970 1971 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 1972 case elfcpp::R_SPARC_TLS_IE_LO10: 1973 case elfcpp::R_SPARC_TLS_IE_LD: 1974 case elfcpp::R_SPARC_TLS_IE_LDX: 1975 case elfcpp::R_SPARC_TLS_IE_ADD: 1976 // These are Initial-Exec relocs which get the thread offset 1977 // from the GOT. If we know that we are linking against the 1978 // local symbol, we can switch to Local-Exec, which links the 1979 // thread offset into the instruction. 1980 if (is_final) 1981 return tls::TLSOPT_TO_LE; 1982 return tls::TLSOPT_NONE; 1983 1984 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec 1985 case elfcpp::R_SPARC_TLS_LE_LOX10: 1986 // When we already have Local-Exec, there is nothing further we 1987 // can do. 1988 return tls::TLSOPT_NONE; 1989 1990 default: 1991 gold_unreachable(); 1992 } 1993 } 1994 1995 // Get the Reference_flags for a particular relocation. 1996 1997 template<int size, bool big_endian> 1998 int 1999 Target_sparc<size, big_endian>::Scan::get_reference_flags(unsigned int r_type) 2000 { 2001 r_type &= 0xff; 2002 switch (r_type) 2003 { 2004 case elfcpp::R_SPARC_NONE: 2005 case elfcpp::R_SPARC_REGISTER: 2006 case elfcpp::R_SPARC_GNU_VTINHERIT: 2007 case elfcpp::R_SPARC_GNU_VTENTRY: 2008 // No symbol reference. 2009 return 0; 2010 2011 case elfcpp::R_SPARC_UA64: 2012 case elfcpp::R_SPARC_64: 2013 case elfcpp::R_SPARC_HIX22: 2014 case elfcpp::R_SPARC_LOX10: 2015 case elfcpp::R_SPARC_H34: 2016 case elfcpp::R_SPARC_H44: 2017 case elfcpp::R_SPARC_M44: 2018 case elfcpp::R_SPARC_L44: 2019 case elfcpp::R_SPARC_HH22: 2020 case elfcpp::R_SPARC_HM10: 2021 case elfcpp::R_SPARC_LM22: 2022 case elfcpp::R_SPARC_HI22: 2023 case elfcpp::R_SPARC_LO10: 2024 case elfcpp::R_SPARC_OLO10: 2025 case elfcpp::R_SPARC_UA32: 2026 case elfcpp::R_SPARC_32: 2027 case elfcpp::R_SPARC_UA16: 2028 case elfcpp::R_SPARC_16: 2029 case elfcpp::R_SPARC_11: 2030 case elfcpp::R_SPARC_10: 2031 case elfcpp::R_SPARC_8: 2032 case elfcpp::R_SPARC_7: 2033 case elfcpp::R_SPARC_6: 2034 case elfcpp::R_SPARC_5: 2035 return Symbol::ABSOLUTE_REF; 2036 2037 case elfcpp::R_SPARC_DISP8: 2038 case elfcpp::R_SPARC_DISP16: 2039 case elfcpp::R_SPARC_DISP32: 2040 case elfcpp::R_SPARC_DISP64: 2041 case elfcpp::R_SPARC_PC_HH22: 2042 case elfcpp::R_SPARC_PC_HM10: 2043 case elfcpp::R_SPARC_PC_LM22: 2044 case elfcpp::R_SPARC_PC10: 2045 case elfcpp::R_SPARC_PC22: 2046 case elfcpp::R_SPARC_WDISP30: 2047 case elfcpp::R_SPARC_WDISP22: 2048 case elfcpp::R_SPARC_WDISP19: 2049 case elfcpp::R_SPARC_WDISP16: 2050 case elfcpp::R_SPARC_WDISP10: 2051 return Symbol::RELATIVE_REF; 2052 2053 case elfcpp::R_SPARC_PLT64: 2054 case elfcpp::R_SPARC_PLT32: 2055 case elfcpp::R_SPARC_HIPLT22: 2056 case elfcpp::R_SPARC_LOPLT10: 2057 case elfcpp::R_SPARC_PCPLT10: 2058 return Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF; 2059 2060 case elfcpp::R_SPARC_PCPLT32: 2061 case elfcpp::R_SPARC_PCPLT22: 2062 case elfcpp::R_SPARC_WPLT30: 2063 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF; 2064 2065 case elfcpp::R_SPARC_GOTDATA_OP: 2066 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 2067 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 2068 case elfcpp::R_SPARC_GOT10: 2069 case elfcpp::R_SPARC_GOT13: 2070 case elfcpp::R_SPARC_GOT22: 2071 // Absolute in GOT. 2072 return Symbol::ABSOLUTE_REF; 2073 2074 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2075 case elfcpp::R_SPARC_TLS_GD_LO10: 2076 case elfcpp::R_SPARC_TLS_GD_ADD: 2077 case elfcpp::R_SPARC_TLS_GD_CALL: 2078 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic 2079 case elfcpp::R_SPARC_TLS_LDM_LO10: 2080 case elfcpp::R_SPARC_TLS_LDM_ADD: 2081 case elfcpp::R_SPARC_TLS_LDM_CALL: 2082 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2083 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2084 case elfcpp::R_SPARC_TLS_LDO_ADD: 2085 case elfcpp::R_SPARC_TLS_LE_HIX22: 2086 case elfcpp::R_SPARC_TLS_LE_LOX10: 2087 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2088 case elfcpp::R_SPARC_TLS_IE_LO10: 2089 case elfcpp::R_SPARC_TLS_IE_LD: 2090 case elfcpp::R_SPARC_TLS_IE_LDX: 2091 case elfcpp::R_SPARC_TLS_IE_ADD: 2092 return Symbol::TLS_REF; 2093 2094 case elfcpp::R_SPARC_COPY: 2095 case elfcpp::R_SPARC_GLOB_DAT: 2096 case elfcpp::R_SPARC_JMP_SLOT: 2097 case elfcpp::R_SPARC_JMP_IREL: 2098 case elfcpp::R_SPARC_RELATIVE: 2099 case elfcpp::R_SPARC_IRELATIVE: 2100 case elfcpp::R_SPARC_TLS_DTPMOD64: 2101 case elfcpp::R_SPARC_TLS_DTPMOD32: 2102 case elfcpp::R_SPARC_TLS_DTPOFF64: 2103 case elfcpp::R_SPARC_TLS_DTPOFF32: 2104 case elfcpp::R_SPARC_TLS_TPOFF64: 2105 case elfcpp::R_SPARC_TLS_TPOFF32: 2106 default: 2107 // Not expected. We will give an error later. 2108 return 0; 2109 } 2110 } 2111 2112 // Generate a PLT entry slot for a call to __tls_get_addr 2113 template<int size, bool big_endian> 2114 void 2115 Target_sparc<size, big_endian>::Scan::generate_tls_call(Symbol_table* symtab, 2116 Layout* layout, 2117 Target_sparc<size, big_endian>* target) 2118 { 2119 Symbol* gsym = target->tls_get_addr_sym(symtab); 2120 2121 target->make_plt_entry(symtab, layout, gsym); 2122 } 2123 2124 // Report an unsupported relocation against a local symbol. 2125 2126 template<int size, bool big_endian> 2127 void 2128 Target_sparc<size, big_endian>::Scan::unsupported_reloc_local( 2129 Sized_relobj_file<size, big_endian>* object, 2130 unsigned int r_type) 2131 { 2132 gold_error(_("%s: unsupported reloc %u against local symbol"), 2133 object->name().c_str(), r_type); 2134 } 2135 2136 // We are about to emit a dynamic relocation of type R_TYPE. If the 2137 // dynamic linker does not support it, issue an error. 2138 2139 template<int size, bool big_endian> 2140 void 2141 Target_sparc<size, big_endian>::Scan::check_non_pic(Relobj* object, unsigned int r_type) 2142 { 2143 gold_assert(r_type != elfcpp::R_SPARC_NONE); 2144 2145 if (size == 64) 2146 { 2147 switch (r_type) 2148 { 2149 // These are the relocation types supported by glibc for sparc 64-bit. 2150 case elfcpp::R_SPARC_RELATIVE: 2151 case elfcpp::R_SPARC_IRELATIVE: 2152 case elfcpp::R_SPARC_COPY: 2153 case elfcpp::R_SPARC_32: 2154 case elfcpp::R_SPARC_64: 2155 case elfcpp::R_SPARC_GLOB_DAT: 2156 case elfcpp::R_SPARC_JMP_SLOT: 2157 case elfcpp::R_SPARC_JMP_IREL: 2158 case elfcpp::R_SPARC_TLS_DTPMOD64: 2159 case elfcpp::R_SPARC_TLS_DTPOFF64: 2160 case elfcpp::R_SPARC_TLS_TPOFF64: 2161 case elfcpp::R_SPARC_TLS_LE_HIX22: 2162 case elfcpp::R_SPARC_TLS_LE_LOX10: 2163 case elfcpp::R_SPARC_8: 2164 case elfcpp::R_SPARC_16: 2165 case elfcpp::R_SPARC_DISP8: 2166 case elfcpp::R_SPARC_DISP16: 2167 case elfcpp::R_SPARC_DISP32: 2168 case elfcpp::R_SPARC_WDISP30: 2169 case elfcpp::R_SPARC_LO10: 2170 case elfcpp::R_SPARC_HI22: 2171 case elfcpp::R_SPARC_OLO10: 2172 case elfcpp::R_SPARC_H34: 2173 case elfcpp::R_SPARC_H44: 2174 case elfcpp::R_SPARC_M44: 2175 case elfcpp::R_SPARC_L44: 2176 case elfcpp::R_SPARC_HH22: 2177 case elfcpp::R_SPARC_HM10: 2178 case elfcpp::R_SPARC_LM22: 2179 case elfcpp::R_SPARC_UA16: 2180 case elfcpp::R_SPARC_UA32: 2181 case elfcpp::R_SPARC_UA64: 2182 return; 2183 2184 default: 2185 break; 2186 } 2187 } 2188 else 2189 { 2190 switch (r_type) 2191 { 2192 // These are the relocation types supported by glibc for sparc 32-bit. 2193 case elfcpp::R_SPARC_RELATIVE: 2194 case elfcpp::R_SPARC_IRELATIVE: 2195 case elfcpp::R_SPARC_COPY: 2196 case elfcpp::R_SPARC_GLOB_DAT: 2197 case elfcpp::R_SPARC_32: 2198 case elfcpp::R_SPARC_JMP_SLOT: 2199 case elfcpp::R_SPARC_JMP_IREL: 2200 case elfcpp::R_SPARC_TLS_DTPMOD32: 2201 case elfcpp::R_SPARC_TLS_DTPOFF32: 2202 case elfcpp::R_SPARC_TLS_TPOFF32: 2203 case elfcpp::R_SPARC_TLS_LE_HIX22: 2204 case elfcpp::R_SPARC_TLS_LE_LOX10: 2205 case elfcpp::R_SPARC_8: 2206 case elfcpp::R_SPARC_16: 2207 case elfcpp::R_SPARC_DISP8: 2208 case elfcpp::R_SPARC_DISP16: 2209 case elfcpp::R_SPARC_DISP32: 2210 case elfcpp::R_SPARC_LO10: 2211 case elfcpp::R_SPARC_WDISP30: 2212 case elfcpp::R_SPARC_HI22: 2213 case elfcpp::R_SPARC_UA16: 2214 case elfcpp::R_SPARC_UA32: 2215 return; 2216 2217 default: 2218 break; 2219 } 2220 } 2221 2222 // This prevents us from issuing more than one error per reloc 2223 // section. But we can still wind up issuing more than one 2224 // error per object file. 2225 if (this->issued_non_pic_error_) 2226 return; 2227 gold_assert(parameters->options().output_is_position_independent()); 2228 object->error(_("requires unsupported dynamic reloc; " 2229 "recompile with -fPIC")); 2230 this->issued_non_pic_error_ = true; 2231 return; 2232 } 2233 2234 // Return whether we need to make a PLT entry for a relocation of the 2235 // given type against a STT_GNU_IFUNC symbol. 2236 2237 template<int size, bool big_endian> 2238 bool 2239 Target_sparc<size, big_endian>::Scan::reloc_needs_plt_for_ifunc( 2240 Sized_relobj_file<size, big_endian>* object, 2241 unsigned int r_type) 2242 { 2243 int flags = Scan::get_reference_flags(r_type); 2244 if (flags & Symbol::TLS_REF) 2245 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"), 2246 object->name().c_str(), r_type); 2247 return flags != 0; 2248 } 2249 2250 // Scan a relocation for a local symbol. 2251 2252 template<int size, bool big_endian> 2253 inline void 2254 Target_sparc<size, big_endian>::Scan::local( 2255 Symbol_table* symtab, 2256 Layout* layout, 2257 Target_sparc<size, big_endian>* target, 2258 Sized_relobj_file<size, big_endian>* object, 2259 unsigned int data_shndx, 2260 Output_section* output_section, 2261 const elfcpp::Rela<size, big_endian>& reloc, 2262 unsigned int r_type, 2263 const elfcpp::Sym<size, big_endian>& lsym, 2264 bool is_discarded) 2265 { 2266 if (is_discarded) 2267 return; 2268 2269 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC; 2270 unsigned int orig_r_type = r_type; 2271 r_type &= 0xff; 2272 2273 if (is_ifunc 2274 && this->reloc_needs_plt_for_ifunc(object, r_type)) 2275 { 2276 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2277 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym); 2278 } 2279 2280 switch (r_type) 2281 { 2282 case elfcpp::R_SPARC_NONE: 2283 case elfcpp::R_SPARC_REGISTER: 2284 case elfcpp::R_SPARC_GNU_VTINHERIT: 2285 case elfcpp::R_SPARC_GNU_VTENTRY: 2286 break; 2287 2288 case elfcpp::R_SPARC_64: 2289 case elfcpp::R_SPARC_32: 2290 // If building a shared library (or a position-independent 2291 // executable), we need to create a dynamic relocation for 2292 // this location. The relocation applied at link time will 2293 // apply the link-time value, so we flag the location with 2294 // an R_SPARC_RELATIVE relocation so the dynamic loader can 2295 // relocate it easily. 2296 if (parameters->options().output_is_position_independent() 2297 && ((size == 64 && r_type == elfcpp::R_SPARC_64) 2298 || (size == 32 && r_type == elfcpp::R_SPARC_32))) 2299 { 2300 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2301 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2302 rela_dyn->add_local_relative(object, r_sym, elfcpp::R_SPARC_RELATIVE, 2303 output_section, data_shndx, 2304 reloc.get_r_offset(), 2305 reloc.get_r_addend(), is_ifunc); 2306 break; 2307 } 2308 /* Fall through. */ 2309 2310 case elfcpp::R_SPARC_HIX22: 2311 case elfcpp::R_SPARC_LOX10: 2312 case elfcpp::R_SPARC_H34: 2313 case elfcpp::R_SPARC_H44: 2314 case elfcpp::R_SPARC_M44: 2315 case elfcpp::R_SPARC_L44: 2316 case elfcpp::R_SPARC_HH22: 2317 case elfcpp::R_SPARC_HM10: 2318 case elfcpp::R_SPARC_LM22: 2319 case elfcpp::R_SPARC_UA64: 2320 case elfcpp::R_SPARC_UA32: 2321 case elfcpp::R_SPARC_UA16: 2322 case elfcpp::R_SPARC_HI22: 2323 case elfcpp::R_SPARC_LO10: 2324 case elfcpp::R_SPARC_OLO10: 2325 case elfcpp::R_SPARC_16: 2326 case elfcpp::R_SPARC_11: 2327 case elfcpp::R_SPARC_10: 2328 case elfcpp::R_SPARC_8: 2329 case elfcpp::R_SPARC_7: 2330 case elfcpp::R_SPARC_6: 2331 case elfcpp::R_SPARC_5: 2332 // If building a shared library (or a position-independent 2333 // executable), we need to create a dynamic relocation for 2334 // this location. 2335 if (parameters->options().output_is_position_independent()) 2336 { 2337 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2338 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2339 2340 check_non_pic(object, r_type); 2341 if (lsym.get_st_type() != elfcpp::STT_SECTION) 2342 { 2343 rela_dyn->add_local(object, r_sym, orig_r_type, output_section, 2344 data_shndx, reloc.get_r_offset(), 2345 reloc.get_r_addend()); 2346 } 2347 else 2348 { 2349 gold_assert(lsym.get_st_value() == 0); 2350 rela_dyn->add_symbolless_local_addend(object, r_sym, orig_r_type, 2351 output_section, data_shndx, 2352 reloc.get_r_offset(), 2353 reloc.get_r_addend()); 2354 } 2355 } 2356 break; 2357 2358 case elfcpp::R_SPARC_WDISP30: 2359 case elfcpp::R_SPARC_WPLT30: 2360 case elfcpp::R_SPARC_WDISP22: 2361 case elfcpp::R_SPARC_WDISP19: 2362 case elfcpp::R_SPARC_WDISP16: 2363 case elfcpp::R_SPARC_WDISP10: 2364 case elfcpp::R_SPARC_DISP8: 2365 case elfcpp::R_SPARC_DISP16: 2366 case elfcpp::R_SPARC_DISP32: 2367 case elfcpp::R_SPARC_DISP64: 2368 case elfcpp::R_SPARC_PC10: 2369 case elfcpp::R_SPARC_PC22: 2370 break; 2371 2372 case elfcpp::R_SPARC_GOTDATA_OP: 2373 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 2374 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 2375 // We will optimize this into a GOT relative relocation 2376 // and code transform the GOT load into an addition. 2377 break; 2378 2379 case elfcpp::R_SPARC_GOT10: 2380 case elfcpp::R_SPARC_GOT13: 2381 case elfcpp::R_SPARC_GOT22: 2382 { 2383 // The symbol requires a GOT entry. 2384 Output_data_got<size, big_endian>* got; 2385 unsigned int r_sym; 2386 2387 got = target->got_section(symtab, layout); 2388 r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2389 2390 // If we are generating a shared object, we need to add a 2391 // dynamic relocation for this symbol's GOT entry. 2392 if (parameters->options().output_is_position_independent()) 2393 { 2394 if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)) 2395 { 2396 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2397 unsigned int off = got->add_constant(0); 2398 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off); 2399 rela_dyn->add_local_relative(object, r_sym, 2400 elfcpp::R_SPARC_RELATIVE, 2401 got, off, 0, is_ifunc); 2402 } 2403 } 2404 else 2405 got->add_local(object, r_sym, GOT_TYPE_STANDARD); 2406 } 2407 break; 2408 2409 // These are initial TLS relocs, which are expected when 2410 // linking. 2411 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2412 case elfcpp::R_SPARC_TLS_GD_LO10: 2413 case elfcpp::R_SPARC_TLS_GD_ADD: 2414 case elfcpp::R_SPARC_TLS_GD_CALL: 2415 case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic 2416 case elfcpp::R_SPARC_TLS_LDM_LO10: 2417 case elfcpp::R_SPARC_TLS_LDM_ADD: 2418 case elfcpp::R_SPARC_TLS_LDM_CALL: 2419 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2420 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2421 case elfcpp::R_SPARC_TLS_LDO_ADD: 2422 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2423 case elfcpp::R_SPARC_TLS_IE_LO10: 2424 case elfcpp::R_SPARC_TLS_IE_LD: 2425 case elfcpp::R_SPARC_TLS_IE_LDX: 2426 case elfcpp::R_SPARC_TLS_IE_ADD: 2427 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec 2428 case elfcpp::R_SPARC_TLS_LE_LOX10: 2429 { 2430 bool output_is_shared = parameters->options().shared(); 2431 const tls::Tls_optimization optimized_type 2432 = optimize_tls_reloc(!output_is_shared, r_type); 2433 switch (r_type) 2434 { 2435 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2436 case elfcpp::R_SPARC_TLS_GD_LO10: 2437 case elfcpp::R_SPARC_TLS_GD_ADD: 2438 case elfcpp::R_SPARC_TLS_GD_CALL: 2439 if (optimized_type == tls::TLSOPT_NONE) 2440 { 2441 // Create a pair of GOT entries for the module index and 2442 // dtv-relative offset. 2443 Output_data_got<size, big_endian>* got 2444 = target->got_section(symtab, layout); 2445 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2446 unsigned int shndx = lsym.get_st_shndx(); 2447 bool is_ordinary; 2448 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary); 2449 if (!is_ordinary) 2450 object->error(_("local symbol %u has bad shndx %u"), 2451 r_sym, shndx); 2452 else 2453 got->add_local_pair_with_rel(object, r_sym, 2454 lsym.get_st_shndx(), 2455 GOT_TYPE_TLS_PAIR, 2456 target->rela_dyn_section(layout), 2457 (size == 64 2458 ? elfcpp::R_SPARC_TLS_DTPMOD64 2459 : elfcpp::R_SPARC_TLS_DTPMOD32)); 2460 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL) 2461 generate_tls_call(symtab, layout, target); 2462 } 2463 else if (optimized_type != tls::TLSOPT_TO_LE) 2464 unsupported_reloc_local(object, r_type); 2465 break; 2466 2467 case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic 2468 case elfcpp::R_SPARC_TLS_LDM_LO10: 2469 case elfcpp::R_SPARC_TLS_LDM_ADD: 2470 case elfcpp::R_SPARC_TLS_LDM_CALL: 2471 if (optimized_type == tls::TLSOPT_NONE) 2472 { 2473 // Create a GOT entry for the module index. 2474 target->got_mod_index_entry(symtab, layout, object); 2475 2476 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL) 2477 generate_tls_call(symtab, layout, target); 2478 } 2479 else if (optimized_type != tls::TLSOPT_TO_LE) 2480 unsupported_reloc_local(object, r_type); 2481 break; 2482 2483 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2484 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2485 case elfcpp::R_SPARC_TLS_LDO_ADD: 2486 break; 2487 2488 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2489 case elfcpp::R_SPARC_TLS_IE_LO10: 2490 case elfcpp::R_SPARC_TLS_IE_LD: 2491 case elfcpp::R_SPARC_TLS_IE_LDX: 2492 case elfcpp::R_SPARC_TLS_IE_ADD: 2493 layout->set_has_static_tls(); 2494 if (optimized_type == tls::TLSOPT_NONE) 2495 { 2496 // Create a GOT entry for the tp-relative offset. 2497 Output_data_got<size, big_endian>* got 2498 = target->got_section(symtab, layout); 2499 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2500 2501 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_OFFSET)) 2502 { 2503 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2504 unsigned int off = got->add_constant(0); 2505 2506 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET, off); 2507 2508 rela_dyn->add_symbolless_local_addend(object, r_sym, 2509 (size == 64 ? 2510 elfcpp::R_SPARC_TLS_TPOFF64 : 2511 elfcpp::R_SPARC_TLS_TPOFF32), 2512 got, off, 0); 2513 } 2514 } 2515 else if (optimized_type != tls::TLSOPT_TO_LE) 2516 unsupported_reloc_local(object, r_type); 2517 break; 2518 2519 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec 2520 case elfcpp::R_SPARC_TLS_LE_LOX10: 2521 layout->set_has_static_tls(); 2522 if (output_is_shared) 2523 { 2524 // We need to create a dynamic relocation. 2525 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION); 2526 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info()); 2527 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2528 rela_dyn->add_symbolless_local_addend(object, r_sym, r_type, 2529 output_section, data_shndx, 2530 reloc.get_r_offset(), 0); 2531 } 2532 break; 2533 } 2534 } 2535 break; 2536 2537 // These are relocations which should only be seen by the 2538 // dynamic linker, and should never be seen here. 2539 case elfcpp::R_SPARC_COPY: 2540 case elfcpp::R_SPARC_GLOB_DAT: 2541 case elfcpp::R_SPARC_JMP_SLOT: 2542 case elfcpp::R_SPARC_JMP_IREL: 2543 case elfcpp::R_SPARC_RELATIVE: 2544 case elfcpp::R_SPARC_IRELATIVE: 2545 case elfcpp::R_SPARC_TLS_DTPMOD64: 2546 case elfcpp::R_SPARC_TLS_DTPMOD32: 2547 case elfcpp::R_SPARC_TLS_DTPOFF64: 2548 case elfcpp::R_SPARC_TLS_DTPOFF32: 2549 case elfcpp::R_SPARC_TLS_TPOFF64: 2550 case elfcpp::R_SPARC_TLS_TPOFF32: 2551 gold_error(_("%s: unexpected reloc %u in object file"), 2552 object->name().c_str(), r_type); 2553 break; 2554 2555 default: 2556 unsupported_reloc_local(object, r_type); 2557 break; 2558 } 2559 } 2560 2561 // Report an unsupported relocation against a global symbol. 2562 2563 template<int size, bool big_endian> 2564 void 2565 Target_sparc<size, big_endian>::Scan::unsupported_reloc_global( 2566 Sized_relobj_file<size, big_endian>* object, 2567 unsigned int r_type, 2568 Symbol* gsym) 2569 { 2570 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 2571 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 2572 } 2573 2574 // Scan a relocation for a global symbol. 2575 2576 template<int size, bool big_endian> 2577 inline void 2578 Target_sparc<size, big_endian>::Scan::global( 2579 Symbol_table* symtab, 2580 Layout* layout, 2581 Target_sparc<size, big_endian>* target, 2582 Sized_relobj_file<size, big_endian>* object, 2583 unsigned int data_shndx, 2584 Output_section* output_section, 2585 const elfcpp::Rela<size, big_endian>& reloc, 2586 unsigned int r_type, 2587 Symbol* gsym) 2588 { 2589 unsigned int orig_r_type = r_type; 2590 bool is_ifunc = gsym->type() == elfcpp::STT_GNU_IFUNC; 2591 2592 // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got 2593 // section. We check here to avoid creating a dynamic reloc against 2594 // _GLOBAL_OFFSET_TABLE_. 2595 if (!target->has_got_section() 2596 && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0) 2597 target->got_section(symtab, layout); 2598 2599 r_type &= 0xff; 2600 2601 // A STT_GNU_IFUNC symbol may require a PLT entry. 2602 if (is_ifunc 2603 && this->reloc_needs_plt_for_ifunc(object, r_type)) 2604 target->make_plt_entry(symtab, layout, gsym); 2605 2606 switch (r_type) 2607 { 2608 case elfcpp::R_SPARC_NONE: 2609 case elfcpp::R_SPARC_REGISTER: 2610 case elfcpp::R_SPARC_GNU_VTINHERIT: 2611 case elfcpp::R_SPARC_GNU_VTENTRY: 2612 break; 2613 2614 case elfcpp::R_SPARC_PLT64: 2615 case elfcpp::R_SPARC_PLT32: 2616 case elfcpp::R_SPARC_HIPLT22: 2617 case elfcpp::R_SPARC_LOPLT10: 2618 case elfcpp::R_SPARC_PCPLT32: 2619 case elfcpp::R_SPARC_PCPLT22: 2620 case elfcpp::R_SPARC_PCPLT10: 2621 case elfcpp::R_SPARC_WPLT30: 2622 // If the symbol is fully resolved, this is just a PC32 reloc. 2623 // Otherwise we need a PLT entry. 2624 if (gsym->final_value_is_known()) 2625 break; 2626 // If building a shared library, we can also skip the PLT entry 2627 // if the symbol is defined in the output file and is protected 2628 // or hidden. 2629 if (gsym->is_defined() 2630 && !gsym->is_from_dynobj() 2631 && !gsym->is_preemptible()) 2632 break; 2633 target->make_plt_entry(symtab, layout, gsym); 2634 break; 2635 2636 case elfcpp::R_SPARC_DISP8: 2637 case elfcpp::R_SPARC_DISP16: 2638 case elfcpp::R_SPARC_DISP32: 2639 case elfcpp::R_SPARC_DISP64: 2640 case elfcpp::R_SPARC_PC_HH22: 2641 case elfcpp::R_SPARC_PC_HM10: 2642 case elfcpp::R_SPARC_PC_LM22: 2643 case elfcpp::R_SPARC_PC10: 2644 case elfcpp::R_SPARC_PC22: 2645 case elfcpp::R_SPARC_WDISP30: 2646 case elfcpp::R_SPARC_WDISP22: 2647 case elfcpp::R_SPARC_WDISP19: 2648 case elfcpp::R_SPARC_WDISP16: 2649 case elfcpp::R_SPARC_WDISP10: 2650 { 2651 if (gsym->needs_plt_entry()) 2652 target->make_plt_entry(symtab, layout, gsym); 2653 // Make a dynamic relocation if necessary. 2654 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 2655 { 2656 if (parameters->options().output_is_executable() 2657 && gsym->may_need_copy_reloc()) 2658 { 2659 target->copy_reloc(symtab, layout, object, 2660 data_shndx, output_section, gsym, 2661 reloc); 2662 } 2663 else 2664 { 2665 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2666 check_non_pic(object, r_type); 2667 rela_dyn->add_global(gsym, orig_r_type, output_section, object, 2668 data_shndx, reloc.get_r_offset(), 2669 reloc.get_r_addend()); 2670 } 2671 } 2672 } 2673 break; 2674 2675 case elfcpp::R_SPARC_UA64: 2676 case elfcpp::R_SPARC_64: 2677 case elfcpp::R_SPARC_HIX22: 2678 case elfcpp::R_SPARC_LOX10: 2679 case elfcpp::R_SPARC_H34: 2680 case elfcpp::R_SPARC_H44: 2681 case elfcpp::R_SPARC_M44: 2682 case elfcpp::R_SPARC_L44: 2683 case elfcpp::R_SPARC_HH22: 2684 case elfcpp::R_SPARC_HM10: 2685 case elfcpp::R_SPARC_LM22: 2686 case elfcpp::R_SPARC_HI22: 2687 case elfcpp::R_SPARC_LO10: 2688 case elfcpp::R_SPARC_OLO10: 2689 case elfcpp::R_SPARC_UA32: 2690 case elfcpp::R_SPARC_32: 2691 case elfcpp::R_SPARC_UA16: 2692 case elfcpp::R_SPARC_16: 2693 case elfcpp::R_SPARC_11: 2694 case elfcpp::R_SPARC_10: 2695 case elfcpp::R_SPARC_8: 2696 case elfcpp::R_SPARC_7: 2697 case elfcpp::R_SPARC_6: 2698 case elfcpp::R_SPARC_5: 2699 { 2700 // Make a PLT entry if necessary. 2701 if (gsym->needs_plt_entry()) 2702 { 2703 target->make_plt_entry(symtab, layout, gsym); 2704 // Since this is not a PC-relative relocation, we may be 2705 // taking the address of a function. In that case we need to 2706 // set the entry in the dynamic symbol table to the address of 2707 // the PLT entry. 2708 if (gsym->is_from_dynobj() && !parameters->options().shared()) 2709 gsym->set_needs_dynsym_value(); 2710 } 2711 // Make a dynamic relocation if necessary. 2712 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 2713 { 2714 unsigned int r_off = reloc.get_r_offset(); 2715 2716 // The assembler can sometimes emit unaligned relocations 2717 // for dwarf2 cfi directives. 2718 switch (r_type) 2719 { 2720 case elfcpp::R_SPARC_16: 2721 if (r_off & 0x1) 2722 orig_r_type = r_type = elfcpp::R_SPARC_UA16; 2723 break; 2724 case elfcpp::R_SPARC_32: 2725 if (r_off & 0x3) 2726 orig_r_type = r_type = elfcpp::R_SPARC_UA32; 2727 break; 2728 case elfcpp::R_SPARC_64: 2729 if (r_off & 0x7) 2730 orig_r_type = r_type = elfcpp::R_SPARC_UA64; 2731 break; 2732 case elfcpp::R_SPARC_UA16: 2733 if (!(r_off & 0x1)) 2734 orig_r_type = r_type = elfcpp::R_SPARC_16; 2735 break; 2736 case elfcpp::R_SPARC_UA32: 2737 if (!(r_off & 0x3)) 2738 orig_r_type = r_type = elfcpp::R_SPARC_32; 2739 break; 2740 case elfcpp::R_SPARC_UA64: 2741 if (!(r_off & 0x7)) 2742 orig_r_type = r_type = elfcpp::R_SPARC_64; 2743 break; 2744 } 2745 2746 if (!parameters->options().output_is_position_independent() 2747 && gsym->may_need_copy_reloc()) 2748 { 2749 target->copy_reloc(symtab, layout, object, 2750 data_shndx, output_section, gsym, reloc); 2751 } 2752 else if (((size == 64 && r_type == elfcpp::R_SPARC_64) 2753 || (size == 32 && r_type == elfcpp::R_SPARC_32)) 2754 && gsym->type() == elfcpp::STT_GNU_IFUNC 2755 && gsym->can_use_relative_reloc(false) 2756 && !gsym->is_from_dynobj() 2757 && !gsym->is_undefined() 2758 && !gsym->is_preemptible()) 2759 { 2760 // Use an IRELATIVE reloc for a locally defined 2761 // STT_GNU_IFUNC symbol. This makes a function 2762 // address in a PIE executable match the address in a 2763 // shared library that it links against. 2764 Reloc_section* rela_dyn = 2765 target->rela_ifunc_section(layout); 2766 unsigned int r_type = elfcpp::R_SPARC_IRELATIVE; 2767 rela_dyn->add_symbolless_global_addend(gsym, r_type, 2768 output_section, object, 2769 data_shndx, 2770 reloc.get_r_offset(), 2771 reloc.get_r_addend()); 2772 } 2773 else if (((size == 64 && r_type == elfcpp::R_SPARC_64) 2774 || (size == 32 && r_type == elfcpp::R_SPARC_32)) 2775 && gsym->can_use_relative_reloc(false)) 2776 { 2777 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2778 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE, 2779 output_section, object, 2780 data_shndx, reloc.get_r_offset(), 2781 reloc.get_r_addend(), is_ifunc); 2782 } 2783 else 2784 { 2785 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2786 2787 check_non_pic(object, r_type); 2788 if (gsym->is_from_dynobj() 2789 || gsym->is_undefined() 2790 || gsym->is_preemptible()) 2791 rela_dyn->add_global(gsym, orig_r_type, output_section, 2792 object, data_shndx, 2793 reloc.get_r_offset(), 2794 reloc.get_r_addend()); 2795 else 2796 rela_dyn->add_symbolless_global_addend(gsym, orig_r_type, 2797 output_section, 2798 object, data_shndx, 2799 reloc.get_r_offset(), 2800 reloc.get_r_addend()); 2801 } 2802 } 2803 } 2804 break; 2805 2806 case elfcpp::R_SPARC_GOTDATA_OP: 2807 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 2808 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 2809 if (gsym->is_defined() 2810 && !gsym->is_from_dynobj() 2811 && !gsym->is_preemptible() 2812 && !is_ifunc) 2813 { 2814 // We will optimize this into a GOT relative relocation 2815 // and code transform the GOT load into an addition. 2816 break; 2817 } 2818 case elfcpp::R_SPARC_GOT10: 2819 case elfcpp::R_SPARC_GOT13: 2820 case elfcpp::R_SPARC_GOT22: 2821 { 2822 // The symbol requires a GOT entry. 2823 Output_data_got<size, big_endian>* got; 2824 2825 got = target->got_section(symtab, layout); 2826 if (gsym->final_value_is_known()) 2827 { 2828 // For a STT_GNU_IFUNC symbol we want the PLT address. 2829 if (gsym->type() == elfcpp::STT_GNU_IFUNC) 2830 got->add_global_plt(gsym, GOT_TYPE_STANDARD); 2831 else 2832 got->add_global(gsym, GOT_TYPE_STANDARD); 2833 } 2834 else 2835 { 2836 // If this symbol is not fully resolved, we need to add a 2837 // GOT entry with a dynamic relocation. 2838 bool is_ifunc = gsym->type() == elfcpp::STT_GNU_IFUNC; 2839 2840 // Use a GLOB_DAT rather than a RELATIVE reloc if: 2841 // 2842 // 1) The symbol may be defined in some other module. 2843 // 2844 // 2) We are building a shared library and this is a 2845 // protected symbol; using GLOB_DAT means that the dynamic 2846 // linker can use the address of the PLT in the main 2847 // executable when appropriate so that function address 2848 // comparisons work. 2849 // 2850 // 3) This is a STT_GNU_IFUNC symbol in position dependent 2851 // code, again so that function address comparisons work. 2852 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2853 if (gsym->is_from_dynobj() 2854 || gsym->is_undefined() 2855 || gsym->is_preemptible() 2856 || (gsym->visibility() == elfcpp::STV_PROTECTED 2857 && parameters->options().shared()) 2858 || (gsym->type() == elfcpp::STT_GNU_IFUNC 2859 && parameters->options().output_is_position_independent() 2860 && !gsym->is_forced_local())) 2861 { 2862 unsigned int r_type = elfcpp::R_SPARC_GLOB_DAT; 2863 2864 // If this symbol is forced local, this relocation will 2865 // not work properly. That's because ld.so on sparc 2866 // (and 32-bit powerpc) expects st_value in the r_addend 2867 // of relocations for STB_LOCAL symbols. Curiously the 2868 // BFD linker does not promote global hidden symbols to be 2869 // STB_LOCAL in the dynamic symbol table like Gold does. 2870 gold_assert(!gsym->is_forced_local()); 2871 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, rela_dyn, 2872 r_type); 2873 } 2874 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD)) 2875 { 2876 unsigned int off = got->add_constant(0); 2877 2878 gsym->set_got_offset(GOT_TYPE_STANDARD, off); 2879 if (is_ifunc) 2880 { 2881 // Tell the dynamic linker to use the PLT address 2882 // when resolving relocations. 2883 if (gsym->is_from_dynobj() 2884 && !parameters->options().shared()) 2885 gsym->set_needs_dynsym_value(); 2886 } 2887 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE, 2888 got, off, 0, is_ifunc); 2889 } 2890 } 2891 } 2892 break; 2893 2894 // These are initial tls relocs, which are expected when 2895 // linking. 2896 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2897 case elfcpp::R_SPARC_TLS_GD_LO10: 2898 case elfcpp::R_SPARC_TLS_GD_ADD: 2899 case elfcpp::R_SPARC_TLS_GD_CALL: 2900 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic 2901 case elfcpp::R_SPARC_TLS_LDM_LO10: 2902 case elfcpp::R_SPARC_TLS_LDM_ADD: 2903 case elfcpp::R_SPARC_TLS_LDM_CALL: 2904 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2905 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2906 case elfcpp::R_SPARC_TLS_LDO_ADD: 2907 case elfcpp::R_SPARC_TLS_LE_HIX22: 2908 case elfcpp::R_SPARC_TLS_LE_LOX10: 2909 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2910 case elfcpp::R_SPARC_TLS_IE_LO10: 2911 case elfcpp::R_SPARC_TLS_IE_LD: 2912 case elfcpp::R_SPARC_TLS_IE_LDX: 2913 case elfcpp::R_SPARC_TLS_IE_ADD: 2914 { 2915 const bool is_final = gsym->final_value_is_known(); 2916 const tls::Tls_optimization optimized_type 2917 = optimize_tls_reloc(is_final, r_type); 2918 switch (r_type) 2919 { 2920 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2921 case elfcpp::R_SPARC_TLS_GD_LO10: 2922 case elfcpp::R_SPARC_TLS_GD_ADD: 2923 case elfcpp::R_SPARC_TLS_GD_CALL: 2924 if (optimized_type == tls::TLSOPT_NONE) 2925 { 2926 // Create a pair of GOT entries for the module index and 2927 // dtv-relative offset. 2928 Output_data_got<size, big_endian>* got 2929 = target->got_section(symtab, layout); 2930 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR, 2931 target->rela_dyn_section(layout), 2932 (size == 64 2933 ? elfcpp::R_SPARC_TLS_DTPMOD64 2934 : elfcpp::R_SPARC_TLS_DTPMOD32), 2935 (size == 64 2936 ? elfcpp::R_SPARC_TLS_DTPOFF64 2937 : elfcpp::R_SPARC_TLS_DTPOFF32)); 2938 2939 // Emit R_SPARC_WPLT30 against "__tls_get_addr" 2940 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL) 2941 generate_tls_call(symtab, layout, target); 2942 } 2943 else if (optimized_type == tls::TLSOPT_TO_IE) 2944 { 2945 // Create a GOT entry for the tp-relative offset. 2946 Output_data_got<size, big_endian>* got 2947 = target->got_section(symtab, layout); 2948 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 2949 target->rela_dyn_section(layout), 2950 (size == 64 ? 2951 elfcpp::R_SPARC_TLS_TPOFF64 : 2952 elfcpp::R_SPARC_TLS_TPOFF32)); 2953 } 2954 else if (optimized_type != tls::TLSOPT_TO_LE) 2955 unsupported_reloc_global(object, r_type, gsym); 2956 break; 2957 2958 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic 2959 case elfcpp::R_SPARC_TLS_LDM_LO10: 2960 case elfcpp::R_SPARC_TLS_LDM_ADD: 2961 case elfcpp::R_SPARC_TLS_LDM_CALL: 2962 if (optimized_type == tls::TLSOPT_NONE) 2963 { 2964 // Create a GOT entry for the module index. 2965 target->got_mod_index_entry(symtab, layout, object); 2966 2967 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL) 2968 generate_tls_call(symtab, layout, target); 2969 } 2970 else if (optimized_type != tls::TLSOPT_TO_LE) 2971 unsupported_reloc_global(object, r_type, gsym); 2972 break; 2973 2974 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2975 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2976 case elfcpp::R_SPARC_TLS_LDO_ADD: 2977 break; 2978 2979 case elfcpp::R_SPARC_TLS_LE_HIX22: 2980 case elfcpp::R_SPARC_TLS_LE_LOX10: 2981 layout->set_has_static_tls(); 2982 if (parameters->options().shared()) 2983 { 2984 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2985 rela_dyn->add_symbolless_global_addend(gsym, orig_r_type, 2986 output_section, object, 2987 data_shndx, reloc.get_r_offset(), 2988 0); 2989 } 2990 break; 2991 2992 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2993 case elfcpp::R_SPARC_TLS_IE_LO10: 2994 case elfcpp::R_SPARC_TLS_IE_LD: 2995 case elfcpp::R_SPARC_TLS_IE_LDX: 2996 case elfcpp::R_SPARC_TLS_IE_ADD: 2997 layout->set_has_static_tls(); 2998 if (optimized_type == tls::TLSOPT_NONE) 2999 { 3000 // Create a GOT entry for the tp-relative offset. 3001 Output_data_got<size, big_endian>* got 3002 = target->got_section(symtab, layout); 3003 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 3004 target->rela_dyn_section(layout), 3005 (size == 64 3006 ? elfcpp::R_SPARC_TLS_TPOFF64 3007 : elfcpp::R_SPARC_TLS_TPOFF32)); 3008 } 3009 else if (optimized_type != tls::TLSOPT_TO_LE) 3010 unsupported_reloc_global(object, r_type, gsym); 3011 break; 3012 } 3013 } 3014 break; 3015 3016 // These are relocations which should only be seen by the 3017 // dynamic linker, and should never be seen here. 3018 case elfcpp::R_SPARC_COPY: 3019 case elfcpp::R_SPARC_GLOB_DAT: 3020 case elfcpp::R_SPARC_JMP_SLOT: 3021 case elfcpp::R_SPARC_JMP_IREL: 3022 case elfcpp::R_SPARC_RELATIVE: 3023 case elfcpp::R_SPARC_IRELATIVE: 3024 case elfcpp::R_SPARC_TLS_DTPMOD64: 3025 case elfcpp::R_SPARC_TLS_DTPMOD32: 3026 case elfcpp::R_SPARC_TLS_DTPOFF64: 3027 case elfcpp::R_SPARC_TLS_DTPOFF32: 3028 case elfcpp::R_SPARC_TLS_TPOFF64: 3029 case elfcpp::R_SPARC_TLS_TPOFF32: 3030 gold_error(_("%s: unexpected reloc %u in object file"), 3031 object->name().c_str(), r_type); 3032 break; 3033 3034 default: 3035 unsupported_reloc_global(object, r_type, gsym); 3036 break; 3037 } 3038 } 3039 3040 // Make a new symbol table entry. 3041 // STT_SPARC_REGISTER symbols require special handling, 3042 // so we intercept these symbols and keep track of them separately. 3043 // We will resolve register symbols here and output them at symbol 3044 // finalization time. 3045 3046 template<int size, bool big_endian> 3047 Sized_symbol<size>* 3048 Target_sparc<size, big_endian>::make_symbol(const char* name, 3049 elfcpp::STT type, 3050 Object* object, 3051 unsigned int shndx, 3052 uint64_t value) 3053 { 3054 // REGISTER symbols are used only on SPARC-64. 3055 if (size == 64 && type == elfcpp::STT_SPARC_REGISTER) 3056 { 3057 // Ignore REGISTER symbols in dynamic objects. 3058 if (object->is_dynamic()) 3059 return NULL; 3060 // Only registers 2, 3, 6, and 7 can be declared global. 3061 int reg = value; 3062 switch (reg) 3063 { 3064 case 2: case 3: 3065 reg -= 2; 3066 break; 3067 case 6: case 7: 3068 reg -= 4; 3069 break; 3070 default: 3071 gold_error(_("%s: only registers %%g[2367] can be declared " 3072 "using STT_REGISTER"), 3073 object->name().c_str()); 3074 return NULL; 3075 } 3076 Register_symbol& rsym = this->register_syms_[reg]; 3077 if (rsym.name == NULL) 3078 { 3079 rsym.name = name; 3080 rsym.shndx = shndx; 3081 rsym.obj = object; 3082 } 3083 else 3084 { 3085 if (strcmp(rsym.name, name) != 0) 3086 { 3087 gold_error(_("%s: register %%g%d declared as '%s'; " 3088 "previously declared as '%s' in %s"), 3089 object->name().c_str(), 3090 static_cast<int>(value), 3091 *name ? name : "#scratch", 3092 *rsym.name ? rsym.name : "#scratch", 3093 rsym.obj->name().c_str()); 3094 return NULL; 3095 } 3096 } 3097 return NULL; 3098 } 3099 return new Sized_symbol<size>(); 3100 } 3101 3102 // Process relocations for gc. 3103 3104 template<int size, bool big_endian> 3105 void 3106 Target_sparc<size, big_endian>::gc_process_relocs( 3107 Symbol_table* symtab, 3108 Layout* layout, 3109 Sized_relobj_file<size, big_endian>* object, 3110 unsigned int data_shndx, 3111 unsigned int, 3112 const unsigned char* prelocs, 3113 size_t reloc_count, 3114 Output_section* output_section, 3115 bool needs_special_offset_handling, 3116 size_t local_symbol_count, 3117 const unsigned char* plocal_symbols) 3118 { 3119 typedef Target_sparc<size, big_endian> Sparc; 3120 typedef typename Target_sparc<size, big_endian>::Scan Scan; 3121 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 3122 Classify_reloc; 3123 3124 gold::gc_process_relocs<size, big_endian, Sparc, Scan, Classify_reloc>( 3125 symtab, 3126 layout, 3127 this, 3128 object, 3129 data_shndx, 3130 prelocs, 3131 reloc_count, 3132 output_section, 3133 needs_special_offset_handling, 3134 local_symbol_count, 3135 plocal_symbols); 3136 } 3137 3138 // Scan relocations for a section. 3139 3140 template<int size, bool big_endian> 3141 void 3142 Target_sparc<size, big_endian>::scan_relocs( 3143 Symbol_table* symtab, 3144 Layout* layout, 3145 Sized_relobj_file<size, big_endian>* object, 3146 unsigned int data_shndx, 3147 unsigned int sh_type, 3148 const unsigned char* prelocs, 3149 size_t reloc_count, 3150 Output_section* output_section, 3151 bool needs_special_offset_handling, 3152 size_t local_symbol_count, 3153 const unsigned char* plocal_symbols) 3154 { 3155 typedef Target_sparc<size, big_endian> Sparc; 3156 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 3157 Classify_reloc; 3158 3159 if (sh_type == elfcpp::SHT_REL) 3160 { 3161 gold_error(_("%s: unsupported REL reloc section"), 3162 object->name().c_str()); 3163 return; 3164 } 3165 3166 gold::scan_relocs<size, big_endian, Sparc, Scan, Classify_reloc>( 3167 symtab, 3168 layout, 3169 this, 3170 object, 3171 data_shndx, 3172 prelocs, 3173 reloc_count, 3174 output_section, 3175 needs_special_offset_handling, 3176 local_symbol_count, 3177 plocal_symbols); 3178 } 3179 3180 // Finalize the sections. 3181 3182 template<int size, bool big_endian> 3183 void 3184 Target_sparc<size, big_endian>::do_finalize_sections( 3185 Layout* layout, 3186 const Input_objects*, 3187 Symbol_table* symtab) 3188 { 3189 if (this->plt_) 3190 this->plt_->emit_pending_ifunc_relocs(); 3191 3192 // Fill in some more dynamic tags. 3193 const Reloc_section* rel_plt = (this->plt_ == NULL 3194 ? NULL 3195 : this->plt_->rel_plt()); 3196 layout->add_target_dynamic_tags(false, this->plt_, rel_plt, 3197 this->rela_dyn_, true, true); 3198 3199 // Emit any relocs we saved in an attempt to avoid generating COPY 3200 // relocs. 3201 if (this->copy_relocs_.any_saved_relocs()) 3202 this->copy_relocs_.emit(this->rela_dyn_section(layout)); 3203 3204 if (parameters->doing_static_link() 3205 && (this->plt_ == NULL || !this->plt_->has_ifunc_section())) 3206 { 3207 // If linking statically, make sure that the __rela_iplt symbols 3208 // were defined if necessary, even if we didn't create a PLT. 3209 static const Define_symbol_in_segment syms[] = 3210 { 3211 { 3212 "__rela_iplt_start", // name 3213 elfcpp::PT_LOAD, // segment_type 3214 elfcpp::PF_W, // segment_flags_set 3215 elfcpp::PF(0), // segment_flags_clear 3216 0, // value 3217 0, // size 3218 elfcpp::STT_NOTYPE, // type 3219 elfcpp::STB_GLOBAL, // binding 3220 elfcpp::STV_HIDDEN, // visibility 3221 0, // nonvis 3222 Symbol::SEGMENT_START, // offset_from_base 3223 true // only_if_ref 3224 }, 3225 { 3226 "__rela_iplt_end", // name 3227 elfcpp::PT_LOAD, // segment_type 3228 elfcpp::PF_W, // segment_flags_set 3229 elfcpp::PF(0), // segment_flags_clear 3230 0, // value 3231 0, // size 3232 elfcpp::STT_NOTYPE, // type 3233 elfcpp::STB_GLOBAL, // binding 3234 elfcpp::STV_HIDDEN, // visibility 3235 0, // nonvis 3236 Symbol::SEGMENT_START, // offset_from_base 3237 true // only_if_ref 3238 } 3239 }; 3240 3241 symtab->define_symbols(layout, 2, syms, 3242 layout->script_options()->saw_sections_clause()); 3243 } 3244 3245 for (int reg = 0; reg < 4; ++reg) 3246 { 3247 Register_symbol& rsym = this->register_syms_[reg]; 3248 if (rsym.name != NULL) 3249 { 3250 int value = reg < 3 ? reg + 2 : reg + 4; 3251 Sized_symbol<size>* sym = new Sized_symbol<size>(); 3252 if (rsym.shndx == elfcpp::SHN_UNDEF) 3253 sym->init_undefined(rsym.name, NULL, value, 3254 elfcpp::STT_SPARC_REGISTER, elfcpp::STB_GLOBAL, 3255 elfcpp::STV_DEFAULT, 0); 3256 else 3257 sym->init_constant(rsym.name, NULL, value, 0, 3258 elfcpp::STT_SPARC_REGISTER, elfcpp::STB_GLOBAL, 3259 elfcpp::STV_DEFAULT, 0, false); 3260 symtab->add_target_global_symbol(sym); 3261 layout->add_target_specific_dynamic_tag(elfcpp::DT_SPARC_REGISTER, 3262 value); 3263 } 3264 } 3265 } 3266 3267 // Perform a relocation. 3268 3269 template<int size, bool big_endian> 3270 inline bool 3271 Target_sparc<size, big_endian>::Relocate::relocate( 3272 const Relocate_info<size, big_endian>* relinfo, 3273 unsigned int, 3274 Target_sparc* target, 3275 Output_section*, 3276 size_t relnum, 3277 const unsigned char* preloc, 3278 const Sized_symbol<size>* gsym, 3279 const Symbol_value<size>* psymval, 3280 unsigned char* view, 3281 typename elfcpp::Elf_types<size>::Elf_Addr address, 3282 section_size_type view_size) 3283 { 3284 const elfcpp::Rela<size, big_endian> rela(preloc); 3285 unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info()); 3286 bool orig_is_ifunc = psymval->is_ifunc_symbol(); 3287 r_type &= 0xff; 3288 3289 if (this->ignore_gd_add_) 3290 { 3291 if (r_type != elfcpp::R_SPARC_TLS_GD_ADD) 3292 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3293 _("missing expected TLS relocation")); 3294 else 3295 { 3296 this->ignore_gd_add_ = false; 3297 return false; 3298 } 3299 } 3300 3301 if (view == NULL) 3302 return true; 3303 3304 if (this->reloc_adjust_addr_ == view) 3305 view -= 4; 3306 3307 typedef Sparc_relocate_functions<size, big_endian> Reloc; 3308 const Sized_relobj_file<size, big_endian>* object = relinfo->object; 3309 3310 // Pick the value to use for symbols defined in shared objects. 3311 Symbol_value<size> symval; 3312 if (gsym != NULL 3313 && gsym->use_plt_offset(Scan::get_reference_flags(r_type))) 3314 { 3315 elfcpp::Elf_Xword value; 3316 3317 value = target->plt_address_for_global(gsym); 3318 3319 symval.set_output_value(value); 3320 3321 psymval = &symval; 3322 } 3323 else if (gsym == NULL && orig_is_ifunc) 3324 { 3325 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 3326 if (object->local_has_plt_offset(r_sym)) 3327 { 3328 symval.set_output_value(target->plt_address_for_local(object, r_sym)); 3329 psymval = &symval; 3330 } 3331 } 3332 3333 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 3334 3335 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT 3336 // pointer points to the beginning, not the end, of the table. 3337 // So we just use the plain offset. 3338 unsigned int got_offset = 0; 3339 bool gdop_valid = false; 3340 switch (r_type) 3341 { 3342 case elfcpp::R_SPARC_GOTDATA_OP: 3343 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 3344 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 3345 // If this is local, we did not create a GOT entry because we 3346 // intend to transform this into a GOT relative relocation. 3347 if (gsym == NULL 3348 || (gsym->is_defined() 3349 && !gsym->is_from_dynobj() 3350 && !gsym->is_preemptible() 3351 && !orig_is_ifunc)) 3352 { 3353 got_offset = psymval->value(object, addend) - target->got_address(); 3354 gdop_valid = true; 3355 break; 3356 } 3357 case elfcpp::R_SPARC_GOT10: 3358 case elfcpp::R_SPARC_GOT13: 3359 case elfcpp::R_SPARC_GOT22: 3360 if (gsym != NULL) 3361 { 3362 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 3363 got_offset = gsym->got_offset(GOT_TYPE_STANDARD); 3364 } 3365 else 3366 { 3367 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 3368 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 3369 got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 3370 } 3371 break; 3372 3373 default: 3374 break; 3375 } 3376 3377 switch (r_type) 3378 { 3379 case elfcpp::R_SPARC_NONE: 3380 case elfcpp::R_SPARC_REGISTER: 3381 case elfcpp::R_SPARC_GNU_VTINHERIT: 3382 case elfcpp::R_SPARC_GNU_VTENTRY: 3383 break; 3384 3385 case elfcpp::R_SPARC_8: 3386 Relocate_functions<size, big_endian>::rela8(view, object, 3387 psymval, addend); 3388 break; 3389 3390 case elfcpp::R_SPARC_16: 3391 if (rela.get_r_offset() & 0x1) 3392 { 3393 // The assembler can sometimes emit unaligned relocations 3394 // for dwarf2 cfi directives. 3395 Reloc::ua16(view, object, psymval, addend); 3396 } 3397 else 3398 Relocate_functions<size, big_endian>::rela16(view, object, 3399 psymval, addend); 3400 break; 3401 3402 case elfcpp::R_SPARC_32: 3403 if (!parameters->options().output_is_position_independent()) 3404 { 3405 if (rela.get_r_offset() & 0x3) 3406 { 3407 // The assembler can sometimes emit unaligned relocations 3408 // for dwarf2 cfi directives. 3409 Reloc::ua32(view, object, psymval, addend); 3410 } 3411 else 3412 Relocate_functions<size, big_endian>::rela32(view, object, 3413 psymval, addend); 3414 } 3415 break; 3416 3417 case elfcpp::R_SPARC_DISP8: 3418 Reloc::disp8(view, object, psymval, addend, address); 3419 break; 3420 3421 case elfcpp::R_SPARC_DISP16: 3422 Reloc::disp16(view, object, psymval, addend, address); 3423 break; 3424 3425 case elfcpp::R_SPARC_DISP32: 3426 Reloc::disp32(view, object, psymval, addend, address); 3427 break; 3428 3429 case elfcpp::R_SPARC_DISP64: 3430 Reloc::disp64(view, object, psymval, addend, address); 3431 break; 3432 3433 case elfcpp::R_SPARC_WDISP30: 3434 case elfcpp::R_SPARC_WPLT30: 3435 Reloc::wdisp30(view, object, psymval, addend, address); 3436 if (target->may_relax()) 3437 relax_call(target, view, rela, view_size); 3438 break; 3439 3440 case elfcpp::R_SPARC_WDISP22: 3441 Reloc::wdisp22(view, object, psymval, addend, address); 3442 break; 3443 3444 case elfcpp::R_SPARC_WDISP19: 3445 Reloc::wdisp19(view, object, psymval, addend, address); 3446 break; 3447 3448 case elfcpp::R_SPARC_WDISP16: 3449 Reloc::wdisp16(view, object, psymval, addend, address); 3450 break; 3451 3452 case elfcpp::R_SPARC_WDISP10: 3453 Reloc::wdisp10(view, object, psymval, addend, address); 3454 break; 3455 3456 case elfcpp::R_SPARC_HI22: 3457 Reloc::hi22(view, object, psymval, addend); 3458 break; 3459 3460 case elfcpp::R_SPARC_22: 3461 Reloc::rela32_22(view, object, psymval, addend); 3462 break; 3463 3464 case elfcpp::R_SPARC_13: 3465 Reloc::rela32_13(view, object, psymval, addend); 3466 break; 3467 3468 case elfcpp::R_SPARC_LO10: 3469 Reloc::lo10(view, object, psymval, addend); 3470 break; 3471 3472 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 3473 if (gdop_valid) 3474 { 3475 Reloc::gdop_lox10(view, got_offset); 3476 break; 3477 } 3478 /* Fall through. */ 3479 case elfcpp::R_SPARC_GOT10: 3480 Reloc::lo10(view, got_offset, addend); 3481 break; 3482 3483 case elfcpp::R_SPARC_GOTDATA_OP: 3484 if (gdop_valid) 3485 { 3486 typedef typename elfcpp::Swap<32, true>::Valtype Insntype; 3487 Insntype* wv = reinterpret_cast<Insntype*>(view); 3488 Insntype val; 3489 3490 // {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd 3491 val = elfcpp::Swap<32, true>::readval(wv); 3492 val = 0x80000000 | (val & 0x3e07c01f); 3493 elfcpp::Swap<32, true>::writeval(wv, val); 3494 } 3495 break; 3496 3497 case elfcpp::R_SPARC_GOT13: 3498 Reloc::rela32_13(view, got_offset, addend); 3499 break; 3500 3501 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 3502 if (gdop_valid) 3503 { 3504 Reloc::gdop_hix22(view, got_offset); 3505 break; 3506 } 3507 /* Fall through. */ 3508 case elfcpp::R_SPARC_GOT22: 3509 Reloc::hi22(view, got_offset, addend); 3510 break; 3511 3512 case elfcpp::R_SPARC_PC10: 3513 Reloc::pc10(view, object, psymval, addend, address); 3514 break; 3515 3516 case elfcpp::R_SPARC_PC22: 3517 Reloc::pc22(view, object, psymval, addend, address); 3518 break; 3519 3520 case elfcpp::R_SPARC_TLS_DTPOFF32: 3521 case elfcpp::R_SPARC_UA32: 3522 Reloc::ua32(view, object, psymval, addend); 3523 break; 3524 3525 case elfcpp::R_SPARC_PLT64: 3526 Relocate_functions<size, big_endian>::rela64(view, object, 3527 psymval, addend); 3528 break; 3529 3530 case elfcpp::R_SPARC_PLT32: 3531 Relocate_functions<size, big_endian>::rela32(view, object, 3532 psymval, addend); 3533 break; 3534 3535 case elfcpp::R_SPARC_HIPLT22: 3536 Reloc::hi22(view, object, psymval, addend); 3537 break; 3538 3539 case elfcpp::R_SPARC_LOPLT10: 3540 Reloc::lo10(view, object, psymval, addend); 3541 break; 3542 3543 case elfcpp::R_SPARC_PCPLT32: 3544 Reloc::disp32(view, object, psymval, addend, address); 3545 break; 3546 3547 case elfcpp::R_SPARC_PCPLT22: 3548 Reloc::pcplt22(view, object, psymval, addend, address); 3549 break; 3550 3551 case elfcpp::R_SPARC_PCPLT10: 3552 Reloc::lo10(view, object, psymval, addend, address); 3553 break; 3554 3555 case elfcpp::R_SPARC_64: 3556 if (!parameters->options().output_is_position_independent()) 3557 { 3558 if (rela.get_r_offset() & 0x7) 3559 { 3560 // The assembler can sometimes emit unaligned relocations 3561 // for dwarf2 cfi directives. 3562 Reloc::ua64(view, object, psymval, addend); 3563 } 3564 else 3565 Relocate_functions<size, big_endian>::rela64(view, object, 3566 psymval, addend); 3567 } 3568 break; 3569 3570 case elfcpp::R_SPARC_OLO10: 3571 { 3572 unsigned int addend2 = rela.get_r_info() & 0xffffffff; 3573 addend2 = ((addend2 >> 8) ^ 0x800000) - 0x800000; 3574 Reloc::olo10(view, object, psymval, addend, addend2); 3575 } 3576 break; 3577 3578 case elfcpp::R_SPARC_HH22: 3579 Reloc::hh22(view, object, psymval, addend); 3580 break; 3581 3582 case elfcpp::R_SPARC_PC_HH22: 3583 Reloc::pc_hh22(view, object, psymval, addend, address); 3584 break; 3585 3586 case elfcpp::R_SPARC_HM10: 3587 Reloc::hm10(view, object, psymval, addend); 3588 break; 3589 3590 case elfcpp::R_SPARC_PC_HM10: 3591 Reloc::pc_hm10(view, object, psymval, addend, address); 3592 break; 3593 3594 case elfcpp::R_SPARC_LM22: 3595 Reloc::hi22(view, object, psymval, addend); 3596 break; 3597 3598 case elfcpp::R_SPARC_PC_LM22: 3599 Reloc::pcplt22(view, object, psymval, addend, address); 3600 break; 3601 3602 case elfcpp::R_SPARC_11: 3603 Reloc::rela32_11(view, object, psymval, addend); 3604 break; 3605 3606 case elfcpp::R_SPARC_10: 3607 Reloc::rela32_10(view, object, psymval, addend); 3608 break; 3609 3610 case elfcpp::R_SPARC_7: 3611 Reloc::rela32_7(view, object, psymval, addend); 3612 break; 3613 3614 case elfcpp::R_SPARC_6: 3615 Reloc::rela32_6(view, object, psymval, addend); 3616 break; 3617 3618 case elfcpp::R_SPARC_5: 3619 Reloc::rela32_5(view, object, psymval, addend); 3620 break; 3621 3622 case elfcpp::R_SPARC_HIX22: 3623 Reloc::hix22(view, object, psymval, addend); 3624 break; 3625 3626 case elfcpp::R_SPARC_LOX10: 3627 Reloc::lox10(view, object, psymval, addend); 3628 break; 3629 3630 case elfcpp::R_SPARC_H34: 3631 Reloc::h34(view, object, psymval, addend); 3632 break; 3633 3634 case elfcpp::R_SPARC_H44: 3635 Reloc::h44(view, object, psymval, addend); 3636 break; 3637 3638 case elfcpp::R_SPARC_M44: 3639 Reloc::m44(view, object, psymval, addend); 3640 break; 3641 3642 case elfcpp::R_SPARC_L44: 3643 Reloc::l44(view, object, psymval, addend); 3644 break; 3645 3646 case elfcpp::R_SPARC_TLS_DTPOFF64: 3647 case elfcpp::R_SPARC_UA64: 3648 Reloc::ua64(view, object, psymval, addend); 3649 break; 3650 3651 case elfcpp::R_SPARC_UA16: 3652 Reloc::ua16(view, object, psymval, addend); 3653 break; 3654 3655 case elfcpp::R_SPARC_TLS_GD_HI22: 3656 case elfcpp::R_SPARC_TLS_GD_LO10: 3657 case elfcpp::R_SPARC_TLS_GD_ADD: 3658 case elfcpp::R_SPARC_TLS_GD_CALL: 3659 case elfcpp::R_SPARC_TLS_LDM_HI22: 3660 case elfcpp::R_SPARC_TLS_LDM_LO10: 3661 case elfcpp::R_SPARC_TLS_LDM_ADD: 3662 case elfcpp::R_SPARC_TLS_LDM_CALL: 3663 case elfcpp::R_SPARC_TLS_LDO_HIX22: 3664 case elfcpp::R_SPARC_TLS_LDO_LOX10: 3665 case elfcpp::R_SPARC_TLS_LDO_ADD: 3666 case elfcpp::R_SPARC_TLS_IE_HI22: 3667 case elfcpp::R_SPARC_TLS_IE_LO10: 3668 case elfcpp::R_SPARC_TLS_IE_LD: 3669 case elfcpp::R_SPARC_TLS_IE_LDX: 3670 case elfcpp::R_SPARC_TLS_IE_ADD: 3671 case elfcpp::R_SPARC_TLS_LE_HIX22: 3672 case elfcpp::R_SPARC_TLS_LE_LOX10: 3673 this->relocate_tls(relinfo, target, relnum, rela, 3674 r_type, gsym, psymval, view, 3675 address, view_size); 3676 break; 3677 3678 case elfcpp::R_SPARC_COPY: 3679 case elfcpp::R_SPARC_GLOB_DAT: 3680 case elfcpp::R_SPARC_JMP_SLOT: 3681 case elfcpp::R_SPARC_JMP_IREL: 3682 case elfcpp::R_SPARC_RELATIVE: 3683 case elfcpp::R_SPARC_IRELATIVE: 3684 // These are outstanding tls relocs, which are unexpected when 3685 // linking. 3686 case elfcpp::R_SPARC_TLS_DTPMOD64: 3687 case elfcpp::R_SPARC_TLS_DTPMOD32: 3688 case elfcpp::R_SPARC_TLS_TPOFF64: 3689 case elfcpp::R_SPARC_TLS_TPOFF32: 3690 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3691 _("unexpected reloc %u in object file"), 3692 r_type); 3693 break; 3694 3695 default: 3696 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3697 _("unsupported reloc %u"), 3698 r_type); 3699 break; 3700 } 3701 3702 return true; 3703 } 3704 3705 // Perform a TLS relocation. 3706 3707 template<int size, bool big_endian> 3708 inline void 3709 Target_sparc<size, big_endian>::Relocate::relocate_tls( 3710 const Relocate_info<size, big_endian>* relinfo, 3711 Target_sparc<size, big_endian>* target, 3712 size_t relnum, 3713 const elfcpp::Rela<size, big_endian>& rela, 3714 unsigned int r_type, 3715 const Sized_symbol<size>* gsym, 3716 const Symbol_value<size>* psymval, 3717 unsigned char* view, 3718 typename elfcpp::Elf_types<size>::Elf_Addr address, 3719 section_size_type) 3720 { 3721 Output_segment* tls_segment = relinfo->layout->tls_segment(); 3722 typedef Sparc_relocate_functions<size, big_endian> Reloc; 3723 const Sized_relobj_file<size, big_endian>* object = relinfo->object; 3724 typedef typename elfcpp::Swap<32, true>::Valtype Insntype; 3725 3726 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 3727 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0); 3728 3729 const bool is_final = 3730 (gsym == NULL 3731 ? !parameters->options().output_is_position_independent() 3732 : gsym->final_value_is_known()); 3733 const tls::Tls_optimization optimized_type 3734 = optimize_tls_reloc(is_final, r_type); 3735 3736 switch (r_type) 3737 { 3738 case elfcpp::R_SPARC_TLS_GD_HI22: 3739 case elfcpp::R_SPARC_TLS_GD_LO10: 3740 case elfcpp::R_SPARC_TLS_GD_ADD: 3741 case elfcpp::R_SPARC_TLS_GD_CALL: 3742 if (optimized_type == tls::TLSOPT_TO_LE) 3743 { 3744 Insntype* wv = reinterpret_cast<Insntype*>(view); 3745 Insntype val; 3746 3747 value -= tls_segment->memsz(); 3748 3749 switch (r_type) 3750 { 3751 case elfcpp::R_SPARC_TLS_GD_HI22: 3752 // TLS_GD_HI22 --> TLS_LE_HIX22 3753 Reloc::hix22(view, value, addend); 3754 break; 3755 3756 case elfcpp::R_SPARC_TLS_GD_LO10: 3757 // TLS_GD_LO10 --> TLS_LE_LOX10 3758 Reloc::lox10(view, value, addend); 3759 break; 3760 3761 case elfcpp::R_SPARC_TLS_GD_ADD: 3762 // add %reg1, %reg2, %reg3 --> mov %g7, %reg2, %reg3 3763 val = elfcpp::Swap<32, true>::readval(wv); 3764 val = (val & ~0x7c000) | 0x1c000; 3765 elfcpp::Swap<32, true>::writeval(wv, val); 3766 break; 3767 case elfcpp::R_SPARC_TLS_GD_CALL: 3768 // call __tls_get_addr --> nop 3769 elfcpp::Swap<32, true>::writeval(wv, sparc_nop); 3770 break; 3771 } 3772 break; 3773 } 3774 else 3775 { 3776 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE 3777 ? GOT_TYPE_TLS_OFFSET 3778 : GOT_TYPE_TLS_PAIR); 3779 if (gsym != NULL) 3780 { 3781 gold_assert(gsym->has_got_offset(got_type)); 3782 value = gsym->got_offset(got_type); 3783 } 3784 else 3785 { 3786 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 3787 gold_assert(object->local_has_got_offset(r_sym, got_type)); 3788 value = object->local_got_offset(r_sym, got_type); 3789 } 3790 if (optimized_type == tls::TLSOPT_TO_IE) 3791 { 3792 Insntype* wv = reinterpret_cast<Insntype*>(view); 3793 Insntype val; 3794 3795 switch (r_type) 3796 { 3797 case elfcpp::R_SPARC_TLS_GD_HI22: 3798 // TLS_GD_HI22 --> TLS_IE_HI22 3799 Reloc::hi22(view, value, addend); 3800 break; 3801 3802 case elfcpp::R_SPARC_TLS_GD_LO10: 3803 // TLS_GD_LO10 --> TLS_IE_LO10 3804 Reloc::lo10(view, value, addend); 3805 break; 3806 3807 case elfcpp::R_SPARC_TLS_GD_ADD: 3808 // add %reg1, %reg2, %reg3 --> ld [%reg1 + %reg2], %reg3 3809 val = elfcpp::Swap<32, true>::readval(wv); 3810 3811 if (size == 64) 3812 val |= 0xc0580000; 3813 else 3814 val |= 0xc0000000; 3815 3816 elfcpp::Swap<32, true>::writeval(wv, val); 3817 break; 3818 3819 case elfcpp::R_SPARC_TLS_GD_CALL: 3820 // The compiler can put the TLS_GD_ADD instruction 3821 // into the delay slot of the call. If so, we need 3822 // to transpose the two instructions so that the 3823 // new sequence works properly. 3824 // 3825 // The test we use is if the instruction in the 3826 // delay slot is an add with destination register 3827 // equal to %o0 3828 val = elfcpp::Swap<32, true>::readval(wv + 1); 3829 if ((val & 0x81f80000) == 0x80000000 3830 && ((val >> 25) & 0x1f) == 0x8) 3831 { 3832 if (size == 64) 3833 val |= 0xc0580000; 3834 else 3835 val |= 0xc0000000; 3836 3837 elfcpp::Swap<32, true>::writeval(wv, val); 3838 3839 wv += 1; 3840 this->ignore_gd_add_ = true; 3841 } 3842 else 3843 { 3844 // Even if the delay slot isn't the TLS_GD_ADD 3845 // instruction, we still have to handle the case 3846 // where it sets up %o0 in some other way. 3847 elfcpp::Swap<32, true>::writeval(wv, val); 3848 wv += 1; 3849 this->reloc_adjust_addr_ = view + 4; 3850 } 3851 // call __tls_get_addr --> add %g7, %o0, %o0 3852 elfcpp::Swap<32, true>::writeval(wv, 0x9001c008); 3853 break; 3854 } 3855 break; 3856 } 3857 else if (optimized_type == tls::TLSOPT_NONE) 3858 { 3859 switch (r_type) 3860 { 3861 case elfcpp::R_SPARC_TLS_GD_HI22: 3862 Reloc::hi22(view, value, addend); 3863 break; 3864 case elfcpp::R_SPARC_TLS_GD_LO10: 3865 Reloc::lo10(view, value, addend); 3866 break; 3867 case elfcpp::R_SPARC_TLS_GD_ADD: 3868 break; 3869 case elfcpp::R_SPARC_TLS_GD_CALL: 3870 { 3871 Symbol_value<size> symval; 3872 elfcpp::Elf_Xword value; 3873 Symbol* tsym; 3874 3875 tsym = target->tls_get_addr_sym_; 3876 gold_assert(tsym); 3877 value = (target->plt_section()->address() + 3878 tsym->plt_offset()); 3879 symval.set_output_value(value); 3880 Reloc::wdisp30(view, object, &symval, addend, address); 3881 } 3882 break; 3883 } 3884 break; 3885 } 3886 } 3887 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3888 _("unsupported reloc %u"), 3889 r_type); 3890 break; 3891 3892 case elfcpp::R_SPARC_TLS_LDM_HI22: 3893 case elfcpp::R_SPARC_TLS_LDM_LO10: 3894 case elfcpp::R_SPARC_TLS_LDM_ADD: 3895 case elfcpp::R_SPARC_TLS_LDM_CALL: 3896 if (optimized_type == tls::TLSOPT_TO_LE) 3897 { 3898 Insntype* wv = reinterpret_cast<Insntype*>(view); 3899 3900 switch (r_type) 3901 { 3902 case elfcpp::R_SPARC_TLS_LDM_HI22: 3903 case elfcpp::R_SPARC_TLS_LDM_LO10: 3904 case elfcpp::R_SPARC_TLS_LDM_ADD: 3905 elfcpp::Swap<32, true>::writeval(wv, sparc_nop); 3906 break; 3907 3908 case elfcpp::R_SPARC_TLS_LDM_CALL: 3909 elfcpp::Swap<32, true>::writeval(wv, sparc_mov_g0_o0); 3910 break; 3911 } 3912 break; 3913 } 3914 else if (optimized_type == tls::TLSOPT_NONE) 3915 { 3916 // Relocate the field with the offset of the GOT entry for 3917 // the module index. 3918 unsigned int got_offset; 3919 3920 got_offset = target->got_mod_index_entry(NULL, NULL, NULL); 3921 switch (r_type) 3922 { 3923 case elfcpp::R_SPARC_TLS_LDM_HI22: 3924 Reloc::hi22(view, got_offset, addend); 3925 break; 3926 case elfcpp::R_SPARC_TLS_LDM_LO10: 3927 Reloc::lo10(view, got_offset, addend); 3928 break; 3929 case elfcpp::R_SPARC_TLS_LDM_ADD: 3930 break; 3931 case elfcpp::R_SPARC_TLS_LDM_CALL: 3932 { 3933 Symbol_value<size> symval; 3934 elfcpp::Elf_Xword value; 3935 Symbol* tsym; 3936 3937 tsym = target->tls_get_addr_sym_; 3938 gold_assert(tsym); 3939 value = (target->plt_section()->address() + 3940 tsym->plt_offset()); 3941 symval.set_output_value(value); 3942 Reloc::wdisp30(view, object, &symval, addend, address); 3943 } 3944 break; 3945 } 3946 break; 3947 } 3948 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3949 _("unsupported reloc %u"), 3950 r_type); 3951 break; 3952 3953 // These relocs can appear in debugging sections, in which case 3954 // we won't see the TLS_LDM relocs. The local_dynamic_type 3955 // field tells us this. 3956 case elfcpp::R_SPARC_TLS_LDO_HIX22: 3957 if (optimized_type == tls::TLSOPT_TO_LE) 3958 { 3959 value -= tls_segment->memsz(); 3960 Reloc::hix22(view, value, addend); 3961 } 3962 else 3963 Reloc::ldo_hix22(view, value, addend); 3964 break; 3965 case elfcpp::R_SPARC_TLS_LDO_LOX10: 3966 if (optimized_type == tls::TLSOPT_TO_LE) 3967 { 3968 value -= tls_segment->memsz(); 3969 Reloc::lox10(view, value, addend); 3970 } 3971 else 3972 Reloc::ldo_lox10(view, value, addend); 3973 break; 3974 case elfcpp::R_SPARC_TLS_LDO_ADD: 3975 if (optimized_type == tls::TLSOPT_TO_LE) 3976 { 3977 Insntype* wv = reinterpret_cast<Insntype*>(view); 3978 Insntype val; 3979 3980 // add %reg1, %reg2, %reg3 --> add %g7, %reg2, %reg3 3981 val = elfcpp::Swap<32, true>::readval(wv); 3982 val = (val & ~0x7c000) | 0x1c000; 3983 elfcpp::Swap<32, true>::writeval(wv, val); 3984 } 3985 break; 3986 3987 // When optimizing IE --> LE, the only relocation that is handled 3988 // differently is R_SPARC_TLS_IE_LD, it is rewritten from 3989 // 'ld{,x} [rs1 + rs2], rd' into 'mov rs2, rd' or simply a NOP is 3990 // rs2 and rd are the same. 3991 case elfcpp::R_SPARC_TLS_IE_LD: 3992 case elfcpp::R_SPARC_TLS_IE_LDX: 3993 if (optimized_type == tls::TLSOPT_TO_LE) 3994 { 3995 Insntype* wv = reinterpret_cast<Insntype*>(view); 3996 Insntype val = elfcpp::Swap<32, true>::readval(wv); 3997 Insntype rs2 = val & 0x1f; 3998 Insntype rd = (val >> 25) & 0x1f; 3999 4000 if (rs2 == rd) 4001 val = sparc_nop; 4002 else 4003 val = sparc_mov | (val & 0x3e00001f); 4004 4005 elfcpp::Swap<32, true>::writeval(wv, val); 4006 } 4007 break; 4008 4009 case elfcpp::R_SPARC_TLS_IE_HI22: 4010 case elfcpp::R_SPARC_TLS_IE_LO10: 4011 if (optimized_type == tls::TLSOPT_TO_LE) 4012 { 4013 value -= tls_segment->memsz(); 4014 switch (r_type) 4015 { 4016 case elfcpp::R_SPARC_TLS_IE_HI22: 4017 // IE_HI22 --> LE_HIX22 4018 Reloc::hix22(view, value, addend); 4019 break; 4020 case elfcpp::R_SPARC_TLS_IE_LO10: 4021 // IE_LO10 --> LE_LOX10 4022 Reloc::lox10(view, value, addend); 4023 break; 4024 } 4025 break; 4026 } 4027 else if (optimized_type == tls::TLSOPT_NONE) 4028 { 4029 // Relocate the field with the offset of the GOT entry for 4030 // the tp-relative offset of the symbol. 4031 if (gsym != NULL) 4032 { 4033 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET)); 4034 value = gsym->got_offset(GOT_TYPE_TLS_OFFSET); 4035 } 4036 else 4037 { 4038 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 4039 gold_assert(object->local_has_got_offset(r_sym, 4040 GOT_TYPE_TLS_OFFSET)); 4041 value = object->local_got_offset(r_sym, 4042 GOT_TYPE_TLS_OFFSET); 4043 } 4044 switch (r_type) 4045 { 4046 case elfcpp::R_SPARC_TLS_IE_HI22: 4047 Reloc::hi22(view, value, addend); 4048 break; 4049 case elfcpp::R_SPARC_TLS_IE_LO10: 4050 Reloc::lo10(view, value, addend); 4051 break; 4052 } 4053 break; 4054 } 4055 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 4056 _("unsupported reloc %u"), 4057 r_type); 4058 break; 4059 4060 case elfcpp::R_SPARC_TLS_IE_ADD: 4061 // This seems to be mainly so that we can find the addition 4062 // instruction if there is one. There doesn't seem to be any 4063 // actual relocation to apply. 4064 break; 4065 4066 case elfcpp::R_SPARC_TLS_LE_HIX22: 4067 // If we're creating a shared library, a dynamic relocation will 4068 // have been created for this location, so do not apply it now. 4069 if (!parameters->options().shared()) 4070 { 4071 value -= tls_segment->memsz(); 4072 Reloc::hix22(view, value, addend); 4073 } 4074 break; 4075 4076 case elfcpp::R_SPARC_TLS_LE_LOX10: 4077 // If we're creating a shared library, a dynamic relocation will 4078 // have been created for this location, so do not apply it now. 4079 if (!parameters->options().shared()) 4080 { 4081 value -= tls_segment->memsz(); 4082 Reloc::lox10(view, value, addend); 4083 } 4084 break; 4085 } 4086 } 4087 4088 // Relax a call instruction. 4089 4090 template<int size, bool big_endian> 4091 inline void 4092 Target_sparc<size, big_endian>::Relocate::relax_call( 4093 Target_sparc<size, big_endian>* target, 4094 unsigned char* view, 4095 const elfcpp::Rela<size, big_endian>& rela, 4096 section_size_type view_size) 4097 { 4098 typedef typename elfcpp::Swap<32, true>::Valtype Insntype; 4099 Insntype *wv = reinterpret_cast<Insntype*>(view); 4100 Insntype call_insn, delay_insn, set_insn; 4101 uint32_t op3, reg, off; 4102 4103 // This code tries to relax call instructions that meet 4104 // certain criteria. 4105 // 4106 // The first criteria is that the call must be such that the return 4107 // address which the call writes into %o7 is unused. Two sequences 4108 // meet this criteria, and are used to implement tail calls. 4109 // 4110 // Leaf function tail call: 4111 // 4112 // or %o7, %g0, %ANY_REG 4113 // call FUNC 4114 // or %ANY_REG, %g0, %o7 4115 // 4116 // Non-leaf function tail call: 4117 // 4118 // call FUNC 4119 // restore 4120 // 4121 // The second criteria is that the call destination is close. If 4122 // the displacement can fit in a signed 22-bit immediate field of a 4123 // pre-V9 branch, we can do it. If we are generating a 64-bit 4124 // object or a 32-bit object with ELF machine type EF_SPARC32PLUS, 4125 // and the displacement fits in a signed 19-bit immediate field, 4126 // then we can use a V9 branch. 4127 4128 // Make sure the delay instruction can be safely accessed. 4129 if (rela.get_r_offset() + 8 > view_size) 4130 return; 4131 4132 call_insn = elfcpp::Swap<32, true>::readval(wv); 4133 delay_insn = elfcpp::Swap<32, true>::readval(wv + 1); 4134 4135 // Make sure it is really a call instruction. 4136 if (((call_insn >> 30) & 0x3) != 1) 4137 return; 4138 4139 if (((delay_insn >> 30) & 0x3) != 2) 4140 return; 4141 4142 // Accept only a restore or an integer arithmetic operation whose 4143 // sole side effect is to write the %o7 register (and perhaps set 4144 // the condition codes, which are considered clobbered across 4145 // function calls). 4146 // 4147 // For example, we don't want to match a tagged addition or 4148 // subtraction. We also don't want to match something like a 4149 // divide. 4150 // 4151 // Specifically we accept add{,cc}, and{,cc}, or{,cc}, 4152 // xor{,cc}, sub{,cc}, andn{,cc}, orn{,cc}, and xnor{,cc}. 4153 4154 op3 = (delay_insn >> 19) & 0x3f; 4155 reg = (delay_insn >> 25) & 0x1f; 4156 if (op3 != 0x3d 4157 && ((op3 & 0x28) != 0 || reg != 15)) 4158 return; 4159 4160 // For non-restore instructions, make sure %o7 isn't 4161 // an input. 4162 if (op3 != 0x3d) 4163 { 4164 // First check RS1 4165 reg = (delay_insn >> 14) & 0x15; 4166 if (reg == 15) 4167 return; 4168 4169 // And if non-immediate, check RS2 4170 if (((delay_insn >> 13) & 1) == 0) 4171 { 4172 reg = (delay_insn & 0x1f); 4173 if (reg == 15) 4174 return; 4175 } 4176 } 4177 4178 // Now check the branch distance. We are called after the 4179 // call has been relocated, so we just have to peek at the 4180 // offset contained in the instruction. 4181 off = call_insn & 0x3fffffff; 4182 if ((off & 0x3fe00000) != 0 4183 && (off & 0x3fe00000) != 0x3fe00000) 4184 return; 4185 4186 if ((size == 64 || target->elf_machine_ == elfcpp::EM_SPARC32PLUS) 4187 && ((off & 0x3c0000) == 0 4188 || (off & 0x3c0000) == 0x3c0000)) 4189 { 4190 // ba,pt %xcc, FUNC 4191 call_insn = 0x10680000 | (off & 0x07ffff); 4192 } 4193 else 4194 { 4195 // ba FUNC 4196 call_insn = 0x10800000 | (off & 0x3fffff); 4197 } 4198 elfcpp::Swap<32, true>::writeval(wv, call_insn); 4199 4200 // See if we can NOP out the delay slot instruction. We peek 4201 // at the instruction before the call to make sure we're dealing 4202 // with exactly the: 4203 // 4204 // or %o7, %g0, %ANY_REG 4205 // call 4206 // or %ANY_REG, %g0, %o7 4207 // 4208 // case. Otherwise this might be a tricky piece of hand written 4209 // assembler calculating %o7 in some non-trivial way, and therefore 4210 // we can't be sure that NOP'ing out the delay slot is safe. 4211 if (op3 == 0x02 4212 && rela.get_r_offset() >= 4) 4213 { 4214 if ((delay_insn & ~(0x1f << 14)) != 0x9e100000) 4215 return; 4216 4217 set_insn = elfcpp::Swap<32, true>::readval(wv - 1); 4218 if ((set_insn & ~(0x1f << 25)) != 0x8013c000) 4219 return; 4220 4221 reg = (set_insn >> 25) & 0x1f; 4222 if (reg == 0 || reg == 15) 4223 return; 4224 if (reg != ((delay_insn >> 14) & 0x1f)) 4225 return; 4226 4227 // All tests pass, nop it out. 4228 elfcpp::Swap<32, true>::writeval(wv + 1, sparc_nop); 4229 } 4230 } 4231 4232 // Relocate section data. 4233 4234 template<int size, bool big_endian> 4235 void 4236 Target_sparc<size, big_endian>::relocate_section( 4237 const Relocate_info<size, big_endian>* relinfo, 4238 unsigned int sh_type, 4239 const unsigned char* prelocs, 4240 size_t reloc_count, 4241 Output_section* output_section, 4242 bool needs_special_offset_handling, 4243 unsigned char* view, 4244 typename elfcpp::Elf_types<size>::Elf_Addr address, 4245 section_size_type view_size, 4246 const Reloc_symbol_changes* reloc_symbol_changes) 4247 { 4248 typedef Target_sparc<size, big_endian> Sparc; 4249 typedef typename Target_sparc<size, big_endian>::Relocate Sparc_relocate; 4250 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4251 Classify_reloc; 4252 4253 gold_assert(sh_type == elfcpp::SHT_RELA); 4254 4255 gold::relocate_section<size, big_endian, Sparc, Sparc_relocate, 4256 gold::Default_comdat_behavior, Classify_reloc>( 4257 relinfo, 4258 this, 4259 prelocs, 4260 reloc_count, 4261 output_section, 4262 needs_special_offset_handling, 4263 view, 4264 address, 4265 view_size, 4266 reloc_symbol_changes); 4267 } 4268 4269 // Scan the relocs during a relocatable link. 4270 4271 template<int size, bool big_endian> 4272 void 4273 Target_sparc<size, big_endian>::scan_relocatable_relocs( 4274 Symbol_table* symtab, 4275 Layout* layout, 4276 Sized_relobj_file<size, big_endian>* object, 4277 unsigned int data_shndx, 4278 unsigned int sh_type, 4279 const unsigned char* prelocs, 4280 size_t reloc_count, 4281 Output_section* output_section, 4282 bool needs_special_offset_handling, 4283 size_t local_symbol_count, 4284 const unsigned char* plocal_symbols, 4285 Relocatable_relocs* rr) 4286 { 4287 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4288 Classify_reloc; 4289 typedef gold::Default_scan_relocatable_relocs<Classify_reloc> 4290 Scan_relocatable_relocs; 4291 4292 gold_assert(sh_type == elfcpp::SHT_RELA); 4293 4294 gold::scan_relocatable_relocs<size, big_endian, Scan_relocatable_relocs>( 4295 symtab, 4296 layout, 4297 object, 4298 data_shndx, 4299 prelocs, 4300 reloc_count, 4301 output_section, 4302 needs_special_offset_handling, 4303 local_symbol_count, 4304 plocal_symbols, 4305 rr); 4306 } 4307 4308 // Scan the relocs for --emit-relocs. 4309 4310 template<int size, bool big_endian> 4311 void 4312 Target_sparc<size, big_endian>::emit_relocs_scan( 4313 Symbol_table* symtab, 4314 Layout* layout, 4315 Sized_relobj_file<size, big_endian>* object, 4316 unsigned int data_shndx, 4317 unsigned int sh_type, 4318 const unsigned char* prelocs, 4319 size_t reloc_count, 4320 Output_section* output_section, 4321 bool needs_special_offset_handling, 4322 size_t local_symbol_count, 4323 const unsigned char* plocal_syms, 4324 Relocatable_relocs* rr) 4325 { 4326 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4327 Classify_reloc; 4328 typedef gold::Default_emit_relocs_strategy<Classify_reloc> 4329 Emit_relocs_strategy; 4330 4331 gold_assert(sh_type == elfcpp::SHT_RELA); 4332 4333 gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>( 4334 symtab, 4335 layout, 4336 object, 4337 data_shndx, 4338 prelocs, 4339 reloc_count, 4340 output_section, 4341 needs_special_offset_handling, 4342 local_symbol_count, 4343 plocal_syms, 4344 rr); 4345 } 4346 4347 // Emit relocations for a section. 4348 4349 template<int size, bool big_endian> 4350 void 4351 Target_sparc<size, big_endian>::relocate_relocs( 4352 const Relocate_info<size, big_endian>* relinfo, 4353 unsigned int sh_type, 4354 const unsigned char* prelocs, 4355 size_t reloc_count, 4356 Output_section* output_section, 4357 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section, 4358 unsigned char* view, 4359 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 4360 section_size_type view_size, 4361 unsigned char* reloc_view, 4362 section_size_type reloc_view_size) 4363 { 4364 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4365 Classify_reloc; 4366 4367 gold_assert(sh_type == elfcpp::SHT_RELA); 4368 4369 gold::relocate_relocs<size, big_endian, Classify_reloc>( 4370 relinfo, 4371 prelocs, 4372 reloc_count, 4373 output_section, 4374 offset_in_output_section, 4375 view, 4376 view_address, 4377 view_size, 4378 reloc_view, 4379 reloc_view_size); 4380 } 4381 4382 // Return the value to use for a dynamic which requires special 4383 // treatment. This is how we support equality comparisons of function 4384 // pointers across shared library boundaries, as described in the 4385 // processor specific ABI supplement. 4386 4387 template<int size, bool big_endian> 4388 uint64_t 4389 Target_sparc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const 4390 { 4391 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); 4392 return this->plt_section()->address() + gsym->plt_offset(); 4393 } 4394 4395 // do_make_elf_object to override the same function in the base class. 4396 // We need to use a target-specific sub-class of 4397 // Sized_relobj_file<size, big_endian> to process SPARC specific bits 4398 // of the ELF headers. Hence we need to have our own ELF object creation. 4399 4400 template<int size, bool big_endian> 4401 Object* 4402 Target_sparc<size, big_endian>::do_make_elf_object( 4403 const std::string& name, 4404 Input_file* input_file, 4405 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr) 4406 { 4407 elfcpp::Elf_Half machine = ehdr.get_e_machine(); 4408 elfcpp::Elf_Word flags = ehdr.get_e_flags(); 4409 elfcpp::Elf_Word omm, mm; 4410 4411 switch (machine) 4412 { 4413 case elfcpp::EM_SPARC32PLUS: 4414 this->elf_machine_ = elfcpp::EM_SPARC32PLUS; 4415 break; 4416 4417 case elfcpp::EM_SPARC: 4418 case elfcpp::EM_SPARCV9: 4419 break; 4420 4421 default: 4422 break; 4423 } 4424 4425 if (!this->elf_flags_set_) 4426 { 4427 this->elf_flags_ = flags; 4428 this->elf_flags_set_ = true; 4429 } 4430 else 4431 { 4432 // Accumulate cpu feature bits. 4433 this->elf_flags_ |= (flags & (elfcpp::EF_SPARC_32PLUS 4434 | elfcpp::EF_SPARC_SUN_US1 4435 | elfcpp::EF_SPARC_HAL_R1 4436 | elfcpp::EF_SPARC_SUN_US3)); 4437 4438 // Bump the memory model setting to the most restrictive 4439 // one we encounter. 4440 omm = (this->elf_flags_ & elfcpp::EF_SPARCV9_MM); 4441 mm = (flags & elfcpp::EF_SPARCV9_MM); 4442 if (omm != mm) 4443 { 4444 if (mm == elfcpp::EF_SPARCV9_TSO) 4445 { 4446 this->elf_flags_ &= ~elfcpp::EF_SPARCV9_MM; 4447 this->elf_flags_ |= elfcpp::EF_SPARCV9_TSO; 4448 } 4449 else if (mm == elfcpp::EF_SPARCV9_PSO 4450 && omm == elfcpp::EF_SPARCV9_RMO) 4451 { 4452 this->elf_flags_ &= ~elfcpp::EF_SPARCV9_MM; 4453 this->elf_flags_ |= elfcpp::EF_SPARCV9_PSO; 4454 } 4455 } 4456 } 4457 4458 // Validate that the little-endian flag matches how we've 4459 // been instantiated. 4460 if (!(flags & elfcpp::EF_SPARC_LEDATA) != big_endian) 4461 { 4462 if (big_endian) 4463 gold_error(_("%s: little endian elf flag set on BE object"), 4464 name.c_str()); 4465 else 4466 gold_error(_("%s: little endian elf flag clear on LE object"), 4467 name.c_str()); 4468 } 4469 4470 return Target::do_make_elf_object(name, input_file, offset, ehdr); 4471 } 4472 4473 // Adjust ELF file header. 4474 4475 template<int size, bool big_endian> 4476 void 4477 Target_sparc<size, big_endian>::do_adjust_elf_header( 4478 unsigned char* view, 4479 int len) 4480 { 4481 elfcpp::Ehdr_write<size, big_endian> oehdr(view); 4482 4483 oehdr.put_e_machine(this->elf_machine_); 4484 oehdr.put_e_flags(this->elf_flags_); 4485 4486 Sized_target<size, big_endian>::do_adjust_elf_header(view, len); 4487 } 4488 4489 // The selector for sparc object files. 4490 4491 template<int size, bool big_endian> 4492 class Target_selector_sparc : public Target_selector 4493 { 4494 public: 4495 Target_selector_sparc() 4496 : Target_selector(elfcpp::EM_NONE, size, big_endian, 4497 (size == 64 ? "elf64-sparc" : "elf32-sparc"), 4498 (size == 64 ? "elf64_sparc" : "elf32_sparc")) 4499 { } 4500 4501 virtual Target* 4502 do_recognize(Input_file*, off_t, int machine, int, int) 4503 { 4504 switch (size) 4505 { 4506 case 64: 4507 if (machine != elfcpp::EM_SPARCV9) 4508 return NULL; 4509 break; 4510 4511 case 32: 4512 if (machine != elfcpp::EM_SPARC 4513 && machine != elfcpp::EM_SPARC32PLUS) 4514 return NULL; 4515 break; 4516 4517 default: 4518 return NULL; 4519 } 4520 4521 return this->instantiate_target(); 4522 } 4523 4524 virtual Target* 4525 do_instantiate_target() 4526 { return new Target_sparc<size, big_endian>(); } 4527 }; 4528 4529 Target_selector_sparc<32, true> target_selector_sparc32; 4530 Target_selector_sparc<64, true> target_selector_sparc64; 4531 4532 } // End anonymous namespace. 4533
