projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* configure.ac (FN_PTRS_IN_SO_WITHOUT_PIC): Add sparc64.
[deliverable/binutils-gdb.git] / gold / sparc.cc
CommitLineData
f5314dd5
DM		 1// sparc.cc -- sparc target support for gold.
2
3// Copyright 2008 Free Software Foundation, Inc.
4// Written by David S. Miller <davem@davemloft.net>.
5
6// This file is part of gold.
7
8// This program is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 3 of the License, or
11// (at your option) any later version.
12
13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21// MA 02110-1301, USA.
22
23#include "gold.h"
24
25#include <cstdlib>
26#include <cstdio>
27#include <cstring>
28
29#include "elfcpp.h"
30#include "parameters.h"
31#include "reloc.h"
32#include "sparc.h"
33#include "object.h"
34#include "symtab.h"
35#include "layout.h"
36#include "output.h"
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"
43
44namespace
45{
46
47using namespace gold;
48
49template<int size, bool big_endian>
50class Output_data_plt_sparc;
51
52template<int size, bool big_endian>
53class Target_sparc : public Sized_target<size, big_endian>
54{
55 public:
56 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian> Reloc_section;
57
58 Target_sparc()
59 : Sized_target<size, big_endian>(&sparc_info),
60 got_(NULL), plt_(NULL), rela_dyn_(NULL),
12c0daef
ILT		 61 copy_relocs_(elfcpp::R_SPARC_COPY), dynbss_(NULL),
62 got_mod_index_offset_(-1U), tls_get_addr_sym_(NULL)
f5314dd5
DM		 63 {
64 }
65
66 // Scan the relocations to look for symbol adjustments.
67 void
68 scan_relocs(const General_options& options,
69 Symbol_table* symtab,
70 Layout* layout,
71 Sized_relobj<size, big_endian>* object,
72 unsigned int data_shndx,
73 unsigned int sh_type,
74 const unsigned char* prelocs,
75 size_t reloc_count,
76 Output_section* output_section,
77 bool needs_special_offset_handling,
78 size_t local_symbol_count,
79 const unsigned char* plocal_symbols);
80 // Finalize the sections.
81 void
82 do_finalize_sections(Layout*);
83
84 // Return the value to use for a dynamic which requires special
85 // treatment.
86 uint64_t
87 do_dynsym_value(const Symbol*) const;
88
89 // Relocate a section.
90 void
91 relocate_section(const Relocate_info<size, big_endian>*,
92 unsigned int sh_type,
93 const unsigned char* prelocs,
94 size_t reloc_count,
95 Output_section* output_section,
96 bool needs_special_offset_handling,
97 unsigned char* view,
98 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
99 section_size_type view_size);
100
101 // Scan the relocs during a relocatable link.
102 void
103 scan_relocatable_relocs(const General_options& options,
104 Symbol_table* symtab,
105 Layout* layout,
106 Sized_relobj<size, big_endian>* object,
107 unsigned int data_shndx,
108 unsigned int sh_type,
109 const unsigned char* prelocs,
110 size_t reloc_count,
111 Output_section* output_section,
112 bool needs_special_offset_handling,
113 size_t local_symbol_count,
114 const unsigned char* plocal_symbols,
115 Relocatable_relocs*);
116
117 // Relocate a section during a relocatable link.
118 void
119 relocate_for_relocatable(const Relocate_info<size, big_endian>*,
120 unsigned int sh_type,
121 const unsigned char* prelocs,
122 size_t reloc_count,
123 Output_section* output_section,
124 off_t offset_in_output_section,
125 const Relocatable_relocs*,
126 unsigned char* view,
127 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
128 section_size_type view_size,
129 unsigned char* reloc_view,
130 section_size_type reloc_view_size);
131 // Return whether SYM is defined by the ABI.
132 bool
133 do_is_defined_by_abi(Symbol* sym) const
134 {
135 // XXX Really need to support this better...
136 if (sym->type() == elfcpp::STT_SPARC_REGISTER)
137 return 1;
138
139 return strcmp(sym->name(), "___tls_get_addr") == 0;
140 }
141
142 // Return the size of the GOT section.
143 section_size_type
144 got_size()
145 {
146 gold_assert(this->got_ != NULL);
147 return this->got_->data_size();
148 }
149
150 private:
151
152 // The class which scans relocations.
153 struct Scan
154 {
155 inline void
156 local(const General_options& options, Symbol_table* symtab,
157 Layout* layout, Target_sparc* target,
158 Sized_relobj<size, big_endian>* object,
159 unsigned int data_shndx,
160 Output_section* output_section,
161 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
162 const elfcpp::Sym<size, big_endian>& lsym);
163
164 inline void
165 global(const General_options& options, Symbol_table* symtab,
166 Layout* layout, Target_sparc* target,
167 Sized_relobj<size, big_endian>* object,
168 unsigned int data_shndx,
169 Output_section* output_section,
170 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
171 Symbol* gsym);
172
173 static void
174 unsupported_reloc_local(Sized_relobj<size, big_endian>*,
175 unsigned int r_type);
176
177 static void
178 unsupported_reloc_global(Sized_relobj<size, big_endian>*,
179 unsigned int r_type, Symbol*);
180
181 static void
182 generate_tls_call(Symbol_table* symtab, Layout* layout,
183 Target_sparc* target);
184 };
185
186 // The class which implements relocation.
187 class Relocate
188 {
189 public:
190 Relocate()
191 : ignore_gd_add_(false)
192 { }
193
194 ~Relocate()
195 {
196 if (this->ignore_gd_add_)
197 {
198 // FIXME: This needs to specify the location somehow.
199 gold_error(_("missing expected TLS relocation"));
200 }
201 }
202
203 // Do a relocation. Return false if the caller should not issue
204 // any warnings about this relocation.
205 inline bool
206 relocate(const Relocate_info<size, big_endian>*, Target_sparc*,
207 size_t relnum, const elfcpp::Rela<size, big_endian>&,
208 unsigned int r_type, const Sized_symbol<size>*,
209 const Symbol_value<size>*,
210 unsigned char*,
211 typename elfcpp::Elf_types<size>::Elf_Addr,
212 section_size_type);
213
214 private:
215 // Do a TLS relocation.
216 inline void
217 relocate_tls(const Relocate_info<size, big_endian>*, Target_sparc* target,
218 size_t relnum, const elfcpp::Rela<size, big_endian>&,
219 unsigned int r_type, const Sized_symbol<size>*,
220 const Symbol_value<size>*,
221 unsigned char*,
222 typename elfcpp::Elf_types<size>::Elf_Addr,
223 section_size_type);
224
225 // Ignore the next relocation which should be R_SPARC_TLS_GD_ADD
226 bool ignore_gd_add_;
227 };
228
229 // A class which returns the size required for a relocation type,
230 // used while scanning relocs during a relocatable link.
231 class Relocatable_size_for_reloc
232 {
233 public:
234 unsigned int
235 get_size_for_reloc(unsigned int, Relobj*);
236 };
237
238 // Get the GOT section, creating it if necessary.
239 Output_data_got<size, big_endian>*
240 got_section(Symbol_table*, Layout*);
241
242 // Create a PLT entry for a global symbol.
243 void
244 make_plt_entry(Symbol_table*, Layout*, Symbol*);
245
246 // Create a GOT entry for the TLS module index.
247 unsigned int
248 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
249 Sized_relobj<size, big_endian>* object);
250
251 // Return the gsym for "__tls_get_addr". Cache if not already
252 // cached.
253 Symbol*
254 tls_get_addr_sym(Symbol_table* symtab)
255 {
256 if (!this->tls_get_addr_sym_)
257 this->tls_get_addr_sym_ = symtab->lookup("__tls_get_addr", NULL);
258 gold_assert(this->tls_get_addr_sym_);
259 return this->tls_get_addr_sym_;
260 }
261
262 // Get the PLT section.
263 const Output_data_plt_sparc<size, big_endian>*
264 plt_section() const
265 {
266 gold_assert(this->plt_ != NULL);
267 return this->plt_;
268 }
269
270 // Get the dynamic reloc section, creating it if necessary.
271 Reloc_section*
272 rela_dyn_section(Layout*);
273
274 // Return true if the symbol may need a COPY relocation.
275 // References from an executable object to non-function symbols
276 // defined in a dynamic object may need a COPY relocation.
277 bool
278 may_need_copy_reloc(Symbol* gsym)
279 {
280 return (!parameters->options().shared()
281 && gsym->is_from_dynobj()
282 && gsym->type() != elfcpp::STT_FUNC);
283 }
284
285 // Copy a relocation against a global symbol.
286 void
12c0daef
ILT		 287 copy_reloc(Symbol_table* symtab, Layout* layout, Relobj* object,
288 unsigned int shndx, Output_section* output_section,
289 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
290 {
291 this->copy_relocs_.copy_reloc(symtab, layout,
292 symtab->get_sized_symbol<size>(sym),
293 object, shndx, output_section,
294 reloc, this->rela_dyn_section(layout));
295 }
f5314dd5
DM		 296
297 // Information about this specific target which we pass to the
298 // general Target structure.
299 static Target::Target_info sparc_info;
300
301 // The types of GOT entries needed for this platform.
302 enum Got_type
303 {
304 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
305 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset
306 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
307 };
308
309 // The GOT section.
310 Output_data_got<size, big_endian>* got_;
311 // The PLT section.
312 Output_data_plt_sparc<size, big_endian>* plt_;
313 // The dynamic reloc section.
314 Reloc_section* rela_dyn_;
315 // Relocs saved to avoid a COPY reloc.
12c0daef 316 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
f5314dd5
DM		 317 // Space for variables copied with a COPY reloc.
318 Output_data_space* dynbss_;
319 // Offset of the GOT entry for the TLS module index;
320 unsigned int got_mod_index_offset_;
321 // Cached pointer to __tls_get_addr symbol
322 Symbol* tls_get_addr_sym_;
323};
324
325template<>
326Target::Target_info Target_sparc<32, true>::sparc_info =
327{
328 32, // size
329 true, // is_big_endian
330 elfcpp::EM_SPARC, // machine_code
331 false, // has_make_symbol
332 false, // has_resolve
333 false, // has_code_fill
334 true, // is_default_stack_executable
335 '\0', // wrap_char
336 "/usr/lib/ld.so.1", // dynamic_linker
337 0x00010000, // default_text_segment_address
338 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
339 8 * 1024 // common_pagesize (overridable by -z common-page-size)
340};
341
342template<>
343Target::Target_info Target_sparc<64, true>::sparc_info =
344{
345 64, // size
346 true, // is_big_endian
347 elfcpp::EM_SPARCV9, // machine_code
348 false, // has_make_symbol
349 false, // has_resolve
350 false, // has_code_fill
351 true, // is_default_stack_executable
352 '\0', // wrap_char
353 "/usr/lib/sparcv9/ld.so.1", // dynamic_linker
354 0x100000, // default_text_segment_address
355 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
356 8 * 1024 // common_pagesize (overridable by -z common-page-size)
357};
358
359// We have to take care here, even when operating in little-endian
360// mode, sparc instructions are still big endian.
361template<int size, bool big_endian>
362class Sparc_relocate_functions
363{
364private:
365 // Do a simple relocation with the addend in the relocation.
366 template<int valsize>
367 static inline void
368 rela(unsigned char* view,
369 unsigned int right_shift,
370 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
371 typename elfcpp::Swap<size, big_endian>::Valtype value,
372 typename elfcpp::Swap<size, big_endian>::Valtype addend)
373 {
374 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
375 Valtype* wv = reinterpret_cast<Valtype*>(view);
376 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
377 Valtype reloc = ((value + addend) >> right_shift);
378
379 val &= ~dst_mask;
380 reloc &= dst_mask;
381
382 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
383 }
384
385 // Do a simple relocation using a symbol value with the addend in
386 // the relocation.
387 template<int valsize>
388 static inline void
389 rela(unsigned char* view,
390 unsigned int right_shift,
391 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
392 const Sized_relobj<size, big_endian>* object,
393 const Symbol_value<size>* psymval,
394 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
395 {
396 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
397 Valtype* wv = reinterpret_cast<Valtype*>(view);
398 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
399 Valtype reloc = (psymval->value(object, addend) >> right_shift);
400
401 val &= ~dst_mask;
402 reloc &= dst_mask;
403
404 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
405 }
406
407 // Do a simple relocation using a symbol value with the addend in
408 // the relocation, unaligned.
409 template<int valsize>
410 static inline void
411 rela_ua(unsigned char* view,
412 unsigned int right_shift, elfcpp::Elf_Xword dst_mask,
413 const Sized_relobj<size, big_endian>* object,
414 const Symbol_value<size>* psymval,
415 typename elfcpp::Swap<size, big_endian>::Valtype addend)
416 {
417 typedef typename elfcpp::Swap_unaligned<valsize,
418 big_endian>::Valtype Valtype;
419 unsigned char* wv = view;
420 Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv);
421 Valtype reloc = (psymval->value(object, addend) >> right_shift);
422
423 val &= ~dst_mask;
424 reloc &= dst_mask;
425
426 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, val | reloc);
427 }
428
429 // Do a simple PC relative relocation with a Symbol_value with the
430 // addend in the relocation.
431 template<int valsize>
432 static inline void
433 pcrela(unsigned char* view,
434 unsigned int right_shift,
435 typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask,
436 const Sized_relobj<size, big_endian>* object,
437 const Symbol_value<size>* psymval,
438 typename elfcpp::Swap<size, big_endian>::Valtype addend,
439 typename elfcpp::Elf_types<size>::Elf_Addr address)
440 {
441 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
442 Valtype* wv = reinterpret_cast<Valtype*>(view);
443 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
444 Valtype reloc = ((psymval->value(object, addend) - address)
445 >> right_shift);
446
447 val &= ~dst_mask;
448 reloc &= dst_mask;
449
450 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
451 }
452
453 template<int valsize>
454 static inline void
455 pcrela_unaligned(unsigned char* view,
456 const Sized_relobj<size, big_endian>* object,
457 const Symbol_value<size>* psymval,
458 typename elfcpp::Swap<size, big_endian>::Valtype addend,
459 typename elfcpp::Elf_types<size>::Elf_Addr address)
460 {
461 typedef typename elfcpp::Swap_unaligned<valsize,
462 big_endian>::Valtype Valtype;
463 unsigned char* wv = view;
464 Valtype reloc = (psymval->value(object, addend) - address);
465
466 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv, reloc);
467 }
468
469 typedef Sparc_relocate_functions<size, big_endian> This;
470 typedef Sparc_relocate_functions<size, true> This_insn;
471
472public:
473 // R_SPARC_WDISP30: (Symbol + Addend - Address) >> 2
474 static inline void
475 wdisp30(unsigned char* view,
476 const Sized_relobj<size, big_endian>* object,
477 const Symbol_value<size>* psymval,
478 typename elfcpp::Elf_types<size>::Elf_Addr addend,
479 typename elfcpp::Elf_types<size>::Elf_Addr address)
480 {
481 This_insn::template pcrela<32>(view, 2, 0x3fffffff, object,
482 psymval, addend, address);
483 }
484
485 // R_SPARC_WDISP22: (Symbol + Addend - Address) >> 2
486 static inline void
487 wdisp22(unsigned char* view,
488 const Sized_relobj<size, big_endian>* object,
489 const Symbol_value<size>* psymval,
490 typename elfcpp::Elf_types<size>::Elf_Addr addend,
491 typename elfcpp::Elf_types<size>::Elf_Addr address)
492 {
493 This_insn::template pcrela<32>(view, 2, 0x003fffff, object,
494 psymval, addend, address);
495 }
496
497 // R_SPARC_WDISP19: (Symbol + Addend - Address) >> 2
498 static inline void
499 wdisp19(unsigned char* view,
500 const Sized_relobj<size, big_endian>* object,
501 const Symbol_value<size>* psymval,
502 typename elfcpp::Elf_types<size>::Elf_Addr addend,
503 typename elfcpp::Elf_types<size>::Elf_Addr address)
504 {
505 This_insn::template pcrela<32>(view, 2, 0x0007ffff, object,
506 psymval, addend, address);
507 }
508
509 // R_SPARC_WDISP16: (Symbol + Addend - Address) >> 2
510 static inline void
511 wdisp16(unsigned char* view,
512 const Sized_relobj<size, big_endian>* object,
513 const Symbol_value<size>* psymval,
514 typename elfcpp::Elf_types<size>::Elf_Addr addend,
515 typename elfcpp::Elf_types<size>::Elf_Addr address)
516 {
517 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
518 Valtype* wv = reinterpret_cast<Valtype*>(view);
519 Valtype val = elfcpp::Swap<32, true>::readval(wv);
520 Valtype reloc = ((psymval->value(object, addend) - address)
521 >> 2);
522
523 // The relocation value is split between the low 14 bits,
524 // and bits 20-21.
525 val &= ~((0x3 << 20) | 0x3fff);
526 reloc = (((reloc & 0xc000) << (20 - 14))
527 | (reloc & 0x3ffff));
528
529 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
530 }
531
532 // R_SPARC_PC22: (Symbol + Addend - Address) >> 10
533 static inline void
534 pc22(unsigned char* view,
535 const Sized_relobj<size, big_endian>* object,
536 const Symbol_value<size>* psymval,
537 typename elfcpp::Elf_types<size>::Elf_Addr addend,
538 typename elfcpp::Elf_types<size>::Elf_Addr address)
539 {
540 This_insn::template pcrela<32>(view, 10, 0x003fffff, object,
541 psymval, addend, address);
542 }
543
544 // R_SPARC_PC10: (Symbol + Addend - Address) & 0x3ff
545 static inline void
546 pc10(unsigned char* view,
547 const Sized_relobj<size, big_endian>* object,
548 const Symbol_value<size>* psymval,
549 typename elfcpp::Elf_types<size>::Elf_Addr addend,
550 typename elfcpp::Elf_types<size>::Elf_Addr address)
551 {
552 This_insn::template pcrela<32>(view, 0, 0x000003ff, object,
553 psymval, addend, address);
554 }
555
556 // R_SPARC_HI22: (Symbol + Addend) >> 10
557 static inline void
558 hi22(unsigned char* view,
559 typename elfcpp::Elf_types<size>::Elf_Addr value,
560 typename elfcpp::Elf_types<size>::Elf_Addr addend)
561 {
562 This_insn::template rela<32>(view, 10, 0x003fffff, value, addend);
563 }
564
565 // R_SPARC_HI22: (Symbol + Addend) >> 10
566 static inline void
567 hi22(unsigned char* view,
568 const Sized_relobj<size, big_endian>* object,
569 const Symbol_value<size>* psymval,
570 typename elfcpp::Elf_types<size>::Elf_Addr addend)
571 {
572 This_insn::template rela<32>(view, 10, 0x003fffff, object, psymval, addend);
573 }
574
575 // R_SPARC_PCPLT22: (Symbol + Addend - Address) >> 10
576 static inline void
577 pcplt22(unsigned char* view,
578 const Sized_relobj<size, big_endian>* object,
579 const Symbol_value<size>* psymval,
580 typename elfcpp::Elf_types<size>::Elf_Addr addend,
581 typename elfcpp::Elf_types<size>::Elf_Addr address)
582 {
583 This_insn::template pcrela<32>(view, 10, 0x003fffff, object,
584 psymval, addend, address);
585 }
586
587 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
588 static inline void
589 lo10(unsigned char* view,
590 typename elfcpp::Elf_types<size>::Elf_Addr value,
591 typename elfcpp::Elf_types<size>::Elf_Addr addend)
592 {
593 This_insn::template rela<32>(view, 0, 0x000003ff, value, addend);
594 }
595
596 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
597 static inline void
598 lo10(unsigned char* view,
599 const Sized_relobj<size, big_endian>* object,
600 const Symbol_value<size>* psymval,
601 typename elfcpp::Elf_types<size>::Elf_Addr addend)
602 {
603 This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend);
604 }
605
606 // R_SPARC_LO10: (Symbol + Addend) & 0x3ff
607 static inline void
608 lo10(unsigned char* view,
609 const Sized_relobj<size, big_endian>* object,
610 const Symbol_value<size>* psymval,
611 typename elfcpp::Elf_types<size>::Elf_Addr addend,
612 typename elfcpp::Elf_types<size>::Elf_Addr address)
613 {
614 This_insn::template pcrela<32>(view, 0, 0x000003ff, object,
615 psymval, addend, address);
616 }
617
618 // R_SPARC_OLO10: ((Symbol + Addend) & 0x3ff) + Addend2
619 static inline void
620 olo10(unsigned char* view,
621 const Sized_relobj<size, big_endian>* object,
622 const Symbol_value<size>* psymval,
623 typename elfcpp::Elf_types<size>::Elf_Addr addend,
624 typename elfcpp::Elf_types<size>::Elf_Addr addend2)
625 {
626 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
627 Valtype* wv = reinterpret_cast<Valtype*>(view);
628 Valtype val = elfcpp::Swap<32, true>::readval(wv);
629 Valtype reloc = psymval->value(object, addend);
630
631 val &= ~0x1fff;
632 reloc &= 0x3ff;
633 reloc += addend2;
634 reloc &= 0x1fff;
635
636 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
637 }
638
639 // R_SPARC_22: (Symbol + Addend)
640 static inline void
641 rela32_22(unsigned char* view,
642 const Sized_relobj<size, big_endian>* object,
643 const Symbol_value<size>* psymval,
644 typename elfcpp::Elf_types<size>::Elf_Addr addend)
645 {
646 This_insn::template rela<32>(view, 0, 0x003fffff, object, psymval, addend);
647 }
648
649 // R_SPARC_13: (Symbol + Addend)
650 static inline void
651 rela32_13(unsigned char* view,
652 typename elfcpp::Elf_types<size>::Elf_Addr value,
653 typename elfcpp::Elf_types<size>::Elf_Addr addend)
654 {
655 This_insn::template rela<32>(view, 0, 0x00001fff, value, addend);
656 }
657
658 // R_SPARC_13: (Symbol + Addend)
659 static inline void
660 rela32_13(unsigned char* view,
661 const Sized_relobj<size, big_endian>* object,
662 const Symbol_value<size>* psymval,
663 typename elfcpp::Elf_types<size>::Elf_Addr addend)
664 {
665 This_insn::template rela<32>(view, 0, 0x00001fff, object, psymval, addend);
666 }
667
668 // R_SPARC_UA16: (Symbol + Addend)
669 static inline void
670 ua16(unsigned char* view,
671 const Sized_relobj<size, big_endian>* object,
672 const Symbol_value<size>* psymval,
673 typename elfcpp::Elf_types<size>::Elf_Addr addend)
674 {
675 This::template rela_ua<16>(view, 0, 0xffff, object, psymval, addend);
676 }
677
678 // R_SPARC_UA32: (Symbol + Addend)
679 static inline void
680 ua32(unsigned char* view,
681 const Sized_relobj<size, big_endian>* object,
682 const Symbol_value<size>* psymval,
683 typename elfcpp::Elf_types<size>::Elf_Addr addend)
684 {
685 This::template rela_ua<32>(view, 0, 0xffffffff, object, psymval, addend);
686 }
687
688 // R_SPARC_UA64: (Symbol + Addend)
689 static inline void
690 ua64(unsigned char* view,
691 const Sized_relobj<size, big_endian>* object,
692 const Symbol_value<size>* psymval,
693 typename elfcpp::Elf_types<size>::Elf_Addr addend)
694 {
695 This::template rela_ua<64>(view, 0, ~(elfcpp::Elf_Xword) 0,
696 object, psymval, addend);
697 }
698
699 // R_SPARC_DISP8: (Symbol + Addend - Address)
700 static inline void
701 disp8(unsigned char* view,
702 const Sized_relobj<size, big_endian>* object,
703 const Symbol_value<size>* psymval,
704 typename elfcpp::Elf_types<size>::Elf_Addr addend,
705 typename elfcpp::Elf_types<size>::Elf_Addr address)
706 {
707 This::template pcrela_unaligned<8>(view, object, psymval,
708 addend, address);
709 }
710
711 // R_SPARC_DISP16: (Symbol + Addend - Address)
712 static inline void
713 disp16(unsigned char* view,
714 const Sized_relobj<size, big_endian>* object,
715 const Symbol_value<size>* psymval,
716 typename elfcpp::Elf_types<size>::Elf_Addr addend,
717 typename elfcpp::Elf_types<size>::Elf_Addr address)
718 {
719 This::template pcrela_unaligned<16>(view, object, psymval,
720 addend, address);
721 }
722
723 // R_SPARC_DISP32: (Symbol + Addend - Address)
724 static inline void
725 disp32(unsigned char* view,
726 const Sized_relobj<size, big_endian>* object,
727 const Symbol_value<size>* psymval,
728 typename elfcpp::Elf_types<size>::Elf_Addr addend,
729 typename elfcpp::Elf_types<size>::Elf_Addr address)
730 {
731 This::template pcrela_unaligned<32>(view, object, psymval,
732 addend, address);
733 }
734
735 // R_SPARC_DISP64: (Symbol + Addend - Address)
736 static inline void
737 disp64(unsigned char* view,
738 const Sized_relobj<size, big_endian>* object,
739 const Symbol_value<size>* psymval,
740 elfcpp::Elf_Xword addend,
741 typename elfcpp::Elf_types<size>::Elf_Addr address)
742 {
743 This::template pcrela_unaligned<64>(view, object, psymval,
744 addend, address);
745 }
746
747 // R_SPARC_H44: (Symbol + Addend) >> 22
748 static inline void
749 h44(unsigned char* view,
750 const Sized_relobj<size, big_endian>* object,
751 const Symbol_value<size>* psymval,
752 typename elfcpp::Elf_types<size>::Elf_Addr addend)
753 {
754 This_insn::template rela<32>(view, 22, 0x003fffff, object, psymval, addend);
755 }
756
757 // R_SPARC_M44: ((Symbol + Addend) >> 12) & 0x3ff
758 static inline void
759 m44(unsigned char* view,
760 const Sized_relobj<size, big_endian>* object,
761 const Symbol_value<size>* psymval,
762 typename elfcpp::Elf_types<size>::Elf_Addr addend)
763 {
764 This_insn::template rela<32>(view, 12, 0x000003ff, object, psymval, addend);
765 }
766
767 // R_SPARC_L44: (Symbol + Addend) & 0xfff
768 static inline void
769 l44(unsigned char* view,
770 const Sized_relobj<size, big_endian>* object,
771 const Symbol_value<size>* psymval,
772 typename elfcpp::Elf_types<size>::Elf_Addr addend)
773 {
774 This_insn::template rela<32>(view, 0, 0x00000fff, object, psymval, addend);
775 }
776
777 // R_SPARC_HH22: (Symbol + Addend) >> 42
778 static inline void
779 hh22(unsigned char* view,
780 const Sized_relobj<size, big_endian>* object,
781 const Symbol_value<size>* psymval,
782 typename elfcpp::Elf_types<size>::Elf_Addr addend)
783 {
784 This_insn::template rela<32>(view, 42, 0x003fffff, object, psymval, addend);
785 }
786
787 // R_SPARC_PC_HH22: (Symbol + Addend - Address) >> 42
788 static inline void
789 pc_hh22(unsigned char* view,
790 const Sized_relobj<size, big_endian>* object,
791 const Symbol_value<size>* psymval,
792 typename elfcpp::Elf_types<size>::Elf_Addr addend,
793 typename elfcpp::Elf_types<size>::Elf_Addr address)
794 {
795 This_insn::template pcrela<32>(view, 42, 0x003fffff, object,
796 psymval, addend, address);
797 }
798
799 // R_SPARC_HM10: ((Symbol + Addend) >> 32) & 0x3ff
800 static inline void
801 hm10(unsigned char* view,
802 const Sized_relobj<size, big_endian>* object,
803 const Symbol_value<size>* psymval,
804 typename elfcpp::Elf_types<size>::Elf_Addr addend)
805 {
806 This_insn::template rela<32>(view, 32, 0x000003ff, object, psymval, addend);
807 }
808
809 // R_SPARC_PC_HM10: ((Symbol + Addend - Address) >> 32) & 0x3ff
810 static inline void
811 pc_hm10(unsigned char* view,
812 const Sized_relobj<size, big_endian>* object,
813 const Symbol_value<size>* psymval,
814 typename elfcpp::Elf_types<size>::Elf_Addr addend,
815 typename elfcpp::Elf_types<size>::Elf_Addr address)
816 {
817 This_insn::template pcrela<32>(view, 32, 0x000003ff, object,
818 psymval, addend, address);
819 }
820
821 // R_SPARC_11: (Symbol + Addend)
822 static inline void
823 rela32_11(unsigned char* view,
824 const Sized_relobj<size, big_endian>* object,
825 const Symbol_value<size>* psymval,
826 typename elfcpp::Elf_types<size>::Elf_Addr addend)
827 {
828 This_insn::template rela<32>(view, 0, 0x000007ff, object, psymval, addend);
829 }
830
831 // R_SPARC_10: (Symbol + Addend)
832 static inline void
833 rela32_10(unsigned char* view,
834 const Sized_relobj<size, big_endian>* object,
835 const Symbol_value<size>* psymval,
836 typename elfcpp::Elf_types<size>::Elf_Addr addend)
837 {
838 This_insn::template rela<32>(view, 0, 0x000003ff, object, psymval, addend);
839 }
840
841 // R_SPARC_7: (Symbol + Addend)
842 static inline void
843 rela32_7(unsigned char* view,
844 const Sized_relobj<size, big_endian>* object,
845 const Symbol_value<size>* psymval,
846 typename elfcpp::Elf_types<size>::Elf_Addr addend)
847 {
848 This_insn::template rela<32>(view, 0, 0x0000007f, object, psymval, addend);
849 }
850
851 // R_SPARC_6: (Symbol + Addend)
852 static inline void
853 rela32_6(unsigned char* view,
854 const Sized_relobj<size, big_endian>* object,
855 const Symbol_value<size>* psymval,
856 typename elfcpp::Elf_types<size>::Elf_Addr addend)
857 {
858 This_insn::template rela<32>(view, 0, 0x0000003f, object, psymval, addend);
859 }
860
861 // R_SPARC_5: (Symbol + Addend)
862 static inline void
863 rela32_5(unsigned char* view,
864 const Sized_relobj<size, big_endian>* object,
865 const Symbol_value<size>* psymval,
866 typename elfcpp::Elf_types<size>::Elf_Addr addend)
867 {
868 This_insn::template rela<32>(view, 0, 0x0000001f, object, psymval, addend);
869 }
870
871 // R_SPARC_TLS_LDO_HIX22: @dtpoff(Symbol + Addend) >> 10
872 static inline void
873 ldo_hix22(unsigned char* view,
874 typename elfcpp::Elf_types<size>::Elf_Addr value,
875 typename elfcpp::Elf_types<size>::Elf_Addr addend)
876 {
877 This_insn::hi22(view, value, addend);
878 }
879
880 // R_SPARC_TLS_LDO_LOX10: @dtpoff(Symbol + Addend) & 0x3ff
881 static inline void
882 ldo_lox10(unsigned char* view,
883 typename elfcpp::Elf_types<size>::Elf_Addr value,
884 typename elfcpp::Elf_types<size>::Elf_Addr addend)
885 {
886 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
887 Valtype* wv = reinterpret_cast<Valtype*>(view);
888 Valtype val = elfcpp::Swap<32, true>::readval(wv);
889 Valtype reloc = (value + addend);
890
891 val &= ~0x1fff;
892 reloc &= 0x3ff;
893
894 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
895 }
896
897 // R_SPARC_TLS_LE_HIX22: (@tpoff(Symbol + Addend) ^ 0xffffffffffffffff) >> 10
898 static inline void
899 hix22(unsigned char* view,
900 typename elfcpp::Elf_types<size>::Elf_Addr value,
901 typename elfcpp::Elf_types<size>::Elf_Addr addend)
902 {
903 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
904 Valtype* wv = reinterpret_cast<Valtype*>(view);
905 Valtype val = elfcpp::Swap<32, true>::readval(wv);
906 Valtype reloc = (value + addend);
907
908 val &= ~0x3fffff;
909
910 reloc ^= ~(Valtype)0;
911 reloc >>= 10;
912
913 reloc &= 0x3fffff;
914
915 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
916 }
917
918 // R_SPARC_HIX22: ((Symbol + Addend) ^ 0xffffffffffffffff) >> 10
919 static inline void
920 hix22(unsigned char* view,
921 const Sized_relobj<size, big_endian>* object,
922 const Symbol_value<size>* psymval,
923 typename elfcpp::Elf_types<size>::Elf_Addr addend)
924 {
925 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
926 Valtype* wv = reinterpret_cast<Valtype*>(view);
927 Valtype val = elfcpp::Swap<32, true>::readval(wv);
928 Valtype reloc = psymval->value(object, addend);
929
930 val &= ~0x3fffff;
931
932 reloc ^= ~(Valtype)0;
933 reloc >>= 10;
934
935 reloc &= 0x3fffff;
936
937 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
938 }
939
940
941 // R_SPARC_TLS_LE_LOX10: (@tpoff(Symbol + Addend) & 0x3ff) | 0x1c00
942 static inline void
943 lox10(unsigned char* view,
944 typename elfcpp::Elf_types<size>::Elf_Addr value,
945 typename elfcpp::Elf_types<size>::Elf_Addr addend)
946 {
947 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
948 Valtype* wv = reinterpret_cast<Valtype*>(view);
949 Valtype val = elfcpp::Swap<32, true>::readval(wv);
950 Valtype reloc = (value + addend);
951
952 val &= ~0x1fff;
953 reloc &= 0x3ff;
954 reloc |= 0x1c00;
955
956 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
957 }
958
959 // R_SPARC_LOX10: ((Symbol + Addend) & 0x3ff) | 0x1c00
960 static inline void
961 lox10(unsigned char* view,
962 const Sized_relobj<size, big_endian>* object,
963 const Symbol_value<size>* psymval,
964 typename elfcpp::Elf_types<size>::Elf_Addr addend)
965 {
966 typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
967 Valtype* wv = reinterpret_cast<Valtype*>(view);
968 Valtype val = elfcpp::Swap<32, true>::readval(wv);
969 Valtype reloc = psymval->value(object, addend);
970
971 val &= ~0x1fff;
972 reloc &= 0x3ff;
973 reloc |= 0x1c00;
974
975 elfcpp::Swap<32, true>::writeval(wv, val | reloc);
976 }
977};
978
979// Get the GOT section, creating it if necessary.
980
981template<int size, bool big_endian>
982Output_data_got<size, big_endian>*
983Target_sparc<size, big_endian>::got_section(Symbol_table* symtab,
984 Layout* layout)
985{
986 if (this->got_ == NULL)
987 {
988 gold_assert(symtab != NULL && layout != NULL);
989
990 this->got_ = new Output_data_got<size, big_endian>();
991
992 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
993 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
994 this->got_);
995
996 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
997 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
998 this->got_,
999 0, 0, elfcpp::STT_OBJECT,
1000 elfcpp::STB_LOCAL,
1001 elfcpp::STV_HIDDEN, 0,
1002 false, false);
1003 }
1004
1005 return this->got_;
1006}
1007
1008// Get the dynamic reloc section, creating it if necessary.
1009
1010template<int size, bool big_endian>
1011typename Target_sparc<size, big_endian>::Reloc_section*
1012Target_sparc<size, big_endian>::rela_dyn_section(Layout* layout)
1013{
1014 if (this->rela_dyn_ == NULL)
1015 {
1016 gold_assert(layout != NULL);
1017 this->rela_dyn_ = new Reloc_section();
1018 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1019 elfcpp::SHF_ALLOC, this->rela_dyn_);
1020 }
1021 return this->rela_dyn_;
1022}
1023
1024// A class to handle the PLT data.
1025
1026template<int size, bool big_endian>
1027class Output_data_plt_sparc : public Output_section_data
1028{
1029 public:
1030 typedef Output_data_reloc<elfcpp::SHT_RELA, true,
1031 size, big_endian> Reloc_section;
1032
1033 Output_data_plt_sparc(Layout*);
1034
1035 // Add an entry to the PLT.
1036 void add_entry(Symbol* gsym);
1037
1038 // Return the .rela.plt section data.
1039 const Reloc_section* rel_plt() const
1040 {
1041 return this->rel_;
1042 }
1043
1044 protected:
1045 void do_adjust_output_section(Output_section* os);
1046
1047 private:
1048 // The size of an entry in the PLT.
1049 static const int base_plt_entry_size = (size == 32 ? 12 : 32);
1050
1051 static const unsigned int plt_entries_per_block = 160;
1052 static const unsigned int plt_insn_chunk_size = 24;
1053 static const unsigned int plt_pointer_chunk_size = 8;
1054 static const unsigned int plt_block_size =
1055 (plt_entries_per_block
1056 * (plt_insn_chunk_size + plt_pointer_chunk_size));
1057
1058 // Set the final size.
1059 void
1060 set_final_data_size()
1061 {
1062 unsigned int full_count = this->count_ + 4;
1063 unsigned int extra = (size == 32 ? 4 : 0);
1064
1065 if (size == 32 || full_count < 32768)
1066 this->set_data_size((full_count * base_plt_entry_size) + extra);
1067 else
1068 {
1069 unsigned int ext_cnt = full_count - 32768;
1070
1071 this->set_data_size((32768 * base_plt_entry_size)
1072 + (ext_cnt
1073 * (plt_insn_chunk_size
1074 + plt_pointer_chunk_size)));
1075 }
1076 }
1077
1078 // Write out the PLT data.
1079 void
1080 do_write(Output_file*);
1081
1082 // The reloc section.
1083 Reloc_section* rel_;
1084 // The number of PLT entries.
1085 unsigned int count_;
1086};
1087
4f2a9edd
ILT		 1088// Define the constants as required by C++ standard.
1089
1090template<int size, bool big_endian>
1091const int Output_data_plt_sparc<size, big_endian>::base_plt_entry_size;
1092
1093template<int size, bool big_endian>
1094const unsigned int
1095Output_data_plt_sparc<size, big_endian>::plt_entries_per_block;
1096
1097template<int size, bool big_endian>
1098const unsigned int Output_data_plt_sparc<size, big_endian>::plt_insn_chunk_size;
1099
1100template<int size, bool big_endian>
1101const unsigned int
1102Output_data_plt_sparc<size, big_endian>::plt_pointer_chunk_size;
1103
1104template<int size, bool big_endian>
1105const unsigned int Output_data_plt_sparc<size, big_endian>::plt_block_size;
1106
f5314dd5
DM		 1107// Create the PLT section. The ordinary .got section is an argument,
1108// since we need to refer to the start.
1109
1110template<int size, bool big_endian>
1111Output_data_plt_sparc<size, big_endian>::Output_data_plt_sparc(Layout* layout)
1112 : Output_section_data(size == 32 ? 4 : 8), count_(0)
1113{
1114 this->rel_ = new Reloc_section();
1115 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1116 elfcpp::SHF_ALLOC, this->rel_);
1117}
1118
1119template<int size, bool big_endian>
1120void
1121Output_data_plt_sparc<size, big_endian>::do_adjust_output_section(Output_section* os)
1122{
1123 os->set_entsize(0);
1124}
1125
1126// Add an entry to the PLT.
1127
1128template<int size, bool big_endian>
1129void
1130Output_data_plt_sparc<size, big_endian>::add_entry(Symbol* gsym)
1131{
1132 gold_assert(!gsym->has_plt_offset());
1133
1134 unsigned int index = this->count_ + 4;
1135 section_offset_type plt_offset;
1136
1137 if (size == 32 || index < 32768)
1138 plt_offset = index * base_plt_entry_size;
1139 else
1140 {
1141 unsigned int ext_index = index - 32768;
1142
1143 plt_offset = (32768 * base_plt_entry_size)
1144 + ((ext_index / plt_entries_per_block)
1145 * plt_block_size)
1146 + ((ext_index % plt_entries_per_block)
1147 * plt_insn_chunk_size);
1148 }
1149
1150 gsym->set_plt_offset(plt_offset);
1151
1152 ++this->count_;
1153
1154 // Every PLT entry needs a reloc.
1155 gsym->set_needs_dynsym_entry();
1156 this->rel_->add_global(gsym, elfcpp::R_SPARC_JMP_SLOT, this,
1157 plt_offset, 0);
1158
1159 // Note that we don't need to save the symbol. The contents of the
1160 // PLT are independent of which symbols are used. The symbols only
1161 // appear in the relocations.
1162}
1163
1164static const unsigned int sparc_nop = 0x01000000;
1165static const unsigned int sparc_sethi_g1 = 0x03000000;
1166static const unsigned int sparc_branch_always = 0x30800000;
1167static const unsigned int sparc_branch_always_pt = 0x30680000;
1168static const unsigned int sparc_mov = 0x80100000;
1169static const unsigned int sparc_mov_g0_o0 = 0x90100000;
1170static const unsigned int sparc_mov_o7_g5 = 0x8a10000f;
1171static const unsigned int sparc_call_plus_8 = 0x40000002;
1172static const unsigned int sparc_ldx_o7_imm_g1 = 0xc25be000;
1173static const unsigned int sparc_jmpl_o7_g1_g1 = 0x83c3c001;
1174static const unsigned int sparc_mov_g5_o7 = 0x9e100005;
1175
1176// Write out the PLT.
1177
1178template<int size, bool big_endian>
1179void
1180Output_data_plt_sparc<size, big_endian>::do_write(Output_file* of)
1181{
1182 const off_t offset = this->offset();
1183 const section_size_type oview_size =
1184 convert_to_section_size_type(this->data_size());
1185 unsigned char* const oview = of->get_output_view(offset, oview_size);
1186 unsigned char* pov = oview;
1187
1188 memset(pov, 0, base_plt_entry_size * 4);
1189 pov += base_plt_entry_size * 4;
1190
1191 unsigned int plt_offset = base_plt_entry_size * 4;
1192 const unsigned int count = this->count_;
1193
1194 if (size == 64)
1195 {
1196 unsigned int limit;
1197
1198 limit = (count > 32768 ? 32768 : count);
1199
1200 for (unsigned int i = 0; i < limit; ++i)
1201 {
1202 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1203 sparc_sethi_g1 + plt_offset);
1204 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1205 sparc_branch_always_pt +
1206 (((base_plt_entry_size -
1207 (plt_offset + 4)) >> 2) &
1208 0x7ffff));
1209 elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop);
1210 elfcpp::Swap<32, true>::writeval(pov + 0x0c, sparc_nop);
1211 elfcpp::Swap<32, true>::writeval(pov + 0x10, sparc_nop);
1212 elfcpp::Swap<32, true>::writeval(pov + 0x14, sparc_nop);
1213 elfcpp::Swap<32, true>::writeval(pov + 0x18, sparc_nop);
1214 elfcpp::Swap<32, true>::writeval(pov + 0x1c, sparc_nop);
1215
1216 pov += base_plt_entry_size;
1217 plt_offset += base_plt_entry_size;
1218 }
1219
1220 if (count > 32768)
1221 {
1222 unsigned int ext_cnt = count - 32768;
1223 unsigned int blks = ext_cnt / plt_entries_per_block;
1224
1225 for (unsigned int i = 0; i < blks; ++i)
1226 {
1227 unsigned int data_off = (plt_entries_per_block
1228 * plt_insn_chunk_size) - 4;
1229
1230 for (unsigned int j = 0; j < plt_entries_per_block; ++j)
1231 {
1232 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1233 sparc_mov_o7_g5);
1234 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1235 sparc_call_plus_8);
1236 elfcpp::Swap<32, true>::writeval(pov + 0x08,
1237 sparc_nop);
1238 elfcpp::Swap<32, true>::writeval(pov + 0x0c,
1239 sparc_ldx_o7_imm_g1 +
1240 (data_off & 0x1fff));
1241 elfcpp::Swap<32, true>::writeval(pov + 0x10,
1242 sparc_jmpl_o7_g1_g1);
1243 elfcpp::Swap<32, true>::writeval(pov + 0x14,
1244 sparc_mov_g5_o7);
1245
1246 elfcpp::Swap<64, big_endian>::writeval(
1247 pov + 0x4 + data_off,
1248 (elfcpp::Elf_Xword) (oview - (pov + 0x04)));
1249
1250 pov += plt_insn_chunk_size;
1251 data_off -= 16;
1252 }
1253 }
1254
1255 unsigned int sub_blk_cnt = ext_cnt % plt_entries_per_block;
1256 for (unsigned int i = 0; i < sub_blk_cnt; ++i)
1257 {
1258 unsigned int data_off = (sub_blk_cnt
1259 * plt_insn_chunk_size) - 4;
1260
1261 for (unsigned int j = 0; j < plt_entries_per_block; ++j)
1262 {
1263 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1264 sparc_mov_o7_g5);
1265 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1266 sparc_call_plus_8);
1267 elfcpp::Swap<32, true>::writeval(pov + 0x08,
1268 sparc_nop);
1269 elfcpp::Swap<32, true>::writeval(pov + 0x0c,
1270 sparc_ldx_o7_imm_g1 +
1271 (data_off & 0x1fff));
1272 elfcpp::Swap<32, true>::writeval(pov + 0x10,
1273 sparc_jmpl_o7_g1_g1);
1274 elfcpp::Swap<32, true>::writeval(pov + 0x14,
1275 sparc_mov_g5_o7);
1276
1277 elfcpp::Swap<64, big_endian>::writeval(
1278 pov + 0x4 + data_off,
1279 (elfcpp::Elf_Xword) (oview - (pov + 0x04)));
1280
1281 pov += plt_insn_chunk_size;
1282 data_off -= 16;
1283 }
1284 }
1285 }
1286 }
1287 else
1288 {
1289 for (unsigned int i = 0; i < count; ++i)
1290 {
1291 elfcpp::Swap<32, true>::writeval(pov + 0x00,
1292 sparc_sethi_g1 + plt_offset);
1293 elfcpp::Swap<32, true>::writeval(pov + 0x04,
1294 sparc_branch_always +
1295 (((- (plt_offset + 4)) >> 2) &
1296 0x003fffff));
1297 elfcpp::Swap<32, true>::writeval(pov + 0x08, sparc_nop);
1298
1299 pov += base_plt_entry_size;
1300 plt_offset += base_plt_entry_size;
1301 }
1302
1303 elfcpp::Swap<32, true>::writeval(pov, sparc_nop);
1304 pov += 4;
1305 }
1306
1307 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1308
1309 of->write_output_view(offset, oview_size, oview);
1310}
1311
1312// Create a PLT entry for a global symbol.
1313
1314template<int size, bool big_endian>
1315void
1316Target_sparc<size, big_endian>::make_plt_entry(Symbol_table* symtab,
1317 Layout* layout,
1318 Symbol* gsym)
1319{
1320 if (gsym->has_plt_offset())
1321 return;
1322
1323 if (this->plt_ == NULL)
1324 {
1325 // Create the GOT sections first.
1326 this->got_section(symtab, layout);
1327
1328 this->plt_ = new Output_data_plt_sparc<size, big_endian>(layout);
1329 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1330 (elfcpp::SHF_ALLOC
1331 | elfcpp::SHF_EXECINSTR
1332 | elfcpp::SHF_WRITE),
1333 this->plt_);
1334
1335 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
1336 symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
1337 this->plt_,
1338 0, 0, elfcpp::STT_OBJECT,
1339 elfcpp::STB_LOCAL,
1340 elfcpp::STV_HIDDEN, 0,
1341 false, false);
1342 }
1343
1344 this->plt_->add_entry(gsym);
1345}
1346
1347// Create a GOT entry for the TLS module index.
1348
1349template<int size, bool big_endian>
1350unsigned int
1351Target_sparc<size, big_endian>::got_mod_index_entry(Symbol_table* symtab,
1352 Layout* layout,
1353 Sized_relobj<size, big_endian>* object)
1354{
1355 if (this->got_mod_index_offset_ == -1U)
1356 {
1357 gold_assert(symtab != NULL && layout != NULL && object != NULL);
1358 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
1359 Output_data_got<size, big_endian>* got;
1360 unsigned int got_offset;
1361
1362 got = this->got_section(symtab, layout);
1363 got_offset = got->add_constant(0);
1364 rela_dyn->add_local(object, 0,
1365 (size == 64 ?
1366 elfcpp::R_SPARC_TLS_DTPMOD64 :
1367 elfcpp::R_SPARC_TLS_DTPMOD32), got,
1368 got_offset, 0);
1369 got->add_constant(0);
1370 this->got_mod_index_offset_ = got_offset;
1371 }
1372 return this->got_mod_index_offset_;
1373}
1374
f5314dd5
DM		 1375// Optimize the TLS relocation type based on what we know about the
1376// symbol. IS_FINAL is true if the final address of this symbol is
1377// known at link time.
1378
1379static tls::Tls_optimization
1380optimize_tls_reloc(bool is_final, int r_type)
1381{
1382 // If we are generating a shared library, then we can't do anything
1383 // in the linker.
1384 if (parameters->options().shared())
1385 return tls::TLSOPT_NONE;
1386
1387 switch (r_type)
1388 {
1389 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1390 case elfcpp::R_SPARC_TLS_GD_LO10:
1391 case elfcpp::R_SPARC_TLS_GD_ADD:
1392 case elfcpp::R_SPARC_TLS_GD_CALL:
1393 // These are General-Dynamic which permits fully general TLS
1394 // access. Since we know that we are generating an executable,
1395 // we can convert this to Initial-Exec. If we also know that
1396 // this is a local symbol, we can further switch to Local-Exec.
1397 if (is_final)
1398 return tls::TLSOPT_TO_LE;
1399 return tls::TLSOPT_TO_IE;
1400
1401 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic
1402 case elfcpp::R_SPARC_TLS_LDM_LO10:
1403 case elfcpp::R_SPARC_TLS_LDM_ADD:
1404 case elfcpp::R_SPARC_TLS_LDM_CALL:
1405 // This is Local-Dynamic, which refers to a local symbol in the
1406 // dynamic TLS block. Since we know that we generating an
1407 // executable, we can switch to Local-Exec.
1408 return tls::TLSOPT_TO_LE;
1409
1410 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1411 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1412 case elfcpp::R_SPARC_TLS_LDO_ADD:
1413 // Another type of Local-Dynamic relocation.
1414 return tls::TLSOPT_TO_LE;
1415
1416 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1417 case elfcpp::R_SPARC_TLS_IE_LO10:
1418 case elfcpp::R_SPARC_TLS_IE_LD:
1419 case elfcpp::R_SPARC_TLS_IE_LDX:
1420 // These are Initial-Exec relocs which get the thread offset
1421 // from the GOT. If we know that we are linking against the
1422 // local symbol, we can switch to Local-Exec, which links the
1423 // thread offset into the instruction.
1424 if (is_final)
1425 return tls::TLSOPT_TO_LE;
1426 return tls::TLSOPT_NONE;
1427
1428 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec
1429 case elfcpp::R_SPARC_TLS_LE_LOX10:
1430 // When we already have Local-Exec, there is nothing further we
1431 // can do.
1432 return tls::TLSOPT_NONE;
1433
1434 default:
1435 gold_unreachable();
1436 }
1437}
1438
1439// Generate a PLT entry slot for a call to __tls_get_addr
1440template<int size, bool big_endian>
1441void
1442Target_sparc<size, big_endian>::Scan::generate_tls_call(Symbol_table* symtab,
1443 Layout* layout,
1444 Target_sparc<size, big_endian>* target)
1445{
1446 Symbol* gsym = target->tls_get_addr_sym(symtab);
1447
1448 target->make_plt_entry(symtab, layout, gsym);
1449}
1450
1451// Report an unsupported relocation against a local symbol.
1452
1453template<int size, bool big_endian>
1454void
1455Target_sparc<size, big_endian>::Scan::unsupported_reloc_local(
1456 Sized_relobj<size, big_endian>* object,
1457 unsigned int r_type)
1458{
1459 gold_error(_("%s: unsupported reloc %u against local symbol"),
1460 object->name().c_str(), r_type);
1461}
1462
1463// Scan a relocation for a local symbol.
1464
1465template<int size, bool big_endian>
1466inline void
1467Target_sparc<size, big_endian>::Scan::local(
1468 const General_options&,
1469 Symbol_table* symtab,
1470 Layout* layout,
1471 Target_sparc<size, big_endian>* target,
1472 Sized_relobj<size, big_endian>* object,
1473 unsigned int data_shndx,
1474 Output_section* output_section,
1475 const elfcpp::Rela<size, big_endian>& reloc,
1476 unsigned int r_type,
1477 const elfcpp::Sym<size, big_endian>& lsym)
1478{
1479 unsigned int orig_r_type = r_type;
1480
1481 r_type &= 0xff;
1482 switch (r_type)
1483 {
1484 case elfcpp::R_SPARC_NONE:
1485 case elfcpp::R_SPARC_REGISTER:
1486 case elfcpp::R_SPARC_GNU_VTINHERIT:
1487 case elfcpp::R_SPARC_GNU_VTENTRY:
1488 break;
1489
1490 case elfcpp::R_SPARC_64:
1491 case elfcpp::R_SPARC_32:
1492 // If building a shared library (or a position-independent
1493 // executable), we need to create a dynamic relocation for
1494 // this location. The relocation applied at link time will
1495 // apply the link-time value, so we flag the location with
1496 // an R_SPARC_RELATIVE relocation so the dynamic loader can
1497 // relocate it easily.
1498 if (parameters->options().output_is_position_independent())
1499 {
1500 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1501 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1502 rela_dyn->add_local_relative(object, r_sym, elfcpp::R_SPARC_RELATIVE,
1503 output_section, data_shndx,
1504 reloc.get_r_offset(),
1505 reloc.get_r_addend());
1506 }
1507 break;
1508
1509 case elfcpp::R_SPARC_HIX22:
1510 case elfcpp::R_SPARC_LOX10:
1511 case elfcpp::R_SPARC_H44:
1512 case elfcpp::R_SPARC_M44:
1513 case elfcpp::R_SPARC_L44:
1514 case elfcpp::R_SPARC_HH22:
1515 case elfcpp::R_SPARC_HM10:
1516 case elfcpp::R_SPARC_LM22:
1517 case elfcpp::R_SPARC_UA64:
1518 case elfcpp::R_SPARC_UA32:
1519 case elfcpp::R_SPARC_UA16:
1520 case elfcpp::R_SPARC_HI22:
1521 case elfcpp::R_SPARC_LO10:
1522 case elfcpp::R_SPARC_OLO10:
1523 case elfcpp::R_SPARC_16:
1524 case elfcpp::R_SPARC_11:
1525 case elfcpp::R_SPARC_10:
1526 case elfcpp::R_SPARC_8:
1527 case elfcpp::R_SPARC_7:
1528 case elfcpp::R_SPARC_6:
1529 case elfcpp::R_SPARC_5:
1530 // If building a shared library (or a position-independent
1531 // executable), we need to create a dynamic relocation for
1532 // this location.
1533 if (parameters->options().output_is_position_independent())
1534 {
1535 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1536 if (lsym.get_st_type() != elfcpp::STT_SECTION)
1537 {
1538 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1539 rela_dyn->add_local(object, r_sym, orig_r_type, output_section,
1540 data_shndx, reloc.get_r_offset(),
1541 reloc.get_r_addend());
1542 }
1543 else
1544 {
1545 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1546 gold_assert(lsym.get_st_value() == 0);
1547 rela_dyn->add_local_relative(object, r_sym, orig_r_type,
1548 output_section, data_shndx,
1549 reloc.get_r_offset(),
1550 reloc.get_r_addend());
1551 }
1552 }
1553 break;
1554
1555 case elfcpp::R_SPARC_WDISP30:
1556 case elfcpp::R_SPARC_WDISP22:
1557 case elfcpp::R_SPARC_WDISP19:
1558 case elfcpp::R_SPARC_WDISP16:
1559 case elfcpp::R_SPARC_DISP8:
1560 case elfcpp::R_SPARC_DISP16:
1561 case elfcpp::R_SPARC_DISP32:
1562 case elfcpp::R_SPARC_DISP64:
1563 case elfcpp::R_SPARC_PC10:
1564 case elfcpp::R_SPARC_PC22:
1565 break;
1566
1567 case elfcpp::R_SPARC_GOT10:
1568 case elfcpp::R_SPARC_GOT13:
1569 case elfcpp::R_SPARC_GOT22:
1570 {
1571 // The symbol requires a GOT entry.
1572 Output_data_got<size, big_endian>* got;
1573 unsigned int r_sym;
1574
1575 got = target->got_section(symtab, layout);
1576 r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1577
1578 // If we are generating a shared object, we need to add a
1579 // dynamic relocation for this symbol's GOT entry.
1580 if (parameters->options().output_is_position_independent())
1581 {
1582 if (!object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD))
1583 {
1584 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1585 unsigned int off;
1586
1587 off = got->add_constant(0);
1588 object->set_local_got_offset(r_sym, GOT_TYPE_STANDARD, off);
1589 rela_dyn->add_local_relative(object, r_sym,
1590 elfcpp::R_SPARC_RELATIVE,
1591 got, off, 0);
1592 }
1593 }
1594 else
1595 got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1596 }
1597 break;
1598
1599 // These are initial TLS relocs, which are expected when
1600 // linking.
1601 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1602 case elfcpp::R_SPARC_TLS_GD_LO10:
1603 case elfcpp::R_SPARC_TLS_GD_ADD:
1604 case elfcpp::R_SPARC_TLS_GD_CALL:
1605 case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic
1606 case elfcpp::R_SPARC_TLS_LDM_LO10:
1607 case elfcpp::R_SPARC_TLS_LDM_ADD:
1608 case elfcpp::R_SPARC_TLS_LDM_CALL:
1609 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1610 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1611 case elfcpp::R_SPARC_TLS_LDO_ADD:
1612 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1613 case elfcpp::R_SPARC_TLS_IE_LO10:
1614 case elfcpp::R_SPARC_TLS_IE_LD:
1615 case elfcpp::R_SPARC_TLS_IE_LDX:
1616 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec
1617 case elfcpp::R_SPARC_TLS_LE_LOX10:
1618 {
1619 bool output_is_shared = parameters->options().shared();
1620 const tls::Tls_optimization optimized_type
1621 = optimize_tls_reloc(!output_is_shared, r_type);
1622 switch (r_type)
1623 {
1624 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1625 case elfcpp::R_SPARC_TLS_GD_LO10:
1626 case elfcpp::R_SPARC_TLS_GD_ADD:
1627 case elfcpp::R_SPARC_TLS_GD_CALL:
1628 if (optimized_type == tls::TLSOPT_NONE)
1629 {
1630 // Create a pair of GOT entries for the module index and
1631 // dtv-relative offset.
1632 Output_data_got<size, big_endian>* got
1633 = target->got_section(symtab, layout);
1634 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1635 got->add_local_pair_with_rela(object, r_sym,
1636 lsym.get_st_shndx(),
1637 GOT_TYPE_TLS_PAIR,
1638 target->rela_dyn_section(layout),
1639 (size == 64 ?
1640 elfcpp::R_SPARC_TLS_DTPMOD64 :
1641 elfcpp::R_SPARC_TLS_DTPMOD32), 0);
1642 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL)
1643 generate_tls_call(symtab, layout, target);
1644 }
1645 else if (optimized_type != tls::TLSOPT_TO_LE)
1646 unsupported_reloc_local(object, r_type);
1647 break;
1648
1649 case elfcpp::R_SPARC_TLS_LDM_HI22 : // Local-dynamic
1650 case elfcpp::R_SPARC_TLS_LDM_LO10:
1651 case elfcpp::R_SPARC_TLS_LDM_ADD:
1652 case elfcpp::R_SPARC_TLS_LDM_CALL:
1653 if (optimized_type == tls::TLSOPT_NONE)
1654 {
1655 // Create a GOT entry for the module index.
1656 target->got_mod_index_entry(symtab, layout, object);
1657
1658 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL)
1659 generate_tls_call(symtab, layout, target);
1660 }
1661 else if (optimized_type != tls::TLSOPT_TO_LE)
1662 unsupported_reloc_local(object, r_type);
1663 break;
1664
1665 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1666 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1667 case elfcpp::R_SPARC_TLS_LDO_ADD:
1668 break;
1669
1670 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1671 case elfcpp::R_SPARC_TLS_IE_LO10:
1672 case elfcpp::R_SPARC_TLS_IE_LD:
1673 case elfcpp::R_SPARC_TLS_IE_LDX:
1674 layout->set_has_static_tls();
1675 if (optimized_type == tls::TLSOPT_NONE)
1676 {
1677 // Create a GOT entry for the tp-relative offset.
1678 Output_data_got<size, big_endian>* got
1679 = target->got_section(symtab, layout);
1680 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1681
1682 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_OFFSET))
1683 {
1684 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1685 unsigned int off = got->add_constant(0);
1686
1687 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET,
1688 off);
1689 rela_dyn->add_local_relative(object, r_sym,
1690 (size == 64 ?
1691 elfcpp::R_SPARC_TLS_TPOFF64 :
1692 elfcpp::R_SPARC_TLS_TPOFF32),
1693 got, off, 0);
1694 }
1695 }
1696 else if (optimized_type != tls::TLSOPT_TO_LE)
1697 unsupported_reloc_local(object, r_type);
1698 break;
1699
1700 case elfcpp::R_SPARC_TLS_LE_HIX22: // Local-exec
1701 case elfcpp::R_SPARC_TLS_LE_LOX10:
1702 layout->set_has_static_tls();
1703 if (output_is_shared)
1704 {
1705 // We need to create a dynamic relocation.
1706 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
1707 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
1708 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1709 rela_dyn->add_local_relative(object, r_sym, r_type,
1710 output_section, data_shndx,
1711 reloc.get_r_offset(), 0);
1712 }
1713 break;
1714 }
1715 }
1716 break;
1717
1718 // These are relocations which should only be seen by the
1719 // dynamic linker, and should never be seen here.
1720 case elfcpp::R_SPARC_COPY:
1721 case elfcpp::R_SPARC_GLOB_DAT:
1722 case elfcpp::R_SPARC_JMP_SLOT:
1723 case elfcpp::R_SPARC_RELATIVE:
1724 case elfcpp::R_SPARC_TLS_DTPMOD64:
1725 case elfcpp::R_SPARC_TLS_DTPMOD32:
1726 case elfcpp::R_SPARC_TLS_DTPOFF64:
1727 case elfcpp::R_SPARC_TLS_DTPOFF32:
1728 case elfcpp::R_SPARC_TLS_TPOFF64:
1729 case elfcpp::R_SPARC_TLS_TPOFF32:
1730 gold_error(_("%s: unexpected reloc %u in object file"),
1731 object->name().c_str(), r_type);
1732 break;
1733
1734 default:
1735 unsupported_reloc_local(object, r_type);
1736 break;
1737 }
1738}
1739
1740// Report an unsupported relocation against a global symbol.
1741
1742template<int size, bool big_endian>
1743void
1744Target_sparc<size, big_endian>::Scan::unsupported_reloc_global(
1745 Sized_relobj<size, big_endian>* object,
1746 unsigned int r_type,
1747 Symbol* gsym)
1748{
1749 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
1750 object->name().c_str(), r_type, gsym->demangled_name().c_str());
1751}
1752
1753// Scan a relocation for a global symbol.
1754
1755template<int size, bool big_endian>
1756inline void
1757Target_sparc<size, big_endian>::Scan::global(
12c0daef 1758 const General_options&,
f5314dd5
DM		 1759 Symbol_table* symtab,
1760 Layout* layout,
1761 Target_sparc<size, big_endian>* target,
1762 Sized_relobj<size, big_endian>* object,
1763 unsigned int data_shndx,
1764 Output_section* output_section,
1765 const elfcpp::Rela<size, big_endian>& reloc,
1766 unsigned int r_type,
1767 Symbol* gsym)
1768{
1769 unsigned int orig_r_type = r_type;
1770
1771 r_type &= 0xff;
1772 switch (r_type)
1773 {
1774 case elfcpp::R_SPARC_NONE:
1775 case elfcpp::R_SPARC_REGISTER:
1776 case elfcpp::R_SPARC_GNU_VTINHERIT:
1777 case elfcpp::R_SPARC_GNU_VTENTRY:
1778 break;
1779
1780 case elfcpp::R_SPARC_PLT64:
1781 case elfcpp::R_SPARC_PLT32:
1782 case elfcpp::R_SPARC_HIPLT22:
1783 case elfcpp::R_SPARC_LOPLT10:
1784 case elfcpp::R_SPARC_PCPLT32:
1785 case elfcpp::R_SPARC_PCPLT22:
1786 case elfcpp::R_SPARC_PCPLT10:
1787 case elfcpp::R_SPARC_WPLT30:
1788 // If the symbol is fully resolved, this is just a PC32 reloc.
1789 // Otherwise we need a PLT entry.
1790 if (gsym->final_value_is_known())
1791 break;
1792 // If building a shared library, we can also skip the PLT entry
1793 // if the symbol is defined in the output file and is protected
1794 // or hidden.
1795 if (gsym->is_defined()
1796 && !gsym->is_from_dynobj()
1797 && !gsym->is_preemptible())
1798 break;
1799 target->make_plt_entry(symtab, layout, gsym);
1800 break;
1801
1802 case elfcpp::R_SPARC_DISP8:
1803 case elfcpp::R_SPARC_DISP16:
1804 case elfcpp::R_SPARC_DISP32:
1805 case elfcpp::R_SPARC_DISP64:
1806 case elfcpp::R_SPARC_PC_HH22:
1807 case elfcpp::R_SPARC_PC_HM10:
1808 case elfcpp::R_SPARC_PC_LM22:
1809 case elfcpp::R_SPARC_PC10:
1810 case elfcpp::R_SPARC_PC22:
1811 case elfcpp::R_SPARC_WDISP30:
1812 case elfcpp::R_SPARC_WDISP22:
1813 case elfcpp::R_SPARC_WDISP19:
1814 case elfcpp::R_SPARC_WDISP16:
1815 {
1816 if (gsym->needs_plt_entry())
1817 target->make_plt_entry(symtab, layout, gsym);
1818 // Make a dynamic relocation if necessary.
1819 int flags = Symbol::NON_PIC_REF;
1820 if (gsym->type() == elfcpp::STT_FUNC)
1821 flags |= Symbol::FUNCTION_CALL;
1822 if (gsym->needs_dynamic_reloc(flags))
1823 {
1824 if (target->may_need_copy_reloc(gsym))
1825 {
12c0daef 1826 target->copy_reloc(symtab, layout, object,
f5314dd5
DM		 1827 data_shndx, output_section, gsym,
1828 reloc);
1829 }
1830 else
1831 {
1832 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1833 rela_dyn->add_global(gsym, orig_r_type, output_section, object,
1834 data_shndx, reloc.get_r_offset(),
1835 reloc.get_r_addend());
1836 }
1837 }
1838 }
1839 break;
1840
1841 case elfcpp::R_SPARC_UA64:
1842 case elfcpp::R_SPARC_64:
1843 case elfcpp::R_SPARC_HIX22:
1844 case elfcpp::R_SPARC_LOX10:
1845 case elfcpp::R_SPARC_H44:
1846 case elfcpp::R_SPARC_M44:
1847 case elfcpp::R_SPARC_L44:
1848 case elfcpp::R_SPARC_HH22:
1849 case elfcpp::R_SPARC_HM10:
1850 case elfcpp::R_SPARC_LM22:
1851 case elfcpp::R_SPARC_HI22:
1852 case elfcpp::R_SPARC_LO10:
1853 case elfcpp::R_SPARC_OLO10:
1854 case elfcpp::R_SPARC_UA32:
1855 case elfcpp::R_SPARC_32:
1856 case elfcpp::R_SPARC_UA16:
1857 case elfcpp::R_SPARC_16:
1858 case elfcpp::R_SPARC_11:
1859 case elfcpp::R_SPARC_10:
1860 case elfcpp::R_SPARC_8:
1861 case elfcpp::R_SPARC_7:
1862 case elfcpp::R_SPARC_6:
1863 case elfcpp::R_SPARC_5:
1864 {
1865 // Make a PLT entry if necessary.
1866 if (gsym->needs_plt_entry())
1867 {
1868 target->make_plt_entry(symtab, layout, gsym);
1869 // Since this is not a PC-relative relocation, we may be
1870 // taking the address of a function. In that case we need to
1871 // set the entry in the dynamic symbol table to the address of
1872 // the PLT entry.
1873 if (gsym->is_from_dynobj() && !parameters->options().shared())
1874 gsym->set_needs_dynsym_value();
1875 }
1876 // Make a dynamic relocation if necessary.
1877 if (gsym->needs_dynamic_reloc(Symbol::ABSOLUTE_REF))
1878 {
1879 if (target->may_need_copy_reloc(gsym))
1880 {
12c0daef 1881 target->copy_reloc(symtab, layout, object,
f5314dd5
DM		 1882 data_shndx, output_section, gsym, reloc);
1883 }
1884 else if ((r_type == elfcpp::R_SPARC_32
1885 || r_type == elfcpp::R_SPARC_64)
1886 && gsym->can_use_relative_reloc(false))
1887 {
1888 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1889 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE,
1890 output_section, object,
1891 data_shndx, reloc.get_r_offset(),
1892 reloc.get_r_addend());
1893 }
1894 else
1895 {
1896 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1897
1898 if (gsym->is_from_dynobj()
1899 || gsym->is_undefined()
1900 || gsym->is_preemptible())
1901 rela_dyn->add_global(gsym, orig_r_type, output_section,
1902 object, data_shndx,
1903 reloc.get_r_offset(),
1904 reloc.get_r_addend());
1905 else
1906 rela_dyn->add_global_relative(gsym, orig_r_type,
1907 output_section, object,
1908 data_shndx,
1909 reloc.get_r_offset(),
1910 reloc.get_r_addend());
1911 }
1912 }
1913 }
1914 break;
1915
1916 case elfcpp::R_SPARC_GOT10:
1917 case elfcpp::R_SPARC_GOT13:
1918 case elfcpp::R_SPARC_GOT22:
1919 {
1920 // The symbol requires a GOT entry.
1921 Output_data_got<size, big_endian>* got;
1922
1923 got = target->got_section(symtab, layout);
1924 if (gsym->final_value_is_known())
1925 got->add_global(gsym, GOT_TYPE_STANDARD);
1926 else
1927 {
1928 // If this symbol is not fully resolved, we need to add a
1929 // dynamic relocation for it.
1930 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
1931 if (gsym->is_from_dynobj()
1932 || gsym->is_undefined()
1933 || gsym->is_preemptible())
1934 got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
1935 elfcpp::R_SPARC_GLOB_DAT);
1936 else if (!gsym->has_got_offset(GOT_TYPE_STANDARD))
1937 {
1938 unsigned int off = got->add_constant(0);
1939
1940 gsym->set_got_offset(GOT_TYPE_STANDARD, off);
1941 rela_dyn->add_global_relative(gsym, elfcpp::R_SPARC_RELATIVE,
1942 got, off, 0);
1943 }
1944 }
1945 }
1946 break;
1947
1948 // These are initial tls relocs, which are expected when
1949 // linking.
1950 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1951 case elfcpp::R_SPARC_TLS_GD_LO10:
1952 case elfcpp::R_SPARC_TLS_GD_ADD:
1953 case elfcpp::R_SPARC_TLS_GD_CALL:
1954 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic
1955 case elfcpp::R_SPARC_TLS_LDM_LO10:
1956 case elfcpp::R_SPARC_TLS_LDM_ADD:
1957 case elfcpp::R_SPARC_TLS_LDM_CALL:
1958 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
1959 case elfcpp::R_SPARC_TLS_LDO_LOX10:
1960 case elfcpp::R_SPARC_TLS_LDO_ADD:
1961 case elfcpp::R_SPARC_TLS_LE_HIX22:
1962 case elfcpp::R_SPARC_TLS_LE_LOX10:
1963 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
1964 case elfcpp::R_SPARC_TLS_IE_LO10:
1965 case elfcpp::R_SPARC_TLS_IE_LD:
1966 case elfcpp::R_SPARC_TLS_IE_LDX:
1967 {
1968 const bool is_final = gsym->final_value_is_known();
1969 const tls::Tls_optimization optimized_type
1970 = optimize_tls_reloc(is_final, r_type);
1971 switch (r_type)
1972 {
1973 case elfcpp::R_SPARC_TLS_GD_HI22: // Global-dynamic
1974 case elfcpp::R_SPARC_TLS_GD_LO10:
1975 case elfcpp::R_SPARC_TLS_GD_ADD:
1976 case elfcpp::R_SPARC_TLS_GD_CALL:
1977 if (optimized_type == tls::TLSOPT_NONE)
1978 {
1979 // Create a pair of GOT entries for the module index and
1980 // dtv-relative offset.
1981 Output_data_got<size, big_endian>* got
1982 = target->got_section(symtab, layout);
1983 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_PAIR,
1984 target->rela_dyn_section(layout),
1985 (size == 64 ?
1986 elfcpp::R_SPARC_TLS_DTPMOD64 :
1987 elfcpp::R_SPARC_TLS_DTPMOD32),
1988 (size == 64 ?
1989 elfcpp::R_SPARC_TLS_DTPOFF64 :
1990 elfcpp::R_SPARC_TLS_DTPOFF32));
1991
1992 // Emit R_SPARC_WPLT30 against "__tls_get_addr"
1993 if (r_type == elfcpp::R_SPARC_TLS_GD_CALL)
1994 generate_tls_call(symtab, layout, target);
1995 }
1996 else if (optimized_type == tls::TLSOPT_TO_IE)
1997 {
1998 // Create a GOT entry for the tp-relative offset.
1999 Output_data_got<size, big_endian>* got
2000 = target->got_section(symtab, layout);
2001 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2002 target->rela_dyn_section(layout),
2003 (size == 64 ?
2004 elfcpp::R_SPARC_TLS_TPOFF64 :
2005 elfcpp::R_SPARC_TLS_TPOFF32));
2006 }
2007 else if (optimized_type != tls::TLSOPT_TO_LE)
2008 unsupported_reloc_global(object, r_type, gsym);
2009 break;
2010
2011 case elfcpp::R_SPARC_TLS_LDM_HI22: // Local-dynamic
2012 case elfcpp::R_SPARC_TLS_LDM_LO10:
2013 case elfcpp::R_SPARC_TLS_LDM_ADD:
2014 case elfcpp::R_SPARC_TLS_LDM_CALL:
2015 if (optimized_type == tls::TLSOPT_NONE)
2016 {
2017 // Create a GOT entry for the module index.
2018 target->got_mod_index_entry(symtab, layout, object);
2019
2020 if (r_type == elfcpp::R_SPARC_TLS_LDM_CALL)
2021 generate_tls_call(symtab, layout, target);
2022 }
2023 else if (optimized_type != tls::TLSOPT_TO_LE)
2024 unsupported_reloc_global(object, r_type, gsym);
2025 break;
2026
2027 case elfcpp::R_SPARC_TLS_LDO_HIX22: // Alternate local-dynamic
2028 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2029 case elfcpp::R_SPARC_TLS_LDO_ADD:
2030 break;
2031
2032 case elfcpp::R_SPARC_TLS_LE_HIX22:
2033 case elfcpp::R_SPARC_TLS_LE_LOX10:
2034 layout->set_has_static_tls();
2035 if (parameters->options().shared())
2036 {
2037 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2038 rela_dyn->add_global_relative(gsym, orig_r_type,
2039 output_section, object,
2040 data_shndx, reloc.get_r_offset(),
2041 0);
2042 }
2043 break;
2044
2045 case elfcpp::R_SPARC_TLS_IE_HI22: // Initial-exec
2046 case elfcpp::R_SPARC_TLS_IE_LO10:
2047 case elfcpp::R_SPARC_TLS_IE_LD:
2048 case elfcpp::R_SPARC_TLS_IE_LDX:
2049 layout->set_has_static_tls();
2050 if (optimized_type == tls::TLSOPT_NONE)
2051 {
2052 // Create a GOT entry for the tp-relative offset.
2053 Output_data_got<size, big_endian>* got
2054 = target->got_section(symtab, layout);
2055 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2056 target->rela_dyn_section(layout),
2057 (size == 64 ?
2058 elfcpp::R_SPARC_TLS_TPOFF64 :
2059 elfcpp::R_SPARC_TLS_TPOFF32));
2060 }
2061 else if (optimized_type != tls::TLSOPT_TO_LE)
2062 unsupported_reloc_global(object, r_type, gsym);
2063 break;
2064 }
2065 }
2066 break;
2067
2068 // These are relocations which should only be seen by the
2069 // dynamic linker, and should never be seen here.
2070 case elfcpp::R_SPARC_COPY:
2071 case elfcpp::R_SPARC_GLOB_DAT:
2072 case elfcpp::R_SPARC_JMP_SLOT:
2073 case elfcpp::R_SPARC_RELATIVE:
2074 case elfcpp::R_SPARC_TLS_DTPMOD64:
2075 case elfcpp::R_SPARC_TLS_DTPMOD32:
2076 case elfcpp::R_SPARC_TLS_DTPOFF64:
2077 case elfcpp::R_SPARC_TLS_DTPOFF32:
2078 case elfcpp::R_SPARC_TLS_TPOFF64:
2079 case elfcpp::R_SPARC_TLS_TPOFF32:
2080 gold_error(_("%s: unexpected reloc %u in object file"),
2081 object->name().c_str(), r_type);
2082 break;
2083
2084 default:
2085 unsupported_reloc_global(object, r_type, gsym);
2086 break;
2087 }
2088}
2089
2090// Scan relocations for a section.
2091
2092template<int size, bool big_endian>
2093void
2094Target_sparc<size, big_endian>::scan_relocs(
2095 const General_options& options,
2096 Symbol_table* symtab,
2097 Layout* layout,
2098 Sized_relobj<size, big_endian>* object,
2099 unsigned int data_shndx,
2100 unsigned int sh_type,
2101 const unsigned char* prelocs,
2102 size_t reloc_count,
2103 Output_section* output_section,
2104 bool needs_special_offset_handling,
2105 size_t local_symbol_count,
2106 const unsigned char* plocal_symbols)
2107{
2108 typedef Target_sparc<size, big_endian> Sparc;
2109 typedef typename Target_sparc<size, big_endian>::Scan Scan;
2110
2111 if (sh_type == elfcpp::SHT_REL)
2112 {
2113 gold_error(_("%s: unsupported REL reloc section"),
2114 object->name().c_str());
2115 return;
2116 }
2117
2118 gold::scan_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>(
2119 options,
2120 symtab,
2121 layout,
2122 this,
2123 object,
2124 data_shndx,
2125 prelocs,
2126 reloc_count,
2127 output_section,
2128 needs_special_offset_handling,
2129 local_symbol_count,
2130 plocal_symbols);
2131}
2132
2133// Finalize the sections.
2134
2135template<int size, bool big_endian>
2136void
2137Target_sparc<size, big_endian>::do_finalize_sections(Layout* layout)
2138{
2139 // Fill in some more dynamic tags.
2140 Output_data_dynamic* const odyn = layout->dynamic_data();
2141 if (odyn != NULL)
2142 {
2143 if (this->plt_ != NULL)
2144 {
2145 const Output_data* od = this->plt_->rel_plt();
2146 odyn->add_section_size(elfcpp::DT_PLTRELSZ, od);
2147 odyn->add_section_address(elfcpp::DT_JMPREL, od);
2148 odyn->add_constant(elfcpp::DT_PLTREL, elfcpp::DT_RELA);
2149
2150 odyn->add_section_address(elfcpp::DT_PLTGOT, this->plt_);
2151 }
2152
2153 if (this->rela_dyn_ != NULL)
2154 {
2155 const Output_data* od = this->rela_dyn_;
2156 odyn->add_section_address(elfcpp::DT_RELA, od);
2157 odyn->add_section_size(elfcpp::DT_RELASZ, od);
2158 odyn->add_constant(elfcpp::DT_RELAENT,
2159 elfcpp::Elf_sizes<size>::rela_size);
2160 }
2161
2162 if (!parameters->options().shared())
2163 {
2164 // The value of the DT_DEBUG tag is filled in by the dynamic
2165 // linker at run time, and used by the debugger.
2166 odyn->add_constant(elfcpp::DT_DEBUG, 0);
2167 }
2168 }
2169
2170 // Emit any relocs we saved in an attempt to avoid generating COPY
2171 // relocs.
12c0daef
ILT		 2172 if (this->copy_relocs_.any_saved_relocs())
2173 this->copy_relocs_.emit(this->rela_dyn_section(layout));
f5314dd5
DM		 2174}
2175
2176// Perform a relocation.
2177
2178template<int size, bool big_endian>
2179inline bool
2180Target_sparc<size, big_endian>::Relocate::relocate(
2181 const Relocate_info<size, big_endian>* relinfo,
2182 Target_sparc* target,
2183 size_t relnum,
2184 const elfcpp::Rela<size, big_endian>& rela,
2185 unsigned int r_type,
2186 const Sized_symbol<size>* gsym,
2187 const Symbol_value<size>* psymval,
2188 unsigned char* view,
2189 typename elfcpp::Elf_types<size>::Elf_Addr address,
2190 section_size_type view_size)
2191{
2192 r_type &= 0xff;
2193
2194 if (this->ignore_gd_add_)
2195 {
2196 if (r_type != elfcpp::R_SPARC_TLS_GD_ADD)
2197 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2198 _("missing expected TLS relocation"));
2199 else
2200 {
2201 this->ignore_gd_add_ = false;
2202 return false;
2203 }
2204 }
2205
2206 typedef Sparc_relocate_functions<size, big_endian> Reloc;
2207
2208 // Pick the value to use for symbols defined in shared objects.
2209 Symbol_value<size> symval;
2210 if (gsym != NULL
2211 && (gsym->is_from_dynobj()
2212 || (parameters->options().shared()
2213 && (gsym->is_undefined() || gsym->is_preemptible())))
2214 && gsym->has_plt_offset())
2215 {
2216 elfcpp::Elf_Xword value;
2217
2218 value = target->plt_section()->address() + gsym->plt_offset();
2219
2220 symval.set_output_value(value);
2221
2222 psymval = &symval;
2223 }
2224
2225 const Sized_relobj<size, big_endian>* object = relinfo->object;
2226 const elfcpp::Elf_Xword addend = rela.get_r_addend();
2227
2228 // Get the GOT offset if needed. Unlike i386 and x86_64, our GOT
2229 // pointer points to the beginning, not the end, of the table.
2230 // So we just use the plain offset.
2231 bool have_got_offset = false;
2232 unsigned int got_offset = 0;
2233 switch (r_type)
2234 {
2235 case elfcpp::R_SPARC_GOT10:
2236 case elfcpp::R_SPARC_GOT13:
2237 case elfcpp::R_SPARC_GOT22:
2238 if (gsym != NULL)
2239 {
2240 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2241 got_offset = gsym->got_offset(GOT_TYPE_STANDARD);
2242 }
2243 else
2244 {
2245 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2246 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2247 got_offset = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
2248 }
2249 have_got_offset = true;
2250 break;
2251
2252 default:
2253 break;
2254 }
2255
2256 switch (r_type)
2257 {
2258 case elfcpp::R_SPARC_NONE:
2259 case elfcpp::R_SPARC_REGISTER:
2260 case elfcpp::R_SPARC_GNU_VTINHERIT:
2261 case elfcpp::R_SPARC_GNU_VTENTRY:
2262 break;
2263
2264 case elfcpp::R_SPARC_8:
2265 Relocate_functions<size, big_endian>::rela8(view, object,
2266 psymval, addend);
2267 break;
2268
2269 case elfcpp::R_SPARC_16:
2270 Relocate_functions<size, big_endian>::rela16(view, object,
2271 psymval, addend);
2272 break;
2273
2274 case elfcpp::R_SPARC_32:
2275 if (!parameters->options().output_is_position_independent())
2276 Relocate_functions<size, big_endian>::rela32(view, object,
2277 psymval, addend);
2278 break;
2279
2280 case elfcpp::R_SPARC_DISP8:
2281 Reloc::disp8(view, object, psymval, addend, address);
2282 break;
2283
2284 case elfcpp::R_SPARC_DISP16:
2285 Reloc::disp16(view, object, psymval, addend, address);
2286 break;
2287
2288 case elfcpp::R_SPARC_DISP32:
2289 Reloc::disp32(view, object, psymval, addend, address);
2290 break;
2291
2292 case elfcpp::R_SPARC_DISP64:
2293 Reloc::disp64(view, object, psymval, addend, address);
2294 break;
2295
2296 case elfcpp::R_SPARC_WDISP30:
2297 case elfcpp::R_SPARC_WPLT30:
2298 Reloc::wdisp30(view, object, psymval, addend, address);
2299 break;
2300
2301 case elfcpp::R_SPARC_WDISP22:
2302 Reloc::wdisp22(view, object, psymval, addend, address);
2303 break;
2304
2305 case elfcpp::R_SPARC_WDISP19:
2306 Reloc::wdisp19(view, object, psymval, addend, address);
2307 break;
2308
2309 case elfcpp::R_SPARC_WDISP16:
2310 Reloc::wdisp16(view, object, psymval, addend, address);
2311 break;
2312
2313 case elfcpp::R_SPARC_HI22:
2314 Reloc::hi22(view, object, psymval, addend);
2315 break;
2316
2317 case elfcpp::R_SPARC_22:
2318 Reloc::rela32_22(view, object, psymval, addend);
2319 break;
2320
2321 case elfcpp::R_SPARC_13:
2322 Reloc::rela32_13(view, object, psymval, addend);
2323 break;
2324
2325 case elfcpp::R_SPARC_LO10:
2326 Reloc::lo10(view, object, psymval, addend);
2327 break;
2328
2329 case elfcpp::R_SPARC_GOT10:
2330 Reloc::lo10(view, got_offset, addend);
2331 break;
2332
2333 case elfcpp::R_SPARC_GOT13:
2334 Reloc::rela32_13(view, got_offset, addend);
2335 break;
2336
2337 case elfcpp::R_SPARC_GOT22:
2338 Reloc::hi22(view, got_offset, addend);
2339 break;
2340
2341 case elfcpp::R_SPARC_PC10:
2342 Reloc::pc10(view, object, psymval, addend, address);
2343 break;
2344
2345 case elfcpp::R_SPARC_PC22:
2346 Reloc::pc22(view, object, psymval, addend, address);
2347 break;
2348
2349 case elfcpp::R_SPARC_TLS_DTPOFF32:
2350 case elfcpp::R_SPARC_UA32:
2351 Reloc::ua32(view, object, psymval, addend);
2352 break;
2353
2354 case elfcpp::R_SPARC_PLT64:
2355 Relocate_functions<size, big_endian>::rela64(view, object,
2356 psymval, addend);
2357 break;
2358
2359 case elfcpp::R_SPARC_PLT32:
2360 Relocate_functions<size, big_endian>::rela32(view, object,
2361 psymval, addend);
2362 break;
2363
2364 case elfcpp::R_SPARC_HIPLT22:
2365 Reloc::hi22(view, object, psymval, addend);
2366 break;
2367
2368 case elfcpp::R_SPARC_LOPLT10:
2369 Reloc::lo10(view, object, psymval, addend);
2370 break;
2371
2372 case elfcpp::R_SPARC_PCPLT32:
2373 Reloc::disp32(view, object, psymval, addend, address);
2374 break;
2375
2376 case elfcpp::R_SPARC_PCPLT22:
2377 Reloc::pcplt22(view, object, psymval, addend, address);
2378 break;
2379
2380 case elfcpp::R_SPARC_PCPLT10:
2381 Reloc::lo10(view, object, psymval, addend, address);
2382 break;
2383
2384 case elfcpp::R_SPARC_64:
2385 if (!parameters->options().output_is_position_independent())
2386 Relocate_functions<size, big_endian>::rela64(view, object,
2387 psymval, addend);
2388 break;
2389
2390 case elfcpp::R_SPARC_OLO10:
2391 {
2392 unsigned int addend2 = rela.get_r_info() & 0xffffffff;
2393 addend2 = ((addend2 >> 8) ^ 0x800000) - 0x800000;
2394 Reloc::olo10(view, object, psymval, addend, addend2);
2395 }
2396 break;
2397
2398 case elfcpp::R_SPARC_HH22:
2399 Reloc::hh22(view, object, psymval, addend);
2400 break;
2401
2402 case elfcpp::R_SPARC_PC_HH22:
2403 Reloc::pc_hh22(view, object, psymval, addend, address);
2404 break;
2405
2406 case elfcpp::R_SPARC_HM10:
2407 Reloc::hm10(view, object, psymval, addend);
2408 break;
2409
2410 case elfcpp::R_SPARC_PC_HM10:
2411 Reloc::pc_hm10(view, object, psymval, addend, address);
2412 break;
2413
2414 case elfcpp::R_SPARC_LM22:
2415 Reloc::hi22(view, object, psymval, addend);
2416 break;
2417
2418 case elfcpp::R_SPARC_PC_LM22:
2419 Reloc::pcplt22(view, object, psymval, addend, address);
2420 break;
2421
2422 case elfcpp::R_SPARC_11:
2423 Reloc::rela32_11(view, object, psymval, addend);
2424 break;
2425
2426 case elfcpp::R_SPARC_10:
2427 Reloc::rela32_10(view, object, psymval, addend);
2428 break;
2429
2430 case elfcpp::R_SPARC_7:
2431 Reloc::rela32_7(view, object, psymval, addend);
2432 break;
2433
2434 case elfcpp::R_SPARC_6:
2435 Reloc::rela32_6(view, object, psymval, addend);
2436 break;
2437
2438 case elfcpp::R_SPARC_5:
2439 Reloc::rela32_5(view, object, psymval, addend);
2440 break;
2441
2442 case elfcpp::R_SPARC_HIX22:
2443 Reloc::hix22(view, object, psymval, addend);
2444 break;
2445
2446 case elfcpp::R_SPARC_LOX10:
2447 Reloc::lox10(view, object, psymval, addend);
2448 break;
2449
2450 case elfcpp::R_SPARC_H44:
2451 Reloc::h44(view, object, psymval, addend);
2452 break;
2453
2454 case elfcpp::R_SPARC_M44:
2455 Reloc::m44(view, object, psymval, addend);
2456 break;
2457
2458 case elfcpp::R_SPARC_L44:
2459 Reloc::l44(view, object, psymval, addend);
2460 break;
2461
2462 case elfcpp::R_SPARC_TLS_DTPOFF64:
2463 case elfcpp::R_SPARC_UA64:
2464 Reloc::ua64(view, object, psymval, addend);
2465 break;
2466
2467 case elfcpp::R_SPARC_UA16:
2468 Reloc::ua16(view, object, psymval, addend);
2469 break;
2470
2471 case elfcpp::R_SPARC_TLS_GD_HI22:
2472 case elfcpp::R_SPARC_TLS_GD_LO10:
2473 case elfcpp::R_SPARC_TLS_GD_ADD:
2474 case elfcpp::R_SPARC_TLS_GD_CALL:
2475 case elfcpp::R_SPARC_TLS_LDM_HI22:
2476 case elfcpp::R_SPARC_TLS_LDM_LO10:
2477 case elfcpp::R_SPARC_TLS_LDM_ADD:
2478 case elfcpp::R_SPARC_TLS_LDM_CALL:
2479 case elfcpp::R_SPARC_TLS_LDO_HIX22:
2480 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2481 case elfcpp::R_SPARC_TLS_LDO_ADD:
2482 case elfcpp::R_SPARC_TLS_IE_HI22:
2483 case elfcpp::R_SPARC_TLS_IE_LO10:
2484 case elfcpp::R_SPARC_TLS_IE_LD:
2485 case elfcpp::R_SPARC_TLS_IE_LDX:
2486 case elfcpp::R_SPARC_TLS_LE_HIX22:
2487 case elfcpp::R_SPARC_TLS_LE_LOX10:
2488 this->relocate_tls(relinfo, target, relnum, rela,
2489 r_type, gsym, psymval, view,
2490 address, view_size);
2491 break;
2492
2493 case elfcpp::R_SPARC_COPY:
2494 case elfcpp::R_SPARC_GLOB_DAT:
2495 case elfcpp::R_SPARC_JMP_SLOT:
2496 case elfcpp::R_SPARC_RELATIVE:
2497 // These are outstanding tls relocs, which are unexpected when
2498 // linking.
2499 case elfcpp::R_SPARC_TLS_DTPMOD64:
2500 case elfcpp::R_SPARC_TLS_DTPMOD32:
2501 case elfcpp::R_SPARC_TLS_TPOFF64:
2502 case elfcpp::R_SPARC_TLS_TPOFF32:
2503 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2504 _("unexpected reloc %u in object file"),
2505 r_type);
2506 break;
2507
2508 default:
2509 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2510 _("unsupported reloc %u"),
2511 r_type);
2512 break;
2513 }
2514
2515 return true;
2516}
2517
2518// Perform a TLS relocation.
2519
2520template<int size, bool big_endian>
2521inline void
2522Target_sparc<size, big_endian>::Relocate::relocate_tls(
2523 const Relocate_info<size, big_endian>* relinfo,
2524 Target_sparc<size, big_endian>* target,
2525 size_t relnum,
2526 const elfcpp::Rela<size, big_endian>& rela,
2527 unsigned int r_type,
2528 const Sized_symbol<size>* gsym,
2529 const Symbol_value<size>* psymval,
2530 unsigned char* view,
2531 typename elfcpp::Elf_types<size>::Elf_Addr address,
2532 section_size_type)
2533{
2534 Output_segment* tls_segment = relinfo->layout->tls_segment();
2535 typedef Sparc_relocate_functions<size, big_endian> Reloc;
2536 const Sized_relobj<size, big_endian>* object = relinfo->object;
2537 typedef typename elfcpp::Swap<32, true>::Valtype Insntype;
2538
2539 const elfcpp::Elf_Xword addend = rela.get_r_addend();
2540 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0);
2541
2542 const bool is_final =
2543 (gsym == NULL
2544 ? !parameters->options().output_is_position_independent()
2545 : gsym->final_value_is_known());
2546 const tls::Tls_optimization optimized_type
2547 = optimize_tls_reloc(is_final, r_type);
2548
2549 switch (r_type)
2550 {
2551 case elfcpp::R_SPARC_TLS_GD_HI22:
2552 case elfcpp::R_SPARC_TLS_GD_LO10:
2553 case elfcpp::R_SPARC_TLS_GD_ADD:
2554 case elfcpp::R_SPARC_TLS_GD_CALL:
2555 if (optimized_type == tls::TLSOPT_TO_LE)
2556 {
2557 Insntype* wv = reinterpret_cast<Insntype*>(view);
2558 Insntype val;
2559
2560 value -= tls_segment->memsz();
2561
2562 switch (r_type)
2563 {
2564 case elfcpp::R_SPARC_TLS_GD_HI22:
2565 // TLS_GD_HI22 --> TLS_LE_HIX22
2566 Reloc::hix22(view, value, addend);
2567 break;
2568
2569 case elfcpp::R_SPARC_TLS_GD_LO10:
2570 // TLS_GD_LO10 --> TLS_LE_LOX10
2571 Reloc::lox10(view, value, addend);
2572 break;
2573
2574 case elfcpp::R_SPARC_TLS_GD_ADD:
2575 // add %reg1, %reg2, %reg3 --> mov %g7, %reg2, %reg3
2576 val = elfcpp::Swap<32, true>::readval(wv);
2577 val = (val & ~0x7c000) | 0x1c000;
2578 elfcpp::Swap<32, true>::writeval(wv, val);
2579 break;
2580 case elfcpp::R_SPARC_TLS_GD_CALL:
2581 // call __tls_get_addr --> nop
2582 elfcpp::Swap<32, true>::writeval(wv, sparc_nop);
2583 break;
2584 }
2585 break;
2586 }
2587 else
2588 {
2589 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2590 ? GOT_TYPE_TLS_OFFSET
2591 : GOT_TYPE_TLS_PAIR);
2592 if (gsym != NULL)
2593 {
2594 gold_assert(gsym->has_got_offset(got_type));
2595 value = gsym->got_offset(got_type);
2596 }
2597 else
2598 {
2599 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2600 gold_assert(object->local_has_got_offset(r_sym, got_type));
2601 value = object->local_got_offset(r_sym, got_type);
2602 }
2603 if (optimized_type == tls::TLSOPT_TO_IE)
2604 {
2605 Insntype* wv = reinterpret_cast<Insntype*>(view);
2606 Insntype val;
2607
2608 switch (r_type)
2609 {
2610 case elfcpp::R_SPARC_TLS_GD_HI22:
2611 // TLS_GD_HI22 --> TLS_IE_HI22
2612 Reloc::hi22(view, value, addend);
2613 break;
2614
2615 case elfcpp::R_SPARC_TLS_GD_LO10:
2616 // TLS_GD_LO10 --> TLS_IE_LO10
2617 Reloc::lo10(view, value, addend);
2618 break;
2619
2620 case elfcpp::R_SPARC_TLS_GD_ADD:
2621 // add %reg1, %reg2, %reg3 --> ld [%reg1 + %reg2], %reg3
2622 val = elfcpp::Swap<32, true>::readval(wv);
2623
2624 if (size == 64)
2625 val |= 0xc0580000;
2626 else
2627 val |= 0xc0000000;
2628
2629 elfcpp::Swap<32, true>::writeval(wv, val);
2630 break;
2631
2632 case elfcpp::R_SPARC_TLS_GD_CALL:
2633 // The compiler can put the TLS_GD_ADD instruction
2634 // into the delay slot of the call. If so, we need
2635 // to transpose the two instructions so that the
2636 // the new sequence works properly.
2637 //
2638 // The test we use is if the instruction in the
2639 // delay slot is an add with destination register
2640 // equal to %o0
2641 val = elfcpp::Swap<32, true>::readval(wv + 1);
2642 if ((val & 0x81f80000) == 0x80000000
2643 && ((val >> 25) & 0x1f) == 0x8)
2644 {
2645 if (size == 64)
2646 val |= 0xc0580000;
2647 else
2648 val |= 0xc0000000;
2649
2650 elfcpp::Swap<32, true>::writeval(wv, val);
2651
2652 wv += 1;
2653 this->ignore_gd_add_ = true;
2654 }
2655
2656 // call __tls_get_addr --> add %g7, %o0, %o0
2657 elfcpp::Swap<32, true>::writeval(wv, 0x9001c008);
2658 break;
2659 }
2660 break;
2661 }
2662 else if (optimized_type == tls::TLSOPT_NONE)
2663 {
2664 switch (r_type)
2665 {
2666 case elfcpp::R_SPARC_TLS_GD_HI22:
2667 Reloc::hi22(view, value, addend);
2668 break;
2669 case elfcpp::R_SPARC_TLS_GD_LO10:
2670 Reloc::lo10(view, value, addend);
2671 break;
2672 case elfcpp::R_SPARC_TLS_GD_ADD:
2673 break;
2674 case elfcpp::R_SPARC_TLS_GD_CALL:
2675 {
2676 Symbol_value<size> symval;
2677 elfcpp::Elf_Xword value;
2678 Symbol* tsym;
2679
2680 tsym = target->tls_get_addr_sym_;
2681 gold_assert(tsym);
2682 value = (target->plt_section()->address() +
2683 tsym->plt_offset());
2684 symval.set_output_value(value);
2685 Reloc::wdisp30(view, object, &symval, addend, address);
2686 }
2687 break;
2688 }
2689 break;
2690 }
2691 }
2692 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2693 _("unsupported reloc %u"),
2694 r_type);
2695 break;
2696
2697 case elfcpp::R_SPARC_TLS_LDM_HI22:
2698 case elfcpp::R_SPARC_TLS_LDM_LO10:
2699 case elfcpp::R_SPARC_TLS_LDM_ADD:
2700 case elfcpp::R_SPARC_TLS_LDM_CALL:
2701 if (optimized_type == tls::TLSOPT_TO_LE)
2702 {
2703 Insntype* wv = reinterpret_cast<Insntype*>(view);
2704
2705 switch (r_type)
2706 {
2707 case elfcpp::R_SPARC_TLS_LDM_HI22:
2708 case elfcpp::R_SPARC_TLS_LDM_LO10:
2709 case elfcpp::R_SPARC_TLS_LDM_ADD:
2710 elfcpp::Swap<32, true>::writeval(wv, sparc_nop);
2711 break;
2712
2713 case elfcpp::R_SPARC_TLS_LDM_CALL:
2714 elfcpp::Swap<32, true>::writeval(wv, sparc_mov_g0_o0);
2715 break;
2716 }
2717 break;
2718 }
2719 else if (optimized_type == tls::TLSOPT_NONE)
2720 {
2721 // Relocate the field with the offset of the GOT entry for
2722 // the module index.
2723 unsigned int got_offset;
2724
2725 got_offset = target->got_mod_index_entry(NULL, NULL, NULL);
2726 switch (r_type)
2727 {
2728 case elfcpp::R_SPARC_TLS_LDM_HI22:
2729 Reloc::hi22(view, got_offset, addend);
2730 break;
2731 case elfcpp::R_SPARC_TLS_LDM_LO10:
2732 Reloc::lo10(view, got_offset, addend);
2733 break;
2734 case elfcpp::R_SPARC_TLS_LDM_ADD:
2735 break;
2736 case elfcpp::R_SPARC_TLS_LDM_CALL:
2737 {
2738 Symbol_value<size> symval;
2739 elfcpp::Elf_Xword value;
2740 Symbol* tsym;
2741
2742 tsym = target->tls_get_addr_sym_;
2743 gold_assert(tsym);
2744 value = (target->plt_section()->address() +
2745 tsym->plt_offset());
2746 symval.set_output_value(value);
2747 Reloc::wdisp30(view, object, &symval, addend, address);
2748 }
2749 break;
2750 }
2751 break;
2752 }
2753 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2754 _("unsupported reloc %u"),
2755 r_type);
2756 break;
2757
2758 // These relocs can appear in debugging sections, in which case
2759 // we won't see the TLS_LDM relocs. The local_dynamic_type
2760 // field tells us this.
2761 case elfcpp::R_SPARC_TLS_LDO_HIX22:
2762 if (optimized_type == tls::TLSOPT_TO_LE)
2763 {
2764 value -= tls_segment->memsz();
2765 Reloc::hix22(view, value, addend);
2766 }
2767 else
2768 Reloc::ldo_hix22(view, value, addend);
2769 break;
2770 case elfcpp::R_SPARC_TLS_LDO_LOX10:
2771 if (optimized_type == tls::TLSOPT_TO_LE)
2772 {
2773 value -= tls_segment->memsz();
2774 Reloc::lox10(view, value, addend);
2775 }
2776 else
2777 Reloc::ldo_lox10(view, value, addend);
2778 break;
2779 case elfcpp::R_SPARC_TLS_LDO_ADD:
2780 if (optimized_type == tls::TLSOPT_TO_LE)
2781 {
2782 Insntype* wv = reinterpret_cast<Insntype*>(view);
2783 Insntype val;
2784
2785 // add %reg1, %reg2, %reg3 --> add %g7, %reg2, %reg3
2786 val = elfcpp::Swap<32, true>::readval(wv);
2787 val = (val & ~0x7c000) | 0x1c000;
2788 elfcpp::Swap<32, true>::writeval(wv, val);
2789 }
2790 break;
2791
2792 // When optimizing IE --> LE, the only relocation that is handled
2793 // differently is R_SPARC_TLS_IE_LD, it is rewritten from
2794 // 'ld{,x} [rs1 + rs2], rd' into 'mov rs2, rd' or simply a NOP is
2795 // rs2 and rd are the same.
2796 case elfcpp::R_SPARC_TLS_IE_LD:
2797 case elfcpp::R_SPARC_TLS_IE_LDX:
2798 if (optimized_type == tls::TLSOPT_TO_LE)
2799 {
2800 Insntype* wv = reinterpret_cast<Insntype*>(view);
2801 Insntype val = elfcpp::Swap<32, true>::readval(wv);
2802 Insntype rs2 = val & 0x1f;
2803 Insntype rd = (val >> 25) & 0x1f;
2804
2805 if (rs2 == rd)
2806 val = sparc_nop;
2807 else
2808 val = sparc_mov | (val & 0x3e00001f);
2809
2810 elfcpp::Swap<32, true>::writeval(wv, val);
2811 }
2812 break;
2813
2814 case elfcpp::R_SPARC_TLS_IE_HI22:
2815 case elfcpp::R_SPARC_TLS_IE_LO10:
2816 if (optimized_type == tls::TLSOPT_TO_LE)
2817 {
2818 value -= tls_segment->memsz();
2819 switch (r_type)
2820 {
2821 case elfcpp::R_SPARC_TLS_IE_HI22:
2822 // IE_HI22 --> LE_HIX22
2823 Reloc::hix22(view, value, addend);
2824 break;
2825 case elfcpp::R_SPARC_TLS_IE_LO10:
2826 // IE_LO10 --> LE_LOX10
2827 Reloc::lox10(view, value, addend);
2828 break;
2829 }
2830 break;
2831 }
2832 else if (optimized_type == tls::TLSOPT_NONE)
2833 {
2834 // Relocate the field with the offset of the GOT entry for
2835 // the tp-relative offset of the symbol.
2836 if (gsym != NULL)
2837 {
2838 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
2839 value = gsym->got_offset(GOT_TYPE_TLS_OFFSET);
2840 }
2841 else
2842 {
2843 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
2844 gold_assert(object->local_has_got_offset(r_sym,
2845 GOT_TYPE_TLS_OFFSET));
2846 value = object->local_got_offset(r_sym,
2847 GOT_TYPE_TLS_OFFSET);
2848 }
2849 switch (r_type)
2850 {
2851 case elfcpp::R_SPARC_TLS_IE_HI22:
2852 Reloc::hi22(view, value, addend);
2853 break;
2854 case elfcpp::R_SPARC_TLS_IE_LO10:
2855 Reloc::lo10(view, value, addend);
2856 break;
2857 }
2858 break;
2859 }
2860 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2861 _("unsupported reloc %u"),
2862 r_type);
2863 break;
2864
2865 case elfcpp::R_SPARC_TLS_LE_HIX22:
2866 // If we're creating a shared library, a dynamic relocation will
2867 // have been created for this location, so do not apply it now.
2868 if (!parameters->options().shared())
2869 {
2870 value -= tls_segment->memsz();
2871 Reloc::hix22(view, value, addend);
2872 }
2873 break;
2874
2875 case elfcpp::R_SPARC_TLS_LE_LOX10:
2876 // If we're creating a shared library, a dynamic relocation will
2877 // have been created for this location, so do not apply it now.
2878 if (!parameters->options().shared())
2879 {
2880 value -= tls_segment->memsz();
2881 Reloc::lox10(view, value, addend);
2882 }
2883 break;
2884 }
2885}
2886
2887// Relocate section data.
2888
2889template<int size, bool big_endian>
2890void
2891Target_sparc<size, big_endian>::relocate_section(
2892 const Relocate_info<size, big_endian>* relinfo,
2893 unsigned int sh_type,
2894 const unsigned char* prelocs,
2895 size_t reloc_count,
2896 Output_section* output_section,
2897 bool needs_special_offset_handling,
2898 unsigned char* view,
2899 typename elfcpp::Elf_types<size>::Elf_Addr address,
2900 section_size_type view_size)
2901{
2902 typedef Target_sparc<size, big_endian> Sparc;
2903 typedef typename Target_sparc<size, big_endian>::Relocate Sparc_relocate;
2904
2905 gold_assert(sh_type == elfcpp::SHT_RELA);
2906
2907 gold::relocate_section<size, big_endian, Sparc, elfcpp::SHT_RELA,
2908 Sparc_relocate>(
2909 relinfo,
2910 this,
2911 prelocs,
2912 reloc_count,
2913 output_section,
2914 needs_special_offset_handling,
2915 view,
2916 address,
2917 view_size);
2918}
2919
2920// Return the size of a relocation while scanning during a relocatable
2921// link.
2922
2923template<int size, bool big_endian>
2924unsigned int
2925Target_sparc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
2926 unsigned int,
2927 Relobj*)
2928{
2929 // We are always SHT_RELA, so we should never get here.
2930 gold_unreachable();
2931 return 0;
2932}
2933
2934// Scan the relocs during a relocatable link.
2935
2936template<int size, bool big_endian>
2937void
2938Target_sparc<size, big_endian>::scan_relocatable_relocs(
2939 const General_options& options,
2940 Symbol_table* symtab,
2941 Layout* layout,
2942 Sized_relobj<size, big_endian>* object,
2943 unsigned int data_shndx,
2944 unsigned int sh_type,
2945 const unsigned char* prelocs,
2946 size_t reloc_count,
2947 Output_section* output_section,
2948 bool needs_special_offset_handling,
2949 size_t local_symbol_count,
2950 const unsigned char* plocal_symbols,
2951 Relocatable_relocs* rr)
2952{
2953 gold_assert(sh_type == elfcpp::SHT_RELA);
2954
2955 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
2956 Relocatable_size_for_reloc> Scan_relocatable_relocs;
2957
2958 gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
2959 Scan_relocatable_relocs>(
2960 options,
2961 symtab,
2962 layout,
2963 object,
2964 data_shndx,
2965 prelocs,
2966 reloc_count,
2967 output_section,
2968 needs_special_offset_handling,
2969 local_symbol_count,
2970 plocal_symbols,
2971 rr);
2972}
2973
2974// Relocate a section during a relocatable link.
2975
2976template<int size, bool big_endian>
2977void
2978Target_sparc<size, big_endian>::relocate_for_relocatable(
2979 const Relocate_info<size, big_endian>* relinfo,
2980 unsigned int sh_type,
2981 const unsigned char* prelocs,
2982 size_t reloc_count,
2983 Output_section* output_section,
2984 off_t offset_in_output_section,
2985 const Relocatable_relocs* rr,
2986 unsigned char* view,
2987 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
2988 section_size_type view_size,
2989 unsigned char* reloc_view,
2990 section_size_type reloc_view_size)
2991{
2992 gold_assert(sh_type == elfcpp::SHT_RELA);
2993
2994 gold::relocate_for_relocatable<size, big_endian, elfcpp::SHT_RELA>(
2995 relinfo,
2996 prelocs,
2997 reloc_count,
2998 output_section,
2999 offset_in_output_section,
3000 rr,
3001 view,
3002 view_address,
3003 view_size,
3004 reloc_view,
3005 reloc_view_size);
3006}
3007
3008// Return the value to use for a dynamic which requires special
3009// treatment. This is how we support equality comparisons of function
3010// pointers across shared library boundaries, as described in the
3011// processor specific ABI supplement.
3012
3013template<int size, bool big_endian>
3014uint64_t
3015Target_sparc<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
3016{
3017 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3018 return this->plt_section()->address() + gsym->plt_offset();
3019}
3020
3021// The selector for sparc object files.
3022
3023template<int size, bool big_endian>
3024class Target_selector_sparc : public Target_selector
3025{
3026public:
3027 Target_selector_sparc()
3028 : Target_selector(elfcpp::EM_NONE, size, big_endian,
3029 (size == 64 ? "elf64-sparc" : "elf32-sparc"))
3030 { }
3031
3032 Target* instantiated_target_;
3033
3034 Target* do_recognize(int machine, int, int)
3035 {
3036 switch (size)
3037 {
3038 case 64:
3039 if (machine != elfcpp::EM_SPARCV9)
3040 return NULL;
3041 break;
3042
3043 case 32:
3044 if (machine != elfcpp::EM_SPARC
3045 && machine != elfcpp::EM_SPARC32PLUS)
3046 return NULL;
3047 break;
3048
3049 default:
3050 return NULL;
3051 }
3052
3053 return do_instantiate_target();
3054 }
3055
3056 Target* do_instantiate_target()
3057 {
3058 if (this->instantiated_target_ == NULL)
3059 this->instantiated_target_ = new Target_sparc<size, big_endian>();
3060 return this->instantiated_target_;
3061 }
3062};
3063
3064Target_selector_sparc<32, true> target_selector_sparc32;
3065Target_selector_sparc<64, true> target_selector_sparc64;
3066
3067} // End anonymous namespace.
GDB Binutils - Deliverables
This page took 0.157422 seconds and 4 git commands to generate.