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