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