1// sparc.cc -- sparc target support for gold. 2 3// Copyright (C) 2008-2017 Free Software Foundation, Inc. 4// Written by David S. Miller <davem@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 45namespace 46{ 47 48using namespace gold; 49 50template<int size, bool big_endian> 51class Output_data_plt_sparc; 52 53template<int size, bool big_endian> 54class 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 476template<> 477Target::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 504template<> 505Target::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. 534template<int size, bool big_endian> 535class Sparc_relocate_functions 536{ 537private: 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 645public: 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 1227template<int size, bool big_endian> 1228Output_data_got<size, big_endian>* 1229Target_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 1258template<int size, bool big_endian> 1259typename Target_sparc<size, big_endian>::Reloc_section* 1260Target_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 1279template<int size, bool big_endian> 1280typename Target_sparc<size, big_endian>::Reloc_section* 1281Target_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 1299template<int size, bool big_endian> 1300class 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 1444template<int size, bool big_endian> 1445const int Output_data_plt_sparc<size, big_endian>::base_plt_entry_size; 1446 1447template<int size, bool big_endian> 1448const unsigned int 1449Output_data_plt_sparc<size, big_endian>::plt_entries_per_block; 1450 1451template<int size, bool big_endian> 1452const unsigned int Output_data_plt_sparc<size, big_endian>::plt_insn_chunk_size; 1453 1454template<int size, bool big_endian> 1455const unsigned int 1456Output_data_plt_sparc<size, big_endian>::plt_pointer_chunk_size; 1457 1458template<int size, bool big_endian> 1459const 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 1464template<int size, bool big_endian> 1465Output_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 1475template<int size, bool big_endian> 1476void 1477Output_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 1484template<int size, bool big_endian> 1485void 1486Output_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 1525template<int size, bool big_endian> 1526unsigned int 1527Output_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 1553template<int size, bool big_endian> 1554void 1555Output_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 1591template<int size, bool big_endian> 1592typename Output_data_plt_sparc<size, big_endian>::Reloc_section* 1593Output_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 1630template<int size, bool big_endian> 1631uint64_t 1632Output_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 1644template<int size, bool big_endian> 1645uint64_t 1646Output_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 1655static const unsigned int sparc_nop = 0x01000000; 1656static const unsigned int sparc_sethi_g1 = 0x03000000; 1657static const unsigned int sparc_branch_always = 0x30800000; 1658static const unsigned int sparc_branch_always_pt = 0x30680000; 1659static const unsigned int sparc_mov = 0x80100000; 1660static const unsigned int sparc_mov_g0_o0 = 0x90100000; 1661static const unsigned int sparc_mov_o7_g5 = 0x8a10000f; 1662static const unsigned int sparc_call_plus_8 = 0x40000002; 1663static const unsigned int sparc_ldx_o7_imm_g1 = 0xc25be000; 1664static const unsigned int sparc_jmpl_o7_g1_g1 = 0x83c3c001; 1665static const unsigned int sparc_mov_g5_o7 = 0x9e100005; 1666 1667// Write out the PLT. 1668 1669template<int size, bool big_endian> 1670void 1671Output_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 1805template<int size, bool big_endian> 1806void 1807Target_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 1837template<int size, bool big_endian> 1838void 1839Target_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 1854template<int size, bool big_endian> 1855void 1856Target_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 1874template<int size, bool big_endian> 1875unsigned int 1876Target_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 1885template<int size, bool big_endian> 1886unsigned int 1887Target_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 1894template<int size, bool big_endian> 1895unsigned int 1896Target_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 1903template<int size, bool big_endian> 1904unsigned int 1905Target_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 1934static tls::Tls_optimization 1935optimize_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 1997template<int size, bool big_endian> 1998int 1999Target_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 2113template<int size, bool big_endian> 2114void 2115Target_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 2126template<int size, bool big_endian> 2127void 2128Target_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 2139template<int size, bool big_endian> 2140void 2141Target_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 2237template<int size, bool big_endian> 2238bool 2239Target_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 2252template<int size, bool big_endian> 2253inline void 2254Target_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 2563template<int size, bool big_endian> 2564void 2565Target_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 2576template<int size, bool big_endian> 2577inline void 2578Target_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 // Fall through. 2819 case elfcpp::R_SPARC_GOT10: 2820 case elfcpp::R_SPARC_GOT13: 2821 case elfcpp::R_SPARC_GOT22: 2822 { 2823 // The symbol requires a GOT entry. 2824 Output_data_got<size, big_endian>* got; 2825 2826 got = target->got_section(symtab, layout); 2827 if (gsym->final_value_is_known()) 2828 { 2829 // For a STT_GNU_IFUNC symbol we want the PLT address. 2830 if (gsym->type() == elfcpp::STT_GNU_IFUNC) 2831 got->add_global_plt(gsym, GOT_TYPE_STANDARD); 2832 else 2833 got->add_global(gsym, GOT_TYPE_STANDARD); 2834 } 2835 else 2836 { 2837 // If this symbol is not fully resolved, we need to add a 2838 // GOT entry with a dynamic relocation. 2839 bool is_ifunc = gsym->type() == elfcpp::STT_GNU_IFUNC; 2840 2841 // Use a GLOB_DAT rather than a RELATIVE reloc if: 2842 // 2843 // 1) The symbol may be defined in some other module. 2844 // 2845 // 2) We are building a shared library and this is a 2846 // protected symbol; using GLOB_DAT means that the dynamic 2847 // linker can use the address of the PLT in the main 2848 // executable when appropriate so that function address 2849 // comparisons work. 2850 // 2851 // 3) This is a STT_GNU_IFUNC symbol in position dependent 2852 // code, again so that function address comparisons work. 2853 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2854 if (gsym->is_from_dynobj() 2855 || gsym->is_undefined() 2856 || gsym->is_preemptible() 2857 || (gsym->visibility() == elfcpp::STV_PROTECTED 2858 && parameters->options().shared()) 2859 || (gsym->type() == elfcpp::STT_GNU_IFUNC 2860 && parameters->options().output_is_position_independent() 2861 && !gsym->is_forced_local())) 2862 { 2863 unsigned int r_type = elfcpp::R_SPARC_GLOB_DAT; 2864 2865 // If this symbol is forced local, this relocation will 2866 // not work properly. That's because ld.so on sparc 2867 // (and 32-bit powerpc) expects st_value in the r_addend 2868 // of relocations for STB_LOCAL symbols. Curiously the 2869 // BFD linker does not promote global hidden symbols to be 2870 // STB_LOCAL in the dynamic symbol table like Gold does. 2871 gold_assert(!gsym->is_forced_local()); 2872 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, rela_dyn, 2873 r_type); 2874 } 2875 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD)) 2876 { 2877 unsigned int off = got->add_constant(0); 2878 2879 gsym->set_got_offset(GOT_TYPE_STANDARD, off); 2880 if (is_ifunc) 2881 { 2882 // Tell the dynamic linker to use the PLT address 2883 // when resolving relocations. 2884 if (gsym->is_from_dynobj() 2885 && !parameters->options().shared()) 2886 gsym->set_needs_dynsym_value(); 2887 } 2888 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE, 2889 got, off, 0, is_ifunc); 2890 } 2891 } 2892 } 2893 break; 2894 2895 // These are initial tls relocs, which are expected when 2896 // linking. 2897 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2898 case elfcpp::R_SPARC_TLS_GD_LO10: 2899 case elfcpp::R_SPARC_TLS_GD_ADD: 2900 case elfcpp::R_SPARC_TLS_GD_CALL: 2901 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic 2902 case elfcpp::R_SPARC_TLS_LDM_LO10: 2903 case elfcpp::R_SPARC_TLS_LDM_ADD: 2904 case elfcpp::R_SPARC_TLS_LDM_CALL: 2905 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2906 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2907 case elfcpp::R_SPARC_TLS_LDO_ADD: 2908 case elfcpp::R_SPARC_TLS_LE_HIX22: 2909 case elfcpp::R_SPARC_TLS_LE_LOX10: 2910 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2911 case elfcpp::R_SPARC_TLS_IE_LO10: 2912 case elfcpp::R_SPARC_TLS_IE_LD: 2913 case elfcpp::R_SPARC_TLS_IE_LDX: 2914 case elfcpp::R_SPARC_TLS_IE_ADD: 2915 { 2916 const bool is_final = gsym->final_value_is_known(); 2917 const tls::Tls_optimization optimized_type 2918 = optimize_tls_reloc(is_final, r_type); 2919 switch (r_type) 2920 { 2921 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic 2922 case elfcpp::R_SPARC_TLS_GD_LO10: 2923 case elfcpp::R_SPARC_TLS_GD_ADD: 2924 case elfcpp::R_SPARC_TLS_GD_CALL: 2925 if (optimized_type == tls::TLSOPT_NONE) 2926 { 2927 // Create a pair of GOT entries for the module index and 2928 // dtv-relative offset. 2929 Output_data_got<size, big_endian>* got 2930 = target->got_section(symtab, layout); 2931 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR, 2932 target->rela_dyn_section(layout), 2933 (size == 64 2934 ? elfcpp::R_SPARC_TLS_DTPMOD64 2935 : elfcpp::R_SPARC_TLS_DTPMOD32), 2936 (size == 64 2937 ? elfcpp::R_SPARC_TLS_DTPOFF64 2938 : elfcpp::R_SPARC_TLS_DTPOFF32)); 2939 2940 // Emit R_SPARC_WPLT30 against "__tls_get_addr" 2941 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL) 2942 generate_tls_call(symtab, layout, target); 2943 } 2944 else if (optimized_type == tls::TLSOPT_TO_IE) 2945 { 2946 // Create a GOT entry for the tp-relative offset. 2947 Output_data_got<size, big_endian>* got 2948 = target->got_section(symtab, layout); 2949 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 2950 target->rela_dyn_section(layout), 2951 (size == 64 ? 2952 elfcpp::R_SPARC_TLS_TPOFF64 : 2953 elfcpp::R_SPARC_TLS_TPOFF32)); 2954 } 2955 else if (optimized_type != tls::TLSOPT_TO_LE) 2956 unsupported_reloc_global(object, r_type, gsym); 2957 break; 2958 2959 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic 2960 case elfcpp::R_SPARC_TLS_LDM_LO10: 2961 case elfcpp::R_SPARC_TLS_LDM_ADD: 2962 case elfcpp::R_SPARC_TLS_LDM_CALL: 2963 if (optimized_type == tls::TLSOPT_NONE) 2964 { 2965 // Create a GOT entry for the module index. 2966 target->got_mod_index_entry(symtab, layout, object); 2967 2968 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL) 2969 generate_tls_call(symtab, layout, target); 2970 } 2971 else if (optimized_type != tls::TLSOPT_TO_LE) 2972 unsupported_reloc_global(object, r_type, gsym); 2973 break; 2974 2975 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic 2976 case elfcpp::R_SPARC_TLS_LDO_LOX10: 2977 case elfcpp::R_SPARC_TLS_LDO_ADD: 2978 break; 2979 2980 case elfcpp::R_SPARC_TLS_LE_HIX22: 2981 case elfcpp::R_SPARC_TLS_LE_LOX10: 2982 layout->set_has_static_tls(); 2983 if (parameters->options().shared()) 2984 { 2985 Reloc_section* rela_dyn = target->rela_dyn_section(layout); 2986 rela_dyn->add_symbolless_global_addend(gsym, orig_r_type, 2987 output_section, object, 2988 data_shndx, reloc.get_r_offset(), 2989 0); 2990 } 2991 break; 2992 2993 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec 2994 case elfcpp::R_SPARC_TLS_IE_LO10: 2995 case elfcpp::R_SPARC_TLS_IE_LD: 2996 case elfcpp::R_SPARC_TLS_IE_LDX: 2997 case elfcpp::R_SPARC_TLS_IE_ADD: 2998 layout->set_has_static_tls(); 2999 if (optimized_type == tls::TLSOPT_NONE) 3000 { 3001 // Create a GOT entry for the tp-relative offset. 3002 Output_data_got<size, big_endian>* got 3003 = target->got_section(symtab, layout); 3004 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET, 3005 target->rela_dyn_section(layout), 3006 (size == 64 3007 ? elfcpp::R_SPARC_TLS_TPOFF64 3008 : elfcpp::R_SPARC_TLS_TPOFF32)); 3009 } 3010 else if (optimized_type != tls::TLSOPT_TO_LE) 3011 unsupported_reloc_global(object, r_type, gsym); 3012 break; 3013 } 3014 } 3015 break; 3016 3017 // These are relocations which should only be seen by the 3018 // dynamic linker, and should never be seen here. 3019 case elfcpp::R_SPARC_COPY: 3020 case elfcpp::R_SPARC_GLOB_DAT: 3021 case elfcpp::R_SPARC_JMP_SLOT: 3022 case elfcpp::R_SPARC_JMP_IREL: 3023 case elfcpp::R_SPARC_RELATIVE: 3024 case elfcpp::R_SPARC_IRELATIVE: 3025 case elfcpp::R_SPARC_TLS_DTPMOD64: 3026 case elfcpp::R_SPARC_TLS_DTPMOD32: 3027 case elfcpp::R_SPARC_TLS_DTPOFF64: 3028 case elfcpp::R_SPARC_TLS_DTPOFF32: 3029 case elfcpp::R_SPARC_TLS_TPOFF64: 3030 case elfcpp::R_SPARC_TLS_TPOFF32: 3031 gold_error(_("%s: unexpected reloc %u in object file"), 3032 object->name().c_str(), r_type); 3033 break; 3034 3035 default: 3036 unsupported_reloc_global(object, r_type, gsym); 3037 break; 3038 } 3039} 3040 3041// Make a new symbol table entry. 3042// STT_SPARC_REGISTER symbols require special handling, 3043// so we intercept these symbols and keep track of them separately. 3044// We will resolve register symbols here and output them at symbol 3045// finalization time. 3046 3047template<int size, bool big_endian> 3048Sized_symbol<size>* 3049Target_sparc<size, big_endian>::make_symbol(const char* name, 3050 elfcpp::STT type, 3051 Object* object, 3052 unsigned int shndx, 3053 uint64_t value) 3054{ 3055 // REGISTER symbols are used only on SPARC-64. 3056 if (size == 64 && type == elfcpp::STT_SPARC_REGISTER) 3057 { 3058 // Ignore REGISTER symbols in dynamic objects. 3059 if (object->is_dynamic()) 3060 return NULL; 3061 // Only registers 2, 3, 6, and 7 can be declared global. 3062 int reg = value; 3063 switch (reg) 3064 { 3065 case 2: case 3: 3066 reg -= 2; 3067 break; 3068 case 6: case 7: 3069 reg -= 4; 3070 break; 3071 default: 3072 gold_error(_("%s: only registers %%g[2367] can be declared " 3073 "using STT_REGISTER"), 3074 object->name().c_str()); 3075 return NULL; 3076 } 3077 Register_symbol& rsym = this->register_syms_[reg]; 3078 if (rsym.name == NULL) 3079 { 3080 rsym.name = name; 3081 rsym.shndx = shndx; 3082 rsym.obj = object; 3083 } 3084 else 3085 { 3086 if (strcmp(rsym.name, name) != 0) 3087 { 3088 gold_error(_("%s: register %%g%d declared as '%s'; " 3089 "previously declared as '%s' in %s"), 3090 object->name().c_str(), 3091 static_cast<int>(value), 3092 *name ? name : "#scratch", 3093 *rsym.name ? rsym.name : "#scratch", 3094 rsym.obj->name().c_str()); 3095 return NULL; 3096 } 3097 } 3098 return NULL; 3099 } 3100 return new Sized_symbol<size>(); 3101} 3102 3103// Process relocations for gc. 3104 3105template<int size, bool big_endian> 3106void 3107Target_sparc<size, big_endian>::gc_process_relocs( 3108 Symbol_table* symtab, 3109 Layout* layout, 3110 Sized_relobj_file<size, big_endian>* object, 3111 unsigned int data_shndx, 3112 unsigned int, 3113 const unsigned char* prelocs, 3114 size_t reloc_count, 3115 Output_section* output_section, 3116 bool needs_special_offset_handling, 3117 size_t local_symbol_count, 3118 const unsigned char* plocal_symbols) 3119{ 3120 typedef Target_sparc<size, big_endian> Sparc; 3121 typedef typename Target_sparc<size, big_endian>::Scan Scan; 3122 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 3123 Classify_reloc; 3124 3125 gold::gc_process_relocs<size, big_endian, Sparc, Scan, Classify_reloc>( 3126 symtab, 3127 layout, 3128 this, 3129 object, 3130 data_shndx, 3131 prelocs, 3132 reloc_count, 3133 output_section, 3134 needs_special_offset_handling, 3135 local_symbol_count, 3136 plocal_symbols); 3137} 3138 3139// Scan relocations for a section. 3140 3141template<int size, bool big_endian> 3142void 3143Target_sparc<size, big_endian>::scan_relocs( 3144 Symbol_table* symtab, 3145 Layout* layout, 3146 Sized_relobj_file<size, big_endian>* object, 3147 unsigned int data_shndx, 3148 unsigned int sh_type, 3149 const unsigned char* prelocs, 3150 size_t reloc_count, 3151 Output_section* output_section, 3152 bool needs_special_offset_handling, 3153 size_t local_symbol_count, 3154 const unsigned char* plocal_symbols) 3155{ 3156 typedef Target_sparc<size, big_endian> Sparc; 3157 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 3158 Classify_reloc; 3159 3160 if (sh_type == elfcpp::SHT_REL) 3161 { 3162 gold_error(_("%s: unsupported REL reloc section"), 3163 object->name().c_str()); 3164 return; 3165 } 3166 3167 gold::scan_relocs<size, big_endian, Sparc, Scan, Classify_reloc>( 3168 symtab, 3169 layout, 3170 this, 3171 object, 3172 data_shndx, 3173 prelocs, 3174 reloc_count, 3175 output_section, 3176 needs_special_offset_handling, 3177 local_symbol_count, 3178 plocal_symbols); 3179} 3180 3181// Finalize the sections. 3182 3183template<int size, bool big_endian> 3184void 3185Target_sparc<size, big_endian>::do_finalize_sections( 3186 Layout* layout, 3187 const Input_objects*, 3188 Symbol_table* symtab) 3189{ 3190 if (this->plt_) 3191 this->plt_->emit_pending_ifunc_relocs(); 3192 3193 // Fill in some more dynamic tags. 3194 const Reloc_section* rel_plt = (this->plt_ == NULL 3195 ? NULL 3196 : this->plt_->rel_plt()); 3197 layout->add_target_dynamic_tags(false, this->plt_, rel_plt, 3198 this->rela_dyn_, true, true); 3199 3200 // Emit any relocs we saved in an attempt to avoid generating COPY 3201 // relocs. 3202 if (this->copy_relocs_.any_saved_relocs()) 3203 this->copy_relocs_.emit(this->rela_dyn_section(layout)); 3204 3205 if (parameters->doing_static_link() 3206 && (this->plt_ == NULL || !this->plt_->has_ifunc_section())) 3207 { 3208 // If linking statically, make sure that the __rela_iplt symbols 3209 // were defined if necessary, even if we didn't create a PLT. 3210 static const Define_symbol_in_segment syms[] = 3211 { 3212 { 3213 "__rela_iplt_start", // name 3214 elfcpp::PT_LOAD, // segment_type 3215 elfcpp::PF_W, // segment_flags_set 3216 elfcpp::PF(0), // segment_flags_clear 3217 0, // value 3218 0, // size 3219 elfcpp::STT_NOTYPE, // type 3220 elfcpp::STB_GLOBAL, // binding 3221 elfcpp::STV_HIDDEN, // visibility 3222 0, // nonvis 3223 Symbol::SEGMENT_START, // offset_from_base 3224 true // only_if_ref 3225 }, 3226 { 3227 "__rela_iplt_end", // name 3228 elfcpp::PT_LOAD, // segment_type 3229 elfcpp::PF_W, // segment_flags_set 3230 elfcpp::PF(0), // segment_flags_clear 3231 0, // value 3232 0, // size 3233 elfcpp::STT_NOTYPE, // type 3234 elfcpp::STB_GLOBAL, // binding 3235 elfcpp::STV_HIDDEN, // visibility 3236 0, // nonvis 3237 Symbol::SEGMENT_START, // offset_from_base 3238 true // only_if_ref 3239 } 3240 }; 3241 3242 symtab->define_symbols(layout, 2, syms, 3243 layout->script_options()->saw_sections_clause()); 3244 } 3245 3246 for (int reg = 0; reg < 4; ++reg) 3247 { 3248 Register_symbol& rsym = this->register_syms_[reg]; 3249 if (rsym.name != NULL) 3250 { 3251 int value = reg < 3 ? reg + 2 : reg + 4; 3252 Sized_symbol<size>* sym = new Sized_symbol<size>(); 3253 if (rsym.shndx == elfcpp::SHN_UNDEF) 3254 sym->init_undefined(rsym.name, NULL, value, 3255 elfcpp::STT_SPARC_REGISTER, elfcpp::STB_GLOBAL, 3256 elfcpp::STV_DEFAULT, 0); 3257 else 3258 sym->init_constant(rsym.name, NULL, value, 0, 3259 elfcpp::STT_SPARC_REGISTER, elfcpp::STB_GLOBAL, 3260 elfcpp::STV_DEFAULT, 0, false); 3261 symtab->add_target_global_symbol(sym); 3262 layout->add_target_specific_dynamic_tag(elfcpp::DT_SPARC_REGISTER, 3263 value); 3264 } 3265 } 3266} 3267 3268// Perform a relocation. 3269 3270template<int size, bool big_endian> 3271inline bool 3272Target_sparc<size, big_endian>::Relocate::relocate( 3273 const Relocate_info<size, big_endian>* relinfo, 3274 unsigned int, 3275 Target_sparc* target, 3276 Output_section*, 3277 size_t relnum, 3278 const unsigned char* preloc, 3279 const Sized_symbol<size>* gsym, 3280 const Symbol_value<size>* psymval, 3281 unsigned char* view, 3282 typename elfcpp::Elf_types<size>::Elf_Addr address, 3283 section_size_type view_size) 3284{ 3285 const elfcpp::Rela<size, big_endian> rela(preloc); 3286 unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info()); 3287 bool orig_is_ifunc = psymval->is_ifunc_symbol(); 3288 r_type &= 0xff; 3289 3290 if (this->ignore_gd_add_) 3291 { 3292 if (r_type != elfcpp::R_SPARC_TLS_GD_ADD) 3293 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3294 _("missing expected TLS relocation")); 3295 else 3296 { 3297 this->ignore_gd_add_ = false; 3298 return false; 3299 } 3300 } 3301 3302 if (view == NULL) 3303 return true; 3304 3305 if (this->reloc_adjust_addr_ == view) 3306 view -= 4; 3307 3308 typedef Sparc_relocate_functions<size, big_endian> Reloc; 3309 const Sized_relobj_file<size, big_endian>* object = relinfo->object; 3310 3311 // Pick the value to use for symbols defined in shared objects. 3312 Symbol_value<size> symval; 3313 if (gsym != NULL 3314 && gsym->use_plt_offset(Scan::get_reference_flags(r_type))) 3315 { 3316 elfcpp::Elf_Xword value; 3317 3318 value = target->plt_address_for_global(gsym); 3319 3320 symval.set_output_value(value); 3321 3322 psymval = &symval; 3323 } 3324 else if (gsym == NULL && orig_is_ifunc) 3325 { 3326 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 3327 if (object->local_has_plt_offset(r_sym)) 3328 { 3329 symval.set_output_value(target->plt_address_for_local(object, r_sym)); 3330 psymval = &symval; 3331 } 3332 } 3333 3334 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 3335 3336 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT 3337 // pointer points to the beginning, not the end, of the table. 3338 // So we just use the plain offset. 3339 unsigned int got_offset = 0; 3340 bool gdop_valid = false; 3341 switch (r_type) 3342 { 3343 case elfcpp::R_SPARC_GOTDATA_OP: 3344 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 3345 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 3346 // If this is local, we did not create a GOT entry because we 3347 // intend to transform this into a GOT relative relocation. 3348 if (gsym == NULL 3349 || (gsym->is_defined() 3350 && !gsym->is_from_dynobj() 3351 && !gsym->is_preemptible() 3352 && !orig_is_ifunc)) 3353 { 3354 got_offset = psymval->value(object, addend) - target->got_address(); 3355 gdop_valid = true; 3356 break; 3357 } 3358 // Fall through. 3359 case elfcpp::R_SPARC_GOT10: 3360 case elfcpp::R_SPARC_GOT13: 3361 case elfcpp::R_SPARC_GOT22: 3362 if (gsym != NULL) 3363 { 3364 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD)); 3365 got_offset = gsym->got_offset(GOT_TYPE_STANDARD); 3366 } 3367 else 3368 { 3369 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 3370 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD)); 3371 got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD); 3372 } 3373 break; 3374 3375 default: 3376 break; 3377 } 3378 3379 switch (r_type) 3380 { 3381 case elfcpp::R_SPARC_NONE: 3382 case elfcpp::R_SPARC_REGISTER: 3383 case elfcpp::R_SPARC_GNU_VTINHERIT: 3384 case elfcpp::R_SPARC_GNU_VTENTRY: 3385 break; 3386 3387 case elfcpp::R_SPARC_8: 3388 Relocate_functions<size, big_endian>::rela8(view, object, 3389 psymval, addend); 3390 break; 3391 3392 case elfcpp::R_SPARC_16: 3393 if (rela.get_r_offset() & 0x1) 3394 { 3395 // The assembler can sometimes emit unaligned relocations 3396 // for dwarf2 cfi directives. 3397 Reloc::ua16(view, object, psymval, addend); 3398 } 3399 else 3400 Relocate_functions<size, big_endian>::rela16(view, object, 3401 psymval, addend); 3402 break; 3403 3404 case elfcpp::R_SPARC_32: 3405 if (!parameters->options().output_is_position_independent()) 3406 { 3407 if (rela.get_r_offset() & 0x3) 3408 { 3409 // The assembler can sometimes emit unaligned relocations 3410 // for dwarf2 cfi directives. 3411 Reloc::ua32(view, object, psymval, addend); 3412 } 3413 else 3414 Relocate_functions<size, big_endian>::rela32(view, object, 3415 psymval, addend); 3416 } 3417 break; 3418 3419 case elfcpp::R_SPARC_DISP8: 3420 Reloc::disp8(view, object, psymval, addend, address); 3421 break; 3422 3423 case elfcpp::R_SPARC_DISP16: 3424 Reloc::disp16(view, object, psymval, addend, address); 3425 break; 3426 3427 case elfcpp::R_SPARC_DISP32: 3428 Reloc::disp32(view, object, psymval, addend, address); 3429 break; 3430 3431 case elfcpp::R_SPARC_DISP64: 3432 Reloc::disp64(view, object, psymval, addend, address); 3433 break; 3434 3435 case elfcpp::R_SPARC_WDISP30: 3436 case elfcpp::R_SPARC_WPLT30: 3437 Reloc::wdisp30(view, object, psymval, addend, address); 3438 if (target->may_relax()) 3439 relax_call(target, view, rela, view_size); 3440 break; 3441 3442 case elfcpp::R_SPARC_WDISP22: 3443 Reloc::wdisp22(view, object, psymval, addend, address); 3444 break; 3445 3446 case elfcpp::R_SPARC_WDISP19: 3447 Reloc::wdisp19(view, object, psymval, addend, address); 3448 break; 3449 3450 case elfcpp::R_SPARC_WDISP16: 3451 Reloc::wdisp16(view, object, psymval, addend, address); 3452 break; 3453 3454 case elfcpp::R_SPARC_WDISP10: 3455 Reloc::wdisp10(view, object, psymval, addend, address); 3456 break; 3457 3458 case elfcpp::R_SPARC_HI22: 3459 Reloc::hi22(view, object, psymval, addend); 3460 break; 3461 3462 case elfcpp::R_SPARC_22: 3463 Reloc::rela32_22(view, object, psymval, addend); 3464 break; 3465 3466 case elfcpp::R_SPARC_13: 3467 Reloc::rela32_13(view, object, psymval, addend); 3468 break; 3469 3470 case elfcpp::R_SPARC_LO10: 3471 Reloc::lo10(view, object, psymval, addend); 3472 break; 3473 3474 case elfcpp::R_SPARC_GOTDATA_OP_LOX10: 3475 if (gdop_valid) 3476 { 3477 Reloc::gdop_lox10(view, got_offset); 3478 break; 3479 } 3480 // Fall through. 3481 case elfcpp::R_SPARC_GOT10: 3482 Reloc::lo10(view, got_offset, addend); 3483 break; 3484 3485 case elfcpp::R_SPARC_GOTDATA_OP: 3486 if (gdop_valid) 3487 { 3488 typedef typename elfcpp::Swap<32, true>::Valtype Insntype; 3489 Insntype* wv = reinterpret_cast<Insntype*>(view); 3490 Insntype val; 3491 3492 // {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd 3493 val = elfcpp::Swap<32, true>::readval(wv); 3494 val = 0x80000000 | (val & 0x3e07c01f); 3495 elfcpp::Swap<32, true>::writeval(wv, val); 3496 } 3497 break; 3498 3499 case elfcpp::R_SPARC_GOT13: 3500 Reloc::rela32_13(view, got_offset, addend); 3501 break; 3502 3503 case elfcpp::R_SPARC_GOTDATA_OP_HIX22: 3504 if (gdop_valid) 3505 { 3506 Reloc::gdop_hix22(view, got_offset); 3507 break; 3508 } 3509 // Fall through. 3510 case elfcpp::R_SPARC_GOT22: 3511 Reloc::hi22(view, got_offset, addend); 3512 break; 3513 3514 case elfcpp::R_SPARC_PC10: 3515 Reloc::pc10(view, object, psymval, addend, address); 3516 break; 3517 3518 case elfcpp::R_SPARC_PC22: 3519 Reloc::pc22(view, object, psymval, addend, address); 3520 break; 3521 3522 case elfcpp::R_SPARC_TLS_DTPOFF32: 3523 case elfcpp::R_SPARC_UA32: 3524 Reloc::ua32(view, object, psymval, addend); 3525 break; 3526 3527 case elfcpp::R_SPARC_PLT64: 3528 Relocate_functions<size, big_endian>::rela64(view, object, 3529 psymval, addend); 3530 break; 3531 3532 case elfcpp::R_SPARC_PLT32: 3533 Relocate_functions<size, big_endian>::rela32(view, object, 3534 psymval, addend); 3535 break; 3536 3537 case elfcpp::R_SPARC_HIPLT22: 3538 Reloc::hi22(view, object, psymval, addend); 3539 break; 3540 3541 case elfcpp::R_SPARC_LOPLT10: 3542 Reloc::lo10(view, object, psymval, addend); 3543 break; 3544 3545 case elfcpp::R_SPARC_PCPLT32: 3546 Reloc::disp32(view, object, psymval, addend, address); 3547 break; 3548 3549 case elfcpp::R_SPARC_PCPLT22: 3550 Reloc::pcplt22(view, object, psymval, addend, address); 3551 break; 3552 3553 case elfcpp::R_SPARC_PCPLT10: 3554 Reloc::lo10(view, object, psymval, addend, address); 3555 break; 3556 3557 case elfcpp::R_SPARC_64: 3558 if (!parameters->options().output_is_position_independent()) 3559 { 3560 if (rela.get_r_offset() & 0x7) 3561 { 3562 // The assembler can sometimes emit unaligned relocations 3563 // for dwarf2 cfi directives. 3564 Reloc::ua64(view, object, psymval, addend); 3565 } 3566 else 3567 Relocate_functions<size, big_endian>::rela64(view, object, 3568 psymval, addend); 3569 } 3570 break; 3571 3572 case elfcpp::R_SPARC_OLO10: 3573 { 3574 unsigned int addend2 = rela.get_r_info() & 0xffffffff; 3575 addend2 = ((addend2 >> 8) ^ 0x800000) - 0x800000; 3576 Reloc::olo10(view, object, psymval, addend, addend2); 3577 } 3578 break; 3579 3580 case elfcpp::R_SPARC_HH22: 3581 Reloc::hh22(view, object, psymval, addend); 3582 break; 3583 3584 case elfcpp::R_SPARC_PC_HH22: 3585 Reloc::pc_hh22(view, object, psymval, addend, address); 3586 break; 3587 3588 case elfcpp::R_SPARC_HM10: 3589 Reloc::hm10(view, object, psymval, addend); 3590 break; 3591 3592 case elfcpp::R_SPARC_PC_HM10: 3593 Reloc::pc_hm10(view, object, psymval, addend, address); 3594 break; 3595 3596 case elfcpp::R_SPARC_LM22: 3597 Reloc::hi22(view, object, psymval, addend); 3598 break; 3599 3600 case elfcpp::R_SPARC_PC_LM22: 3601 Reloc::pcplt22(view, object, psymval, addend, address); 3602 break; 3603 3604 case elfcpp::R_SPARC_11: 3605 Reloc::rela32_11(view, object, psymval, addend); 3606 break; 3607 3608 case elfcpp::R_SPARC_10: 3609 Reloc::rela32_10(view, object, psymval, addend); 3610 break; 3611 3612 case elfcpp::R_SPARC_7: 3613 Reloc::rela32_7(view, object, psymval, addend); 3614 break; 3615 3616 case elfcpp::R_SPARC_6: 3617 Reloc::rela32_6(view, object, psymval, addend); 3618 break; 3619 3620 case elfcpp::R_SPARC_5: 3621 Reloc::rela32_5(view, object, psymval, addend); 3622 break; 3623 3624 case elfcpp::R_SPARC_HIX22: 3625 Reloc::hix22(view, object, psymval, addend); 3626 break; 3627 3628 case elfcpp::R_SPARC_LOX10: 3629 Reloc::lox10(view, object, psymval, addend); 3630 break; 3631 3632 case elfcpp::R_SPARC_H34: 3633 Reloc::h34(view, object, psymval, addend); 3634 break; 3635 3636 case elfcpp::R_SPARC_H44: 3637 Reloc::h44(view, object, psymval, addend); 3638 break; 3639 3640 case elfcpp::R_SPARC_M44: 3641 Reloc::m44(view, object, psymval, addend); 3642 break; 3643 3644 case elfcpp::R_SPARC_L44: 3645 Reloc::l44(view, object, psymval, addend); 3646 break; 3647 3648 case elfcpp::R_SPARC_TLS_DTPOFF64: 3649 case elfcpp::R_SPARC_UA64: 3650 Reloc::ua64(view, object, psymval, addend); 3651 break; 3652 3653 case elfcpp::R_SPARC_UA16: 3654 Reloc::ua16(view, object, psymval, addend); 3655 break; 3656 3657 case elfcpp::R_SPARC_TLS_GD_HI22: 3658 case elfcpp::R_SPARC_TLS_GD_LO10: 3659 case elfcpp::R_SPARC_TLS_GD_ADD: 3660 case elfcpp::R_SPARC_TLS_GD_CALL: 3661 case elfcpp::R_SPARC_TLS_LDM_HI22: 3662 case elfcpp::R_SPARC_TLS_LDM_LO10: 3663 case elfcpp::R_SPARC_TLS_LDM_ADD: 3664 case elfcpp::R_SPARC_TLS_LDM_CALL: 3665 case elfcpp::R_SPARC_TLS_LDO_HIX22: 3666 case elfcpp::R_SPARC_TLS_LDO_LOX10: 3667 case elfcpp::R_SPARC_TLS_LDO_ADD: 3668 case elfcpp::R_SPARC_TLS_IE_HI22: 3669 case elfcpp::R_SPARC_TLS_IE_LO10: 3670 case elfcpp::R_SPARC_TLS_IE_LD: 3671 case elfcpp::R_SPARC_TLS_IE_LDX: 3672 case elfcpp::R_SPARC_TLS_IE_ADD: 3673 case elfcpp::R_SPARC_TLS_LE_HIX22: 3674 case elfcpp::R_SPARC_TLS_LE_LOX10: 3675 this->relocate_tls(relinfo, target, relnum, rela, 3676 r_type, gsym, psymval, view, 3677 address, view_size); 3678 break; 3679 3680 case elfcpp::R_SPARC_COPY: 3681 case elfcpp::R_SPARC_GLOB_DAT: 3682 case elfcpp::R_SPARC_JMP_SLOT: 3683 case elfcpp::R_SPARC_JMP_IREL: 3684 case elfcpp::R_SPARC_RELATIVE: 3685 case elfcpp::R_SPARC_IRELATIVE: 3686 // These are outstanding tls relocs, which are unexpected when 3687 // linking. 3688 case elfcpp::R_SPARC_TLS_DTPMOD64: 3689 case elfcpp::R_SPARC_TLS_DTPMOD32: 3690 case elfcpp::R_SPARC_TLS_TPOFF64: 3691 case elfcpp::R_SPARC_TLS_TPOFF32: 3692 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3693 _("unexpected reloc %u in object file"), 3694 r_type); 3695 break; 3696 3697 default: 3698 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3699 _("unsupported reloc %u"), 3700 r_type); 3701 break; 3702 } 3703 3704 return true; 3705} 3706 3707// Perform a TLS relocation. 3708 3709template<int size, bool big_endian> 3710inline void 3711Target_sparc<size, big_endian>::Relocate::relocate_tls( 3712 const Relocate_info<size, big_endian>* relinfo, 3713 Target_sparc<size, big_endian>* target, 3714 size_t relnum, 3715 const elfcpp::Rela<size, big_endian>& rela, 3716 unsigned int r_type, 3717 const Sized_symbol<size>* gsym, 3718 const Symbol_value<size>* psymval, 3719 unsigned char* view, 3720 typename elfcpp::Elf_types<size>::Elf_Addr address, 3721 section_size_type) 3722{ 3723 Output_segment* tls_segment = relinfo->layout->tls_segment(); 3724 typedef Sparc_relocate_functions<size, big_endian> Reloc; 3725 const Sized_relobj_file<size, big_endian>* object = relinfo->object; 3726 typedef typename elfcpp::Swap<32, true>::Valtype Insntype; 3727 3728 const elfcpp::Elf_Xword addend = rela.get_r_addend(); 3729 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0); 3730 3731 const bool is_final = 3732 (gsym == NULL 3733 ? !parameters->options().shared() 3734 : gsym->final_value_is_known()); 3735 const tls::Tls_optimization optimized_type 3736 = optimize_tls_reloc(is_final, r_type); 3737 3738 switch (r_type) 3739 { 3740 case elfcpp::R_SPARC_TLS_GD_HI22: 3741 case elfcpp::R_SPARC_TLS_GD_LO10: 3742 case elfcpp::R_SPARC_TLS_GD_ADD: 3743 case elfcpp::R_SPARC_TLS_GD_CALL: 3744 if (optimized_type == tls::TLSOPT_TO_LE) 3745 { 3746 Insntype* wv = reinterpret_cast<Insntype*>(view); 3747 Insntype val; 3748 3749 value -= tls_segment->memsz(); 3750 3751 switch (r_type) 3752 { 3753 case elfcpp::R_SPARC_TLS_GD_HI22: 3754 // TLS_GD_HI22 --> TLS_LE_HIX22 3755 Reloc::hix22(view, value, addend); 3756 break; 3757 3758 case elfcpp::R_SPARC_TLS_GD_LO10: 3759 // TLS_GD_LO10 --> TLS_LE_LOX10 3760 Reloc::lox10(view, value, addend); 3761 break; 3762 3763 case elfcpp::R_SPARC_TLS_GD_ADD: 3764 // add %reg1, %reg2, %reg3 --> mov %g7, %reg2, %reg3 3765 val = elfcpp::Swap<32, true>::readval(wv); 3766 val = (val & ~0x7c000) | 0x1c000; 3767 elfcpp::Swap<32, true>::writeval(wv, val); 3768 break; 3769 case elfcpp::R_SPARC_TLS_GD_CALL: 3770 // call __tls_get_addr --> nop 3771 elfcpp::Swap<32, true>::writeval(wv, sparc_nop); 3772 break; 3773 } 3774 break; 3775 } 3776 else 3777 { 3778 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE 3779 ? GOT_TYPE_TLS_OFFSET 3780 : GOT_TYPE_TLS_PAIR); 3781 if (gsym != NULL) 3782 { 3783 gold_assert(gsym->has_got_offset(got_type)); 3784 value = gsym->got_offset(got_type); 3785 } 3786 else 3787 { 3788 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 3789 gold_assert(object->local_has_got_offset(r_sym, got_type)); 3790 value = object->local_got_offset(r_sym, got_type); 3791 } 3792 if (optimized_type == tls::TLSOPT_TO_IE) 3793 { 3794 Insntype* wv = reinterpret_cast<Insntype*>(view); 3795 Insntype val; 3796 3797 switch (r_type) 3798 { 3799 case elfcpp::R_SPARC_TLS_GD_HI22: 3800 // TLS_GD_HI22 --> TLS_IE_HI22 3801 Reloc::hi22(view, value, addend); 3802 break; 3803 3804 case elfcpp::R_SPARC_TLS_GD_LO10: 3805 // TLS_GD_LO10 --> TLS_IE_LO10 3806 Reloc::lo10(view, value, addend); 3807 break; 3808 3809 case elfcpp::R_SPARC_TLS_GD_ADD: 3810 // add %reg1, %reg2, %reg3 --> ld [%reg1 + %reg2], %reg3 3811 val = elfcpp::Swap<32, true>::readval(wv); 3812 3813 if (size == 64) 3814 val |= 0xc0580000; 3815 else 3816 val |= 0xc0000000; 3817 3818 elfcpp::Swap<32, true>::writeval(wv, val); 3819 break; 3820 3821 case elfcpp::R_SPARC_TLS_GD_CALL: 3822 // The compiler can put the TLS_GD_ADD instruction 3823 // into the delay slot of the call. If so, we need 3824 // to transpose the two instructions so that the 3825 // new sequence works properly. 3826 // 3827 // The test we use is if the instruction in the 3828 // delay slot is an add with destination register 3829 // equal to %o0 3830 val = elfcpp::Swap<32, true>::readval(wv + 1); 3831 if ((val & 0x81f80000) == 0x80000000 3832 && ((val >> 25) & 0x1f) == 0x8) 3833 { 3834 if (size == 64) 3835 val |= 0xc0580000; 3836 else 3837 val |= 0xc0000000; 3838 3839 elfcpp::Swap<32, true>::writeval(wv, val); 3840 3841 wv += 1; 3842 this->ignore_gd_add_ = true; 3843 } 3844 else 3845 { 3846 // Even if the delay slot isn't the TLS_GD_ADD 3847 // instruction, we still have to handle the case 3848 // where it sets up %o0 in some other way. 3849 elfcpp::Swap<32, true>::writeval(wv, val); 3850 wv += 1; 3851 this->reloc_adjust_addr_ = view + 4; 3852 } 3853 // call __tls_get_addr --> add %g7, %o0, %o0 3854 elfcpp::Swap<32, true>::writeval(wv, 0x9001c008); 3855 break; 3856 } 3857 break; 3858 } 3859 else if (optimized_type == tls::TLSOPT_NONE) 3860 { 3861 switch (r_type) 3862 { 3863 case elfcpp::R_SPARC_TLS_GD_HI22: 3864 Reloc::hi22(view, value, addend); 3865 break; 3866 case elfcpp::R_SPARC_TLS_GD_LO10: 3867 Reloc::lo10(view, value, addend); 3868 break; 3869 case elfcpp::R_SPARC_TLS_GD_ADD: 3870 break; 3871 case elfcpp::R_SPARC_TLS_GD_CALL: 3872 { 3873 Symbol_value<size> symval; 3874 elfcpp::Elf_Xword value; 3875 Symbol* tsym; 3876 3877 tsym = target->tls_get_addr_sym_; 3878 gold_assert(tsym); 3879 value = (target->plt_section()->address() + 3880 tsym->plt_offset()); 3881 symval.set_output_value(value); 3882 Reloc::wdisp30(view, object, &symval, addend, address); 3883 } 3884 break; 3885 } 3886 break; 3887 } 3888 } 3889 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3890 _("unsupported reloc %u"), 3891 r_type); 3892 break; 3893 3894 case elfcpp::R_SPARC_TLS_LDM_HI22: 3895 case elfcpp::R_SPARC_TLS_LDM_LO10: 3896 case elfcpp::R_SPARC_TLS_LDM_ADD: 3897 case elfcpp::R_SPARC_TLS_LDM_CALL: 3898 if (optimized_type == tls::TLSOPT_TO_LE) 3899 { 3900 Insntype* wv = reinterpret_cast<Insntype*>(view); 3901 3902 switch (r_type) 3903 { 3904 case elfcpp::R_SPARC_TLS_LDM_HI22: 3905 case elfcpp::R_SPARC_TLS_LDM_LO10: 3906 case elfcpp::R_SPARC_TLS_LDM_ADD: 3907 elfcpp::Swap<32, true>::writeval(wv, sparc_nop); 3908 break; 3909 3910 case elfcpp::R_SPARC_TLS_LDM_CALL: 3911 elfcpp::Swap<32, true>::writeval(wv, sparc_mov_g0_o0); 3912 break; 3913 } 3914 break; 3915 } 3916 else if (optimized_type == tls::TLSOPT_NONE) 3917 { 3918 // Relocate the field with the offset of the GOT entry for 3919 // the module index. 3920 unsigned int got_offset; 3921 3922 got_offset = target->got_mod_index_entry(NULL, NULL, NULL); 3923 switch (r_type) 3924 { 3925 case elfcpp::R_SPARC_TLS_LDM_HI22: 3926 Reloc::hi22(view, got_offset, addend); 3927 break; 3928 case elfcpp::R_SPARC_TLS_LDM_LO10: 3929 Reloc::lo10(view, got_offset, addend); 3930 break; 3931 case elfcpp::R_SPARC_TLS_LDM_ADD: 3932 break; 3933 case elfcpp::R_SPARC_TLS_LDM_CALL: 3934 { 3935 Symbol_value<size> symval; 3936 elfcpp::Elf_Xword value; 3937 Symbol* tsym; 3938 3939 tsym = target->tls_get_addr_sym_; 3940 gold_assert(tsym); 3941 value = (target->plt_section()->address() + 3942 tsym->plt_offset()); 3943 symval.set_output_value(value); 3944 Reloc::wdisp30(view, object, &symval, addend, address); 3945 } 3946 break; 3947 } 3948 break; 3949 } 3950 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 3951 _("unsupported reloc %u"), 3952 r_type); 3953 break; 3954 3955 // These relocs can appear in debugging sections, in which case 3956 // we won't see the TLS_LDM relocs. The local_dynamic_type 3957 // field tells us this. 3958 case elfcpp::R_SPARC_TLS_LDO_HIX22: 3959 if (optimized_type == tls::TLSOPT_TO_LE) 3960 { 3961 value -= tls_segment->memsz(); 3962 Reloc::hix22(view, value, addend); 3963 } 3964 else 3965 Reloc::ldo_hix22(view, value, addend); 3966 break; 3967 case elfcpp::R_SPARC_TLS_LDO_LOX10: 3968 if (optimized_type == tls::TLSOPT_TO_LE) 3969 { 3970 value -= tls_segment->memsz(); 3971 Reloc::lox10(view, value, addend); 3972 } 3973 else 3974 Reloc::ldo_lox10(view, value, addend); 3975 break; 3976 case elfcpp::R_SPARC_TLS_LDO_ADD: 3977 if (optimized_type == tls::TLSOPT_TO_LE) 3978 { 3979 Insntype* wv = reinterpret_cast<Insntype*>(view); 3980 Insntype val; 3981 3982 // add %reg1, %reg2, %reg3 --> add %g7, %reg2, %reg3 3983 val = elfcpp::Swap<32, true>::readval(wv); 3984 val = (val & ~0x7c000) | 0x1c000; 3985 elfcpp::Swap<32, true>::writeval(wv, val); 3986 } 3987 break; 3988 3989 // When optimizing IE --> LE, the only relocation that is handled 3990 // differently is R_SPARC_TLS_IE_LD, it is rewritten from 3991 // 'ld{,x} [rs1 + rs2], rd' into 'mov rs2, rd' or simply a NOP is 3992 // rs2 and rd are the same. 3993 case elfcpp::R_SPARC_TLS_IE_LD: 3994 case elfcpp::R_SPARC_TLS_IE_LDX: 3995 if (optimized_type == tls::TLSOPT_TO_LE) 3996 { 3997 Insntype* wv = reinterpret_cast<Insntype*>(view); 3998 Insntype val = elfcpp::Swap<32, true>::readval(wv); 3999 Insntype rs2 = val & 0x1f; 4000 Insntype rd = (val >> 25) & 0x1f; 4001 4002 if (rs2 == rd) 4003 val = sparc_nop; 4004 else 4005 val = sparc_mov | (val & 0x3e00001f); 4006 4007 elfcpp::Swap<32, true>::writeval(wv, val); 4008 } 4009 break; 4010 4011 case elfcpp::R_SPARC_TLS_IE_HI22: 4012 case elfcpp::R_SPARC_TLS_IE_LO10: 4013 if (optimized_type == tls::TLSOPT_TO_LE) 4014 { 4015 value -= tls_segment->memsz(); 4016 switch (r_type) 4017 { 4018 case elfcpp::R_SPARC_TLS_IE_HI22: 4019 // IE_HI22 --> LE_HIX22 4020 Reloc::hix22(view, value, addend); 4021 break; 4022 case elfcpp::R_SPARC_TLS_IE_LO10: 4023 // IE_LO10 --> LE_LOX10 4024 Reloc::lox10(view, value, addend); 4025 break; 4026 } 4027 break; 4028 } 4029 else if (optimized_type == tls::TLSOPT_NONE) 4030 { 4031 // Relocate the field with the offset of the GOT entry for 4032 // the tp-relative offset of the symbol. 4033 if (gsym != NULL) 4034 { 4035 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET)); 4036 value = gsym->got_offset(GOT_TYPE_TLS_OFFSET); 4037 } 4038 else 4039 { 4040 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); 4041 gold_assert(object->local_has_got_offset(r_sym, 4042 GOT_TYPE_TLS_OFFSET)); 4043 value = object->local_got_offset(r_sym, 4044 GOT_TYPE_TLS_OFFSET); 4045 } 4046 switch (r_type) 4047 { 4048 case elfcpp::R_SPARC_TLS_IE_HI22: 4049 Reloc::hi22(view, value, addend); 4050 break; 4051 case elfcpp::R_SPARC_TLS_IE_LO10: 4052 Reloc::lo10(view, value, addend); 4053 break; 4054 } 4055 break; 4056 } 4057 gold_error_at_location(relinfo, relnum, rela.get_r_offset(), 4058 _("unsupported reloc %u"), 4059 r_type); 4060 break; 4061 4062 case elfcpp::R_SPARC_TLS_IE_ADD: 4063 // This seems to be mainly so that we can find the addition 4064 // instruction if there is one. There doesn't seem to be any 4065 // actual relocation to apply. 4066 break; 4067 4068 case elfcpp::R_SPARC_TLS_LE_HIX22: 4069 // If we're creating a shared library, a dynamic relocation will 4070 // have been created for this location, so do not apply it now. 4071 if (!parameters->options().shared()) 4072 { 4073 value -= tls_segment->memsz(); 4074 Reloc::hix22(view, value, addend); 4075 } 4076 break; 4077 4078 case elfcpp::R_SPARC_TLS_LE_LOX10: 4079 // If we're creating a shared library, a dynamic relocation will 4080 // have been created for this location, so do not apply it now. 4081 if (!parameters->options().shared()) 4082 { 4083 value -= tls_segment->memsz(); 4084 Reloc::lox10(view, value, addend); 4085 } 4086 break; 4087 } 4088} 4089 4090// Relax a call instruction. 4091 4092template<int size, bool big_endian> 4093inline void 4094Target_sparc<size, big_endian>::Relocate::relax_call( 4095 Target_sparc<size, big_endian>* target, 4096 unsigned char* view, 4097 const elfcpp::Rela<size, big_endian>& rela, 4098 section_size_type view_size) 4099{ 4100 typedef typename elfcpp::Swap<32, true>::Valtype Insntype; 4101 Insntype *wv = reinterpret_cast<Insntype*>(view); 4102 Insntype call_insn, delay_insn, set_insn; 4103 uint32_t op3, reg, off; 4104 4105 // This code tries to relax call instructions that meet 4106 // certain criteria. 4107 // 4108 // The first criteria is that the call must be such that the return 4109 // address which the call writes into %o7 is unused. Two sequences 4110 // meet this criteria, and are used to implement tail calls. 4111 // 4112 // Leaf function tail call: 4113 // 4114 // or %o7, %g0, %ANY_REG 4115 // call FUNC 4116 // or %ANY_REG, %g0, %o7 4117 // 4118 // Non-leaf function tail call: 4119 // 4120 // call FUNC 4121 // restore 4122 // 4123 // The second criteria is that the call destination is close. If 4124 // the displacement can fit in a signed 22-bit immediate field of a 4125 // pre-V9 branch, we can do it. If we are generating a 64-bit 4126 // object or a 32-bit object with ELF machine type EF_SPARC32PLUS, 4127 // and the displacement fits in a signed 19-bit immediate field, 4128 // then we can use a V9 branch. 4129 4130 // Make sure the delay instruction can be safely accessed. 4131 if (rela.get_r_offset() + 8 > view_size) 4132 return; 4133 4134 call_insn = elfcpp::Swap<32, true>::readval(wv); 4135 delay_insn = elfcpp::Swap<32, true>::readval(wv + 1); 4136 4137 // Make sure it is really a call instruction. 4138 if (((call_insn >> 30) & 0x3) != 1) 4139 return; 4140 4141 if (((delay_insn >> 30) & 0x3) != 2) 4142 return; 4143 4144 // Accept only a restore or an integer arithmetic operation whose 4145 // sole side effect is to write the %o7 register (and perhaps set 4146 // the condition codes, which are considered clobbered across 4147 // function calls). 4148 // 4149 // For example, we don't want to match a tagged addition or 4150 // subtraction. We also don't want to match something like a 4151 // divide. 4152 // 4153 // Specifically we accept add{,cc}, and{,cc}, or{,cc}, 4154 // xor{,cc}, sub{,cc}, andn{,cc}, orn{,cc}, and xnor{,cc}. 4155 4156 op3 = (delay_insn >> 19) & 0x3f; 4157 reg = (delay_insn >> 25) & 0x1f; 4158 if (op3 != 0x3d 4159 && ((op3 & 0x28) != 0 || reg != 15)) 4160 return; 4161 4162 // For non-restore instructions, make sure %o7 isn't 4163 // an input. 4164 if (op3 != 0x3d) 4165 { 4166 // First check RS1 4167 reg = (delay_insn >> 14) & 0x15; 4168 if (reg == 15) 4169 return; 4170 4171 // And if non-immediate, check RS2 4172 if (((delay_insn >> 13) & 1) == 0) 4173 { 4174 reg = (delay_insn & 0x1f); 4175 if (reg == 15) 4176 return; 4177 } 4178 } 4179 4180 // Now check the branch distance. We are called after the 4181 // call has been relocated, so we just have to peek at the 4182 // offset contained in the instruction. 4183 off = call_insn & 0x3fffffff; 4184 if ((off & 0x3fe00000) != 0 4185 && (off & 0x3fe00000) != 0x3fe00000) 4186 return; 4187 4188 if ((size == 64 || target->elf_machine_ == elfcpp::EM_SPARC32PLUS) 4189 && ((off & 0x3c0000) == 0 4190 || (off & 0x3c0000) == 0x3c0000)) 4191 { 4192 // ba,pt %xcc, FUNC 4193 call_insn = 0x10680000 | (off & 0x07ffff); 4194 } 4195 else 4196 { 4197 // ba FUNC 4198 call_insn = 0x10800000 | (off & 0x3fffff); 4199 } 4200 elfcpp::Swap<32, true>::writeval(wv, call_insn); 4201 4202 // See if we can NOP out the delay slot instruction. We peek 4203 // at the instruction before the call to make sure we're dealing 4204 // with exactly the: 4205 // 4206 // or %o7, %g0, %ANY_REG 4207 // call 4208 // or %ANY_REG, %g0, %o7 4209 // 4210 // case. Otherwise this might be a tricky piece of hand written 4211 // assembler calculating %o7 in some non-trivial way, and therefore 4212 // we can't be sure that NOP'ing out the delay slot is safe. 4213 if (op3 == 0x02 4214 && rela.get_r_offset() >= 4) 4215 { 4216 if ((delay_insn & ~(0x1f << 14)) != 0x9e100000) 4217 return; 4218 4219 set_insn = elfcpp::Swap<32, true>::readval(wv - 1); 4220 if ((set_insn & ~(0x1f << 25)) != 0x8013c000) 4221 return; 4222 4223 reg = (set_insn >> 25) & 0x1f; 4224 if (reg == 0 || reg == 15) 4225 return; 4226 if (reg != ((delay_insn >> 14) & 0x1f)) 4227 return; 4228 4229 // All tests pass, nop it out. 4230 elfcpp::Swap<32, true>::writeval(wv + 1, sparc_nop); 4231 } 4232} 4233 4234// Relocate section data. 4235 4236template<int size, bool big_endian> 4237void 4238Target_sparc<size, big_endian>::relocate_section( 4239 const Relocate_info<size, big_endian>* relinfo, 4240 unsigned int sh_type, 4241 const unsigned char* prelocs, 4242 size_t reloc_count, 4243 Output_section* output_section, 4244 bool needs_special_offset_handling, 4245 unsigned char* view, 4246 typename elfcpp::Elf_types<size>::Elf_Addr address, 4247 section_size_type view_size, 4248 const Reloc_symbol_changes* reloc_symbol_changes) 4249{ 4250 typedef Target_sparc<size, big_endian> Sparc; 4251 typedef typename Target_sparc<size, big_endian>::Relocate Sparc_relocate; 4252 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4253 Classify_reloc; 4254 4255 gold_assert(sh_type == elfcpp::SHT_RELA); 4256 4257 gold::relocate_section<size, big_endian, Sparc, Sparc_relocate, 4258 gold::Default_comdat_behavior, Classify_reloc>( 4259 relinfo, 4260 this, 4261 prelocs, 4262 reloc_count, 4263 output_section, 4264 needs_special_offset_handling, 4265 view, 4266 address, 4267 view_size, 4268 reloc_symbol_changes); 4269} 4270 4271// Scan the relocs during a relocatable link. 4272 4273template<int size, bool big_endian> 4274void 4275Target_sparc<size, big_endian>::scan_relocatable_relocs( 4276 Symbol_table* symtab, 4277 Layout* layout, 4278 Sized_relobj_file<size, big_endian>* object, 4279 unsigned int data_shndx, 4280 unsigned int sh_type, 4281 const unsigned char* prelocs, 4282 size_t reloc_count, 4283 Output_section* output_section, 4284 bool needs_special_offset_handling, 4285 size_t local_symbol_count, 4286 const unsigned char* plocal_symbols, 4287 Relocatable_relocs* rr) 4288{ 4289 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4290 Classify_reloc; 4291 typedef gold::Default_scan_relocatable_relocs<Classify_reloc> 4292 Scan_relocatable_relocs; 4293 4294 gold_assert(sh_type == elfcpp::SHT_RELA); 4295 4296 gold::scan_relocatable_relocs<size, big_endian, Scan_relocatable_relocs>( 4297 symtab, 4298 layout, 4299 object, 4300 data_shndx, 4301 prelocs, 4302 reloc_count, 4303 output_section, 4304 needs_special_offset_handling, 4305 local_symbol_count, 4306 plocal_symbols, 4307 rr); 4308} 4309 4310// Scan the relocs for --emit-relocs. 4311 4312template<int size, bool big_endian> 4313void 4314Target_sparc<size, big_endian>::emit_relocs_scan( 4315 Symbol_table* symtab, 4316 Layout* layout, 4317 Sized_relobj_file<size, big_endian>* object, 4318 unsigned int data_shndx, 4319 unsigned int sh_type, 4320 const unsigned char* prelocs, 4321 size_t reloc_count, 4322 Output_section* output_section, 4323 bool needs_special_offset_handling, 4324 size_t local_symbol_count, 4325 const unsigned char* plocal_syms, 4326 Relocatable_relocs* rr) 4327{ 4328 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4329 Classify_reloc; 4330 typedef gold::Default_emit_relocs_strategy<Classify_reloc> 4331 Emit_relocs_strategy; 4332 4333 gold_assert(sh_type == elfcpp::SHT_RELA); 4334 4335 gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>( 4336 symtab, 4337 layout, 4338 object, 4339 data_shndx, 4340 prelocs, 4341 reloc_count, 4342 output_section, 4343 needs_special_offset_handling, 4344 local_symbol_count, 4345 plocal_syms, 4346 rr); 4347} 4348 4349// Emit relocations for a section. 4350 4351template<int size, bool big_endian> 4352void 4353Target_sparc<size, big_endian>::relocate_relocs( 4354 const Relocate_info<size, big_endian>* relinfo, 4355 unsigned int sh_type, 4356 const unsigned char* prelocs, 4357 size_t reloc_count, 4358 Output_section* output_section, 4359 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section, 4360 unsigned char* view, 4361 typename elfcpp::Elf_types<size>::Elf_Addr view_address, 4362 section_size_type view_size, 4363 unsigned char* reloc_view, 4364 section_size_type reloc_view_size) 4365{ 4366 typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 4367 Classify_reloc; 4368 4369 gold_assert(sh_type == elfcpp::SHT_RELA); 4370 4371 gold::relocate_relocs<size, big_endian, Classify_reloc>( 4372 relinfo, 4373 prelocs, 4374 reloc_count, 4375 output_section, 4376 offset_in_output_section, 4377 view, 4378 view_address, 4379 view_size, 4380 reloc_view, 4381 reloc_view_size); 4382} 4383 4384// Return the value to use for a dynamic which requires special 4385// treatment. This is how we support equality comparisons of function 4386// pointers across shared library boundaries, as described in the 4387// processor specific ABI supplement. 4388 4389template<int size, bool big_endian> 4390uint64_t 4391Target_sparc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const 4392{ 4393 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset()); 4394 return this->plt_section()->address() + gsym->plt_offset(); 4395} 4396 4397// do_make_elf_object to override the same function in the base class. 4398// We need to use a target-specific sub-class of 4399// Sized_relobj_file<size, big_endian> to process SPARC specific bits 4400// of the ELF headers. Hence we need to have our own ELF object creation. 4401 4402template<int size, bool big_endian> 4403Object* 4404Target_sparc<size, big_endian>::do_make_elf_object( 4405 const std::string& name, 4406 Input_file* input_file, 4407 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr) 4408{ 4409 elfcpp::Elf_Half machine = ehdr.get_e_machine(); 4410 elfcpp::Elf_Word flags = ehdr.get_e_flags(); 4411 elfcpp::Elf_Word omm, mm; 4412 4413 switch (machine) 4414 { 4415 case elfcpp::EM_SPARC32PLUS: 4416 this->elf_machine_ = elfcpp::EM_SPARC32PLUS; 4417 break; 4418 4419 case elfcpp::EM_SPARC: 4420 case elfcpp::EM_SPARCV9: 4421 break; 4422 4423 default: 4424 break; 4425 } 4426 4427 if (!this->elf_flags_set_) 4428 { 4429 this->elf_flags_ = flags; 4430 this->elf_flags_set_ = true; 4431 } 4432 else 4433 { 4434 // Accumulate cpu feature bits. 4435 this->elf_flags_ |= (flags & (elfcpp::EF_SPARC_32PLUS 4436 | elfcpp::EF_SPARC_SUN_US1 4437 | elfcpp::EF_SPARC_HAL_R1 4438 | elfcpp::EF_SPARC_SUN_US3)); 4439 4440 // Bump the memory model setting to the most restrictive 4441 // one we encounter. 4442 omm = (this->elf_flags_ & elfcpp::EF_SPARCV9_MM); 4443 mm = (flags & elfcpp::EF_SPARCV9_MM); 4444 if (omm != mm) 4445 { 4446 if (mm == elfcpp::EF_SPARCV9_TSO) 4447 { 4448 this->elf_flags_ &= ~elfcpp::EF_SPARCV9_MM; 4449 this->elf_flags_ |= elfcpp::EF_SPARCV9_TSO; 4450 } 4451 else if (mm == elfcpp::EF_SPARCV9_PSO 4452 && omm == elfcpp::EF_SPARCV9_RMO) 4453 { 4454 this->elf_flags_ &= ~elfcpp::EF_SPARCV9_MM; 4455 this->elf_flags_ |= elfcpp::EF_SPARCV9_PSO; 4456 } 4457 } 4458 } 4459 4460 // Validate that the little-endian flag matches how we've 4461 // been instantiated. 4462 if (!(flags & elfcpp::EF_SPARC_LEDATA) != big_endian) 4463 { 4464 if (big_endian) 4465 gold_error(_("%s: little endian elf flag set on BE object"), 4466 name.c_str()); 4467 else 4468 gold_error(_("%s: little endian elf flag clear on LE object"), 4469 name.c_str()); 4470 } 4471 4472 return Target::do_make_elf_object(name, input_file, offset, ehdr); 4473} 4474 4475// Adjust ELF file header. 4476 4477template<int size, bool big_endian> 4478void 4479Target_sparc<size, big_endian>::do_adjust_elf_header( 4480 unsigned char* view, 4481 int len) 4482{ 4483 elfcpp::Ehdr_write<size, big_endian> oehdr(view); 4484 4485 oehdr.put_e_machine(this->elf_machine_); 4486 oehdr.put_e_flags(this->elf_flags_); 4487 4488 Sized_target<size, big_endian>::do_adjust_elf_header(view, len); 4489} 4490 4491// The selector for sparc object files. 4492 4493template<int size, bool big_endian> 4494class Target_selector_sparc : public Target_selector 4495{ 4496public: 4497 Target_selector_sparc() 4498 : Target_selector(elfcpp::EM_NONE, size, big_endian, 4499 (size == 64 ? "elf64-sparc" : "elf32-sparc"), 4500 (size == 64 ? "elf64_sparc" : "elf32_sparc")) 4501 { } 4502 4503 virtual Target* 4504 do_recognize(Input_file*, off_t, int machine, int, int) 4505 { 4506 switch (size) 4507 { 4508 case 64: 4509 if (machine != elfcpp::EM_SPARCV9) 4510 return NULL; 4511 break; 4512 4513 case 32: 4514 if (machine != elfcpp::EM_SPARC 4515 && machine != elfcpp::EM_SPARC32PLUS) 4516 return NULL; 4517 break; 4518 4519 default: 4520 return NULL; 4521 } 4522 4523 return this->instantiate_target(); 4524 } 4525 4526 virtual Target* 4527 do_instantiate_target() 4528 { return new Target_sparc<size, big_endian>(); } 4529}; 4530 4531Target_selector_sparc<32, true> target_selector_sparc32; 4532Target_selector_sparc<64, true> target_selector_sparc64; 4533 4534} // End anonymous namespace. 4535