1 // sparc.cc -- sparc target support for gold.
3 // Copyright 2008 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"
49 template<int size
, bool big_endian
>
50 class Output_data_plt_sparc
;
52 template<int size
, bool big_endian
>
53 class Target_sparc
: public Sized_target
<size
, big_endian
>
56 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, big_endian
> Reloc_section
;
59 : Sized_target
<size
, big_endian
>(&sparc_info
),
60 got_(NULL
), plt_(NULL
), rela_dyn_(NULL
),
61 copy_relocs_(elfcpp::R_SPARC_COPY
), dynbss_(NULL
),
62 got_mod_index_offset_(-1U), tls_get_addr_sym_(NULL
)
66 // Scan the relocations to look for symbol adjustments.
68 scan_relocs(const General_options
& options
,
71 Sized_relobj
<size
, big_endian
>* object
,
72 unsigned int data_shndx
,
74 const unsigned char* prelocs
,
76 Output_section
* output_section
,
77 bool needs_special_offset_handling
,
78 size_t local_symbol_count
,
79 const unsigned char* plocal_symbols
);
80 // Finalize the sections.
82 do_finalize_sections(Layout
*);
84 // Return the value to use for a dynamic which requires special
87 do_dynsym_value(const Symbol
*) const;
89 // Relocate a section.
91 relocate_section(const Relocate_info
<size
, big_endian
>*,
93 const unsigned char* prelocs
,
95 Output_section
* output_section
,
96 bool needs_special_offset_handling
,
98 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
99 section_size_type view_size
);
101 // Scan the relocs during a relocatable link.
103 scan_relocatable_relocs(const General_options
& options
,
104 Symbol_table
* symtab
,
106 Sized_relobj
<size
, big_endian
>* object
,
107 unsigned int data_shndx
,
108 unsigned int sh_type
,
109 const unsigned char* prelocs
,
111 Output_section
* output_section
,
112 bool needs_special_offset_handling
,
113 size_t local_symbol_count
,
114 const unsigned char* plocal_symbols
,
115 Relocatable_relocs
*);
117 // Relocate a section during a relocatable link.
119 relocate_for_relocatable(const Relocate_info
<size
, big_endian
>*,
120 unsigned int sh_type
,
121 const unsigned char* prelocs
,
123 Output_section
* output_section
,
124 off_t offset_in_output_section
,
125 const Relocatable_relocs
*,
127 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
128 section_size_type view_size
,
129 unsigned char* reloc_view
,
130 section_size_type reloc_view_size
);
131 // Return whether SYM is defined by the ABI.
133 do_is_defined_by_abi(Symbol
* sym
) const
135 // XXX Really need to support this better...
136 if (sym
->type() == elfcpp::STT_SPARC_REGISTER
)
139 return strcmp(sym
->name(), "___tls_get_addr") == 0;
142 // Return the size of the GOT section.
146 gold_assert(this->got_
!= NULL
);
147 return this->got_
->data_size();
152 // The class which scans relocations.
157 : issued_non_pic_error_(false)
161 local(const General_options
& options
, Symbol_table
* symtab
,
162 Layout
* layout
, Target_sparc
* target
,
163 Sized_relobj
<size
, big_endian
>* object
,
164 unsigned int data_shndx
,
165 Output_section
* output_section
,
166 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
167 const elfcpp::Sym
<size
, big_endian
>& lsym
);
170 global(const General_options
& options
, Symbol_table
* symtab
,
171 Layout
* layout
, Target_sparc
* target
,
172 Sized_relobj
<size
, big_endian
>* object
,
173 unsigned int data_shndx
,
174 Output_section
* output_section
,
175 const elfcpp::Rela
<size
, big_endian
>& reloc
, unsigned int r_type
,
180 unsupported_reloc_local(Sized_relobj
<size
, big_endian
>*,
181 unsigned int r_type
);
184 unsupported_reloc_global(Sized_relobj
<size
, big_endian
>*,
185 unsigned int r_type
, Symbol
*);
188 generate_tls_call(Symbol_table
* symtab
, Layout
* layout
,
189 Target_sparc
* target
);
192 check_non_pic(Relobj
*, unsigned int r_type
);
194 // Whether we have issued an error about a non-PIC compilation.
195 bool issued_non_pic_error_
;
198 // The class which implements relocation.
203 : ignore_gd_add_(false)
208 if (this->ignore_gd_add_
)
210 // FIXME: This needs to specify the location somehow.
211 gold_error(_("missing expected TLS relocation"));
215 // Do a relocation. Return false if the caller should not issue
216 // any warnings about this relocation.
218 relocate(const Relocate_info
<size
, big_endian
>*, Target_sparc
*,
219 size_t relnum
, const elfcpp::Rela
<size
, big_endian
>&,
220 unsigned int r_type
, const Sized_symbol
<size
>*,
221 const Symbol_value
<size
>*,
223 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
227 // Do a TLS relocation.
229 relocate_tls(const Relocate_info
<size
, big_endian
>*, Target_sparc
* target
,
230 size_t relnum
, const elfcpp::Rela
<size
, big_endian
>&,
231 unsigned int r_type
, const Sized_symbol
<size
>*,
232 const Symbol_value
<size
>*,
234 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
237 // Ignore the next relocation which should be R_SPARC_TLS_GD_ADD
241 // A class which returns the size required for a relocation type,
242 // used while scanning relocs during a relocatable link.
243 class Relocatable_size_for_reloc
247 get_size_for_reloc(unsigned int, Relobj
*);
250 // Get the GOT section, creating it if necessary.
251 Output_data_got
<size
, big_endian
>*
252 got_section(Symbol_table
*, Layout
*);
254 // Create a PLT entry for a global symbol.
256 make_plt_entry(Symbol_table
*, Layout
*, Symbol
*);
258 // Create a GOT entry for the TLS module index.
260 got_mod_index_entry(Symbol_table
* symtab
, Layout
* layout
,
261 Sized_relobj
<size
, big_endian
>* object
);
263 // Return the gsym for "__tls_get_addr". Cache if not already
266 tls_get_addr_sym(Symbol_table
* symtab
)
268 if (!this->tls_get_addr_sym_
)
269 this->tls_get_addr_sym_
= symtab
->lookup("__tls_get_addr", NULL
);
270 gold_assert(this->tls_get_addr_sym_
);
271 return this->tls_get_addr_sym_
;
274 // Get the PLT section.
275 const Output_data_plt_sparc
<size
, big_endian
>*
278 gold_assert(this->plt_
!= NULL
);
282 // Get the dynamic reloc section, creating it if necessary.
284 rela_dyn_section(Layout
*);
286 // Return true if the symbol may need a COPY relocation.
287 // References from an executable object to non-function symbols
288 // defined in a dynamic object may need a COPY relocation.
290 may_need_copy_reloc(Symbol
* gsym
)
292 return (!parameters
->options().shared()
293 && gsym
->is_from_dynobj()
294 && gsym
->type() != elfcpp::STT_FUNC
);
297 // Copy a relocation against a global symbol.
299 copy_reloc(Symbol_table
* symtab
, Layout
* layout
, Relobj
* object
,
300 unsigned int shndx
, Output_section
* output_section
,
301 Symbol
* sym
, const elfcpp::Rela
<size
, big_endian
>& reloc
)
303 this->copy_relocs_
.copy_reloc(symtab
, layout
,
304 symtab
->get_sized_symbol
<size
>(sym
),
305 object
, shndx
, output_section
,
306 reloc
, this->rela_dyn_section(layout
));
309 // Information about this specific target which we pass to the
310 // general Target structure.
311 static Target::Target_info sparc_info
;
313 // The types of GOT entries needed for this platform.
316 GOT_TYPE_STANDARD
= 0, // GOT entry for a regular symbol
317 GOT_TYPE_TLS_OFFSET
= 1, // GOT entry for TLS offset
318 GOT_TYPE_TLS_PAIR
= 2, // GOT entry for TLS module/offset pair
322 Output_data_got
<size
, big_endian
>* got_
;
324 Output_data_plt_sparc
<size
, big_endian
>* plt_
;
325 // The dynamic reloc section.
326 Reloc_section
* rela_dyn_
;
327 // Relocs saved to avoid a COPY reloc.
328 Copy_relocs
<elfcpp::SHT_RELA
, size
, big_endian
> copy_relocs_
;
329 // Space for variables copied with a COPY reloc.
330 Output_data_space
* dynbss_
;
331 // Offset of the GOT entry for the TLS module index;
332 unsigned int got_mod_index_offset_
;
333 // Cached pointer to __tls_get_addr symbol
334 Symbol
* tls_get_addr_sym_
;
338 Target::Target_info Target_sparc
<32, true>::sparc_info
=
341 true, // is_big_endian
342 elfcpp::EM_SPARC
, // machine_code
343 false, // has_make_symbol
344 false, // has_resolve
345 false, // has_code_fill
346 true, // is_default_stack_executable
348 "/usr/lib/ld.so.1", // dynamic_linker
349 0x00010000, // default_text_segment_address
350 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
351 8 * 1024 // common_pagesize (overridable by -z common-page-size)
355 Target::Target_info Target_sparc
<64, true>::sparc_info
=
358 true, // is_big_endian
359 elfcpp::EM_SPARCV9
, // machine_code
360 false, // has_make_symbol
361 false, // has_resolve
362 false, // has_code_fill
363 true, // is_default_stack_executable
365 "/usr/lib/sparcv9/ld.so.1", // dynamic_linker
366 0x100000, // default_text_segment_address
367 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
368 8 * 1024 // common_pagesize (overridable by -z common-page-size)
371 // We have to take care here, even when operating in little-endian
372 // mode, sparc instructions are still big endian.
373 template<int size
, bool big_endian
>
374 class Sparc_relocate_functions
377 // Do a simple relocation with the addend in the relocation.
378 template<int valsize
>
380 rela(unsigned char* view
,
381 unsigned int right_shift
,
382 typename
elfcpp::Elf_types
<valsize
>::Elf_Addr dst_mask
,
383 typename
elfcpp::Swap
<size
, big_endian
>::Valtype value
,
384 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
)
386 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
387 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
388 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
389 Valtype reloc
= ((value
+ addend
) >> right_shift
);
394 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
397 // Do a simple relocation using a symbol value with the addend in
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 const Sized_relobj
<size
, big_endian
>* object
,
405 const Symbol_value
<size
>* psymval
,
406 typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype addend
)
408 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
409 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
410 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
411 Valtype reloc
= (psymval
->value(object
, addend
) >> right_shift
);
416 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
419 // Do a simple relocation using a symbol value with the addend in
420 // the relocation, unaligned.
421 template<int valsize
>
423 rela_ua(unsigned char* view
,
424 unsigned int right_shift
, elfcpp::Elf_Xword dst_mask
,
425 const Sized_relobj
<size
, big_endian
>* object
,
426 const Symbol_value
<size
>* psymval
,
427 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
)
429 typedef typename
elfcpp::Swap_unaligned
<valsize
,
430 big_endian
>::Valtype Valtype
;
431 unsigned char* wv
= view
;
432 Valtype val
= elfcpp::Swap_unaligned
<valsize
, big_endian
>::readval(wv
);
433 Valtype reloc
= (psymval
->value(object
, addend
) >> right_shift
);
438 elfcpp::Swap_unaligned
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
441 // Do a simple PC relative relocation with a Symbol_value with the
442 // addend in the relocation.
443 template<int valsize
>
445 pcrela(unsigned char* view
,
446 unsigned int right_shift
,
447 typename
elfcpp::Elf_types
<valsize
>::Elf_Addr dst_mask
,
448 const Sized_relobj
<size
, big_endian
>* object
,
449 const Symbol_value
<size
>* psymval
,
450 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
,
451 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
453 typedef typename
elfcpp::Swap
<valsize
, big_endian
>::Valtype Valtype
;
454 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
455 Valtype val
= elfcpp::Swap
<valsize
, big_endian
>::readval(wv
);
456 Valtype reloc
= ((psymval
->value(object
, addend
) - address
)
462 elfcpp::Swap
<valsize
, big_endian
>::writeval(wv
, val
| reloc
);
465 template<int valsize
>
467 pcrela_unaligned(unsigned char* view
,
468 const Sized_relobj
<size
, big_endian
>* object
,
469 const Symbol_value
<size
>* psymval
,
470 typename
elfcpp::Swap
<size
, big_endian
>::Valtype addend
,
471 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
473 typedef typename
elfcpp::Swap_unaligned
<valsize
,
474 big_endian
>::Valtype Valtype
;
475 unsigned char* wv
= view
;
476 Valtype reloc
= (psymval
->value(object
, addend
) - address
);
478 elfcpp::Swap_unaligned
<valsize
, big_endian
>::writeval(wv
, reloc
);
481 typedef Sparc_relocate_functions
<size
, big_endian
> This
;
482 typedef Sparc_relocate_functions
<size
, true> This_insn
;
485 // R_SPARC_WDISP30: (Symbol + Addend - Address) >> 2
487 wdisp30(unsigned char* view
,
488 const Sized_relobj
<size
, big_endian
>* object
,
489 const Symbol_value
<size
>* psymval
,
490 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
491 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
493 This_insn::template pcrela
<32>(view
, 2, 0x3fffffff, object
,
494 psymval
, addend
, address
);
497 // R_SPARC_WDISP22: (Symbol + Addend - Address) >> 2
499 wdisp22(unsigned char* view
,
500 const Sized_relobj
<size
, big_endian
>* object
,
501 const Symbol_value
<size
>* psymval
,
502 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
503 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
505 This_insn::template pcrela
<32>(view
, 2, 0x003fffff, object
,
506 psymval
, addend
, address
);
509 // R_SPARC_WDISP19: (Symbol + Addend - Address) >> 2
511 wdisp19(unsigned char* view
,
512 const Sized_relobj
<size
, big_endian
>* object
,
513 const Symbol_value
<size
>* psymval
,
514 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
515 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
517 This_insn::template pcrela
<32>(view
, 2, 0x0007ffff, object
,
518 psymval
, addend
, address
);
521 // R_SPARC_WDISP16: (Symbol + Addend - Address) >> 2
523 wdisp16(unsigned char* view
,
524 const Sized_relobj
<size
, big_endian
>* object
,
525 const Symbol_value
<size
>* psymval
,
526 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
527 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
529 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
530 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
531 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
532 Valtype reloc
= ((psymval
->value(object
, addend
) - address
)
535 // The relocation value is split between the low 14 bits,
537 val
&= ~((0x3 << 20) | 0x3fff);
538 reloc
= (((reloc
& 0xc000) << (20 - 14))
539 | (reloc
& 0x3ffff));
541 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
544 // R_SPARC_PC22: (Symbol + Addend - Address) >> 10
546 pc22(unsigned char* view
,
547 const Sized_relobj
<size
, big_endian
>* object
,
548 const Symbol_value
<size
>* psymval
,
549 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
550 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
552 This_insn::template pcrela
<32>(view
, 10, 0x003fffff, object
,
553 psymval
, addend
, address
);
556 // R_SPARC_PC10: (Symbol + Addend - Address) & 0x3ff
558 pc10(unsigned char* view
,
559 const Sized_relobj
<size
, big_endian
>* object
,
560 const Symbol_value
<size
>* psymval
,
561 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
562 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
564 This_insn::template pcrela
<32>(view
, 0, 0x000003ff, object
,
565 psymval
, addend
, address
);
568 // R_SPARC_HI22: (Symbol + Addend) >> 10
570 hi22(unsigned char* view
,
571 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
572 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
574 This_insn::template rela
<32>(view
, 10, 0x003fffff, value
, addend
);
577 // R_SPARC_HI22: (Symbol + Addend) >> 10
579 hi22(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
)
584 This_insn::template rela
<32>(view
, 10, 0x003fffff, object
, psymval
, addend
);
587 // R_SPARC_PCPLT22: (Symbol + Addend - Address) >> 10
589 pcplt22(unsigned char* view
,
590 const Sized_relobj
<size
, big_endian
>* object
,
591 const Symbol_value
<size
>* psymval
,
592 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
593 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
595 This_insn::template pcrela
<32>(view
, 10, 0x003fffff, object
,
596 psymval
, addend
, address
);
599 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
601 lo10(unsigned char* view
,
602 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
603 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
605 This_insn::template rela
<32>(view
, 0, 0x000003ff, value
, addend
);
608 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
610 lo10(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
)
615 This_insn::template rela
<32>(view
, 0, 0x000003ff, object
, psymval
, addend
);
618 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
620 lo10(unsigned char* view
,
621 const Sized_relobj
<size
, big_endian
>* object
,
622 const Symbol_value
<size
>* psymval
,
623 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
624 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
626 This_insn::template pcrela
<32>(view
, 0, 0x000003ff, object
,
627 psymval
, addend
, address
);
630 // R_SPARC_OLO10: ((Symbol + Addend) & 0x3ff) + Addend2
632 olo10(unsigned char* view
,
633 const Sized_relobj
<size
, big_endian
>* object
,
634 const Symbol_value
<size
>* psymval
,
635 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
636 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend2
)
638 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
639 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
640 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
641 Valtype reloc
= psymval
->value(object
, addend
);
648 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
651 // R_SPARC_22: (Symbol + Addend)
653 rela32_22(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
)
658 This_insn::template rela
<32>(view
, 0, 0x003fffff, object
, psymval
, addend
);
661 // R_SPARC_13: (Symbol + Addend)
663 rela32_13(unsigned char* view
,
664 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
665 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
667 This_insn::template rela
<32>(view
, 0, 0x00001fff, value
, addend
);
670 // R_SPARC_13: (Symbol + Addend)
672 rela32_13(unsigned char* view
,
673 const Sized_relobj
<size
, big_endian
>* object
,
674 const Symbol_value
<size
>* psymval
,
675 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
677 This_insn::template rela
<32>(view
, 0, 0x00001fff, object
, psymval
, addend
);
680 // R_SPARC_UA16: (Symbol + Addend)
682 ua16(unsigned char* view
,
683 const Sized_relobj
<size
, big_endian
>* object
,
684 const Symbol_value
<size
>* psymval
,
685 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
687 This::template rela_ua
<16>(view
, 0, 0xffff, object
, psymval
, addend
);
690 // R_SPARC_UA32: (Symbol + Addend)
692 ua32(unsigned char* view
,
693 const Sized_relobj
<size
, big_endian
>* object
,
694 const Symbol_value
<size
>* psymval
,
695 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
697 This::template rela_ua
<32>(view
, 0, 0xffffffff, object
, psymval
, addend
);
700 // R_SPARC_UA64: (Symbol + Addend)
702 ua64(unsigned char* view
,
703 const Sized_relobj
<size
, big_endian
>* object
,
704 const Symbol_value
<size
>* psymval
,
705 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
707 This::template rela_ua
<64>(view
, 0, ~(elfcpp::Elf_Xword
) 0,
708 object
, psymval
, addend
);
711 // R_SPARC_DISP8: (Symbol + Addend - Address)
713 disp8(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
,
717 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
719 This::template pcrela_unaligned
<8>(view
, object
, psymval
,
723 // R_SPARC_DISP16: (Symbol + Addend - Address)
725 disp16(unsigned char* view
,
726 const Sized_relobj
<size
, big_endian
>* object
,
727 const Symbol_value
<size
>* psymval
,
728 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
729 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
731 This::template pcrela_unaligned
<16>(view
, object
, psymval
,
735 // R_SPARC_DISP32: (Symbol + Addend - Address)
737 disp32(unsigned char* view
,
738 const Sized_relobj
<size
, big_endian
>* object
,
739 const Symbol_value
<size
>* psymval
,
740 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
741 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
743 This::template pcrela_unaligned
<32>(view
, object
, psymval
,
747 // R_SPARC_DISP64: (Symbol + Addend - Address)
749 disp64(unsigned char* view
,
750 const Sized_relobj
<size
, big_endian
>* object
,
751 const Symbol_value
<size
>* psymval
,
752 elfcpp::Elf_Xword addend
,
753 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
755 This::template pcrela_unaligned
<64>(view
, object
, psymval
,
759 // R_SPARC_H44: (Symbol + Addend) >> 22
761 h44(unsigned char* view
,
762 const Sized_relobj
<size
, big_endian
>* object
,
763 const Symbol_value
<size
>* psymval
,
764 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
766 This_insn::template rela
<32>(view
, 22, 0x003fffff, object
, psymval
, addend
);
769 // R_SPARC_M44: ((Symbol + Addend) >> 12) & 0x3ff
771 m44(unsigned char* view
,
772 const Sized_relobj
<size
, big_endian
>* object
,
773 const Symbol_value
<size
>* psymval
,
774 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
776 This_insn::template rela
<32>(view
, 12, 0x000003ff, object
, psymval
, addend
);
779 // R_SPARC_L44: (Symbol + Addend) & 0xfff
781 l44(unsigned char* view
,
782 const Sized_relobj
<size
, big_endian
>* object
,
783 const Symbol_value
<size
>* psymval
,
784 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
786 This_insn::template rela
<32>(view
, 0, 0x00000fff, object
, psymval
, addend
);
789 // R_SPARC_HH22: (Symbol + Addend) >> 42
791 hh22(unsigned char* view
,
792 const Sized_relobj
<size
, big_endian
>* object
,
793 const Symbol_value
<size
>* psymval
,
794 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
796 This_insn::template rela
<32>(view
, 42, 0x003fffff, object
, psymval
, addend
);
799 // R_SPARC_PC_HH22: (Symbol + Addend - Address) >> 42
801 pc_hh22(unsigned char* view
,
802 const Sized_relobj
<size
, big_endian
>* object
,
803 const Symbol_value
<size
>* psymval
,
804 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
805 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
807 This_insn::template pcrela
<32>(view
, 42, 0x003fffff, object
,
808 psymval
, addend
, address
);
811 // R_SPARC_HM10: ((Symbol + Addend) >> 32) & 0x3ff
813 hm10(unsigned char* view
,
814 const Sized_relobj
<size
, big_endian
>* object
,
815 const Symbol_value
<size
>* psymval
,
816 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
818 This_insn::template rela
<32>(view
, 32, 0x000003ff, object
, psymval
, addend
);
821 // R_SPARC_PC_HM10: ((Symbol + Addend - Address) >> 32) & 0x3ff
823 pc_hm10(unsigned char* view
,
824 const Sized_relobj
<size
, big_endian
>* object
,
825 const Symbol_value
<size
>* psymval
,
826 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
,
827 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
)
829 This_insn::template pcrela
<32>(view
, 32, 0x000003ff, object
,
830 psymval
, addend
, address
);
833 // R_SPARC_11: (Symbol + Addend)
835 rela32_11(unsigned char* view
,
836 const Sized_relobj
<size
, big_endian
>* object
,
837 const Symbol_value
<size
>* psymval
,
838 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
840 This_insn::template rela
<32>(view
, 0, 0x000007ff, object
, psymval
, addend
);
843 // R_SPARC_10: (Symbol + Addend)
845 rela32_10(unsigned char* view
,
846 const Sized_relobj
<size
, big_endian
>* object
,
847 const Symbol_value
<size
>* psymval
,
848 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
850 This_insn::template rela
<32>(view
, 0, 0x000003ff, object
, psymval
, addend
);
853 // R_SPARC_7: (Symbol + Addend)
855 rela32_7(unsigned char* view
,
856 const Sized_relobj
<size
, big_endian
>* object
,
857 const Symbol_value
<size
>* psymval
,
858 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
860 This_insn::template rela
<32>(view
, 0, 0x0000007f, object
, psymval
, addend
);
863 // R_SPARC_6: (Symbol + Addend)
865 rela32_6(unsigned char* view
,
866 const Sized_relobj
<size
, big_endian
>* object
,
867 const Symbol_value
<size
>* psymval
,
868 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
870 This_insn::template rela
<32>(view
, 0, 0x0000003f, object
, psymval
, addend
);
873 // R_SPARC_5: (Symbol + Addend)
875 rela32_5(unsigned char* view
,
876 const Sized_relobj
<size
, big_endian
>* object
,
877 const Symbol_value
<size
>* psymval
,
878 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
880 This_insn::template rela
<32>(view
, 0, 0x0000001f, object
, psymval
, addend
);
883 // R_SPARC_TLS_LDO_HIX22: @dtpoff(Symbol + Addend) >> 10
885 ldo_hix22(unsigned char* view
,
886 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
887 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
889 This_insn::hi22(view
, value
, addend
);
892 // R_SPARC_TLS_LDO_LOX10: @dtpoff(Symbol + Addend) & 0x3ff
894 ldo_lox10(unsigned char* view
,
895 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
896 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
898 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
899 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
900 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
901 Valtype reloc
= (value
+ addend
);
906 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
909 // R_SPARC_TLS_LE_HIX22: (@tpoff(Symbol + Addend) ^ 0xffffffffffffffff) >> 10
911 hix22(unsigned char* view
,
912 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
913 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
915 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
916 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
917 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
918 Valtype reloc
= (value
+ addend
);
922 reloc
^= ~(Valtype
)0;
927 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
930 // R_SPARC_HIX22: ((Symbol + Addend) ^ 0xffffffffffffffff) >> 10
932 hix22(unsigned char* view
,
933 const Sized_relobj
<size
, big_endian
>* object
,
934 const Symbol_value
<size
>* psymval
,
935 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
937 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
938 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
939 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
940 Valtype reloc
= psymval
->value(object
, addend
);
944 reloc
^= ~(Valtype
)0;
949 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
953 // R_SPARC_TLS_LE_LOX10: (@tpoff(Symbol + Addend) & 0x3ff) | 0x1c00
955 lox10(unsigned char* view
,
956 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
957 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
959 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
960 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
961 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
962 Valtype reloc
= (value
+ addend
);
968 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
971 // R_SPARC_LOX10: ((Symbol + Addend) & 0x3ff) | 0x1c00
973 lox10(unsigned char* view
,
974 const Sized_relobj
<size
, big_endian
>* object
,
975 const Symbol_value
<size
>* psymval
,
976 typename
elfcpp::Elf_types
<size
>::Elf_Addr addend
)
978 typedef typename
elfcpp::Swap
<32, true>::Valtype Valtype
;
979 Valtype
* wv
= reinterpret_cast<Valtype
*>(view
);
980 Valtype val
= elfcpp::Swap
<32, true>::readval(wv
);
981 Valtype reloc
= psymval
->value(object
, addend
);
987 elfcpp::Swap
<32, true>::writeval(wv
, val
| reloc
);
991 // Get the GOT section, creating it if necessary.
993 template<int size
, bool big_endian
>
994 Output_data_got
<size
, big_endian
>*
995 Target_sparc
<size
, big_endian
>::got_section(Symbol_table
* symtab
,
998 if (this->got_
== NULL
)
1000 gold_assert(symtab
!= NULL
&& layout
!= NULL
);
1002 this->got_
= new Output_data_got
<size
, big_endian
>();
1004 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
1005 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
1008 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
1009 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
1011 0, 0, elfcpp::STT_OBJECT
,
1013 elfcpp::STV_HIDDEN
, 0,
1020 // Get the dynamic reloc section, creating it if necessary.
1022 template<int size
, bool big_endian
>
1023 typename Target_sparc
<size
, big_endian
>::Reloc_section
*
1024 Target_sparc
<size
, big_endian
>::rela_dyn_section(Layout
* layout
)
1026 if (this->rela_dyn_
== NULL
)
1028 gold_assert(layout
!= NULL
);
1029 this->rela_dyn_
= new Reloc_section();
1030 layout
->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA
,
1031 elfcpp::SHF_ALLOC
, this->rela_dyn_
);
1033 return this->rela_dyn_
;
1036 // A class to handle the PLT data.
1038 template<int size
, bool big_endian
>
1039 class Output_data_plt_sparc
: public Output_section_data
1042 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true,
1043 size
, big_endian
> Reloc_section
;
1045 Output_data_plt_sparc(Layout
*);
1047 // Add an entry to the PLT.
1048 void add_entry(Symbol
* gsym
);
1050 // Return the .rela.plt section data.
1051 const Reloc_section
* rel_plt() const
1057 void do_adjust_output_section(Output_section
* os
);
1060 // The size of an entry in the PLT.
1061 static const int base_plt_entry_size
= (size
== 32 ? 12 : 32);
1063 static const unsigned int plt_entries_per_block
= 160;
1064 static const unsigned int plt_insn_chunk_size
= 24;
1065 static const unsigned int plt_pointer_chunk_size
= 8;
1066 static const unsigned int plt_block_size
=
1067 (plt_entries_per_block
1068 * (plt_insn_chunk_size
+ plt_pointer_chunk_size
));
1070 // Set the final size.
1072 set_final_data_size()
1074 unsigned int full_count
= this->count_
+ 4;
1075 unsigned int extra
= (size
== 32 ? 4 : 0);
1077 if (size
== 32 || full_count
< 32768)
1078 this->set_data_size((full_count
* base_plt_entry_size
) + extra
);
1081 unsigned int ext_cnt
= full_count
- 32768;
1083 this->set_data_size((32768 * base_plt_entry_size
)
1085 * (plt_insn_chunk_size
1086 + plt_pointer_chunk_size
)));
1090 // Write out the PLT data.
1092 do_write(Output_file
*);
1094 // The reloc section.
1095 Reloc_section
* rel_
;
1096 // The number of PLT entries.
1097 unsigned int count_
;
1100 // Define the constants as required by C++ standard.
1102 template<int size
, bool big_endian
>
1103 const int Output_data_plt_sparc
<size
, big_endian
>::base_plt_entry_size
;
1105 template<int size
, bool big_endian
>
1107 Output_data_plt_sparc
<size
, big_endian
>::plt_entries_per_block
;
1109 template<int size
, bool big_endian
>
1110 const unsigned int Output_data_plt_sparc
<size
, big_endian
>::plt_insn_chunk_size
;
1112 template<int size
, bool big_endian
>
1114 Output_data_plt_sparc
<size
, big_endian
>::plt_pointer_chunk_size
;
1116 template<int size
, bool big_endian
>
1117 const unsigned int Output_data_plt_sparc
<size
, big_endian
>::plt_block_size
;
1119 // Create the PLT section. The ordinary .got section is an argument,
1120 // since we need to refer to the start.
1122 template<int size
, bool big_endian
>
1123 Output_data_plt_sparc
<size
, big_endian
>::Output_data_plt_sparc(Layout
* layout
)
1124 : Output_section_data(size
== 32 ? 4 : 8), count_(0)
1126 this->rel_
= new Reloc_section();
1127 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
1128 elfcpp::SHF_ALLOC
, this->rel_
);
1131 template<int size
, bool big_endian
>
1133 Output_data_plt_sparc
<size
, big_endian
>::do_adjust_output_section(Output_section
* os
)
1138 // Add an entry to the PLT.
1140 template<int size
, bool big_endian
>
1142 Output_data_plt_sparc
<size
, big_endian
>::add_entry(Symbol
* gsym
)
1144 gold_assert(!gsym
->has_plt_offset());
1146 unsigned int index
= this->count_
+ 4;
1147 section_offset_type plt_offset
;
1149 if (size
== 32 || index
< 32768)
1150 plt_offset
= index
* base_plt_entry_size
;
1153 unsigned int ext_index
= index
- 32768;
1155 plt_offset
= (32768 * base_plt_entry_size
)
1156 + ((ext_index
/ plt_entries_per_block
)
1158 + ((ext_index
% plt_entries_per_block
)
1159 * plt_insn_chunk_size
);
1162 gsym
->set_plt_offset(plt_offset
);
1166 // Every PLT entry needs a reloc.
1167 gsym
->set_needs_dynsym_entry();
1168 this->rel_
->add_global(gsym
, elfcpp::R_SPARC_JMP_SLOT
, this,
1171 // Note that we don't need to save the symbol. The contents of the
1172 // PLT are independent of which symbols are used. The symbols only
1173 // appear in the relocations.
1176 static const unsigned int sparc_nop
= 0x01000000;
1177 static const unsigned int sparc_sethi_g1
= 0x03000000;
1178 static const unsigned int sparc_branch_always
= 0x30800000;
1179 static const unsigned int sparc_branch_always_pt
= 0x30680000;
1180 static const unsigned int sparc_mov
= 0x80100000;
1181 static const unsigned int sparc_mov_g0_o0
= 0x90100000;
1182 static const unsigned int sparc_mov_o7_g5
= 0x8a10000f;
1183 static const unsigned int sparc_call_plus_8
= 0x40000002;
1184 static const unsigned int sparc_ldx_o7_imm_g1
= 0xc25be000;
1185 static const unsigned int sparc_jmpl_o7_g1_g1
= 0x83c3c001;
1186 static const unsigned int sparc_mov_g5_o7
= 0x9e100005;
1188 // Write out the PLT.
1190 template<int size
, bool big_endian
>
1192 Output_data_plt_sparc
<size
, big_endian
>::do_write(Output_file
* of
)
1194 const off_t offset
= this->offset();
1195 const section_size_type oview_size
=
1196 convert_to_section_size_type(this->data_size());
1197 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
1198 unsigned char* pov
= oview
;
1200 memset(pov
, 0, base_plt_entry_size
* 4);
1201 pov
+= base_plt_entry_size
* 4;
1203 unsigned int plt_offset
= base_plt_entry_size
* 4;
1204 const unsigned int count
= this->count_
;
1210 limit
= (count
> 32768 ? 32768 : count
);
1212 for (unsigned int i
= 0; i
< limit
; ++i
)
1214 elfcpp::Swap
<32, true>::writeval(pov
+ 0x00,
1215 sparc_sethi_g1
+ plt_offset
);
1216 elfcpp::Swap
<32, true>::writeval(pov
+ 0x04,
1217 sparc_branch_always_pt
+
1218 (((base_plt_entry_size
-
1219 (plt_offset
+ 4)) >> 2) &
1221 elfcpp::Swap
<32, true>::writeval(pov
+ 0x08, sparc_nop
);
1222 elfcpp::Swap
<32, true>::writeval(pov
+ 0x0c, sparc_nop
);
1223 elfcpp::Swap
<32, true>::writeval(pov
+ 0x10, sparc_nop
);
1224 elfcpp::Swap
<32, true>::writeval(pov
+ 0x14, sparc_nop
);
1225 elfcpp::Swap
<32, true>::writeval(pov
+ 0x18, sparc_nop
);
1226 elfcpp::Swap
<32, true>::writeval(pov
+ 0x1c, sparc_nop
);
1228 pov
+= base_plt_entry_size
;
1229 plt_offset
+= base_plt_entry_size
;
1234 unsigned int ext_cnt
= count
- 32768;
1235 unsigned int blks
= ext_cnt
/ plt_entries_per_block
;
1237 for (unsigned int i
= 0; i
< blks
; ++i
)
1239 unsigned int data_off
= (plt_entries_per_block
1240 * plt_insn_chunk_size
) - 4;
1242 for (unsigned int j
= 0; j
< plt_entries_per_block
; ++j
)
1244 elfcpp::Swap
<32, true>::writeval(pov
+ 0x00,
1246 elfcpp::Swap
<32, true>::writeval(pov
+ 0x04,
1248 elfcpp::Swap
<32, true>::writeval(pov
+ 0x08,
1250 elfcpp::Swap
<32, true>::writeval(pov
+ 0x0c,
1251 sparc_ldx_o7_imm_g1
+
1252 (data_off
& 0x1fff));
1253 elfcpp::Swap
<32, true>::writeval(pov
+ 0x10,
1254 sparc_jmpl_o7_g1_g1
);
1255 elfcpp::Swap
<32, true>::writeval(pov
+ 0x14,
1258 elfcpp::Swap
<64, big_endian
>::writeval(
1259 pov
+ 0x4 + data_off
,
1260 (elfcpp::Elf_Xword
) (oview
- (pov
+ 0x04)));
1262 pov
+= plt_insn_chunk_size
;
1267 unsigned int sub_blk_cnt
= ext_cnt
% plt_entries_per_block
;
1268 for (unsigned int i
= 0; i
< sub_blk_cnt
; ++i
)
1270 unsigned int data_off
= (sub_blk_cnt
1271 * plt_insn_chunk_size
) - 4;
1273 for (unsigned int j
= 0; j
< plt_entries_per_block
; ++j
)
1275 elfcpp::Swap
<32, true>::writeval(pov
+ 0x00,
1277 elfcpp::Swap
<32, true>::writeval(pov
+ 0x04,
1279 elfcpp::Swap
<32, true>::writeval(pov
+ 0x08,
1281 elfcpp::Swap
<32, true>::writeval(pov
+ 0x0c,
1282 sparc_ldx_o7_imm_g1
+
1283 (data_off
& 0x1fff));
1284 elfcpp::Swap
<32, true>::writeval(pov
+ 0x10,
1285 sparc_jmpl_o7_g1_g1
);
1286 elfcpp::Swap
<32, true>::writeval(pov
+ 0x14,
1289 elfcpp::Swap
<64, big_endian
>::writeval(
1290 pov
+ 0x4 + data_off
,
1291 (elfcpp::Elf_Xword
) (oview
- (pov
+ 0x04)));
1293 pov
+= plt_insn_chunk_size
;
1301 for (unsigned int i
= 0; i
< count
; ++i
)
1303 elfcpp::Swap
<32, true>::writeval(pov
+ 0x00,
1304 sparc_sethi_g1
+ plt_offset
);
1305 elfcpp::Swap
<32, true>::writeval(pov
+ 0x04,
1306 sparc_branch_always
+
1307 (((- (plt_offset
+ 4)) >> 2) &
1309 elfcpp::Swap
<32, true>::writeval(pov
+ 0x08, sparc_nop
);
1311 pov
+= base_plt_entry_size
;
1312 plt_offset
+= base_plt_entry_size
;
1315 elfcpp::Swap
<32, true>::writeval(pov
, sparc_nop
);
1319 gold_assert(static_cast<section_size_type
>(pov
- oview
) == oview_size
);
1321 of
->write_output_view(offset
, oview_size
, oview
);
1324 // Create a PLT entry for a global symbol.
1326 template<int size
, bool big_endian
>
1328 Target_sparc
<size
, big_endian
>::make_plt_entry(Symbol_table
* symtab
,
1332 if (gsym
->has_plt_offset())
1335 if (this->plt_
== NULL
)
1337 // Create the GOT sections first.
1338 this->got_section(symtab
, layout
);
1340 this->plt_
= new Output_data_plt_sparc
<size
, big_endian
>(layout
);
1341 layout
->add_output_section_data(".plt", elfcpp::SHT_PROGBITS
,
1343 | elfcpp::SHF_EXECINSTR
1344 | elfcpp::SHF_WRITE
),
1347 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
1348 symtab
->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL
,
1350 0, 0, elfcpp::STT_OBJECT
,
1352 elfcpp::STV_HIDDEN
, 0,
1356 this->plt_
->add_entry(gsym
);
1359 // Create a GOT entry for the TLS module index.
1361 template<int size
, bool big_endian
>
1363 Target_sparc
<size
, big_endian
>::got_mod_index_entry(Symbol_table
* symtab
,
1365 Sized_relobj
<size
, big_endian
>* object
)
1367 if (this->got_mod_index_offset_
== -1U)
1369 gold_assert(symtab
!= NULL
&& layout
!= NULL
&& object
!= NULL
);
1370 Reloc_section
* rela_dyn
= this->rela_dyn_section(layout
);
1371 Output_data_got
<size
, big_endian
>* got
;
1372 unsigned int got_offset
;
1374 got
= this->got_section(symtab
, layout
);
1375 got_offset
= got
->add_constant(0);
1376 rela_dyn
->add_local(object
, 0,
1378 elfcpp::R_SPARC_TLS_DTPMOD64
:
1379 elfcpp::R_SPARC_TLS_DTPMOD32
), got
,
1381 got
->add_constant(0);
1382 this->got_mod_index_offset_
= got_offset
;
1384 return this->got_mod_index_offset_
;
1387 // Optimize the TLS relocation type based on what we know about the
1388 // symbol. IS_FINAL is true if the final address of this symbol is
1389 // known at link time.
1391 static tls::Tls_optimization
1392 optimize_tls_reloc(bool is_final
, int r_type
)
1394 // If we are generating a shared library, then we can't do anything
1396 if (parameters
->options().shared())
1397 return tls::TLSOPT_NONE
;
1401 case elfcpp::R_SPARC_TLS_GD_HI22
: // Global-dynamic
1402 case elfcpp::R_SPARC_TLS_GD_LO10
:
1403 case elfcpp::R_SPARC_TLS_GD_ADD
:
1404 case elfcpp::R_SPARC_TLS_GD_CALL
:
1405 // These are General-Dynamic which permits fully general TLS
1406 // access. Since we know that we are generating an executable,
1407 // we can convert this to Initial-Exec. If we also know that
1408 // this is a local symbol, we can further switch to Local-Exec.
1410 return tls::TLSOPT_TO_LE
;
1411 return tls::TLSOPT_TO_IE
;
1413 case elfcpp::R_SPARC_TLS_LDM_HI22
: // Local-dynamic
1414 case elfcpp::R_SPARC_TLS_LDM_LO10
:
1415 case elfcpp::R_SPARC_TLS_LDM_ADD
:
1416 case elfcpp::R_SPARC_TLS_LDM_CALL
:
1417 // This is Local-Dynamic, which refers to a local symbol in the
1418 // dynamic TLS block. Since we know that we generating an
1419 // executable, we can switch to Local-Exec.
1420 return tls::TLSOPT_TO_LE
;
1422 case elfcpp::R_SPARC_TLS_LDO_HIX22
: // Alternate local-dynamic
1423 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
1424 case elfcpp::R_SPARC_TLS_LDO_ADD
:
1425 // Another type of Local-Dynamic relocation.
1426 return tls::TLSOPT_TO_LE
;
1428 case elfcpp::R_SPARC_TLS_IE_HI22
: // Initial-exec
1429 case elfcpp::R_SPARC_TLS_IE_LO10
:
1430 case elfcpp::R_SPARC_TLS_IE_LD
:
1431 case elfcpp::R_SPARC_TLS_IE_LDX
:
1432 // These are Initial-Exec relocs which get the thread offset
1433 // from the GOT. If we know that we are linking against the
1434 // local symbol, we can switch to Local-Exec, which links the
1435 // thread offset into the instruction.
1437 return tls::TLSOPT_TO_LE
;
1438 return tls::TLSOPT_NONE
;
1440 case elfcpp::R_SPARC_TLS_LE_HIX22
: // Local-exec
1441 case elfcpp::R_SPARC_TLS_LE_LOX10
:
1442 // When we already have Local-Exec, there is nothing further we
1444 return tls::TLSOPT_NONE
;
1451 // Generate a PLT entry slot for a call to __tls_get_addr
1452 template<int size
, bool big_endian
>
1454 Target_sparc
<size
, big_endian
>::Scan::generate_tls_call(Symbol_table
* symtab
,
1456 Target_sparc
<size
, big_endian
>* target
)
1458 Symbol
* gsym
= target
->tls_get_addr_sym(symtab
);
1460 target
->make_plt_entry(symtab
, layout
, gsym
);
1463 // Report an unsupported relocation against a local symbol.
1465 template<int size
, bool big_endian
>
1467 Target_sparc
<size
, big_endian
>::Scan::unsupported_reloc_local(
1468 Sized_relobj
<size
, big_endian
>* object
,
1469 unsigned int r_type
)
1471 gold_error(_("%s: unsupported reloc %u against local symbol"),
1472 object
->name().c_str(), r_type
);
1475 // We are about to emit a dynamic relocation of type R_TYPE. If the
1476 // dynamic linker does not support it, issue an error.
1478 template<int size
, bool big_endian
>
1480 Target_sparc
<size
, big_endian
>::Scan::check_non_pic(Relobj
* object
, unsigned int r_type
)
1482 gold_assert(r_type
!= elfcpp::R_SPARC_NONE
);
1488 // These are the relocation types supported by glibc for sparc 64-bit.
1489 case elfcpp::R_SPARC_RELATIVE
:
1490 case elfcpp::R_SPARC_COPY
:
1491 case elfcpp::R_SPARC_64
:
1492 case elfcpp::R_SPARC_GLOB_DAT
:
1493 case elfcpp::R_SPARC_JMP_SLOT
:
1494 case elfcpp::R_SPARC_TLS_DTPMOD64
:
1495 case elfcpp::R_SPARC_TLS_DTPOFF64
:
1496 case elfcpp::R_SPARC_TLS_TPOFF64
:
1497 case elfcpp::R_SPARC_TLS_LE_HIX22
:
1498 case elfcpp::R_SPARC_TLS_LE_LOX10
:
1499 case elfcpp::R_SPARC_8
:
1500 case elfcpp::R_SPARC_16
:
1501 case elfcpp::R_SPARC_DISP8
:
1502 case elfcpp::R_SPARC_DISP16
:
1503 case elfcpp::R_SPARC_DISP32
:
1504 case elfcpp::R_SPARC_WDISP30
:
1505 case elfcpp::R_SPARC_LO10
:
1506 case elfcpp::R_SPARC_HI22
:
1507 case elfcpp::R_SPARC_OLO10
:
1508 case elfcpp::R_SPARC_H44
:
1509 case elfcpp::R_SPARC_M44
:
1510 case elfcpp::R_SPARC_L44
:
1511 case elfcpp::R_SPARC_HH22
:
1512 case elfcpp::R_SPARC_HM10
:
1513 case elfcpp::R_SPARC_LM22
:
1514 case elfcpp::R_SPARC_UA16
:
1515 case elfcpp::R_SPARC_UA32
:
1516 case elfcpp::R_SPARC_UA64
:
1527 // These are the relocation types supported by glibc for sparc 32-bit.
1528 case elfcpp::R_SPARC_RELATIVE
:
1529 case elfcpp::R_SPARC_COPY
:
1530 case elfcpp::R_SPARC_GLOB_DAT
:
1531 case elfcpp::R_SPARC_32
:
1532 case elfcpp::R_SPARC_JMP_SLOT
:
1533 case elfcpp::R_SPARC_TLS_DTPMOD32
:
1534 case elfcpp::R_SPARC_TLS_DTPOFF32
:
1535 case elfcpp::R_SPARC_TLS_TPOFF32
:
1536 case elfcpp::R_SPARC_TLS_LE_HIX22
:
1537 case elfcpp::R_SPARC_TLS_LE_LOX10
:
1538 case elfcpp::R_SPARC_8
:
1539 case elfcpp::R_SPARC_16
:
1540 case elfcpp::R_SPARC_DISP8
:
1541 case elfcpp::R_SPARC_DISP16
:
1542 case elfcpp::R_SPARC_DISP32
:
1543 case elfcpp::R_SPARC_LO10
:
1544 case elfcpp::R_SPARC_WDISP30
:
1545 case elfcpp::R_SPARC_HI22
:
1546 case elfcpp::R_SPARC_UA16
:
1547 case elfcpp::R_SPARC_UA32
:
1555 // This prevents us from issuing more than one error per reloc
1556 // section. But we can still wind up issuing more than one
1557 // error per object file.
1558 if (this->issued_non_pic_error_
)
1560 object
->error(_("requires unsupported dynamic reloc; "
1561 "recompile with -fPIC"));
1562 this->issued_non_pic_error_
= true;
1566 // Scan a relocation for a local symbol.
1568 template<int size
, bool big_endian
>
1570 Target_sparc
<size
, big_endian
>::Scan::local(
1571 const General_options
&,
1572 Symbol_table
* symtab
,
1574 Target_sparc
<size
, big_endian
>* target
,
1575 Sized_relobj
<size
, big_endian
>* object
,
1576 unsigned int data_shndx
,
1577 Output_section
* output_section
,
1578 const elfcpp::Rela
<size
, big_endian
>& reloc
,
1579 unsigned int r_type
,
1580 const elfcpp::Sym
<size
, big_endian
>& lsym
)
1582 unsigned int orig_r_type
= r_type
;
1587 case elfcpp::R_SPARC_NONE
:
1588 case elfcpp::R_SPARC_REGISTER
:
1589 case elfcpp::R_SPARC_GNU_VTINHERIT
:
1590 case elfcpp::R_SPARC_GNU_VTENTRY
:
1593 case elfcpp::R_SPARC_64
:
1594 case elfcpp::R_SPARC_32
:
1595 // If building a shared library (or a position-independent
1596 // executable), we need to create a dynamic relocation for
1597 // this location. The relocation applied at link time will
1598 // apply the link-time value, so we flag the location with
1599 // an R_SPARC_RELATIVE relocation so the dynamic loader can
1600 // relocate it easily.
1601 if (parameters
->options().output_is_position_independent())
1603 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1604 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1605 rela_dyn
->add_local_relative(object
, r_sym
, elfcpp::R_SPARC_RELATIVE
,
1606 output_section
, data_shndx
,
1607 reloc
.get_r_offset(),
1608 reloc
.get_r_addend());
1612 case elfcpp::R_SPARC_HIX22
:
1613 case elfcpp::R_SPARC_LOX10
:
1614 case elfcpp::R_SPARC_H44
:
1615 case elfcpp::R_SPARC_M44
:
1616 case elfcpp::R_SPARC_L44
:
1617 case elfcpp::R_SPARC_HH22
:
1618 case elfcpp::R_SPARC_HM10
:
1619 case elfcpp::R_SPARC_LM22
:
1620 case elfcpp::R_SPARC_UA64
:
1621 case elfcpp::R_SPARC_UA32
:
1622 case elfcpp::R_SPARC_UA16
:
1623 case elfcpp::R_SPARC_HI22
:
1624 case elfcpp::R_SPARC_LO10
:
1625 case elfcpp::R_SPARC_OLO10
:
1626 case elfcpp::R_SPARC_16
:
1627 case elfcpp::R_SPARC_11
:
1628 case elfcpp::R_SPARC_10
:
1629 case elfcpp::R_SPARC_8
:
1630 case elfcpp::R_SPARC_7
:
1631 case elfcpp::R_SPARC_6
:
1632 case elfcpp::R_SPARC_5
:
1633 // If building a shared library (or a position-independent
1634 // executable), we need to create a dynamic relocation for
1636 if (parameters
->options().output_is_position_independent())
1638 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1640 check_non_pic(object
, r_type
);
1641 if (lsym
.get_st_type() != elfcpp::STT_SECTION
)
1643 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1644 rela_dyn
->add_local(object
, r_sym
, orig_r_type
, output_section
,
1645 data_shndx
, reloc
.get_r_offset(),
1646 reloc
.get_r_addend());
1650 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1651 gold_assert(lsym
.get_st_value() == 0);
1652 rela_dyn
->add_local_relative(object
, r_sym
, orig_r_type
,
1653 output_section
, data_shndx
,
1654 reloc
.get_r_offset(),
1655 reloc
.get_r_addend());
1660 case elfcpp::R_SPARC_WDISP30
:
1661 case elfcpp::R_SPARC_WDISP22
:
1662 case elfcpp::R_SPARC_WDISP19
:
1663 case elfcpp::R_SPARC_WDISP16
:
1664 case elfcpp::R_SPARC_DISP8
:
1665 case elfcpp::R_SPARC_DISP16
:
1666 case elfcpp::R_SPARC_DISP32
:
1667 case elfcpp::R_SPARC_DISP64
:
1668 case elfcpp::R_SPARC_PC10
:
1669 case elfcpp::R_SPARC_PC22
:
1672 case elfcpp::R_SPARC_GOT10
:
1673 case elfcpp::R_SPARC_GOT13
:
1674 case elfcpp::R_SPARC_GOT22
:
1676 // The symbol requires a GOT entry.
1677 Output_data_got
<size
, big_endian
>* got
;
1680 got
= target
->got_section(symtab
, layout
);
1681 r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1683 // If we are generating a shared object, we need to add a
1684 // dynamic relocation for this symbol's GOT entry.
1685 if (parameters
->options().output_is_position_independent())
1687 if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
))
1689 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1692 off
= got
->add_constant(0);
1693 object
->set_local_got_offset(r_sym
, GOT_TYPE_STANDARD
, off
);
1694 rela_dyn
->add_local_relative(object
, r_sym
,
1695 elfcpp::R_SPARC_RELATIVE
,
1700 got
->add_local(object
, r_sym
, GOT_TYPE_STANDARD
);
1704 // These are initial TLS relocs, which are expected when
1706 case elfcpp::R_SPARC_TLS_GD_HI22
: // Global-dynamic
1707 case elfcpp::R_SPARC_TLS_GD_LO10
:
1708 case elfcpp::R_SPARC_TLS_GD_ADD
:
1709 case elfcpp::R_SPARC_TLS_GD_CALL
:
1710 case elfcpp::R_SPARC_TLS_LDM_HI22
: // Local-dynamic
1711 case elfcpp::R_SPARC_TLS_LDM_LO10
:
1712 case elfcpp::R_SPARC_TLS_LDM_ADD
:
1713 case elfcpp::R_SPARC_TLS_LDM_CALL
:
1714 case elfcpp::R_SPARC_TLS_LDO_HIX22
: // Alternate local-dynamic
1715 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
1716 case elfcpp::R_SPARC_TLS_LDO_ADD
:
1717 case elfcpp::R_SPARC_TLS_IE_HI22
: // Initial-exec
1718 case elfcpp::R_SPARC_TLS_IE_LO10
:
1719 case elfcpp::R_SPARC_TLS_IE_LD
:
1720 case elfcpp::R_SPARC_TLS_IE_LDX
:
1721 case elfcpp::R_SPARC_TLS_LE_HIX22
: // Local-exec
1722 case elfcpp::R_SPARC_TLS_LE_LOX10
:
1724 bool output_is_shared
= parameters
->options().shared();
1725 const tls::Tls_optimization optimized_type
1726 = optimize_tls_reloc(!output_is_shared
, r_type
);
1729 case elfcpp::R_SPARC_TLS_GD_HI22
: // Global-dynamic
1730 case elfcpp::R_SPARC_TLS_GD_LO10
:
1731 case elfcpp::R_SPARC_TLS_GD_ADD
:
1732 case elfcpp::R_SPARC_TLS_GD_CALL
:
1733 if (optimized_type
== tls::TLSOPT_NONE
)
1735 // Create a pair of GOT entries for the module index and
1736 // dtv-relative offset.
1737 Output_data_got
<size
, big_endian
>* got
1738 = target
->got_section(symtab
, layout
);
1739 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1740 got
->add_local_pair_with_rela(object
, r_sym
,
1741 lsym
.get_st_shndx(),
1743 target
->rela_dyn_section(layout
),
1745 elfcpp::R_SPARC_TLS_DTPMOD64
:
1746 elfcpp::R_SPARC_TLS_DTPMOD32
), 0);
1747 if (r_type
== elfcpp::R_SPARC_TLS_GD_CALL
)
1748 generate_tls_call(symtab
, layout
, target
);
1750 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
1751 unsupported_reloc_local(object
, r_type
);
1754 case elfcpp::R_SPARC_TLS_LDM_HI22
: // Local-dynamic
1755 case elfcpp::R_SPARC_TLS_LDM_LO10
:
1756 case elfcpp::R_SPARC_TLS_LDM_ADD
:
1757 case elfcpp::R_SPARC_TLS_LDM_CALL
:
1758 if (optimized_type
== tls::TLSOPT_NONE
)
1760 // Create a GOT entry for the module index.
1761 target
->got_mod_index_entry(symtab
, layout
, object
);
1763 if (r_type
== elfcpp::R_SPARC_TLS_LDM_CALL
)
1764 generate_tls_call(symtab
, layout
, target
);
1766 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
1767 unsupported_reloc_local(object
, r_type
);
1770 case elfcpp::R_SPARC_TLS_LDO_HIX22
: // Alternate local-dynamic
1771 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
1772 case elfcpp::R_SPARC_TLS_LDO_ADD
:
1775 case elfcpp::R_SPARC_TLS_IE_HI22
: // Initial-exec
1776 case elfcpp::R_SPARC_TLS_IE_LO10
:
1777 case elfcpp::R_SPARC_TLS_IE_LD
:
1778 case elfcpp::R_SPARC_TLS_IE_LDX
:
1779 layout
->set_has_static_tls();
1780 if (optimized_type
== tls::TLSOPT_NONE
)
1782 // Create a GOT entry for the tp-relative offset.
1783 Output_data_got
<size
, big_endian
>* got
1784 = target
->got_section(symtab
, layout
);
1785 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1787 if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_TLS_OFFSET
))
1789 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1790 unsigned int off
= got
->add_constant(0);
1792 object
->set_local_got_offset(r_sym
, GOT_TYPE_TLS_OFFSET
,
1794 rela_dyn
->add_local_relative(object
, r_sym
,
1796 elfcpp::R_SPARC_TLS_TPOFF64
:
1797 elfcpp::R_SPARC_TLS_TPOFF32
),
1801 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
1802 unsupported_reloc_local(object
, r_type
);
1805 case elfcpp::R_SPARC_TLS_LE_HIX22
: // Local-exec
1806 case elfcpp::R_SPARC_TLS_LE_LOX10
:
1807 layout
->set_has_static_tls();
1808 if (output_is_shared
)
1810 // We need to create a dynamic relocation.
1811 gold_assert(lsym
.get_st_type() != elfcpp::STT_SECTION
);
1812 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
1813 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1814 rela_dyn
->add_local_relative(object
, r_sym
, r_type
,
1815 output_section
, data_shndx
,
1816 reloc
.get_r_offset(), 0);
1823 // These are relocations which should only be seen by the
1824 // dynamic linker, and should never be seen here.
1825 case elfcpp::R_SPARC_COPY
:
1826 case elfcpp::R_SPARC_GLOB_DAT
:
1827 case elfcpp::R_SPARC_JMP_SLOT
:
1828 case elfcpp::R_SPARC_RELATIVE
:
1829 case elfcpp::R_SPARC_TLS_DTPMOD64
:
1830 case elfcpp::R_SPARC_TLS_DTPMOD32
:
1831 case elfcpp::R_SPARC_TLS_DTPOFF64
:
1832 case elfcpp::R_SPARC_TLS_DTPOFF32
:
1833 case elfcpp::R_SPARC_TLS_TPOFF64
:
1834 case elfcpp::R_SPARC_TLS_TPOFF32
:
1835 gold_error(_("%s: unexpected reloc %u in object file"),
1836 object
->name().c_str(), r_type
);
1840 unsupported_reloc_local(object
, r_type
);
1845 // Report an unsupported relocation against a global symbol.
1847 template<int size
, bool big_endian
>
1849 Target_sparc
<size
, big_endian
>::Scan::unsupported_reloc_global(
1850 Sized_relobj
<size
, big_endian
>* object
,
1851 unsigned int r_type
,
1854 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1855 object
->name().c_str(), r_type
, gsym
->demangled_name().c_str());
1858 // Scan a relocation for a global symbol.
1860 template<int size
, bool big_endian
>
1862 Target_sparc
<size
, big_endian
>::Scan::global(
1863 const General_options
&,
1864 Symbol_table
* symtab
,
1866 Target_sparc
<size
, big_endian
>* target
,
1867 Sized_relobj
<size
, big_endian
>* object
,
1868 unsigned int data_shndx
,
1869 Output_section
* output_section
,
1870 const elfcpp::Rela
<size
, big_endian
>& reloc
,
1871 unsigned int r_type
,
1874 unsigned int orig_r_type
= r_type
;
1879 case elfcpp::R_SPARC_NONE
:
1880 case elfcpp::R_SPARC_REGISTER
:
1881 case elfcpp::R_SPARC_GNU_VTINHERIT
:
1882 case elfcpp::R_SPARC_GNU_VTENTRY
:
1885 case elfcpp::R_SPARC_PLT64
:
1886 case elfcpp::R_SPARC_PLT32
:
1887 case elfcpp::R_SPARC_HIPLT22
:
1888 case elfcpp::R_SPARC_LOPLT10
:
1889 case elfcpp::R_SPARC_PCPLT32
:
1890 case elfcpp::R_SPARC_PCPLT22
:
1891 case elfcpp::R_SPARC_PCPLT10
:
1892 case elfcpp::R_SPARC_WPLT30
:
1893 // If the symbol is fully resolved, this is just a PC32 reloc.
1894 // Otherwise we need a PLT entry.
1895 if (gsym
->final_value_is_known())
1897 // If building a shared library, we can also skip the PLT entry
1898 // if the symbol is defined in the output file and is protected
1900 if (gsym
->is_defined()
1901 && !gsym
->is_from_dynobj()
1902 && !gsym
->is_preemptible())
1904 target
->make_plt_entry(symtab
, layout
, gsym
);
1907 case elfcpp::R_SPARC_DISP8
:
1908 case elfcpp::R_SPARC_DISP16
:
1909 case elfcpp::R_SPARC_DISP32
:
1910 case elfcpp::R_SPARC_DISP64
:
1911 case elfcpp::R_SPARC_PC_HH22
:
1912 case elfcpp::R_SPARC_PC_HM10
:
1913 case elfcpp::R_SPARC_PC_LM22
:
1914 case elfcpp::R_SPARC_PC10
:
1915 case elfcpp::R_SPARC_PC22
:
1916 case elfcpp::R_SPARC_WDISP30
:
1917 case elfcpp::R_SPARC_WDISP22
:
1918 case elfcpp::R_SPARC_WDISP19
:
1919 case elfcpp::R_SPARC_WDISP16
:
1921 if (gsym
->needs_plt_entry())
1922 target
->make_plt_entry(symtab
, layout
, gsym
);
1923 // Make a dynamic relocation if necessary.
1924 int flags
= Symbol::NON_PIC_REF
;
1925 if (gsym
->type() == elfcpp::STT_FUNC
)
1926 flags
|= Symbol::FUNCTION_CALL
;
1927 if (gsym
->needs_dynamic_reloc(flags
))
1929 if (target
->may_need_copy_reloc(gsym
))
1931 target
->copy_reloc(symtab
, layout
, object
,
1932 data_shndx
, output_section
, gsym
,
1937 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1938 check_non_pic(object
, r_type
);
1939 rela_dyn
->add_global(gsym
, orig_r_type
, output_section
, object
,
1940 data_shndx
, reloc
.get_r_offset(),
1941 reloc
.get_r_addend());
1947 case elfcpp::R_SPARC_UA64
:
1948 case elfcpp::R_SPARC_64
:
1949 case elfcpp::R_SPARC_HIX22
:
1950 case elfcpp::R_SPARC_LOX10
:
1951 case elfcpp::R_SPARC_H44
:
1952 case elfcpp::R_SPARC_M44
:
1953 case elfcpp::R_SPARC_L44
:
1954 case elfcpp::R_SPARC_HH22
:
1955 case elfcpp::R_SPARC_HM10
:
1956 case elfcpp::R_SPARC_LM22
:
1957 case elfcpp::R_SPARC_HI22
:
1958 case elfcpp::R_SPARC_LO10
:
1959 case elfcpp::R_SPARC_OLO10
:
1960 case elfcpp::R_SPARC_UA32
:
1961 case elfcpp::R_SPARC_32
:
1962 case elfcpp::R_SPARC_UA16
:
1963 case elfcpp::R_SPARC_16
:
1964 case elfcpp::R_SPARC_11
:
1965 case elfcpp::R_SPARC_10
:
1966 case elfcpp::R_SPARC_8
:
1967 case elfcpp::R_SPARC_7
:
1968 case elfcpp::R_SPARC_6
:
1969 case elfcpp::R_SPARC_5
:
1971 // Make a PLT entry if necessary.
1972 if (gsym
->needs_plt_entry())
1974 target
->make_plt_entry(symtab
, layout
, gsym
);
1975 // Since this is not a PC-relative relocation, we may be
1976 // taking the address of a function. In that case we need to
1977 // set the entry in the dynamic symbol table to the address of
1979 if (gsym
->is_from_dynobj() && !parameters
->options().shared())
1980 gsym
->set_needs_dynsym_value();
1982 // Make a dynamic relocation if necessary.
1983 if (gsym
->needs_dynamic_reloc(Symbol::ABSOLUTE_REF
))
1985 if (target
->may_need_copy_reloc(gsym
))
1987 target
->copy_reloc(symtab
, layout
, object
,
1988 data_shndx
, output_section
, gsym
, reloc
);
1990 else if ((r_type
== elfcpp::R_SPARC_32
1991 || r_type
== elfcpp::R_SPARC_64
)
1992 && gsym
->can_use_relative_reloc(false))
1994 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
1995 rela_dyn
->add_global_relative(gsym
, elfcpp::R_SPARC_RELATIVE
,
1996 output_section
, object
,
1997 data_shndx
, reloc
.get_r_offset(),
1998 reloc
.get_r_addend());
2002 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2004 check_non_pic(object
, r_type
);
2005 if (gsym
->is_from_dynobj()
2006 || gsym
->is_undefined()
2007 || gsym
->is_preemptible())
2008 rela_dyn
->add_global(gsym
, orig_r_type
, output_section
,
2010 reloc
.get_r_offset(),
2011 reloc
.get_r_addend());
2013 rela_dyn
->add_global_relative(gsym
, orig_r_type
,
2014 output_section
, object
,
2016 reloc
.get_r_offset(),
2017 reloc
.get_r_addend());
2023 case elfcpp::R_SPARC_GOT10
:
2024 case elfcpp::R_SPARC_GOT13
:
2025 case elfcpp::R_SPARC_GOT22
:
2027 // The symbol requires a GOT entry.
2028 Output_data_got
<size
, big_endian
>* got
;
2030 got
= target
->got_section(symtab
, layout
);
2031 if (gsym
->final_value_is_known())
2032 got
->add_global(gsym
, GOT_TYPE_STANDARD
);
2035 // If this symbol is not fully resolved, we need to add a
2036 // dynamic relocation for it.
2037 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2038 if (gsym
->is_from_dynobj()
2039 || gsym
->is_undefined()
2040 || gsym
->is_preemptible())
2041 got
->add_global_with_rela(gsym
, GOT_TYPE_STANDARD
, rela_dyn
,
2042 elfcpp::R_SPARC_GLOB_DAT
);
2043 else if (!gsym
->has_got_offset(GOT_TYPE_STANDARD
))
2045 unsigned int off
= got
->add_constant(0);
2047 gsym
->set_got_offset(GOT_TYPE_STANDARD
, off
);
2048 rela_dyn
->add_global_relative(gsym
, elfcpp::R_SPARC_RELATIVE
,
2055 // These are initial tls relocs, which are expected when
2057 case elfcpp::R_SPARC_TLS_GD_HI22
: // Global-dynamic
2058 case elfcpp::R_SPARC_TLS_GD_LO10
:
2059 case elfcpp::R_SPARC_TLS_GD_ADD
:
2060 case elfcpp::R_SPARC_TLS_GD_CALL
:
2061 case elfcpp::R_SPARC_TLS_LDM_HI22
: // Local-dynamic
2062 case elfcpp::R_SPARC_TLS_LDM_LO10
:
2063 case elfcpp::R_SPARC_TLS_LDM_ADD
:
2064 case elfcpp::R_SPARC_TLS_LDM_CALL
:
2065 case elfcpp::R_SPARC_TLS_LDO_HIX22
: // Alternate local-dynamic
2066 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
2067 case elfcpp::R_SPARC_TLS_LDO_ADD
:
2068 case elfcpp::R_SPARC_TLS_LE_HIX22
:
2069 case elfcpp::R_SPARC_TLS_LE_LOX10
:
2070 case elfcpp::R_SPARC_TLS_IE_HI22
: // Initial-exec
2071 case elfcpp::R_SPARC_TLS_IE_LO10
:
2072 case elfcpp::R_SPARC_TLS_IE_LD
:
2073 case elfcpp::R_SPARC_TLS_IE_LDX
:
2075 const bool is_final
= gsym
->final_value_is_known();
2076 const tls::Tls_optimization optimized_type
2077 = optimize_tls_reloc(is_final
, r_type
);
2080 case elfcpp::R_SPARC_TLS_GD_HI22
: // Global-dynamic
2081 case elfcpp::R_SPARC_TLS_GD_LO10
:
2082 case elfcpp::R_SPARC_TLS_GD_ADD
:
2083 case elfcpp::R_SPARC_TLS_GD_CALL
:
2084 if (optimized_type
== tls::TLSOPT_NONE
)
2086 // Create a pair of GOT entries for the module index and
2087 // dtv-relative offset.
2088 Output_data_got
<size
, big_endian
>* got
2089 = target
->got_section(symtab
, layout
);
2090 got
->add_global_pair_with_rela(gsym
, GOT_TYPE_TLS_PAIR
,
2091 target
->rela_dyn_section(layout
),
2093 elfcpp::R_SPARC_TLS_DTPMOD64
:
2094 elfcpp::R_SPARC_TLS_DTPMOD32
),
2096 elfcpp::R_SPARC_TLS_DTPOFF64
:
2097 elfcpp::R_SPARC_TLS_DTPOFF32
));
2099 // Emit R_SPARC_WPLT30 against "__tls_get_addr"
2100 if (r_type
== elfcpp::R_SPARC_TLS_GD_CALL
)
2101 generate_tls_call(symtab
, layout
, target
);
2103 else if (optimized_type
== tls::TLSOPT_TO_IE
)
2105 // Create a GOT entry for the tp-relative offset.
2106 Output_data_got
<size
, big_endian
>* got
2107 = target
->got_section(symtab
, layout
);
2108 got
->add_global_with_rela(gsym
, GOT_TYPE_TLS_OFFSET
,
2109 target
->rela_dyn_section(layout
),
2111 elfcpp::R_SPARC_TLS_TPOFF64
:
2112 elfcpp::R_SPARC_TLS_TPOFF32
));
2114 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2115 unsupported_reloc_global(object
, r_type
, gsym
);
2118 case elfcpp::R_SPARC_TLS_LDM_HI22
: // Local-dynamic
2119 case elfcpp::R_SPARC_TLS_LDM_LO10
:
2120 case elfcpp::R_SPARC_TLS_LDM_ADD
:
2121 case elfcpp::R_SPARC_TLS_LDM_CALL
:
2122 if (optimized_type
== tls::TLSOPT_NONE
)
2124 // Create a GOT entry for the module index.
2125 target
->got_mod_index_entry(symtab
, layout
, object
);
2127 if (r_type
== elfcpp::R_SPARC_TLS_LDM_CALL
)
2128 generate_tls_call(symtab
, layout
, target
);
2130 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2131 unsupported_reloc_global(object
, r_type
, gsym
);
2134 case elfcpp::R_SPARC_TLS_LDO_HIX22
: // Alternate local-dynamic
2135 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
2136 case elfcpp::R_SPARC_TLS_LDO_ADD
:
2139 case elfcpp::R_SPARC_TLS_LE_HIX22
:
2140 case elfcpp::R_SPARC_TLS_LE_LOX10
:
2141 layout
->set_has_static_tls();
2142 if (parameters
->options().shared())
2144 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2145 rela_dyn
->add_global_relative(gsym
, orig_r_type
,
2146 output_section
, object
,
2147 data_shndx
, reloc
.get_r_offset(),
2152 case elfcpp::R_SPARC_TLS_IE_HI22
: // Initial-exec
2153 case elfcpp::R_SPARC_TLS_IE_LO10
:
2154 case elfcpp::R_SPARC_TLS_IE_LD
:
2155 case elfcpp::R_SPARC_TLS_IE_LDX
:
2156 layout
->set_has_static_tls();
2157 if (optimized_type
== tls::TLSOPT_NONE
)
2159 // Create a GOT entry for the tp-relative offset.
2160 Output_data_got
<size
, big_endian
>* got
2161 = target
->got_section(symtab
, layout
);
2162 got
->add_global_with_rela(gsym
, GOT_TYPE_TLS_OFFSET
,
2163 target
->rela_dyn_section(layout
),
2165 elfcpp::R_SPARC_TLS_TPOFF64
:
2166 elfcpp::R_SPARC_TLS_TPOFF32
));
2168 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2169 unsupported_reloc_global(object
, r_type
, gsym
);
2175 // These are relocations which should only be seen by the
2176 // dynamic linker, and should never be seen here.
2177 case elfcpp::R_SPARC_COPY
:
2178 case elfcpp::R_SPARC_GLOB_DAT
:
2179 case elfcpp::R_SPARC_JMP_SLOT
:
2180 case elfcpp::R_SPARC_RELATIVE
:
2181 case elfcpp::R_SPARC_TLS_DTPMOD64
:
2182 case elfcpp::R_SPARC_TLS_DTPMOD32
:
2183 case elfcpp::R_SPARC_TLS_DTPOFF64
:
2184 case elfcpp::R_SPARC_TLS_DTPOFF32
:
2185 case elfcpp::R_SPARC_TLS_TPOFF64
:
2186 case elfcpp::R_SPARC_TLS_TPOFF32
:
2187 gold_error(_("%s: unexpected reloc %u in object file"),
2188 object
->name().c_str(), r_type
);
2192 unsupported_reloc_global(object
, r_type
, gsym
);
2197 // Scan relocations for a section.
2199 template<int size
, bool big_endian
>
2201 Target_sparc
<size
, big_endian
>::scan_relocs(
2202 const General_options
& options
,
2203 Symbol_table
* symtab
,
2205 Sized_relobj
<size
, big_endian
>* object
,
2206 unsigned int data_shndx
,
2207 unsigned int sh_type
,
2208 const unsigned char* prelocs
,
2210 Output_section
* output_section
,
2211 bool needs_special_offset_handling
,
2212 size_t local_symbol_count
,
2213 const unsigned char* plocal_symbols
)
2215 typedef Target_sparc
<size
, big_endian
> Sparc
;
2216 typedef typename Target_sparc
<size
, big_endian
>::Scan Scan
;
2218 if (sh_type
== elfcpp::SHT_REL
)
2220 gold_error(_("%s: unsupported REL reloc section"),
2221 object
->name().c_str());
2225 gold::scan_relocs
<size
, big_endian
, Sparc
, elfcpp::SHT_RELA
, Scan
>(
2235 needs_special_offset_handling
,
2240 // Finalize the sections.
2242 template<int size
, bool big_endian
>
2244 Target_sparc
<size
, big_endian
>::do_finalize_sections(Layout
* layout
)
2246 // Fill in some more dynamic tags.
2247 Output_data_dynamic
* const odyn
= layout
->dynamic_data();
2250 if (this->plt_
!= NULL
)
2252 const Output_data
* od
= this->plt_
->rel_plt();
2253 odyn
->add_section_size(elfcpp::DT_PLTRELSZ
, od
);
2254 odyn
->add_section_address(elfcpp::DT_JMPREL
, od
);
2255 odyn
->add_constant(elfcpp::DT_PLTREL
, elfcpp::DT_RELA
);
2257 odyn
->add_section_address(elfcpp::DT_PLTGOT
, this->plt_
);
2260 if (this->rela_dyn_
!= NULL
)
2262 const Output_data
* od
= this->rela_dyn_
;
2263 odyn
->add_section_address(elfcpp::DT_RELA
, od
);
2264 odyn
->add_section_size(elfcpp::DT_RELASZ
, od
);
2265 odyn
->add_constant(elfcpp::DT_RELAENT
,
2266 elfcpp::Elf_sizes
<size
>::rela_size
);
2269 if (!parameters
->options().shared())
2271 // The value of the DT_DEBUG tag is filled in by the dynamic
2272 // linker at run time, and used by the debugger.
2273 odyn
->add_constant(elfcpp::DT_DEBUG
, 0);
2277 // Emit any relocs we saved in an attempt to avoid generating COPY
2279 if (this->copy_relocs_
.any_saved_relocs())
2280 this->copy_relocs_
.emit(this->rela_dyn_section(layout
));
2283 // Perform a relocation.
2285 template<int size
, bool big_endian
>
2287 Target_sparc
<size
, big_endian
>::Relocate::relocate(
2288 const Relocate_info
<size
, big_endian
>* relinfo
,
2289 Target_sparc
* target
,
2291 const elfcpp::Rela
<size
, big_endian
>& rela
,
2292 unsigned int r_type
,
2293 const Sized_symbol
<size
>* gsym
,
2294 const Symbol_value
<size
>* psymval
,
2295 unsigned char* view
,
2296 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
2297 section_size_type view_size
)
2301 if (this->ignore_gd_add_
)
2303 if (r_type
!= elfcpp::R_SPARC_TLS_GD_ADD
)
2304 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
2305 _("missing expected TLS relocation"));
2308 this->ignore_gd_add_
= false;
2313 typedef Sparc_relocate_functions
<size
, big_endian
> Reloc
;
2315 // Pick the value to use for symbols defined in shared objects.
2316 Symbol_value
<size
> symval
;
2318 && (gsym
->is_from_dynobj()
2319 || (parameters
->options().shared()
2320 && (gsym
->is_undefined() || gsym
->is_preemptible())))
2321 && gsym
->has_plt_offset())
2323 elfcpp::Elf_Xword value
;
2325 value
= target
->plt_section()->address() + gsym
->plt_offset();
2327 symval
.set_output_value(value
);
2332 const Sized_relobj
<size
, big_endian
>* object
= relinfo
->object
;
2333 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
2335 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT
2336 // pointer points to the beginning, not the end, of the table.
2337 // So we just use the plain offset.
2338 bool have_got_offset
= false;
2339 unsigned int got_offset
= 0;
2342 case elfcpp::R_SPARC_GOT10
:
2343 case elfcpp::R_SPARC_GOT13
:
2344 case elfcpp::R_SPARC_GOT22
:
2347 gold_assert(gsym
->has_got_offset(GOT_TYPE_STANDARD
));
2348 got_offset
= gsym
->got_offset(GOT_TYPE_STANDARD
);
2352 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
2353 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
));
2354 got_offset
= object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
);
2356 have_got_offset
= true;
2365 case elfcpp::R_SPARC_NONE
:
2366 case elfcpp::R_SPARC_REGISTER
:
2367 case elfcpp::R_SPARC_GNU_VTINHERIT
:
2368 case elfcpp::R_SPARC_GNU_VTENTRY
:
2371 case elfcpp::R_SPARC_8
:
2372 Relocate_functions
<size
, big_endian
>::rela8(view
, object
,
2376 case elfcpp::R_SPARC_16
:
2377 Relocate_functions
<size
, big_endian
>::rela16(view
, object
,
2381 case elfcpp::R_SPARC_32
:
2382 if (!parameters
->options().output_is_position_independent())
2383 Relocate_functions
<size
, big_endian
>::rela32(view
, object
,
2387 case elfcpp::R_SPARC_DISP8
:
2388 Reloc::disp8(view
, object
, psymval
, addend
, address
);
2391 case elfcpp::R_SPARC_DISP16
:
2392 Reloc::disp16(view
, object
, psymval
, addend
, address
);
2395 case elfcpp::R_SPARC_DISP32
:
2396 Reloc::disp32(view
, object
, psymval
, addend
, address
);
2399 case elfcpp::R_SPARC_DISP64
:
2400 Reloc::disp64(view
, object
, psymval
, addend
, address
);
2403 case elfcpp::R_SPARC_WDISP30
:
2404 case elfcpp::R_SPARC_WPLT30
:
2405 Reloc::wdisp30(view
, object
, psymval
, addend
, address
);
2408 case elfcpp::R_SPARC_WDISP22
:
2409 Reloc::wdisp22(view
, object
, psymval
, addend
, address
);
2412 case elfcpp::R_SPARC_WDISP19
:
2413 Reloc::wdisp19(view
, object
, psymval
, addend
, address
);
2416 case elfcpp::R_SPARC_WDISP16
:
2417 Reloc::wdisp16(view
, object
, psymval
, addend
, address
);
2420 case elfcpp::R_SPARC_HI22
:
2421 Reloc::hi22(view
, object
, psymval
, addend
);
2424 case elfcpp::R_SPARC_22
:
2425 Reloc::rela32_22(view
, object
, psymval
, addend
);
2428 case elfcpp::R_SPARC_13
:
2429 Reloc::rela32_13(view
, object
, psymval
, addend
);
2432 case elfcpp::R_SPARC_LO10
:
2433 Reloc::lo10(view
, object
, psymval
, addend
);
2436 case elfcpp::R_SPARC_GOT10
:
2437 Reloc::lo10(view
, got_offset
, addend
);
2440 case elfcpp::R_SPARC_GOT13
:
2441 Reloc::rela32_13(view
, got_offset
, addend
);
2444 case elfcpp::R_SPARC_GOT22
:
2445 Reloc::hi22(view
, got_offset
, addend
);
2448 case elfcpp::R_SPARC_PC10
:
2449 Reloc::pc10(view
, object
, psymval
, addend
, address
);
2452 case elfcpp::R_SPARC_PC22
:
2453 Reloc::pc22(view
, object
, psymval
, addend
, address
);
2456 case elfcpp::R_SPARC_TLS_DTPOFF32
:
2457 case elfcpp::R_SPARC_UA32
:
2458 Reloc::ua32(view
, object
, psymval
, addend
);
2461 case elfcpp::R_SPARC_PLT64
:
2462 Relocate_functions
<size
, big_endian
>::rela64(view
, object
,
2466 case elfcpp::R_SPARC_PLT32
:
2467 Relocate_functions
<size
, big_endian
>::rela32(view
, object
,
2471 case elfcpp::R_SPARC_HIPLT22
:
2472 Reloc::hi22(view
, object
, psymval
, addend
);
2475 case elfcpp::R_SPARC_LOPLT10
:
2476 Reloc::lo10(view
, object
, psymval
, addend
);
2479 case elfcpp::R_SPARC_PCPLT32
:
2480 Reloc::disp32(view
, object
, psymval
, addend
, address
);
2483 case elfcpp::R_SPARC_PCPLT22
:
2484 Reloc::pcplt22(view
, object
, psymval
, addend
, address
);
2487 case elfcpp::R_SPARC_PCPLT10
:
2488 Reloc::lo10(view
, object
, psymval
, addend
, address
);
2491 case elfcpp::R_SPARC_64
:
2492 if (!parameters
->options().output_is_position_independent())
2493 Relocate_functions
<size
, big_endian
>::rela64(view
, object
,
2497 case elfcpp::R_SPARC_OLO10
:
2499 unsigned int addend2
= rela
.get_r_info() & 0xffffffff;
2500 addend2
= ((addend2
>> 8) ^ 0x800000) - 0x800000;
2501 Reloc::olo10(view
, object
, psymval
, addend
, addend2
);
2505 case elfcpp::R_SPARC_HH22
:
2506 Reloc::hh22(view
, object
, psymval
, addend
);
2509 case elfcpp::R_SPARC_PC_HH22
:
2510 Reloc::pc_hh22(view
, object
, psymval
, addend
, address
);
2513 case elfcpp::R_SPARC_HM10
:
2514 Reloc::hm10(view
, object
, psymval
, addend
);
2517 case elfcpp::R_SPARC_PC_HM10
:
2518 Reloc::pc_hm10(view
, object
, psymval
, addend
, address
);
2521 case elfcpp::R_SPARC_LM22
:
2522 Reloc::hi22(view
, object
, psymval
, addend
);
2525 case elfcpp::R_SPARC_PC_LM22
:
2526 Reloc::pcplt22(view
, object
, psymval
, addend
, address
);
2529 case elfcpp::R_SPARC_11
:
2530 Reloc::rela32_11(view
, object
, psymval
, addend
);
2533 case elfcpp::R_SPARC_10
:
2534 Reloc::rela32_10(view
, object
, psymval
, addend
);
2537 case elfcpp::R_SPARC_7
:
2538 Reloc::rela32_7(view
, object
, psymval
, addend
);
2541 case elfcpp::R_SPARC_6
:
2542 Reloc::rela32_6(view
, object
, psymval
, addend
);
2545 case elfcpp::R_SPARC_5
:
2546 Reloc::rela32_5(view
, object
, psymval
, addend
);
2549 case elfcpp::R_SPARC_HIX22
:
2550 Reloc::hix22(view
, object
, psymval
, addend
);
2553 case elfcpp::R_SPARC_LOX10
:
2554 Reloc::lox10(view
, object
, psymval
, addend
);
2557 case elfcpp::R_SPARC_H44
:
2558 Reloc::h44(view
, object
, psymval
, addend
);
2561 case elfcpp::R_SPARC_M44
:
2562 Reloc::m44(view
, object
, psymval
, addend
);
2565 case elfcpp::R_SPARC_L44
:
2566 Reloc::l44(view
, object
, psymval
, addend
);
2569 case elfcpp::R_SPARC_TLS_DTPOFF64
:
2570 case elfcpp::R_SPARC_UA64
:
2571 Reloc::ua64(view
, object
, psymval
, addend
);
2574 case elfcpp::R_SPARC_UA16
:
2575 Reloc::ua16(view
, object
, psymval
, addend
);
2578 case elfcpp::R_SPARC_TLS_GD_HI22
:
2579 case elfcpp::R_SPARC_TLS_GD_LO10
:
2580 case elfcpp::R_SPARC_TLS_GD_ADD
:
2581 case elfcpp::R_SPARC_TLS_GD_CALL
:
2582 case elfcpp::R_SPARC_TLS_LDM_HI22
:
2583 case elfcpp::R_SPARC_TLS_LDM_LO10
:
2584 case elfcpp::R_SPARC_TLS_LDM_ADD
:
2585 case elfcpp::R_SPARC_TLS_LDM_CALL
:
2586 case elfcpp::R_SPARC_TLS_LDO_HIX22
:
2587 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
2588 case elfcpp::R_SPARC_TLS_LDO_ADD
:
2589 case elfcpp::R_SPARC_TLS_IE_HI22
:
2590 case elfcpp::R_SPARC_TLS_IE_LO10
:
2591 case elfcpp::R_SPARC_TLS_IE_LD
:
2592 case elfcpp::R_SPARC_TLS_IE_LDX
:
2593 case elfcpp::R_SPARC_TLS_LE_HIX22
:
2594 case elfcpp::R_SPARC_TLS_LE_LOX10
:
2595 this->relocate_tls(relinfo
, target
, relnum
, rela
,
2596 r_type
, gsym
, psymval
, view
,
2597 address
, view_size
);
2600 case elfcpp::R_SPARC_COPY
:
2601 case elfcpp::R_SPARC_GLOB_DAT
:
2602 case elfcpp::R_SPARC_JMP_SLOT
:
2603 case elfcpp::R_SPARC_RELATIVE
:
2604 // These are outstanding tls relocs, which are unexpected when
2606 case elfcpp::R_SPARC_TLS_DTPMOD64
:
2607 case elfcpp::R_SPARC_TLS_DTPMOD32
:
2608 case elfcpp::R_SPARC_TLS_TPOFF64
:
2609 case elfcpp::R_SPARC_TLS_TPOFF32
:
2610 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
2611 _("unexpected reloc %u in object file"),
2616 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
2617 _("unsupported reloc %u"),
2625 // Perform a TLS relocation.
2627 template<int size
, bool big_endian
>
2629 Target_sparc
<size
, big_endian
>::Relocate::relocate_tls(
2630 const Relocate_info
<size
, big_endian
>* relinfo
,
2631 Target_sparc
<size
, big_endian
>* target
,
2633 const elfcpp::Rela
<size
, big_endian
>& rela
,
2634 unsigned int r_type
,
2635 const Sized_symbol
<size
>* gsym
,
2636 const Symbol_value
<size
>* psymval
,
2637 unsigned char* view
,
2638 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
2641 Output_segment
* tls_segment
= relinfo
->layout
->tls_segment();
2642 typedef Sparc_relocate_functions
<size
, big_endian
> Reloc
;
2643 const Sized_relobj
<size
, big_endian
>* object
= relinfo
->object
;
2644 typedef typename
elfcpp::Swap
<32, true>::Valtype Insntype
;
2646 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
2647 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
= psymval
->value(object
, 0);
2649 const bool is_final
=
2651 ? !parameters
->options().output_is_position_independent()
2652 : gsym
->final_value_is_known());
2653 const tls::Tls_optimization optimized_type
2654 = optimize_tls_reloc(is_final
, r_type
);
2658 case elfcpp::R_SPARC_TLS_GD_HI22
:
2659 case elfcpp::R_SPARC_TLS_GD_LO10
:
2660 case elfcpp::R_SPARC_TLS_GD_ADD
:
2661 case elfcpp::R_SPARC_TLS_GD_CALL
:
2662 if (optimized_type
== tls::TLSOPT_TO_LE
)
2664 Insntype
* wv
= reinterpret_cast<Insntype
*>(view
);
2667 value
-= tls_segment
->memsz();
2671 case elfcpp::R_SPARC_TLS_GD_HI22
:
2672 // TLS_GD_HI22 --> TLS_LE_HIX22
2673 Reloc::hix22(view
, value
, addend
);
2676 case elfcpp::R_SPARC_TLS_GD_LO10
:
2677 // TLS_GD_LO10 --> TLS_LE_LOX10
2678 Reloc::lox10(view
, value
, addend
);
2681 case elfcpp::R_SPARC_TLS_GD_ADD
:
2682 // add %reg1, %reg2, %reg3 --> mov %g7, %reg2, %reg3
2683 val
= elfcpp::Swap
<32, true>::readval(wv
);
2684 val
= (val
& ~0x7c000) | 0x1c000;
2685 elfcpp::Swap
<32, true>::writeval(wv
, val
);
2687 case elfcpp::R_SPARC_TLS_GD_CALL
:
2688 // call __tls_get_addr --> nop
2689 elfcpp::Swap
<32, true>::writeval(wv
, sparc_nop
);
2696 unsigned int got_type
= (optimized_type
== tls::TLSOPT_TO_IE
2697 ? GOT_TYPE_TLS_OFFSET
2698 : GOT_TYPE_TLS_PAIR
);
2701 gold_assert(gsym
->has_got_offset(got_type
));
2702 value
= gsym
->got_offset(got_type
);
2706 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
2707 gold_assert(object
->local_has_got_offset(r_sym
, got_type
));
2708 value
= object
->local_got_offset(r_sym
, got_type
);
2710 if (optimized_type
== tls::TLSOPT_TO_IE
)
2712 Insntype
* wv
= reinterpret_cast<Insntype
*>(view
);
2717 case elfcpp::R_SPARC_TLS_GD_HI22
:
2718 // TLS_GD_HI22 --> TLS_IE_HI22
2719 Reloc::hi22(view
, value
, addend
);
2722 case elfcpp::R_SPARC_TLS_GD_LO10
:
2723 // TLS_GD_LO10 --> TLS_IE_LO10
2724 Reloc::lo10(view
, value
, addend
);
2727 case elfcpp::R_SPARC_TLS_GD_ADD
:
2728 // add %reg1, %reg2, %reg3 --> ld [%reg1 + %reg2], %reg3
2729 val
= elfcpp::Swap
<32, true>::readval(wv
);
2736 elfcpp::Swap
<32, true>::writeval(wv
, val
);
2739 case elfcpp::R_SPARC_TLS_GD_CALL
:
2740 // The compiler can put the TLS_GD_ADD instruction
2741 // into the delay slot of the call. If so, we need
2742 // to transpose the two instructions so that the
2743 // the new sequence works properly.
2745 // The test we use is if the instruction in the
2746 // delay slot is an add with destination register
2748 val
= elfcpp::Swap
<32, true>::readval(wv
+ 1);
2749 if ((val
& 0x81f80000) == 0x80000000
2750 && ((val
>> 25) & 0x1f) == 0x8)
2757 elfcpp::Swap
<32, true>::writeval(wv
, val
);
2760 this->ignore_gd_add_
= true;
2763 // call __tls_get_addr --> add %g7, %o0, %o0
2764 elfcpp::Swap
<32, true>::writeval(wv
, 0x9001c008);
2769 else if (optimized_type
== tls::TLSOPT_NONE
)
2773 case elfcpp::R_SPARC_TLS_GD_HI22
:
2774 Reloc::hi22(view
, value
, addend
);
2776 case elfcpp::R_SPARC_TLS_GD_LO10
:
2777 Reloc::lo10(view
, value
, addend
);
2779 case elfcpp::R_SPARC_TLS_GD_ADD
:
2781 case elfcpp::R_SPARC_TLS_GD_CALL
:
2783 Symbol_value
<size
> symval
;
2784 elfcpp::Elf_Xword value
;
2787 tsym
= target
->tls_get_addr_sym_
;
2789 value
= (target
->plt_section()->address() +
2790 tsym
->plt_offset());
2791 symval
.set_output_value(value
);
2792 Reloc::wdisp30(view
, object
, &symval
, addend
, address
);
2799 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
2800 _("unsupported reloc %u"),
2804 case elfcpp::R_SPARC_TLS_LDM_HI22
:
2805 case elfcpp::R_SPARC_TLS_LDM_LO10
:
2806 case elfcpp::R_SPARC_TLS_LDM_ADD
:
2807 case elfcpp::R_SPARC_TLS_LDM_CALL
:
2808 if (optimized_type
== tls::TLSOPT_TO_LE
)
2810 Insntype
* wv
= reinterpret_cast<Insntype
*>(view
);
2814 case elfcpp::R_SPARC_TLS_LDM_HI22
:
2815 case elfcpp::R_SPARC_TLS_LDM_LO10
:
2816 case elfcpp::R_SPARC_TLS_LDM_ADD
:
2817 elfcpp::Swap
<32, true>::writeval(wv
, sparc_nop
);
2820 case elfcpp::R_SPARC_TLS_LDM_CALL
:
2821 elfcpp::Swap
<32, true>::writeval(wv
, sparc_mov_g0_o0
);
2826 else if (optimized_type
== tls::TLSOPT_NONE
)
2828 // Relocate the field with the offset of the GOT entry for
2829 // the module index.
2830 unsigned int got_offset
;
2832 got_offset
= target
->got_mod_index_entry(NULL
, NULL
, NULL
);
2835 case elfcpp::R_SPARC_TLS_LDM_HI22
:
2836 Reloc::hi22(view
, got_offset
, addend
);
2838 case elfcpp::R_SPARC_TLS_LDM_LO10
:
2839 Reloc::lo10(view
, got_offset
, addend
);
2841 case elfcpp::R_SPARC_TLS_LDM_ADD
:
2843 case elfcpp::R_SPARC_TLS_LDM_CALL
:
2845 Symbol_value
<size
> symval
;
2846 elfcpp::Elf_Xword value
;
2849 tsym
= target
->tls_get_addr_sym_
;
2851 value
= (target
->plt_section()->address() +
2852 tsym
->plt_offset());
2853 symval
.set_output_value(value
);
2854 Reloc::wdisp30(view
, object
, &symval
, addend
, address
);
2860 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
2861 _("unsupported reloc %u"),
2865 // These relocs can appear in debugging sections, in which case
2866 // we won't see the TLS_LDM relocs. The local_dynamic_type
2867 // field tells us this.
2868 case elfcpp::R_SPARC_TLS_LDO_HIX22
:
2869 if (optimized_type
== tls::TLSOPT_TO_LE
)
2871 value
-= tls_segment
->memsz();
2872 Reloc::hix22(view
, value
, addend
);
2875 Reloc::ldo_hix22(view
, value
, addend
);
2877 case elfcpp::R_SPARC_TLS_LDO_LOX10
:
2878 if (optimized_type
== tls::TLSOPT_TO_LE
)
2880 value
-= tls_segment
->memsz();
2881 Reloc::lox10(view
, value
, addend
);
2884 Reloc::ldo_lox10(view
, value
, addend
);
2886 case elfcpp::R_SPARC_TLS_LDO_ADD
:
2887 if (optimized_type
== tls::TLSOPT_TO_LE
)
2889 Insntype
* wv
= reinterpret_cast<Insntype
*>(view
);
2892 // add %reg1, %reg2, %reg3 --> add %g7, %reg2, %reg3
2893 val
= elfcpp::Swap
<32, true>::readval(wv
);
2894 val
= (val
& ~0x7c000) | 0x1c000;
2895 elfcpp::Swap
<32, true>::writeval(wv
, val
);
2899 // When optimizing IE --> LE, the only relocation that is handled
2900 // differently is R_SPARC_TLS_IE_LD, it is rewritten from
2901 // 'ld{,x} [rs1 + rs2], rd' into 'mov rs2, rd' or simply a NOP is
2902 // rs2 and rd are the same.
2903 case elfcpp::R_SPARC_TLS_IE_LD
:
2904 case elfcpp::R_SPARC_TLS_IE_LDX
:
2905 if (optimized_type
== tls::TLSOPT_TO_LE
)
2907 Insntype
* wv
= reinterpret_cast<Insntype
*>(view
);
2908 Insntype val
= elfcpp::Swap
<32, true>::readval(wv
);
2909 Insntype rs2
= val
& 0x1f;
2910 Insntype rd
= (val
>> 25) & 0x1f;
2915 val
= sparc_mov
| (val
& 0x3e00001f);
2917 elfcpp::Swap
<32, true>::writeval(wv
, val
);
2921 case elfcpp::R_SPARC_TLS_IE_HI22
:
2922 case elfcpp::R_SPARC_TLS_IE_LO10
:
2923 if (optimized_type
== tls::TLSOPT_TO_LE
)
2925 value
-= tls_segment
->memsz();
2928 case elfcpp::R_SPARC_TLS_IE_HI22
:
2929 // IE_HI22 --> LE_HIX22
2930 Reloc::hix22(view
, value
, addend
);
2932 case elfcpp::R_SPARC_TLS_IE_LO10
:
2933 // IE_LO10 --> LE_LOX10
2934 Reloc::lox10(view
, value
, addend
);
2939 else if (optimized_type
== tls::TLSOPT_NONE
)
2941 // Relocate the field with the offset of the GOT entry for
2942 // the tp-relative offset of the symbol.
2945 gold_assert(gsym
->has_got_offset(GOT_TYPE_TLS_OFFSET
));
2946 value
= gsym
->got_offset(GOT_TYPE_TLS_OFFSET
);
2950 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
2951 gold_assert(object
->local_has_got_offset(r_sym
,
2952 GOT_TYPE_TLS_OFFSET
));
2953 value
= object
->local_got_offset(r_sym
,
2954 GOT_TYPE_TLS_OFFSET
);
2958 case elfcpp::R_SPARC_TLS_IE_HI22
:
2959 Reloc::hi22(view
, value
, addend
);
2961 case elfcpp::R_SPARC_TLS_IE_LO10
:
2962 Reloc::lo10(view
, value
, addend
);
2967 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
2968 _("unsupported reloc %u"),
2972 case elfcpp::R_SPARC_TLS_LE_HIX22
:
2973 // If we're creating a shared library, a dynamic relocation will
2974 // have been created for this location, so do not apply it now.
2975 if (!parameters
->options().shared())
2977 value
-= tls_segment
->memsz();
2978 Reloc::hix22(view
, value
, addend
);
2982 case elfcpp::R_SPARC_TLS_LE_LOX10
:
2983 // If we're creating a shared library, a dynamic relocation will
2984 // have been created for this location, so do not apply it now.
2985 if (!parameters
->options().shared())
2987 value
-= tls_segment
->memsz();
2988 Reloc::lox10(view
, value
, addend
);
2994 // Relocate section data.
2996 template<int size
, bool big_endian
>
2998 Target_sparc
<size
, big_endian
>::relocate_section(
2999 const Relocate_info
<size
, big_endian
>* relinfo
,
3000 unsigned int sh_type
,
3001 const unsigned char* prelocs
,
3003 Output_section
* output_section
,
3004 bool needs_special_offset_handling
,
3005 unsigned char* view
,
3006 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
3007 section_size_type view_size
)
3009 typedef Target_sparc
<size
, big_endian
> Sparc
;
3010 typedef typename Target_sparc
<size
, big_endian
>::Relocate Sparc_relocate
;
3012 gold_assert(sh_type
== elfcpp::SHT_RELA
);
3014 gold::relocate_section
<size
, big_endian
, Sparc
, elfcpp::SHT_RELA
,
3021 needs_special_offset_handling
,
3027 // Return the size of a relocation while scanning during a relocatable
3030 template<int size
, bool big_endian
>
3032 Target_sparc
<size
, big_endian
>::Relocatable_size_for_reloc::get_size_for_reloc(
3036 // We are always SHT_RELA, so we should never get here.
3041 // Scan the relocs during a relocatable link.
3043 template<int size
, bool big_endian
>
3045 Target_sparc
<size
, big_endian
>::scan_relocatable_relocs(
3046 const General_options
& options
,
3047 Symbol_table
* symtab
,
3049 Sized_relobj
<size
, big_endian
>* object
,
3050 unsigned int data_shndx
,
3051 unsigned int sh_type
,
3052 const unsigned char* prelocs
,
3054 Output_section
* output_section
,
3055 bool needs_special_offset_handling
,
3056 size_t local_symbol_count
,
3057 const unsigned char* plocal_symbols
,
3058 Relocatable_relocs
* rr
)
3060 gold_assert(sh_type
== elfcpp::SHT_RELA
);
3062 typedef gold::Default_scan_relocatable_relocs
<elfcpp::SHT_RELA
,
3063 Relocatable_size_for_reloc
> Scan_relocatable_relocs
;
3065 gold::scan_relocatable_relocs
<size
, big_endian
, elfcpp::SHT_RELA
,
3066 Scan_relocatable_relocs
>(
3075 needs_special_offset_handling
,
3081 // Relocate a section during a relocatable link.
3083 template<int size
, bool big_endian
>
3085 Target_sparc
<size
, big_endian
>::relocate_for_relocatable(
3086 const Relocate_info
<size
, big_endian
>* relinfo
,
3087 unsigned int sh_type
,
3088 const unsigned char* prelocs
,
3090 Output_section
* output_section
,
3091 off_t offset_in_output_section
,
3092 const Relocatable_relocs
* rr
,
3093 unsigned char* view
,
3094 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
3095 section_size_type view_size
,
3096 unsigned char* reloc_view
,
3097 section_size_type reloc_view_size
)
3099 gold_assert(sh_type
== elfcpp::SHT_RELA
);
3101 gold::relocate_for_relocatable
<size
, big_endian
, elfcpp::SHT_RELA
>(
3106 offset_in_output_section
,
3115 // Return the value to use for a dynamic which requires special
3116 // treatment. This is how we support equality comparisons of function
3117 // pointers across shared library boundaries, as described in the
3118 // processor specific ABI supplement.
3120 template<int size
, bool big_endian
>
3122 Target_sparc
<size
, big_endian
>::do_dynsym_value(const Symbol
* gsym
) const
3124 gold_assert(gsym
->is_from_dynobj() && gsym
->has_plt_offset());
3125 return this->plt_section()->address() + gsym
->plt_offset();
3128 // The selector for sparc object files.
3130 template<int size
, bool big_endian
>
3131 class Target_selector_sparc
: public Target_selector
3134 Target_selector_sparc()
3135 : Target_selector(elfcpp::EM_NONE
, size
, big_endian
,
3136 (size
== 64 ? "elf64-sparc" : "elf32-sparc"))
3139 Target
* instantiated_target_
;
3141 Target
* do_recognize(int machine
, int, int)
3146 if (machine
!= elfcpp::EM_SPARCV9
)
3151 if (machine
!= elfcpp::EM_SPARC
3152 && machine
!= elfcpp::EM_SPARC32PLUS
)
3160 return do_instantiate_target();
3163 Target
* do_instantiate_target()
3165 if (this->instantiated_target_
== NULL
)
3166 this->instantiated_target_
= new Target_sparc
<size
, big_endian
>();
3167 return this->instantiated_target_
;
3171 Target_selector_sparc
<32, true> target_selector_sparc32
;
3172 Target_selector_sparc
<64, true> target_selector_sparc64
;
3174 } // End anonymous namespace.