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