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