]> Git Repo - binutils.git/blame - gold/tilegx.cc
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* powerpc.cc (Target_powerpc::symval_for_branch): Don't assert
[binutils.git] / gold / tilegx.cc
CommitLineData
5c0b3823
WL		 1// tilegx.cc -- tilegx target support for gold.
2
0e804863 3// Copyright 2012, 2013 Free Software Foundation, Inc.
5c0b3823
WL		 4// Written by Jiong Wang ([email protected])
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 <cstring>
26
27#include "elfcpp.h"
28#include "dwarf.h"
29#include "parameters.h"
30#include "reloc.h"
31#include "tilegx.h"
32#include "object.h"
33#include "symtab.h"
34#include "layout.h"
35#include "output.h"
36#include "copy-relocs.h"
37#include "target.h"
38#include "target-reloc.h"
39#include "target-select.h"
40#include "tls.h"
41#include "gc.h"
42#include "icf.h"
43
44// the first got entry reserved
45const int32_t TILEGX_GOT_RESERVE_COUNT = 1;
46
47// the first two .got.plt entry reserved
48const int32_t TILEGX_GOTPLT_RESERVE_COUNT = 2;
49
50// 1. for both 64/32 bit mode, the instruction bundle is always 64bit.
51// 2. thus .plt section should always be aligned to 64 bit.
52const int32_t TILEGX_INST_BUNDLE_SIZE = 64;
53
54namespace
55{
56
57using namespace gold;
58
59// A class to handle the PLT data.
60// This is an abstract base class that handles most of the linker details
61// but does not know the actual contents of PLT entries. The derived
62// classes below fill in those details.
63
64template<int size, bool big_endian>
65class Output_data_plt_tilegx : public Output_section_data
66{
67 public:
68 typedef Output_data_reloc<elfcpp::SHT_RELA, true,size, big_endian>
69 Reloc_section;
70
71 Output_data_plt_tilegx(Layout* layout, uint64_t addralign,
72 Output_data_got<size, big_endian>* got,
73 Output_data_space* got_plt,
74 Output_data_space* got_irelative)
75 : Output_section_data(addralign), layout_(layout),
76 irelative_rel_(NULL), got_(got), got_plt_(got_plt),
77 got_irelative_(got_irelative), count_(0),
78 irelative_count_(0), free_list_()
79 { this->init(layout); }
80
81 Output_data_plt_tilegx(Layout* layout, uint64_t plt_entry_size,
82 Output_data_got<size, big_endian>* got,
83 Output_data_space* got_plt,
84 Output_data_space* got_irelative,
85 unsigned int plt_count)
86 : Output_section_data((plt_count + 1) * plt_entry_size,
87 TILEGX_INST_BUNDLE_SIZE, false),
88 layout_(layout), irelative_rel_(NULL), got_(got),
89 got_plt_(got_plt), got_irelative_(got_irelative), count_(plt_count),
90 irelative_count_(0), free_list_()
91 {
92 this->init(layout);
93
94 // Initialize the free list and reserve the first entry.
95 this->free_list_.init((plt_count + 1) * plt_entry_size, false);
96 this->free_list_.remove(0, plt_entry_size);
97 }
98
99 // Initialize the PLT section.
100 void
101 init(Layout* layout);
102
103 // Add an entry to the PLT.
104 void
105 add_entry(Symbol_table*, Layout*, Symbol* gsym);
106
107 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
108 unsigned int
109 add_local_ifunc_entry(Symbol_table*, Layout*,
110 Sized_relobj_file<size, big_endian>*, unsigned int);
111
112 // Add the relocation for a PLT entry.
113 void
114 add_relocation(Symbol_table*, Layout*, Symbol*, unsigned int);
115
116 // Return the .rela.plt section data.
117 Reloc_section*
118 rela_plt()
119 { return this->rel_; }
120
121 // Return where the IRELATIVE relocations should go in the PLT
122 // relocations.
123 Reloc_section*
124 rela_irelative(Symbol_table*, Layout*);
125
126 // Return whether we created a section for IRELATIVE relocations.
127 bool
128 has_irelative_section() const
129 { return this->irelative_rel_ != NULL; }
130
131 // Return the number of PLT entries.
132 unsigned int
133 entry_count() const
134 { return this->count_ + this->irelative_count_; }
135
136 // Return the offset of the first non-reserved PLT entry.
137 unsigned int
138 first_plt_entry_offset()
139 { return this->get_plt_entry_size(); }
140
141 // Return the size of a PLT entry.
142 unsigned int
143 get_plt_entry_size() const
144 { return plt_entry_size; }
145
146 // Reserve a slot in the PLT for an existing symbol in an incremental update.
147 void
148 reserve_slot(unsigned int plt_index)
149 {
150 this->free_list_.remove((plt_index + 1) * this->get_plt_entry_size(),
151 (plt_index + 2) * this->get_plt_entry_size());
152 }
153
154 // Return the PLT address to use for a global symbol.
155 uint64_t
156 address_for_global(const Symbol*);
157
158 // Return the PLT address to use for a local symbol.
159 uint64_t
160 address_for_local(const Relobj*, unsigned int symndx);
161
162 protected:
163 // Fill in the first PLT entry.
164 void
165 fill_first_plt_entry(unsigned char*);
166
167 // Fill in a normal PLT entry. Returns the offset into the entry that
168 // should be the initial GOT slot value.
169 void
170 fill_plt_entry(unsigned char*,
171 typename elfcpp::Elf_types<size>::Elf_Addr,
172 unsigned int,
173 typename elfcpp::Elf_types<size>::Elf_Addr,
174 unsigned int, unsigned int);
175
176 void
177 do_adjust_output_section(Output_section* os);
178
179 // Write to a map file.
180 void
181 do_print_to_mapfile(Mapfile* mapfile) const
182 { mapfile->print_output_data(this, _("** PLT")); }
183
184 private:
185 // Set the final size.
186 void
187 set_final_data_size();
188
189 // Write out the PLT data.
190 void
191 do_write(Output_file*);
192
193 // A pointer to the Layout class, so that we can find the .dynamic
194 // section when we write out the GOT PLT section.
195 Layout* layout_;
196 // The reloc section.
197 Reloc_section* rel_;
198 // The IRELATIVE relocs, if necessary. These must follow the
199 // regular PLT relocations.
200 Reloc_section* irelative_rel_;
201 // The .got section.
202 Output_data_got<size, big_endian>* got_;
203 // The .got.plt section.
204 Output_data_space* got_plt_;
205 // The part of the .got.plt section used for IRELATIVE relocs.
206 Output_data_space* got_irelative_;
207 // The number of PLT entries.
208 unsigned int count_;
209 // Number of PLT entries with R_TILEGX_IRELATIVE relocs. These
210 // follow the regular PLT entries.
211 unsigned int irelative_count_;
212 // List of available regions within the section, for incremental
213 // update links.
214 Free_list free_list_;
215 // The size of an entry in the PLT.
216 static const int plt_entry_size = 40;
217 // The first entry in the PLT.
218 static const unsigned char first_plt_entry[plt_entry_size];
219 // Other entries in the PLT for an executable.
220 static const unsigned char plt_entry[plt_entry_size];
221};
222
223// The tilegx target class.
224// See the ABI at
225// http://www.tilera.com/scm
226// TLS info comes from
227// http://people.redhat.com/drepper/tls.pdf
228
229template<int size, bool big_endian>
230class Target_tilegx : public Sized_target<size, big_endian>
231{
232 public:
233 // TileGX use RELA
234 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>
235 Reloc_section;
236
237 Target_tilegx(const Target::Target_info* info = &tilegx_info)
238 : Sized_target<size, big_endian>(info),
239 got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL),
240 global_offset_table_(NULL), tilegx_dynamic_(NULL), rela_dyn_(NULL),
241 rela_irelative_(NULL), copy_relocs_(elfcpp::R_TILEGX_COPY),
242 dynbss_(NULL), got_mod_index_offset_(-1U),
243 tls_get_addr_sym_defined_(false)
244 { }
245
246 // Scan the relocations to look for symbol adjustments.
247 void
248 gc_process_relocs(Symbol_table* symtab,
249 Layout* layout,
250 Sized_relobj_file<size, big_endian>* object,
251 unsigned int data_shndx,
252 unsigned int sh_type,
253 const unsigned char* prelocs,
254 size_t reloc_count,
255 Output_section* output_section,
256 bool needs_special_offset_handling,
257 size_t local_symbol_count,
258 const unsigned char* plocal_symbols);
259
260 // Scan the relocations to look for symbol adjustments.
261 void
262 scan_relocs(Symbol_table* symtab,
263 Layout* layout,
264 Sized_relobj_file<size, big_endian>* object,
265 unsigned int data_shndx,
266 unsigned int sh_type,
267 const unsigned char* prelocs,
268 size_t reloc_count,
269 Output_section* output_section,
270 bool needs_special_offset_handling,
271 size_t local_symbol_count,
272 const unsigned char* plocal_symbols);
273
274 // Finalize the sections.
275 void
276 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
277
278 // Return the value to use for a dynamic which requires special
279 // treatment.
280 uint64_t
281 do_dynsym_value(const Symbol*) const;
282
283 // Relocate a section.
284 void
285 relocate_section(const Relocate_info<size, big_endian>*,
286 unsigned int sh_type,
287 const unsigned char* prelocs,
288 size_t reloc_count,
289 Output_section* output_section,
290 bool needs_special_offset_handling,
291 unsigned char* view,
292 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
293 section_size_type view_size,
294 const Reloc_symbol_changes*);
295
296 // Scan the relocs during a relocatable link.
297 void
298 scan_relocatable_relocs(Symbol_table* symtab,
299 Layout* layout,
300 Sized_relobj_file<size, big_endian>* object,
301 unsigned int data_shndx,
302 unsigned int sh_type,
303 const unsigned char* prelocs,
304 size_t reloc_count,
305 Output_section* output_section,
306 bool needs_special_offset_handling,
307 size_t local_symbol_count,
308 const unsigned char* plocal_symbols,
309 Relocatable_relocs*);
310
311 // Relocate a section during a relocatable link.
312 void
313 relocate_relocs(
314 const Relocate_info<size, big_endian>*,
315 unsigned int sh_type,
316 const unsigned char* prelocs,
317 size_t reloc_count,
318 Output_section* output_section,
62fe925a 319 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
5c0b3823
WL		 320 const Relocatable_relocs*,
321 unsigned char* view,
322 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
323 section_size_type view_size,
324 unsigned char* reloc_view,
325 section_size_type reloc_view_size);
326
327 // Return whether SYM is defined by the ABI.
328 bool
329 do_is_defined_by_abi(const Symbol* sym) const
330 { return strcmp(sym->name(), "__tls_get_addr") == 0; }
331
332 // define tilegx specific symbols
333 virtual void
334 do_define_standard_symbols(Symbol_table*, Layout*);
335
336 // Return the PLT section.
337 uint64_t
338 do_plt_address_for_global(const Symbol* gsym) const
339 { return this->plt_section()->address_for_global(gsym); }
340
341 uint64_t
342 do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const
343 { return this->plt_section()->address_for_local(relobj, symndx); }
344
345 // This function should be defined in targets that can use relocation
346 // types to determine (implemented in local_reloc_may_be_function_pointer
347 // and global_reloc_may_be_function_pointer)
348 // if a function's pointer is taken. ICF uses this in safe mode to only
349 // fold those functions whose pointer is defintely not taken. For tilegx
350 // pie binaries, safe ICF cannot be done by looking at relocation types.
351 bool
352 do_can_check_for_function_pointers() const
353 { return true; }
354
355 // Return the base for a DW_EH_PE_datarel encoding.
356 uint64_t
357 do_ehframe_datarel_base() const;
358
359 // Return whether there is a GOT section.
360 bool
361 has_got_section() const
362 { return this->got_ != NULL; }
363
364 // Return the size of the GOT section.
365 section_size_type
366 got_size() const
367 {
368 gold_assert(this->got_ != NULL);
369 return this->got_->data_size();
370 }
371
372 // Return the number of entries in the GOT.
373 unsigned int
374 got_entry_count() const
375 {
376 if (this->got_ == NULL)
377 return 0;
378 return this->got_size() / (size / 8);
379 }
380
381 // Return the number of entries in the PLT.
382 unsigned int
383 plt_entry_count() const;
384
385 // Return the offset of the first non-reserved PLT entry.
386 unsigned int
387 first_plt_entry_offset() const;
388
389 // Return the size of each PLT entry.
390 unsigned int
391 plt_entry_size() const;
392
393 // Create the GOT section for an incremental update.
394 Output_data_got_base*
395 init_got_plt_for_update(Symbol_table* symtab,
396 Layout* layout,
397 unsigned int got_count,
398 unsigned int plt_count);
399
400 // Reserve a GOT entry for a local symbol, and regenerate any
401 // necessary dynamic relocations.
402 void
403 reserve_local_got_entry(unsigned int got_index,
404 Sized_relobj<size, big_endian>* obj,
405 unsigned int r_sym,
406 unsigned int got_type);
407
408 // Reserve a GOT entry for a global symbol, and regenerate any
409 // necessary dynamic relocations.
410 void
411 reserve_global_got_entry(unsigned int got_index, Symbol* gsym,
412 unsigned int got_type);
413
414 // Register an existing PLT entry for a global symbol.
415 void
416 register_global_plt_entry(Symbol_table*, Layout*, unsigned int plt_index,
417 Symbol* gsym);
418
419 // Force a COPY relocation for a given symbol.
420 void
421 emit_copy_reloc(Symbol_table*, Symbol*, Output_section*, off_t);
422
423 // Apply an incremental relocation.
424 void
425 apply_relocation(const Relocate_info<size, big_endian>* relinfo,
426 typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
427 unsigned int r_type,
428 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend,
429 const Symbol* gsym,
430 unsigned char* view,
431 typename elfcpp::Elf_types<size>::Elf_Addr address,
432 section_size_type view_size);
433
434 private:
435 // The class which scans relocations.
436 class Scan
437 {
438 public:
439 Scan()
440 : issued_non_pic_error_(false)
441 { }
442
443 static inline int
444 get_reference_flags(unsigned int r_type);
445
446 inline void
447 local(Symbol_table* symtab, Layout* layout, Target_tilegx* target,
448 Sized_relobj_file<size, big_endian>* object,
449 unsigned int data_shndx,
450 Output_section* output_section,
451 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
452 const elfcpp::Sym<size, big_endian>& lsym,
453 bool is_discarded);
454
455 inline void
456 global(Symbol_table* symtab, Layout* layout, Target_tilegx* target,
457 Sized_relobj_file<size, big_endian>* object,
458 unsigned int data_shndx,
459 Output_section* output_section,
460 const elfcpp::Rela<size, big_endian>& reloc, unsigned int r_type,
461 Symbol* gsym);
462
463 inline bool
464 local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
465 Target_tilegx* target,
466 Sized_relobj_file<size, big_endian>* object,
467 unsigned int data_shndx,
468 Output_section* output_section,
469 const elfcpp::Rela<size, big_endian>& reloc,
470 unsigned int r_type,
471 const elfcpp::Sym<size, big_endian>& lsym);
472
473 inline bool
474 global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
475 Target_tilegx* target,
476 Sized_relobj_file<size, big_endian>* object,
477 unsigned int data_shndx,
478 Output_section* output_section,
479 const elfcpp::Rela<size, big_endian>& reloc,
480 unsigned int r_type,
481 Symbol* gsym);
482
483 private:
484 static void
485 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*,
486 unsigned int r_type);
487
488 static void
489 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*,
490 unsigned int r_type, Symbol*);
491
492 void
493 check_non_pic(Relobj*, unsigned int r_type);
494
495 inline bool
496 possible_function_pointer_reloc(unsigned int r_type);
497
498 bool
499 reloc_needs_plt_for_ifunc(Sized_relobj_file<size, big_endian>*,
500 unsigned int r_type);
501
502 // Whether we have issued an error about a non-PIC compilation.
503 bool issued_non_pic_error_;
504 };
505
506 // The class which implements relocation.
507 class Relocate
508 {
509 public:
510 Relocate()
511 { }
512
513 ~Relocate()
514 {
515 }
516
517 // Do a relocation. Return false if the caller should not issue
518 // any warnings about this relocation.
519 inline bool
520 relocate(const Relocate_info<size, big_endian>*, Target_tilegx*,
521 Output_section*,
522 size_t relnum, const elfcpp::Rela<size, big_endian>&,
523 unsigned int r_type, const Sized_symbol<size>*,
524 const Symbol_value<size>*,
525 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr,
526 section_size_type);
527 };
528
529 // A class which returns the size required for a relocation type,
530 // used while scanning relocs during a relocatable link.
531 class Relocatable_size_for_reloc
532 {
533 public:
534 unsigned int
535 get_size_for_reloc(unsigned int, Relobj*);
536 };
537
538 // Adjust TLS relocation type based on the options and whether this
539 // is a local symbol.
540 static tls::Tls_optimization
541 optimize_tls_reloc(bool is_final, int r_type);
542
543 // Get the GOT section, creating it if necessary.
544 Output_data_got<size, big_endian>*
545 got_section(Symbol_table*, Layout*);
546
547 // Get the GOT PLT section.
548 Output_data_space*
549 got_plt_section() const
550 {
551 gold_assert(this->got_plt_ != NULL);
552 return this->got_plt_;
553 }
554
555 // Create the PLT section.
556 void
557 make_plt_section(Symbol_table* symtab, Layout* layout);
558
559 // Create a PLT entry for a global symbol.
560 void
561 make_plt_entry(Symbol_table*, Layout*, Symbol*);
562
563 // Create a PLT entry for a local STT_GNU_IFUNC symbol.
564 void
565 make_local_ifunc_plt_entry(Symbol_table*, Layout*,
566 Sized_relobj_file<size, big_endian>* relobj,
567 unsigned int local_sym_index);
568
569 // Create a GOT entry for the TLS module index.
570 unsigned int
571 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
572 Sized_relobj_file<size, big_endian>* object);
573
574 // Get the PLT section.
575 Output_data_plt_tilegx<size, big_endian>*
576 plt_section() const
577 {
578 gold_assert(this->plt_ != NULL);
579 return this->plt_;
580 }
581
582 // Get the dynamic reloc section, creating it if necessary.
583 Reloc_section*
584 rela_dyn_section(Layout*);
585
586 // Get the section to use for IRELATIVE relocations.
587 Reloc_section*
588 rela_irelative_section(Layout*);
589
590 // Add a potential copy relocation.
591 void
592 copy_reloc(Symbol_table* symtab, Layout* layout,
593 Sized_relobj_file<size, big_endian>* object,
594 unsigned int shndx, Output_section* output_section,
595 Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
596 {
597 this->copy_relocs_.copy_reloc(symtab, layout,
598 symtab->get_sized_symbol<size>(sym),
599 object, shndx, output_section,
600 reloc, this->rela_dyn_section(layout));
601 }
602
603 // Information about this specific target which we pass to the
604 // general Target structure.
605 static const Target::Target_info tilegx_info;
606
607 // The types of GOT entries needed for this platform.
608 // These values are exposed to the ABI in an incremental link.
609 // Do not renumber existing values without changing the version
610 // number of the .gnu_incremental_inputs section.
611 enum Got_type
612 {
613 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
614 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset
615 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
616 GOT_TYPE_TLS_DESC = 3 // GOT entry for TLS_DESC pair
617 };
618
619 // This type is used as the argument to the target specific
620 // relocation routines. The only target specific reloc is
621 // R_X86_64_TLSDESC against a local symbol.
622 struct Tlsdesc_info
623 {
624 Tlsdesc_info(Sized_relobj_file<size, big_endian>* a_object,
625 unsigned int a_r_sym)
626 : object(a_object), r_sym(a_r_sym)
627 { }
628
629 // The object in which the local symbol is defined.
630 Sized_relobj_file<size, big_endian>* object;
631 // The local symbol index in the object.
632 unsigned int r_sym;
633 };
634
635 // The GOT section.
636 Output_data_got<size, big_endian>* got_;
637 // The PLT section.
638 Output_data_plt_tilegx<size, big_endian>* plt_;
639 // The GOT PLT section.
640 Output_data_space* got_plt_;
641 // The GOT section for IRELATIVE relocations.
642 Output_data_space* got_irelative_;
643 // The _GLOBAL_OFFSET_TABLE_ symbol.
644 Symbol* global_offset_table_;
645 // The _TILEGX_DYNAMIC_ symbol.
646 Symbol* tilegx_dynamic_;
647 // The dynamic reloc section.
648 Reloc_section* rela_dyn_;
649 // The section to use for IRELATIVE relocs.
650 Reloc_section* rela_irelative_;
651 // Relocs saved to avoid a COPY reloc.
652 Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
653 // Space for variables copied with a COPY reloc.
654 Output_data_space* dynbss_;
655 // Offset of the GOT entry for the TLS module index.
656 unsigned int got_mod_index_offset_;
657 // True if the _tls_get_addr symbol has been defined.
658 bool tls_get_addr_sym_defined_;
659};
660
661template<>
662const Target::Target_info Target_tilegx<64, false>::tilegx_info =
663{
664 64, // size
665 false, // is_big_endian
666 elfcpp::EM_TILEGX, // machine_code
667 false, // has_make_symbol
668 false, // has_resolve
669 false, // has_code_fill
670 true, // is_default_stack_executable
671 false, // can_icf_inline_merge_sections
672 '\0', // wrap_char
673 "/lib/ld.so.1", // program interpreter
674 0x10000, // default_text_segment_address
675 0x10000, // abi_pagesize (overridable by -z max-page-size)
676 0x10000, // common_pagesize (overridable by -z common-page-size)
677 false, // isolate_execinstr
678 0, // rosegment_gap
679 elfcpp::SHN_UNDEF, // small_common_shndx
680 elfcpp::SHN_UNDEF, // large_common_shndx
681 0, // small_common_section_flags
682 0, // large_common_section_flags
683 NULL, // attributes_section
684 NULL // attributes_vendor
685};
686
687template<>
688const Target::Target_info Target_tilegx<32, false>::tilegx_info =
689{
690 32, // size
691 false, // is_big_endian
692 elfcpp::EM_TILEGX, // machine_code
693 false, // has_make_symbol
694 false, // has_resolve
695 false, // has_code_fill
696 true, // is_default_stack_executable
697 false, // can_icf_inline_merge_sections
698 '\0', // wrap_char
699 "/lib32/ld.so.1", // program interpreter
700 0x10000, // default_text_segment_address
701 0x10000, // abi_pagesize (overridable by -z max-page-size)
702 0x10000, // common_pagesize (overridable by -z common-page-size)
703 false, // isolate_execinstr
704 0, // rosegment_gap
705 elfcpp::SHN_UNDEF, // small_common_shndx
706 elfcpp::SHN_UNDEF, // large_common_shndx
707 0, // small_common_section_flags
708 0, // large_common_section_flags
709 NULL, // attributes_section
710 NULL // attributes_vendor
711};
712
713template<>
714const Target::Target_info Target_tilegx<64, true>::tilegx_info =
715{
716 64, // size
717 true, // is_big_endian
718 elfcpp::EM_TILEGX, // machine_code
719 false, // has_make_symbol
720 false, // has_resolve
721 false, // has_code_fill
722 true, // is_default_stack_executable
723 false, // can_icf_inline_merge_sections
724 '\0', // wrap_char
725 "/lib/ld.so.1", // program interpreter
726 0x10000, // default_text_segment_address
727 0x10000, // abi_pagesize (overridable by -z max-page-size)
728 0x10000, // common_pagesize (overridable by -z common-page-size)
729 false, // isolate_execinstr
730 0, // rosegment_gap
731 elfcpp::SHN_UNDEF, // small_common_shndx
732 elfcpp::SHN_UNDEF, // large_common_shndx
733 0, // small_common_section_flags
734 0, // large_common_section_flags
735 NULL, // attributes_section
736 NULL // attributes_vendor
737};
738
739template<>
740const Target::Target_info Target_tilegx<32, true>::tilegx_info =
741{
742 32, // size
743 true, // is_big_endian
744 elfcpp::EM_TILEGX, // machine_code
745 false, // has_make_symbol
746 false, // has_resolve
747 false, // has_code_fill
748 true, // is_default_stack_executable
749 false, // can_icf_inline_merge_sections
750 '\0', // wrap_char
751 "/lib32/ld.so.1", // program interpreter
752 0x10000, // default_text_segment_address
753 0x10000, // abi_pagesize (overridable by -z max-page-size)
754 0x10000, // common_pagesize (overridable by -z common-page-size)
755 false, // isolate_execinstr
756 0, // rosegment_gap
757 elfcpp::SHN_UNDEF, // small_common_shndx
758 elfcpp::SHN_UNDEF, // large_common_shndx
759 0, // small_common_section_flags
760 0, // large_common_section_flags
761 NULL, // attributes_section
762 NULL // attributes_vendor
763};
764
765// tilegx relocation handlers
766template<int size, bool big_endian>
767class Tilegx_relocate_functions
768{
769public:
770 // overflow check will be supported later
771 typedef enum
772 {
773 STATUS_OKAY, // No error during relocation.
774 STATUS_OVERFLOW, // Relocation overflow.
775 STATUS_BAD_RELOC // Relocation cannot be applied.
776 } Status;
777
778 struct Tilegx_howto
779 {
780 // right shift operand by this number of bits.
781 unsigned char srshift;
782
62fe925a 783 // the offset to apply relocation.
5c0b3823
WL		 784 unsigned char doffset;
785
786 // set to 1 for pc-relative relocation.
787 unsigned char is_pcrel;
788
789 // size in bits, or 0 if this table entry should be ignored.
790 unsigned char bsize;
791
792 // whether we need to check overflow.
793 unsigned char overflow;
794 };
795
796 static const Tilegx_howto howto[elfcpp::R_TILEGX_NUM];
797
798private:
799
800 // Do a simple rela relocation
801 template<int valsize>
802 static inline void
803 rela(unsigned char* view,
804 const Sized_relobj_file<size, big_endian>* object,
805 const Symbol_value<size>* psymval,
806 typename elfcpp::Swap<size, big_endian>::Valtype addend,
807 elfcpp::Elf_Xword srshift, elfcpp::Elf_Xword doffset,
808 elfcpp::Elf_Xword bitmask)
809 {
810 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
811 Valtype* wv = reinterpret_cast<Valtype*>(view);
812 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
813 Valtype reloc = 0;
814 if (size == 32)
815 reloc = Bits<32>::sign_extend(psymval->value(object, addend)) >> srshift;
816 else
817 reloc = psymval->value(object, addend) >> srshift;
818
819 elfcpp::Elf_Xword dst_mask = bitmask << doffset;
820
821 val &= ~dst_mask;
822 reloc &= bitmask;
823
824 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | (reloc<<doffset));
825 }
826
827 // Do a simple rela relocation
828 template<int valsize>
829 static inline void
830 rela_ua(unsigned char* view,
831 const Sized_relobj_file<size, big_endian>* object,
832 const Symbol_value<size>* psymval,
833 typename elfcpp::Swap<size, big_endian>::Valtype addend,
834 elfcpp::Elf_Xword srshift, elfcpp::Elf_Xword doffset,
835 elfcpp::Elf_Xword bitmask)
836 {
837 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
838 Valtype;
839 unsigned char* wv = view;
840 Valtype val = elfcpp::Swap_unaligned<valsize, big_endian>::readval(wv);
841 Valtype reloc = 0;
842 if (size == 32)
843 reloc = Bits<32>::sign_extend(psymval->value(object, addend)) >> srshift;
844 else
845 reloc = psymval->value(object, addend) >> srshift;
846
847 elfcpp::Elf_Xword dst_mask = bitmask << doffset;
848
849 val &= ~dst_mask;
850 reloc &= bitmask;
851
852 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(wv,
853 val | (reloc<<doffset));
854 }
855
856 template<int valsize>
857 static inline void
858 rela(unsigned char* view,
859 const Sized_relobj_file<size, big_endian>* object,
860 const Symbol_value<size>* psymval,
861 typename elfcpp::Swap<size, big_endian>::Valtype addend,
862 elfcpp::Elf_Xword srshift, elfcpp::Elf_Xword doffset1,
863 elfcpp::Elf_Xword bitmask1, elfcpp::Elf_Xword doffset2,
864 elfcpp::Elf_Xword bitmask2)
865 {
866 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
867 Valtype* wv = reinterpret_cast<Valtype*>(view);
868 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
869 Valtype reloc = 0;
870 if (size == 32)
871 reloc = Bits<32>::sign_extend(psymval->value(object, addend)) >> srshift;
872 else
873 reloc = psymval->value(object, addend) >> srshift;
874
875 elfcpp::Elf_Xword dst_mask = (bitmask1 << doffset1)
876 | (bitmask2 << doffset2);
877 val &= ~dst_mask;
878 reloc = ((reloc & bitmask1) << doffset1)
879 | ((reloc & bitmask2) << doffset2);
880
881 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
882
883 }
884
885 // Do a simple PC relative relocation with a Symbol_value with the
886 // addend in the relocation.
887 template<int valsize>
888 static inline void
889 pcrela(unsigned char* view,
890 const Sized_relobj_file<size, big_endian>* object,
891 const Symbol_value<size>* psymval,
892 typename elfcpp::Swap<size, big_endian>::Valtype addend,
893 typename elfcpp::Elf_types<size>::Elf_Addr address,
894 elfcpp::Elf_Xword srshift, elfcpp::Elf_Xword doffset,
895 elfcpp::Elf_Xword bitmask)
896
897 {
898 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
899 Valtype* wv = reinterpret_cast<Valtype*>(view);
900 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
901 Valtype reloc = 0;
62fe925a 902 if (size == 32)
5c0b3823
WL		 903 reloc = Bits<32>::sign_extend(psymval->value(object, addend) - address)
904 >> srshift;
905 else
906 reloc = (psymval->value(object, addend) - address) >> srshift;
907
908 elfcpp::Elf_Xword dst_mask = bitmask << doffset;
909 val &= ~dst_mask;
910 reloc &= bitmask;
911
912 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | (reloc<<doffset));
913 }
914
915 template<int valsize>
916 static inline void
917 pcrela_ua(unsigned char* view,
918 const Sized_relobj_file<size, big_endian>* object,
919 const Symbol_value<size>* psymval,
920 typename elfcpp::Swap<size, big_endian>::Valtype addend,
921 typename elfcpp::Elf_types<size>::Elf_Addr address,
922 elfcpp::Elf_Xword srshift, elfcpp::Elf_Xword doffset,
923 elfcpp::Elf_Xword bitmask)
924
925 {
926 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
927 Valtype;
928 unsigned char* wv = view;
929 Valtype reloc = 0;
62fe925a 930 if (size == 32)
5c0b3823
WL		 931 reloc = Bits<32>::sign_extend(psymval->value(object, addend) - address)
932 >> srshift;
933 else
934 reloc = (psymval->value(object, addend) - address) >> srshift;
935
936 reloc &= bitmask;
937
938 elfcpp::Swap<valsize, big_endian>::writeval(wv, reloc << doffset);
939 }
940
941 template<int valsize>
942 static inline void
943 pcrela(unsigned char* view,
944 const Sized_relobj_file<size, big_endian>* object,
945 const Symbol_value<size>* psymval,
946 typename elfcpp::Swap<size, big_endian>::Valtype addend,
947 typename elfcpp::Elf_types<size>::Elf_Addr address,
948 elfcpp::Elf_Xword srshift, elfcpp::Elf_Xword doffset1,
949 elfcpp::Elf_Xword bitmask1, elfcpp::Elf_Xword doffset2,
950 elfcpp::Elf_Xword bitmask2)
951
952 {
953 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
954 Valtype* wv = reinterpret_cast<Valtype*>(view);
955 Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv);
956 Valtype reloc = 0;
62fe925a 957 if (size == 32)
5c0b3823
WL		 958 reloc = Bits<32>::sign_extend(psymval->value(object, addend) - address)
959 >> srshift;
960 else
961 reloc = (psymval->value(object, addend) - address) >> srshift;
962
963 elfcpp::Elf_Xword dst_mask = (bitmask1 << doffset1)
964 | (bitmask2 << doffset2);
965 val &= ~dst_mask;
966 reloc = ((reloc & bitmask1) << doffset1)
967 | ((reloc & bitmask2) << doffset2);
968
969 elfcpp::Swap<valsize, big_endian>::writeval(wv, val | reloc);
970 }
971
972 typedef Tilegx_relocate_functions<size, big_endian> This;
973 typedef Relocate_functions<size, big_endian> Base;
974
975public:
976
977 static inline void
978 abs64(unsigned char* view,
979 const Sized_relobj_file<size, big_endian>* object,
980 const Symbol_value<size>* psymval,
981 typename elfcpp::Elf_types<size>::Elf_Addr addend)
982 {
983 This::template rela_ua<64>(view, object, psymval, addend, 0, 0,
984 0xffffffffffffffffllu);
985 }
986
987 static inline void
988 abs32(unsigned char* view,
989 const Sized_relobj_file<size, big_endian>* object,
990 const Symbol_value<size>* psymval,
991 typename elfcpp::Elf_types<size>::Elf_Addr addend)
992 {
993 This::template rela_ua<32>(view, object, psymval, addend, 0, 0,
994 0xffffffff);
995 }
996
997 static inline void
998 abs16(unsigned char* view,
999 const Sized_relobj_file<size, big_endian>* object,
1000 const Symbol_value<size>* psymval,
1001 typename elfcpp::Elf_types<size>::Elf_Addr addend)
1002 {
1003 This::template rela_ua<16>(view, object, psymval, addend, 0, 0,
1004 0xffff);
1005 }
1006
1007 static inline void
1008 pc_abs64(unsigned char* view,
1009 const Sized_relobj_file<size, big_endian>* object,
1010 const Symbol_value<size>* psymval,
1011 typename elfcpp::Elf_types<size>::Elf_Addr addend,
1012 typename elfcpp::Elf_types<size>::Elf_Addr address)
1013 {
1014 This::template pcrela_ua<64>(view, object, psymval, addend, address, 0, 0,
1015 0xffffffffffffffffllu);
1016 }
1017
1018 static inline void
1019 pc_abs32(unsigned char* view,
1020 const Sized_relobj_file<size, big_endian>* object,
1021 const Symbol_value<size>* psymval,
1022 typename elfcpp::Elf_types<size>::Elf_Addr addend,
1023 typename elfcpp::Elf_types<size>::Elf_Addr address)
1024 {
1025 This::template pcrela_ua<32>(view, object, psymval, addend, address, 0, 0,
1026 0xffffffff);
1027 }
1028
1029 static inline void
1030 pc_abs16(unsigned char* view,
1031 const Sized_relobj_file<size, big_endian>* object,
1032 const Symbol_value<size>* psymval,
1033 typename elfcpp::Elf_types<size>::Elf_Addr addend,
1034 typename elfcpp::Elf_types<size>::Elf_Addr address)
1035 {
1036 This::template pcrela_ua<16>(view, object, psymval, addend, address, 0, 0,
1037 0xffff);
1038 }
1039
1040 static inline void
1041 imm_x_general(unsigned char* view,
1042 const Sized_relobj_file<size, big_endian>* object,
1043 const Symbol_value<size>* psymval,
1044 typename elfcpp::Elf_types<size>::Elf_Addr addend,
1045 Tilegx_howto &r_howto)
62fe925a 1046 {
5c0b3823
WL		 1047 This::template rela<64>(view, object, psymval, addend,
1048 (elfcpp::Elf_Xword)(r_howto.srshift),
1049 (elfcpp::Elf_Xword)(r_howto.doffset),
1050 (elfcpp::Elf_Xword)((1 << r_howto.bsize) - 1));
1051 }
1052
1053 static inline void
1054 imm_x_pcrel_general(unsigned char* view,
1055 const Sized_relobj_file<size, big_endian>* object,
1056 const Symbol_value<size>* psymval,
1057 typename elfcpp::Elf_types<size>::Elf_Addr addend,
1058 typename elfcpp::Elf_types<size>::Elf_Addr address,
1059 Tilegx_howto &r_howto)
62fe925a 1060 {
5c0b3823
WL		 1061 This::template pcrela<64>(view, object, psymval, addend, address,
1062 (elfcpp::Elf_Xword)(r_howto.srshift),
1063 (elfcpp::Elf_Xword)(r_howto.doffset),
1064 (elfcpp::Elf_Xword)((1 << r_howto.bsize) - 1));
1065 }
1066
1067 static inline void
1068 imm_x_two_part_general(unsigned char* view,
1069 const Sized_relobj_file<size, big_endian>* object,
1070 const Symbol_value<size>* psymval,
1071 typename elfcpp::Elf_types<size>::Elf_Addr addend,
1072 typename elfcpp::Elf_types<size>::Elf_Addr address,
1073 unsigned int r_type)
62fe925a 1074 {
5c0b3823
WL		 1075
1076 elfcpp::Elf_Xword doffset1 = 0llu;
1077 elfcpp::Elf_Xword doffset2 = 0llu;
1078 elfcpp::Elf_Xword dmask1 = 0llu;
1079 elfcpp::Elf_Xword dmask2 = 0llu;
1080 elfcpp::Elf_Xword rshift = 0llu;
1081 unsigned int pc_rel = 0;
1082
1083 switch (r_type)
1084 {
1085 case elfcpp::R_TILEGX_BROFF_X1:
1086 doffset1 = 31llu;
1087 doffset2 = 37llu;
1088 dmask1 = 0x3fllu;
1089 dmask2 = 0x1ffc0llu;
1090 rshift = 3llu;
1091 pc_rel = 1;
1092 break;
1093 case elfcpp::R_TILEGX_DEST_IMM8_X1:
1094 doffset1 = 31llu;
1095 doffset2 = 43llu;
1096 dmask1 = 0x3fllu;
1097 dmask2 = 0xc0llu;
1098 rshift = 0llu;
1099 break;
1100 }
1101
1102 if (pc_rel)
1103 This::template pcrela<64>(view, object, psymval, addend, address,
1104 rshift, doffset1, dmask1, doffset2, dmask2);
1105 else
1106 This::template rela<64>(view, object, psymval, addend, rshift,
1107 doffset1, dmask1, doffset2, dmask2);
1108
1109 }
1110
1111 static inline void
1112 tls_relax(unsigned char* view, unsigned int r_type,
1113 tls::Tls_optimization opt_t)
62fe925a
RM		 1114 {
1115
5c0b3823
WL		 1116 const uint64_t TILEGX_X_MOVE_R0_R0 = 0x283bf8005107f000llu;
1117 const uint64_t TILEGX_Y_MOVE_R0_R0 = 0xae05f800540bf000llu;
1118 const uint64_t TILEGX_X_LD = 0x286ae80000000000llu;
1119 const uint64_t TILEGX_X_LD4S = 0x286a980000000000llu;
1120 const uint64_t TILEGX_X1_FULL_MASK = 0x3fffffff80000000llu;
1121 const uint64_t TILEGX_X0_RRR_MASK = 0x000000007ffc0000llu;
1122 const uint64_t TILEGX_X1_RRR_MASK = 0x3ffe000000000000llu;
1123 const uint64_t TILEGX_Y0_RRR_MASK = 0x00000000780c0000llu;
1124 const uint64_t TILEGX_Y1_RRR_MASK = 0x3c06000000000000llu;
1125 const uint64_t TILEGX_X0_RRR_SRCB_MASK = 0x000000007ffff000llu;
1126 const uint64_t TILEGX_X1_RRR_SRCB_MASK = 0x3ffff80000000000llu;
1127 const uint64_t TILEGX_Y0_RRR_SRCB_MASK = 0x00000000780ff000llu;
1128 const uint64_t TILEGX_Y1_RRR_SRCB_MASK = 0x3c07f80000000000llu;
1129 const uint64_t TILEGX_X_ADD_R0_R0_TP = 0x2807a800500f5000llu;
1130 const uint64_t TILEGX_Y_ADD_R0_R0_TP = 0x9a13a8002c275000llu;
1131 const uint64_t TILEGX_X_ADDX_R0_R0_TP = 0x2805a800500b5000llu;
1132 const uint64_t TILEGX_Y_ADDX_R0_R0_TP = 0x9a01a8002c035000llu;
1133
1134 const uint64_t R_TILEGX_IMM8_X0_TLS_ADD_MASK =
1135 (TILEGX_X0_RRR_MASK | (0x3Fllu << 12));
1136
1137 const uint64_t R_TILEGX_IMM8_X1_TLS_ADD_MASK =
1138 (TILEGX_X1_RRR_MASK | (0x3Fllu << 43));
1139
1140 const uint64_t R_TILEGX_IMM8_Y0_TLS_ADD_MASK =
1141 (TILEGX_Y0_RRR_MASK | (0x3Fllu << 12));
1142
1143 const uint64_t R_TILEGX_IMM8_Y1_TLS_ADD_MASK =
1144 (TILEGX_Y1_RRR_MASK | (0x3Fllu << 43));
1145
1146 const uint64_t R_TILEGX_IMM8_X0_TLS_ADD_LE_MASK =
1147 (TILEGX_X0_RRR_SRCB_MASK | (0x3Fllu << 6));
1148
1149 const uint64_t R_TILEGX_IMM8_X1_TLS_ADD_LE_MASK =
1150 (TILEGX_X1_RRR_SRCB_MASK | (0x3Fllu << 37));
1151
1152 const uint64_t R_TILEGX_IMM8_Y0_TLS_ADD_LE_MASK =
1153 (TILEGX_Y0_RRR_SRCB_MASK | (0x3Fllu << 6));
1154
1155 const uint64_t R_TILEGX_IMM8_Y1_TLS_ADD_LE_MASK =
1156 (TILEGX_Y1_RRR_SRCB_MASK | (0x3Fllu << 37));
1157
1158 typedef typename elfcpp::Swap<64, big_endian>::Valtype Valtype;
1159 Valtype* wv = reinterpret_cast<Valtype*>(view);
1160 Valtype val = elfcpp::Swap<64, big_endian>::readval(wv);
1161 Valtype reloc = 0;
1162
1163 switch (r_type)
1164 {
1165 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
1166 if (opt_t == tls::TLSOPT_NONE) {
1167 // GD/IE: 1. copy dest operand into the second source operand
1168 // 2. change the opcode to "add"
1169 reloc = (val & 0x3Fllu) << 12; // featch the dest reg
1170 reloc |= ((size == 32
1171 ? TILEGX_X_ADDX_R0_R0_TP
1172 : TILEGX_X_ADD_R0_R0_TP)
1173 & TILEGX_X0_RRR_MASK); // change opcode
1174 val &= ~R_TILEGX_IMM8_X0_TLS_ADD_MASK;
1175 } else if (opt_t == tls::TLSOPT_TO_LE) {
1176 // LE: 1. copy dest operand into the first source operand
1177 // 2. change the opcode to "move"
1178 reloc = (val & 0x3Fllu) << 6;
62fe925a 1179 reloc |= (TILEGX_X_MOVE_R0_R0 & TILEGX_X0_RRR_SRCB_MASK);
5c0b3823
WL		 1180 val &= ~R_TILEGX_IMM8_X0_TLS_ADD_LE_MASK;
1181 } else
1182 gold_unreachable();
1183 break;
1184 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
1185 if (opt_t == tls::TLSOPT_NONE) {
1186 reloc = (val & (0x3Fllu << 31)) << 12;
1187 reloc |= ((size == 32
1188 ? TILEGX_X_ADDX_R0_R0_TP
1189 : TILEGX_X_ADD_R0_R0_TP)
1190 & TILEGX_X1_RRR_MASK);
1191 val &= ~R_TILEGX_IMM8_X1_TLS_ADD_MASK;
1192 } else if (opt_t == tls::TLSOPT_TO_LE) {
1193 reloc = (val & (0x3Fllu << 31)) << 6;
1194 reloc |= (TILEGX_X_MOVE_R0_R0 & TILEGX_X1_RRR_SRCB_MASK);
1195 val &= ~R_TILEGX_IMM8_X1_TLS_ADD_LE_MASK;
1196 } else
1197 gold_unreachable();
1198 break;
1199 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
1200 if (opt_t == tls::TLSOPT_NONE) {
1201 reloc = (val & 0x3Fllu) << 12;
1202 reloc |= ((size == 32
1203 ? TILEGX_Y_ADDX_R0_R0_TP
1204 : TILEGX_Y_ADD_R0_R0_TP)
1205 & TILEGX_Y0_RRR_MASK);
1206 val &= ~R_TILEGX_IMM8_Y0_TLS_ADD_MASK;
1207 } else if (opt_t == tls::TLSOPT_TO_LE) {
1208 reloc = (val & 0x3Fllu) << 6;
1209 reloc |= (TILEGX_Y_MOVE_R0_R0 & TILEGX_Y0_RRR_SRCB_MASK);
1210 val &= ~R_TILEGX_IMM8_Y0_TLS_ADD_LE_MASK;
1211 } else
1212 gold_unreachable();
1213 break;
1214 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
1215 if (opt_t == tls::TLSOPT_NONE) {
1216 reloc = (val & (0x3Fllu << 31)) << 12;
1217 reloc |= ((size == 32
1218 ? TILEGX_Y_ADDX_R0_R0_TP
1219 : TILEGX_Y_ADD_R0_R0_TP)
1220 & TILEGX_Y1_RRR_MASK);
1221 val &= ~R_TILEGX_IMM8_Y1_TLS_ADD_MASK;
1222 } else if (opt_t == tls::TLSOPT_TO_LE) {
1223 reloc = (val & (0x3Fllu << 31)) << 6;
1224 reloc |= (TILEGX_Y_MOVE_R0_R0 & TILEGX_Y1_RRR_SRCB_MASK);
1225 val &= ~R_TILEGX_IMM8_Y1_TLS_ADD_LE_MASK;
1226 } else
1227 gold_unreachable();
1228 break;
1229 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
1230 if (opt_t == tls::TLSOPT_NONE) {
62fe925a 1231 // GD see comments for optimize_tls_reloc
5c0b3823
WL		 1232 reloc = TILEGX_X_MOVE_R0_R0 & TILEGX_X0_RRR_SRCB_MASK;
1233 val &= ~TILEGX_X0_RRR_SRCB_MASK;
1234 } else if (opt_t == tls::TLSOPT_TO_IE
1235 || opt_t == tls::TLSOPT_TO_LE) {
1236 // IE/LE
1237 reloc = (size == 32
1238 ? TILEGX_X_ADDX_R0_R0_TP
1239 : TILEGX_X_ADD_R0_R0_TP)
1240 & TILEGX_X0_RRR_SRCB_MASK;
1241 val &= ~TILEGX_X0_RRR_SRCB_MASK;
1242 }
1243 break;
1244 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
1245 if (opt_t == tls::TLSOPT_NONE) {
1246 reloc = TILEGX_X_MOVE_R0_R0 & TILEGX_X1_RRR_SRCB_MASK;
1247 val &= ~TILEGX_X1_RRR_SRCB_MASK;
1248 } else if (opt_t == tls::TLSOPT_TO_IE
1249 || opt_t == tls::TLSOPT_TO_LE) {
1250 reloc = (size == 32
1251 ? TILEGX_X_ADDX_R0_R0_TP
1252 : TILEGX_X_ADD_R0_R0_TP)
1253 & TILEGX_X1_RRR_SRCB_MASK;
1254 val &= ~TILEGX_X1_RRR_SRCB_MASK;
1255 }
1256 break;
1257 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
1258 if (opt_t == tls::TLSOPT_NONE) {
1259 reloc = TILEGX_Y_MOVE_R0_R0 & TILEGX_Y0_RRR_SRCB_MASK;
1260 val &= ~TILEGX_Y0_RRR_SRCB_MASK;
1261 } else if (opt_t == tls::TLSOPT_TO_IE
1262 || opt_t == tls::TLSOPT_TO_LE) {
1263 reloc = (size == 32
1264 ? TILEGX_Y_ADDX_R0_R0_TP
1265 : TILEGX_Y_ADD_R0_R0_TP)
1266 & TILEGX_Y0_RRR_SRCB_MASK;
1267 val &= ~TILEGX_Y0_RRR_SRCB_MASK;
1268 }
1269 break;
1270 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
1271 if (opt_t == tls::TLSOPT_NONE) {
1272 reloc = TILEGX_Y_MOVE_R0_R0 & TILEGX_Y1_RRR_SRCB_MASK;
1273 val &= ~TILEGX_Y1_RRR_SRCB_MASK;
1274 } else if (opt_t == tls::TLSOPT_TO_IE
1275 || opt_t == tls::TLSOPT_TO_LE) {
1276 reloc = (size == 32
1277 ? TILEGX_Y_ADDX_R0_R0_TP
1278 : TILEGX_Y_ADD_R0_R0_TP)
1279 & TILEGX_Y1_RRR_SRCB_MASK;
1280 val &= ~TILEGX_Y1_RRR_SRCB_MASK;
1281 }
1282 break;
1283 case elfcpp::R_TILEGX_TLS_IE_LOAD:
1284 if (opt_t == tls::TLSOPT_NONE) {
1285 // IE
1286 reloc = (size == 32
1287 ? TILEGX_X_LD4S
1288 : TILEGX_X_LD)
1289 & TILEGX_X1_RRR_SRCB_MASK;
1290 val &= ~TILEGX_X1_RRR_SRCB_MASK;
1291 } else if (opt_t == tls::TLSOPT_TO_LE) {
1292 // LE
1293 reloc = TILEGX_X_MOVE_R0_R0 & TILEGX_X1_RRR_SRCB_MASK;
1294 val &= ~TILEGX_X1_RRR_SRCB_MASK;
1295 } else
1296 gold_unreachable();
1297 break;
1298 case elfcpp::R_TILEGX_TLS_GD_CALL:
1299 if (opt_t == tls::TLSOPT_TO_IE) {
1300 // ld/ld4s r0, r0
1301 reloc = (size == 32
1302 ? TILEGX_X_LD4S
1303 : TILEGX_X_LD) & TILEGX_X1_FULL_MASK;
1304 val &= ~TILEGX_X1_FULL_MASK;
1305 } else if (opt_t == tls::TLSOPT_TO_LE) {
1306 // move r0, r0
1307 reloc = TILEGX_X_MOVE_R0_R0 & TILEGX_X1_FULL_MASK;
1308 val &= ~TILEGX_X1_FULL_MASK;
1309 } else
1310 // should be handled in ::relocate
1311 gold_unreachable();
1312 break;
1313 default:
1314 gold_unreachable();
1315 break;
1316 }
1317 elfcpp::Swap<64, big_endian>::writeval(wv, val | reloc);
1318 }
1319};
1320
1321template<>
1322const Tilegx_relocate_functions<64, false>::Tilegx_howto
1323Tilegx_relocate_functions<64, false>::howto[elfcpp::R_TILEGX_NUM] =
1324{
1325 { 0, 0, 0, 0, 0}, // R_TILEGX_NONE
1326 { 0, 0, 0, 64, 0}, // R_TILEGX_64
1327 { 0, 0, 0, 32, 0}, // R_TILEGX_32
1328 { 0, 0, 0, 16, 0}, // R_TILEGX_16
1329 { 0, 0, 0, 8, 0}, // R_TILEGX_8
1330 { 0, 0, 1, 64, 0}, // R_TILEGX_64_PCREL
1331 { 0, 0, 1, 32, 0}, // R_TILEGX_32_PCREL
1332 { 0, 0, 1, 16, 0}, // R_TILEGX_16_PCREL
1333 { 0, 0, 1, 8, 0}, // R_TILEGX_8_PCREL
1334 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0
1335 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1
1336 { 32, 0, 0, 0, 0}, // R_TILEGX_HW2
1337 { 48, 0, 0, 0, 0}, // R_TILEGX_HW3
1338 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0_LAST
1339 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1_LAST
1340 { 32, 0, 0, 0, 0}, // R_TILEGX_HW2_LAST
1341 { 0, 0, 0, 0, 0}, // R_TILEGX_COPY
1342 { 0, 0, 0, 8, 0}, // R_TILEGX_GLOB_DAT
1343 { 0, 0, 0, 0, 0}, // R_TILEGX_JMP_SLOT
1344 { 0, 0, 0, 0, 0}, // R_TILEGX_RELATIVE
1345 { 3, 1, 1, 0, 0}, // R_TILEGX_BROFF_X1
1346 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1
1347 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1_PLT
1348 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X0
1349 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y0
1350 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X1
1351 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y1
1352 { 0, 1, 0, 8, 0}, // R_TILEGX_DEST_IMM8_X1
1353 { 0, 1, 0, 8, 0}, // R_TILEGX_MT_IMM14_X1
1354 { 0, 1, 0, 8, 0}, // R_TILEGX_MF_IMM14_X1
1355 { 0, 1, 0, 8, 0}, // R_TILEGX_MMSTART_X0
1356 { 0, 1, 0, 8, 0}, // R_TILEGX_MMEND_X0
1357 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X0
1358 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X1
1359 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y0
1360 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y1
1361 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0
1362 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0
1363 { 16, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW1
1364 { 16, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW1
1365 { 32, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW2
1366 { 32, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW2
1367 { 48, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW3
1368 { 48, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW3
1369 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST
1370 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST
1371 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST
1372 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST
1373 { 32, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST
1374 { 32, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST
1375 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PCREL
1376 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PCREL
1377 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PCREL
1378 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PCREL
1379 { 32, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PCREL
1380 { 32, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PCREL
1381 { 48, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW3_PCREL
1382 { 48, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW3_PCREL
1383 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PCREL
1384 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PCREL
1385 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PCREL
1386 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PCREL
1387 { 32, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PCREL
1388 { 32, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PCREL
1389 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_GOT
1390 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_GOT
1391 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PLT_PCREL
1392 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PLT_PCREL
1393 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PLT_PCREL
1394 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PLT_PCREL
1395 { 32, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PLT_PCREL
1396 { 32, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PLT_PCREL
1397 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_GOT
1398 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_GOT
1399 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_GOT
1400 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_GOT
1401 { 32, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_GOT
1402 { 32, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_GOT
1403 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_GD
1404 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_GD
1405 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_LE
1406 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_LE
1407 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
1408 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
1409 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
1410 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
1411 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
1412 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
1413 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
1414 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
1415 { 0, 0, 0, 0, 0}, // R_TILEGX_IRELATIVE
1416 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1417 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_IE
1418 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_IE
1419 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
1420 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
1421 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
1422 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
1423 { 32, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
1424 { 32, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
1425 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
1426 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
1427 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
1428 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
1429 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1430 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1431 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD64
1432 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF64
1433 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF64
1434 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD32
1435 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF32
1436 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF32
1437 { 3, 31, 1, 27, 0}, // R_TILEGX_TLS_GD_CALL
1438 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_GD_ADD
1439 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_GD_ADD
1440 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_GD_ADD
1441 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_GD_ADD
1442 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_IE_LOAD
1443 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_ADD
1444 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_ADD
1445 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_ADD
1446 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_ADD
1447 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTINHERIT
1448 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTENTRY
1449};
1450
1451template<>
1452const Tilegx_relocate_functions<32, false>::Tilegx_howto
1453Tilegx_relocate_functions<32, false>::howto[elfcpp::R_TILEGX_NUM] =
1454{
1455 { 0, 0, 0, 0, 0}, // R_TILEGX_NONE
1456 { 0, 0, 0, 64, 0}, // R_TILEGX_64
1457 { 0, 0, 0, 32, 0}, // R_TILEGX_32
1458 { 0, 0, 0, 16, 0}, // R_TILEGX_16
1459 { 0, 0, 0, 8, 0}, // R_TILEGX_8
1460 { 0, 0, 1, 64, 0}, // R_TILEGX_64_PCREL
1461 { 0, 0, 1, 32, 0}, // R_TILEGX_32_PCREL
1462 { 0, 0, 1, 16, 0}, // R_TILEGX_16_PCREL
1463 { 0, 0, 1, 8, 0}, // R_TILEGX_8_PCREL
1464 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0
1465 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1
1466 { 31, 0, 0, 0, 0}, // R_TILEGX_HW2
1467 { 31, 0, 0, 0, 0}, // R_TILEGX_HW3
1468 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0_LAST
1469 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1_LAST
1470 { 31, 0, 0, 0, 0}, // R_TILEGX_HW2_LAST
1471 { 0, 0, 0, 0, 0}, // R_TILEGX_COPY
1472 { 0, 0, 0, 8, 0}, // R_TILEGX_GLOB_DAT
1473 { 0, 0, 0, 0, 0}, // R_TILEGX_JMP_SLOT
1474 { 0, 0, 0, 0, 0}, // R_TILEGX_RELATIVE
1475 { 3, 1, 1, 0, 0}, // R_TILEGX_BROFF_X1
1476 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1
1477 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1_PLT
1478 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X0
1479 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y0
1480 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X1
1481 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y1
1482 { 0, 1, 0, 8, 0}, // R_TILEGX_DEST_IMM8_X1
1483 { 0, 1, 0, 8, 0}, // R_TILEGX_MT_IMM14_X1
1484 { 0, 1, 0, 8, 0}, // R_TILEGX_MF_IMM14_X1
1485 { 0, 1, 0, 8, 0}, // R_TILEGX_MMSTART_X0
1486 { 0, 1, 0, 8, 0}, // R_TILEGX_MMEND_X0
1487 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X0
1488 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X1
1489 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y0
1490 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y1
1491 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0
1492 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0
1493 { 16, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW1
1494 { 16, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW1
1495 { 31, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW2
1496 { 31, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW2
1497 { 31, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW3
1498 { 31, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW3
1499 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST
1500 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST
1501 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST
1502 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST
1503 { 31, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST
1504 { 31, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST
1505 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PCREL
1506 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PCREL
1507 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PCREL
1508 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PCREL
1509 { 31, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PCREL
1510 { 31, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PCREL
1511 { 31, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW3_PCREL
1512 { 31, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW3_PCREL
1513 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PCREL
1514 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PCREL
1515 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PCREL
1516 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PCREL
1517 { 31, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PCREL
1518 { 31, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PCREL
1519 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_GOT
1520 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_GOT
1521 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PLT_PCREL
1522 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PLT_PCREL
1523 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PLT_PCREL
1524 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PLT_PCREL
1525 { 31, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PLT_PCREL
1526 { 31, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PLT_PCREL
1527 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_GOT
1528 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_GOT
1529 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_GOT
1530 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_GOT
1531 { 31, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_GOT
1532 { 31, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_GOT
1533 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_GD
1534 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_GD
1535 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_LE
1536 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_LE
1537 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
1538 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
1539 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
1540 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
1541 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
1542 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
1543 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
1544 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
1545 { 0, 0, 0, 0, 0}, // R_TILEGX_IRELATIVE
1546 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1547 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_IE
1548 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_IE
1549 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
1550 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
1551 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
1552 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
1553 { 31, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
1554 { 31, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
1555 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
1556 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
1557 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
1558 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
1559 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1560 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1561 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD64
1562 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF64
1563 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF64
1564 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD32
1565 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF32
1566 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF32
1567 { 3, 31, 1, 27, 0}, // R_TILEGX_TLS_GD_CALL
1568 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_GD_ADD
1569 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_GD_ADD
1570 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_GD_ADD
1571 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_GD_ADD
1572 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_IE_LOAD
1573 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_ADD
1574 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_ADD
1575 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_ADD
1576 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_ADD
1577 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTINHERIT
1578 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTENTRY
1579};
1580
1581template<>
1582const Tilegx_relocate_functions<64, true>::Tilegx_howto
1583Tilegx_relocate_functions<64, true>::howto[elfcpp::R_TILEGX_NUM] =
1584{
1585 { 0, 0, 0, 0, 0}, // R_TILEGX_NONE
1586 { 0, 0, 0, 64, 0}, // R_TILEGX_64
1587 { 0, 0, 0, 32, 0}, // R_TILEGX_32
1588 { 0, 0, 0, 16, 0}, // R_TILEGX_16
1589 { 0, 0, 0, 8, 0}, // R_TILEGX_8
1590 { 0, 0, 1, 64, 0}, // R_TILEGX_64_PCREL
1591 { 0, 0, 1, 32, 0}, // R_TILEGX_32_PCREL
1592 { 0, 0, 1, 16, 0}, // R_TILEGX_16_PCREL
1593 { 0, 0, 1, 8, 0}, // R_TILEGX_8_PCREL
1594 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0
1595 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1
1596 { 32, 0, 0, 0, 0}, // R_TILEGX_HW2
1597 { 48, 0, 0, 0, 0}, // R_TILEGX_HW3
1598 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0_LAST
1599 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1_LAST
1600 { 32, 0, 0, 0, 0}, // R_TILEGX_HW2_LAST
1601 { 0, 0, 0, 0, 0}, // R_TILEGX_COPY
1602 { 0, 0, 0, 8, 0}, // R_TILEGX_GLOB_DAT
1603 { 0, 0, 0, 0, 0}, // R_TILEGX_JMP_SLOT
1604 { 0, 0, 0, 0, 0}, // R_TILEGX_RELATIVE
1605 { 3, 1, 1, 0, 0}, // R_TILEGX_BROFF_X1
1606 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1
1607 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1_PLT
1608 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X0
1609 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y0
1610 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X1
1611 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y1
1612 { 0, 1, 0, 8, 0}, // R_TILEGX_DEST_IMM8_X1
1613 { 0, 1, 0, 8, 0}, // R_TILEGX_MT_IMM14_X1
1614 { 0, 1, 0, 8, 0}, // R_TILEGX_MF_IMM14_X1
1615 { 0, 1, 0, 8, 0}, // R_TILEGX_MMSTART_X0
1616 { 0, 1, 0, 8, 0}, // R_TILEGX_MMEND_X0
1617 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X0
1618 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X1
1619 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y0
1620 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y1
1621 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0
1622 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0
1623 { 16, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW1
1624 { 16, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW1
1625 { 32, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW2
1626 { 32, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW2
1627 { 48, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW3
1628 { 48, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW3
1629 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST
1630 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST
1631 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST
1632 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST
1633 { 32, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST
1634 { 32, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST
1635 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PCREL
1636 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PCREL
1637 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PCREL
1638 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PCREL
1639 { 32, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PCREL
1640 { 32, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PCREL
1641 { 48, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW3_PCREL
1642 { 48, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW3_PCREL
1643 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PCREL
1644 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PCREL
1645 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PCREL
1646 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PCREL
1647 { 32, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PCREL
1648 { 32, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PCREL
1649 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_GOT
1650 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_GOT
1651 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PLT_PCREL
1652 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PLT_PCREL
1653 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PLT_PCREL
1654 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PLT_PCREL
1655 { 32, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PLT_PCREL
1656 { 32, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PLT_PCREL
1657 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_GOT
1658 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_GOT
1659 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_GOT
1660 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_GOT
1661 { 32, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_GOT
1662 { 32, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_GOT
1663 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_GD
1664 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_GD
1665 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_LE
1666 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_LE
1667 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
1668 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
1669 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
1670 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
1671 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
1672 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
1673 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
1674 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
1675 { 0, 0, 0, 0, 0}, // R_TILEGX_IRELATIVE
1676 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1677 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_IE
1678 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_IE
1679 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
1680 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
1681 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
1682 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
1683 { 32, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
1684 { 32, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
1685 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
1686 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
1687 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
1688 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
1689 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1690 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1691 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD64
1692 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF64
1693 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF64
1694 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD32
1695 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF32
1696 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF32
1697 { 3, 31, 1, 27, 0}, // R_TILEGX_TLS_GD_CALL
1698 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_GD_ADD
1699 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_GD_ADD
1700 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_GD_ADD
1701 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_GD_ADD
1702 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_IE_LOAD
1703 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_ADD
1704 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_ADD
1705 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_ADD
1706 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_ADD
1707 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTINHERIT
1708 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTENTRY
1709};
1710
1711template<>
1712const Tilegx_relocate_functions<32, true>::Tilegx_howto
1713Tilegx_relocate_functions<32, true>::howto[elfcpp::R_TILEGX_NUM] =
1714{
1715 { 0, 0, 0, 0, 0}, // R_TILEGX_NONE
1716 { 0, 0, 0, 64, 0}, // R_TILEGX_64
1717 { 0, 0, 0, 32, 0}, // R_TILEGX_32
1718 { 0, 0, 0, 16, 0}, // R_TILEGX_16
1719 { 0, 0, 0, 8, 0}, // R_TILEGX_8
1720 { 0, 0, 1, 64, 0}, // R_TILEGX_64_PCREL
1721 { 0, 0, 1, 32, 0}, // R_TILEGX_32_PCREL
1722 { 0, 0, 1, 16, 0}, // R_TILEGX_16_PCREL
1723 { 0, 0, 1, 8, 0}, // R_TILEGX_8_PCREL
1724 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0
1725 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1
1726 { 31, 0, 0, 0, 0}, // R_TILEGX_HW2
1727 { 31, 0, 0, 0, 0}, // R_TILEGX_HW3
1728 { 0, 0, 0, 0, 0}, // R_TILEGX_HW0_LAST
1729 { 16, 0, 0, 0, 0}, // R_TILEGX_HW1_LAST
1730 { 31, 0, 0, 0, 0}, // R_TILEGX_HW2_LAST
1731 { 0, 0, 0, 0, 0}, // R_TILEGX_COPY
1732 { 0, 0, 0, 8, 0}, // R_TILEGX_GLOB_DAT
1733 { 0, 0, 0, 0, 0}, // R_TILEGX_JMP_SLOT
1734 { 0, 0, 0, 0, 0}, // R_TILEGX_RELATIVE
1735 { 3, 1, 1, 0, 0}, // R_TILEGX_BROFF_X1
1736 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1
1737 { 3, 31, 1, 27, 0}, // R_TILEGX_JUMPOFF_X1_PLT
1738 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X0
1739 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y0
1740 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_X1
1741 { 0, 1, 0, 8, 0}, // R_TILEGX_IMM8_Y1
1742 { 0, 1, 0, 8, 0}, // R_TILEGX_DEST_IMM8_X1
1743 { 0, 1, 0, 8, 0}, // R_TILEGX_MT_IMM14_X1
1744 { 0, 1, 0, 8, 0}, // R_TILEGX_MF_IMM14_X1
1745 { 0, 1, 0, 8, 0}, // R_TILEGX_MMSTART_X0
1746 { 0, 1, 0, 8, 0}, // R_TILEGX_MMEND_X0
1747 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X0
1748 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_X1
1749 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y0
1750 { 0, 1, 0, 8, 0}, // R_TILEGX_SHAMT_Y1
1751 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0
1752 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0
1753 { 16, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW1
1754 { 16, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW1
1755 { 31, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW2
1756 { 31, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW2
1757 { 31, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW3
1758 { 31, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW3
1759 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST
1760 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST
1761 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST
1762 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST
1763 { 31, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST
1764 { 31, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST
1765 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PCREL
1766 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PCREL
1767 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PCREL
1768 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PCREL
1769 { 31, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PCREL
1770 { 31, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PCREL
1771 { 31, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW3_PCREL
1772 { 31, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW3_PCREL
1773 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PCREL
1774 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PCREL
1775 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PCREL
1776 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PCREL
1777 { 31, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PCREL
1778 { 31, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PCREL
1779 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_GOT
1780 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_GOT
1781 { 0, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW0_PLT_PCREL
1782 { 0, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW0_PLT_PCREL
1783 { 16, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW1_PLT_PCREL
1784 { 16, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW1_PLT_PCREL
1785 { 31, 12, 1, 16, 0}, // R_TILEGX_IMM16_X0_HW2_PLT_PCREL
1786 { 31, 43, 1, 16, 0}, // R_TILEGX_IMM16_X1_HW2_PLT_PCREL
1787 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_GOT
1788 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_GOT
1789 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_GOT
1790 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_GOT
1791 { 31, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_GOT
1792 { 31, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_GOT
1793 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_GD
1794 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_GD
1795 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_LE
1796 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_LE
1797 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
1798 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
1799 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
1800 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
1801 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
1802 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
1803 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
1804 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
1805 { 0, 0, 0, 0, 0}, // R_TILEGX_IRELATIVE
1806 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1807 { 0, 12, 0, 16, 0}, // R_TILEGX_IMM16_X0_HW0_TLS_IE
1808 { 0, 43, 0, 16, 0}, // R_TILEGX_IMM16_X1_HW0_TLS_IE
1809 { 0, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
1810 { 0, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
1811 { 16, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
1812 { 16, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
1813 { 31, 12, 1, 16, 1}, // R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
1814 { 31, 43, 1, 16, 1}, // R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
1815 { 0, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
1816 { 0, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
1817 { 16, 12, 0, 16, 1}, // R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
1818 { 16, 43, 0, 16, 1}, // R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
1819 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1820 { 0, 0, 0, 0, 0}, // R_TILEGX_INVALID
1821 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD64
1822 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF64
1823 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF64
1824 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPMOD32
1825 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_DTPOFF32
1826 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_TPOFF32
1827 { 3, 31, 1, 27, 0}, // R_TILEGX_TLS_GD_CALL
1828 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_GD_ADD
1829 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_GD_ADD
1830 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_GD_ADD
1831 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_GD_ADD
1832 { 0, 0, 0, 0, 0}, // R_TILEGX_TLS_IE_LOAD
1833 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X0_TLS_ADD
1834 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_X1_TLS_ADD
1835 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y0_TLS_ADD
1836 { 0, 0, 0, 0, 0}, // R_TILEGX_IMM8_Y1_TLS_ADD
1837 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTINHERIT
1838 { 0, 0, 0, 0, 0}, // R_TILEGX_GNU_VTENTRY
1839};
1840
1841// Get the GOT section, creating it if necessary.
1842
1843template<int size, bool big_endian>
1844Output_data_got<size, big_endian>*
1845Target_tilegx<size, big_endian>::got_section(Symbol_table* symtab,
1846 Layout* layout)
1847{
1848 if (this->got_ == NULL)
1849 {
1850 gold_assert(symtab != NULL && layout != NULL);
1851
1852 // When using -z now, we can treat .got.plt as a relro section.
1853 // Without -z now, it is modified after program startup by lazy
1854 // PLT relocations.
1855 bool is_got_plt_relro = parameters->options().now();
1856 Output_section_order got_order = (is_got_plt_relro
1857 ? ORDER_RELRO
1858 : ORDER_RELRO_LAST);
1859 Output_section_order got_plt_order = (is_got_plt_relro
1860 ? ORDER_RELRO
1861 : ORDER_NON_RELRO_FIRST);
1862
1863 this->got_ = new Output_data_got<size, big_endian>();
1864
1865 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1866 (elfcpp::SHF_ALLOC
1867 | elfcpp::SHF_WRITE),
1868 this->got_, got_order, true);
1869
1870 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1871 this->global_offset_table_ =
1872 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1873 Symbol_table::PREDEFINED,
1874 this->got_,
1875 0, 0, elfcpp::STT_OBJECT,
1876 elfcpp::STB_LOCAL,
1877 elfcpp::STV_HIDDEN, 0,
1878 false, false);
1879
1880 if (parameters->options().shared()) {
1881 // we need to keep the address of .dynamic section in the
1882 // first got entry for .so
1883 this->tilegx_dynamic_ =
1884 symtab->define_in_output_data("_TILEGX_DYNAMIC_", NULL,
1885 Symbol_table::PREDEFINED,
1886 layout->dynamic_section(),
1887 0, 0, elfcpp::STT_OBJECT,
1888 elfcpp::STB_LOCAL,
1889 elfcpp::STV_HIDDEN, 0,
1890 false, false);
1891
1892 this->got_->add_global(this->tilegx_dynamic_, GOT_TYPE_STANDARD);
62fe925a 1893 } else
5c0b3823
WL		 1894 // for executable, just set the first entry to zero.
1895 this->got_->set_current_data_size(size / 8);
1896
1897 this->got_plt_ = new Output_data_space(size / 8, "** GOT PLT");
1898 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1899 (elfcpp::SHF_ALLOC
1900 | elfcpp::SHF_WRITE),
1901 this->got_plt_, got_plt_order,
1902 is_got_plt_relro);
1903
1904 // The first two entries are reserved.
1905 this->got_plt_->set_current_data_size
1906 (TILEGX_GOTPLT_RESERVE_COUNT * (size / 8));
1907
1908 if (!is_got_plt_relro)
1909 {
1910 // Those bytes can go into the relro segment.
1911 layout->increase_relro(size / 8);
1912 }
1913
1914
1915 // If there are any IRELATIVE relocations, they get GOT entries
1916 // in .got.plt after the jump slot entries.
1917 this->got_irelative_
1918 = new Output_data_space(size / 8, "** GOT IRELATIVE PLT");
1919 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1920 (elfcpp::SHF_ALLOC
1921 | elfcpp::SHF_WRITE),
1922 this->got_irelative_,
1923 got_plt_order, is_got_plt_relro);
1924 }
1925
1926 return this->got_;
1927}
1928
1929// Get the dynamic reloc section, creating it if necessary.
1930
1931template<int size, bool big_endian>
1932typename Target_tilegx<size, big_endian>::Reloc_section*
1933Target_tilegx<size, big_endian>::rela_dyn_section(Layout* layout)
1934{
1935 if (this->rela_dyn_ == NULL)
1936 {
1937 gold_assert(layout != NULL);
1938 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
1939 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1940 elfcpp::SHF_ALLOC, this->rela_dyn_,
1941 ORDER_DYNAMIC_RELOCS, false);
1942 }
1943 return this->rela_dyn_;
1944}
1945
1946// Get the section to use for IRELATIVE relocs, creating it if
1947// necessary. These go in .rela.dyn, but only after all other dynamic
1948// relocations. They need to follow the other dynamic relocations so
1949// that they can refer to global variables initialized by those
1950// relocs.
1951
1952template<int size, bool big_endian>
1953typename Target_tilegx<size, big_endian>::Reloc_section*
1954Target_tilegx<size, big_endian>::rela_irelative_section(Layout* layout)
1955{
1956 if (this->rela_irelative_ == NULL)
1957 {
1958 // Make sure we have already created the dynamic reloc section.
1959 this->rela_dyn_section(layout);
1960 this->rela_irelative_ = new Reloc_section(false);
1961 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1962 elfcpp::SHF_ALLOC, this->rela_irelative_,
1963 ORDER_DYNAMIC_RELOCS, false);
1964 gold_assert(this->rela_dyn_->output_section()
1965 == this->rela_irelative_->output_section());
1966 }
1967 return this->rela_irelative_;
1968}
1969
1970// Initialize the PLT section.
1971
1972template<int size, bool big_endian>
1973void
1974Output_data_plt_tilegx<size, big_endian>::init(Layout* layout)
1975{
1976 this->rel_ = new Reloc_section(false);
1977 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1978 elfcpp::SHF_ALLOC, this->rel_,
1979 ORDER_DYNAMIC_PLT_RELOCS, false);
1980}
1981
1982template<int size, bool big_endian>
1983void
1984Output_data_plt_tilegx<size, big_endian>::do_adjust_output_section(
1985 Output_section* os)
1986{
1987 os->set_entsize(this->get_plt_entry_size());
1988}
1989
1990// Add an entry to the PLT.
1991
1992template<int size, bool big_endian>
1993void
1994Output_data_plt_tilegx<size, big_endian>::add_entry(Symbol_table* symtab,
1995 Layout* layout, Symbol* gsym)
1996{
1997 gold_assert(!gsym->has_plt_offset());
1998
1999 unsigned int plt_index;
2000 off_t plt_offset;
2001 section_offset_type got_offset;
2002
2003 unsigned int* pcount;
2004 unsigned int reserved;
2005 Output_data_space* got;
2006 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2007 && gsym->can_use_relative_reloc(false))
2008 {
2009 pcount = &this->irelative_count_;
2010 reserved = 0;
2011 got = this->got_irelative_;
2012 }
2013 else
2014 {
2015 pcount = &this->count_;
2016 reserved = TILEGX_GOTPLT_RESERVE_COUNT;
2017 got = this->got_plt_;
2018 }
2019
2020 if (!this->is_data_size_valid())
2021 {
2022 plt_index = *pcount;
2023
2024 // TILEGX .plt section layout
62fe925a 2025 //
5c0b3823
WL		 2026 // ----
2027 // plt_header
2028 // ----
2029 // plt stub
2030 // ----
2031 // ...
2032 // ----
62fe925a 2033 //
5c0b3823 2034 // TILEGX .got.plt section layout
62fe925a 2035 //
5c0b3823
WL		 2036 // ----
2037 // reserv1
2038 // ----
2039 // reserv2
2040 // ----
2041 // entries for normal function
2042 // ----
2043 // ...
62fe925a 2044 // ----
5c0b3823
WL		 2045 // entries for ifunc
2046 // ----
2047 // ...
2048 // ----
2049 if (got == this->got_irelative_)
2050 plt_offset = plt_index * this->get_plt_entry_size();
2051 else
2052 plt_offset = (plt_index + 1) * this->get_plt_entry_size();
2053
2054 ++*pcount;
2055
2056 got_offset = (plt_index + reserved) * (size / 8);
2057 gold_assert(got_offset == got->current_data_size());
2058
2059 // Every PLT entry needs a GOT entry which points back to the PLT
2060 // entry (this will be changed by the dynamic linker, normally
2061 // lazily when the function is called).
2062 got->set_current_data_size(got_offset + size / 8);
2063 }
2064 else
2065 {
2066 // FIXME: This is probably not correct for IRELATIVE relocs.
2067
2068 // For incremental updates, find an available slot.
2069 plt_offset = this->free_list_.allocate(this->get_plt_entry_size(),
2070 this->get_plt_entry_size(), 0);
2071 if (plt_offset == -1)
2072 gold_fallback(_("out of patch space (PLT);"
2073 " relink with --incremental-full"));
2074
2075 // The GOT and PLT entries have a 1-1 correspondance, so the GOT offset
2076 // can be calculated from the PLT index, adjusting for the three
2077 // reserved entries at the beginning of the GOT.
2078 plt_index = plt_offset / this->get_plt_entry_size() - 1;
2079 got_offset = (plt_index + reserved) * (size / 8);
2080 }
2081
2082 gsym->set_plt_offset(plt_offset);
2083
2084 // Every PLT entry needs a reloc.
2085 this->add_relocation(symtab, layout, gsym, got_offset);
2086
2087 // Note that we don't need to save the symbol. The contents of the
2088 // PLT are independent of which symbols are used. The symbols only
2089 // appear in the relocations.
2090}
2091
2092// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return
2093// the PLT offset.
2094
2095template<int size, bool big_endian>
2096unsigned int
2097Output_data_plt_tilegx<size, big_endian>::add_local_ifunc_entry(
2098 Symbol_table* symtab,
2099 Layout* layout,
2100 Sized_relobj_file<size, big_endian>* relobj,
2101 unsigned int local_sym_index)
2102{
2103 unsigned int plt_offset =
2104 this->irelative_count_ * this->get_plt_entry_size();
2105 ++this->irelative_count_;
2106
2107 section_offset_type got_offset = this->got_irelative_->current_data_size();
2108
2109 // Every PLT entry needs a GOT entry which points back to the PLT
2110 // entry.
2111 this->got_irelative_->set_current_data_size(got_offset + size / 8);
2112
2113 // Every PLT entry needs a reloc.
2114 Reloc_section* rela = this->rela_irelative(symtab, layout);
2115 rela->add_symbolless_local_addend(relobj, local_sym_index,
2116 elfcpp::R_TILEGX_IRELATIVE,
2117 this->got_irelative_, got_offset, 0);
2118
2119 return plt_offset;
2120}
2121
2122// Add the relocation for a PLT entry.
2123
2124template<int size, bool big_endian>
2125void
2126Output_data_plt_tilegx<size, big_endian>::add_relocation(Symbol_table* symtab,
2127 Layout* layout,
2128 Symbol* gsym,
2129 unsigned int got_offset)
2130{
2131 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2132 && gsym->can_use_relative_reloc(false))
2133 {
2134 Reloc_section* rela = this->rela_irelative(symtab, layout);
2135 rela->add_symbolless_global_addend(gsym, elfcpp::R_TILEGX_IRELATIVE,
2136 this->got_irelative_, got_offset, 0);
2137 }
2138 else
2139 {
2140 gsym->set_needs_dynsym_entry();
2141 this->rel_->add_global(gsym, elfcpp::R_TILEGX_JMP_SLOT, this->got_plt_,
2142 got_offset, 0);
2143 }
2144}
2145
2146// Return where the IRELATIVE relocations should go in the PLT. These
2147// follow the JUMP_SLOT and the TLSDESC relocations.
2148
2149template<int size, bool big_endian>
2150typename Output_data_plt_tilegx<size, big_endian>::Reloc_section*
2151Output_data_plt_tilegx<size, big_endian>::rela_irelative(Symbol_table* symtab,
2152 Layout* layout)
2153{
2154 if (this->irelative_rel_ == NULL)
2155 {
2156 // case we see any later on.
2157 this->irelative_rel_ = new Reloc_section(false);
2158 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
2159 elfcpp::SHF_ALLOC, this->irelative_rel_,
2160 ORDER_DYNAMIC_PLT_RELOCS, false);
2161 gold_assert(this->irelative_rel_->output_section()
2162 == this->rel_->output_section());
2163
2164 if (parameters->doing_static_link())
2165 {
2166 // A statically linked executable will only have a .rela.plt
2167 // section to hold R_TILEGX_IRELATIVE relocs for
2168 // STT_GNU_IFUNC symbols. The library will use these
2169 // symbols to locate the IRELATIVE relocs at program startup
2170 // time.
2171 symtab->define_in_output_data("__rela_iplt_start", NULL,
2172 Symbol_table::PREDEFINED,
2173 this->irelative_rel_, 0, 0,
2174 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
2175 elfcpp::STV_HIDDEN, 0, false, true);
2176 symtab->define_in_output_data("__rela_iplt_end", NULL,
2177 Symbol_table::PREDEFINED,
2178 this->irelative_rel_, 0, 0,
2179 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
2180 elfcpp::STV_HIDDEN, 0, true, true);
2181 }
2182 }
2183 return this->irelative_rel_;
2184}
2185
2186// Return the PLT address to use for a global symbol.
2187
2188template<int size, bool big_endian>
2189uint64_t
2190Output_data_plt_tilegx<size, big_endian>::address_for_global(
2191 const Symbol* gsym)
2192{
2193 uint64_t offset = 0;
2194 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2195 && gsym->can_use_relative_reloc(false))
2196 offset = (this->count_ + 1) * this->get_plt_entry_size();
19fec8c1 2197 return this->address() + offset + gsym->plt_offset();
5c0b3823
WL		 2198}
2199
2200// Return the PLT address to use for a local symbol. These are always
2201// IRELATIVE relocs.
2202
2203template<int size, bool big_endian>
2204uint64_t
19fec8c1
AM		 2205Output_data_plt_tilegx<size, big_endian>::address_for_local(
2206 const Relobj* object,
2207 unsigned int r_sym)
5c0b3823 2208{
19fec8c1
AM		 2209 return (this->address()
2210 + (this->count_ + 1) * this->get_plt_entry_size()
2211 + object->local_plt_offset(r_sym));
5c0b3823
WL		 2212}
2213
2214// Set the final size.
2215template<int size, bool big_endian>
2216void
2217Output_data_plt_tilegx<size, big_endian>::set_final_data_size()
2218{
2219 unsigned int count = this->count_ + this->irelative_count_;
2220 this->set_data_size((count + 1) * this->get_plt_entry_size());
2221}
2222
2223// The first entry in the PLT for an executable.
2224template<>
2225const unsigned char
2226Output_data_plt_tilegx<64, false>::first_plt_entry[plt_entry_size] =
2227{
2228 0x00, 0x30, 0x48, 0x51,
2229 0x6e, 0x43, 0xa0, 0x18, // { ld_add r28, r27, 8 }
2230 0x00, 0x30, 0xbc, 0x35,
2231 0x00, 0x40, 0xde, 0x9e, // { ld r27, r27 }
2232 0xff, 0xaf, 0x30, 0x40,
2233 0x60, 0x73, 0x6a, 0x28, // { info 10 ; jr r27 }
2234 // padding
2235 0x00, 0x00, 0x00, 0x00,
2236 0x00, 0x00, 0x00, 0x00,
2237 0x00, 0x00, 0x00, 0x00,
2238 0x00, 0x00, 0x00, 0x00
2239};
2240
2241template<>
2242const unsigned char
2243Output_data_plt_tilegx<32, false>::first_plt_entry[plt_entry_size] =
2244{
2245 0x00, 0x30, 0x48, 0x51,
2246 0x6e, 0x23, 0x58, 0x18, // { ld4s_add r28, r27, 4 }
2247 0x00, 0x30, 0xbc, 0x35,
2248 0x00, 0x40, 0xde, 0x9c, // { ld4s r27, r27 }
2249 0xff, 0xaf, 0x30, 0x40,
2250 0x60, 0x73, 0x6a, 0x28, // { info 10 ; jr r27 }
2251 // padding
2252 0x00, 0x00, 0x00, 0x00,
2253 0x00, 0x00, 0x00, 0x00,
2254 0x00, 0x00, 0x00, 0x00,
2255 0x00, 0x00, 0x00, 0x00
2256};
2257
2258template<>
2259const unsigned char
2260Output_data_plt_tilegx<64, true>::first_plt_entry[plt_entry_size] =
2261{
2262 0x00, 0x30, 0x48, 0x51,
2263 0x6e, 0x43, 0xa0, 0x18, // { ld_add r28, r27, 8 }
2264 0x00, 0x30, 0xbc, 0x35,
2265 0x00, 0x40, 0xde, 0x9e, // { ld r27, r27 }
2266 0xff, 0xaf, 0x30, 0x40,
2267 0x60, 0x73, 0x6a, 0x28, // { info 10 ; jr r27 }
2268 // padding
2269 0x00, 0x00, 0x00, 0x00,
2270 0x00, 0x00, 0x00, 0x00,
2271 0x00, 0x00, 0x00, 0x00,
2272 0x00, 0x00, 0x00, 0x00
2273};
2274
2275template<>
2276const unsigned char
2277Output_data_plt_tilegx<32, true>::first_plt_entry[plt_entry_size] =
2278{
2279 0x00, 0x30, 0x48, 0x51,
2280 0x6e, 0x23, 0x58, 0x18, // { ld4s_add r28, r27, 4 }
2281 0x00, 0x30, 0xbc, 0x35,
2282 0x00, 0x40, 0xde, 0x9c, // { ld4s r27, r27 }
2283 0xff, 0xaf, 0x30, 0x40,
2284 0x60, 0x73, 0x6a, 0x28, // { info 10 ; jr r27 }
2285 // padding
2286 0x00, 0x00, 0x00, 0x00,
2287 0x00, 0x00, 0x00, 0x00,
2288 0x00, 0x00, 0x00, 0x00,
2289 0x00, 0x00, 0x00, 0x00
2290};
2291
2292template<int size, bool big_endian>
2293void
2294Output_data_plt_tilegx<size, big_endian>::fill_first_plt_entry(
2295 unsigned char* pov)
2296{
2297 memcpy(pov, first_plt_entry, plt_entry_size);
2298}
2299
2300// Subsequent entries in the PLT for an executable.
2301
2302template<>
2303const unsigned char
2304Output_data_plt_tilegx<64, false>::plt_entry[plt_entry_size] =
2305{
2306 0xdc, 0x0f, 0x00, 0x10,
2307 0x0d, 0xf0, 0x6a, 0x28, // { moveli r28, 0 ; lnk r26 }
2308 0xdb, 0x0f, 0x00, 0x10,
2309 0x8e, 0x03, 0x00, 0x38, // { moveli r27, 0 ; shl16insli r28, r28, 0 }
2310 0x9c, 0xc6, 0x0d, 0xd0,
2311 0x6d, 0x03, 0x00, 0x38, // { add r28, r26, r28 ; shl16insli r27, r27, 0 }
2312 0x9b, 0xb6, 0xc5, 0xad,
2313 0xff, 0x57, 0xe0, 0x8e, // { add r27, r26, r27 ; info 10 ; ld r28, r28 }
2314 0xdd, 0x0f, 0x00, 0x70,
2315 0x80, 0x73, 0x6a, 0x28, // { shl16insli r29, zero, 0 ; jr r28 }
2316
2317};
2318
2319template<>
2320const unsigned char
2321Output_data_plt_tilegx<32, false>::plt_entry[plt_entry_size] =
2322{
2323 0xdc, 0x0f, 0x00, 0x10,
2324 0x0d, 0xf0, 0x6a, 0x28, // { moveli r28, 0 ; lnk r26 }
2325 0xdb, 0x0f, 0x00, 0x10,
2326 0x8e, 0x03, 0x00, 0x38, // { moveli r27, 0 ; shl16insli r28, r28, 0 }
2327 0x9c, 0xc6, 0x0d, 0xd0,
2328 0x6d, 0x03, 0x00, 0x38, // { add r28, r26, r28 ; shl16insli r27, r27, 0 }
2329 0x9b, 0xb6, 0xc5, 0xad,
2330 0xff, 0x57, 0xe0, 0x8c, // { add r27, r26, r27 ; info 10 ; ld4s r28, r28 }
2331 0xdd, 0x0f, 0x00, 0x70,
2332 0x80, 0x73, 0x6a, 0x28, // { shl16insli r29, zero, 0 ; jr r28 }
2333};
2334
2335template<>
2336const unsigned char
2337Output_data_plt_tilegx<64, true>::plt_entry[plt_entry_size] =
2338{
2339 0xdc, 0x0f, 0x00, 0x10,
2340 0x0d, 0xf0, 0x6a, 0x28, // { moveli r28, 0 ; lnk r26 }
2341 0xdb, 0x0f, 0x00, 0x10,
2342 0x8e, 0x03, 0x00, 0x38, // { moveli r27, 0 ; shl16insli r28, r28, 0 }
2343 0x9c, 0xc6, 0x0d, 0xd0,
2344 0x6d, 0x03, 0x00, 0x38, // { add r28, r26, r28 ; shl16insli r27, r27, 0 }
2345 0x9b, 0xb6, 0xc5, 0xad,
2346 0xff, 0x57, 0xe0, 0x8e, // { add r27, r26, r27 ; info 10 ; ld r28, r28 }
2347 0xdd, 0x0f, 0x00, 0x70,
2348 0x80, 0x73, 0x6a, 0x28, // { shl16insli r29, zero, 0 ; jr r28 }
2349
2350};
2351
2352template<>
2353const unsigned char
2354Output_data_plt_tilegx<32, true>::plt_entry[plt_entry_size] =
2355{
2356 0xdc, 0x0f, 0x00, 0x10,
2357 0x0d, 0xf0, 0x6a, 0x28, // { moveli r28, 0 ; lnk r26 }
2358 0xdb, 0x0f, 0x00, 0x10,
2359 0x8e, 0x03, 0x00, 0x38, // { moveli r27, 0 ; shl16insli r28, r28, 0 }
2360 0x9c, 0xc6, 0x0d, 0xd0,
2361 0x6d, 0x03, 0x00, 0x38, // { add r28, r26, r28 ; shl16insli r27, r27, 0 }
2362 0x9b, 0xb6, 0xc5, 0xad,
2363 0xff, 0x57, 0xe0, 0x8c, // { add r27, r26, r27 ; info 10 ; ld4s r28, r28 }
2364 0xdd, 0x0f, 0x00, 0x70,
2365 0x80, 0x73, 0x6a, 0x28, // { shl16insli r29, zero, 0 ; jr r28 }
2366};
2367
2368template<int size, bool big_endian>
2369void
2370Output_data_plt_tilegx<size, big_endian>::fill_plt_entry(
2371 unsigned char* pov,
2372 typename elfcpp::Elf_types<size>::Elf_Addr gotplt_base,
2373 unsigned int got_offset,
2374 typename elfcpp::Elf_types<size>::Elf_Addr plt_base,
2375 unsigned int plt_offset, unsigned int plt_index)
2376{
2377
2378 const uint32_t TILEGX_IMM16_MASK = 0xFFFF;
2379 const uint32_t TILEGX_X0_IMM16_BITOFF = 12;
2380 const uint32_t TILEGX_X1_IMM16_BITOFF = 43;
2381
2382 typedef typename elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::Valtype
2383 Valtype;
2384 memcpy(pov, plt_entry, plt_entry_size);
2385
2386 // first bundle in plt stub - x0
2387 Valtype* wv = reinterpret_cast<Valtype*>(pov);
2388 Valtype val = elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::readval(wv);
2389 Valtype reloc =
2390 ((gotplt_base + got_offset) - (plt_base + plt_offset + 8)) >> 16;
2391 elfcpp::Elf_Xword dst_mask =
2392 (elfcpp::Elf_Xword)(TILEGX_IMM16_MASK) << TILEGX_X0_IMM16_BITOFF;
2393 val &= ~dst_mask;
2394 reloc &= TILEGX_IMM16_MASK;
2395 elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::writeval(wv,
2396 val | (reloc<<TILEGX_X0_IMM16_BITOFF));
2397
2398 // second bundle in plt stub - x1
2399 wv = reinterpret_cast<Valtype*>(pov + 8);
2400 val = elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::readval(wv);
2401 reloc = (gotplt_base + got_offset) - (plt_base + plt_offset + 8);
2402 dst_mask = (elfcpp::Elf_Xword)(TILEGX_IMM16_MASK) << TILEGX_X1_IMM16_BITOFF;
2403 val &= ~dst_mask;
2404 reloc &= TILEGX_IMM16_MASK;
2405 elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::writeval(wv,
2406 val | (reloc<<TILEGX_X1_IMM16_BITOFF));
2407
2408 // second bundle in plt stub - x0
2409 wv = reinterpret_cast<Valtype*>(pov + 8);
2410 val = elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::readval(wv);
2411 reloc = (gotplt_base - (plt_base + plt_offset + 8)) >> 16;
2412 dst_mask = (elfcpp::Elf_Xword)(TILEGX_IMM16_MASK) << TILEGX_X0_IMM16_BITOFF;
2413 val &= ~dst_mask;
2414 reloc &= TILEGX_IMM16_MASK;
2415 elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::writeval(wv,
2416 val | (reloc<<TILEGX_X0_IMM16_BITOFF));
2417
2418 // third bundle in plt stub - x1
2419 wv = reinterpret_cast<Valtype*>(pov + 16);
2420 val = elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::readval(wv);
2421 reloc = gotplt_base - (plt_base + plt_offset + 8);
2422 dst_mask = (elfcpp::Elf_Xword)(TILEGX_IMM16_MASK) << TILEGX_X1_IMM16_BITOFF;
2423 val &= ~dst_mask;
2424 reloc &= TILEGX_IMM16_MASK;
2425 elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::writeval(wv,
2426 val | (reloc<<TILEGX_X1_IMM16_BITOFF));
2427
2428 // fifth bundle in plt stub - carry plt_index x0
2429 wv = reinterpret_cast<Valtype*>(pov + 32);
2430 val = elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::readval(wv);
2431 dst_mask = (elfcpp::Elf_Xword)(TILEGX_IMM16_MASK) << TILEGX_X0_IMM16_BITOFF;
2432 val &= ~dst_mask;
2433 plt_index &= TILEGX_IMM16_MASK;
2434 elfcpp::Swap<TILEGX_INST_BUNDLE_SIZE, big_endian>::writeval(wv,
2435 val | (plt_index<<TILEGX_X0_IMM16_BITOFF));
2436
2437}
2438
2439// Write out the PLT. This uses the hand-coded instructions above.
2440
2441template<int size, bool big_endian>
2442void
2443Output_data_plt_tilegx<size, big_endian>::do_write(Output_file* of)
2444{
2445 const off_t offset = this->offset();
2446 const section_size_type oview_size =
2447 convert_to_section_size_type(this->data_size());
2448 unsigned char* const oview = of->get_output_view(offset, oview_size);
2449
2450 const off_t got_file_offset = this->got_plt_->offset();
2451 gold_assert(parameters->incremental_update()
2452 || (got_file_offset + this->got_plt_->data_size()
2453 == this->got_irelative_->offset()));
2454 const section_size_type got_size =
2455 convert_to_section_size_type(this->got_plt_->data_size()
2456 + this->got_irelative_->data_size());
2457 unsigned char* const got_view = of->get_output_view(got_file_offset,
2458 got_size);
2459
2460 unsigned char* pov = oview;
2461
2462 // The base address of the .plt section.
2463 typename elfcpp::Elf_types<size>::Elf_Addr plt_address = this->address();
2464 typename elfcpp::Elf_types<size>::Elf_Addr got_address =
2465 this->got_plt_->address();
2466
2467 this->fill_first_plt_entry(pov);
2468 pov += this->get_plt_entry_size();
2469
2470 unsigned char* got_pov = got_view;
2471
2472 // first entry of .got.plt are set to -1
2473 // second entry of .got.plt are set to 0
2474 memset(got_pov, 0xff, size / 8);
2475 got_pov += size / 8;
2476 memset(got_pov, 0x0, size / 8);
2477 got_pov += size / 8;
2478
2479 unsigned int plt_offset = this->get_plt_entry_size();
2480 const unsigned int count = this->count_ + this->irelative_count_;
2481 unsigned int got_offset = (size / 8) * TILEGX_GOTPLT_RESERVE_COUNT;
2482 for (unsigned int plt_index = 0;
2483 plt_index < count;
2484 ++plt_index,
2485 pov += this->get_plt_entry_size(),
2486 got_pov += size / 8,
2487 plt_offset += this->get_plt_entry_size(),
2488 got_offset += size / 8)
2489 {
2490 // Set and adjust the PLT entry itself.
2491 this->fill_plt_entry(pov, got_address, got_offset,
2492 plt_address, plt_offset, plt_index);
2493
2494 // Initialize entry in .got.plt to plt start address
2495 elfcpp::Swap<size, big_endian>::writeval(got_pov, plt_address);
2496 }
2497
2498 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
2499 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
2500
2501 of->write_output_view(offset, oview_size, oview);
2502 of->write_output_view(got_file_offset, got_size, got_view);
2503}
2504
2505// Create the PLT section.
2506
2507template<int size, bool big_endian>
2508void
2509Target_tilegx<size, big_endian>::make_plt_section(Symbol_table* symtab,
2510 Layout* layout)
2511{
2512 if (this->plt_ == NULL)
2513 {
2514 // Create the GOT sections first.
2515 this->got_section(symtab, layout);
2516
2517 // Ensure that .rela.dyn always appears before .rela.plt,
2518 // becuase on TILE-Gx, .rela.dyn needs to include .rela.plt
2519 // in it's range.
2520 this->rela_dyn_section(layout);
2521
2522 this->plt_ = new Output_data_plt_tilegx<size, big_endian>(layout,
2523 TILEGX_INST_BUNDLE_SIZE, this->got_, this->got_plt_,
2524 this->got_irelative_);
2525
2526 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
2527 (elfcpp::SHF_ALLOC
2528 | elfcpp::SHF_EXECINSTR),
2529 this->plt_, ORDER_NON_RELRO_FIRST,
2530 false);
2531
2532 // Make the sh_info field of .rela.plt point to .plt.
2533 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
2534 rela_plt_os->set_info_section(this->plt_->output_section());
2535 }
2536}
2537
2538// Create a PLT entry for a global symbol.
2539
2540template<int size, bool big_endian>
2541void
2542Target_tilegx<size, big_endian>::make_plt_entry(Symbol_table* symtab,
2543 Layout* layout, Symbol* gsym)
2544{
2545 if (gsym->has_plt_offset())
2546 return;
2547
2548 if (this->plt_ == NULL)
2549 this->make_plt_section(symtab, layout);
2550
2551 this->plt_->add_entry(symtab, layout, gsym);
2552}
2553
2554// Make a PLT entry for a local STT_GNU_IFUNC symbol.
2555
2556template<int size, bool big_endian>
2557void
2558Target_tilegx<size, big_endian>::make_local_ifunc_plt_entry(
2559 Symbol_table* symtab, Layout* layout,
2560 Sized_relobj_file<size, big_endian>* relobj,
2561 unsigned int local_sym_index)
2562{
2563 if (relobj->local_has_plt_offset(local_sym_index))
2564 return;
2565 if (this->plt_ == NULL)
2566 this->make_plt_section(symtab, layout);
2567 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout,
2568 relobj,
2569 local_sym_index);
2570 relobj->set_local_plt_offset(local_sym_index, plt_offset);
2571}
2572
2573// Return the number of entries in the PLT.
2574
2575template<int size, bool big_endian>
2576unsigned int
2577Target_tilegx<size, big_endian>::plt_entry_count() const
2578{
2579 if (this->plt_ == NULL)
2580 return 0;
2581 return this->plt_->entry_count();
2582}
2583
2584// Return the offset of the first non-reserved PLT entry.
2585
2586template<int size, bool big_endian>
2587unsigned int
2588Target_tilegx<size, big_endian>::first_plt_entry_offset() const
2589{
2590 return this->plt_->first_plt_entry_offset();
2591}
2592
2593// Return the size of each PLT entry.
2594
2595template<int size, bool big_endian>
2596unsigned int
2597Target_tilegx<size, big_endian>::plt_entry_size() const
2598{
2599 return this->plt_->get_plt_entry_size();
2600}
2601
2602// Create the GOT and PLT sections for an incremental update.
2603
2604template<int size, bool big_endian>
2605Output_data_got_base*
2606Target_tilegx<size, big_endian>::init_got_plt_for_update(Symbol_table* symtab,
2607 Layout* layout,
2608 unsigned int got_count,
2609 unsigned int plt_count)
2610{
2611 gold_assert(this->got_ == NULL);
2612
2613 this->got_ =
2614 new Output_data_got<size, big_endian>((got_count
2615 + TILEGX_GOT_RESERVE_COUNT)
2616 * (size / 8));
2617 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
2618 (elfcpp::SHF_ALLOC
2619 | elfcpp::SHF_WRITE),
2620 this->got_, ORDER_RELRO_LAST,
2621 true);
2622
2623 // Define _GLOBAL_OFFSET_TABLE_ at the start of the GOT.
2624 this->global_offset_table_ =
2625 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
2626 Symbol_table::PREDEFINED,
2627 this->got_,
2628 0, 0, elfcpp::STT_OBJECT,
2629 elfcpp::STB_LOCAL,
2630 elfcpp::STV_HIDDEN, 0,
2631 false, false);
2632
2633 if (parameters->options().shared()) {
2634 this->tilegx_dynamic_ =
2635 symtab->define_in_output_data("_TILEGX_DYNAMIC_", NULL,
2636 Symbol_table::PREDEFINED,
2637 layout->dynamic_section(),
2638 0, 0, elfcpp::STT_OBJECT,
2639 elfcpp::STB_LOCAL,
2640 elfcpp::STV_HIDDEN, 0,
2641 false, false);
2642
2643 this->got_->add_global(this->tilegx_dynamic_, GOT_TYPE_STANDARD);
2644 } else
2645 this->got_->set_current_data_size(size / 8);
2646
2647 // Add the two reserved entries.
2648 this->got_plt_
2649 = new Output_data_space((plt_count + TILEGX_GOTPLT_RESERVE_COUNT)
2650 * (size / 8), size / 8, "** GOT PLT");
2651 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
2652 (elfcpp::SHF_ALLOC
2653 | elfcpp::SHF_WRITE),
2654 this->got_plt_, ORDER_NON_RELRO_FIRST,
2655 false);
2656
2657 // If there are any IRELATIVE relocations, they get GOT entries in
2658 // .got.plt after the jump slot.
2659 this->got_irelative_
2660 = new Output_data_space(0, size / 8, "** GOT IRELATIVE PLT");
2661 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
2662 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
2663 this->got_irelative_,
2664 ORDER_NON_RELRO_FIRST, false);
2665
2666 // Create the PLT section.
2667 this->plt_ = new Output_data_plt_tilegx<size, big_endian>(layout,
2668 this->plt_entry_size(), this->got_, this->got_plt_, this->got_irelative_,
2669 plt_count);
2670
2671 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
2672 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
2673 this->plt_, ORDER_PLT, false);
2674
2675 // Make the sh_info field of .rela.plt point to .plt.
2676 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
2677 rela_plt_os->set_info_section(this->plt_->output_section());
2678
2679 // Create the rela_dyn section.
2680 this->rela_dyn_section(layout);
2681
2682 return this->got_;
2683}
2684
2685// Reserve a GOT entry for a local symbol, and regenerate any
2686// necessary dynamic relocations.
2687
2688template<int size, bool big_endian>
2689void
2690Target_tilegx<size, big_endian>::reserve_local_got_entry(
2691 unsigned int got_index,
2692 Sized_relobj<size, big_endian>* obj,
2693 unsigned int r_sym,
2694 unsigned int got_type)
2695{
2696 unsigned int got_offset = (got_index + TILEGX_GOT_RESERVE_COUNT)
2697 * (size / 8);
2698 Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
2699
2700 this->got_->reserve_local(got_index, obj, r_sym, got_type);
2701 switch (got_type)
2702 {
2703 case GOT_TYPE_STANDARD:
2704 if (parameters->options().output_is_position_independent())
2705 rela_dyn->add_local_relative(obj, r_sym, elfcpp::R_TILEGX_RELATIVE,
2706 this->got_, got_offset, 0, false);
2707 break;
2708 case GOT_TYPE_TLS_OFFSET:
2709 rela_dyn->add_local(obj, r_sym,
2710 size == 32 ? elfcpp::R_TILEGX_TLS_DTPOFF32
2711 : elfcpp::R_TILEGX_TLS_DTPOFF64,
2712 this->got_, got_offset, 0);
2713 break;
2714 case GOT_TYPE_TLS_PAIR:
2715 this->got_->reserve_slot(got_index + 1);
2716 rela_dyn->add_local(obj, r_sym,
2717 size == 32 ? elfcpp::R_TILEGX_TLS_DTPMOD32
2718 : elfcpp::R_TILEGX_TLS_DTPMOD64,
2719 this->got_, got_offset, 0);
2720 break;
2721 case GOT_TYPE_TLS_DESC:
2722 gold_fatal(_("TLS_DESC not yet supported for incremental linking"));
2723 break;
2724 default:
2725 gold_unreachable();
2726 }
2727}
2728
2729// Reserve a GOT entry for a global symbol, and regenerate any
2730// necessary dynamic relocations.
2731
2732template<int size, bool big_endian>
2733void
2734Target_tilegx<size, big_endian>::reserve_global_got_entry(
2735 unsigned int got_index, Symbol* gsym, unsigned int got_type)
2736{
2737 unsigned int got_offset = (got_index + TILEGX_GOT_RESERVE_COUNT)
2738 * (size / 8);
2739 Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
2740
2741 this->got_->reserve_global(got_index, gsym, got_type);
2742 switch (got_type)
2743 {
2744 case GOT_TYPE_STANDARD:
2745 if (!gsym->final_value_is_known())
2746 {
2747 if (gsym->is_from_dynobj()
2748 || gsym->is_undefined()
2749 || gsym->is_preemptible()
2750 || gsym->type() == elfcpp::STT_GNU_IFUNC)
2751 rela_dyn->add_global(gsym, elfcpp::R_TILEGX_GLOB_DAT,
2752 this->got_, got_offset, 0);
2753 else
2754 rela_dyn->add_global_relative(gsym, elfcpp::R_TILEGX_RELATIVE,
2755 this->got_, got_offset, 0, false);
2756 }
2757 break;
2758 case GOT_TYPE_TLS_OFFSET:
2759 rela_dyn->add_global_relative(gsym,
2760 size == 32 ? elfcpp::R_TILEGX_TLS_TPOFF32
2761 : elfcpp::R_TILEGX_TLS_TPOFF64,
2762 this->got_, got_offset, 0, false);
2763 break;
2764 case GOT_TYPE_TLS_PAIR:
2765 this->got_->reserve_slot(got_index + 1);
2766 rela_dyn->add_global_relative(gsym,
2767 size == 32 ? elfcpp::R_TILEGX_TLS_DTPMOD32
2768 : elfcpp::R_TILEGX_TLS_DTPMOD64,
2769 this->got_, got_offset, 0, false);
2770 rela_dyn->add_global_relative(gsym,
2771 size == 32 ? elfcpp::R_TILEGX_TLS_DTPOFF32
2772 : elfcpp::R_TILEGX_TLS_DTPOFF64,
2773 this->got_, got_offset + size / 8,
2774 0, false);
2775 break;
2776 case GOT_TYPE_TLS_DESC:
2777 gold_fatal(_("TLS_DESC not yet supported for TILEGX"));
2778 break;
2779 default:
2780 gold_unreachable();
2781 }
2782}
2783
2784// Register an existing PLT entry for a global symbol.
2785
2786template<int size, bool big_endian>
2787void
2788Target_tilegx<size, big_endian>::register_global_plt_entry(
2789 Symbol_table* symtab, Layout* layout, unsigned int plt_index, Symbol* gsym)
2790{
2791 gold_assert(this->plt_ != NULL);
2792 gold_assert(!gsym->has_plt_offset());
2793
2794 this->plt_->reserve_slot(plt_index);
2795
2796 gsym->set_plt_offset((plt_index + 1) * this->plt_entry_size());
2797
2798 unsigned int got_offset = (plt_index + 2) * (size / 8);
2799 this->plt_->add_relocation(symtab, layout, gsym, got_offset);
2800}
2801
2802// Force a COPY relocation for a given symbol.
2803
2804template<int size, bool big_endian>
2805void
2806Target_tilegx<size, big_endian>::emit_copy_reloc(
2807 Symbol_table* symtab, Symbol* sym, Output_section* os, off_t offset)
2808{
2809 this->copy_relocs_.emit_copy_reloc(symtab,
2810 symtab->get_sized_symbol<size>(sym),
2811 os,
2812 offset,
2813 this->rela_dyn_section(NULL));
2814}
2815
2816// Create a GOT entry for the TLS module index.
2817
2818template<int size, bool big_endian>
2819unsigned int
2820Target_tilegx<size, big_endian>::got_mod_index_entry(Symbol_table* symtab,
2821 Layout* layout,
2822 Sized_relobj_file<size, big_endian>* object)
2823{
2824 if (this->got_mod_index_offset_ == -1U)
2825 {
2826 gold_assert(symtab != NULL && layout != NULL && object != NULL);
2827 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
2828 Output_data_got<size, big_endian>* got
2829 = this->got_section(symtab, layout);
2830 unsigned int got_offset = got->add_constant(0);
2831 rela_dyn->add_local(object, 0,
2832 size == 32 ? elfcpp::R_TILEGX_TLS_DTPMOD32
2833 : elfcpp::R_TILEGX_TLS_DTPMOD64, got,
2834 got_offset, 0);
2835 got->add_constant(0);
2836 this->got_mod_index_offset_ = got_offset;
2837 }
2838 return this->got_mod_index_offset_;
2839}
2840
2841// Optimize the TLS relocation type based on what we know about the
2842// symbol. IS_FINAL is true if the final address of this symbol is
2843// known at link time.
2844//
2845// the transformation rules is described below:
2846//
2847// compiler GD reference
2848// |
2849// V
2850// moveli tmp, hw1_last_tls_gd(x) X0/X1
2851// shl16insli r0, tmp, hw0_tls_gd(x) X0/X1
2852// addi r0, got, tls_add(x) Y0/Y1/X0/X1
2853// jal tls_gd_call(x) X1
2854// addi adr, r0, tls_gd_add(x) Y0/Y1/X0/X1
2855//
2856// linker tranformation of GD insn sequence
2857// |
2858// V
2859// ==> GD:
2860// moveli tmp, hw1_last_tls_gd(x) X0/X1
2861// shl16insli r0, tmp, hw0_tls_gd(x) X0/X1
2862// add r0, got, r0 Y0/Y1/X0/X1
2863// jal plt(__tls_get_addr) X1
2864// move adr, r0 Y0/Y1/X0/X1
2865// ==> IE:
2866// moveli tmp, hw1_last_tls_ie(x) X0/X1
2867// shl16insli r0, tmp, hw0_tls_ie(x) X0/X1
2868// add r0, got, r0 Y0/Y1/X0/X1
2869// ld r0, r0 X1
2870// add adr, r0, tp Y0/Y1/X0/X1
2871// ==> LE:
2872// moveli tmp, hw1_last_tls_le(x) X0/X1
2873// shl16insli r0, tmp, hw0_tls_le(x) X0/X1
2874// move r0, r0 Y0/Y1/X0/X1
2875// move r0, r0 Y0/Y1/X0/X1
2876// add adr, r0, tp Y0/Y1/X0/X1
62fe925a
RM		 2877//
2878//
5c0b3823
WL		 2879// compiler IE reference
2880// |
2881// V
2882// moveli tmp, hw1_last_tls_ie(x) X0/X1
2883// shl16insli tmp, tmp, hw0_tls_ie(x) X0/X1
2884// addi tmp, got, tls_add(x) Y0/Y1/X0/X1
2885// ld_tls tmp, tmp, tls_ie_load(x) X1
2886// add adr, tmp, tp Y0/Y1/X0/X1
2887//
2888// linker transformation for IE insn sequence
2889// |
2890// V
2891// ==> IE:
2892// moveli tmp, hw1_last_tls_ie(x) X0/X1
2893// shl16insli tmp, tmp, hw0_tls_ie(x) X0/X1
2894// add tmp, got, tmp Y0/Y1/X0/X1
2895// ld tmp, tmp X1
2896// add adr, tmp, tp Y0/Y1/X0/X1
2897// ==> LE:
2898// moveli tmp, hw1_last_tls_le(x) X0/X1
2899// shl16insli tmp, tmp, hw0_tls_le(x) X0/X1
2900// move tmp, tmp Y0/Y1/X0/X1
2901// move tmp, tmp Y0/Y1/X0/X1
2902//
2903//
2904// compiler LE reference
2905// |
2906// V
2907// moveli tmp, hw1_last_tls_le(x) X0/X1
2908// shl16insli tmp, tmp, hw0_tls_le(x) X0/X1
2909// add adr, tmp, tp Y0/Y1/X0/X1
2910
2911template<int size, bool big_endian>
2912tls::Tls_optimization
2913Target_tilegx<size, big_endian>::optimize_tls_reloc(bool is_final, int r_type)
2914{
2915 // If we are generating a shared library, then we can't do anything
2916 // in the linker.
2917 if (parameters->options().shared())
2918 return tls::TLSOPT_NONE;
2919
2920 switch (r_type)
2921 {
2922 // unique GD relocations
2923 case elfcpp::R_TILEGX_TLS_GD_CALL:
2924 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
2925 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
2926 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
2927 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
2928 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
2929 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
2930 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
2931 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
2932 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
2933 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
2934 // These are General-Dynamic which permits fully general TLS
2935 // access. Since we know that we are generating an executable,
2936 // we can convert this to Initial-Exec. If we also know that
2937 // this is a local symbol, we can further switch to Local-Exec.
2938 if (is_final)
2939 return tls::TLSOPT_TO_LE;
2940 return tls::TLSOPT_TO_IE;
2941
2942 // unique IE relocations
2943 case elfcpp::R_TILEGX_TLS_IE_LOAD:
2944 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
2945 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
2946 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
2947 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
2948 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
2949 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
2950 // These are Initial-Exec relocs which get the thread offset
2951 // from the GOT. If we know that we are linking against the
2952 // local symbol, we can switch to Local-Exec, which links the
2953 // thread offset into the instruction.
2954 if (is_final)
2955 return tls::TLSOPT_TO_LE;
2956 return tls::TLSOPT_NONE;
2957
2958 // could be created for both GD and IE
2959 // but they are expanded into the same
2960 // instruction in GD and IE.
2961 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
2962 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
2963 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
2964 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
2965 if (is_final)
2966 return tls::TLSOPT_TO_LE;
2967 return tls::TLSOPT_NONE;
2968
2969 // unique LE relocations
2970 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
2971 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
2972 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
2973 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
2974 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
2975 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
2976 // When we already have Local-Exec, there is nothing further we
2977 // can do.
2978 return tls::TLSOPT_NONE;
2979
2980 default:
2981 gold_unreachable();
2982 }
2983}
2984
2985// Get the Reference_flags for a particular relocation.
2986
2987template<int size, bool big_endian>
2988int
2989Target_tilegx<size, big_endian>::Scan::get_reference_flags(unsigned int r_type)
2990{
2991 switch (r_type)
2992 {
2993 case elfcpp::R_TILEGX_NONE:
2994 case elfcpp::R_TILEGX_GNU_VTINHERIT:
2995 case elfcpp::R_TILEGX_GNU_VTENTRY:
2996 // No symbol reference.
2997 return 0;
2998
2999 case elfcpp::R_TILEGX_64:
3000 case elfcpp::R_TILEGX_32:
3001 case elfcpp::R_TILEGX_16:
3002 case elfcpp::R_TILEGX_8:
3003 return Symbol::ABSOLUTE_REF;
3004
3005 case elfcpp::R_TILEGX_BROFF_X1:
3006 case elfcpp::R_TILEGX_64_PCREL:
3007 case elfcpp::R_TILEGX_32_PCREL:
3008 case elfcpp::R_TILEGX_16_PCREL:
3009 case elfcpp::R_TILEGX_8_PCREL:
3010 case elfcpp::R_TILEGX_IMM16_X0_HW0_PCREL:
3011 case elfcpp::R_TILEGX_IMM16_X1_HW0_PCREL:
3012 case elfcpp::R_TILEGX_IMM16_X0_HW1_PCREL:
3013 case elfcpp::R_TILEGX_IMM16_X1_HW1_PCREL:
3014 case elfcpp::R_TILEGX_IMM16_X0_HW2_PCREL:
3015 case elfcpp::R_TILEGX_IMM16_X1_HW2_PCREL:
3016 case elfcpp::R_TILEGX_IMM16_X0_HW3_PCREL:
3017 case elfcpp::R_TILEGX_IMM16_X1_HW3_PCREL:
3018 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
3019 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
3020 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
3021 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
3022 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
3023 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
3024 return Symbol::RELATIVE_REF;
3025
3026 case elfcpp::R_TILEGX_JUMPOFF_X1:
3027 case elfcpp::R_TILEGX_JUMPOFF_X1_PLT:
3028 case elfcpp::R_TILEGX_IMM16_X0_HW0_PLT_PCREL:
3029 case elfcpp::R_TILEGX_IMM16_X1_HW0_PLT_PCREL:
3030 case elfcpp::R_TILEGX_IMM16_X0_HW1_PLT_PCREL:
3031 case elfcpp::R_TILEGX_IMM16_X1_HW1_PLT_PCREL:
3032 case elfcpp::R_TILEGX_IMM16_X0_HW2_PLT_PCREL:
3033 case elfcpp::R_TILEGX_IMM16_X1_HW2_PLT_PCREL:
3034 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL:
3035 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL:
3036 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL:
3037 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL:
3038 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL:
3039 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL:
3040 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
3041
3042 case elfcpp::R_TILEGX_IMM16_X0_HW0:
3043 case elfcpp::R_TILEGX_IMM16_X1_HW0:
3044 case elfcpp::R_TILEGX_IMM16_X0_HW1:
3045 case elfcpp::R_TILEGX_IMM16_X1_HW1:
3046 case elfcpp::R_TILEGX_IMM16_X0_HW2:
3047 case elfcpp::R_TILEGX_IMM16_X1_HW2:
3048 case elfcpp::R_TILEGX_IMM16_X0_HW3:
3049 case elfcpp::R_TILEGX_IMM16_X1_HW3:
3050 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST:
3051 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST:
3052 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST:
3053 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST:
3054 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST:
3055 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST:
3056 return Symbol::ABSOLUTE_REF;
3057
3058 case elfcpp::R_TILEGX_IMM16_X0_HW0_GOT:
3059 case elfcpp::R_TILEGX_IMM16_X1_HW0_GOT:
3060 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_GOT:
3061 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_GOT:
3062 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_GOT:
3063 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_GOT:
3064 // Absolute in GOT.
3065 return Symbol::ABSOLUTE_REF;
3066
3067 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
3068 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
3069 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
3070 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
3071 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
3072 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
3073 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
3074 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
3075 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
3076 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
3077 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
3078 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
3079 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
3080 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
3081 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
3082 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
3083 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
3084 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
3085 case elfcpp::R_TILEGX_TLS_DTPOFF64:
3086 case elfcpp::R_TILEGX_TLS_DTPMOD32:
3087 case elfcpp::R_TILEGX_TLS_DTPOFF32:
3088 case elfcpp::R_TILEGX_TLS_TPOFF32:
3089 case elfcpp::R_TILEGX_TLS_GD_CALL:
3090 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
3091 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
3092 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
3093 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
3094 case elfcpp::R_TILEGX_TLS_IE_LOAD:
3095 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
3096 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
3097 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
3098 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
3099 return Symbol::TLS_REF;
3100
3101 case elfcpp::R_TILEGX_COPY:
3102 case elfcpp::R_TILEGX_GLOB_DAT:
3103 case elfcpp::R_TILEGX_JMP_SLOT:
3104 case elfcpp::R_TILEGX_RELATIVE:
3105 case elfcpp::R_TILEGX_TLS_TPOFF64:
3106 case elfcpp::R_TILEGX_TLS_DTPMOD64:
3107 default:
3108 // Not expected. We will give an error later.
3109 return 0;
3110 }
3111}
3112
3113// Report an unsupported relocation against a local symbol.
3114
3115template<int size, bool big_endian>
3116void
3117Target_tilegx<size, big_endian>::Scan::unsupported_reloc_local(
3118 Sized_relobj_file<size, big_endian>* object,
3119 unsigned int r_type)
3120{
3121 gold_error(_("%s: unsupported reloc %u against local symbol"),
3122 object->name().c_str(), r_type);
3123}
3124
3125// We are about to emit a dynamic relocation of type R_TYPE. If the
62fe925a 3126// dynamic linker does not support it, issue an error.
5c0b3823
WL		 3127template<int size, bool big_endian>
3128void
3129Target_tilegx<size, big_endian>::Scan::check_non_pic(Relobj* object,
3130 unsigned int r_type)
3131{
3132 switch (r_type)
3133 {
3134 // These are the relocation types supported by glibc for tilegx
3135 // which should always work.
3136 case elfcpp::R_TILEGX_RELATIVE:
3137 case elfcpp::R_TILEGX_GLOB_DAT:
3138 case elfcpp::R_TILEGX_JMP_SLOT:
3139 case elfcpp::R_TILEGX_TLS_DTPMOD64:
3140 case elfcpp::R_TILEGX_TLS_DTPOFF64:
3141 case elfcpp::R_TILEGX_TLS_TPOFF64:
3142 case elfcpp::R_TILEGX_8:
3143 case elfcpp::R_TILEGX_16:
3144 case elfcpp::R_TILEGX_32:
3145 case elfcpp::R_TILEGX_64:
3146 case elfcpp::R_TILEGX_COPY:
3147 case elfcpp::R_TILEGX_IMM16_X0_HW0:
3148 case elfcpp::R_TILEGX_IMM16_X1_HW0:
3149 case elfcpp::R_TILEGX_IMM16_X0_HW1:
3150 case elfcpp::R_TILEGX_IMM16_X1_HW1:
3151 case elfcpp::R_TILEGX_IMM16_X0_HW2:
3152 case elfcpp::R_TILEGX_IMM16_X1_HW2:
3153 case elfcpp::R_TILEGX_IMM16_X0_HW3:
3154 case elfcpp::R_TILEGX_IMM16_X1_HW3:
3155 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST:
3156 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST:
3157 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST:
3158 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST:
3159 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST:
3160 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST:
3161 case elfcpp::R_TILEGX_BROFF_X1:
3162 case elfcpp::R_TILEGX_JUMPOFF_X1:
3163 case elfcpp::R_TILEGX_IMM16_X0_HW0_PCREL:
3164 case elfcpp::R_TILEGX_IMM16_X1_HW0_PCREL:
3165 case elfcpp::R_TILEGX_IMM16_X0_HW1_PCREL:
3166 case elfcpp::R_TILEGX_IMM16_X1_HW1_PCREL:
3167 case elfcpp::R_TILEGX_IMM16_X0_HW2_PCREL:
3168 case elfcpp::R_TILEGX_IMM16_X1_HW2_PCREL:
3169 case elfcpp::R_TILEGX_IMM16_X0_HW3_PCREL:
3170 case elfcpp::R_TILEGX_IMM16_X1_HW3_PCREL:
3171 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
3172 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
3173 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
3174 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
3175 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
3176 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
3177 return;
3178
3179 default:
3180 // This prevents us from issuing more than one error per reloc
3181 // section. But we can still wind up issuing more than one
3182 // error per object file.
3183 if (this->issued_non_pic_error_)
3184 return;
3185 gold_assert(parameters->options().output_is_position_independent());
3186 object->error(_("requires unsupported dynamic reloc %u; "
3187 "recompile with -fPIC"),
3188 r_type);
3189 this->issued_non_pic_error_ = true;
3190 return;
3191
3192 case elfcpp::R_TILEGX_NONE:
3193 gold_unreachable();
3194 }
3195}
3196
3197// Return whether we need to make a PLT entry for a relocation of the
3198// given type against a STT_GNU_IFUNC symbol.
3199
3200template<int size, bool big_endian>
3201bool
3202Target_tilegx<size, big_endian>::Scan::reloc_needs_plt_for_ifunc(
3203 Sized_relobj_file<size, big_endian>* object, unsigned int r_type)
3204{
3205 int flags = Scan::get_reference_flags(r_type);
3206 if (flags & Symbol::TLS_REF)
3207 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
3208 object->name().c_str(), r_type);
3209 return flags != 0;
3210}
3211
3212// Scan a relocation for a local symbol.
3213
3214template<int size, bool big_endian>
3215inline void
3216Target_tilegx<size, big_endian>::Scan::local(Symbol_table* symtab,
3217 Layout* layout,
3218 Target_tilegx<size, big_endian>* target,
3219 Sized_relobj_file<size, big_endian>* object,
3220 unsigned int data_shndx,
3221 Output_section* output_section,
3222 const elfcpp::Rela<size, big_endian>& reloc,
3223 unsigned int r_type,
3224 const elfcpp::Sym<size, big_endian>& lsym,
3225 bool is_discarded)
3226{
3227 if (is_discarded)
3228 return;
3229
3230 // A local STT_GNU_IFUNC symbol may require a PLT entry.
3231 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC;
3232 if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type))
3233 {
3234 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3235 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
3236 }
3237
3238 switch (r_type)
3239 {
3240 case elfcpp::R_TILEGX_NONE:
3241 case elfcpp::R_TILEGX_GNU_VTINHERIT:
3242 case elfcpp::R_TILEGX_GNU_VTENTRY:
3243 break;
3244
3245 // If building a shared library (or a position-independent
3246 // executable), because the runtime address needs plus
3247 // the module base address, so generate a R_TILEGX_RELATIVE.
3248 case elfcpp::R_TILEGX_32:
3249 case elfcpp::R_TILEGX_64:
3250 if (parameters->options().output_is_position_independent())
3251 {
3252 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3253 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3254 rela_dyn->add_local_relative(object, r_sym,
3255 elfcpp::R_TILEGX_RELATIVE,
3256 output_section, data_shndx,
3257 reloc.get_r_offset(),
3258 reloc.get_r_addend(), is_ifunc);
3259 }
3260 break;
3261
3262 // If building a shared library (or a position-independent
3263 // executable), we need to create a dynamic relocation for this
3264 // location.
3265 case elfcpp::R_TILEGX_8:
3266 case elfcpp::R_TILEGX_16:
3267 case elfcpp::R_TILEGX_IMM16_X0_HW0:
3268 case elfcpp::R_TILEGX_IMM16_X1_HW0:
3269 case elfcpp::R_TILEGX_IMM16_X0_HW1:
3270 case elfcpp::R_TILEGX_IMM16_X1_HW1:
3271 case elfcpp::R_TILEGX_IMM16_X0_HW2:
3272 case elfcpp::R_TILEGX_IMM16_X1_HW2:
3273 case elfcpp::R_TILEGX_IMM16_X0_HW3:
3274 case elfcpp::R_TILEGX_IMM16_X1_HW3:
3275 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST:
3276 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST:
3277 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST:
3278 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST:
3279 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST:
3280 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST:
3281 if (parameters->options().output_is_position_independent())
3282 {
3283 this->check_non_pic(object, r_type);
3284
3285 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3286 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3287 if (lsym.get_st_type() != elfcpp::STT_SECTION)
3288 rela_dyn->add_local(object, r_sym, r_type, output_section,
3289 data_shndx, reloc.get_r_offset(),
3290 reloc.get_r_addend());
3291 else
3292 {
3293 gold_assert(lsym.get_st_value() == 0);
3294 rela_dyn->add_symbolless_local_addend(object, r_sym, r_type,
3295 output_section,
3296 data_shndx,
3297 reloc.get_r_offset(),
3298 reloc.get_r_addend());
62fe925a 3299
5c0b3823
WL		 3300 }
3301 }
3302 break;
3303
3304 // R_TILEGX_JUMPOFF_X1_PLT against local symbol
3305 // may happen for ifunc case.
3306 case elfcpp::R_TILEGX_JUMPOFF_X1_PLT:
3307 case elfcpp::R_TILEGX_JUMPOFF_X1:
3308 case elfcpp::R_TILEGX_64_PCREL:
3309 case elfcpp::R_TILEGX_32_PCREL:
3310 case elfcpp::R_TILEGX_16_PCREL:
3311 case elfcpp::R_TILEGX_8_PCREL:
3312 case elfcpp::R_TILEGX_BROFF_X1:
3313 case elfcpp::R_TILEGX_IMM16_X0_HW0_PCREL:
3314 case elfcpp::R_TILEGX_IMM16_X1_HW0_PCREL:
3315 case elfcpp::R_TILEGX_IMM16_X0_HW1_PCREL:
3316 case elfcpp::R_TILEGX_IMM16_X1_HW1_PCREL:
3317 case elfcpp::R_TILEGX_IMM16_X0_HW2_PCREL:
3318 case elfcpp::R_TILEGX_IMM16_X1_HW2_PCREL:
3319 case elfcpp::R_TILEGX_IMM16_X0_HW3_PCREL:
3320 case elfcpp::R_TILEGX_IMM16_X1_HW3_PCREL:
3321 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
3322 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
3323 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
3324 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
3325 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
3326 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
3327 case elfcpp::R_TILEGX_IMM16_X0_HW0_PLT_PCREL:
3328 case elfcpp::R_TILEGX_IMM16_X1_HW0_PLT_PCREL:
3329 case elfcpp::R_TILEGX_IMM16_X0_HW1_PLT_PCREL:
3330 case elfcpp::R_TILEGX_IMM16_X1_HW1_PLT_PCREL:
3331 case elfcpp::R_TILEGX_IMM16_X0_HW2_PLT_PCREL:
3332 case elfcpp::R_TILEGX_IMM16_X1_HW2_PLT_PCREL:
3333 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL:
3334 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL:
3335 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL:
3336 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL:
3337 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL:
3338 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL:
3339 break;
3340
3341 case elfcpp::R_TILEGX_IMM16_X0_HW0_GOT:
3342 case elfcpp::R_TILEGX_IMM16_X1_HW0_GOT:
3343 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_GOT:
3344 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_GOT:
3345 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_GOT:
3346 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_GOT:
3347 {
3348 // The symbol requires a GOT entry.
3349 Output_data_got<size, big_endian>* got
3350 = target->got_section(symtab, layout);
3351 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3352
3353 // For a STT_GNU_IFUNC symbol we want the PLT offset. That
3354 // lets function pointers compare correctly with shared
3355 // libraries. Otherwise we would need an IRELATIVE reloc.
3356 bool is_new;
3357 if (is_ifunc)
3358 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
3359 else
3360 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
3361 if (is_new)
3362 {
3363 // tilegx dynamic linker will not update local got entry,
3364 // so, if we are generating a shared object, we need to add a
3365 // dynamic relocation for this symbol's GOT entry to inform
3366 // dynamic linker plus the load base explictly.
3367 if (parameters->options().output_is_position_independent())
3368 {
3369 unsigned int got_offset
3370 = object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
3371
3372 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3373 rela_dyn->add_local_relative(object, r_sym,
3374 r_type,
3375 got, got_offset, 0, is_ifunc);
3376 }
3377 }
3378 }
3379 break;
3380
3381 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
3382 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
3383 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
3384 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
3385 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
3386 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
3387 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
3388 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
3389 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
3390 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
3391 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
3392 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
3393 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
3394 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
3395 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
3396 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
3397 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
3398 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
3399 case elfcpp::R_TILEGX_TLS_GD_CALL:
3400 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
3401 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
3402 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
3403 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
3404 case elfcpp::R_TILEGX_TLS_IE_LOAD:
3405 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
3406 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
3407 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
3408 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
3409 {
3410 bool output_is_shared = parameters->options().shared();
3411 const tls::Tls_optimization opt_t =
3412 Target_tilegx<size, big_endian>::optimize_tls_reloc(
3413 !output_is_shared, r_type);
3414
3415 switch (r_type)
3416 {
3417 case elfcpp::R_TILEGX_TLS_GD_CALL:
3418 // FIXME: predefine __tls_get_addr
3419 //
3420 // R_TILEGX_TLS_GD_CALL implicitly reference __tls_get_addr,
3421 // while all other target, x86/arm/mips/powerpc/sparc
3422 // generate tls relocation against __tls_get_addr explictly,
3423 // so for TILEGX, we need the following hack.
3424 if (opt_t == tls::TLSOPT_NONE) {
3425 if (!target->tls_get_addr_sym_defined_) {
3426 Symbol* sym = NULL;
3427 options::parse_set(NULL, "__tls_get_addr",
3428 (gold::options::String_set*)
3429 &parameters->options().undefined());
3430 symtab->add_undefined_symbols_from_command_line(layout);
3431 target->tls_get_addr_sym_defined_ = true;
3432 sym = symtab->lookup("__tls_get_addr");
3433 sym->set_in_reg();
3434 }
3435 target->make_plt_entry(symtab, layout,
3436 symtab->lookup("__tls_get_addr"));
3437 }
3438 break;
3439
3440 // only make effect when applying relocation
3441 case elfcpp::R_TILEGX_TLS_IE_LOAD:
3442 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
3443 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
3444 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
3445 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
3446 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
3447 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
3448 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
3449 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
3450 break;
3451
3452 // GD: requires two GOT entry for module index and offset
62fe925a 3453 // IE: requires one GOT entry for tp-relative offset
5c0b3823
WL		 3454 // LE: shouldn't happen for global symbol
3455 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
3456 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
3457 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
3458 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
3459 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
3460 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
3461 {
3462 if (opt_t == tls::TLSOPT_NONE) {
3463 Output_data_got<size, big_endian> *got
3464 = target->got_section(symtab, layout);
3465 unsigned int r_sym
3466 = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3467 unsigned int shndx = lsym.get_st_shndx();
3468 bool is_ordinary;
3469 shndx = object->adjust_sym_shndx(r_sym, shndx,
3470 &is_ordinary);
3471 if (!is_ordinary)
3472 object->error(_("local symbol %u has bad shndx %u"),
3473 r_sym, shndx);
3474 else
3475 got->add_local_pair_with_rel(object, r_sym, shndx,
62fe925a 3476 GOT_TYPE_TLS_PAIR,
5c0b3823
WL		 3477 target->rela_dyn_section(layout),
3478 size == 32
3479 ? elfcpp::R_TILEGX_TLS_DTPMOD32
3480 : elfcpp::R_TILEGX_TLS_DTPMOD64);
3481 } else if (opt_t == tls::TLSOPT_TO_IE) {
3482 Output_data_got<size, big_endian>* got
3483 = target->got_section(symtab, layout);
3484 Reloc_section* rela_dyn
3485 = target->rela_dyn_section(layout);
3486 unsigned int r_sym
3487 = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3488 unsigned int off = got->add_constant(0);
3489 object->set_local_got_offset(r_sym,
3490 GOT_TYPE_TLS_OFFSET,off);
3491 rela_dyn->add_symbolless_local_addend(object, r_sym,
3492 size == 32
3493 ? elfcpp::R_TILEGX_TLS_TPOFF32
3494 : elfcpp::R_TILEGX_TLS_TPOFF64,
3495 got, off, 0);
62fe925a 3496 } else if (opt_t != tls::TLSOPT_TO_LE)
5c0b3823
WL		 3497 // only TO_LE is allowed for local symbol
3498 unsupported_reloc_local(object, r_type);
3499 }
3500 break;
3501
3502 // IE
3503 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
3504 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
3505 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
3506 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
3507 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
3508 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
3509 {
3510 layout->set_has_static_tls();
3511 if (opt_t == tls::TLSOPT_NONE) {
3512 Output_data_got<size, big_endian>* got
3513 = target->got_section(symtab, layout);
3514 Reloc_section* rela_dyn
3515 = target->rela_dyn_section(layout);
3516 unsigned int r_sym
3517 = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3518 unsigned int off = got->add_constant(0);
3519 object->set_local_got_offset(r_sym,
3520 GOT_TYPE_TLS_OFFSET, off);
3521 rela_dyn->add_symbolless_local_addend(object, r_sym,
3522 size == 32
3523 ? elfcpp::R_TILEGX_TLS_TPOFF32
3524 : elfcpp::R_TILEGX_TLS_TPOFF64,
3525 got, off, 0);
3526 } else if (opt_t != tls::TLSOPT_TO_LE)
3527 unsupported_reloc_local(object, r_type);
3528 }
3529 break;
3530
3531 // LE
3532 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
3533 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
3534 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
3535 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
3536 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
3537 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
3538 layout->set_has_static_tls();
3539 if (parameters->options().shared()) {
3540 // defer to dynamic linker
3541 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
3542 unsigned int r_sym
3543 = elfcpp::elf_r_sym<size>(reloc.get_r_info());
3544 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3545 rela_dyn->add_symbolless_local_addend(object, r_sym, r_type,
3546 output_section, data_shndx,
3547 reloc.get_r_offset(), 0);
3548 }
3549 break;
3550
3551 default:
3552 gold_unreachable();
3553 }
3554 }
3555 break;
3556
3557 case elfcpp::R_TILEGX_COPY:
3558 case elfcpp::R_TILEGX_GLOB_DAT:
3559 case elfcpp::R_TILEGX_JMP_SLOT:
3560 case elfcpp::R_TILEGX_RELATIVE:
3561 // These are outstanding tls relocs, which are unexpected when linking
3562 case elfcpp::R_TILEGX_TLS_TPOFF32:
3563 case elfcpp::R_TILEGX_TLS_TPOFF64:
3564 case elfcpp::R_TILEGX_TLS_DTPMOD32:
3565 case elfcpp::R_TILEGX_TLS_DTPMOD64:
3566 case elfcpp::R_TILEGX_TLS_DTPOFF32:
3567 case elfcpp::R_TILEGX_TLS_DTPOFF64:
3568 gold_error(_("%s: unexpected reloc %u in object file"),
3569 object->name().c_str(), r_type);
3570 break;
3571
3572 default:
3573 gold_error(_("%s: unsupported reloc %u against local symbol"),
3574 object->name().c_str(), r_type);
3575 break;
3576 }
3577}
3578
3579
3580// Report an unsupported relocation against a global symbol.
3581
3582template<int size, bool big_endian>
3583void
3584Target_tilegx<size, big_endian>::Scan::unsupported_reloc_global(
3585 Sized_relobj_file<size, big_endian>* object,
3586 unsigned int r_type,
3587 Symbol* gsym)
3588{
3589 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
3590 object->name().c_str(), r_type, gsym->demangled_name().c_str());
3591}
3592
3593// Returns true if this relocation type could be that of a function pointer.
3594template<int size, bool big_endian>
3595inline bool
3596Target_tilegx<size, big_endian>::Scan::possible_function_pointer_reloc(
3597 unsigned int r_type)
3598{
3599 switch (r_type)
3600 {
3601 case elfcpp::R_TILEGX_IMM16_X0_HW0:
3602 case elfcpp::R_TILEGX_IMM16_X1_HW0:
3603 case elfcpp::R_TILEGX_IMM16_X0_HW1:
3604 case elfcpp::R_TILEGX_IMM16_X1_HW1:
3605 case elfcpp::R_TILEGX_IMM16_X0_HW2:
3606 case elfcpp::R_TILEGX_IMM16_X1_HW2:
3607 case elfcpp::R_TILEGX_IMM16_X0_HW3:
3608 case elfcpp::R_TILEGX_IMM16_X1_HW3:
3609 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST:
3610 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST:
3611 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST:
3612 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST:
3613 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST:
3614 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST:
3615 case elfcpp::R_TILEGX_IMM16_X0_HW0_PCREL:
3616 case elfcpp::R_TILEGX_IMM16_X1_HW0_PCREL:
3617 case elfcpp::R_TILEGX_IMM16_X0_HW1_PCREL:
3618 case elfcpp::R_TILEGX_IMM16_X1_HW1_PCREL:
3619 case elfcpp::R_TILEGX_IMM16_X0_HW2_PCREL:
3620 case elfcpp::R_TILEGX_IMM16_X1_HW2_PCREL:
3621 case elfcpp::R_TILEGX_IMM16_X0_HW3_PCREL:
3622 case elfcpp::R_TILEGX_IMM16_X1_HW3_PCREL:
3623 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
3624 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
3625 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
3626 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
3627 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
3628 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
3629 case elfcpp::R_TILEGX_IMM16_X0_HW0_GOT:
3630 case elfcpp::R_TILEGX_IMM16_X1_HW0_GOT:
3631 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_GOT:
3632 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_GOT:
3633 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_GOT:
3634 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_GOT:
3635 {
3636 return true;
3637 }
3638 }
3639 return false;
3640}
3641
3642// For safe ICF, scan a relocation for a local symbol to check if it
3643// corresponds to a function pointer being taken. In that case mark
3644// the function whose pointer was taken as not foldable.
3645
3646template<int size, bool big_endian>
3647inline bool
3648Target_tilegx<size, big_endian>::Scan::local_reloc_may_be_function_pointer(
3649 Symbol_table* ,
3650 Layout* ,
3651 Target_tilegx<size, big_endian>* ,
3652 Sized_relobj_file<size, big_endian>* ,
3653 unsigned int ,
3654 Output_section* ,
3655 const elfcpp::Rela<size, big_endian>& ,
3656 unsigned int r_type,
3657 const elfcpp::Sym<size, big_endian>&)
3658{
3659 return possible_function_pointer_reloc(r_type);
3660}
3661
3662// For safe ICF, scan a relocation for a global symbol to check if it
3663// corresponds to a function pointer being taken. In that case mark
3664// the function whose pointer was taken as not foldable.
3665
3666template<int size, bool big_endian>
3667inline bool
3668Target_tilegx<size, big_endian>::Scan::global_reloc_may_be_function_pointer(
3669 Symbol_table*,
3670 Layout* ,
3671 Target_tilegx<size, big_endian>* ,
3672 Sized_relobj_file<size, big_endian>* ,
3673 unsigned int ,
3674 Output_section* ,
3675 const elfcpp::Rela<size, big_endian>& ,
3676 unsigned int r_type,
3677 Symbol* gsym)
3678{
3679 // GOT is not a function.
3680 if (strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
3681 return false;
3682
3683 // When building a shared library, do not fold symbols whose visibility
3684 // is hidden, internal or protected.
3685 return ((parameters->options().shared()
3686 && (gsym->visibility() == elfcpp::STV_INTERNAL
3687 || gsym->visibility() == elfcpp::STV_PROTECTED
3688 || gsym->visibility() == elfcpp::STV_HIDDEN))
3689 || possible_function_pointer_reloc(r_type));
3690}
3691
3692// Scan a relocation for a global symbol.
3693
3694template<int size, bool big_endian>
3695inline void
3696Target_tilegx<size, big_endian>::Scan::global(Symbol_table* symtab,
3697 Layout* layout,
3698 Target_tilegx<size, big_endian>* target,
3699 Sized_relobj_file<size, big_endian>* object,
3700 unsigned int data_shndx,
3701 Output_section* output_section,
3702 const elfcpp::Rela<size, big_endian>& reloc,
3703 unsigned int r_type,
3704 Symbol* gsym)
3705{
3706 // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got
3707 // section. We check here to avoid creating a dynamic reloc against
3708 // _GLOBAL_OFFSET_TABLE_.
3709 if (!target->has_got_section()
3710 && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
3711 target->got_section(symtab, layout);
3712
3713 // A STT_GNU_IFUNC symbol may require a PLT entry.
3714 if (gsym->type() == elfcpp::STT_GNU_IFUNC
3715 && this->reloc_needs_plt_for_ifunc(object, r_type))
3716 target->make_plt_entry(symtab, layout, gsym);
3717
3718 switch (r_type)
3719 {
3720 case elfcpp::R_TILEGX_NONE:
3721 case elfcpp::R_TILEGX_GNU_VTINHERIT:
3722 case elfcpp::R_TILEGX_GNU_VTENTRY:
3723 break;
3724
3725 case elfcpp::R_TILEGX_DEST_IMM8_X1:
3726 case elfcpp::R_TILEGX_IMM16_X0_HW0:
3727 case elfcpp::R_TILEGX_IMM16_X1_HW0:
3728 case elfcpp::R_TILEGX_IMM16_X0_HW1:
3729 case elfcpp::R_TILEGX_IMM16_X1_HW1:
3730 case elfcpp::R_TILEGX_IMM16_X0_HW2:
3731 case elfcpp::R_TILEGX_IMM16_X1_HW2:
3732 case elfcpp::R_TILEGX_IMM16_X0_HW3:
3733 case elfcpp::R_TILEGX_IMM16_X1_HW3:
3734 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST:
3735 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST:
3736 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST:
3737 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST:
3738 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST:
3739 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST:
3740 case elfcpp::R_TILEGX_64:
3741 case elfcpp::R_TILEGX_32:
3742 case elfcpp::R_TILEGX_16:
3743 case elfcpp::R_TILEGX_8:
3744 {
3745 // Make a PLT entry if necessary.
3746 if (gsym->needs_plt_entry())
3747 {
3748 target->make_plt_entry(symtab, layout, gsym);
3749 // Since this is not a PC-relative relocation, we may be
3750 // taking the address of a function. In that case we need to
3751 // set the entry in the dynamic symbol table to the address of
3752 // the PLT entry.
3753 if (gsym->is_from_dynobj() && !parameters->options().shared())
3754 gsym->set_needs_dynsym_value();
3755 }
3756 // Make a dynamic relocation if necessary.
3757 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
3758 {
3759 if (gsym->may_need_copy_reloc())
3760 {
3761 target->copy_reloc(symtab, layout, object,
3762 data_shndx, output_section, gsym, reloc);
3763 }
3764 else if (((size == 64 && r_type == elfcpp::R_TILEGX_64)
3765 || (size == 32 && r_type == elfcpp::R_TILEGX_32))
3766 && gsym->type() == elfcpp::STT_GNU_IFUNC
3767 && gsym->can_use_relative_reloc(false)
3768 && !gsym->is_from_dynobj()
3769 && !gsym->is_undefined()
3770 && !gsym->is_preemptible())
3771 {
3772 // Use an IRELATIVE reloc for a locally defined
3773 // STT_GNU_IFUNC symbol. This makes a function
3774 // address in a PIE executable match the address in a
3775 // shared library that it links against.
3776 Reloc_section* rela_dyn =
3777 target->rela_irelative_section(layout);
3778 unsigned int r_type = elfcpp::R_TILEGX_IRELATIVE;
3779 rela_dyn->add_symbolless_global_addend(gsym, r_type,
3780 output_section, object,
3781 data_shndx,
3782 reloc.get_r_offset(),
3783 reloc.get_r_addend());
3784 } else if ((r_type == elfcpp::R_TILEGX_64
3785 || r_type == elfcpp::R_TILEGX_32)
3786 && gsym->can_use_relative_reloc(false))
3787 {
3788 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3789 rela_dyn->add_global_relative(gsym, elfcpp::R_TILEGX_RELATIVE,
3790 output_section, object,
3791 data_shndx,
3792 reloc.get_r_offset(),
3793 reloc.get_r_addend(), false);
3794 }
3795 else
3796 {
3797 this->check_non_pic(object, r_type);
3798 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3799 rela_dyn->add_global(gsym, r_type, output_section, object,
3800 data_shndx, reloc.get_r_offset(),
3801 reloc.get_r_addend());
3802 }
3803 }
3804 }
3805 break;
3806
3807 case elfcpp::R_TILEGX_BROFF_X1:
3808 case elfcpp::R_TILEGX_IMM16_X0_HW0_PCREL:
3809 case elfcpp::R_TILEGX_IMM16_X1_HW0_PCREL:
3810 case elfcpp::R_TILEGX_IMM16_X0_HW1_PCREL:
3811 case elfcpp::R_TILEGX_IMM16_X1_HW1_PCREL:
3812 case elfcpp::R_TILEGX_IMM16_X0_HW2_PCREL:
3813 case elfcpp::R_TILEGX_IMM16_X1_HW2_PCREL:
3814 case elfcpp::R_TILEGX_IMM16_X0_HW3_PCREL:
3815 case elfcpp::R_TILEGX_IMM16_X1_HW3_PCREL:
3816 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
3817 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
3818 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
3819 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
3820 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
3821 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
3822 case elfcpp::R_TILEGX_64_PCREL:
3823 case elfcpp::R_TILEGX_32_PCREL:
3824 case elfcpp::R_TILEGX_16_PCREL:
3825 case elfcpp::R_TILEGX_8_PCREL:
3826 {
3827 // Make a PLT entry if necessary.
3828 if (gsym->needs_plt_entry())
3829 target->make_plt_entry(symtab, layout, gsym);
3830 // Make a dynamic relocation if necessary.
3831 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
3832 {
3833 if (gsym->may_need_copy_reloc())
3834 {
3835 target->copy_reloc(symtab, layout, object,
3836 data_shndx, output_section, gsym, reloc);
3837 }
3838 else
3839 {
3840 this->check_non_pic(object, r_type);
3841 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3842 rela_dyn->add_global(gsym, r_type, output_section, object,
3843 data_shndx, reloc.get_r_offset(),
3844 reloc.get_r_addend());
3845 }
3846 }
3847 }
3848 break;
3849
3850 case elfcpp::R_TILEGX_IMM16_X0_HW0_GOT:
3851 case elfcpp::R_TILEGX_IMM16_X1_HW0_GOT:
3852 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_GOT:
3853 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_GOT:
3854 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_GOT:
3855 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_GOT:
3856 {
3857 // The symbol requires a GOT entry.
3858 Output_data_got<size, big_endian>* got
3859 = target->got_section(symtab, layout);
3860 if (gsym->final_value_is_known())
3861 {
3862 // For a STT_GNU_IFUNC symbol we want the PLT address.
3863 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
3864 got->add_global_plt(gsym, GOT_TYPE_STANDARD);
3865 else
3866 got->add_global(gsym, GOT_TYPE_STANDARD);
3867 }
3868 else
3869 {
3870 // If this symbol is not fully resolved, we need to add a
3871 // dynamic relocation for it.
3872 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
3873
3874 // Use a GLOB_DAT rather than a RELATIVE reloc if:
3875 //
3876 // 1) The symbol may be defined in some other module.
3877 //
3878 // 2) We are building a shared library and this is a
3879 // protected symbol; using GLOB_DAT means that the dynamic
3880 // linker can use the address of the PLT in the main
3881 // executable when appropriate so that function address
3882 // comparisons work.
3883 //
3884 // 3) This is a STT_GNU_IFUNC symbol in position dependent
3885 // code, again so that function address comparisons work.
3886 if (gsym->is_from_dynobj()
3887 || gsym->is_undefined()
3888 || gsym->is_preemptible()
3889 || (gsym->visibility() == elfcpp::STV_PROTECTED
3890 && parameters->options().shared())
3891 || (gsym->type() == elfcpp::STT_GNU_IFUNC
3892 && parameters->options().output_is_position_independent()))
3893 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, rela_dyn,
3894 elfcpp::R_TILEGX_GLOB_DAT);
3895 else
3896 {
3897 // For a STT_GNU_IFUNC symbol we want to write the PLT
3898 // offset into the GOT, so that function pointer
3899 // comparisons work correctly.
3900 bool is_new;
3901 if (gsym->type() != elfcpp::STT_GNU_IFUNC)
3902 is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
3903 else
3904 {
3905 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
3906 // Tell the dynamic linker to use the PLT address
3907 // when resolving relocations.
3908 if (gsym->is_from_dynobj()
3909 && !parameters->options().shared())
3910 gsym->set_needs_dynsym_value();
3911 }
3912 if (is_new)
3913 {
3914 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
3915 rela_dyn->add_global_relative(gsym,
3916 r_type,
3917 got, got_off, 0, false);
3918 }
3919 }
3920 }
3921 }
3922 break;
3923
3924 // a minor difference here for R_TILEGX_JUMPOFF_X1
3925 // between bfd linker and gold linker for gold, when
3926 // R_TILEGX_JUMPOFF_X1 against global symbol, we
3927 // turn it into JUMPOFF_X1_PLT, otherwise the distance
3928 // to the symbol function may overflow at runtime.
3929 case elfcpp::R_TILEGX_JUMPOFF_X1:
3930
3931 case elfcpp::R_TILEGX_JUMPOFF_X1_PLT:
3932 case elfcpp::R_TILEGX_IMM16_X0_HW0_PLT_PCREL:
3933 case elfcpp::R_TILEGX_IMM16_X1_HW0_PLT_PCREL:
3934 case elfcpp::R_TILEGX_IMM16_X0_HW1_PLT_PCREL:
3935 case elfcpp::R_TILEGX_IMM16_X1_HW1_PLT_PCREL:
3936 case elfcpp::R_TILEGX_IMM16_X0_HW2_PLT_PCREL:
3937 case elfcpp::R_TILEGX_IMM16_X1_HW2_PLT_PCREL:
3938 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL:
3939 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL:
3940 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL:
3941 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL:
3942 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL:
3943 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL:
3944 // If the symbol is fully resolved, this is just a PC32 reloc.
3945 // Otherwise we need a PLT entry.
3946 if (gsym->final_value_is_known())
3947 break;
3948 // If building a shared library, we can also skip the PLT entry
3949 // if the symbol is defined in the output file and is protected
3950 // or hidden.
3951 if (gsym->is_defined()
3952 && !gsym->is_from_dynobj()
3953 && !gsym->is_preemptible())
3954 break;
3955 target->make_plt_entry(symtab, layout, gsym);
3956 break;
3957
3958
3959 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
3960 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
3961 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
3962 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
3963 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
3964 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
3965 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
3966 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
3967 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
3968 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
3969 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
3970 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
3971 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
3972 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
3973 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
3974 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
3975 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
3976 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
3977 case elfcpp::R_TILEGX_TLS_GD_CALL:
3978 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
3979 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
3980 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
3981 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
3982 case elfcpp::R_TILEGX_TLS_IE_LOAD:
3983 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
3984 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
3985 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
3986 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
3987 {
3988 const bool is_final = gsym->final_value_is_known();
3989 const tls::Tls_optimization opt_t =
3990 Target_tilegx<size, big_endian>::optimize_tls_reloc(is_final,
3991 r_type);
3992
3993 switch (r_type)
3994 {
3995 // only expand to plt against __tls_get_addr in GD model
3996 case elfcpp::R_TILEGX_TLS_GD_CALL:
3997 if (opt_t == tls::TLSOPT_NONE) {
3998 // FIXME: it's better '__tls_get_addr' referenced explictly
3999 if (!target->tls_get_addr_sym_defined_) {
4000 Symbol* sym = NULL;
4001 options::parse_set(NULL, "__tls_get_addr",
4002 (gold::options::String_set*)
4003 &parameters->options().undefined());
4004 symtab->add_undefined_symbols_from_command_line(layout);
4005 target->tls_get_addr_sym_defined_ = true;
4006 sym = symtab->lookup("__tls_get_addr");
4007 sym->set_in_reg();
4008 }
4009 target->make_plt_entry(symtab, layout,
4010 symtab->lookup("__tls_get_addr"));
4011 }
4012 break;
62fe925a 4013
5c0b3823
WL		 4014 // only make effect when applying relocation
4015 case elfcpp::R_TILEGX_TLS_IE_LOAD:
4016 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
4017 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
4018 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
4019 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
4020 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
4021 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
4022 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
4023 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
4024 break;
62fe925a 4025
5c0b3823 4026 // GD: requires two GOT entry for module index and offset
62fe925a 4027 // IE: requires one GOT entry for tp-relative offset
5c0b3823
WL		 4028 // LE: shouldn't happen for global symbol
4029 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
4030 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
4031 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
4032 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
4033 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
4034 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
4035 {
4036 if (opt_t == tls::TLSOPT_NONE) {
4037 Output_data_got<size, big_endian>* got
4038 = target->got_section(symtab, layout);
4039 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR,
4040 target->rela_dyn_section(layout),
4041 size == 32
4042 ? elfcpp::R_TILEGX_TLS_DTPMOD32
4043 : elfcpp::R_TILEGX_TLS_DTPMOD64,
4044 size == 32
4045 ? elfcpp::R_TILEGX_TLS_DTPOFF32
4046 : elfcpp::R_TILEGX_TLS_DTPOFF64);
4047 } else if (opt_t == tls::TLSOPT_TO_IE) {
4048 // Create a GOT entry for the tp-relative offset.
4049 Output_data_got<size, big_endian>* got
4050 = target->got_section(symtab, layout);
4051 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
4052 target->rela_dyn_section(layout),
4053 size == 32
4054 ? elfcpp::R_TILEGX_TLS_TPOFF32
4055 : elfcpp::R_TILEGX_TLS_TPOFF64);
4056 } else if (opt_t != tls::TLSOPT_TO_LE)
4057 // exteranl symbol should not be optimized to TO_LE
4058 unsupported_reloc_global(object, r_type, gsym);
4059 }
4060 break;
62fe925a 4061
5c0b3823
WL		 4062 // IE
4063 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
4064 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
4065 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
4066 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
4067 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
4068 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
4069 {
4070 layout->set_has_static_tls();
4071 if (opt_t == tls::TLSOPT_NONE) {
4072 // Create a GOT entry for the tp-relative offset.
4073 Output_data_got<size, big_endian>* got
4074 = target->got_section(symtab, layout);
4075 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
4076 target->rela_dyn_section(layout),
4077 size == 32
4078 ? elfcpp::R_TILEGX_TLS_TPOFF32
4079 : elfcpp::R_TILEGX_TLS_TPOFF64);
4080 } else if (opt_t != tls::TLSOPT_TO_LE)
4081 unsupported_reloc_global(object, r_type, gsym);
4082 }
4083 break;
62fe925a 4084
5c0b3823
WL		 4085 // LE
4086 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
4087 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
4088 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
4089 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
4090 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
4091 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
4092 layout->set_has_static_tls();
4093 if (parameters->options().shared()) {
4094 // defer to dynamic linker
4095 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
4096 rela_dyn->add_symbolless_global_addend(gsym, r_type,
4097 output_section, object,
4098 data_shndx,
4099 reloc.get_r_offset(), 0);
4100 }
4101 break;
4102
4103 default:
4104 gold_unreachable();
4105 }
4106 }
4107 break;
4108
4109 // below are outstanding relocs
4110 // should not existed in static linking stage
4111 case elfcpp::R_TILEGX_COPY:
4112 case elfcpp::R_TILEGX_GLOB_DAT:
4113 case elfcpp::R_TILEGX_JMP_SLOT:
4114 case elfcpp::R_TILEGX_RELATIVE:
4115 case elfcpp::R_TILEGX_TLS_TPOFF32:
4116 case elfcpp::R_TILEGX_TLS_TPOFF64:
4117 case elfcpp::R_TILEGX_TLS_DTPMOD32:
4118 case elfcpp::R_TILEGX_TLS_DTPMOD64:
4119 case elfcpp::R_TILEGX_TLS_DTPOFF32:
4120 case elfcpp::R_TILEGX_TLS_DTPOFF64:
4121 gold_error(_("%s: unexpected reloc %u in object file"),
4122 object->name().c_str(), r_type);
4123 break;
4124
4125 default:
4126 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
4127 object->name().c_str(), r_type,
4128 gsym->demangled_name().c_str());
4129 break;
4130 }
4131}
4132
4133template<int size, bool big_endian>
4134void
4135Target_tilegx<size, big_endian>::gc_process_relocs(Symbol_table* symtab,
4136 Layout* layout,
4137 Sized_relobj_file<size, big_endian>* object,
4138 unsigned int data_shndx,
4139 unsigned int sh_type,
4140 const unsigned char* prelocs,
4141 size_t reloc_count,
4142 Output_section* output_section,
4143 bool needs_special_offset_handling,
4144 size_t local_symbol_count,
4145 const unsigned char* plocal_symbols)
4146{
4147 typedef Target_tilegx<size, big_endian> Tilegx;
4148 typedef typename Target_tilegx<size, big_endian>::Scan Scan;
4149
4150 if (sh_type == elfcpp::SHT_REL)
4151 {
4152 return;
4153 }
4154
4155 gold::gc_process_relocs<size, big_endian,
4156 Tilegx, elfcpp::SHT_RELA, Scan,
4157 typename Target_tilegx<size, big_endian>::Relocatable_size_for_reloc>(
4158 symtab,
4159 layout,
4160 this,
4161 object,
4162 data_shndx,
4163 prelocs,
4164 reloc_count,
4165 output_section,
4166 needs_special_offset_handling,
4167 local_symbol_count,
4168 plocal_symbols);
4169}
4170// Scan relocations for a section.
4171
4172template<int size, bool big_endian>
4173void
4174Target_tilegx<size, big_endian>::scan_relocs(Symbol_table* symtab,
4175 Layout* layout,
4176 Sized_relobj_file<size, big_endian>* object,
4177 unsigned int data_shndx,
4178 unsigned int sh_type,
4179 const unsigned char* prelocs,
4180 size_t reloc_count,
4181 Output_section* output_section,
4182 bool needs_special_offset_handling,
4183 size_t local_symbol_count,
4184 const unsigned char* plocal_symbols)
4185{
4186 typedef Target_tilegx<size, big_endian> Tilegx;
4187 typedef typename Target_tilegx<size, big_endian>::Scan Scan;
4188
4189 if (sh_type == elfcpp::SHT_REL)
4190 {
4191 gold_error(_("%s: unsupported REL reloc section"),
4192 object->name().c_str());
4193 return;
4194 }
4195
4196 gold::scan_relocs<size, big_endian, Tilegx, elfcpp::SHT_RELA, Scan>(
4197 symtab,
4198 layout,
4199 this,
4200 object,
4201 data_shndx,
4202 prelocs,
4203 reloc_count,
4204 output_section,
4205 needs_special_offset_handling,
4206 local_symbol_count,
4207 plocal_symbols);
4208}
4209
4210template<int size, bool big_endian>
4211void
4212Target_tilegx<size, big_endian>::do_define_standard_symbols(
4213 Symbol_table* symtab,
4214 Layout* layout)
4215{
4216 Output_section* feedback_section = layout->find_output_section(".feedback");
4217
4218 if (feedback_section != NULL)
4219 {
4220 symtab->define_in_output_data("__feedback_section_end",
4221 NULL,
4222 Symbol_table::PREDEFINED,
4223 feedback_section,
4224 0,
4225 0,
4226 elfcpp::STT_NOTYPE,
4227 elfcpp::STB_GLOBAL,
4228 elfcpp::STV_HIDDEN,
4229 0,
4230 true, // offset_is_from_end
4231 false);
4232 }
4233}
4234
4235// Finalize the sections.
4236
4237template<int size, bool big_endian>
4238void
4239Target_tilegx<size, big_endian>::do_finalize_sections(
4240 Layout* layout,
4241 const Input_objects*,
4242 Symbol_table* symtab)
4243{
4244 const Reloc_section* rel_plt = (this->plt_ == NULL
4245 ? NULL
4246 : this->plt_->rela_plt());
4247 layout->add_target_dynamic_tags(false, this->got_plt_, rel_plt,
4248 this->rela_dyn_, true, true);
4249
4250 // Emit any relocs we saved in an attempt to avoid generating COPY
4251 // relocs.
4252 if (this->copy_relocs_.any_saved_relocs())
4253 this->copy_relocs_.emit(this->rela_dyn_section(layout));
4254
4255 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
4256 // the .got section.
4257 Symbol* sym = this->global_offset_table_;
4258 if (sym != NULL)
4259 {
4260 uint64_t data_size = this->got_->current_data_size();
4261 symtab->get_sized_symbol<size>(sym)->set_symsize(data_size);
e867b647
WL		 4262
4263 // If the .got section is more than 0x8000 bytes, we add
4264 // 0x8000 to the value of _GLOBAL_OFFSET_TABLE_, so that 16
4265 // bit relocations have a greater chance of working.
4266 if (data_size >= 0x8000)
4267 symtab->get_sized_symbol<size>(sym)->set_value(
4268 symtab->get_sized_symbol<size>(sym)->value() + 0x8000);
5c0b3823
WL		 4269 }
4270
4271 if (parameters->doing_static_link()
4272 && (this->plt_ == NULL || !this->plt_->has_irelative_section()))
4273 {
4274 // If linking statically, make sure that the __rela_iplt symbols
4275 // were defined if necessary, even if we didn't create a PLT.
4276 static const Define_symbol_in_segment syms[] =
4277 {
4278 {
4279 "__rela_iplt_start", // name
4280 elfcpp::PT_LOAD, // segment_type
4281 elfcpp::PF_W, // segment_flags_set
4282 elfcpp::PF(0), // segment_flags_clear
4283 0, // value
4284 0, // size
4285 elfcpp::STT_NOTYPE, // type
4286 elfcpp::STB_GLOBAL, // binding
4287 elfcpp::STV_HIDDEN, // visibility
4288 0, // nonvis
4289 Symbol::SEGMENT_START, // offset_from_base
4290 true // only_if_ref
4291 },
4292 {
4293 "__rela_iplt_end", // name
4294 elfcpp::PT_LOAD, // segment_type
4295 elfcpp::PF_W, // segment_flags_set
4296 elfcpp::PF(0), // segment_flags_clear
4297 0, // value
4298 0, // size
4299 elfcpp::STT_NOTYPE, // type
4300 elfcpp::STB_GLOBAL, // binding
4301 elfcpp::STV_HIDDEN, // visibility
4302 0, // nonvis
4303 Symbol::SEGMENT_START, // offset_from_base
4304 true // only_if_ref
4305 }
4306 };
4307
4308 symtab->define_symbols(layout, 2, syms,
4309 layout->script_options()->saw_sections_clause());
4310 }
4311}
4312
4313// Perform a relocation.
4314
4315template<int size, bool big_endian>
4316inline bool
4317Target_tilegx<size, big_endian>::Relocate::relocate(
4318 const Relocate_info<size, big_endian>* relinfo,
4319 Target_tilegx<size, big_endian>* target,
4320 Output_section*,
4321 size_t relnum,
4322 const elfcpp::Rela<size, big_endian>& rela,
4323 unsigned int r_type,
4324 const Sized_symbol<size>* gsym,
4325 const Symbol_value<size>* psymval,
4326 unsigned char* view,
4327 typename elfcpp::Elf_types<size>::Elf_Addr address,
4328 section_size_type)
4329{
0e804863
ILT		 4330 if (view == NULL)
4331 return true;
4332
5c0b3823
WL		 4333 typedef Tilegx_relocate_functions<size, big_endian> TilegxReloc;
4334 typename TilegxReloc::Tilegx_howto r_howto;
4335
4336 const Sized_relobj_file<size, big_endian>* object = relinfo->object;
4337
4338 // Pick the value to use for symbols defined in the PLT.
4339 Symbol_value<size> symval;
4340 if (gsym != NULL
4341 && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
4342 {
19fec8c1 4343 symval.set_output_value(target->plt_address_for_global(gsym));
5c0b3823
WL		 4344 psymval = &symval;
4345 }
4346 else if (gsym == NULL && psymval->is_ifunc_symbol())
4347 {
4348 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
4349 if (object->local_has_plt_offset(r_sym))
4350 {
19fec8c1 4351 symval.set_output_value(target->plt_address_for_local(object, r_sym));
5c0b3823
WL		 4352 psymval = &symval;
4353 }
4354 }
4355
4356 elfcpp::Elf_Xword addend = rela.get_r_addend();
4357
4358 // Get the GOT offset if needed.
4359 // For tilegx, the GOT pointer points to the start of the GOT section.
4360 bool have_got_offset = false;
e867b647
WL		 4361 int got_offset = 0;
4362 int got_base = target->got_ != NULL
4363 ? target->got_->current_data_size() >= 0x8000 ? 0x8000 : 0
4364 : 0;
5c0b3823
WL		 4365 unsigned int got_type = GOT_TYPE_STANDARD;
4366 bool always_apply_relocation = false;
4367 switch (r_type)
4368 {
4369 case elfcpp::R_TILEGX_IMM16_X0_HW0_GOT:
4370 case elfcpp::R_TILEGX_IMM16_X1_HW0_GOT:
4371 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_GOT:
4372 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_GOT:
4373 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_GOT:
4374 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_GOT:
4375 if (gsym != NULL)
4376 {
4377 gold_assert(gsym->has_got_offset(got_type));
e867b647 4378 got_offset = gsym->got_offset(got_type) - got_base;
5c0b3823
WL		 4379 }
4380 else
4381 {
4382 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
4383 gold_assert(object->local_has_got_offset(r_sym, got_type));
e867b647
WL		 4384 got_offset =
4385 object->local_got_offset(r_sym, got_type) - got_base;
5c0b3823
WL		 4386 }
4387 have_got_offset = true;
4388 break;
4389
4390 default:
4391 break;
4392 }
4393
4394 r_howto = TilegxReloc::howto[r_type];
4395 switch (r_type)
4396 {
4397 case elfcpp::R_TILEGX_NONE:
4398 case elfcpp::R_TILEGX_GNU_VTINHERIT:
4399 case elfcpp::R_TILEGX_GNU_VTENTRY:
4400 break;
4401
4402 case elfcpp::R_TILEGX_IMM16_X0_HW0_GOT:
4403 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_GOT:
4404 case elfcpp::R_TILEGX_IMM16_X1_HW0_GOT:
4405 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_GOT:
4406 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_GOT:
4407 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_GOT:
4408 gold_assert(have_got_offset);
4409 symval.set_output_value(got_offset);
4410 psymval = &symval;
4411 always_apply_relocation = true;
4412 addend = 0;
4413
4414 // when under PIC mode, these relocations are deferred to rtld
4415 case elfcpp::R_TILEGX_IMM16_X0_HW0:
4416 case elfcpp::R_TILEGX_IMM16_X1_HW0:
4417 case elfcpp::R_TILEGX_IMM16_X0_HW1:
4418 case elfcpp::R_TILEGX_IMM16_X1_HW1:
4419 case elfcpp::R_TILEGX_IMM16_X0_HW2:
4420 case elfcpp::R_TILEGX_IMM16_X1_HW2:
4421 case elfcpp::R_TILEGX_IMM16_X0_HW3:
4422 case elfcpp::R_TILEGX_IMM16_X1_HW3:
4423 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST:
4424 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST:
4425 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST:
4426 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST:
4427 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST:
4428 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST:
4429 if (always_apply_relocation
4430 || !parameters->options().output_is_position_independent())
4431 TilegxReloc::imm_x_general(view, object, psymval, addend, r_howto);
4432 break;
4433
4434 case elfcpp::R_TILEGX_JUMPOFF_X1:
4435 case elfcpp::R_TILEGX_JUMPOFF_X1_PLT:
4436 gold_assert(gsym == NULL
4437 || gsym->has_plt_offset()
4438 || gsym->final_value_is_known()
4439 || (gsym->is_defined()
4440 && !gsym->is_from_dynobj()
4441 && !gsym->is_preemptible()));
4442 TilegxReloc::imm_x_pcrel_general(view, object, psymval, addend,
4443 address, r_howto);
4444 break;
4445
4446
4447 case elfcpp::R_TILEGX_IMM16_X0_HW0_PLT_PCREL:
4448 case elfcpp::R_TILEGX_IMM16_X0_HW0_PCREL:
4449 case elfcpp::R_TILEGX_IMM16_X1_HW0_PLT_PCREL:
4450 case elfcpp::R_TILEGX_IMM16_X1_HW0_PCREL:
4451 case elfcpp::R_TILEGX_IMM16_X0_HW1_PLT_PCREL:
4452 case elfcpp::R_TILEGX_IMM16_X0_HW1_PCREL:
4453 case elfcpp::R_TILEGX_IMM16_X1_HW1_PLT_PCREL:
4454 case elfcpp::R_TILEGX_IMM16_X1_HW1_PCREL:
4455 case elfcpp::R_TILEGX_IMM16_X0_HW2_PLT_PCREL:
4456 case elfcpp::R_TILEGX_IMM16_X0_HW2_PCREL:
4457 case elfcpp::R_TILEGX_IMM16_X1_HW2_PLT_PCREL:
4458 case elfcpp::R_TILEGX_IMM16_X1_HW2_PCREL:
4459 case elfcpp::R_TILEGX_IMM16_X0_HW3_PCREL:
4460 case elfcpp::R_TILEGX_IMM16_X1_HW3_PCREL:
4461 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL:
4462 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_PCREL:
4463 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL:
4464 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_PCREL:
4465 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL:
4466 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_PCREL:
4467 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL:
4468 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_PCREL:
4469 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL:
4470 case elfcpp::R_TILEGX_IMM16_X0_HW2_LAST_PCREL:
4471 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL:
4472 case elfcpp::R_TILEGX_IMM16_X1_HW2_LAST_PCREL:
4473 TilegxReloc::imm_x_pcrel_general(view, object, psymval, addend,
4474 address, r_howto);
4475 break;
4476
4477 case elfcpp::R_TILEGX_BROFF_X1:
4478 case elfcpp::R_TILEGX_DEST_IMM8_X1:
4479 TilegxReloc::imm_x_two_part_general(view, object, psymval,
4480 addend, address, r_type);
4481 break;
4482
4483
4484 // below are general relocation types, which can be
4485 // handled by target-independent handlers
4486 case elfcpp::R_TILEGX_64:
4487 TilegxReloc::abs64(view, object, psymval, addend);
4488 break;
4489
4490 case elfcpp::R_TILEGX_64_PCREL:
4491 TilegxReloc::pc_abs64(view, object, psymval, addend, address);
4492 break;
4493
4494 case elfcpp::R_TILEGX_32:
4495 TilegxReloc::abs32(view, object, psymval, addend);
4496 break;
4497
4498 case elfcpp::R_TILEGX_32_PCREL:
4499 TilegxReloc::pc_abs32(view, object, psymval, addend, address);
4500 break;
4501
4502 case elfcpp::R_TILEGX_16:
4503 TilegxReloc::abs16(view, object, psymval, addend);
4504 break;
4505
4506 case elfcpp::R_TILEGX_16_PCREL:
4507 TilegxReloc::pc_abs16(view, object, psymval, addend, address);
4508 break;
4509
4510 case elfcpp::R_TILEGX_8:
4511 Relocate_functions<size, big_endian>::rela8(view, object,
4512 psymval, addend);
4513 break;
4514
4515 case elfcpp::R_TILEGX_8_PCREL:
4516 Relocate_functions<size, big_endian>::pcrela8(view, object,
4517 psymval, addend, address);
4518 break;
4519
4520 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
4521 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
4522 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
4523 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
4524 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
4525 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
4526 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
4527 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
4528 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
4529 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
4530 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
4531 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
4532 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
4533 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
4534 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
4535 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
4536 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
4537 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
4538 case elfcpp::R_TILEGX_TLS_GD_CALL:
4539 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
4540 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
4541 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
4542 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
4543 case elfcpp::R_TILEGX_TLS_IE_LOAD:
4544 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
4545 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
4546 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
4547 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
4548 {
4549 const bool is_final = (gsym == NULL
4550 ? !parameters->options().shared()
4551 : gsym->final_value_is_known());
4552 tls::Tls_optimization opt_t =
4553 Target_tilegx<size, big_endian>::optimize_tls_reloc(is_final,
4554 r_type);
4555
4556 switch (r_type)
4557 {
4558
4559 case elfcpp::R_TILEGX_TLS_GD_CALL:
4560 {
4561 if (opt_t == tls::TLSOPT_NONE) {
4562 Symbol *tls_sym = relinfo->symtab->lookup("__tls_get_addr");
4563 symval.set_output_value(
19fec8c1 4564 target->plt_address_for_global(tls_sym));
5c0b3823
WL		 4565 psymval = &symval;
4566 TilegxReloc::imm_x_pcrel_general(view, object, psymval,
4567 addend, address, r_howto);
4568 }
4569 else if (opt_t == tls::TLSOPT_TO_IE
4570 || opt_t == tls::TLSOPT_TO_LE)
4571 TilegxReloc::tls_relax(view, r_type, opt_t);
4572 }
4573 break;
4574
4575 // XX_TLS_GD is the same as normal X_GOT relocation
4576 // except allocating a got entry pair,
4577 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_GD:
4578 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_GD:
4579 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD:
4580 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD:
4581 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD:
4582 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD:
4583 if (opt_t == tls::TLSOPT_NONE) {
4584 got_type = GOT_TYPE_TLS_PAIR;
4585 have_got_offset = true;
4586 } else if (opt_t == tls::TLSOPT_TO_IE) {
4587 got_type = GOT_TYPE_TLS_OFFSET;
4588 have_got_offset = true;
4589 }
4590 goto do_update_value;
4591 // XX_TLS_IE is the same as normal X_GOT relocation
4592 // except allocating one additional runtime relocation
4593 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_IE:
4594 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_IE:
4595 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE:
4596 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE:
4597 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE:
4598 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE:
4599 if (opt_t == tls::TLSOPT_NONE) {
4600 got_type = GOT_TYPE_TLS_OFFSET;
4601 have_got_offset = true;
4602 }
4603 do_update_value:
4604 if (have_got_offset) {
4605 if (gsym != NULL) {
4606 gold_assert(gsym->has_got_offset(got_type));
e867b647 4607 got_offset = gsym->got_offset(got_type) - got_base;
5c0b3823
WL		 4608 } else {
4609 unsigned int r_sym
4610 = elfcpp::elf_r_sym<size>(rela.get_r_info());
4611 gold_assert(object->local_has_got_offset(r_sym, got_type));
e867b647
WL		 4612 got_offset =
4613 object->local_got_offset(r_sym, got_type) - got_base;
5c0b3823
WL		 4614 }
4615 }
4616
4617 if (opt_t == tls::TLSOPT_NONE
4618 || opt_t == tls::TLSOPT_TO_IE) {
4619 // for both GD/IE, these relocations
4620 // actually calculate got offset, so
4621 // there behavior are the same
4622 gold_assert(have_got_offset);
4623 symval.set_output_value(got_offset);
4624 psymval = &symval;
4625 addend = 0;
4626 TilegxReloc::imm_x_general(view, object, psymval,
4627 addend, r_howto);
4628 break;
4629 } // else if (opt_t == tls::TLSOPT_TO_LE)
4630 // both GD/IE are turned into LE, which
4631 // is absolute relocation.
62fe925a 4632 //
5c0b3823 4633 // | go through
62fe925a 4634 // |
5c0b3823
WL		 4635 // V
4636 // LE
62fe925a 4637 //
5c0b3823
WL		 4638 // tp
4639 // |
4640 // V
62fe925a 4641 // t_var1 | t_var2 | t_var3 | ...
5c0b3823
WL		 4642 // --------------------------------------------------
4643 //
4644 // so offset to tp should be negative, we get offset
4645 // from the following formular for LE
4646 //
4647 // t_var1_off = t_var1_sym_value - tls_section_start
4648 //
4649 case elfcpp::R_TILEGX_IMM16_X0_HW0_TLS_LE:
4650 case elfcpp::R_TILEGX_IMM16_X1_HW0_TLS_LE:
4651 case elfcpp::R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE:
4652 case elfcpp::R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE:
4653 case elfcpp::R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE:
4654 case elfcpp::R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE:
4655 {
4656 Output_segment *tls_segment = relinfo->layout->tls_segment();
4657 if (tls_segment == NULL) {
4658 gold_assert(parameters->errors()->error_count() > 0
4659 || issue_undefined_symbol_error(gsym));
4660 return false;
4661 }
62fe925a 4662
5c0b3823
WL		 4663 typename elfcpp::Elf_types<size>::Elf_Addr value
4664 = psymval->value(relinfo->object, 0);
4665 symval.set_output_value(value);
4666 psymval = &symval;
4667 TilegxReloc::imm_x_general(view, object, psymval,
4668 addend, r_howto);
4669 }
4670 break;
4671
4672 // tls relaxation
4673 case elfcpp::R_TILEGX_TLS_IE_LOAD:
4674 case elfcpp::R_TILEGX_IMM8_X0_TLS_ADD:
4675 case elfcpp::R_TILEGX_IMM8_X1_TLS_ADD:
4676 case elfcpp::R_TILEGX_IMM8_Y0_TLS_ADD:
4677 case elfcpp::R_TILEGX_IMM8_Y1_TLS_ADD:
4678 case elfcpp::R_TILEGX_IMM8_X0_TLS_GD_ADD:
4679 case elfcpp::R_TILEGX_IMM8_X1_TLS_GD_ADD:
4680 case elfcpp::R_TILEGX_IMM8_Y0_TLS_GD_ADD:
4681 case elfcpp::R_TILEGX_IMM8_Y1_TLS_GD_ADD:
4682 TilegxReloc::tls_relax(view, r_type, opt_t);
4683 break;
4684
4685 default:
4686 gold_unreachable();
4687 }
4688 }
4689 break;
4690
4691 // below are outstanding relocs
4692 // should not existed in static linking stage
4693 case elfcpp::R_TILEGX_COPY:
4694 case elfcpp::R_TILEGX_GLOB_DAT:
4695 case elfcpp::R_TILEGX_JMP_SLOT:
4696 case elfcpp::R_TILEGX_RELATIVE:
4697 case elfcpp::R_TILEGX_TLS_TPOFF32:
4698 case elfcpp::R_TILEGX_TLS_TPOFF64:
4699 case elfcpp::R_TILEGX_TLS_DTPMOD32:
4700 case elfcpp::R_TILEGX_TLS_DTPMOD64:
4701 case elfcpp::R_TILEGX_TLS_DTPOFF32:
4702 case elfcpp::R_TILEGX_TLS_DTPOFF64:
4703 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
4704 _("unexpected reloc %u in object file"),
4705 r_type);
4706 break;
4707
4708 default:
4709 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
4710 _("unsupported reloc %u"),
4711 r_type);
4712 break;
4713 }
4714
4715 return true;
4716}
4717
4718// Relocate section data.
4719
4720template<int size, bool big_endian>
4721void
4722Target_tilegx<size, big_endian>::relocate_section(
4723 const Relocate_info<size, big_endian>* relinfo,
4724 unsigned int sh_type,
4725 const unsigned char* prelocs,
4726 size_t reloc_count,
4727 Output_section* output_section,
4728 bool needs_special_offset_handling,
4729 unsigned char* view,
4730 typename elfcpp::Elf_types<size>::Elf_Addr address,
4731 section_size_type view_size,
4732 const Reloc_symbol_changes* reloc_symbol_changes)
4733{
4734 typedef Target_tilegx<size, big_endian> Tilegx;
4735 typedef typename Target_tilegx<size, big_endian>::Relocate Tilegx_relocate;
4736
4737 gold_assert(sh_type == elfcpp::SHT_RELA);
4738
168a4726
AM		 4739 gold::relocate_section<size, big_endian, Tilegx, elfcpp::SHT_RELA,
4740 Tilegx_relocate, gold::Default_comdat_behavior>(
5c0b3823
WL		 4741 relinfo,
4742 this,
4743 prelocs,
4744 reloc_count,
4745 output_section,
4746 needs_special_offset_handling,
4747 view,
4748 address,
4749 view_size,
4750 reloc_symbol_changes);
4751}
4752
4753// Apply an incremental relocation. Incremental relocations always refer
4754// to global symbols.
4755
4756template<int size, bool big_endian>
4757void
4758Target_tilegx<size, big_endian>::apply_relocation(
4759 const Relocate_info<size, big_endian>* relinfo,
4760 typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
4761 unsigned int r_type,
4762 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend,
4763 const Symbol* gsym,
4764 unsigned char* view,
4765 typename elfcpp::Elf_types<size>::Elf_Addr address,
4766 section_size_type view_size)
4767{
4768 gold::apply_relocation<size, big_endian, Target_tilegx<size, big_endian>,
4769 typename Target_tilegx<size, big_endian>::Relocate>(
4770 relinfo,
4771 this,
4772 r_offset,
4773 r_type,
4774 r_addend,
4775 gsym,
4776 view,
4777 address,
4778 view_size);
4779}
4780
4781// Return the size of a relocation while scanning during a relocatable
4782// link.
4783
4784template<int size, bool big_endian>
4785unsigned int
4786Target_tilegx<size,big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
4787 unsigned int, Relobj*)
4788{
4789 // We are always SHT_RELA, so we should never get here.
4790 gold_unreachable();
4791 return 0;
4792}
4793
4794// Scan the relocs during a relocatable link.
4795
4796template<int size, bool big_endian>
4797void
4798Target_tilegx<size, big_endian>::scan_relocatable_relocs(
4799 Symbol_table* symtab,
4800 Layout* layout,
4801 Sized_relobj_file<size, big_endian>* object,
4802 unsigned int data_shndx,
4803 unsigned int sh_type,
4804 const unsigned char* prelocs,
4805 size_t reloc_count,
4806 Output_section* output_section,
4807 bool needs_special_offset_handling,
4808 size_t local_symbol_count,
4809 const unsigned char* plocal_symbols,
4810 Relocatable_relocs* rr)
4811{
4812 gold_assert(sh_type == elfcpp::SHT_RELA);
4813
4814 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
4815 Relocatable_size_for_reloc> Scan_relocatable_relocs;
4816
4817 gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
4818 Scan_relocatable_relocs>(
4819 symtab,
4820 layout,
4821 object,
4822 data_shndx,
4823 prelocs,
4824 reloc_count,
4825 output_section,
4826 needs_special_offset_handling,
4827 local_symbol_count,
4828 plocal_symbols,
4829 rr);
4830}
4831
4832// Relocate a section during a relocatable link.
4833
4834template<int size, bool big_endian>
4835void
4836Target_tilegx<size, big_endian>::relocate_relocs(
4837 const Relocate_info<size, big_endian>* relinfo,
4838 unsigned int sh_type,
4839 const unsigned char* prelocs,
4840 size_t reloc_count,
4841 Output_section* output_section,
62fe925a 4842 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
5c0b3823
WL		 4843 const Relocatable_relocs* rr,
4844 unsigned char* view,
4845 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
4846 section_size_type view_size,
4847 unsigned char* reloc_view,
4848 section_size_type reloc_view_size)
4849{
4850 gold_assert(sh_type == elfcpp::SHT_RELA);
4851
4852 gold::relocate_relocs<size, big_endian, elfcpp::SHT_RELA>(
4853 relinfo,
4854 prelocs,
4855 reloc_count,
4856 output_section,
4857 offset_in_output_section,
4858 rr,
4859 view,
4860 view_address,
4861 view_size,
4862 reloc_view,
4863 reloc_view_size);
4864}
4865
4866// Return the value to use for a dynamic which requires special
4867// treatment. This is how we support equality comparisons of function
4868// pointers across shared library boundaries, as described in the
4869// processor specific ABI supplement.
4870
4871template<int size, bool big_endian>
4872uint64_t
4873Target_tilegx<size, big_endian>::do_dynsym_value(const Symbol* gsym) const
4874{
4875 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
19fec8c1 4876 return this->plt_address_for_global(gsym);
5c0b3823
WL		 4877}
4878
4879// Return the value to use for the base of a DW_EH_PE_datarel offset
4880// in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their
4881// assembler can not write out the difference between two labels in
4882// different sections, so instead of using a pc-relative value they
4883// use an offset from the GOT.
4884
4885template<int size, bool big_endian>
4886uint64_t
4887Target_tilegx<size, big_endian>::do_ehframe_datarel_base() const
4888{
4889 gold_assert(this->global_offset_table_ != NULL);
4890 Symbol* sym = this->global_offset_table_;
4891 Sized_symbol<size>* ssym = static_cast<Sized_symbol<size>*>(sym);
4892 return ssym->value();
4893}
4894
62fe925a 4895// The selector for tilegx object files.
5c0b3823
WL		 4896
4897template<int size, bool big_endian>
4898class Target_selector_tilegx : public Target_selector
4899{
4900public:
4901 Target_selector_tilegx()
4902 : Target_selector(elfcpp::EM_TILEGX, size, big_endian,
4903 (size == 64
4904 ? (big_endian ? "elf64-tilegx-be" : "elf64-tilegx-le")
4905 : (big_endian ? "elf32-tilegx-be"
4906 : "elf32-tilegx-le")),
4907 (size == 64
4908 ? (big_endian ? "elf64tilegx_be" : "elf64tilegx")
4909 : (big_endian ? "elf32tilegx_be" : "elf32tilegx")))
4910 { }
4911
4912 Target*
4913 do_instantiate_target()
4914 { return new Target_tilegx<size, big_endian>(); }
4915
4916};
4917
4918Target_selector_tilegx<64, false> target_selector_tilegx64_le;
4919Target_selector_tilegx<32, false> target_selector_tilegx32_le;
4920Target_selector_tilegx<64, true> target_selector_tilegx64_be;
4921Target_selector_tilegx<32, true> target_selector_tilegx32_be;
4922} // End anonymous namespace.
Empty description
This page took 0.664174 seconds and 4 git commands to generate.