1 // sparc.cc -- sparc target support for gold.
3 // Copyright 2008, 2009 Free Software Foundation, Inc.
4 // Written by David S. Miller <davem@davemloft.net>.
6 // This file is part of gold.
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.
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.
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.
30 #include "parameters.h"
37 #include "copy-relocs.h"
39 #include "target-reloc.h"
40 #include "target-select.h"
50 template<int size, bool big_endian>
51 class Output_data_plt_sparc;
53 template<int size, bool big_endian>
54 class Target_sparc : public Sized_target<size, big_endian>
57 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
60 : Sized_target<size, big_endian>(&sparc_info),
61 got_(NULL), plt_(NULL), rela_dyn_(NULL),
62 copy_relocs_(elfcpp::R_SPARC_COPY), dynbss_(NULL),
63 got_mod_index_offset_(-1U), tls_get_addr_sym_(NULL)
67 // Process the relocations to determine unreferenced sections for
68 // garbage collection.
70 gc_process_relocs(Symbol_table* symtab,
72 Sized_relobj<size, big_endian>* object,
73 unsigned int data_shndx,
75 const unsigned char* prelocs,
77 Output_section* output_section,
78 bool needs_special_offset_handling,
79 size_t local_symbol_count,
80 const unsigned char* plocal_symbols);
82 // Scan the relocations to look for symbol adjustments.
84 scan_relocs(Symbol_table* symtab,
86 Sized_relobj<size, big_endian>* object,
87 unsigned int data_shndx,
89 const unsigned char* prelocs,
91 Output_section* output_section,
92 bool needs_special_offset_handling,
93 size_t local_symbol_count,
94 const unsigned char* plocal_symbols);
95 // Finalize the sections.
97 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
99 // Return the value to use for a dynamic which requires special
102 do_dynsym_value(const Symbol*) const;
104 // Relocate a section.
106 relocate_section(const Relocate_info<size, big_endian>*,
107 unsigned int sh_type,
108 const unsigned char* prelocs,
110 Output_section* output_section,
111 bool needs_special_offset_handling,
113 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
114 section_size_type view_size,
115 const Reloc_symbol_changes*);
117 // Scan the relocs during a relocatable link.
119 scan_relocatable_relocs(Symbol_table* symtab,
121 Sized_relobj<size, big_endian>* object,
122 unsigned int data_shndx,
123 unsigned int sh_type,
124 const unsigned char* prelocs,
126 Output_section* output_section,
127 bool needs_special_offset_handling,
128 size_t local_symbol_count,
129 const unsigned char* plocal_symbols,
130 Relocatable_relocs*);
132 // Relocate a section during a relocatable link.
134 relocate_for_relocatable(const Relocate_info<size, big_endian>*,
135 unsigned int sh_type,
136 const unsigned char* prelocs,
138 Output_section* output_section,
139 off_t offset_in_output_section,
140 const Relocatable_relocs*,
142 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
143 section_size_type view_size,
144 unsigned char* reloc_view,
145 section_size_type reloc_view_size);
146 // Return whether SYM is defined by the ABI.
148 do_is_defined_by_abi(const Symbol* sym) const
150 // XXX Really need to support this better...
151 if (sym->type() == elfcpp::STT_SPARC_REGISTER)
154 return strcmp(sym->name(), "___tls_get_addr") == 0;
157 // Return whether there is a GOT section.
159 has_got_section() const
160 { return this->got_ != NULL; }
162 // Return the size of the GOT section.
166 gold_assert(this->got_ != NULL);
167 return this->got_->data_size();
172 // The class which scans relocations.
177 : issued_non_pic_error_(false)
181 local(Symbol_table* symtab, Layout* layout, Target_sparc* target,
182 Sized_relobj<size, big_endian>* object,
183 unsigned int data_shndx,
184 Output_section* output_section,
185 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
186 const elfcpp::Sym<size, big_endian>& lsym);
189 global(Symbol_table* symtab, Layout* layout, Target_sparc* target,
190 Sized_relobj<size, big_endian>* object,
191 unsigned int data_shndx,
192 Output_section* output_section,
193 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
198 unsupported_reloc_local(Sized_relobj<size, big_endian>*,
199 unsigned int r_type);
202 unsupported_reloc_global(Sized_relobj<size, big_endian>*,
203 unsigned int r_type, Symbol*);
206 generate_tls_call(Symbol_table* symtab, Layout* layout,
207 Target_sparc* target);
210 check_non_pic(Relobj*, unsigned int r_type);
212 // Whether we have issued an error about a non-PIC compilation.
213 bool issued_non_pic_error_;
216 // The class which implements relocation.
221 : ignore_gd_add_(false)
226 if (this->ignore_gd_add_)
228 // FIXME: This needs to specify the location somehow.
229 gold_error(_("missing expected TLS relocation"));
233 // Do a relocation. Return false if the caller should not issue
234 // any warnings about this relocation.
236 relocate(const Relocate_info<size, big_endian>*, Target_sparc*,
237 Output_section*, size_t relnum,
238 const elfcpp::Rela<size, big_endian>&,
239 unsigned int r_type, const Sized_symbol<size>*,
240 const Symbol_value<size>*,
242 typename elfcpp::Elf_types<size>::Elf_Addr,
246 // Do a TLS relocation.
248 relocate_tls(const Relocate_info<size, big_endian>*, Target_sparc* target,
249 size_t relnum, const elfcpp::Rela<size, big_endian>&,
250 unsigned int r_type, const Sized_symbol<size>*,
251 const Symbol_value<size>*,
253 typename elfcpp::Elf_types<size>::Elf_Addr,
256 // Ignore the next relocation which should be R_SPARC_TLS_GD_ADD
260 // A class which returns the size required for a relocation type,
261 // used while scanning relocs during a relocatable link.
262 class Relocatable_size_for_reloc
266 get_size_for_reloc(unsigned int, Relobj*);
269 // Get the GOT section, creating it if necessary.
270 Output_data_got<size, big_endian>*
271 got_section(Symbol_table*, Layout*);
273 // Create a PLT entry for a global symbol.
275 make_plt_entry(Symbol_table*, Layout*, Symbol*);
277 // Create a GOT entry for the TLS module index.
279 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
280 Sized_relobj<size, big_endian>* object);
282 // Return the gsym for "__tls_get_addr". Cache if not already
285 tls_get_addr_sym(Symbol_table* symtab)
287 if (!this->tls_get_addr_sym_)
288 this->tls_get_addr_sym_ = symtab->lookup("__tls_get_addr", NULL);
289 gold_assert(this->tls_get_addr_sym_);
290 return this->tls_get_addr_sym_;
293 // Get the PLT section.
294 const Output_data_plt_sparc<size, big_endian>*
297 gold_assert(this->plt_ != NULL);
301 // Get the dynamic reloc section, creating it if necessary.
303 rela_dyn_section(Layout*);
305 // Copy a relocation against a global symbol.
307 copy_reloc(Symbol_table* symtab, Layout* layout,
308 Sized_relobj<size, big_endian>* object,
309 unsigned int shndx, Output_section* output_section,
310 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
312 this->copy_relocs_.copy_reloc(symtab, layout,
313 symtab->get_sized_symbol<size>(sym),
314 object, shndx, output_section,
315 reloc, this->rela_dyn_section(layout));
318 // Information about this specific target which we pass to the
319 // general Target structure.
320 static Target::Target_info sparc_info;
322 // The types of GOT entries needed for this platform.
325 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
326 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset
327 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
331 Output_data_got<size, big_endian>* got_;
333 Output_data_plt_sparc<size, big_endian>* plt_;
334 // The dynamic reloc section.
335 Reloc_section* rela_dyn_;
336 // Relocs saved to avoid a COPY reloc.
337 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
338 // Space for variables copied with a COPY reloc.
339 Output_data_space* dynbss_;
340 // Offset of the GOT entry for the TLS module index;
341 unsigned int got_mod_index_offset_;
342 // Cached pointer to __tls_get_addr symbol
343 Symbol* tls_get_addr_sym_;
347 Target::Target_info Target_sparc<32, true>::sparc_info =
350 true, // is_big_endian
351 elfcpp::EM_SPARC, // machine_code
352 false, // has_make_symbol
353 false, // has_resolve
354 false, // has_code_fill
355 true, // is_default_stack_executable
357 "/usr/lib/ld.so.1", // dynamic_linker
358 0x00010000, // default_text_segment_address
359 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
360 8 * 1024, // common_pagesize (overridable by -z common-page-size)
361 elfcpp::SHN_UNDEF, // small_common_shndx
362 elfcpp::SHN_UNDEF, // large_common_shndx
363 0, // small_common_section_flags
364 0, // large_common_section_flags
365 NULL, // attributes_section
366 NULL // attributes_vendor
370 Target::Target_info Target_sparc<64, true>::sparc_info =
373 true, // is_big_endian
374 elfcpp::EM_SPARCV9, // machine_code
375 false, // has_make_symbol
376 false, // has_resolve
377 false, // has_code_fill
378 true, // is_default_stack_executable
380 "/usr/lib/sparcv9/ld.so.1", // dynamic_linker
381 0x100000, // default_text_segment_address
382 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
383 8 * 1024, // common_pagesize (overridable by -z common-page-size)
384 elfcpp::SHN_UNDEF, // small_common_shndx
385 elfcpp::SHN_UNDEF, // large_common_shndx
386 0, // small_common_section_flags
387 0, // large_common_section_flags
388 NULL, // attributes_section
389 NULL // attributes_vendor
392 // We have to take care here, even when operating in little-endian
393 // mode, sparc instructions are still big endian.
394 template<int size, bool big_endian>
395 class Sparc_relocate_functions
398 // Do a simple relocation with the addend in the relocation.
399 template<int valsize>
401 rela(unsigned char* view,
402 unsigned int right_shift,
403 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
404 typename elfcpp::Swap<size, big_endian>::Valtype value,
405 typename elfcpp::Swap<size, big_endian>::Valtype addend)
407 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
408 Valtype* wv = reinterpret_cast<Valtype*>(view);
409 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
410 Valtype reloc = ((value + addend) >> right_shift);
415 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
418 // Do a simple relocation using a symbol value with the addend in
420 template<int valsize>
422 rela(unsigned char* view,
423 unsigned int right_shift,
424 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
425 const Sized_relobj<size, big_endian>* object,
426 const Symbol_value<size>* psymval,
427 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
429 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
430 Valtype* wv = reinterpret_cast<Valtype*>(view);
431 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
432 Valtype reloc = (psymval->value(object, addend) >> right_shift);
437 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
440 // Do a simple relocation using a symbol value with the addend in
441 // the relocation, unaligned.
442 template<int valsize>
444 rela_ua(unsigned char* view,
445 unsigned int right_shift, elfcpp::Elf_Xword dst_mask,
446 const Sized_relobj<size, big_endian>* object,
447 const Symbol_value<size>* psymval,
448 typename elfcpp::Swap<size, big_endian>::Valtype addend)
450 typedef typename elfcpp::Swap_unaligned<valsize,
451 big_endian>::Valtype Valtype;
452 unsigned char* wv = view;
453 Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv);
454 Valtype reloc = (psymval->value(object, addend) >> right_shift);
459 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc);
462 // Do a simple PC relative relocation with a Symbol_value with the
463 // addend in the relocation.
464 template<int valsize>
466 pcrela(unsigned char* view,
467 unsigned int right_shift,
468 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
469 const Sized_relobj<size, big_endian>* object,
470 const Symbol_value<size>* psymval,
471 typename elfcpp::Swap<size, big_endian>::Valtype addend,
472 typename elfcpp::Elf_types<size>::Elf_Addr address)
474 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
475 Valtype* wv = reinterpret_cast<Valtype*>(view);
476 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
477 Valtype reloc = ((psymval->value(object, addend) - address)
483 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
486 template<int valsize>
488 pcrela_unaligned(unsigned char* view,
489 const Sized_relobj<size, big_endian>* object,
490 const Symbol_value<size>* psymval,
491 typename elfcpp::Swap<size, big_endian>::Valtype addend,
492 typename elfcpp::Elf_types<size>::Elf_Addr address)
494 typedef typename elfcpp::Swap_unaligned<valsize,
495 big_endian>::Valtype Valtype;
496 unsigned char* wv = view;
497 Valtype reloc = (psymval->value(object, addend) - address);
499 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc);
502 typedef Sparc_relocate_functions<size, big_endian> This;
503 typedef Sparc_relocate_functions<size, true> This_insn;
506 // R_SPARC_WDISP30: (Symbol + Addend - Address) >> 2
508 wdisp30(unsigned char* view,
509 const Sized_relobj<size, big_endian>* object,
510 const Symbol_value<size>* psymval,
511 typename elfcpp::Elf_types<size>::Elf_Addr addend,
512 typename elfcpp::Elf_types<size>::Elf_Addr address)
514 This_insn::template pcrela<32>(view, 2, 0x3fffffff, object,
515 psymval, addend, address);
518 // R_SPARC_WDISP22: (Symbol + Addend - Address) >> 2
520 wdisp22(unsigned char* view,
521 const Sized_relobj<size, big_endian>* object,
522 const Symbol_value<size>* psymval,
523 typename elfcpp::Elf_types<size>::Elf_Addr addend,
524 typename elfcpp::Elf_types<size>::Elf_Addr address)
526 This_insn::template pcrela<32>(view, 2, 0x003fffff, object,
527 psymval, addend, address);
530 // R_SPARC_WDISP19: (Symbol + Addend - Address) >> 2
532 wdisp19(unsigned char* view,
533 const Sized_relobj<size, big_endian>* object,
534 const Symbol_value<size>* psymval,
535 typename elfcpp::Elf_types<size>::Elf_Addr addend,
536 typename elfcpp::Elf_types<size>::Elf_Addr address)
538 This_insn::template pcrela<32>(view, 2, 0x0007ffff, object,
539 psymval, addend, address);
542 // R_SPARC_WDISP16: (Symbol + Addend - Address) >> 2
544 wdisp16(unsigned char* view,
545 const Sized_relobj<size, big_endian>* object,
546 const Symbol_value<size>* psymval,
547 typename elfcpp::Elf_types<size>::Elf_Addr addend,
548 typename elfcpp::Elf_types<size>::Elf_Addr address)
550 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
551 Valtype* wv = reinterpret_cast<Valtype*>(view);
552 Valtype val = elfcpp::Swap<32, true>::readval(wv);
553 Valtype reloc = ((psymval->value(object, addend) - address)
556 // The relocation value is split between the low 14 bits,
558 val &= ~((0x3 << 20) | 0x3fff);
559 reloc = (((reloc & 0xc000) << (20 - 14))
560 | (reloc & 0x3ffff));
562 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
565 // R_SPARC_PC22: (Symbol + Addend - Address) >> 10
567 pc22(unsigned char* view,
568 const Sized_relobj<size, big_endian>* object,
569 const Symbol_value<size>* psymval,
570 typename elfcpp::Elf_types<size>::Elf_Addr addend,
571 typename elfcpp::Elf_types<size>::Elf_Addr address)
573 This_insn::template pcrela<32>(view, 10, 0x003fffff, object,
574 psymval, addend, address);
577 // R_SPARC_PC10: (Symbol + Addend - Address) & 0x3ff
579 pc10(unsigned char* view,
580 const Sized_relobj<size, big_endian>* object,
581 const Symbol_value<size>* psymval,
582 typename elfcpp::Elf_types<size>::Elf_Addr addend,
583 typename elfcpp::Elf_types<size>::Elf_Addr address)
585 This_insn::template pcrela<32>(view, 0, 0x000003ff, object,
586 psymval, addend, address);
589 // R_SPARC_HI22: (Symbol + Addend) >> 10
591 hi22(unsigned char* view,
592 typename elfcpp::Elf_types<size>::Elf_Addr value,
593 typename elfcpp::Elf_types<size>::Elf_Addr addend)
595 This_insn::template rela<32>(view, 10, 0x003fffff, value, addend);
598 // R_SPARC_HI22: (Symbol + Addend) >> 10
600 hi22(unsigned char* view,
601 const Sized_relobj<size, big_endian>* object,
602 const Symbol_value<size>* psymval,
603 typename elfcpp::Elf_types<size>::Elf_Addr addend)
605 This_insn::template rela<32>(view, 10, 0x003fffff, object, psymval, addend);
608 // R_SPARC_PCPLT22: (Symbol + Addend - Address) >> 10
610 pcplt22(unsigned char* view,
611 const Sized_relobj<size, big_endian>* object,
612 const Symbol_value<size>* psymval,
613 typename elfcpp::Elf_types<size>::Elf_Addr addend,
614 typename elfcpp::Elf_types<size>::Elf_Addr address)
616 This_insn::template pcrela<32>(view, 10, 0x003fffff, object,
617 psymval, addend, address);
620 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
622 lo10(unsigned char* view,
623 typename elfcpp::Elf_types<size>::Elf_Addr value,
624 typename elfcpp::Elf_types<size>::Elf_Addr addend)
626 This_insn::template rela<32>(view, 0, 0x000003ff, value, addend);
629 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
631 lo10(unsigned char* view,
632 const Sized_relobj<size, big_endian>* object,
633 const Symbol_value<size>* psymval,
634 typename elfcpp::Elf_types<size>::Elf_Addr addend)
636 This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend);
639 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
641 lo10(unsigned char* view,
642 const Sized_relobj<size, big_endian>* object,
643 const Symbol_value<size>* psymval,
644 typename elfcpp::Elf_types<size>::Elf_Addr addend,
645 typename elfcpp::Elf_types<size>::Elf_Addr address)
647 This_insn::template pcrela<32>(view, 0, 0x000003ff, object,
648 psymval, addend, address);
651 // R_SPARC_OLO10: ((Symbol + Addend) & 0x3ff) + Addend2
653 olo10(unsigned char* view,
654 const Sized_relobj<size, big_endian>* object,
655 const Symbol_value<size>* psymval,
656 typename elfcpp::Elf_types<size>::Elf_Addr addend,
657 typename elfcpp::Elf_types<size>::Elf_Addr addend2)
659 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
660 Valtype* wv = reinterpret_cast<Valtype*>(view);
661 Valtype val = elfcpp::Swap<32, true>::readval(wv);
662 Valtype reloc = psymval->value(object, addend);
669 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
672 // R_SPARC_22: (Symbol + Addend)
674 rela32_22(unsigned char* view,
675 const Sized_relobj<size, big_endian>* object,
676 const Symbol_value<size>* psymval,
677 typename elfcpp::Elf_types<size>::Elf_Addr addend)
679 This_insn::template rela<32>(view, 0, 0x003fffff, object, psymval, addend);
682 // R_SPARC_13: (Symbol + Addend)
684 rela32_13(unsigned char* view,
685 typename elfcpp::Elf_types<size>::Elf_Addr value,
686 typename elfcpp::Elf_types<size>::Elf_Addr addend)
688 This_insn::template rela<32>(view, 0, 0x00001fff, value, addend);
691 // R_SPARC_13: (Symbol + Addend)
693 rela32_13(unsigned char* view,
694 const Sized_relobj<size, big_endian>* object,
695 const Symbol_value<size>* psymval,
696 typename elfcpp::Elf_types<size>::Elf_Addr addend)
698 This_insn::template rela<32>(view, 0, 0x00001fff, object, psymval, addend);
701 // R_SPARC_UA16: (Symbol + Addend)
703 ua16(unsigned char* view,
704 const Sized_relobj<size, big_endian>* object,
705 const Symbol_value<size>* psymval,
706 typename elfcpp::Elf_types<size>::Elf_Addr addend)
708 This::template rela_ua<16>(view, 0, 0xffff, object, psymval, addend);
711 // R_SPARC_UA32: (Symbol + Addend)
713 ua32(unsigned char* view,
714 const Sized_relobj<size, big_endian>* object,
715 const Symbol_value<size>* psymval,
716 typename elfcpp::Elf_types<size>::Elf_Addr addend)
718 This::template rela_ua<32>(view, 0, 0xffffffff, object, psymval, addend);
721 // R_SPARC_UA64: (Symbol + Addend)
723 ua64(unsigned char* view,
724 const Sized_relobj<size, big_endian>* object,
725 const Symbol_value<size>* psymval,
726 typename elfcpp::Elf_types<size>::Elf_Addr addend)
728 This::template rela_ua<64>(view, 0, ~(elfcpp::Elf_Xword) 0,
729 object, psymval, addend);
732 // R_SPARC_DISP8: (Symbol + Addend - Address)
734 disp8(unsigned char* view,
735 const Sized_relobj<size, big_endian>* object,
736 const Symbol_value<size>* psymval,
737 typename elfcpp::Elf_types<size>::Elf_Addr addend,
738 typename elfcpp::Elf_types<size>::Elf_Addr address)
740 This::template pcrela_unaligned<8>(view, object, psymval,
744 // R_SPARC_DISP16: (Symbol + Addend - Address)
746 disp16(unsigned char* view,
747 const Sized_relobj<size, big_endian>* object,
748 const Symbol_value<size>* psymval,
749 typename elfcpp::Elf_types<size>::Elf_Addr addend,
750 typename elfcpp::Elf_types<size>::Elf_Addr address)
752 This::template pcrela_unaligned<16>(view, object, psymval,
756 // R_SPARC_DISP32: (Symbol + Addend - Address)
758 disp32(unsigned char* view,
759 const Sized_relobj<size, big_endian>* object,
760 const Symbol_value<size>* psymval,
761 typename elfcpp::Elf_types<size>::Elf_Addr addend,
762 typename elfcpp::Elf_types<size>::Elf_Addr address)
764 This::template pcrela_unaligned<32>(view, object, psymval,
768 // R_SPARC_DISP64: (Symbol + Addend - Address)
770 disp64(unsigned char* view,
771 const Sized_relobj<size, big_endian>* object,
772 const Symbol_value<size>* psymval,
773 elfcpp::Elf_Xword addend,
774 typename elfcpp::Elf_types<size>::Elf_Addr address)
776 This::template pcrela_unaligned<64>(view, object, psymval,
780 // R_SPARC_H44: (Symbol + Addend) >> 22
782 h44(unsigned char* view,
783 const Sized_relobj<size, big_endian>* object,
784 const Symbol_value<size>* psymval,
785 typename elfcpp::Elf_types<size>::Elf_Addr addend)
787 This_insn::template rela<32>(view, 22, 0x003fffff, object, psymval, addend);
790 // R_SPARC_M44: ((Symbol + Addend) >> 12) & 0x3ff
792 m44(unsigned char* view,
793 const Sized_relobj<size, big_endian>* object,
794 const Symbol_value<size>* psymval,
795 typename elfcpp::Elf_types<size>::Elf_Addr addend)
797 This_insn::template rela<32>(view, 12, 0x000003ff, object, psymval, addend);
800 // R_SPARC_L44: (Symbol + Addend) & 0xfff
802 l44(unsigned char* view,
803 const Sized_relobj<size, big_endian>* object,
804 const Symbol_value<size>* psymval,
805 typename elfcpp::Elf_types<size>::Elf_Addr addend)
807 This_insn::template rela<32>(view, 0, 0x00000fff, object, psymval, addend);
810 // R_SPARC_HH22: (Symbol + Addend) >> 42
812 hh22(unsigned char* view,
813 const Sized_relobj<size, big_endian>* object,
814 const Symbol_value<size>* psymval,
815 typename elfcpp::Elf_types<size>::Elf_Addr addend)
817 This_insn::template rela<32>(view, 42, 0x003fffff, object, psymval, addend);
820 // R_SPARC_PC_HH22: (Symbol + Addend - Address) >> 42
822 pc_hh22(unsigned char* view,
823 const Sized_relobj<size, big_endian>* object,
824 const Symbol_value<size>* psymval,
825 typename elfcpp::Elf_types<size>::Elf_Addr addend,
826 typename elfcpp::Elf_types<size>::Elf_Addr address)
828 This_insn::template pcrela<32>(view, 42, 0x003fffff, object,
829 psymval, addend, address);
832 // R_SPARC_HM10: ((Symbol + Addend) >> 32) & 0x3ff
834 hm10(unsigned char* view,
835 const Sized_relobj<size, big_endian>* object,
836 const Symbol_value<size>* psymval,
837 typename elfcpp::Elf_types<size>::Elf_Addr addend)
839 This_insn::template rela<32>(view, 32, 0x000003ff, object, psymval, addend);
842 // R_SPARC_PC_HM10: ((Symbol + Addend - Address) >> 32) & 0x3ff
844 pc_hm10(unsigned char* view,
845 const Sized_relobj<size, big_endian>* object,
846 const Symbol_value<size>* psymval,
847 typename elfcpp::Elf_types<size>::Elf_Addr addend,
848 typename elfcpp::Elf_types<size>::Elf_Addr address)
850 This_insn::template pcrela<32>(view, 32, 0x000003ff, object,
851 psymval, addend, address);
854 // R_SPARC_11: (Symbol + Addend)
856 rela32_11(unsigned char* view,
857 const Sized_relobj<size, big_endian>* object,
858 const Symbol_value<size>* psymval,
859 typename elfcpp::Elf_types<size>::Elf_Addr addend)
861 This_insn::template rela<32>(view, 0, 0x000007ff, object, psymval, addend);
864 // R_SPARC_10: (Symbol + Addend)
866 rela32_10(unsigned char* view,
867 const Sized_relobj<size, big_endian>* object,
868 const Symbol_value<size>* psymval,
869 typename elfcpp::Elf_types<size>::Elf_Addr addend)
871 This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend);
874 // R_SPARC_7: (Symbol + Addend)
876 rela32_7(unsigned char* view,
877 const Sized_relobj<size, big_endian>* object,
878 const Symbol_value<size>* psymval,
879 typename elfcpp::Elf_types<size>::Elf_Addr addend)
881 This_insn::template rela<32>(view, 0, 0x0000007f, object, psymval, addend);
884 // R_SPARC_6: (Symbol + Addend)
886 rela32_6(unsigned char* view,
887 const Sized_relobj<size, big_endian>* object,
888 const Symbol_value<size>* psymval,
889 typename elfcpp::Elf_types<size>::Elf_Addr addend)
891 This_insn::template rela<32>(view, 0, 0x0000003f, object, psymval, addend);
894 // R_SPARC_5: (Symbol + Addend)
896 rela32_5(unsigned char* view,
897 const Sized_relobj<size, big_endian>* object,
898 const Symbol_value<size>* psymval,
899 typename elfcpp::Elf_types<size>::Elf_Addr addend)
901 This_insn::template rela<32>(view, 0, 0x0000001f, object, psymval, addend);
904 // R_SPARC_TLS_LDO_HIX22: @dtpoff(Symbol + Addend) >> 10
906 ldo_hix22(unsigned char* view,
907 typename elfcpp::Elf_types<size>::Elf_Addr value,
908 typename elfcpp::Elf_types<size>::Elf_Addr addend)
910 This_insn::hi22(view, value, addend);
913 // R_SPARC_TLS_LDO_LOX10: @dtpoff(Symbol + Addend) & 0x3ff
915 ldo_lox10(unsigned char* view,
916 typename elfcpp::Elf_types<size>::Elf_Addr value,
917 typename elfcpp::Elf_types<size>::Elf_Addr addend)
919 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
920 Valtype* wv = reinterpret_cast<Valtype*>(view);
921 Valtype val = elfcpp::Swap<32, true>::readval(wv);
922 Valtype reloc = (value + addend);
927 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
930 // R_SPARC_TLS_LE_HIX22: (@tpoff(Symbol + Addend) ^ 0xffffffffffffffff) >> 10
932 hix22(unsigned char* view,
933 typename elfcpp::Elf_types<size>::Elf_Addr value,
934 typename elfcpp::Elf_types<size>::Elf_Addr addend)
936 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
937 Valtype* wv = reinterpret_cast<Valtype*>(view);
938 Valtype val = elfcpp::Swap<32, true>::readval(wv);
939 Valtype reloc = (value + addend);
943 reloc ^= ~(Valtype)0;
948 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
951 // R_SPARC_HIX22: ((Symbol + Addend) ^ 0xffffffffffffffff) >> 10
953 hix22(unsigned char* view,
954 const Sized_relobj<size, big_endian>* object,
955 const Symbol_value<size>* psymval,
956 typename elfcpp::Elf_types<size>::Elf_Addr addend)
958 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
959 Valtype* wv = reinterpret_cast<Valtype*>(view);
960 Valtype val = elfcpp::Swap<32, true>::readval(wv);
961 Valtype reloc = psymval->value(object, addend);
965 reloc ^= ~(Valtype)0;
970 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
974 // R_SPARC_TLS_LE_LOX10: (@tpoff(Symbol + Addend) & 0x3ff) | 0x1c00
976 lox10(unsigned char* view,
977 typename elfcpp::Elf_types<size>::Elf_Addr value,
978 typename elfcpp::Elf_types<size>::Elf_Addr addend)
980 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
981 Valtype* wv = reinterpret_cast<Valtype*>(view);
982 Valtype val = elfcpp::Swap<32, true>::readval(wv);
983 Valtype reloc = (value + addend);
989 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
992 // R_SPARC_LOX10: ((Symbol + Addend) & 0x3ff) | 0x1c00
994 lox10(unsigned char* view,
995 const Sized_relobj<size, big_endian>* object,
996 const Symbol_value<size>* psymval,
997 typename elfcpp::Elf_types<size>::Elf_Addr addend)
999 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
1000 Valtype* wv = reinterpret_cast<Valtype*>(view);
1001 Valtype val = elfcpp::Swap<32, true>::readval(wv);
1002 Valtype reloc = psymval->value(object, addend);
1008 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
1012 // Get the GOT section, creating it if necessary.
1014 template<int size, bool big_endian>
1015 Output_data_got<size, big_endian>*
1016 Target_sparc<size, big_endian>::got_section(Symbol_table* symtab,
1019 if (this->got_ == NULL)
1021 gold_assert(symtab != NULL && layout != NULL);
1023 this->got_ = new Output_data_got<size, big_endian>();
1026 os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1028 | elfcpp::SHF_WRITE),
1029 this->got_, false, true, false,
1032 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
1033 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1034 Symbol_table::PREDEFINED,
1036 0, 0, elfcpp::STT_OBJECT,
1038 elfcpp::STV_HIDDEN, 0,
1045 // Get the dynamic reloc section, creating it if necessary.
1047 template<int size, bool big_endian>
1048 typename Target_sparc<size, big_endian>::Reloc_section*
1049 Target_sparc<size, big_endian>::rela_dyn_section(Layout* layout)
1051 if (this->rela_dyn_ == NULL)
1053 gold_assert(layout != NULL);
1054 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
1055 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1056 elfcpp::SHF_ALLOC, this->rela_dyn_, true,
1057 false, false, false);
1059 return this->rela_dyn_;
1062 // A class to handle the PLT data.
1064 template<int size, bool big_endian>
1065 class Output_data_plt_sparc : public Output_section_data
1068 typedef Output_data_reloc<elfcpp::SHT_RELA, true,
1069 size, big_endian> Reloc_section;
1071 Output_data_plt_sparc(Layout*);
1073 // Add an entry to the PLT.
1074 void add_entry(Symbol* gsym);
1076 // Return the .rela.plt section data.
1077 const Reloc_section* rel_plt() const
1083 void do_adjust_output_section(Output_section* os);
1085 // Write to a map file.
1087 do_print_to_mapfile(Mapfile* mapfile) const
1088 { mapfile->print_output_data(this, _("** PLT")); }
1091 // The size of an entry in the PLT.
1092 static const int base_plt_entry_size = (size == 32 ? 12 : 32);
1094 static const unsigned int plt_entries_per_block = 160;
1095 static const unsigned int plt_insn_chunk_size = 24;
1096 static const unsigned int plt_pointer_chunk_size = 8;
1097 static const unsigned int plt_block_size =
1098 (plt_entries_per_block
1099 * (plt_insn_chunk_size + plt_pointer_chunk_size));
1101 // Set the final size.
1103 set_final_data_size()
1105 unsigned int full_count = this->count_ + 4;
1106 unsigned int extra = (size == 32 ? 4 : 0);
1108 if (size == 32 || full_count < 32768)
1109 this->set_data_size((full_count * base_plt_entry_size) + extra);
1112 unsigned int ext_cnt = full_count - 32768;
1114 this->set_data_size((32768 * base_plt_entry_size)
1116 * (plt_insn_chunk_size
1117 + plt_pointer_chunk_size)));
1121 // Write out the PLT data.
1123 do_write(Output_file*);
1125 // The reloc section.
1126 Reloc_section* rel_;
1127 // The number of PLT entries.
1128 unsigned int count_;
1131 // Define the constants as required by C++ standard.
1133 template<int size, bool big_endian>
1134 const int Output_data_plt_sparc<size, big_endian>::base_plt_entry_size;
1136 template<int size, bool big_endian>
1138 Output_data_plt_sparc<size, big_endian>::plt_entries_per_block;
1140 template<int size, bool big_endian>
1141 const unsigned int Output_data_plt_sparc<size, big_endian>::plt_insn_chunk_size;
1143 template<int size, bool big_endian>
1145 Output_data_plt_sparc<size, big_endian>::plt_pointer_chunk_size;
1147 template<int size, bool big_endian>
1148 const unsigned int Output_data_plt_sparc<size, big_endian>::plt_block_size;
1150 // Create the PLT section. The ordinary .got section is an argument,
1151 // since we need to refer to the start.
1153 template<int size, bool big_endian>
1154 Output_data_plt_sparc<size, big_endian>::Output_data_plt_sparc(Layout* layout)
1155 : Output_section_data(size == 32 ? 4 : 8), count_(0)
1157 this->rel_ = new Reloc_section(false);
1158 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1159 elfcpp::SHF_ALLOC, this->rel_, true,
1160 false, false, false);
1163 template<int size, bool big_endian>
1165 Output_data_plt_sparc<size, big_endian>::do_adjust_output_section(Output_section* os)
1170 // Add an entry to the PLT.
1172 template<int size, bool big_endian>
1174 Output_data_plt_sparc<size, big_endian>::add_entry(Symbol* gsym)
1176 gold_assert(!gsym->has_plt_offset());
1178 unsigned int index = this->count_ + 4;
1179 section_offset_type plt_offset;
1181 if (size == 32 || index < 32768)
1182 plt_offset = index * base_plt_entry_size;
1185 unsigned int ext_index = index - 32768;
1187 plt_offset = (32768 * base_plt_entry_size)
1188 + ((ext_index / plt_entries_per_block)
1190 + ((ext_index % plt_entries_per_block)
1191 * plt_insn_chunk_size);
1194 gsym->set_plt_offset(plt_offset);
1198 // Every PLT entry needs a reloc.
1199 gsym->set_needs_dynsym_entry();
1200 this->rel_->add_global(gsym, elfcpp::R_SPARC_JMP_SLOT, this,
1203 // Note that we don't need to save the symbol. The contents of the
1204 // PLT are independent of which symbols are used. The symbols only
1205 // appear in the relocations.
1208 static const unsigned int sparc_nop = 0x01000000;
1209 static const unsigned int sparc_sethi_g1 = 0x03000000;
1210 static const unsigned int sparc_branch_always = 0x30800000;
1211 static const unsigned int sparc_branch_always_pt = 0x30680000;
1212 static const unsigned int sparc_mov = 0x80100000;
1213 static const unsigned int sparc_mov_g0_o0 = 0x90100000;
1214 static const unsigned int sparc_mov_o7_g5 = 0x8a10000f;
1215 static const unsigned int sparc_call_plus_8 = 0x40000002;
1216 static const unsigned int sparc_ldx_o7_imm_g1 = 0xc25be000;
1217 static const unsigned int sparc_jmpl_o7_g1_g1 = 0x83c3c001;
1218 static const unsigned int sparc_mov_g5_o7 = 0x9e100005;
1220 // Write out the PLT.
1222 template<int size, bool big_endian>
1224 Output_data_plt_sparc<size, big_endian>::do_write(Output_file* of)
1226 const off_t offset = this->offset();
1227 const section_size_type oview_size =
1228 convert_to_section_size_type(this->data_size());
1229 unsigned char* const oview = of->get_output_view(offset, oview_size);
1230 unsigned char* pov = oview;
1232 memset(pov, 0, base_plt_entry_size * 4);
1233 pov += base_plt_entry_size * 4;
1235 unsigned int plt_offset = base_plt_entry_size * 4;
1236 const unsigned int count = this->count_;
1242 limit = (count > 32768 ? 32768 : count);
1244 for (unsigned int i = 0; i < limit; ++i)
1246 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1247 sparc_sethi_g1 + plt_offset);
1248 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1249 sparc_branch_always_pt +
1250 (((base_plt_entry_size -
1251 (plt_offset + 4)) >> 2) &
1253 elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop);
1254 elfcpp::Swap<32, true>::writeval(pov + 0x0c, sparc_nop);
1255 elfcpp::Swap<32, true>::writeval(pov + 0x10, sparc_nop);
1256 elfcpp::Swap<32, true>::writeval(pov + 0x14, sparc_nop);
1257 elfcpp::Swap<32, true>::writeval(pov + 0x18, sparc_nop);
1258 elfcpp::Swap<32, true>::writeval(pov + 0x1c, sparc_nop);
1260 pov += base_plt_entry_size;
1261 plt_offset += base_plt_entry_size;
1266 unsigned int ext_cnt = count - 32768;
1267 unsigned int blks = ext_cnt / plt_entries_per_block;
1269 for (unsigned int i = 0; i < blks; ++i)
1271 unsigned int data_off = (plt_entries_per_block
1272 * plt_insn_chunk_size) - 4;
1274 for (unsigned int j = 0; j < plt_entries_per_block; ++j)
1276 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1278 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1280 elfcpp::Swap<32, true>::writeval(pov + 0x08,
1282 elfcpp::Swap<32, true>::writeval(pov + 0x0c,
1283 sparc_ldx_o7_imm_g1 +
1284 (data_off & 0x1fff));
1285 elfcpp::Swap<32, true>::writeval(pov + 0x10,
1286 sparc_jmpl_o7_g1_g1);
1287 elfcpp::Swap<32, true>::writeval(pov + 0x14,
1290 elfcpp::Swap<64, big_endian>::writeval(
1291 pov + 0x4 + data_off,
1292 (elfcpp::Elf_Xword) (oview - (pov + 0x04)));
1294 pov += plt_insn_chunk_size;
1299 unsigned int sub_blk_cnt = ext_cnt % plt_entries_per_block;
1300 for (unsigned int i = 0; i < sub_blk_cnt; ++i)
1302 unsigned int data_off = (sub_blk_cnt
1303 * plt_insn_chunk_size) - 4;
1305 for (unsigned int j = 0; j < plt_entries_per_block; ++j)
1307 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1309 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1311 elfcpp::Swap<32, true>::writeval(pov + 0x08,
1313 elfcpp::Swap<32, true>::writeval(pov + 0x0c,
1314 sparc_ldx_o7_imm_g1 +
1315 (data_off & 0x1fff));
1316 elfcpp::Swap<32, true>::writeval(pov + 0x10,
1317 sparc_jmpl_o7_g1_g1);
1318 elfcpp::Swap<32, true>::writeval(pov + 0x14,
1321 elfcpp::Swap<64, big_endian>::writeval(
1322 pov + 0x4 + data_off,
1323 (elfcpp::Elf_Xword) (oview - (pov + 0x04)));
1325 pov += plt_insn_chunk_size;
1333 for (unsigned int i = 0; i < count; ++i)
1335 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1336 sparc_sethi_g1 + plt_offset);
1337 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1338 sparc_branch_always +
1339 (((- (plt_offset + 4)) >> 2) &
1341 elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop);
1343 pov += base_plt_entry_size;
1344 plt_offset += base_plt_entry_size;
1347 elfcpp::Swap<32, true>::writeval(pov, sparc_nop);
1351 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1353 of->write_output_view(offset, oview_size, oview);
1356 // Create a PLT entry for a global symbol.
1358 template<int size, bool big_endian>
1360 Target_sparc<size, big_endian>::make_plt_entry(Symbol_table* symtab,
1364 if (gsym->has_plt_offset())
1367 if (this->plt_ == NULL)
1369 // Create the GOT sections first.
1370 this->got_section(symtab, layout);
1372 this->plt_ = new Output_data_plt_sparc<size, big_endian>(layout);
1373 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1375 | elfcpp::SHF_EXECINSTR
1376 | elfcpp::SHF_WRITE),
1377 this->plt_, false, false, false, false);
1379 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
1380 symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
1381 Symbol_table::PREDEFINED,
1383 0, 0, elfcpp::STT_OBJECT,
1385 elfcpp::STV_HIDDEN, 0,
1389 this->plt_->add_entry(gsym);
1392 // Create a GOT entry for the TLS module index.
1394 template<int size, bool big_endian>
1396 Target_sparc<size, big_endian>::got_mod_index_entry(Symbol_table* symtab,
1398 Sized_relobj<size, big_endian>* object)
1400 if (this->got_mod_index_offset_ == -1U)
1402 gold_assert(symtab != NULL && layout != NULL && object != NULL);
1403 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
1404 Output_data_got<size, big_endian>* got;
1405 unsigned int got_offset;
1407 got = this->got_section(symtab, layout);
1408 got_offset = got->add_constant(0);
1409 rela_dyn->add_local(object, 0,
1411 elfcpp::R_SPARC_TLS_DTPMOD64 :
1412 elfcpp::R_SPARC_TLS_DTPMOD32), got,
1414 got->add_constant(0);
1415 this->got_mod_index_offset_ = got_offset;
1417 return this->got_mod_index_offset_;
1420 // Optimize the TLS relocation type based on what we know about the
1421 // symbol. IS_FINAL is true if the final address of this symbol is
1422 // known at link time.
1424 static tls::Tls_optimization
1425 optimize_tls_reloc(bool is_final, int r_type)
1427 // If we are generating a shared library, then we can't do anything
1429 if (parameters->options().shared())
1430 return tls::TLSOPT_NONE;
1434 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1435 case elfcpp::R_SPARC_TLS_GD_LO10:
1436 case elfcpp::R_SPARC_TLS_GD_ADD:
1437 case elfcpp::R_SPARC_TLS_GD_CALL:
1438 // These are General-Dynamic which permits fully general TLS
1439 // access. Since we know that we are generating an executable,
1440 // we can convert this to Initial-Exec. If we also know that
1441 // this is a local symbol, we can further switch to Local-Exec.
1443 return tls::TLSOPT_TO_LE;
1444 return tls::TLSOPT_TO_IE;
1446 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic
1447 case elfcpp::R_SPARC_TLS_LDM_LO10:
1448 case elfcpp::R_SPARC_TLS_LDM_ADD:
1449 case elfcpp::R_SPARC_TLS_LDM_CALL:
1450 // This is Local-Dynamic, which refers to a local symbol in the
1451 // dynamic TLS block. Since we know that we generating an
1452 // executable, we can switch to Local-Exec.
1453 return tls::TLSOPT_TO_LE;
1455 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1456 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1457 case elfcpp::R_SPARC_TLS_LDO_ADD:
1458 // Another type of Local-Dynamic relocation.
1459 return tls::TLSOPT_TO_LE;
1461 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1462 case elfcpp::R_SPARC_TLS_IE_LO10:
1463 case elfcpp::R_SPARC_TLS_IE_LD:
1464 case elfcpp::R_SPARC_TLS_IE_LDX:
1465 case elfcpp::R_SPARC_TLS_IE_ADD:
1466 // These are Initial-Exec relocs which get the thread offset
1467 // from the GOT. If we know that we are linking against the
1468 // local symbol, we can switch to Local-Exec, which links the
1469 // thread offset into the instruction.
1471 return tls::TLSOPT_TO_LE;
1472 return tls::TLSOPT_NONE;
1474 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec
1475 case elfcpp::R_SPARC_TLS_LE_LOX10:
1476 // When we already have Local-Exec, there is nothing further we
1478 return tls::TLSOPT_NONE;
1485 // Generate a PLT entry slot for a call to __tls_get_addr
1486 template<int size, bool big_endian>
1488 Target_sparc<size, big_endian>::Scan::generate_tls_call(Symbol_table* symtab,
1490 Target_sparc<size, big_endian>* target)
1492 Symbol* gsym = target->tls_get_addr_sym(symtab);
1494 target->make_plt_entry(symtab, layout, gsym);
1497 // Report an unsupported relocation against a local symbol.
1499 template<int size, bool big_endian>
1501 Target_sparc<size, big_endian>::Scan::unsupported_reloc_local(
1502 Sized_relobj<size, big_endian>* object,
1503 unsigned int r_type)
1505 gold_error(_("%s: unsupported reloc %u against local symbol"),
1506 object->name().c_str(), r_type);
1509 // We are about to emit a dynamic relocation of type R_TYPE. If the
1510 // dynamic linker does not support it, issue an error.
1512 template<int size, bool big_endian>
1514 Target_sparc<size, big_endian>::Scan::check_non_pic(Relobj* object, unsigned int r_type)
1516 gold_assert(r_type != elfcpp::R_SPARC_NONE);
1522 // These are the relocation types supported by glibc for sparc 64-bit.
1523 case elfcpp::R_SPARC_RELATIVE:
1524 case elfcpp::R_SPARC_COPY:
1525 case elfcpp::R_SPARC_64:
1526 case elfcpp::R_SPARC_GLOB_DAT:
1527 case elfcpp::R_SPARC_JMP_SLOT:
1528 case elfcpp::R_SPARC_TLS_DTPMOD64:
1529 case elfcpp::R_SPARC_TLS_DTPOFF64:
1530 case elfcpp::R_SPARC_TLS_TPOFF64:
1531 case elfcpp::R_SPARC_TLS_LE_HIX22:
1532 case elfcpp::R_SPARC_TLS_LE_LOX10:
1533 case elfcpp::R_SPARC_8:
1534 case elfcpp::R_SPARC_16:
1535 case elfcpp::R_SPARC_DISP8:
1536 case elfcpp::R_SPARC_DISP16:
1537 case elfcpp::R_SPARC_DISP32:
1538 case elfcpp::R_SPARC_WDISP30:
1539 case elfcpp::R_SPARC_LO10:
1540 case elfcpp::R_SPARC_HI22:
1541 case elfcpp::R_SPARC_OLO10:
1542 case elfcpp::R_SPARC_H44:
1543 case elfcpp::R_SPARC_M44:
1544 case elfcpp::R_SPARC_L44:
1545 case elfcpp::R_SPARC_HH22:
1546 case elfcpp::R_SPARC_HM10:
1547 case elfcpp::R_SPARC_LM22:
1548 case elfcpp::R_SPARC_UA16:
1549 case elfcpp::R_SPARC_UA32:
1550 case elfcpp::R_SPARC_UA64:
1561 // These are the relocation types supported by glibc for sparc 32-bit.
1562 case elfcpp::R_SPARC_RELATIVE:
1563 case elfcpp::R_SPARC_COPY:
1564 case elfcpp::R_SPARC_GLOB_DAT:
1565 case elfcpp::R_SPARC_32:
1566 case elfcpp::R_SPARC_JMP_SLOT:
1567 case elfcpp::R_SPARC_TLS_DTPMOD32:
1568 case elfcpp::R_SPARC_TLS_DTPOFF32:
1569 case elfcpp::R_SPARC_TLS_TPOFF32:
1570 case elfcpp::R_SPARC_TLS_LE_HIX22:
1571 case elfcpp::R_SPARC_TLS_LE_LOX10:
1572 case elfcpp::R_SPARC_8:
1573 case elfcpp::R_SPARC_16:
1574 case elfcpp::R_SPARC_DISP8:
1575 case elfcpp::R_SPARC_DISP16:
1576 case elfcpp::R_SPARC_DISP32:
1577 case elfcpp::R_SPARC_LO10:
1578 case elfcpp::R_SPARC_WDISP30:
1579 case elfcpp::R_SPARC_HI22:
1580 case elfcpp::R_SPARC_UA16:
1581 case elfcpp::R_SPARC_UA32:
1589 // This prevents us from issuing more than one error per reloc
1590 // section. But we can still wind up issuing more than one
1591 // error per object file.
1592 if (this->issued_non_pic_error_)
1594 gold_assert(parameters->options().output_is_position_independent());
1595 object->error(_("requires unsupported dynamic reloc; "
1596 "recompile with -fPIC"));
1597 this->issued_non_pic_error_ = true;
1601 // Scan a relocation for a local symbol.
1603 template<int size, bool big_endian>
1605 Target_sparc<size, big_endian>::Scan::local(
1606 Symbol_table* symtab,
1608 Target_sparc<size, big_endian>* target,
1609 Sized_relobj<size, big_endian>* object,
1610 unsigned int data_shndx,
1611 Output_section* output_section,
1612 const elfcpp::Rela<size, big_endian>& reloc,
1613 unsigned int r_type,
1614 const elfcpp::Sym<size, big_endian>& lsym)
1616 unsigned int orig_r_type = r_type;
1621 case elfcpp::R_SPARC_NONE:
1622 case elfcpp::R_SPARC_REGISTER:
1623 case elfcpp::R_SPARC_GNU_VTINHERIT:
1624 case elfcpp::R_SPARC_GNU_VTENTRY:
1627 case elfcpp::R_SPARC_64:
1628 case elfcpp::R_SPARC_32:
1629 // If building a shared library (or a position-independent
1630 // executable), we need to create a dynamic relocation for
1631 // this location. The relocation applied at link time will
1632 // apply the link-time value, so we flag the location with
1633 // an R_SPARC_RELATIVE relocation so the dynamic loader can
1634 // relocate it easily.
1635 if (parameters->options().output_is_position_independent())
1637 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1638 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1639 rela_dyn->add_local_relative(object, r_sym, elfcpp::R_SPARC_RELATIVE,
1640 output_section, data_shndx,
1641 reloc.get_r_offset(),
1642 reloc.get_r_addend());
1646 case elfcpp::R_SPARC_HIX22:
1647 case elfcpp::R_SPARC_LOX10:
1648 case elfcpp::R_SPARC_H44:
1649 case elfcpp::R_SPARC_M44:
1650 case elfcpp::R_SPARC_L44:
1651 case elfcpp::R_SPARC_HH22:
1652 case elfcpp::R_SPARC_HM10:
1653 case elfcpp::R_SPARC_LM22:
1654 case elfcpp::R_SPARC_UA64:
1655 case elfcpp::R_SPARC_UA32:
1656 case elfcpp::R_SPARC_UA16:
1657 case elfcpp::R_SPARC_HI22:
1658 case elfcpp::R_SPARC_LO10:
1659 case elfcpp::R_SPARC_OLO10:
1660 case elfcpp::R_SPARC_16:
1661 case elfcpp::R_SPARC_11:
1662 case elfcpp::R_SPARC_10:
1663 case elfcpp::R_SPARC_8:
1664 case elfcpp::R_SPARC_7:
1665 case elfcpp::R_SPARC_6:
1666 case elfcpp::R_SPARC_5:
1667 // If building a shared library (or a position-independent
1668 // executable), we need to create a dynamic relocation for
1670 if (parameters->options().output_is_position_independent())
1672 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1674 check_non_pic(object, r_type);
1675 if (lsym.get_st_type() != elfcpp::STT_SECTION)
1677 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1678 rela_dyn->add_local(object, r_sym, orig_r_type, output_section,
1679 data_shndx, reloc.get_r_offset(),
1680 reloc.get_r_addend());
1684 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1685 gold_assert(lsym.get_st_value() == 0);
1686 rela_dyn->add_local_relative(object, r_sym, orig_r_type,
1687 output_section, data_shndx,
1688 reloc.get_r_offset(),
1689 reloc.get_r_addend());
1694 case elfcpp::R_SPARC_WDISP30:
1695 case elfcpp::R_SPARC_WDISP22:
1696 case elfcpp::R_SPARC_WDISP19:
1697 case elfcpp::R_SPARC_WDISP16:
1698 case elfcpp::R_SPARC_DISP8:
1699 case elfcpp::R_SPARC_DISP16:
1700 case elfcpp::R_SPARC_DISP32:
1701 case elfcpp::R_SPARC_DISP64:
1702 case elfcpp::R_SPARC_PC10:
1703 case elfcpp::R_SPARC_PC22:
1706 case elfcpp::R_SPARC_GOTDATA_OP:
1707 case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
1708 case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
1709 case elfcpp::R_SPARC_GOT10:
1710 case elfcpp::R_SPARC_GOT13:
1711 case elfcpp::R_SPARC_GOT22:
1713 // The symbol requires a GOT entry.
1714 Output_data_got<size, big_endian>* got;
1717 got = target->got_section(symtab, layout);
1718 r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1720 // If we are generating a shared object, we need to add a
1721 // dynamic relocation for this symbol's GOT entry.
1722 if (parameters->options().output_is_position_independent())
1724 if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
1726 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1729 off = got->add_constant(0);
1730 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
1731 rela_dyn->add_local_relative(object, r_sym,
1732 elfcpp::R_SPARC_RELATIVE,
1737 got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1741 // These are initial TLS relocs, which are expected when
1743 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1744 case elfcpp::R_SPARC_TLS_GD_LO10:
1745 case elfcpp::R_SPARC_TLS_GD_ADD:
1746 case elfcpp::R_SPARC_TLS_GD_CALL:
1747 case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic
1748 case elfcpp::R_SPARC_TLS_LDM_LO10:
1749 case elfcpp::R_SPARC_TLS_LDM_ADD:
1750 case elfcpp::R_SPARC_TLS_LDM_CALL:
1751 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1752 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1753 case elfcpp::R_SPARC_TLS_LDO_ADD:
1754 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1755 case elfcpp::R_SPARC_TLS_IE_LO10:
1756 case elfcpp::R_SPARC_TLS_IE_LD:
1757 case elfcpp::R_SPARC_TLS_IE_LDX:
1758 case elfcpp::R_SPARC_TLS_IE_ADD:
1759 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec
1760 case elfcpp::R_SPARC_TLS_LE_LOX10:
1762 bool output_is_shared = parameters->options().shared();
1763 const tls::Tls_optimization optimized_type
1764 = optimize_tls_reloc(!output_is_shared, r_type);
1767 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1768 case elfcpp::R_SPARC_TLS_GD_LO10:
1769 case elfcpp::R_SPARC_TLS_GD_ADD:
1770 case elfcpp::R_SPARC_TLS_GD_CALL:
1771 if (optimized_type == tls::TLSOPT_NONE)
1773 // Create a pair of GOT entries for the module index and
1774 // dtv-relative offset.
1775 Output_data_got<size, big_endian>* got
1776 = target->got_section(symtab, layout);
1777 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1778 unsigned int shndx = lsym.get_st_shndx();
1780 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1782 object->error(_("local symbol %u has bad shndx %u"),
1785 got->add_local_pair_with_rela(object, r_sym,
1786 lsym.get_st_shndx(),
1788 target->rela_dyn_section(layout),
1790 ? elfcpp::R_SPARC_TLS_DTPMOD64
1791 : elfcpp::R_SPARC_TLS_DTPMOD32),
1793 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL)
1794 generate_tls_call(symtab, layout, target);
1796 else if (optimized_type != tls::TLSOPT_TO_LE)
1797 unsupported_reloc_local(object, r_type);
1800 case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic
1801 case elfcpp::R_SPARC_TLS_LDM_LO10:
1802 case elfcpp::R_SPARC_TLS_LDM_ADD:
1803 case elfcpp::R_SPARC_TLS_LDM_CALL:
1804 if (optimized_type == tls::TLSOPT_NONE)
1806 // Create a GOT entry for the module index.
1807 target->got_mod_index_entry(symtab, layout, object);
1809 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL)
1810 generate_tls_call(symtab, layout, target);
1812 else if (optimized_type != tls::TLSOPT_TO_LE)
1813 unsupported_reloc_local(object, r_type);
1816 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1817 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1818 case elfcpp::R_SPARC_TLS_LDO_ADD:
1821 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1822 case elfcpp::R_SPARC_TLS_IE_LO10:
1823 case elfcpp::R_SPARC_TLS_IE_LD:
1824 case elfcpp::R_SPARC_TLS_IE_LDX:
1825 case elfcpp::R_SPARC_TLS_IE_ADD:
1826 layout->set_has_static_tls();
1827 if (optimized_type == tls::TLSOPT_NONE)
1829 // Create a GOT entry for the tp-relative offset.
1830 Output_data_got<size, big_endian>* got
1831 = target->got_section(symtab, layout);
1832 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1834 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_OFFSET))
1836 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1837 unsigned int off = got->add_constant(0);
1839 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET,
1841 rela_dyn->add_local_relative(object, r_sym,
1843 elfcpp::R_SPARC_TLS_TPOFF64 :
1844 elfcpp::R_SPARC_TLS_TPOFF32),
1848 else if (optimized_type != tls::TLSOPT_TO_LE)
1849 unsupported_reloc_local(object, r_type);
1852 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec
1853 case elfcpp::R_SPARC_TLS_LE_LOX10:
1854 layout->set_has_static_tls();
1855 if (output_is_shared)
1857 // We need to create a dynamic relocation.
1858 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
1859 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1860 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1861 rela_dyn->add_local_relative(object, r_sym, r_type,
1862 output_section, data_shndx,
1863 reloc.get_r_offset(), 0);
1870 // These are relocations which should only be seen by the
1871 // dynamic linker, and should never be seen here.
1872 case elfcpp::R_SPARC_COPY:
1873 case elfcpp::R_SPARC_GLOB_DAT:
1874 case elfcpp::R_SPARC_JMP_SLOT:
1875 case elfcpp::R_SPARC_RELATIVE:
1876 case elfcpp::R_SPARC_TLS_DTPMOD64:
1877 case elfcpp::R_SPARC_TLS_DTPMOD32:
1878 case elfcpp::R_SPARC_TLS_DTPOFF64:
1879 case elfcpp::R_SPARC_TLS_DTPOFF32:
1880 case elfcpp::R_SPARC_TLS_TPOFF64:
1881 case elfcpp::R_SPARC_TLS_TPOFF32:
1882 gold_error(_("%s: unexpected reloc %u in object file"),
1883 object->name().c_str(), r_type);
1887 unsupported_reloc_local(object, r_type);
1892 // Report an unsupported relocation against a global symbol.
1894 template<int size, bool big_endian>
1896 Target_sparc<size, big_endian>::Scan::unsupported_reloc_global(
1897 Sized_relobj<size, big_endian>* object,
1898 unsigned int r_type,
1901 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1902 object->name().c_str(), r_type, gsym->demangled_name().c_str());
1905 // Scan a relocation for a global symbol.
1907 template<int size, bool big_endian>
1909 Target_sparc<size, big_endian>::Scan::global(
1910 Symbol_table* symtab,
1912 Target_sparc<size, big_endian>* target,
1913 Sized_relobj<size, big_endian>* object,
1914 unsigned int data_shndx,
1915 Output_section* output_section,
1916 const elfcpp::Rela<size, big_endian>& reloc,
1917 unsigned int r_type,
1920 unsigned int orig_r_type = r_type;
1922 // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got
1923 // section. We check here to avoid creating a dynamic reloc against
1924 // _GLOBAL_OFFSET_TABLE_.
1925 if (!target->has_got_section()
1926 && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
1927 target->got_section(symtab, layout);
1932 case elfcpp::R_SPARC_NONE:
1933 case elfcpp::R_SPARC_REGISTER:
1934 case elfcpp::R_SPARC_GNU_VTINHERIT:
1935 case elfcpp::R_SPARC_GNU_VTENTRY:
1938 case elfcpp::R_SPARC_PLT64:
1939 case elfcpp::R_SPARC_PLT32:
1940 case elfcpp::R_SPARC_HIPLT22:
1941 case elfcpp::R_SPARC_LOPLT10:
1942 case elfcpp::R_SPARC_PCPLT32:
1943 case elfcpp::R_SPARC_PCPLT22:
1944 case elfcpp::R_SPARC_PCPLT10:
1945 case elfcpp::R_SPARC_WPLT30:
1946 // If the symbol is fully resolved, this is just a PC32 reloc.
1947 // Otherwise we need a PLT entry.
1948 if (gsym->final_value_is_known())
1950 // If building a shared library, we can also skip the PLT entry
1951 // if the symbol is defined in the output file and is protected
1953 if (gsym->is_defined()
1954 && !gsym->is_from_dynobj()
1955 && !gsym->is_preemptible())
1957 target->make_plt_entry(symtab, layout, gsym);
1960 case elfcpp::R_SPARC_DISP8:
1961 case elfcpp::R_SPARC_DISP16:
1962 case elfcpp::R_SPARC_DISP32:
1963 case elfcpp::R_SPARC_DISP64:
1964 case elfcpp::R_SPARC_PC_HH22:
1965 case elfcpp::R_SPARC_PC_HM10:
1966 case elfcpp::R_SPARC_PC_LM22:
1967 case elfcpp::R_SPARC_PC10:
1968 case elfcpp::R_SPARC_PC22:
1969 case elfcpp::R_SPARC_WDISP30:
1970 case elfcpp::R_SPARC_WDISP22:
1971 case elfcpp::R_SPARC_WDISP19:
1972 case elfcpp::R_SPARC_WDISP16:
1974 if (gsym->needs_plt_entry())
1975 target->make_plt_entry(symtab, layout, gsym);
1976 // Make a dynamic relocation if necessary.
1977 int flags = Symbol::NON_PIC_REF;
1978 if (gsym->type() == elfcpp::STT_FUNC)
1979 flags |= Symbol::FUNCTION_CALL;
1980 if (gsym->needs_dynamic_reloc(flags))
1982 if (gsym->may_need_copy_reloc())
1984 target->copy_reloc(symtab, layout, object,
1985 data_shndx, output_section, gsym,
1990 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1991 check_non_pic(object, r_type);
1992 rela_dyn->add_global(gsym, orig_r_type, output_section, object,
1993 data_shndx, reloc.get_r_offset(),
1994 reloc.get_r_addend());
2000 case elfcpp::R_SPARC_UA64:
2001 case elfcpp::R_SPARC_64:
2002 case elfcpp::R_SPARC_HIX22:
2003 case elfcpp::R_SPARC_LOX10:
2004 case elfcpp::R_SPARC_H44:
2005 case elfcpp::R_SPARC_M44:
2006 case elfcpp::R_SPARC_L44:
2007 case elfcpp::R_SPARC_HH22:
2008 case elfcpp::R_SPARC_HM10:
2009 case elfcpp::R_SPARC_LM22:
2010 case elfcpp::R_SPARC_HI22:
2011 case elfcpp::R_SPARC_LO10:
2012 case elfcpp::R_SPARC_OLO10:
2013 case elfcpp::R_SPARC_UA32:
2014 case elfcpp::R_SPARC_32:
2015 case elfcpp::R_SPARC_UA16:
2016 case elfcpp::R_SPARC_16:
2017 case elfcpp::R_SPARC_11:
2018 case elfcpp::R_SPARC_10:
2019 case elfcpp::R_SPARC_8:
2020 case elfcpp::R_SPARC_7:
2021 case elfcpp::R_SPARC_6:
2022 case elfcpp::R_SPARC_5:
2024 // Make a PLT entry if necessary.
2025 if (gsym->needs_plt_entry())
2027 target->make_plt_entry(symtab, layout, gsym);
2028 // Since this is not a PC-relative relocation, we may be
2029 // taking the address of a function. In that case we need to
2030 // set the entry in the dynamic symbol table to the address of
2032 if (gsym->is_from_dynobj() && !parameters->options().shared())
2033 gsym->set_needs_dynsym_value();
2035 // Make a dynamic relocation if necessary.
2036 if (gsym->needs_dynamic_reloc(Symbol::ABSOLUTE_REF))
2038 if (gsym->may_need_copy_reloc())
2040 target->copy_reloc(symtab, layout, object,
2041 data_shndx, output_section, gsym, reloc);
2043 else if ((r_type == elfcpp::R_SPARC_32
2044 || r_type == elfcpp::R_SPARC_64)
2045 && gsym->can_use_relative_reloc(false))
2047 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2048 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE,
2049 output_section, object,
2050 data_shndx, reloc.get_r_offset(),
2051 reloc.get_r_addend());
2055 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2057 check_non_pic(object, r_type);
2058 if (gsym->is_from_dynobj()
2059 || gsym->is_undefined()
2060 || gsym->is_preemptible())
2061 rela_dyn->add_global(gsym, orig_r_type, output_section,
2063 reloc.get_r_offset(),
2064 reloc.get_r_addend());
2066 rela_dyn->add_global_relative(gsym, orig_r_type,
2067 output_section, object,
2069 reloc.get_r_offset(),
2070 reloc.get_r_addend());
2076 case elfcpp::R_SPARC_GOTDATA_OP:
2077 case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
2078 case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
2079 case elfcpp::R_SPARC_GOT10:
2080 case elfcpp::R_SPARC_GOT13:
2081 case elfcpp::R_SPARC_GOT22:
2083 // The symbol requires a GOT entry.
2084 Output_data_got<size, big_endian>* got;
2086 got = target->got_section(symtab, layout);
2087 if (gsym->final_value_is_known())
2088 got->add_global(gsym, GOT_TYPE_STANDARD);
2091 // If this symbol is not fully resolved, we need to add a
2092 // dynamic relocation for it.
2093 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2094 if (gsym->is_from_dynobj()
2095 || gsym->is_undefined()
2096 || gsym->is_preemptible())
2097 got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
2098 elfcpp::R_SPARC_GLOB_DAT);
2099 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
2101 unsigned int off = got->add_constant(0);
2103 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
2104 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE,
2111 // These are initial tls relocs, which are expected when
2113 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
2114 case elfcpp::R_SPARC_TLS_GD_LO10:
2115 case elfcpp::R_SPARC_TLS_GD_ADD:
2116 case elfcpp::R_SPARC_TLS_GD_CALL:
2117 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic
2118 case elfcpp::R_SPARC_TLS_LDM_LO10:
2119 case elfcpp::R_SPARC_TLS_LDM_ADD:
2120 case elfcpp::R_SPARC_TLS_LDM_CALL:
2121 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
2122 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2123 case elfcpp::R_SPARC_TLS_LDO_ADD:
2124 case elfcpp::R_SPARC_TLS_LE_HIX22:
2125 case elfcpp::R_SPARC_TLS_LE_LOX10:
2126 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
2127 case elfcpp::R_SPARC_TLS_IE_LO10:
2128 case elfcpp::R_SPARC_TLS_IE_LD:
2129 case elfcpp::R_SPARC_TLS_IE_LDX:
2130 case elfcpp::R_SPARC_TLS_IE_ADD:
2132 const bool is_final = gsym->final_value_is_known();
2133 const tls::Tls_optimization optimized_type
2134 = optimize_tls_reloc(is_final, r_type);
2137 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
2138 case elfcpp::R_SPARC_TLS_GD_LO10:
2139 case elfcpp::R_SPARC_TLS_GD_ADD:
2140 case elfcpp::R_SPARC_TLS_GD_CALL:
2141 if (optimized_type == tls::TLSOPT_NONE)
2143 // Create a pair of GOT entries for the module index and
2144 // dtv-relative offset.
2145 Output_data_got<size, big_endian>* got
2146 = target->got_section(symtab, layout);
2147 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_PAIR,
2148 target->rela_dyn_section(layout),
2150 elfcpp::R_SPARC_TLS_DTPMOD64 :
2151 elfcpp::R_SPARC_TLS_DTPMOD32),
2153 elfcpp::R_SPARC_TLS_DTPOFF64 :
2154 elfcpp::R_SPARC_TLS_DTPOFF32));
2156 // Emit R_SPARC_WPLT30 against "__tls_get_addr"
2157 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL)
2158 generate_tls_call(symtab, layout, target);
2160 else if (optimized_type == tls::TLSOPT_TO_IE)
2162 // Create a GOT entry for the tp-relative offset.
2163 Output_data_got<size, big_endian>* got
2164 = target->got_section(symtab, layout);
2165 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2166 target->rela_dyn_section(layout),
2168 elfcpp::R_SPARC_TLS_TPOFF64 :
2169 elfcpp::R_SPARC_TLS_TPOFF32));
2171 else if (optimized_type != tls::TLSOPT_TO_LE)
2172 unsupported_reloc_global(object, r_type, gsym);
2175 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic
2176 case elfcpp::R_SPARC_TLS_LDM_LO10:
2177 case elfcpp::R_SPARC_TLS_LDM_ADD:
2178 case elfcpp::R_SPARC_TLS_LDM_CALL:
2179 if (optimized_type == tls::TLSOPT_NONE)
2181 // Create a GOT entry for the module index.
2182 target->got_mod_index_entry(symtab, layout, object);
2184 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL)
2185 generate_tls_call(symtab, layout, target);
2187 else if (optimized_type != tls::TLSOPT_TO_LE)
2188 unsupported_reloc_global(object, r_type, gsym);
2191 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
2192 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2193 case elfcpp::R_SPARC_TLS_LDO_ADD:
2196 case elfcpp::R_SPARC_TLS_LE_HIX22:
2197 case elfcpp::R_SPARC_TLS_LE_LOX10:
2198 layout->set_has_static_tls();
2199 if (parameters->options().shared())
2201 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2202 rela_dyn->add_global_relative(gsym, orig_r_type,
2203 output_section, object,
2204 data_shndx, reloc.get_r_offset(),
2209 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
2210 case elfcpp::R_SPARC_TLS_IE_LO10:
2211 case elfcpp::R_SPARC_TLS_IE_LD:
2212 case elfcpp::R_SPARC_TLS_IE_LDX:
2213 case elfcpp::R_SPARC_TLS_IE_ADD:
2214 layout->set_has_static_tls();
2215 if (optimized_type == tls::TLSOPT_NONE)
2217 // Create a GOT entry for the tp-relative offset.
2218 Output_data_got<size, big_endian>* got
2219 = target->got_section(symtab, layout);
2220 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2221 target->rela_dyn_section(layout),
2223 elfcpp::R_SPARC_TLS_TPOFF64 :
2224 elfcpp::R_SPARC_TLS_TPOFF32));
2226 else if (optimized_type != tls::TLSOPT_TO_LE)
2227 unsupported_reloc_global(object, r_type, gsym);
2233 // These are relocations which should only be seen by the
2234 // dynamic linker, and should never be seen here.
2235 case elfcpp::R_SPARC_COPY:
2236 case elfcpp::R_SPARC_GLOB_DAT:
2237 case elfcpp::R_SPARC_JMP_SLOT:
2238 case elfcpp::R_SPARC_RELATIVE:
2239 case elfcpp::R_SPARC_TLS_DTPMOD64:
2240 case elfcpp::R_SPARC_TLS_DTPMOD32:
2241 case elfcpp::R_SPARC_TLS_DTPOFF64:
2242 case elfcpp::R_SPARC_TLS_DTPOFF32:
2243 case elfcpp::R_SPARC_TLS_TPOFF64:
2244 case elfcpp::R_SPARC_TLS_TPOFF32:
2245 gold_error(_("%s: unexpected reloc %u in object file"),
2246 object->name().c_str(), r_type);
2250 unsupported_reloc_global(object, r_type, gsym);
2255 // Process relocations for gc.
2257 template<int size, bool big_endian>
2259 Target_sparc<size, big_endian>::gc_process_relocs(
2260 Symbol_table* symtab,
2262 Sized_relobj<size, big_endian>* object,
2263 unsigned int data_shndx,
2265 const unsigned char* prelocs,
2267 Output_section* output_section,
2268 bool needs_special_offset_handling,
2269 size_t local_symbol_count,
2270 const unsigned char* plocal_symbols)
2272 typedef Target_sparc<size, big_endian> Sparc;
2273 typedef typename Target_sparc<size, big_endian>::Scan Scan;
2275 gold::gc_process_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>(
2284 needs_special_offset_handling,
2289 // Scan relocations for a section.
2291 template<int size, bool big_endian>
2293 Target_sparc<size, big_endian>::scan_relocs(
2294 Symbol_table* symtab,
2296 Sized_relobj<size, big_endian>* object,
2297 unsigned int data_shndx,
2298 unsigned int sh_type,
2299 const unsigned char* prelocs,
2301 Output_section* output_section,
2302 bool needs_special_offset_handling,
2303 size_t local_symbol_count,
2304 const unsigned char* plocal_symbols)
2306 typedef Target_sparc<size, big_endian> Sparc;
2307 typedef typename Target_sparc<size, big_endian>::Scan Scan;
2309 if (sh_type == elfcpp::SHT_REL)
2311 gold_error(_("%s: unsupported REL reloc section"),
2312 object->name().c_str());
2316 gold::scan_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>(
2325 needs_special_offset_handling,
2330 // Finalize the sections.
2332 template<int size, bool big_endian>
2334 Target_sparc<size, big_endian>::do_finalize_sections(
2336 const Input_objects*,
2339 // Fill in some more dynamic tags.
2340 const Reloc_section* rel_plt = (this->plt_ == NULL
2342 : this->plt_->rel_plt());
2343 layout->add_target_dynamic_tags(false, this->plt_, rel_plt,
2344 this->rela_dyn_, true);
2346 // Emit any relocs we saved in an attempt to avoid generating COPY
2348 if (this->copy_relocs_.any_saved_relocs())
2349 this->copy_relocs_.emit(this->rela_dyn_section(layout));
2352 // Perform a relocation.
2354 template<int size, bool big_endian>
2356 Target_sparc<size, big_endian>::Relocate::relocate(
2357 const Relocate_info<size, big_endian>* relinfo,
2358 Target_sparc* target,
2361 const elfcpp::Rela<size, big_endian>& rela,
2362 unsigned int r_type,
2363 const Sized_symbol<size>* gsym,
2364 const Symbol_value<size>* psymval,
2365 unsigned char* view,
2366 typename elfcpp::Elf_types<size>::Elf_Addr address,
2367 section_size_type view_size)
2371 if (this->ignore_gd_add_)
2373 if (r_type != elfcpp::R_SPARC_TLS_GD_ADD)
2374 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2375 _("missing expected TLS relocation"));
2378 this->ignore_gd_add_ = false;
2383 typedef Sparc_relocate_functions<size, big_endian> Reloc;
2385 // Pick the value to use for symbols defined in shared objects.
2386 Symbol_value<size> symval;
2388 && gsym->use_plt_offset(r_type == elfcpp::R_SPARC_DISP8
2389 || r_type == elfcpp::R_SPARC_DISP16
2390 || r_type == elfcpp::R_SPARC_DISP32
2391 || r_type == elfcpp::R_SPARC_DISP64
2392 || r_type == elfcpp::R_SPARC_PC_HH22
2393 || r_type == elfcpp::R_SPARC_PC_HM10
2394 || r_type == elfcpp::R_SPARC_PC_LM22
2395 || r_type == elfcpp::R_SPARC_PC10
2396 || r_type == elfcpp::R_SPARC_PC22
2397 || r_type == elfcpp::R_SPARC_WDISP30
2398 || r_type == elfcpp::R_SPARC_WDISP22
2399 || r_type == elfcpp::R_SPARC_WDISP19
2400 || r_type == elfcpp::R_SPARC_WDISP16))
2402 elfcpp::Elf_Xword value;
2404 value = target->plt_section()->address() + gsym->plt_offset();
2406 symval.set_output_value(value);
2411 const Sized_relobj<size, big_endian>* object = relinfo->object;
2412 const elfcpp::Elf_Xword addend = rela.get_r_addend();
2414 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT
2415 // pointer points to the beginning, not the end, of the table.
2416 // So we just use the plain offset.
2417 bool have_got_offset = false;
2418 unsigned int got_offset = 0;
2421 case elfcpp::R_SPARC_GOTDATA_OP:
2422 case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
2423 case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
2424 case elfcpp::R_SPARC_GOT10:
2425 case elfcpp::R_SPARC_GOT13:
2426 case elfcpp::R_SPARC_GOT22:
2429 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2430 got_offset = gsym->got_offset(GOT_TYPE_STANDARD);
2434 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2435 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2436 got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
2438 have_got_offset = true;
2447 case elfcpp::R_SPARC_NONE:
2448 case elfcpp::R_SPARC_REGISTER:
2449 case elfcpp::R_SPARC_GNU_VTINHERIT:
2450 case elfcpp::R_SPARC_GNU_VTENTRY:
2453 case elfcpp::R_SPARC_8:
2454 Relocate_functions<size, big_endian>::rela8(view, object,
2458 case elfcpp::R_SPARC_16:
2459 if (rela.get_r_offset() & 0x1)
2461 // The assembler can sometimes emit unaligned relocations
2462 // for dwarf2 cfi directives.
2463 Reloc::ua16(view, object, psymval, addend);
2466 Relocate_functions<size, big_endian>::rela16(view, object,
2470 case elfcpp::R_SPARC_32:
2471 if (!parameters->options().output_is_position_independent())
2473 if (rela.get_r_offset() & 0x3)
2475 // The assembler can sometimes emit unaligned relocations
2476 // for dwarf2 cfi directives.
2477 Reloc::ua32(view, object, psymval, addend);
2480 Relocate_functions<size, big_endian>::rela32(view, object,
2485 case elfcpp::R_SPARC_DISP8:
2486 Reloc::disp8(view, object, psymval, addend, address);
2489 case elfcpp::R_SPARC_DISP16:
2490 Reloc::disp16(view, object, psymval, addend, address);
2493 case elfcpp::R_SPARC_DISP32:
2494 Reloc::disp32(view, object, psymval, addend, address);
2497 case elfcpp::R_SPARC_DISP64:
2498 Reloc::disp64(view, object, psymval, addend, address);
2501 case elfcpp::R_SPARC_WDISP30:
2502 case elfcpp::R_SPARC_WPLT30:
2503 Reloc::wdisp30(view, object, psymval, addend, address);
2506 case elfcpp::R_SPARC_WDISP22:
2507 Reloc::wdisp22(view, object, psymval, addend, address);
2510 case elfcpp::R_SPARC_WDISP19:
2511 Reloc::wdisp19(view, object, psymval, addend, address);
2514 case elfcpp::R_SPARC_WDISP16:
2515 Reloc::wdisp16(view, object, psymval, addend, address);
2518 case elfcpp::R_SPARC_HI22:
2519 Reloc::hi22(view, object, psymval, addend);
2522 case elfcpp::R_SPARC_22:
2523 Reloc::rela32_22(view, object, psymval, addend);
2526 case elfcpp::R_SPARC_13:
2527 Reloc::rela32_13(view, object, psymval, addend);
2530 case elfcpp::R_SPARC_LO10:
2531 Reloc::lo10(view, object, psymval, addend);
2534 case elfcpp::R_SPARC_GOT10:
2535 Reloc::lo10(view, got_offset, addend);
2538 case elfcpp::R_SPARC_GOTDATA_OP:
2541 case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
2542 case elfcpp::R_SPARC_GOT13:
2543 Reloc::rela32_13(view, got_offset, addend);
2546 case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
2547 case elfcpp::R_SPARC_GOT22:
2548 Reloc::hi22(view, got_offset, addend);
2551 case elfcpp::R_SPARC_PC10:
2552 Reloc::pc10(view, object, psymval, addend, address);
2555 case elfcpp::R_SPARC_PC22:
2556 Reloc::pc22(view, object, psymval, addend, address);
2559 case elfcpp::R_SPARC_TLS_DTPOFF32:
2560 case elfcpp::R_SPARC_UA32:
2561 Reloc::ua32(view, object, psymval, addend);
2564 case elfcpp::R_SPARC_PLT64:
2565 Relocate_functions<size, big_endian>::rela64(view, object,
2569 case elfcpp::R_SPARC_PLT32:
2570 Relocate_functions<size, big_endian>::rela32(view, object,
2574 case elfcpp::R_SPARC_HIPLT22:
2575 Reloc::hi22(view, object, psymval, addend);
2578 case elfcpp::R_SPARC_LOPLT10:
2579 Reloc::lo10(view, object, psymval, addend);
2582 case elfcpp::R_SPARC_PCPLT32:
2583 Reloc::disp32(view, object, psymval, addend, address);
2586 case elfcpp::R_SPARC_PCPLT22:
2587 Reloc::pcplt22(view, object, psymval, addend, address);
2590 case elfcpp::R_SPARC_PCPLT10:
2591 Reloc::lo10(view, object, psymval, addend, address);
2594 case elfcpp::R_SPARC_64:
2595 if (!parameters->options().output_is_position_independent())
2597 if (rela.get_r_offset() & 0x7)
2599 // The assembler can sometimes emit unaligned relocations
2600 // for dwarf2 cfi directives.
2601 Reloc::ua64(view, object, psymval, addend);
2604 Relocate_functions<size, big_endian>::rela64(view, object,
2609 case elfcpp::R_SPARC_OLO10:
2611 unsigned int addend2 = rela.get_r_info() & 0xffffffff;
2612 addend2 = ((addend2 >> 8) ^ 0x800000) - 0x800000;
2613 Reloc::olo10(view, object, psymval, addend, addend2);
2617 case elfcpp::R_SPARC_HH22:
2618 Reloc::hh22(view, object, psymval, addend);
2621 case elfcpp::R_SPARC_PC_HH22:
2622 Reloc::pc_hh22(view, object, psymval, addend, address);
2625 case elfcpp::R_SPARC_HM10:
2626 Reloc::hm10(view, object, psymval, addend);
2629 case elfcpp::R_SPARC_PC_HM10:
2630 Reloc::pc_hm10(view, object, psymval, addend, address);
2633 case elfcpp::R_SPARC_LM22:
2634 Reloc::hi22(view, object, psymval, addend);
2637 case elfcpp::R_SPARC_PC_LM22:
2638 Reloc::pcplt22(view, object, psymval, addend, address);
2641 case elfcpp::R_SPARC_11:
2642 Reloc::rela32_11(view, object, psymval, addend);
2645 case elfcpp::R_SPARC_10:
2646 Reloc::rela32_10(view, object, psymval, addend);
2649 case elfcpp::R_SPARC_7:
2650 Reloc::rela32_7(view, object, psymval, addend);
2653 case elfcpp::R_SPARC_6:
2654 Reloc::rela32_6(view, object, psymval, addend);
2657 case elfcpp::R_SPARC_5:
2658 Reloc::rela32_5(view, object, psymval, addend);
2661 case elfcpp::R_SPARC_HIX22:
2662 Reloc::hix22(view, object, psymval, addend);
2665 case elfcpp::R_SPARC_LOX10:
2666 Reloc::lox10(view, object, psymval, addend);
2669 case elfcpp::R_SPARC_H44:
2670 Reloc::h44(view, object, psymval, addend);
2673 case elfcpp::R_SPARC_M44:
2674 Reloc::m44(view, object, psymval, addend);
2677 case elfcpp::R_SPARC_L44:
2678 Reloc::l44(view, object, psymval, addend);
2681 case elfcpp::R_SPARC_TLS_DTPOFF64:
2682 case elfcpp::R_SPARC_UA64:
2683 Reloc::ua64(view, object, psymval, addend);
2686 case elfcpp::R_SPARC_UA16:
2687 Reloc::ua16(view, object, psymval, addend);
2690 case elfcpp::R_SPARC_TLS_GD_HI22:
2691 case elfcpp::R_SPARC_TLS_GD_LO10:
2692 case elfcpp::R_SPARC_TLS_GD_ADD:
2693 case elfcpp::R_SPARC_TLS_GD_CALL:
2694 case elfcpp::R_SPARC_TLS_LDM_HI22:
2695 case elfcpp::R_SPARC_TLS_LDM_LO10:
2696 case elfcpp::R_SPARC_TLS_LDM_ADD:
2697 case elfcpp::R_SPARC_TLS_LDM_CALL:
2698 case elfcpp::R_SPARC_TLS_LDO_HIX22:
2699 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2700 case elfcpp::R_SPARC_TLS_LDO_ADD:
2701 case elfcpp::R_SPARC_TLS_IE_HI22:
2702 case elfcpp::R_SPARC_TLS_IE_LO10:
2703 case elfcpp::R_SPARC_TLS_IE_LD:
2704 case elfcpp::R_SPARC_TLS_IE_LDX:
2705 case elfcpp::R_SPARC_TLS_IE_ADD:
2706 case elfcpp::R_SPARC_TLS_LE_HIX22:
2707 case elfcpp::R_SPARC_TLS_LE_LOX10:
2708 this->relocate_tls(relinfo, target, relnum, rela,
2709 r_type, gsym, psymval, view,
2710 address, view_size);
2713 case elfcpp::R_SPARC_COPY:
2714 case elfcpp::R_SPARC_GLOB_DAT:
2715 case elfcpp::R_SPARC_JMP_SLOT:
2716 case elfcpp::R_SPARC_RELATIVE:
2717 // These are outstanding tls relocs, which are unexpected when
2719 case elfcpp::R_SPARC_TLS_DTPMOD64:
2720 case elfcpp::R_SPARC_TLS_DTPMOD32:
2721 case elfcpp::R_SPARC_TLS_TPOFF64:
2722 case elfcpp::R_SPARC_TLS_TPOFF32:
2723 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2724 _("unexpected reloc %u in object file"),
2729 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2730 _("unsupported reloc %u"),
2738 // Perform a TLS relocation.
2740 template<int size, bool big_endian>
2742 Target_sparc<size, big_endian>::Relocate::relocate_tls(
2743 const Relocate_info<size, big_endian>* relinfo,
2744 Target_sparc<size, big_endian>* target,
2746 const elfcpp::Rela<size, big_endian>& rela,
2747 unsigned int r_type,
2748 const Sized_symbol<size>* gsym,
2749 const Symbol_value<size>* psymval,
2750 unsigned char* view,
2751 typename elfcpp::Elf_types<size>::Elf_Addr address,
2754 Output_segment* tls_segment = relinfo->layout->tls_segment();
2755 typedef Sparc_relocate_functions<size, big_endian> Reloc;
2756 const Sized_relobj<size, big_endian>* object = relinfo->object;
2757 typedef typename elfcpp::Swap<32, true>::Valtype Insntype;
2759 const elfcpp::Elf_Xword addend = rela.get_r_addend();
2760 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0);
2762 const bool is_final =
2764 ? !parameters->options().output_is_position_independent()
2765 : gsym->final_value_is_known());
2766 const tls::Tls_optimization optimized_type
2767 = optimize_tls_reloc(is_final, r_type);
2771 case elfcpp::R_SPARC_TLS_GD_HI22:
2772 case elfcpp::R_SPARC_TLS_GD_LO10:
2773 case elfcpp::R_SPARC_TLS_GD_ADD:
2774 case elfcpp::R_SPARC_TLS_GD_CALL:
2775 if (optimized_type == tls::TLSOPT_TO_LE)
2777 Insntype* wv = reinterpret_cast<Insntype*>(view);
2780 value -= tls_segment->memsz();
2784 case elfcpp::R_SPARC_TLS_GD_HI22:
2785 // TLS_GD_HI22 --> TLS_LE_HIX22
2786 Reloc::hix22(view, value, addend);
2789 case elfcpp::R_SPARC_TLS_GD_LO10:
2790 // TLS_GD_LO10 --> TLS_LE_LOX10
2791 Reloc::lox10(view, value, addend);
2794 case elfcpp::R_SPARC_TLS_GD_ADD:
2795 // add %reg1, %reg2, %reg3 --> mov %g7, %reg2, %reg3
2796 val = elfcpp::Swap<32, true>::readval(wv);
2797 val = (val & ~0x7c000) | 0x1c000;
2798 elfcpp::Swap<32, true>::writeval(wv, val);
2800 case elfcpp::R_SPARC_TLS_GD_CALL:
2801 // call __tls_get_addr --> nop
2802 elfcpp::Swap<32, true>::writeval(wv, sparc_nop);
2809 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2810 ? GOT_TYPE_TLS_OFFSET
2811 : GOT_TYPE_TLS_PAIR);
2814 gold_assert(gsym->has_got_offset(got_type));
2815 value = gsym->got_offset(got_type);
2819 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2820 gold_assert(object->local_has_got_offset(r_sym, got_type));
2821 value = object->local_got_offset(r_sym, got_type);
2823 if (optimized_type == tls::TLSOPT_TO_IE)
2825 Insntype* wv = reinterpret_cast<Insntype*>(view);
2830 case elfcpp::R_SPARC_TLS_GD_HI22:
2831 // TLS_GD_HI22 --> TLS_IE_HI22
2832 Reloc::hi22(view, value, addend);
2835 case elfcpp::R_SPARC_TLS_GD_LO10:
2836 // TLS_GD_LO10 --> TLS_IE_LO10
2837 Reloc::lo10(view, value, addend);
2840 case elfcpp::R_SPARC_TLS_GD_ADD:
2841 // add %reg1, %reg2, %reg3 --> ld [%reg1 + %reg2], %reg3
2842 val = elfcpp::Swap<32, true>::readval(wv);
2849 elfcpp::Swap<32, true>::writeval(wv, val);
2852 case elfcpp::R_SPARC_TLS_GD_CALL:
2853 // The compiler can put the TLS_GD_ADD instruction
2854 // into the delay slot of the call. If so, we need
2855 // to transpose the two instructions so that the
2856 // the new sequence works properly.
2858 // The test we use is if the instruction in the
2859 // delay slot is an add with destination register
2861 val = elfcpp::Swap<32, true>::readval(wv + 1);
2862 if ((val & 0x81f80000) == 0x80000000
2863 && ((val >> 25) & 0x1f) == 0x8)
2870 elfcpp::Swap<32, true>::writeval(wv, val);
2873 this->ignore_gd_add_ = true;
2876 // call __tls_get_addr --> add %g7, %o0, %o0
2877 elfcpp::Swap<32, true>::writeval(wv, 0x9001c008);
2882 else if (optimized_type == tls::TLSOPT_NONE)
2886 case elfcpp::R_SPARC_TLS_GD_HI22:
2887 Reloc::hi22(view, value, addend);
2889 case elfcpp::R_SPARC_TLS_GD_LO10:
2890 Reloc::lo10(view, value, addend);
2892 case elfcpp::R_SPARC_TLS_GD_ADD:
2894 case elfcpp::R_SPARC_TLS_GD_CALL:
2896 Symbol_value<size> symval;
2897 elfcpp::Elf_Xword value;
2900 tsym = target->tls_get_addr_sym_;
2902 value = (target->plt_section()->address() +
2903 tsym->plt_offset());
2904 symval.set_output_value(value);
2905 Reloc::wdisp30(view, object, &symval, addend, address);
2912 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2913 _("unsupported reloc %u"),
2917 case elfcpp::R_SPARC_TLS_LDM_HI22:
2918 case elfcpp::R_SPARC_TLS_LDM_LO10:
2919 case elfcpp::R_SPARC_TLS_LDM_ADD:
2920 case elfcpp::R_SPARC_TLS_LDM_CALL:
2921 if (optimized_type == tls::TLSOPT_TO_LE)
2923 Insntype* wv = reinterpret_cast<Insntype*>(view);
2927 case elfcpp::R_SPARC_TLS_LDM_HI22:
2928 case elfcpp::R_SPARC_TLS_LDM_LO10:
2929 case elfcpp::R_SPARC_TLS_LDM_ADD:
2930 elfcpp::Swap<32, true>::writeval(wv, sparc_nop);
2933 case elfcpp::R_SPARC_TLS_LDM_CALL:
2934 elfcpp::Swap<32, true>::writeval(wv, sparc_mov_g0_o0);
2939 else if (optimized_type == tls::TLSOPT_NONE)
2941 // Relocate the field with the offset of the GOT entry for
2942 // the module index.
2943 unsigned int got_offset;
2945 got_offset = target->got_mod_index_entry(NULL, NULL, NULL);
2948 case elfcpp::R_SPARC_TLS_LDM_HI22:
2949 Reloc::hi22(view, got_offset, addend);
2951 case elfcpp::R_SPARC_TLS_LDM_LO10:
2952 Reloc::lo10(view, got_offset, addend);
2954 case elfcpp::R_SPARC_TLS_LDM_ADD:
2956 case elfcpp::R_SPARC_TLS_LDM_CALL:
2958 Symbol_value<size> symval;
2959 elfcpp::Elf_Xword value;
2962 tsym = target->tls_get_addr_sym_;
2964 value = (target->plt_section()->address() +
2965 tsym->plt_offset());
2966 symval.set_output_value(value);
2967 Reloc::wdisp30(view, object, &symval, addend, address);
2973 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2974 _("unsupported reloc %u"),
2978 // These relocs can appear in debugging sections, in which case
2979 // we won't see the TLS_LDM relocs. The local_dynamic_type
2980 // field tells us this.
2981 case elfcpp::R_SPARC_TLS_LDO_HIX22:
2982 if (optimized_type == tls::TLSOPT_TO_LE)
2984 value -= tls_segment->memsz();
2985 Reloc::hix22(view, value, addend);
2988 Reloc::ldo_hix22(view, value, addend);
2990 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2991 if (optimized_type == tls::TLSOPT_TO_LE)
2993 value -= tls_segment->memsz();
2994 Reloc::lox10(view, value, addend);
2997 Reloc::ldo_lox10(view, value, addend);
2999 case elfcpp::R_SPARC_TLS_LDO_ADD:
3000 if (optimized_type == tls::TLSOPT_TO_LE)
3002 Insntype* wv = reinterpret_cast<Insntype*>(view);
3005 // add %reg1, %reg2, %reg3 --> add %g7, %reg2, %reg3
3006 val = elfcpp::Swap<32, true>::readval(wv);
3007 val = (val & ~0x7c000) | 0x1c000;
3008 elfcpp::Swap<32, true>::writeval(wv, val);
3012 // When optimizing IE --> LE, the only relocation that is handled
3013 // differently is R_SPARC_TLS_IE_LD, it is rewritten from
3014 // 'ld{,x} [rs1 + rs2], rd' into 'mov rs2, rd' or simply a NOP is
3015 // rs2 and rd are the same.
3016 case elfcpp::R_SPARC_TLS_IE_LD:
3017 case elfcpp::R_SPARC_TLS_IE_LDX:
3018 if (optimized_type == tls::TLSOPT_TO_LE)
3020 Insntype* wv = reinterpret_cast<Insntype*>(view);
3021 Insntype val = elfcpp::Swap<32, true>::readval(wv);
3022 Insntype rs2 = val & 0x1f;
3023 Insntype rd = (val >> 25) & 0x1f;
3028 val = sparc_mov | (val & 0x3e00001f);
3030 elfcpp::Swap<32, true>::writeval(wv, val);
3034 case elfcpp::R_SPARC_TLS_IE_HI22:
3035 case elfcpp::R_SPARC_TLS_IE_LO10:
3036 if (optimized_type == tls::TLSOPT_TO_LE)
3038 value -= tls_segment->memsz();
3041 case elfcpp::R_SPARC_TLS_IE_HI22:
3042 // IE_HI22 --> LE_HIX22
3043 Reloc::hix22(view, value, addend);
3045 case elfcpp::R_SPARC_TLS_IE_LO10:
3046 // IE_LO10 --> LE_LOX10
3047 Reloc::lox10(view, value, addend);
3052 else if (optimized_type == tls::TLSOPT_NONE)
3054 // Relocate the field with the offset of the GOT entry for
3055 // the tp-relative offset of the symbol.
3058 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
3059 value = gsym->got_offset(GOT_TYPE_TLS_OFFSET);
3063 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3064 gold_assert(object->local_has_got_offset(r_sym,
3065 GOT_TYPE_TLS_OFFSET));
3066 value = object->local_got_offset(r_sym,
3067 GOT_TYPE_TLS_OFFSET);
3071 case elfcpp::R_SPARC_TLS_IE_HI22:
3072 Reloc::hi22(view, value, addend);
3074 case elfcpp::R_SPARC_TLS_IE_LO10:
3075 Reloc::lo10(view, value, addend);
3080 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3081 _("unsupported reloc %u"),
3085 case elfcpp::R_SPARC_TLS_IE_ADD:
3086 // This seems to be mainly so that we can find the addition
3087 // instruction if there is one. There doesn't seem to be any
3088 // actual relocation to apply.
3091 case elfcpp::R_SPARC_TLS_LE_HIX22:
3092 // If we're creating a shared library, a dynamic relocation will
3093 // have been created for this location, so do not apply it now.
3094 if (!parameters->options().shared())
3096 value -= tls_segment->memsz();
3097 Reloc::hix22(view, value, addend);
3101 case elfcpp::R_SPARC_TLS_LE_LOX10:
3102 // If we're creating a shared library, a dynamic relocation will
3103 // have been created for this location, so do not apply it now.
3104 if (!parameters->options().shared())
3106 value -= tls_segment->memsz();
3107 Reloc::lox10(view, value, addend);
3113 // Relocate section data.
3115 template<int size, bool big_endian>
3117 Target_sparc<size, big_endian>::relocate_section(
3118 const Relocate_info<size, big_endian>* relinfo,
3119 unsigned int sh_type,
3120 const unsigned char* prelocs,
3122 Output_section* output_section,
3123 bool needs_special_offset_handling,
3124 unsigned char* view,
3125 typename elfcpp::Elf_types<size>::Elf_Addr address,
3126 section_size_type view_size,
3127 const Reloc_symbol_changes* reloc_symbol_changes)
3129 typedef Target_sparc<size, big_endian> Sparc;
3130 typedef typename Target_sparc<size, big_endian>::Relocate Sparc_relocate;
3132 gold_assert(sh_type == elfcpp::SHT_RELA);
3134 gold::relocate_section<size, big_endian, Sparc, elfcpp::SHT_RELA,
3141 needs_special_offset_handling,
3145 reloc_symbol_changes);
3148 // Return the size of a relocation while scanning during a relocatable
3151 template<int size, bool big_endian>
3153 Target_sparc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
3157 // We are always SHT_RELA, so we should never get here.
3162 // Scan the relocs during a relocatable link.
3164 template<int size, bool big_endian>
3166 Target_sparc<size, big_endian>::scan_relocatable_relocs(
3167 Symbol_table* symtab,
3169 Sized_relobj<size, big_endian>* object,
3170 unsigned int data_shndx,
3171 unsigned int sh_type,
3172 const unsigned char* prelocs,
3174 Output_section* output_section,
3175 bool needs_special_offset_handling,
3176 size_t local_symbol_count,
3177 const unsigned char* plocal_symbols,
3178 Relocatable_relocs* rr)
3180 gold_assert(sh_type == elfcpp::SHT_RELA);
3182 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
3183 Relocatable_size_for_reloc> Scan_relocatable_relocs;
3185 gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
3186 Scan_relocatable_relocs>(
3194 needs_special_offset_handling,
3200 // Relocate a section during a relocatable link.
3202 template<int size, bool big_endian>
3204 Target_sparc<size, big_endian>::relocate_for_relocatable(
3205 const Relocate_info<size, big_endian>* relinfo,
3206 unsigned int sh_type,
3207 const unsigned char* prelocs,
3209 Output_section* output_section,
3210 off_t offset_in_output_section,
3211 const Relocatable_relocs* rr,
3212 unsigned char* view,
3213 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
3214 section_size_type view_size,
3215 unsigned char* reloc_view,
3216 section_size_type reloc_view_size)
3218 gold_assert(sh_type == elfcpp::SHT_RELA);
3220 gold::relocate_for_relocatable<size, big_endian, elfcpp::SHT_RELA>(
3225 offset_in_output_section,
3234 // Return the value to use for a dynamic which requires special
3235 // treatment. This is how we support equality comparisons of function
3236 // pointers across shared library boundaries, as described in the
3237 // processor specific ABI supplement.
3239 template<int size, bool big_endian>
3241 Target_sparc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
3243 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3244 return this->plt_section()->address() + gsym->plt_offset();
3247 // The selector for sparc object files.
3249 template<int size, bool big_endian>
3250 class Target_selector_sparc : public Target_selector
3253 Target_selector_sparc()
3254 : Target_selector(elfcpp::EM_NONE, size, big_endian,
3255 (size == 64 ? "elf64-sparc" : "elf32-sparc"))
3258 Target* do_recognize(int machine, int, int)
3263 if (machine != elfcpp::EM_SPARCV9)
3268 if (machine != elfcpp::EM_SPARC
3269 && machine != elfcpp::EM_SPARC32PLUS)
3277 return this->instantiate_target();
3280 Target* do_instantiate_target()
3281 { return new Target_sparc<size, big_endian>(); }
3284 Target_selector_sparc<32, true> target_selector_sparc32;
3285 Target_selector_sparc<64, true> target_selector_sparc64;
3287 } // End anonymous namespace.