1 // x86_64.cc -- x86_64 target support for gold.
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 // Free Software Foundation, Inc.
5 // Written by Ian Lance Taylor <iant@google.com>.
7 // This file is part of gold.
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
30 #include "parameters.h"
37 #include "copy-relocs.h"
39 #include "target-reloc.h"
40 #include "target-select.h"
52 // A class to handle the PLT data.
53 // This is an abstract base class that handles most of the linker details
54 // but does not know the actual contents of PLT entries. The derived
55 // classes below fill in those details.
58 class Output_data_plt_x86_64
: public Output_section_data
61 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, false> Reloc_section
;
63 Output_data_plt_x86_64(Layout
* layout
, uint64_t addralign
,
64 Output_data_got
<64, false>* got
,
65 Output_data_space
* got_plt
,
66 Output_data_space
* got_irelative
)
67 : Output_section_data(addralign
), layout_(layout
), tlsdesc_rel_(NULL
),
68 irelative_rel_(NULL
), got_(got
), got_plt_(got_plt
),
69 got_irelative_(got_irelative
), count_(0), irelative_count_(0),
70 tlsdesc_got_offset_(-1U), free_list_()
71 { this->init(layout
); }
73 Output_data_plt_x86_64(Layout
* layout
, uint64_t plt_entry_size
,
74 Output_data_got
<64, false>* got
,
75 Output_data_space
* got_plt
,
76 Output_data_space
* got_irelative
,
77 unsigned int plt_count
)
78 : Output_section_data((plt_count
+ 1) * plt_entry_size
,
79 plt_entry_size
, false),
80 layout_(layout
), tlsdesc_rel_(NULL
), irelative_rel_(NULL
), got_(got
),
81 got_plt_(got_plt
), got_irelative_(got_irelative
), count_(plt_count
),
82 irelative_count_(0), tlsdesc_got_offset_(-1U), free_list_()
86 // Initialize the free list and reserve the first entry.
87 this->free_list_
.init((plt_count
+ 1) * plt_entry_size
, false);
88 this->free_list_
.remove(0, plt_entry_size
);
91 // Initialize the PLT section.
95 // Add an entry to the PLT.
97 add_entry(Symbol_table
*, Layout
*, Symbol
* gsym
);
99 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
101 add_local_ifunc_entry(Symbol_table
* symtab
, Layout
*,
102 Sized_relobj_file
<size
, false>* relobj
,
103 unsigned int local_sym_index
);
105 // Add the relocation for a PLT entry.
107 add_relocation(Symbol_table
*, Layout
*, Symbol
* gsym
,
108 unsigned int got_offset
);
110 // Add the reserved TLSDESC_PLT entry to the PLT.
112 reserve_tlsdesc_entry(unsigned int got_offset
)
113 { this->tlsdesc_got_offset_
= got_offset
; }
115 // Return true if a TLSDESC_PLT entry has been reserved.
117 has_tlsdesc_entry() const
118 { return this->tlsdesc_got_offset_
!= -1U; }
120 // Return the GOT offset for the reserved TLSDESC_PLT entry.
122 get_tlsdesc_got_offset() const
123 { return this->tlsdesc_got_offset_
; }
125 // Return the offset of the reserved TLSDESC_PLT entry.
127 get_tlsdesc_plt_offset() const
129 return ((this->count_
+ this->irelative_count_
+ 1)
130 * this->get_plt_entry_size());
133 // Return the .rela.plt section data.
136 { return this->rel_
; }
138 // Return where the TLSDESC relocations should go.
140 rela_tlsdesc(Layout
*);
142 // Return where the IRELATIVE relocations should go in the PLT
145 rela_irelative(Symbol_table
*, Layout
*);
147 // Return whether we created a section for IRELATIVE relocations.
149 has_irelative_section() const
150 { return this->irelative_rel_
!= NULL
; }
152 // Return the number of PLT entries.
155 { return this->count_
+ this->irelative_count_
; }
157 // Return the offset of the first non-reserved PLT entry.
159 first_plt_entry_offset()
160 { return this->get_plt_entry_size(); }
162 // Return the size of a PLT entry.
164 get_plt_entry_size() const
165 { return this->do_get_plt_entry_size(); }
167 // Reserve a slot in the PLT for an existing symbol in an incremental update.
169 reserve_slot(unsigned int plt_index
)
171 this->free_list_
.remove((plt_index
+ 1) * this->get_plt_entry_size(),
172 (plt_index
+ 2) * this->get_plt_entry_size());
175 // Return the PLT address to use for a global symbol.
177 address_for_global(const Symbol
*);
179 // Return the PLT address to use for a local symbol.
181 address_for_local(const Relobj
*, unsigned int symndx
);
183 // Add .eh_frame information for the PLT.
185 add_eh_frame(Layout
* layout
)
186 { this->do_add_eh_frame(layout
); }
189 // Fill in the first PLT entry.
191 fill_first_plt_entry(unsigned char* pov
,
192 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
193 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
)
194 { this->do_fill_first_plt_entry(pov
, got_address
, plt_address
); }
196 // Fill in a normal PLT entry. Returns the offset into the entry that
197 // should be the initial GOT slot value.
199 fill_plt_entry(unsigned char* pov
,
200 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
201 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
202 unsigned int got_offset
,
203 unsigned int plt_offset
,
204 unsigned int plt_index
)
206 return this->do_fill_plt_entry(pov
, got_address
, plt_address
,
207 got_offset
, plt_offset
, plt_index
);
210 // Fill in the reserved TLSDESC PLT entry.
212 fill_tlsdesc_entry(unsigned char* pov
,
213 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
214 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
215 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
,
216 unsigned int tlsdesc_got_offset
,
217 unsigned int plt_offset
)
219 this->do_fill_tlsdesc_entry(pov
, got_address
, plt_address
, got_base
,
220 tlsdesc_got_offset
, plt_offset
);
224 do_get_plt_entry_size() const = 0;
227 do_fill_first_plt_entry(unsigned char* pov
,
228 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_addr
,
229 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_addr
)
233 do_fill_plt_entry(unsigned char* pov
,
234 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
235 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
236 unsigned int got_offset
,
237 unsigned int plt_offset
,
238 unsigned int plt_index
) = 0;
241 do_fill_tlsdesc_entry(unsigned char* pov
,
242 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
243 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
244 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
,
245 unsigned int tlsdesc_got_offset
,
246 unsigned int plt_offset
) = 0;
249 do_add_eh_frame(Layout
* layout
) = 0;
252 do_adjust_output_section(Output_section
* os
);
254 // Write to a map file.
256 do_print_to_mapfile(Mapfile
* mapfile
) const
257 { mapfile
->print_output_data(this, _("** PLT")); }
259 // The CIE of the .eh_frame unwind information for the PLT.
260 static const int plt_eh_frame_cie_size
= 16;
261 static const unsigned char plt_eh_frame_cie
[plt_eh_frame_cie_size
];
264 // Set the final size.
266 set_final_data_size();
268 // Write out the PLT data.
270 do_write(Output_file
*);
272 // A pointer to the Layout class, so that we can find the .dynamic
273 // section when we write out the GOT PLT section.
275 // The reloc section.
277 // The TLSDESC relocs, if necessary. These must follow the regular
279 Reloc_section
* tlsdesc_rel_
;
280 // The IRELATIVE relocs, if necessary. These must follow the
281 // regular PLT relocations and the TLSDESC relocations.
282 Reloc_section
* irelative_rel_
;
284 Output_data_got
<64, false>* got_
;
285 // The .got.plt section.
286 Output_data_space
* got_plt_
;
287 // The part of the .got.plt section used for IRELATIVE relocs.
288 Output_data_space
* got_irelative_
;
289 // The number of PLT entries.
291 // Number of PLT entries with R_X86_64_IRELATIVE relocs. These
292 // follow the regular PLT entries.
293 unsigned int irelative_count_
;
294 // Offset of the reserved TLSDESC_GOT entry when needed.
295 unsigned int tlsdesc_got_offset_
;
296 // List of available regions within the section, for incremental
298 Free_list free_list_
;
302 class Output_data_plt_x86_64_standard
: public Output_data_plt_x86_64
<size
>
305 Output_data_plt_x86_64_standard(Layout
* layout
,
306 Output_data_got
<64, false>* got
,
307 Output_data_space
* got_plt
,
308 Output_data_space
* got_irelative
)
309 : Output_data_plt_x86_64
<size
>(layout
, plt_entry_size
,
310 got
, got_plt
, got_irelative
)
313 Output_data_plt_x86_64_standard(Layout
* layout
,
314 Output_data_got
<64, false>* got
,
315 Output_data_space
* got_plt
,
316 Output_data_space
* got_irelative
,
317 unsigned int plt_count
)
318 : Output_data_plt_x86_64
<size
>(layout
, plt_entry_size
,
319 got
, got_plt
, got_irelative
,
325 do_get_plt_entry_size() const
326 { return plt_entry_size
; }
329 do_add_eh_frame(Layout
* layout
)
331 layout
->add_eh_frame_for_plt(this,
332 this->plt_eh_frame_cie
,
333 this->plt_eh_frame_cie_size
,
335 plt_eh_frame_fde_size
);
339 do_fill_first_plt_entry(unsigned char* pov
,
340 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_addr
,
341 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_addr
);
344 do_fill_plt_entry(unsigned char* pov
,
345 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
346 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
347 unsigned int got_offset
,
348 unsigned int plt_offset
,
349 unsigned int plt_index
);
352 do_fill_tlsdesc_entry(unsigned char* pov
,
353 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
354 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
355 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
,
356 unsigned int tlsdesc_got_offset
,
357 unsigned int plt_offset
);
360 // The size of an entry in the PLT.
361 static const int plt_entry_size
= 16;
363 // The first entry in the PLT.
364 // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same
365 // procedure linkage table for both programs and shared objects."
366 static const unsigned char first_plt_entry
[plt_entry_size
];
368 // Other entries in the PLT for an executable.
369 static const unsigned char plt_entry
[plt_entry_size
];
371 // The reserved TLSDESC entry in the PLT for an executable.
372 static const unsigned char tlsdesc_plt_entry
[plt_entry_size
];
374 // The .eh_frame unwind information for the PLT.
375 static const int plt_eh_frame_fde_size
= 32;
376 static const unsigned char plt_eh_frame_fde
[plt_eh_frame_fde_size
];
379 // The x86_64 target class.
381 // http://www.x86-64.org/documentation/abi.pdf
382 // TLS info comes from
383 // http://people.redhat.com/drepper/tls.pdf
384 // http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt
387 class Target_x86_64
: public Sized_target
<size
, false>
390 // In the x86_64 ABI (p 68), it says "The AMD64 ABI architectures
391 // uses only Elf64_Rela relocation entries with explicit addends."
392 typedef Output_data_reloc
<elfcpp::SHT_RELA
, true, size
, false> Reloc_section
;
394 Target_x86_64(const Target::Target_info
* info
= &x86_64_info
)
395 : Sized_target
<size
, false>(info
),
396 got_(NULL
), plt_(NULL
), got_plt_(NULL
), got_irelative_(NULL
),
397 got_tlsdesc_(NULL
), global_offset_table_(NULL
), rela_dyn_(NULL
),
398 rela_irelative_(NULL
), copy_relocs_(elfcpp::R_X86_64_COPY
),
399 dynbss_(NULL
), got_mod_index_offset_(-1U), tlsdesc_reloc_info_(),
400 tls_base_symbol_defined_(false)
403 // Hook for a new output section.
405 do_new_output_section(Output_section
*) const;
407 // Scan the relocations to look for symbol adjustments.
409 gc_process_relocs(Symbol_table
* symtab
,
411 Sized_relobj_file
<size
, false>* object
,
412 unsigned int data_shndx
,
413 unsigned int sh_type
,
414 const unsigned char* prelocs
,
416 Output_section
* output_section
,
417 bool needs_special_offset_handling
,
418 size_t local_symbol_count
,
419 const unsigned char* plocal_symbols
);
421 // Scan the relocations to look for symbol adjustments.
423 scan_relocs(Symbol_table
* symtab
,
425 Sized_relobj_file
<size
, false>* object
,
426 unsigned int data_shndx
,
427 unsigned int sh_type
,
428 const unsigned char* prelocs
,
430 Output_section
* output_section
,
431 bool needs_special_offset_handling
,
432 size_t local_symbol_count
,
433 const unsigned char* plocal_symbols
);
435 // Finalize the sections.
437 do_finalize_sections(Layout
*, const Input_objects
*, Symbol_table
*);
439 // Return the value to use for a dynamic which requires special
442 do_dynsym_value(const Symbol
*) const;
444 // Relocate a section.
446 relocate_section(const Relocate_info
<size
, false>*,
447 unsigned int sh_type
,
448 const unsigned char* prelocs
,
450 Output_section
* output_section
,
451 bool needs_special_offset_handling
,
453 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
454 section_size_type view_size
,
455 const Reloc_symbol_changes
*);
457 // Scan the relocs during a relocatable link.
459 scan_relocatable_relocs(Symbol_table
* symtab
,
461 Sized_relobj_file
<size
, false>* object
,
462 unsigned int data_shndx
,
463 unsigned int sh_type
,
464 const unsigned char* prelocs
,
466 Output_section
* output_section
,
467 bool needs_special_offset_handling
,
468 size_t local_symbol_count
,
469 const unsigned char* plocal_symbols
,
470 Relocatable_relocs
*);
472 // Emit relocations for a section.
475 const Relocate_info
<size
, false>*,
476 unsigned int sh_type
,
477 const unsigned char* prelocs
,
479 Output_section
* output_section
,
480 off_t offset_in_output_section
,
481 const Relocatable_relocs
*,
483 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
484 section_size_type view_size
,
485 unsigned char* reloc_view
,
486 section_size_type reloc_view_size
);
488 // Return a string used to fill a code section with nops.
490 do_code_fill(section_size_type length
) const;
492 // Return whether SYM is defined by the ABI.
494 do_is_defined_by_abi(const Symbol
* sym
) const
495 { return strcmp(sym
->name(), "__tls_get_addr") == 0; }
497 // Return the symbol index to use for a target specific relocation.
498 // The only target specific relocation is R_X86_64_TLSDESC for a
499 // local symbol, which is an absolute reloc.
501 do_reloc_symbol_index(void*, unsigned int r_type
) const
503 gold_assert(r_type
== elfcpp::R_X86_64_TLSDESC
);
507 // Return the addend to use for a target specific relocation.
509 do_reloc_addend(void* arg
, unsigned int r_type
, uint64_t addend
) const;
511 // Return the PLT section.
513 do_plt_address_for_global(const Symbol
* gsym
) const
514 { return this->plt_section()->address_for_global(gsym
); }
517 do_plt_address_for_local(const Relobj
* relobj
, unsigned int symndx
) const
518 { return this->plt_section()->address_for_local(relobj
, symndx
); }
520 // This function should be defined in targets that can use relocation
521 // types to determine (implemented in local_reloc_may_be_function_pointer
522 // and global_reloc_may_be_function_pointer)
523 // if a function's pointer is taken. ICF uses this in safe mode to only
524 // fold those functions whose pointer is defintely not taken. For x86_64
525 // pie binaries, safe ICF cannot be done by looking at relocation types.
527 do_can_check_for_function_pointers() const
528 { return !parameters
->options().pie(); }
530 // Return the base for a DW_EH_PE_datarel encoding.
532 do_ehframe_datarel_base() const;
534 // Adjust -fsplit-stack code which calls non-split-stack code.
536 do_calls_non_split(Relobj
* object
, unsigned int shndx
,
537 section_offset_type fnoffset
, section_size_type fnsize
,
538 unsigned char* view
, section_size_type view_size
,
539 std::string
* from
, std::string
* to
) const;
541 // Return the size of the GOT section.
545 gold_assert(this->got_
!= NULL
);
546 return this->got_
->data_size();
549 // Return the number of entries in the GOT.
551 got_entry_count() const
553 if (this->got_
== NULL
)
555 return this->got_size() / 8;
558 // Return the number of entries in the PLT.
560 plt_entry_count() const;
562 // Return the offset of the first non-reserved PLT entry.
564 first_plt_entry_offset() const;
566 // Return the size of each PLT entry.
568 plt_entry_size() const;
570 // Create the GOT section for an incremental update.
571 Output_data_got_base
*
572 init_got_plt_for_update(Symbol_table
* symtab
,
574 unsigned int got_count
,
575 unsigned int plt_count
);
577 // Reserve a GOT entry for a local symbol, and regenerate any
578 // necessary dynamic relocations.
580 reserve_local_got_entry(unsigned int got_index
,
581 Sized_relobj
<size
, false>* obj
,
583 unsigned int got_type
);
585 // Reserve a GOT entry for a global symbol, and regenerate any
586 // necessary dynamic relocations.
588 reserve_global_got_entry(unsigned int got_index
, Symbol
* gsym
,
589 unsigned int got_type
);
591 // Register an existing PLT entry for a global symbol.
593 register_global_plt_entry(Symbol_table
*, Layout
*, unsigned int plt_index
,
596 // Force a COPY relocation for a given symbol.
598 emit_copy_reloc(Symbol_table
*, Symbol
*, Output_section
*, off_t
);
600 // Apply an incremental relocation.
602 apply_relocation(const Relocate_info
<size
, false>* relinfo
,
603 typename
elfcpp::Elf_types
<size
>::Elf_Addr r_offset
,
605 typename
elfcpp::Elf_types
<size
>::Elf_Swxword r_addend
,
608 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
609 section_size_type view_size
);
611 // Add a new reloc argument, returning the index in the vector.
613 add_tlsdesc_info(Sized_relobj_file
<size
, false>* object
, unsigned int r_sym
)
615 this->tlsdesc_reloc_info_
.push_back(Tlsdesc_info(object
, r_sym
));
616 return this->tlsdesc_reloc_info_
.size() - 1;
619 Output_data_plt_x86_64
<size
>*
620 make_data_plt(Layout
* layout
,
621 Output_data_got
<64, false>* got
,
622 Output_data_space
* got_plt
,
623 Output_data_space
* got_irelative
)
625 return this->do_make_data_plt(layout
, got
, got_plt
, got_irelative
);
628 Output_data_plt_x86_64
<size
>*
629 make_data_plt(Layout
* layout
,
630 Output_data_got
<64, false>* got
,
631 Output_data_space
* got_plt
,
632 Output_data_space
* got_irelative
,
633 unsigned int plt_count
)
635 return this->do_make_data_plt(layout
, got
, got_plt
, got_irelative
,
639 virtual Output_data_plt_x86_64
<size
>*
640 do_make_data_plt(Layout
* layout
,
641 Output_data_got
<64, false>* got
,
642 Output_data_space
* got_plt
,
643 Output_data_space
* got_irelative
)
645 return new Output_data_plt_x86_64_standard
<size
>(layout
, got
, got_plt
,
649 virtual Output_data_plt_x86_64
<size
>*
650 do_make_data_plt(Layout
* layout
,
651 Output_data_got
<64, false>* got
,
652 Output_data_space
* got_plt
,
653 Output_data_space
* got_irelative
,
654 unsigned int plt_count
)
656 return new Output_data_plt_x86_64_standard
<size
>(layout
, got
, got_plt
,
662 // The class which scans relocations.
667 : issued_non_pic_error_(false)
671 get_reference_flags(unsigned int r_type
);
674 local(Symbol_table
* symtab
, Layout
* layout
, Target_x86_64
* target
,
675 Sized_relobj_file
<size
, false>* object
,
676 unsigned int data_shndx
,
677 Output_section
* output_section
,
678 const elfcpp::Rela
<size
, false>& reloc
, unsigned int r_type
,
679 const elfcpp::Sym
<size
, false>& lsym
,
683 global(Symbol_table
* symtab
, Layout
* layout
, Target_x86_64
* target
,
684 Sized_relobj_file
<size
, false>* object
,
685 unsigned int data_shndx
,
686 Output_section
* output_section
,
687 const elfcpp::Rela
<size
, false>& reloc
, unsigned int r_type
,
691 local_reloc_may_be_function_pointer(Symbol_table
* symtab
, Layout
* layout
,
692 Target_x86_64
* target
,
693 Sized_relobj_file
<size
, false>* object
,
694 unsigned int data_shndx
,
695 Output_section
* output_section
,
696 const elfcpp::Rela
<size
, false>& reloc
,
698 const elfcpp::Sym
<size
, false>& lsym
);
701 global_reloc_may_be_function_pointer(Symbol_table
* symtab
, Layout
* layout
,
702 Target_x86_64
* target
,
703 Sized_relobj_file
<size
, false>* object
,
704 unsigned int data_shndx
,
705 Output_section
* output_section
,
706 const elfcpp::Rela
<size
, false>& reloc
,
712 unsupported_reloc_local(Sized_relobj_file
<size
, false>*,
713 unsigned int r_type
);
716 unsupported_reloc_global(Sized_relobj_file
<size
, false>*,
717 unsigned int r_type
, Symbol
*);
720 check_non_pic(Relobj
*, unsigned int r_type
, Symbol
*);
723 possible_function_pointer_reloc(unsigned int r_type
);
726 reloc_needs_plt_for_ifunc(Sized_relobj_file
<size
, false>*,
727 unsigned int r_type
);
729 // Whether we have issued an error about a non-PIC compilation.
730 bool issued_non_pic_error_
;
733 // The class which implements relocation.
738 : skip_call_tls_get_addr_(false)
743 if (this->skip_call_tls_get_addr_
)
745 // FIXME: This needs to specify the location somehow.
746 gold_error(_("missing expected TLS relocation"));
750 // Do a relocation. Return false if the caller should not issue
751 // any warnings about this relocation.
753 relocate(const Relocate_info
<size
, false>*, Target_x86_64
*,
755 size_t relnum
, const elfcpp::Rela
<size
, false>&,
756 unsigned int r_type
, const Sized_symbol
<size
>*,
757 const Symbol_value
<size
>*,
758 unsigned char*, typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
762 // Do a TLS relocation.
764 relocate_tls(const Relocate_info
<size
, false>*, Target_x86_64
*,
765 size_t relnum
, const elfcpp::Rela
<size
, false>&,
766 unsigned int r_type
, const Sized_symbol
<size
>*,
767 const Symbol_value
<size
>*,
768 unsigned char*, typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
771 // Do a TLS General-Dynamic to Initial-Exec transition.
773 tls_gd_to_ie(const Relocate_info
<size
, false>*, size_t relnum
,
774 Output_segment
* tls_segment
,
775 const elfcpp::Rela
<size
, false>&, unsigned int r_type
,
776 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
778 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
779 section_size_type view_size
);
781 // Do a TLS General-Dynamic to Local-Exec transition.
783 tls_gd_to_le(const Relocate_info
<size
, false>*, size_t relnum
,
784 Output_segment
* tls_segment
,
785 const elfcpp::Rela
<size
, false>&, unsigned int r_type
,
786 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
788 section_size_type view_size
);
790 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
792 tls_desc_gd_to_ie(const Relocate_info
<size
, false>*, size_t relnum
,
793 Output_segment
* tls_segment
,
794 const elfcpp::Rela
<size
, false>&, unsigned int r_type
,
795 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
797 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
798 section_size_type view_size
);
800 // Do a TLSDESC-style General-Dynamic to Local-Exec transition.
802 tls_desc_gd_to_le(const Relocate_info
<size
, false>*, size_t relnum
,
803 Output_segment
* tls_segment
,
804 const elfcpp::Rela
<size
, false>&, unsigned int r_type
,
805 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
807 section_size_type view_size
);
809 // Do a TLS Local-Dynamic to Local-Exec transition.
811 tls_ld_to_le(const Relocate_info
<size
, false>*, size_t relnum
,
812 Output_segment
* tls_segment
,
813 const elfcpp::Rela
<size
, false>&, unsigned int r_type
,
814 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
816 section_size_type view_size
);
818 // Do a TLS Initial-Exec to Local-Exec transition.
820 tls_ie_to_le(const Relocate_info
<size
, false>*, size_t relnum
,
821 Output_segment
* tls_segment
,
822 const elfcpp::Rela
<size
, false>&, unsigned int r_type
,
823 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
825 section_size_type view_size
);
827 // This is set if we should skip the next reloc, which should be a
828 // PLT32 reloc against ___tls_get_addr.
829 bool skip_call_tls_get_addr_
;
832 // A class which returns the size required for a relocation type,
833 // used while scanning relocs during a relocatable link.
834 class Relocatable_size_for_reloc
838 get_size_for_reloc(unsigned int, Relobj
*);
841 // Adjust TLS relocation type based on the options and whether this
842 // is a local symbol.
843 static tls::Tls_optimization
844 optimize_tls_reloc(bool is_final
, int r_type
);
846 // Get the GOT section, creating it if necessary.
847 Output_data_got
<64, false>*
848 got_section(Symbol_table
*, Layout
*);
850 // Get the GOT PLT section.
852 got_plt_section() const
854 gold_assert(this->got_plt_
!= NULL
);
855 return this->got_plt_
;
858 // Get the GOT section for TLSDESC entries.
859 Output_data_got
<64, false>*
860 got_tlsdesc_section() const
862 gold_assert(this->got_tlsdesc_
!= NULL
);
863 return this->got_tlsdesc_
;
866 // Create the PLT section.
868 make_plt_section(Symbol_table
* symtab
, Layout
* layout
);
870 // Create a PLT entry for a global symbol.
872 make_plt_entry(Symbol_table
*, Layout
*, Symbol
*);
874 // Create a PLT entry for a local STT_GNU_IFUNC symbol.
876 make_local_ifunc_plt_entry(Symbol_table
*, Layout
*,
877 Sized_relobj_file
<size
, false>* relobj
,
878 unsigned int local_sym_index
);
880 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
882 define_tls_base_symbol(Symbol_table
*, Layout
*);
884 // Create the reserved PLT and GOT entries for the TLS descriptor resolver.
886 reserve_tlsdesc_entries(Symbol_table
* symtab
, Layout
* layout
);
888 // Create a GOT entry for the TLS module index.
890 got_mod_index_entry(Symbol_table
* symtab
, Layout
* layout
,
891 Sized_relobj_file
<size
, false>* object
);
893 // Get the PLT section.
894 Output_data_plt_x86_64
<size
>*
897 gold_assert(this->plt_
!= NULL
);
901 // Get the dynamic reloc section, creating it if necessary.
903 rela_dyn_section(Layout
*);
905 // Get the section to use for TLSDESC relocations.
907 rela_tlsdesc_section(Layout
*) const;
909 // Get the section to use for IRELATIVE relocations.
911 rela_irelative_section(Layout
*);
913 // Add a potential copy relocation.
915 copy_reloc(Symbol_table
* symtab
, Layout
* layout
,
916 Sized_relobj_file
<size
, false>* object
,
917 unsigned int shndx
, Output_section
* output_section
,
918 Symbol
* sym
, const elfcpp::Rela
<size
, false>& reloc
)
920 this->copy_relocs_
.copy_reloc(symtab
, layout
,
921 symtab
->get_sized_symbol
<size
>(sym
),
922 object
, shndx
, output_section
,
923 reloc
, this->rela_dyn_section(layout
));
926 // Information about this specific target which we pass to the
927 // general Target structure.
928 static const Target::Target_info x86_64_info
;
930 // The types of GOT entries needed for this platform.
931 // These values are exposed to the ABI in an incremental link.
932 // Do not renumber existing values without changing the version
933 // number of the .gnu_incremental_inputs section.
936 GOT_TYPE_STANDARD
= 0, // GOT entry for a regular symbol
937 GOT_TYPE_TLS_OFFSET
= 1, // GOT entry for TLS offset
938 GOT_TYPE_TLS_PAIR
= 2, // GOT entry for TLS module/offset pair
939 GOT_TYPE_TLS_DESC
= 3 // GOT entry for TLS_DESC pair
942 // This type is used as the argument to the target specific
943 // relocation routines. The only target specific reloc is
944 // R_X86_64_TLSDESC against a local symbol.
947 Tlsdesc_info(Sized_relobj_file
<size
, false>* a_object
, unsigned int a_r_sym
)
948 : object(a_object
), r_sym(a_r_sym
)
951 // The object in which the local symbol is defined.
952 Sized_relobj_file
<size
, false>* object
;
953 // The local symbol index in the object.
958 Output_data_got
<64, false>* got_
;
960 Output_data_plt_x86_64
<size
>* plt_
;
961 // The GOT PLT section.
962 Output_data_space
* got_plt_
;
963 // The GOT section for IRELATIVE relocations.
964 Output_data_space
* got_irelative_
;
965 // The GOT section for TLSDESC relocations.
966 Output_data_got
<64, false>* got_tlsdesc_
;
967 // The _GLOBAL_OFFSET_TABLE_ symbol.
968 Symbol
* global_offset_table_
;
969 // The dynamic reloc section.
970 Reloc_section
* rela_dyn_
;
971 // The section to use for IRELATIVE relocs.
972 Reloc_section
* rela_irelative_
;
973 // Relocs saved to avoid a COPY reloc.
974 Copy_relocs
<elfcpp::SHT_RELA
, size
, false> copy_relocs_
;
975 // Space for variables copied with a COPY reloc.
976 Output_data_space
* dynbss_
;
977 // Offset of the GOT entry for the TLS module index.
978 unsigned int got_mod_index_offset_
;
979 // We handle R_X86_64_TLSDESC against a local symbol as a target
980 // specific relocation. Here we store the object and local symbol
981 // index for the relocation.
982 std::vector
<Tlsdesc_info
> tlsdesc_reloc_info_
;
983 // True if the _TLS_MODULE_BASE_ symbol has been defined.
984 bool tls_base_symbol_defined_
;
988 const Target::Target_info Target_x86_64
<64>::x86_64_info
=
991 false, // is_big_endian
992 elfcpp::EM_X86_64
, // machine_code
993 false, // has_make_symbol
994 false, // has_resolve
995 true, // has_code_fill
996 true, // is_default_stack_executable
997 true, // can_icf_inline_merge_sections
999 "/lib/ld64.so.1", // program interpreter
1000 0x400000, // default_text_segment_address
1001 0x1000, // abi_pagesize (overridable by -z max-page-size)
1002 0x1000, // common_pagesize (overridable by -z common-page-size)
1003 false, // isolate_execinstr
1005 elfcpp::SHN_UNDEF
, // small_common_shndx
1006 elfcpp::SHN_X86_64_LCOMMON
, // large_common_shndx
1007 0, // small_common_section_flags
1008 elfcpp::SHF_X86_64_LARGE
, // large_common_section_flags
1009 NULL
, // attributes_section
1010 NULL
// attributes_vendor
1014 const Target::Target_info Target_x86_64
<32>::x86_64_info
=
1017 false, // is_big_endian
1018 elfcpp::EM_X86_64
, // machine_code
1019 false, // has_make_symbol
1020 false, // has_resolve
1021 true, // has_code_fill
1022 true, // is_default_stack_executable
1023 true, // can_icf_inline_merge_sections
1025 "/libx32/ldx32.so.1", // program interpreter
1026 0x400000, // default_text_segment_address
1027 0x1000, // abi_pagesize (overridable by -z max-page-size)
1028 0x1000, // common_pagesize (overridable by -z common-page-size)
1029 false, // isolate_execinstr
1031 elfcpp::SHN_UNDEF
, // small_common_shndx
1032 elfcpp::SHN_X86_64_LCOMMON
, // large_common_shndx
1033 0, // small_common_section_flags
1034 elfcpp::SHF_X86_64_LARGE
, // large_common_section_flags
1035 NULL
, // attributes_section
1036 NULL
// attributes_vendor
1039 // This is called when a new output section is created. This is where
1040 // we handle the SHF_X86_64_LARGE.
1044 Target_x86_64
<size
>::do_new_output_section(Output_section
* os
) const
1046 if ((os
->flags() & elfcpp::SHF_X86_64_LARGE
) != 0)
1047 os
->set_is_large_section();
1050 // Get the GOT section, creating it if necessary.
1053 Output_data_got
<64, false>*
1054 Target_x86_64
<size
>::got_section(Symbol_table
* symtab
, Layout
* layout
)
1056 if (this->got_
== NULL
)
1058 gold_assert(symtab
!= NULL
&& layout
!= NULL
);
1060 // When using -z now, we can treat .got.plt as a relro section.
1061 // Without -z now, it is modified after program startup by lazy
1063 bool is_got_plt_relro
= parameters
->options().now();
1064 Output_section_order got_order
= (is_got_plt_relro
1066 : ORDER_RELRO_LAST
);
1067 Output_section_order got_plt_order
= (is_got_plt_relro
1069 : ORDER_NON_RELRO_FIRST
);
1071 this->got_
= new Output_data_got
<64, false>();
1073 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
1075 | elfcpp::SHF_WRITE
),
1076 this->got_
, got_order
, true);
1078 this->got_plt_
= new Output_data_space(8, "** GOT PLT");
1079 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
1081 | elfcpp::SHF_WRITE
),
1082 this->got_plt_
, got_plt_order
,
1085 // The first three entries are reserved.
1086 this->got_plt_
->set_current_data_size(3 * 8);
1088 if (!is_got_plt_relro
)
1090 // Those bytes can go into the relro segment.
1091 layout
->increase_relro(3 * 8);
1094 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1095 this->global_offset_table_
=
1096 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
1097 Symbol_table::PREDEFINED
,
1099 0, 0, elfcpp::STT_OBJECT
,
1101 elfcpp::STV_HIDDEN
, 0,
1104 // If there are any IRELATIVE relocations, they get GOT entries
1105 // in .got.plt after the jump slot entries.
1106 this->got_irelative_
= new Output_data_space(8, "** GOT IRELATIVE PLT");
1107 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
1109 | elfcpp::SHF_WRITE
),
1110 this->got_irelative_
,
1111 got_plt_order
, is_got_plt_relro
);
1113 // If there are any TLSDESC relocations, they get GOT entries in
1114 // .got.plt after the jump slot and IRELATIVE entries.
1115 this->got_tlsdesc_
= new Output_data_got
<64, false>();
1116 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
1118 | elfcpp::SHF_WRITE
),
1120 got_plt_order
, is_got_plt_relro
);
1126 // Get the dynamic reloc section, creating it if necessary.
1129 typename Target_x86_64
<size
>::Reloc_section
*
1130 Target_x86_64
<size
>::rela_dyn_section(Layout
* layout
)
1132 if (this->rela_dyn_
== NULL
)
1134 gold_assert(layout
!= NULL
);
1135 this->rela_dyn_
= new Reloc_section(parameters
->options().combreloc());
1136 layout
->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA
,
1137 elfcpp::SHF_ALLOC
, this->rela_dyn_
,
1138 ORDER_DYNAMIC_RELOCS
, false);
1140 return this->rela_dyn_
;
1143 // Get the section to use for IRELATIVE relocs, creating it if
1144 // necessary. These go in .rela.dyn, but only after all other dynamic
1145 // relocations. They need to follow the other dynamic relocations so
1146 // that they can refer to global variables initialized by those
1150 typename Target_x86_64
<size
>::Reloc_section
*
1151 Target_x86_64
<size
>::rela_irelative_section(Layout
* layout
)
1153 if (this->rela_irelative_
== NULL
)
1155 // Make sure we have already created the dynamic reloc section.
1156 this->rela_dyn_section(layout
);
1157 this->rela_irelative_
= new Reloc_section(false);
1158 layout
->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA
,
1159 elfcpp::SHF_ALLOC
, this->rela_irelative_
,
1160 ORDER_DYNAMIC_RELOCS
, false);
1161 gold_assert(this->rela_dyn_
->output_section()
1162 == this->rela_irelative_
->output_section());
1164 return this->rela_irelative_
;
1167 // Initialize the PLT section.
1171 Output_data_plt_x86_64
<size
>::init(Layout
* layout
)
1173 this->rel_
= new Reloc_section(false);
1174 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
1175 elfcpp::SHF_ALLOC
, this->rel_
,
1176 ORDER_DYNAMIC_PLT_RELOCS
, false);
1181 Output_data_plt_x86_64
<size
>::do_adjust_output_section(Output_section
* os
)
1183 os
->set_entsize(this->get_plt_entry_size());
1186 // Add an entry to the PLT.
1190 Output_data_plt_x86_64
<size
>::add_entry(Symbol_table
* symtab
, Layout
* layout
,
1193 gold_assert(!gsym
->has_plt_offset());
1195 unsigned int plt_index
;
1197 section_offset_type got_offset
;
1199 unsigned int* pcount
;
1200 unsigned int offset
;
1201 unsigned int reserved
;
1202 Output_data_space
* got
;
1203 if (gsym
->type() == elfcpp::STT_GNU_IFUNC
1204 && gsym
->can_use_relative_reloc(false))
1206 pcount
= &this->irelative_count_
;
1209 got
= this->got_irelative_
;
1213 pcount
= &this->count_
;
1216 got
= this->got_plt_
;
1219 if (!this->is_data_size_valid())
1221 // Note that when setting the PLT offset for a non-IRELATIVE
1222 // entry we skip the initial reserved PLT entry.
1223 plt_index
= *pcount
+ offset
;
1224 plt_offset
= plt_index
* this->get_plt_entry_size();
1228 got_offset
= (plt_index
- offset
+ reserved
) * 8;
1229 gold_assert(got_offset
== got
->current_data_size());
1231 // Every PLT entry needs a GOT entry which points back to the PLT
1232 // entry (this will be changed by the dynamic linker, normally
1233 // lazily when the function is called).
1234 got
->set_current_data_size(got_offset
+ 8);
1238 // FIXME: This is probably not correct for IRELATIVE relocs.
1240 // For incremental updates, find an available slot.
1241 plt_offset
= this->free_list_
.allocate(this->get_plt_entry_size(),
1242 this->get_plt_entry_size(), 0);
1243 if (plt_offset
== -1)
1244 gold_fallback(_("out of patch space (PLT);"
1245 " relink with --incremental-full"));
1247 // The GOT and PLT entries have a 1-1 correspondance, so the GOT offset
1248 // can be calculated from the PLT index, adjusting for the three
1249 // reserved entries at the beginning of the GOT.
1250 plt_index
= plt_offset
/ this->get_plt_entry_size() - 1;
1251 got_offset
= (plt_index
- offset
+ reserved
) * 8;
1254 gsym
->set_plt_offset(plt_offset
);
1256 // Every PLT entry needs a reloc.
1257 this->add_relocation(symtab
, layout
, gsym
, got_offset
);
1259 // Note that we don't need to save the symbol. The contents of the
1260 // PLT are independent of which symbols are used. The symbols only
1261 // appear in the relocations.
1264 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return
1269 Output_data_plt_x86_64
<size
>::add_local_ifunc_entry(
1270 Symbol_table
* symtab
,
1272 Sized_relobj_file
<size
, false>* relobj
,
1273 unsigned int local_sym_index
)
1275 unsigned int plt_offset
= this->irelative_count_
* this->get_plt_entry_size();
1276 ++this->irelative_count_
;
1278 section_offset_type got_offset
= this->got_irelative_
->current_data_size();
1280 // Every PLT entry needs a GOT entry which points back to the PLT
1282 this->got_irelative_
->set_current_data_size(got_offset
+ 8);
1284 // Every PLT entry needs a reloc.
1285 Reloc_section
* rela
= this->rela_irelative(symtab
, layout
);
1286 rela
->add_symbolless_local_addend(relobj
, local_sym_index
,
1287 elfcpp::R_X86_64_IRELATIVE
,
1288 this->got_irelative_
, got_offset
, 0);
1293 // Add the relocation for a PLT entry.
1297 Output_data_plt_x86_64
<size
>::add_relocation(Symbol_table
* symtab
,
1300 unsigned int got_offset
)
1302 if (gsym
->type() == elfcpp::STT_GNU_IFUNC
1303 && gsym
->can_use_relative_reloc(false))
1305 Reloc_section
* rela
= this->rela_irelative(symtab
, layout
);
1306 rela
->add_symbolless_global_addend(gsym
, elfcpp::R_X86_64_IRELATIVE
,
1307 this->got_irelative_
, got_offset
, 0);
1311 gsym
->set_needs_dynsym_entry();
1312 this->rel_
->add_global(gsym
, elfcpp::R_X86_64_JUMP_SLOT
, this->got_plt_
,
1317 // Return where the TLSDESC relocations should go, creating it if
1318 // necessary. These follow the JUMP_SLOT relocations.
1321 typename Output_data_plt_x86_64
<size
>::Reloc_section
*
1322 Output_data_plt_x86_64
<size
>::rela_tlsdesc(Layout
* layout
)
1324 if (this->tlsdesc_rel_
== NULL
)
1326 this->tlsdesc_rel_
= new Reloc_section(false);
1327 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
1328 elfcpp::SHF_ALLOC
, this->tlsdesc_rel_
,
1329 ORDER_DYNAMIC_PLT_RELOCS
, false);
1330 gold_assert(this->tlsdesc_rel_
->output_section()
1331 == this->rel_
->output_section());
1333 return this->tlsdesc_rel_
;
1336 // Return where the IRELATIVE relocations should go in the PLT. These
1337 // follow the JUMP_SLOT and the TLSDESC relocations.
1340 typename Output_data_plt_x86_64
<size
>::Reloc_section
*
1341 Output_data_plt_x86_64
<size
>::rela_irelative(Symbol_table
* symtab
,
1344 if (this->irelative_rel_
== NULL
)
1346 // Make sure we have a place for the TLSDESC relocations, in
1347 // case we see any later on.
1348 this->rela_tlsdesc(layout
);
1349 this->irelative_rel_
= new Reloc_section(false);
1350 layout
->add_output_section_data(".rela.plt", elfcpp::SHT_RELA
,
1351 elfcpp::SHF_ALLOC
, this->irelative_rel_
,
1352 ORDER_DYNAMIC_PLT_RELOCS
, false);
1353 gold_assert(this->irelative_rel_
->output_section()
1354 == this->rel_
->output_section());
1356 if (parameters
->doing_static_link())
1358 // A statically linked executable will only have a .rela.plt
1359 // section to hold R_X86_64_IRELATIVE relocs for
1360 // STT_GNU_IFUNC symbols. The library will use these
1361 // symbols to locate the IRELATIVE relocs at program startup
1363 symtab
->define_in_output_data("__rela_iplt_start", NULL
,
1364 Symbol_table::PREDEFINED
,
1365 this->irelative_rel_
, 0, 0,
1366 elfcpp::STT_NOTYPE
, elfcpp::STB_GLOBAL
,
1367 elfcpp::STV_HIDDEN
, 0, false, true);
1368 symtab
->define_in_output_data("__rela_iplt_end", NULL
,
1369 Symbol_table::PREDEFINED
,
1370 this->irelative_rel_
, 0, 0,
1371 elfcpp::STT_NOTYPE
, elfcpp::STB_GLOBAL
,
1372 elfcpp::STV_HIDDEN
, 0, true, true);
1375 return this->irelative_rel_
;
1378 // Return the PLT address to use for a global symbol.
1382 Output_data_plt_x86_64
<size
>::address_for_global(const Symbol
* gsym
)
1384 uint64_t offset
= 0;
1385 if (gsym
->type() == elfcpp::STT_GNU_IFUNC
1386 && gsym
->can_use_relative_reloc(false))
1387 offset
= (this->count_
+ 1) * this->get_plt_entry_size();
1388 return this->address() + offset
;
1391 // Return the PLT address to use for a local symbol. These are always
1392 // IRELATIVE relocs.
1396 Output_data_plt_x86_64
<size
>::address_for_local(const Relobj
*, unsigned int)
1398 return this->address() + (this->count_
+ 1) * this->get_plt_entry_size();
1401 // Set the final size.
1404 Output_data_plt_x86_64
<size
>::set_final_data_size()
1406 unsigned int count
= this->count_
+ this->irelative_count_
;
1407 if (this->has_tlsdesc_entry())
1409 this->set_data_size((count
+ 1) * this->get_plt_entry_size());
1412 // The first entry in the PLT for an executable.
1416 Output_data_plt_x86_64_standard
<size
>::first_plt_entry
[plt_entry_size
] =
1418 // From AMD64 ABI Draft 0.98, page 76
1419 0xff, 0x35, // pushq contents of memory address
1420 0, 0, 0, 0, // replaced with address of .got + 8
1421 0xff, 0x25, // jmp indirect
1422 0, 0, 0, 0, // replaced with address of .got + 16
1423 0x90, 0x90, 0x90, 0x90 // noop (x4)
1428 Output_data_plt_x86_64_standard
<size
>::do_fill_first_plt_entry(
1430 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
1431 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
)
1433 memcpy(pov
, first_plt_entry
, plt_entry_size
);
1434 // We do a jmp relative to the PC at the end of this instruction.
1435 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 2,
1437 - (plt_address
+ 6)));
1438 elfcpp::Swap
<32, false>::writeval(pov
+ 8,
1440 - (plt_address
+ 12)));
1443 // Subsequent entries in the PLT for an executable.
1447 Output_data_plt_x86_64_standard
<size
>::plt_entry
[plt_entry_size
] =
1449 // From AMD64 ABI Draft 0.98, page 76
1450 0xff, 0x25, // jmpq indirect
1451 0, 0, 0, 0, // replaced with address of symbol in .got
1452 0x68, // pushq immediate
1453 0, 0, 0, 0, // replaced with offset into relocation table
1454 0xe9, // jmpq relative
1455 0, 0, 0, 0 // replaced with offset to start of .plt
1460 Output_data_plt_x86_64_standard
<size
>::do_fill_plt_entry(
1462 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
1463 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
1464 unsigned int got_offset
,
1465 unsigned int plt_offset
,
1466 unsigned int plt_index
)
1468 memcpy(pov
, plt_entry
, plt_entry_size
);
1469 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 2,
1470 (got_address
+ got_offset
1471 - (plt_address
+ plt_offset
1474 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 7, plt_index
);
1475 elfcpp::Swap
<32, false>::writeval(pov
+ 12,
1476 - (plt_offset
+ plt_entry_size
));
1481 // The reserved TLSDESC entry in the PLT for an executable.
1485 Output_data_plt_x86_64_standard
<size
>::tlsdesc_plt_entry
[plt_entry_size
] =
1487 // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32
1488 // and AMD64/EM64T", Version 0.9.4 (2005-10-10).
1489 0xff, 0x35, // pushq x(%rip)
1490 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
1491 0xff, 0x25, // jmpq *y(%rip)
1492 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
1499 Output_data_plt_x86_64_standard
<size
>::do_fill_tlsdesc_entry(
1501 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
1502 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
1503 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
,
1504 unsigned int tlsdesc_got_offset
,
1505 unsigned int plt_offset
)
1507 memcpy(pov
, tlsdesc_plt_entry
, plt_entry_size
);
1508 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 2,
1510 - (plt_address
+ plt_offset
1512 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 8,
1514 + tlsdesc_got_offset
1515 - (plt_address
+ plt_offset
1519 // The .eh_frame unwind information for the PLT.
1523 Output_data_plt_x86_64
<size
>::plt_eh_frame_cie
[plt_eh_frame_cie_size
] =
1526 'z', // Augmentation: augmentation size included.
1527 'R', // Augmentation: FDE encoding included.
1528 '\0', // End of augmentation string.
1529 1, // Code alignment factor.
1530 0x78, // Data alignment factor.
1531 16, // Return address column.
1532 1, // Augmentation size.
1533 (elfcpp::DW_EH_PE_pcrel
// FDE encoding.
1534 | elfcpp::DW_EH_PE_sdata4
),
1535 elfcpp::DW_CFA_def_cfa
, 7, 8, // DW_CFA_def_cfa: r7 (rsp) ofs 8.
1536 elfcpp::DW_CFA_offset
+ 16, 1,// DW_CFA_offset: r16 (rip) at cfa-8.
1537 elfcpp::DW_CFA_nop
, // Align to 16 bytes.
1543 Output_data_plt_x86_64_standard
<size
>::plt_eh_frame_fde
[plt_eh_frame_fde_size
] =
1545 0, 0, 0, 0, // Replaced with offset to .plt.
1546 0, 0, 0, 0, // Replaced with size of .plt.
1547 0, // Augmentation size.
1548 elfcpp::DW_CFA_def_cfa_offset
, 16, // DW_CFA_def_cfa_offset: 16.
1549 elfcpp::DW_CFA_advance_loc
+ 6, // Advance 6 to __PLT__ + 6.
1550 elfcpp::DW_CFA_def_cfa_offset
, 24, // DW_CFA_def_cfa_offset: 24.
1551 elfcpp::DW_CFA_advance_loc
+ 10, // Advance 10 to __PLT__ + 16.
1552 elfcpp::DW_CFA_def_cfa_expression
, // DW_CFA_def_cfa_expression.
1553 11, // Block length.
1554 elfcpp::DW_OP_breg7
, 8, // Push %rsp + 8.
1555 elfcpp::DW_OP_breg16
, 0, // Push %rip.
1556 elfcpp::DW_OP_lit15
, // Push 0xf.
1557 elfcpp::DW_OP_and
, // & (%rip & 0xf).
1558 elfcpp::DW_OP_lit11
, // Push 0xb.
1559 elfcpp::DW_OP_ge
, // >= ((%rip & 0xf) >= 0xb)
1560 elfcpp::DW_OP_lit3
, // Push 3.
1561 elfcpp::DW_OP_shl
, // << (((%rip & 0xf) >= 0xb) << 3)
1562 elfcpp::DW_OP_plus
, // + ((((%rip&0xf)>=0xb)<<3)+%rsp+8
1563 elfcpp::DW_CFA_nop
, // Align to 32 bytes.
1569 // Write out the PLT. This uses the hand-coded instructions above,
1570 // and adjusts them as needed. This is specified by the AMD64 ABI.
1574 Output_data_plt_x86_64
<size
>::do_write(Output_file
* of
)
1576 const off_t offset
= this->offset();
1577 const section_size_type oview_size
=
1578 convert_to_section_size_type(this->data_size());
1579 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
1581 const off_t got_file_offset
= this->got_plt_
->offset();
1582 gold_assert(parameters
->incremental_update()
1583 || (got_file_offset
+ this->got_plt_
->data_size()
1584 == this->got_irelative_
->offset()));
1585 const section_size_type got_size
=
1586 convert_to_section_size_type(this->got_plt_
->data_size()
1587 + this->got_irelative_
->data_size());
1588 unsigned char* const got_view
= of
->get_output_view(got_file_offset
,
1591 unsigned char* pov
= oview
;
1593 // The base address of the .plt section.
1594 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
= this->address();
1595 // The base address of the .got section.
1596 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
= this->got_
->address();
1597 // The base address of the PLT portion of the .got section,
1598 // which is where the GOT pointer will point, and where the
1599 // three reserved GOT entries are located.
1600 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
1601 = this->got_plt_
->address();
1603 this->fill_first_plt_entry(pov
, got_address
, plt_address
);
1604 pov
+= this->get_plt_entry_size();
1606 unsigned char* got_pov
= got_view
;
1608 // The first entry in the GOT is the address of the .dynamic section
1609 // aka the PT_DYNAMIC segment. The next two entries are reserved.
1610 // We saved space for them when we created the section in
1611 // Target_x86_64::got_section.
1612 Output_section
* dynamic
= this->layout_
->dynamic_section();
1613 uint32_t dynamic_addr
= dynamic
== NULL
? 0 : dynamic
->address();
1614 elfcpp::Swap
<64, false>::writeval(got_pov
, dynamic_addr
);
1616 memset(got_pov
, 0, 16);
1619 unsigned int plt_offset
= this->get_plt_entry_size();
1620 unsigned int got_offset
= 24;
1621 const unsigned int count
= this->count_
+ this->irelative_count_
;
1622 for (unsigned int plt_index
= 0;
1625 pov
+= this->get_plt_entry_size(),
1627 plt_offset
+= this->get_plt_entry_size(),
1630 // Set and adjust the PLT entry itself.
1631 unsigned int lazy_offset
= this->fill_plt_entry(pov
,
1632 got_address
, plt_address
,
1633 got_offset
, plt_offset
,
1636 // Set the entry in the GOT.
1637 elfcpp::Swap
<64, false>::writeval(got_pov
,
1638 plt_address
+ plt_offset
+ lazy_offset
);
1641 if (this->has_tlsdesc_entry())
1643 // Set and adjust the reserved TLSDESC PLT entry.
1644 unsigned int tlsdesc_got_offset
= this->get_tlsdesc_got_offset();
1645 this->fill_tlsdesc_entry(pov
, got_address
, plt_address
, got_base
,
1646 tlsdesc_got_offset
, plt_offset
);
1647 pov
+= this->get_plt_entry_size();
1650 gold_assert(static_cast<section_size_type
>(pov
- oview
) == oview_size
);
1651 gold_assert(static_cast<section_size_type
>(got_pov
- got_view
) == got_size
);
1653 of
->write_output_view(offset
, oview_size
, oview
);
1654 of
->write_output_view(got_file_offset
, got_size
, got_view
);
1657 // Create the PLT section.
1661 Target_x86_64
<size
>::make_plt_section(Symbol_table
* symtab
, Layout
* layout
)
1663 if (this->plt_
== NULL
)
1665 // Create the GOT sections first.
1666 this->got_section(symtab
, layout
);
1668 this->plt_
= this->make_data_plt(layout
, this->got_
, this->got_plt_
,
1669 this->got_irelative_
);
1671 // Add unwind information if requested.
1672 if (parameters
->options().ld_generated_unwind_info())
1673 this->plt_
->add_eh_frame(layout
);
1675 layout
->add_output_section_data(".plt", elfcpp::SHT_PROGBITS
,
1677 | elfcpp::SHF_EXECINSTR
),
1678 this->plt_
, ORDER_PLT
, false);
1680 // Make the sh_info field of .rela.plt point to .plt.
1681 Output_section
* rela_plt_os
= this->plt_
->rela_plt()->output_section();
1682 rela_plt_os
->set_info_section(this->plt_
->output_section());
1686 // Return the section for TLSDESC relocations.
1689 typename Target_x86_64
<size
>::Reloc_section
*
1690 Target_x86_64
<size
>::rela_tlsdesc_section(Layout
* layout
) const
1692 return this->plt_section()->rela_tlsdesc(layout
);
1695 // Create a PLT entry for a global symbol.
1699 Target_x86_64
<size
>::make_plt_entry(Symbol_table
* symtab
, Layout
* layout
,
1702 if (gsym
->has_plt_offset())
1705 if (this->plt_
== NULL
)
1706 this->make_plt_section(symtab
, layout
);
1708 this->plt_
->add_entry(symtab
, layout
, gsym
);
1711 // Make a PLT entry for a local STT_GNU_IFUNC symbol.
1715 Target_x86_64
<size
>::make_local_ifunc_plt_entry(
1716 Symbol_table
* symtab
, Layout
* layout
,
1717 Sized_relobj_file
<size
, false>* relobj
,
1718 unsigned int local_sym_index
)
1720 if (relobj
->local_has_plt_offset(local_sym_index
))
1722 if (this->plt_
== NULL
)
1723 this->make_plt_section(symtab
, layout
);
1724 unsigned int plt_offset
= this->plt_
->add_local_ifunc_entry(symtab
, layout
,
1727 relobj
->set_local_plt_offset(local_sym_index
, plt_offset
);
1730 // Return the number of entries in the PLT.
1734 Target_x86_64
<size
>::plt_entry_count() const
1736 if (this->plt_
== NULL
)
1738 return this->plt_
->entry_count();
1741 // Return the offset of the first non-reserved PLT entry.
1745 Target_x86_64
<size
>::first_plt_entry_offset() const
1747 return this->plt_
->first_plt_entry_offset();
1750 // Return the size of each PLT entry.
1754 Target_x86_64
<size
>::plt_entry_size() const
1756 return this->plt_
->get_plt_entry_size();
1759 // Create the GOT and PLT sections for an incremental update.
1762 Output_data_got_base
*
1763 Target_x86_64
<size
>::init_got_plt_for_update(Symbol_table
* symtab
,
1765 unsigned int got_count
,
1766 unsigned int plt_count
)
1768 gold_assert(this->got_
== NULL
);
1770 this->got_
= new Output_data_got
<64, false>(got_count
* 8);
1771 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
1773 | elfcpp::SHF_WRITE
),
1774 this->got_
, ORDER_RELRO_LAST
,
1777 // Add the three reserved entries.
1778 this->got_plt_
= new Output_data_space((plt_count
+ 3) * 8, 8, "** GOT PLT");
1779 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
1781 | elfcpp::SHF_WRITE
),
1782 this->got_plt_
, ORDER_NON_RELRO_FIRST
,
1785 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1786 this->global_offset_table_
=
1787 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
1788 Symbol_table::PREDEFINED
,
1790 0, 0, elfcpp::STT_OBJECT
,
1792 elfcpp::STV_HIDDEN
, 0,
1795 // If there are any TLSDESC relocations, they get GOT entries in
1796 // .got.plt after the jump slot entries.
1797 // FIXME: Get the count for TLSDESC entries.
1798 this->got_tlsdesc_
= new Output_data_got
<64, false>(0);
1799 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
1800 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
1802 ORDER_NON_RELRO_FIRST
, false);
1804 // If there are any IRELATIVE relocations, they get GOT entries in
1805 // .got.plt after the jump slot and TLSDESC entries.
1806 this->got_irelative_
= new Output_data_space(0, 8, "** GOT IRELATIVE PLT");
1807 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
1808 elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
,
1809 this->got_irelative_
,
1810 ORDER_NON_RELRO_FIRST
, false);
1812 // Create the PLT section.
1813 this->plt_
= this->make_data_plt(layout
, this->got_
,
1815 this->got_irelative_
,
1818 // Add unwind information if requested.
1819 if (parameters
->options().ld_generated_unwind_info())
1820 this->plt_
->add_eh_frame(layout
);
1822 layout
->add_output_section_data(".plt", elfcpp::SHT_PROGBITS
,
1823 elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR
,
1824 this->plt_
, ORDER_PLT
, false);
1826 // Make the sh_info field of .rela.plt point to .plt.
1827 Output_section
* rela_plt_os
= this->plt_
->rela_plt()->output_section();
1828 rela_plt_os
->set_info_section(this->plt_
->output_section());
1830 // Create the rela_dyn section.
1831 this->rela_dyn_section(layout
);
1836 // Reserve a GOT entry for a local symbol, and regenerate any
1837 // necessary dynamic relocations.
1841 Target_x86_64
<size
>::reserve_local_got_entry(
1842 unsigned int got_index
,
1843 Sized_relobj
<size
, false>* obj
,
1845 unsigned int got_type
)
1847 unsigned int got_offset
= got_index
* 8;
1848 Reloc_section
* rela_dyn
= this->rela_dyn_section(NULL
);
1850 this->got_
->reserve_local(got_index
, obj
, r_sym
, got_type
);
1853 case GOT_TYPE_STANDARD
:
1854 if (parameters
->options().output_is_position_independent())
1855 rela_dyn
->add_local_relative(obj
, r_sym
, elfcpp::R_X86_64_RELATIVE
,
1856 this->got_
, got_offset
, 0, false);
1858 case GOT_TYPE_TLS_OFFSET
:
1859 rela_dyn
->add_local(obj
, r_sym
, elfcpp::R_X86_64_TPOFF64
,
1860 this->got_
, got_offset
, 0);
1862 case GOT_TYPE_TLS_PAIR
:
1863 this->got_
->reserve_slot(got_index
+ 1);
1864 rela_dyn
->add_local(obj
, r_sym
, elfcpp::R_X86_64_DTPMOD64
,
1865 this->got_
, got_offset
, 0);
1867 case GOT_TYPE_TLS_DESC
:
1868 gold_fatal(_("TLS_DESC not yet supported for incremental linking"));
1869 // this->got_->reserve_slot(got_index + 1);
1870 // rela_dyn->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1871 // this->got_, got_offset, 0);
1878 // Reserve a GOT entry for a global symbol, and regenerate any
1879 // necessary dynamic relocations.
1883 Target_x86_64
<size
>::reserve_global_got_entry(unsigned int got_index
,
1885 unsigned int got_type
)
1887 unsigned int got_offset
= got_index
* 8;
1888 Reloc_section
* rela_dyn
= this->rela_dyn_section(NULL
);
1890 this->got_
->reserve_global(got_index
, gsym
, got_type
);
1893 case GOT_TYPE_STANDARD
:
1894 if (!gsym
->final_value_is_known())
1896 if (gsym
->is_from_dynobj()
1897 || gsym
->is_undefined()
1898 || gsym
->is_preemptible()
1899 || gsym
->type() == elfcpp::STT_GNU_IFUNC
)
1900 rela_dyn
->add_global(gsym
, elfcpp::R_X86_64_GLOB_DAT
,
1901 this->got_
, got_offset
, 0);
1903 rela_dyn
->add_global_relative(gsym
, elfcpp::R_X86_64_RELATIVE
,
1904 this->got_
, got_offset
, 0, false);
1907 case GOT_TYPE_TLS_OFFSET
:
1908 rela_dyn
->add_global_relative(gsym
, elfcpp::R_X86_64_TPOFF64
,
1909 this->got_
, got_offset
, 0, false);
1911 case GOT_TYPE_TLS_PAIR
:
1912 this->got_
->reserve_slot(got_index
+ 1);
1913 rela_dyn
->add_global_relative(gsym
, elfcpp::R_X86_64_DTPMOD64
,
1914 this->got_
, got_offset
, 0, false);
1915 rela_dyn
->add_global_relative(gsym
, elfcpp::R_X86_64_DTPOFF64
,
1916 this->got_
, got_offset
+ 8, 0, false);
1918 case GOT_TYPE_TLS_DESC
:
1919 this->got_
->reserve_slot(got_index
+ 1);
1920 rela_dyn
->add_global_relative(gsym
, elfcpp::R_X86_64_TLSDESC
,
1921 this->got_
, got_offset
, 0, false);
1928 // Register an existing PLT entry for a global symbol.
1932 Target_x86_64
<size
>::register_global_plt_entry(Symbol_table
* symtab
,
1934 unsigned int plt_index
,
1937 gold_assert(this->plt_
!= NULL
);
1938 gold_assert(!gsym
->has_plt_offset());
1940 this->plt_
->reserve_slot(plt_index
);
1942 gsym
->set_plt_offset((plt_index
+ 1) * this->plt_entry_size());
1944 unsigned int got_offset
= (plt_index
+ 3) * 8;
1945 this->plt_
->add_relocation(symtab
, layout
, gsym
, got_offset
);
1948 // Force a COPY relocation for a given symbol.
1952 Target_x86_64
<size
>::emit_copy_reloc(
1953 Symbol_table
* symtab
, Symbol
* sym
, Output_section
* os
, off_t offset
)
1955 this->copy_relocs_
.emit_copy_reloc(symtab
,
1956 symtab
->get_sized_symbol
<size
>(sym
),
1959 this->rela_dyn_section(NULL
));
1962 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
1966 Target_x86_64
<size
>::define_tls_base_symbol(Symbol_table
* symtab
,
1969 if (this->tls_base_symbol_defined_
)
1972 Output_segment
* tls_segment
= layout
->tls_segment();
1973 if (tls_segment
!= NULL
)
1975 bool is_exec
= parameters
->options().output_is_executable();
1976 symtab
->define_in_output_segment("_TLS_MODULE_BASE_", NULL
,
1977 Symbol_table::PREDEFINED
,
1981 elfcpp::STV_HIDDEN
, 0,
1983 ? Symbol::SEGMENT_END
1984 : Symbol::SEGMENT_START
),
1987 this->tls_base_symbol_defined_
= true;
1990 // Create the reserved PLT and GOT entries for the TLS descriptor resolver.
1994 Target_x86_64
<size
>::reserve_tlsdesc_entries(Symbol_table
* symtab
,
1997 if (this->plt_
== NULL
)
1998 this->make_plt_section(symtab
, layout
);
2000 if (!this->plt_
->has_tlsdesc_entry())
2002 // Allocate the TLSDESC_GOT entry.
2003 Output_data_got
<64, false>* got
= this->got_section(symtab
, layout
);
2004 unsigned int got_offset
= got
->add_constant(0);
2006 // Allocate the TLSDESC_PLT entry.
2007 this->plt_
->reserve_tlsdesc_entry(got_offset
);
2011 // Create a GOT entry for the TLS module index.
2015 Target_x86_64
<size
>::got_mod_index_entry(Symbol_table
* symtab
, Layout
* layout
,
2016 Sized_relobj_file
<size
, false>* object
)
2018 if (this->got_mod_index_offset_
== -1U)
2020 gold_assert(symtab
!= NULL
&& layout
!= NULL
&& object
!= NULL
);
2021 Reloc_section
* rela_dyn
= this->rela_dyn_section(layout
);
2022 Output_data_got
<64, false>* got
= this->got_section(symtab
, layout
);
2023 unsigned int got_offset
= got
->add_constant(0);
2024 rela_dyn
->add_local(object
, 0, elfcpp::R_X86_64_DTPMOD64
, got
,
2026 got
->add_constant(0);
2027 this->got_mod_index_offset_
= got_offset
;
2029 return this->got_mod_index_offset_
;
2032 // Optimize the TLS relocation type based on what we know about the
2033 // symbol. IS_FINAL is true if the final address of this symbol is
2034 // known at link time.
2037 tls::Tls_optimization
2038 Target_x86_64
<size
>::optimize_tls_reloc(bool is_final
, int r_type
)
2040 // If we are generating a shared library, then we can't do anything
2042 if (parameters
->options().shared())
2043 return tls::TLSOPT_NONE
;
2047 case elfcpp::R_X86_64_TLSGD
:
2048 case elfcpp::R_X86_64_GOTPC32_TLSDESC
:
2049 case elfcpp::R_X86_64_TLSDESC_CALL
:
2050 // These are General-Dynamic which permits fully general TLS
2051 // access. Since we know that we are generating an executable,
2052 // we can convert this to Initial-Exec. If we also know that
2053 // this is a local symbol, we can further switch to Local-Exec.
2055 return tls::TLSOPT_TO_LE
;
2056 return tls::TLSOPT_TO_IE
;
2058 case elfcpp::R_X86_64_TLSLD
:
2059 // This is Local-Dynamic, which refers to a local symbol in the
2060 // dynamic TLS block. Since we know that we generating an
2061 // executable, we can switch to Local-Exec.
2062 return tls::TLSOPT_TO_LE
;
2064 case elfcpp::R_X86_64_DTPOFF32
:
2065 case elfcpp::R_X86_64_DTPOFF64
:
2066 // Another Local-Dynamic reloc.
2067 return tls::TLSOPT_TO_LE
;
2069 case elfcpp::R_X86_64_GOTTPOFF
:
2070 // These are Initial-Exec relocs which get the thread offset
2071 // from the GOT. If we know that we are linking against the
2072 // local symbol, we can switch to Local-Exec, which links the
2073 // thread offset into the instruction.
2075 return tls::TLSOPT_TO_LE
;
2076 return tls::TLSOPT_NONE
;
2078 case elfcpp::R_X86_64_TPOFF32
:
2079 // When we already have Local-Exec, there is nothing further we
2081 return tls::TLSOPT_NONE
;
2088 // Get the Reference_flags for a particular relocation.
2092 Target_x86_64
<size
>::Scan::get_reference_flags(unsigned int r_type
)
2096 case elfcpp::R_X86_64_NONE
:
2097 case elfcpp::R_X86_64_GNU_VTINHERIT
:
2098 case elfcpp::R_X86_64_GNU_VTENTRY
:
2099 case elfcpp::R_X86_64_GOTPC32
:
2100 case elfcpp::R_X86_64_GOTPC64
:
2101 // No symbol reference.
2104 case elfcpp::R_X86_64_64
:
2105 case elfcpp::R_X86_64_32
:
2106 case elfcpp::R_X86_64_32S
:
2107 case elfcpp::R_X86_64_16
:
2108 case elfcpp::R_X86_64_8
:
2109 return Symbol::ABSOLUTE_REF
;
2111 case elfcpp::R_X86_64_PC64
:
2112 case elfcpp::R_X86_64_PC32
:
2113 case elfcpp::R_X86_64_PC16
:
2114 case elfcpp::R_X86_64_PC8
:
2115 case elfcpp::R_X86_64_GOTOFF64
:
2116 return Symbol::RELATIVE_REF
;
2118 case elfcpp::R_X86_64_PLT32
:
2119 case elfcpp::R_X86_64_PLTOFF64
:
2120 return Symbol::FUNCTION_CALL
| Symbol::RELATIVE_REF
;
2122 case elfcpp::R_X86_64_GOT64
:
2123 case elfcpp::R_X86_64_GOT32
:
2124 case elfcpp::R_X86_64_GOTPCREL64
:
2125 case elfcpp::R_X86_64_GOTPCREL
:
2126 case elfcpp::R_X86_64_GOTPLT64
:
2128 return Symbol::ABSOLUTE_REF
;
2130 case elfcpp::R_X86_64_TLSGD
: // Global-dynamic
2131 case elfcpp::R_X86_64_GOTPC32_TLSDESC
: // Global-dynamic (from ~oliva url)
2132 case elfcpp::R_X86_64_TLSDESC_CALL
:
2133 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
2134 case elfcpp::R_X86_64_DTPOFF32
:
2135 case elfcpp::R_X86_64_DTPOFF64
:
2136 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
2137 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
2138 return Symbol::TLS_REF
;
2140 case elfcpp::R_X86_64_COPY
:
2141 case elfcpp::R_X86_64_GLOB_DAT
:
2142 case elfcpp::R_X86_64_JUMP_SLOT
:
2143 case elfcpp::R_X86_64_RELATIVE
:
2144 case elfcpp::R_X86_64_IRELATIVE
:
2145 case elfcpp::R_X86_64_TPOFF64
:
2146 case elfcpp::R_X86_64_DTPMOD64
:
2147 case elfcpp::R_X86_64_TLSDESC
:
2148 case elfcpp::R_X86_64_SIZE32
:
2149 case elfcpp::R_X86_64_SIZE64
:
2151 // Not expected. We will give an error later.
2156 // Report an unsupported relocation against a local symbol.
2160 Target_x86_64
<size
>::Scan::unsupported_reloc_local(
2161 Sized_relobj_file
<size
, false>* object
,
2162 unsigned int r_type
)
2164 gold_error(_("%s: unsupported reloc %u against local symbol"),
2165 object
->name().c_str(), r_type
);
2168 // We are about to emit a dynamic relocation of type R_TYPE. If the
2169 // dynamic linker does not support it, issue an error. The GNU linker
2170 // only issues a non-PIC error for an allocated read-only section.
2171 // Here we know the section is allocated, but we don't know that it is
2172 // read-only. But we check for all the relocation types which the
2173 // glibc dynamic linker supports, so it seems appropriate to issue an
2174 // error even if the section is not read-only. If GSYM is not NULL,
2175 // it is the symbol the relocation is against; if it is NULL, the
2176 // relocation is against a local symbol.
2180 Target_x86_64
<size
>::Scan::check_non_pic(Relobj
* object
, unsigned int r_type
,
2185 // These are the relocation types supported by glibc for x86_64
2186 // which should always work.
2187 case elfcpp::R_X86_64_RELATIVE
:
2188 case elfcpp::R_X86_64_IRELATIVE
:
2189 case elfcpp::R_X86_64_GLOB_DAT
:
2190 case elfcpp::R_X86_64_JUMP_SLOT
:
2191 case elfcpp::R_X86_64_DTPMOD64
:
2192 case elfcpp::R_X86_64_DTPOFF64
:
2193 case elfcpp::R_X86_64_TPOFF64
:
2194 case elfcpp::R_X86_64_64
:
2195 case elfcpp::R_X86_64_COPY
:
2198 // glibc supports these reloc types, but they can overflow.
2199 case elfcpp::R_X86_64_PC32
:
2200 // A PC relative reference is OK against a local symbol or if
2201 // the symbol is defined locally.
2203 || (!gsym
->is_from_dynobj()
2204 && !gsym
->is_undefined()
2205 && !gsym
->is_preemptible()))
2208 case elfcpp::R_X86_64_32
:
2209 // R_X86_64_32 is OK for x32.
2210 if (size
== 32 && r_type
== elfcpp::R_X86_64_32
)
2212 if (this->issued_non_pic_error_
)
2214 gold_assert(parameters
->options().output_is_position_independent());
2216 object
->error(_("requires dynamic R_X86_64_32 reloc which may "
2217 "overflow at runtime; recompile with -fPIC"));
2219 object
->error(_("requires dynamic %s reloc against '%s' which may "
2220 "overflow at runtime; recompile with -fPIC"),
2221 (r_type
== elfcpp::R_X86_64_32
2225 this->issued_non_pic_error_
= true;
2229 // This prevents us from issuing more than one error per reloc
2230 // section. But we can still wind up issuing more than one
2231 // error per object file.
2232 if (this->issued_non_pic_error_
)
2234 gold_assert(parameters
->options().output_is_position_independent());
2235 object
->error(_("requires unsupported dynamic reloc %u; "
2236 "recompile with -fPIC"),
2238 this->issued_non_pic_error_
= true;
2241 case elfcpp::R_X86_64_NONE
:
2246 // Return whether we need to make a PLT entry for a relocation of the
2247 // given type against a STT_GNU_IFUNC symbol.
2251 Target_x86_64
<size
>::Scan::reloc_needs_plt_for_ifunc(
2252 Sized_relobj_file
<size
, false>* object
,
2253 unsigned int r_type
)
2255 int flags
= Scan::get_reference_flags(r_type
);
2256 if (flags
& Symbol::TLS_REF
)
2257 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
2258 object
->name().c_str(), r_type
);
2262 // Scan a relocation for a local symbol.
2266 Target_x86_64
<size
>::Scan::local(Symbol_table
* symtab
,
2268 Target_x86_64
<size
>* target
,
2269 Sized_relobj_file
<size
, false>* object
,
2270 unsigned int data_shndx
,
2271 Output_section
* output_section
,
2272 const elfcpp::Rela
<size
, false>& reloc
,
2273 unsigned int r_type
,
2274 const elfcpp::Sym
<size
, false>& lsym
,
2280 // A local STT_GNU_IFUNC symbol may require a PLT entry.
2281 bool is_ifunc
= lsym
.get_st_type() == elfcpp::STT_GNU_IFUNC
;
2282 if (is_ifunc
&& this->reloc_needs_plt_for_ifunc(object
, r_type
))
2284 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2285 target
->make_local_ifunc_plt_entry(symtab
, layout
, object
, r_sym
);
2290 case elfcpp::R_X86_64_NONE
:
2291 case elfcpp::R_X86_64_GNU_VTINHERIT
:
2292 case elfcpp::R_X86_64_GNU_VTENTRY
:
2295 case elfcpp::R_X86_64_64
:
2296 // If building a shared library (or a position-independent
2297 // executable), we need to create a dynamic relocation for this
2298 // location. The relocation applied at link time will apply the
2299 // link-time value, so we flag the location with an
2300 // R_X86_64_RELATIVE relocation so the dynamic loader can
2301 // relocate it easily.
2302 if (parameters
->options().output_is_position_independent())
2304 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2305 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2306 rela_dyn
->add_local_relative(object
, r_sym
,
2308 ? elfcpp::R_X86_64_RELATIVE64
2309 : elfcpp::R_X86_64_RELATIVE
),
2310 output_section
, data_shndx
,
2311 reloc
.get_r_offset(),
2312 reloc
.get_r_addend(), is_ifunc
);
2316 case elfcpp::R_X86_64_32
:
2317 case elfcpp::R_X86_64_32S
:
2318 case elfcpp::R_X86_64_16
:
2319 case elfcpp::R_X86_64_8
:
2320 // If building a shared library (or a position-independent
2321 // executable), we need to create a dynamic relocation for this
2322 // location. We can't use an R_X86_64_RELATIVE relocation
2323 // because that is always a 64-bit relocation.
2324 if (parameters
->options().output_is_position_independent())
2326 // Use R_X86_64_RELATIVE relocation for R_X86_64_32 under x32.
2327 if (size
== 32 && r_type
== elfcpp::R_X86_64_32
)
2329 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2330 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2331 rela_dyn
->add_local_relative(object
, r_sym
,
2332 elfcpp::R_X86_64_RELATIVE
,
2333 output_section
, data_shndx
,
2334 reloc
.get_r_offset(),
2335 reloc
.get_r_addend(), is_ifunc
);
2339 this->check_non_pic(object
, r_type
, NULL
);
2341 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2342 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2343 if (lsym
.get_st_type() != elfcpp::STT_SECTION
)
2344 rela_dyn
->add_local(object
, r_sym
, r_type
, output_section
,
2345 data_shndx
, reloc
.get_r_offset(),
2346 reloc
.get_r_addend());
2349 gold_assert(lsym
.get_st_value() == 0);
2350 unsigned int shndx
= lsym
.get_st_shndx();
2352 shndx
= object
->adjust_sym_shndx(r_sym
, shndx
,
2355 object
->error(_("section symbol %u has bad shndx %u"),
2358 rela_dyn
->add_local_section(object
, shndx
,
2359 r_type
, output_section
,
2360 data_shndx
, reloc
.get_r_offset(),
2361 reloc
.get_r_addend());
2366 case elfcpp::R_X86_64_PC64
:
2367 case elfcpp::R_X86_64_PC32
:
2368 case elfcpp::R_X86_64_PC16
:
2369 case elfcpp::R_X86_64_PC8
:
2372 case elfcpp::R_X86_64_PLT32
:
2373 // Since we know this is a local symbol, we can handle this as a
2377 case elfcpp::R_X86_64_GOTPC32
:
2378 case elfcpp::R_X86_64_GOTOFF64
:
2379 case elfcpp::R_X86_64_GOTPC64
:
2380 case elfcpp::R_X86_64_PLTOFF64
:
2381 // We need a GOT section.
2382 target
->got_section(symtab
, layout
);
2383 // For PLTOFF64, we'd normally want a PLT section, but since we
2384 // know this is a local symbol, no PLT is needed.
2387 case elfcpp::R_X86_64_GOT64
:
2388 case elfcpp::R_X86_64_GOT32
:
2389 case elfcpp::R_X86_64_GOTPCREL64
:
2390 case elfcpp::R_X86_64_GOTPCREL
:
2391 case elfcpp::R_X86_64_GOTPLT64
:
2393 // The symbol requires a GOT entry.
2394 Output_data_got
<64, false>* got
= target
->got_section(symtab
, layout
);
2395 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2397 // For a STT_GNU_IFUNC symbol we want the PLT offset. That
2398 // lets function pointers compare correctly with shared
2399 // libraries. Otherwise we would need an IRELATIVE reloc.
2402 is_new
= got
->add_local_plt(object
, r_sym
, GOT_TYPE_STANDARD
);
2404 is_new
= got
->add_local(object
, r_sym
, GOT_TYPE_STANDARD
);
2407 // If we are generating a shared object, we need to add a
2408 // dynamic relocation for this symbol's GOT entry.
2409 if (parameters
->options().output_is_position_independent())
2411 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2412 // R_X86_64_RELATIVE assumes a 64-bit relocation.
2413 if (r_type
!= elfcpp::R_X86_64_GOT32
)
2415 unsigned int got_offset
=
2416 object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
);
2417 rela_dyn
->add_local_relative(object
, r_sym
,
2418 elfcpp::R_X86_64_RELATIVE
,
2419 got
, got_offset
, 0, is_ifunc
);
2423 this->check_non_pic(object
, r_type
, NULL
);
2425 gold_assert(lsym
.get_st_type() != elfcpp::STT_SECTION
);
2426 rela_dyn
->add_local(
2427 object
, r_sym
, r_type
, got
,
2428 object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
), 0);
2432 // For GOTPLT64, we'd normally want a PLT section, but since
2433 // we know this is a local symbol, no PLT is needed.
2437 case elfcpp::R_X86_64_COPY
:
2438 case elfcpp::R_X86_64_GLOB_DAT
:
2439 case elfcpp::R_X86_64_JUMP_SLOT
:
2440 case elfcpp::R_X86_64_RELATIVE
:
2441 case elfcpp::R_X86_64_IRELATIVE
:
2442 // These are outstanding tls relocs, which are unexpected when linking
2443 case elfcpp::R_X86_64_TPOFF64
:
2444 case elfcpp::R_X86_64_DTPMOD64
:
2445 case elfcpp::R_X86_64_TLSDESC
:
2446 gold_error(_("%s: unexpected reloc %u in object file"),
2447 object
->name().c_str(), r_type
);
2450 // These are initial tls relocs, which are expected when linking
2451 case elfcpp::R_X86_64_TLSGD
: // Global-dynamic
2452 case elfcpp::R_X86_64_GOTPC32_TLSDESC
: // Global-dynamic (from ~oliva url)
2453 case elfcpp::R_X86_64_TLSDESC_CALL
:
2454 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
2455 case elfcpp::R_X86_64_DTPOFF32
:
2456 case elfcpp::R_X86_64_DTPOFF64
:
2457 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
2458 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
2460 bool output_is_shared
= parameters
->options().shared();
2461 const tls::Tls_optimization optimized_type
2462 = Target_x86_64
<size
>::optimize_tls_reloc(!output_is_shared
,
2466 case elfcpp::R_X86_64_TLSGD
: // General-dynamic
2467 if (optimized_type
== tls::TLSOPT_NONE
)
2469 // Create a pair of GOT entries for the module index and
2470 // dtv-relative offset.
2471 Output_data_got
<64, false>* got
2472 = target
->got_section(symtab
, layout
);
2473 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2474 unsigned int shndx
= lsym
.get_st_shndx();
2476 shndx
= object
->adjust_sym_shndx(r_sym
, shndx
, &is_ordinary
);
2478 object
->error(_("local symbol %u has bad shndx %u"),
2481 got
->add_local_pair_with_rel(object
, r_sym
,
2484 target
->rela_dyn_section(layout
),
2485 elfcpp::R_X86_64_DTPMOD64
);
2487 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2488 unsupported_reloc_local(object
, r_type
);
2491 case elfcpp::R_X86_64_GOTPC32_TLSDESC
:
2492 target
->define_tls_base_symbol(symtab
, layout
);
2493 if (optimized_type
== tls::TLSOPT_NONE
)
2495 // Create reserved PLT and GOT entries for the resolver.
2496 target
->reserve_tlsdesc_entries(symtab
, layout
);
2498 // Generate a double GOT entry with an
2499 // R_X86_64_TLSDESC reloc. The R_X86_64_TLSDESC reloc
2500 // is resolved lazily, so the GOT entry needs to be in
2501 // an area in .got.plt, not .got. Call got_section to
2502 // make sure the section has been created.
2503 target
->got_section(symtab
, layout
);
2504 Output_data_got
<64, false>* got
= target
->got_tlsdesc_section();
2505 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2506 if (!object
->local_has_got_offset(r_sym
, GOT_TYPE_TLS_DESC
))
2508 unsigned int got_offset
= got
->add_constant(0);
2509 got
->add_constant(0);
2510 object
->set_local_got_offset(r_sym
, GOT_TYPE_TLS_DESC
,
2512 Reloc_section
* rt
= target
->rela_tlsdesc_section(layout
);
2513 // We store the arguments we need in a vector, and
2514 // use the index into the vector as the parameter
2515 // to pass to the target specific routines.
2516 uintptr_t intarg
= target
->add_tlsdesc_info(object
, r_sym
);
2517 void* arg
= reinterpret_cast<void*>(intarg
);
2518 rt
->add_target_specific(elfcpp::R_X86_64_TLSDESC
, arg
,
2519 got
, got_offset
, 0);
2522 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2523 unsupported_reloc_local(object
, r_type
);
2526 case elfcpp::R_X86_64_TLSDESC_CALL
:
2529 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
2530 if (optimized_type
== tls::TLSOPT_NONE
)
2532 // Create a GOT entry for the module index.
2533 target
->got_mod_index_entry(symtab
, layout
, object
);
2535 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2536 unsupported_reloc_local(object
, r_type
);
2539 case elfcpp::R_X86_64_DTPOFF32
:
2540 case elfcpp::R_X86_64_DTPOFF64
:
2543 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
2544 layout
->set_has_static_tls();
2545 if (optimized_type
== tls::TLSOPT_NONE
)
2547 // Create a GOT entry for the tp-relative offset.
2548 Output_data_got
<64, false>* got
2549 = target
->got_section(symtab
, layout
);
2550 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(reloc
.get_r_info());
2551 got
->add_local_with_rel(object
, r_sym
, GOT_TYPE_TLS_OFFSET
,
2552 target
->rela_dyn_section(layout
),
2553 elfcpp::R_X86_64_TPOFF64
);
2555 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2556 unsupported_reloc_local(object
, r_type
);
2559 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
2560 layout
->set_has_static_tls();
2561 if (output_is_shared
)
2562 unsupported_reloc_local(object
, r_type
);
2571 case elfcpp::R_X86_64_SIZE32
:
2572 case elfcpp::R_X86_64_SIZE64
:
2574 gold_error(_("%s: unsupported reloc %u against local symbol"),
2575 object
->name().c_str(), r_type
);
2581 // Report an unsupported relocation against a global symbol.
2585 Target_x86_64
<size
>::Scan::unsupported_reloc_global(
2586 Sized_relobj_file
<size
, false>* object
,
2587 unsigned int r_type
,
2590 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
2591 object
->name().c_str(), r_type
, gsym
->demangled_name().c_str());
2594 // Returns true if this relocation type could be that of a function pointer.
2597 Target_x86_64
<size
>::Scan::possible_function_pointer_reloc(unsigned int r_type
)
2601 case elfcpp::R_X86_64_64
:
2602 case elfcpp::R_X86_64_32
:
2603 case elfcpp::R_X86_64_32S
:
2604 case elfcpp::R_X86_64_16
:
2605 case elfcpp::R_X86_64_8
:
2606 case elfcpp::R_X86_64_GOT64
:
2607 case elfcpp::R_X86_64_GOT32
:
2608 case elfcpp::R_X86_64_GOTPCREL64
:
2609 case elfcpp::R_X86_64_GOTPCREL
:
2610 case elfcpp::R_X86_64_GOTPLT64
:
2618 // For safe ICF, scan a relocation for a local symbol to check if it
2619 // corresponds to a function pointer being taken. In that case mark
2620 // the function whose pointer was taken as not foldable.
2624 Target_x86_64
<size
>::Scan::local_reloc_may_be_function_pointer(
2627 Target_x86_64
<size
>* ,
2628 Sized_relobj_file
<size
, false>* ,
2631 const elfcpp::Rela
<size
, false>& ,
2632 unsigned int r_type
,
2633 const elfcpp::Sym
<size
, false>&)
2635 // When building a shared library, do not fold any local symbols as it is
2636 // not possible to distinguish pointer taken versus a call by looking at
2637 // the relocation types.
2638 return (parameters
->options().shared()
2639 || possible_function_pointer_reloc(r_type
));
2642 // For safe ICF, scan a relocation for a global symbol to check if it
2643 // corresponds to a function pointer being taken. In that case mark
2644 // the function whose pointer was taken as not foldable.
2648 Target_x86_64
<size
>::Scan::global_reloc_may_be_function_pointer(
2651 Target_x86_64
<size
>* ,
2652 Sized_relobj_file
<size
, false>* ,
2655 const elfcpp::Rela
<size
, false>& ,
2656 unsigned int r_type
,
2659 // When building a shared library, do not fold symbols whose visibility
2660 // is hidden, internal or protected.
2661 return ((parameters
->options().shared()
2662 && (gsym
->visibility() == elfcpp::STV_INTERNAL
2663 || gsym
->visibility() == elfcpp::STV_PROTECTED
2664 || gsym
->visibility() == elfcpp::STV_HIDDEN
))
2665 || possible_function_pointer_reloc(r_type
));
2668 // Scan a relocation for a global symbol.
2672 Target_x86_64
<size
>::Scan::global(Symbol_table
* symtab
,
2674 Target_x86_64
<size
>* target
,
2675 Sized_relobj_file
<size
, false>* object
,
2676 unsigned int data_shndx
,
2677 Output_section
* output_section
,
2678 const elfcpp::Rela
<size
, false>& reloc
,
2679 unsigned int r_type
,
2682 // A STT_GNU_IFUNC symbol may require a PLT entry.
2683 if (gsym
->type() == elfcpp::STT_GNU_IFUNC
2684 && this->reloc_needs_plt_for_ifunc(object
, r_type
))
2685 target
->make_plt_entry(symtab
, layout
, gsym
);
2689 case elfcpp::R_X86_64_NONE
:
2690 case elfcpp::R_X86_64_GNU_VTINHERIT
:
2691 case elfcpp::R_X86_64_GNU_VTENTRY
:
2694 case elfcpp::R_X86_64_64
:
2695 case elfcpp::R_X86_64_32
:
2696 case elfcpp::R_X86_64_32S
:
2697 case elfcpp::R_X86_64_16
:
2698 case elfcpp::R_X86_64_8
:
2700 // Make a PLT entry if necessary.
2701 if (gsym
->needs_plt_entry())
2703 target
->make_plt_entry(symtab
, layout
, gsym
);
2704 // Since this is not a PC-relative relocation, we may be
2705 // taking the address of a function. In that case we need to
2706 // set the entry in the dynamic symbol table to the address of
2708 if (gsym
->is_from_dynobj() && !parameters
->options().shared())
2709 gsym
->set_needs_dynsym_value();
2711 // Make a dynamic relocation if necessary.
2712 if (gsym
->needs_dynamic_reloc(Scan::get_reference_flags(r_type
)))
2714 if (gsym
->may_need_copy_reloc())
2716 target
->copy_reloc(symtab
, layout
, object
,
2717 data_shndx
, output_section
, gsym
, reloc
);
2719 else if (((size
== 64 && r_type
== elfcpp::R_X86_64_64
)
2720 || (size
== 32 && r_type
== elfcpp::R_X86_64_32
))
2721 && gsym
->type() == elfcpp::STT_GNU_IFUNC
2722 && gsym
->can_use_relative_reloc(false)
2723 && !gsym
->is_from_dynobj()
2724 && !gsym
->is_undefined()
2725 && !gsym
->is_preemptible())
2727 // Use an IRELATIVE reloc for a locally defined
2728 // STT_GNU_IFUNC symbol. This makes a function
2729 // address in a PIE executable match the address in a
2730 // shared library that it links against.
2731 Reloc_section
* rela_dyn
=
2732 target
->rela_irelative_section(layout
);
2733 unsigned int r_type
= elfcpp::R_X86_64_IRELATIVE
;
2734 rela_dyn
->add_symbolless_global_addend(gsym
, r_type
,
2735 output_section
, object
,
2737 reloc
.get_r_offset(),
2738 reloc
.get_r_addend());
2740 else if (r_type
== elfcpp::R_X86_64_64
2741 && gsym
->can_use_relative_reloc(false))
2743 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2744 rela_dyn
->add_global_relative(gsym
, elfcpp::R_X86_64_RELATIVE
,
2745 output_section
, object
,
2747 reloc
.get_r_offset(),
2748 reloc
.get_r_addend(), false);
2752 this->check_non_pic(object
, r_type
, gsym
);
2753 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2754 rela_dyn
->add_global(gsym
, r_type
, output_section
, object
,
2755 data_shndx
, reloc
.get_r_offset(),
2756 reloc
.get_r_addend());
2762 case elfcpp::R_X86_64_PC64
:
2763 case elfcpp::R_X86_64_PC32
:
2764 case elfcpp::R_X86_64_PC16
:
2765 case elfcpp::R_X86_64_PC8
:
2767 // Make a PLT entry if necessary.
2768 if (gsym
->needs_plt_entry())
2769 target
->make_plt_entry(symtab
, layout
, gsym
);
2770 // Make a dynamic relocation if necessary.
2771 if (gsym
->needs_dynamic_reloc(Scan::get_reference_flags(r_type
)))
2773 if (gsym
->may_need_copy_reloc())
2775 target
->copy_reloc(symtab
, layout
, object
,
2776 data_shndx
, output_section
, gsym
, reloc
);
2780 this->check_non_pic(object
, r_type
, gsym
);
2781 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2782 rela_dyn
->add_global(gsym
, r_type
, output_section
, object
,
2783 data_shndx
, reloc
.get_r_offset(),
2784 reloc
.get_r_addend());
2790 case elfcpp::R_X86_64_GOT64
:
2791 case elfcpp::R_X86_64_GOT32
:
2792 case elfcpp::R_X86_64_GOTPCREL64
:
2793 case elfcpp::R_X86_64_GOTPCREL
:
2794 case elfcpp::R_X86_64_GOTPLT64
:
2796 // The symbol requires a GOT entry.
2797 Output_data_got
<64, false>* got
= target
->got_section(symtab
, layout
);
2798 if (gsym
->final_value_is_known())
2800 // For a STT_GNU_IFUNC symbol we want the PLT address.
2801 if (gsym
->type() == elfcpp::STT_GNU_IFUNC
)
2802 got
->add_global_plt(gsym
, GOT_TYPE_STANDARD
);
2804 got
->add_global(gsym
, GOT_TYPE_STANDARD
);
2808 // If this symbol is not fully resolved, we need to add a
2809 // dynamic relocation for it.
2810 Reloc_section
* rela_dyn
= target
->rela_dyn_section(layout
);
2812 // Use a GLOB_DAT rather than a RELATIVE reloc if:
2814 // 1) The symbol may be defined in some other module.
2816 // 2) We are building a shared library and this is a
2817 // protected symbol; using GLOB_DAT means that the dynamic
2818 // linker can use the address of the PLT in the main
2819 // executable when appropriate so that function address
2820 // comparisons work.
2822 // 3) This is a STT_GNU_IFUNC symbol in position dependent
2823 // code, again so that function address comparisons work.
2824 if (gsym
->is_from_dynobj()
2825 || gsym
->is_undefined()
2826 || gsym
->is_preemptible()
2827 || (gsym
->visibility() == elfcpp::STV_PROTECTED
2828 && parameters
->options().shared())
2829 || (gsym
->type() == elfcpp::STT_GNU_IFUNC
2830 && parameters
->options().output_is_position_independent()))
2831 got
->add_global_with_rel(gsym
, GOT_TYPE_STANDARD
, rela_dyn
,
2832 elfcpp::R_X86_64_GLOB_DAT
);
2835 // For a STT_GNU_IFUNC symbol we want to write the PLT
2836 // offset into the GOT, so that function pointer
2837 // comparisons work correctly.
2839 if (gsym
->type() != elfcpp::STT_GNU_IFUNC
)
2840 is_new
= got
->add_global(gsym
, GOT_TYPE_STANDARD
);
2843 is_new
= got
->add_global_plt(gsym
, GOT_TYPE_STANDARD
);
2844 // Tell the dynamic linker to use the PLT address
2845 // when resolving relocations.
2846 if (gsym
->is_from_dynobj()
2847 && !parameters
->options().shared())
2848 gsym
->set_needs_dynsym_value();
2852 unsigned int got_off
= gsym
->got_offset(GOT_TYPE_STANDARD
);
2853 rela_dyn
->add_global_relative(gsym
,
2854 elfcpp::R_X86_64_RELATIVE
,
2855 got
, got_off
, 0, false);
2859 // For GOTPLT64, we also need a PLT entry (but only if the
2860 // symbol is not fully resolved).
2861 if (r_type
== elfcpp::R_X86_64_GOTPLT64
2862 && !gsym
->final_value_is_known())
2863 target
->make_plt_entry(symtab
, layout
, gsym
);
2867 case elfcpp::R_X86_64_PLT32
:
2868 // If the symbol is fully resolved, this is just a PC32 reloc.
2869 // Otherwise we need a PLT entry.
2870 if (gsym
->final_value_is_known())
2872 // If building a shared library, we can also skip the PLT entry
2873 // if the symbol is defined in the output file and is protected
2875 if (gsym
->is_defined()
2876 && !gsym
->is_from_dynobj()
2877 && !gsym
->is_preemptible())
2879 target
->make_plt_entry(symtab
, layout
, gsym
);
2882 case elfcpp::R_X86_64_GOTPC32
:
2883 case elfcpp::R_X86_64_GOTOFF64
:
2884 case elfcpp::R_X86_64_GOTPC64
:
2885 case elfcpp::R_X86_64_PLTOFF64
:
2886 // We need a GOT section.
2887 target
->got_section(symtab
, layout
);
2888 // For PLTOFF64, we also need a PLT entry (but only if the
2889 // symbol is not fully resolved).
2890 if (r_type
== elfcpp::R_X86_64_PLTOFF64
2891 && !gsym
->final_value_is_known())
2892 target
->make_plt_entry(symtab
, layout
, gsym
);
2895 case elfcpp::R_X86_64_COPY
:
2896 case elfcpp::R_X86_64_GLOB_DAT
:
2897 case elfcpp::R_X86_64_JUMP_SLOT
:
2898 case elfcpp::R_X86_64_RELATIVE
:
2899 case elfcpp::R_X86_64_IRELATIVE
:
2900 // These are outstanding tls relocs, which are unexpected when linking
2901 case elfcpp::R_X86_64_TPOFF64
:
2902 case elfcpp::R_X86_64_DTPMOD64
:
2903 case elfcpp::R_X86_64_TLSDESC
:
2904 gold_error(_("%s: unexpected reloc %u in object file"),
2905 object
->name().c_str(), r_type
);
2908 // These are initial tls relocs, which are expected for global()
2909 case elfcpp::R_X86_64_TLSGD
: // Global-dynamic
2910 case elfcpp::R_X86_64_GOTPC32_TLSDESC
: // Global-dynamic (from ~oliva url)
2911 case elfcpp::R_X86_64_TLSDESC_CALL
:
2912 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
2913 case elfcpp::R_X86_64_DTPOFF32
:
2914 case elfcpp::R_X86_64_DTPOFF64
:
2915 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
2916 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
2918 const bool is_final
= gsym
->final_value_is_known();
2919 const tls::Tls_optimization optimized_type
2920 = Target_x86_64
<size
>::optimize_tls_reloc(is_final
, r_type
);
2923 case elfcpp::R_X86_64_TLSGD
: // General-dynamic
2924 if (optimized_type
== tls::TLSOPT_NONE
)
2926 // Create a pair of GOT entries for the module index and
2927 // dtv-relative offset.
2928 Output_data_got
<64, false>* got
2929 = target
->got_section(symtab
, layout
);
2930 got
->add_global_pair_with_rel(gsym
, GOT_TYPE_TLS_PAIR
,
2931 target
->rela_dyn_section(layout
),
2932 elfcpp::R_X86_64_DTPMOD64
,
2933 elfcpp::R_X86_64_DTPOFF64
);
2935 else if (optimized_type
== tls::TLSOPT_TO_IE
)
2937 // Create a GOT entry for the tp-relative offset.
2938 Output_data_got
<64, false>* got
2939 = target
->got_section(symtab
, layout
);
2940 got
->add_global_with_rel(gsym
, GOT_TYPE_TLS_OFFSET
,
2941 target
->rela_dyn_section(layout
),
2942 elfcpp::R_X86_64_TPOFF64
);
2944 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2945 unsupported_reloc_global(object
, r_type
, gsym
);
2948 case elfcpp::R_X86_64_GOTPC32_TLSDESC
:
2949 target
->define_tls_base_symbol(symtab
, layout
);
2950 if (optimized_type
== tls::TLSOPT_NONE
)
2952 // Create reserved PLT and GOT entries for the resolver.
2953 target
->reserve_tlsdesc_entries(symtab
, layout
);
2955 // Create a double GOT entry with an R_X86_64_TLSDESC
2956 // reloc. The R_X86_64_TLSDESC reloc is resolved
2957 // lazily, so the GOT entry needs to be in an area in
2958 // .got.plt, not .got. Call got_section to make sure
2959 // the section has been created.
2960 target
->got_section(symtab
, layout
);
2961 Output_data_got
<64, false>* got
= target
->got_tlsdesc_section();
2962 Reloc_section
* rt
= target
->rela_tlsdesc_section(layout
);
2963 got
->add_global_pair_with_rel(gsym
, GOT_TYPE_TLS_DESC
, rt
,
2964 elfcpp::R_X86_64_TLSDESC
, 0);
2966 else if (optimized_type
== tls::TLSOPT_TO_IE
)
2968 // Create a GOT entry for the tp-relative offset.
2969 Output_data_got
<64, false>* got
2970 = target
->got_section(symtab
, layout
);
2971 got
->add_global_with_rel(gsym
, GOT_TYPE_TLS_OFFSET
,
2972 target
->rela_dyn_section(layout
),
2973 elfcpp::R_X86_64_TPOFF64
);
2975 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2976 unsupported_reloc_global(object
, r_type
, gsym
);
2979 case elfcpp::R_X86_64_TLSDESC_CALL
:
2982 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
2983 if (optimized_type
== tls::TLSOPT_NONE
)
2985 // Create a GOT entry for the module index.
2986 target
->got_mod_index_entry(symtab
, layout
, object
);
2988 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
2989 unsupported_reloc_global(object
, r_type
, gsym
);
2992 case elfcpp::R_X86_64_DTPOFF32
:
2993 case elfcpp::R_X86_64_DTPOFF64
:
2996 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
2997 layout
->set_has_static_tls();
2998 if (optimized_type
== tls::TLSOPT_NONE
)
3000 // Create a GOT entry for the tp-relative offset.
3001 Output_data_got
<64, false>* got
3002 = target
->got_section(symtab
, layout
);
3003 got
->add_global_with_rel(gsym
, GOT_TYPE_TLS_OFFSET
,
3004 target
->rela_dyn_section(layout
),
3005 elfcpp::R_X86_64_TPOFF64
);
3007 else if (optimized_type
!= tls::TLSOPT_TO_LE
)
3008 unsupported_reloc_global(object
, r_type
, gsym
);
3011 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
3012 layout
->set_has_static_tls();
3013 if (parameters
->options().shared())
3014 unsupported_reloc_global(object
, r_type
, gsym
);
3023 case elfcpp::R_X86_64_SIZE32
:
3024 case elfcpp::R_X86_64_SIZE64
:
3026 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
3027 object
->name().c_str(), r_type
,
3028 gsym
->demangled_name().c_str());
3035 Target_x86_64
<size
>::gc_process_relocs(Symbol_table
* symtab
,
3037 Sized_relobj_file
<size
, false>* object
,
3038 unsigned int data_shndx
,
3039 unsigned int sh_type
,
3040 const unsigned char* prelocs
,
3042 Output_section
* output_section
,
3043 bool needs_special_offset_handling
,
3044 size_t local_symbol_count
,
3045 const unsigned char* plocal_symbols
)
3048 if (sh_type
== elfcpp::SHT_REL
)
3053 gold::gc_process_relocs
<size
, false, Target_x86_64
<size
>, elfcpp::SHT_RELA
,
3054 typename Target_x86_64
<size
>::Scan
,
3055 typename Target_x86_64
<size
>::Relocatable_size_for_reloc
>(
3064 needs_special_offset_handling
,
3069 // Scan relocations for a section.
3073 Target_x86_64
<size
>::scan_relocs(Symbol_table
* symtab
,
3075 Sized_relobj_file
<size
, false>* object
,
3076 unsigned int data_shndx
,
3077 unsigned int sh_type
,
3078 const unsigned char* prelocs
,
3080 Output_section
* output_section
,
3081 bool needs_special_offset_handling
,
3082 size_t local_symbol_count
,
3083 const unsigned char* plocal_symbols
)
3085 if (sh_type
== elfcpp::SHT_REL
)
3087 gold_error(_("%s: unsupported REL reloc section"),
3088 object
->name().c_str());
3092 gold::scan_relocs
<size
, false, Target_x86_64
<size
>, elfcpp::SHT_RELA
,
3093 typename Target_x86_64
<size
>::Scan
>(
3102 needs_special_offset_handling
,
3107 // Finalize the sections.
3111 Target_x86_64
<size
>::do_finalize_sections(
3113 const Input_objects
*,
3114 Symbol_table
* symtab
)
3116 const Reloc_section
* rel_plt
= (this->plt_
== NULL
3118 : this->plt_
->rela_plt());
3119 layout
->add_target_dynamic_tags(false, this->got_plt_
, rel_plt
,
3120 this->rela_dyn_
, true, false);
3122 // Fill in some more dynamic tags.
3123 Output_data_dynamic
* const odyn
= layout
->dynamic_data();
3126 if (this->plt_
!= NULL
3127 && this->plt_
->output_section() != NULL
3128 && this->plt_
->has_tlsdesc_entry())
3130 unsigned int plt_offset
= this->plt_
->get_tlsdesc_plt_offset();
3131 unsigned int got_offset
= this->plt_
->get_tlsdesc_got_offset();
3132 this->got_
->finalize_data_size();
3133 odyn
->add_section_plus_offset(elfcpp::DT_TLSDESC_PLT
,
3134 this->plt_
, plt_offset
);
3135 odyn
->add_section_plus_offset(elfcpp::DT_TLSDESC_GOT
,
3136 this->got_
, got_offset
);
3140 // Emit any relocs we saved in an attempt to avoid generating COPY
3142 if (this->copy_relocs_
.any_saved_relocs())
3143 this->copy_relocs_
.emit(this->rela_dyn_section(layout
));
3145 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
3146 // the .got.plt section.
3147 Symbol
* sym
= this->global_offset_table_
;
3150 uint64_t data_size
= this->got_plt_
->current_data_size();
3151 symtab
->get_sized_symbol
<size
>(sym
)->set_symsize(data_size
);
3154 if (parameters
->doing_static_link()
3155 && (this->plt_
== NULL
|| !this->plt_
->has_irelative_section()))
3157 // If linking statically, make sure that the __rela_iplt symbols
3158 // were defined if necessary, even if we didn't create a PLT.
3159 static const Define_symbol_in_segment syms
[] =
3162 "__rela_iplt_start", // name
3163 elfcpp::PT_LOAD
, // segment_type
3164 elfcpp::PF_W
, // segment_flags_set
3165 elfcpp::PF(0), // segment_flags_clear
3168 elfcpp::STT_NOTYPE
, // type
3169 elfcpp::STB_GLOBAL
, // binding
3170 elfcpp::STV_HIDDEN
, // visibility
3172 Symbol::SEGMENT_START
, // offset_from_base
3176 "__rela_iplt_end", // name
3177 elfcpp::PT_LOAD
, // segment_type
3178 elfcpp::PF_W
, // segment_flags_set
3179 elfcpp::PF(0), // segment_flags_clear
3182 elfcpp::STT_NOTYPE
, // type
3183 elfcpp::STB_GLOBAL
, // binding
3184 elfcpp::STV_HIDDEN
, // visibility
3186 Symbol::SEGMENT_START
, // offset_from_base
3191 symtab
->define_symbols(layout
, 2, syms
,
3192 layout
->script_options()->saw_sections_clause());
3196 // Perform a relocation.
3200 Target_x86_64
<size
>::Relocate::relocate(
3201 const Relocate_info
<size
, false>* relinfo
,
3202 Target_x86_64
<size
>* target
,
3205 const elfcpp::Rela
<size
, false>& rela
,
3206 unsigned int r_type
,
3207 const Sized_symbol
<size
>* gsym
,
3208 const Symbol_value
<size
>* psymval
,
3209 unsigned char* view
,
3210 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
3211 section_size_type view_size
)
3213 if (this->skip_call_tls_get_addr_
)
3215 if ((r_type
!= elfcpp::R_X86_64_PLT32
3216 && r_type
!= elfcpp::R_X86_64_PC32
)
3218 || strcmp(gsym
->name(), "__tls_get_addr") != 0)
3220 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3221 _("missing expected TLS relocation"));
3225 this->skip_call_tls_get_addr_
= false;
3230 const Sized_relobj_file
<size
, false>* object
= relinfo
->object
;
3232 // Pick the value to use for symbols defined in the PLT.
3233 Symbol_value
<size
> symval
;
3235 && gsym
->use_plt_offset(Scan::get_reference_flags(r_type
)))
3237 symval
.set_output_value(target
->plt_address_for_global(gsym
)
3238 + gsym
->plt_offset());
3241 else if (gsym
== NULL
&& psymval
->is_ifunc_symbol())
3243 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
3244 if (object
->local_has_plt_offset(r_sym
))
3246 symval
.set_output_value(target
->plt_address_for_local(object
, r_sym
)
3247 + object
->local_plt_offset(r_sym
));
3252 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
3254 // Get the GOT offset if needed.
3255 // The GOT pointer points to the end of the GOT section.
3256 // We need to subtract the size of the GOT section to get
3257 // the actual offset to use in the relocation.
3258 bool have_got_offset
= false;
3259 unsigned int got_offset
= 0;
3262 case elfcpp::R_X86_64_GOT32
:
3263 case elfcpp::R_X86_64_GOT64
:
3264 case elfcpp::R_X86_64_GOTPLT64
:
3265 case elfcpp::R_X86_64_GOTPCREL
:
3266 case elfcpp::R_X86_64_GOTPCREL64
:
3269 gold_assert(gsym
->has_got_offset(GOT_TYPE_STANDARD
));
3270 got_offset
= gsym
->got_offset(GOT_TYPE_STANDARD
) - target
->got_size();
3274 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
3275 gold_assert(object
->local_has_got_offset(r_sym
, GOT_TYPE_STANDARD
));
3276 got_offset
= (object
->local_got_offset(r_sym
, GOT_TYPE_STANDARD
)
3277 - target
->got_size());
3279 have_got_offset
= true;
3288 case elfcpp::R_X86_64_NONE
:
3289 case elfcpp::R_X86_64_GNU_VTINHERIT
:
3290 case elfcpp::R_X86_64_GNU_VTENTRY
:
3293 case elfcpp::R_X86_64_64
:
3294 Relocate_functions
<size
, false>::rela64(view
, object
, psymval
, addend
);
3297 case elfcpp::R_X86_64_PC64
:
3298 Relocate_functions
<size
, false>::pcrela64(view
, object
, psymval
, addend
,
3302 case elfcpp::R_X86_64_32
:
3303 // FIXME: we need to verify that value + addend fits into 32 bits:
3304 // uint64_t x = value + addend;
3305 // x == static_cast<uint64_t>(static_cast<uint32_t>(x))
3306 // Likewise for other <=32-bit relocations (but see R_X86_64_32S).
3307 Relocate_functions
<size
, false>::rela32(view
, object
, psymval
, addend
);
3310 case elfcpp::R_X86_64_32S
:
3311 // FIXME: we need to verify that value + addend fits into 32 bits:
3312 // int64_t x = value + addend; // note this quantity is signed!
3313 // x == static_cast<int64_t>(static_cast<int32_t>(x))
3314 Relocate_functions
<size
, false>::rela32(view
, object
, psymval
, addend
);
3317 case elfcpp::R_X86_64_PC32
:
3318 Relocate_functions
<size
, false>::pcrela32(view
, object
, psymval
, addend
,
3322 case elfcpp::R_X86_64_16
:
3323 Relocate_functions
<size
, false>::rela16(view
, object
, psymval
, addend
);
3326 case elfcpp::R_X86_64_PC16
:
3327 Relocate_functions
<size
, false>::pcrela16(view
, object
, psymval
, addend
,
3331 case elfcpp::R_X86_64_8
:
3332 Relocate_functions
<size
, false>::rela8(view
, object
, psymval
, addend
);
3335 case elfcpp::R_X86_64_PC8
:
3336 Relocate_functions
<size
, false>::pcrela8(view
, object
, psymval
, addend
,
3340 case elfcpp::R_X86_64_PLT32
:
3341 gold_assert(gsym
== NULL
3342 || gsym
->has_plt_offset()
3343 || gsym
->final_value_is_known()
3344 || (gsym
->is_defined()
3345 && !gsym
->is_from_dynobj()
3346 && !gsym
->is_preemptible()));
3347 // Note: while this code looks the same as for R_X86_64_PC32, it
3348 // behaves differently because psymval was set to point to
3349 // the PLT entry, rather than the symbol, in Scan::global().
3350 Relocate_functions
<size
, false>::pcrela32(view
, object
, psymval
, addend
,
3354 case elfcpp::R_X86_64_PLTOFF64
:
3357 gold_assert(gsym
->has_plt_offset()
3358 || gsym
->final_value_is_known());
3359 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
;
3360 got_address
= target
->got_section(NULL
, NULL
)->address();
3361 Relocate_functions
<size
, false>::rela64(view
, object
, psymval
,
3362 addend
- got_address
);
3365 case elfcpp::R_X86_64_GOT32
:
3366 gold_assert(have_got_offset
);
3367 Relocate_functions
<size
, false>::rela32(view
, got_offset
, addend
);
3370 case elfcpp::R_X86_64_GOTPC32
:
3373 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
;
3374 value
= target
->got_plt_section()->address();
3375 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
, address
);
3379 case elfcpp::R_X86_64_GOT64
:
3380 // The ABI doc says "Like GOT64, but indicates a PLT entry is needed."
3381 // Since we always add a PLT entry, this is equivalent.
3382 case elfcpp::R_X86_64_GOTPLT64
:
3383 gold_assert(have_got_offset
);
3384 Relocate_functions
<size
, false>::rela64(view
, got_offset
, addend
);
3387 case elfcpp::R_X86_64_GOTPC64
:
3390 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
;
3391 value
= target
->got_plt_section()->address();
3392 Relocate_functions
<size
, false>::pcrela64(view
, value
, addend
, address
);
3396 case elfcpp::R_X86_64_GOTOFF64
:
3398 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
;
3399 value
= (psymval
->value(object
, 0)
3400 - target
->got_plt_section()->address());
3401 Relocate_functions
<size
, false>::rela64(view
, value
, addend
);
3405 case elfcpp::R_X86_64_GOTPCREL
:
3407 gold_assert(have_got_offset
);
3408 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
;
3409 value
= target
->got_plt_section()->address() + got_offset
;
3410 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
, address
);
3414 case elfcpp::R_X86_64_GOTPCREL64
:
3416 gold_assert(have_got_offset
);
3417 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
;
3418 value
= target
->got_plt_section()->address() + got_offset
;
3419 Relocate_functions
<size
, false>::pcrela64(view
, value
, addend
, address
);
3423 case elfcpp::R_X86_64_COPY
:
3424 case elfcpp::R_X86_64_GLOB_DAT
:
3425 case elfcpp::R_X86_64_JUMP_SLOT
:
3426 case elfcpp::R_X86_64_RELATIVE
:
3427 case elfcpp::R_X86_64_IRELATIVE
:
3428 // These are outstanding tls relocs, which are unexpected when linking
3429 case elfcpp::R_X86_64_TPOFF64
:
3430 case elfcpp::R_X86_64_DTPMOD64
:
3431 case elfcpp::R_X86_64_TLSDESC
:
3432 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3433 _("unexpected reloc %u in object file"),
3437 // These are initial tls relocs, which are expected when linking
3438 case elfcpp::R_X86_64_TLSGD
: // Global-dynamic
3439 case elfcpp::R_X86_64_GOTPC32_TLSDESC
: // Global-dynamic (from ~oliva url)
3440 case elfcpp::R_X86_64_TLSDESC_CALL
:
3441 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
3442 case elfcpp::R_X86_64_DTPOFF32
:
3443 case elfcpp::R_X86_64_DTPOFF64
:
3444 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
3445 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
3446 this->relocate_tls(relinfo
, target
, relnum
, rela
, r_type
, gsym
, psymval
,
3447 view
, address
, view_size
);
3450 case elfcpp::R_X86_64_SIZE32
:
3451 case elfcpp::R_X86_64_SIZE64
:
3453 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3454 _("unsupported reloc %u"),
3462 // Perform a TLS relocation.
3466 Target_x86_64
<size
>::Relocate::relocate_tls(
3467 const Relocate_info
<size
, false>* relinfo
,
3468 Target_x86_64
<size
>* target
,
3470 const elfcpp::Rela
<size
, false>& rela
,
3471 unsigned int r_type
,
3472 const Sized_symbol
<size
>* gsym
,
3473 const Symbol_value
<size
>* psymval
,
3474 unsigned char* view
,
3475 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
3476 section_size_type view_size
)
3478 Output_segment
* tls_segment
= relinfo
->layout
->tls_segment();
3480 const Sized_relobj_file
<size
, false>* object
= relinfo
->object
;
3481 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
3482 elfcpp::Shdr
<size
, false> data_shdr(relinfo
->data_shdr
);
3483 bool is_executable
= (data_shdr
.get_sh_flags() & elfcpp::SHF_EXECINSTR
) != 0;
3485 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
= psymval
->value(relinfo
->object
, 0);
3487 const bool is_final
= (gsym
== NULL
3488 ? !parameters
->options().shared()
3489 : gsym
->final_value_is_known());
3490 tls::Tls_optimization optimized_type
3491 = Target_x86_64
<size
>::optimize_tls_reloc(is_final
, r_type
);
3494 case elfcpp::R_X86_64_TLSGD
: // Global-dynamic
3495 if (!is_executable
&& optimized_type
== tls::TLSOPT_TO_LE
)
3497 // If this code sequence is used in a non-executable section,
3498 // we will not optimize the R_X86_64_DTPOFF32/64 relocation,
3499 // on the assumption that it's being used by itself in a debug
3500 // section. Therefore, in the unlikely event that the code
3501 // sequence appears in a non-executable section, we simply
3502 // leave it unoptimized.
3503 optimized_type
= tls::TLSOPT_NONE
;
3505 if (optimized_type
== tls::TLSOPT_TO_LE
)
3507 if (tls_segment
== NULL
)
3509 gold_assert(parameters
->errors()->error_count() > 0
3510 || issue_undefined_symbol_error(gsym
));
3513 this->tls_gd_to_le(relinfo
, relnum
, tls_segment
,
3514 rela
, r_type
, value
, view
,
3520 unsigned int got_type
= (optimized_type
== tls::TLSOPT_TO_IE
3521 ? GOT_TYPE_TLS_OFFSET
3522 : GOT_TYPE_TLS_PAIR
);
3523 unsigned int got_offset
;
3526 gold_assert(gsym
->has_got_offset(got_type
));
3527 got_offset
= gsym
->got_offset(got_type
) - target
->got_size();
3531 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
3532 gold_assert(object
->local_has_got_offset(r_sym
, got_type
));
3533 got_offset
= (object
->local_got_offset(r_sym
, got_type
)
3534 - target
->got_size());
3536 if (optimized_type
== tls::TLSOPT_TO_IE
)
3538 value
= target
->got_plt_section()->address() + got_offset
;
3539 this->tls_gd_to_ie(relinfo
, relnum
, tls_segment
, rela
, r_type
,
3540 value
, view
, address
, view_size
);
3543 else if (optimized_type
== tls::TLSOPT_NONE
)
3545 // Relocate the field with the offset of the pair of GOT
3547 value
= target
->got_plt_section()->address() + got_offset
;
3548 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
,
3553 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3554 _("unsupported reloc %u"), r_type
);
3557 case elfcpp::R_X86_64_GOTPC32_TLSDESC
: // Global-dynamic (from ~oliva url)
3558 case elfcpp::R_X86_64_TLSDESC_CALL
:
3559 if (!is_executable
&& optimized_type
== tls::TLSOPT_TO_LE
)
3561 // See above comment for R_X86_64_TLSGD.
3562 optimized_type
= tls::TLSOPT_NONE
;
3564 if (optimized_type
== tls::TLSOPT_TO_LE
)
3566 if (tls_segment
== NULL
)
3568 gold_assert(parameters
->errors()->error_count() > 0
3569 || issue_undefined_symbol_error(gsym
));
3572 this->tls_desc_gd_to_le(relinfo
, relnum
, tls_segment
,
3573 rela
, r_type
, value
, view
,
3579 unsigned int got_type
= (optimized_type
== tls::TLSOPT_TO_IE
3580 ? GOT_TYPE_TLS_OFFSET
3581 : GOT_TYPE_TLS_DESC
);
3582 unsigned int got_offset
= 0;
3583 if (r_type
== elfcpp::R_X86_64_GOTPC32_TLSDESC
3584 && optimized_type
== tls::TLSOPT_NONE
)
3586 // We created GOT entries in the .got.tlsdesc portion of
3587 // the .got.plt section, but the offset stored in the
3588 // symbol is the offset within .got.tlsdesc.
3589 got_offset
= (target
->got_size()
3590 + target
->got_plt_section()->data_size());
3594 gold_assert(gsym
->has_got_offset(got_type
));
3595 got_offset
+= gsym
->got_offset(got_type
) - target
->got_size();
3599 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
3600 gold_assert(object
->local_has_got_offset(r_sym
, got_type
));
3601 got_offset
+= (object
->local_got_offset(r_sym
, got_type
)
3602 - target
->got_size());
3604 if (optimized_type
== tls::TLSOPT_TO_IE
)
3606 if (tls_segment
== NULL
)
3608 gold_assert(parameters
->errors()->error_count() > 0
3609 || issue_undefined_symbol_error(gsym
));
3612 value
= target
->got_plt_section()->address() + got_offset
;
3613 this->tls_desc_gd_to_ie(relinfo
, relnum
, tls_segment
,
3614 rela
, r_type
, value
, view
, address
,
3618 else if (optimized_type
== tls::TLSOPT_NONE
)
3620 if (r_type
== elfcpp::R_X86_64_GOTPC32_TLSDESC
)
3622 // Relocate the field with the offset of the pair of GOT
3624 value
= target
->got_plt_section()->address() + got_offset
;
3625 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
,
3631 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3632 _("unsupported reloc %u"), r_type
);
3635 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
3636 if (!is_executable
&& optimized_type
== tls::TLSOPT_TO_LE
)
3638 // See above comment for R_X86_64_TLSGD.
3639 optimized_type
= tls::TLSOPT_NONE
;
3641 if (optimized_type
== tls::TLSOPT_TO_LE
)
3643 if (tls_segment
== NULL
)
3645 gold_assert(parameters
->errors()->error_count() > 0
3646 || issue_undefined_symbol_error(gsym
));
3649 this->tls_ld_to_le(relinfo
, relnum
, tls_segment
, rela
, r_type
,
3650 value
, view
, view_size
);
3653 else if (optimized_type
== tls::TLSOPT_NONE
)
3655 // Relocate the field with the offset of the GOT entry for
3656 // the module index.
3657 unsigned int got_offset
;
3658 got_offset
= (target
->got_mod_index_entry(NULL
, NULL
, NULL
)
3659 - target
->got_size());
3660 value
= target
->got_plt_section()->address() + got_offset
;
3661 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
,
3665 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3666 _("unsupported reloc %u"), r_type
);
3669 case elfcpp::R_X86_64_DTPOFF32
:
3670 // This relocation type is used in debugging information.
3671 // In that case we need to not optimize the value. If the
3672 // section is not executable, then we assume we should not
3673 // optimize this reloc. See comments above for R_X86_64_TLSGD,
3674 // R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and
3676 if (optimized_type
== tls::TLSOPT_TO_LE
&& is_executable
)
3678 if (tls_segment
== NULL
)
3680 gold_assert(parameters
->errors()->error_count() > 0
3681 || issue_undefined_symbol_error(gsym
));
3684 value
-= tls_segment
->memsz();
3686 Relocate_functions
<size
, false>::rela32(view
, value
, addend
);
3689 case elfcpp::R_X86_64_DTPOFF64
:
3690 // See R_X86_64_DTPOFF32, just above, for why we check for is_executable.
3691 if (optimized_type
== tls::TLSOPT_TO_LE
&& is_executable
)
3693 if (tls_segment
== NULL
)
3695 gold_assert(parameters
->errors()->error_count() > 0
3696 || issue_undefined_symbol_error(gsym
));
3699 value
-= tls_segment
->memsz();
3701 Relocate_functions
<size
, false>::rela64(view
, value
, addend
);
3704 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
3705 if (optimized_type
== tls::TLSOPT_TO_LE
)
3707 if (tls_segment
== NULL
)
3709 gold_assert(parameters
->errors()->error_count() > 0
3710 || issue_undefined_symbol_error(gsym
));
3713 Target_x86_64
<size
>::Relocate::tls_ie_to_le(relinfo
, relnum
,
3715 r_type
, value
, view
,
3719 else if (optimized_type
== tls::TLSOPT_NONE
)
3721 // Relocate the field with the offset of the GOT entry for
3722 // the tp-relative offset of the symbol.
3723 unsigned int got_offset
;
3726 gold_assert(gsym
->has_got_offset(GOT_TYPE_TLS_OFFSET
));
3727 got_offset
= (gsym
->got_offset(GOT_TYPE_TLS_OFFSET
)
3728 - target
->got_size());
3732 unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(rela
.get_r_info());
3733 gold_assert(object
->local_has_got_offset(r_sym
,
3734 GOT_TYPE_TLS_OFFSET
));
3735 got_offset
= (object
->local_got_offset(r_sym
, GOT_TYPE_TLS_OFFSET
)
3736 - target
->got_size());
3738 value
= target
->got_plt_section()->address() + got_offset
;
3739 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
,
3743 gold_error_at_location(relinfo
, relnum
, rela
.get_r_offset(),
3744 _("unsupported reloc type %u"),
3748 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
3749 if (tls_segment
== NULL
)
3751 gold_assert(parameters
->errors()->error_count() > 0
3752 || issue_undefined_symbol_error(gsym
));
3755 value
-= tls_segment
->memsz();
3756 Relocate_functions
<size
, false>::rela32(view
, value
, addend
);
3761 // Do a relocation in which we convert a TLS General-Dynamic to an
3766 Target_x86_64
<size
>::Relocate::tls_gd_to_ie(
3767 const Relocate_info
<size
, false>* relinfo
,
3770 const elfcpp::Rela
<size
, false>& rela
,
3772 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
3773 unsigned char* view
,
3774 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
3775 section_size_type view_size
)
3778 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3779 // .word 0x6666; rex64; call __tls_get_addr
3780 // ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax
3782 // leaq foo@tlsgd(%rip),%rdi;
3783 // .word 0x6666; rex64; call __tls_get_addr
3784 // ==> movl %fs:0,%eax; addq x@gottpoff(%rip),%rax
3786 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 12);
3787 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3788 (memcmp(view
+ 4, "\x66\x66\x48\xe8", 4) == 0));
3792 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
,
3794 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3795 (memcmp(view
- 4, "\x66\x48\x8d\x3d", 4) == 0));
3796 memcpy(view
- 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0",
3801 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
,
3803 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3804 (memcmp(view
- 3, "\x48\x8d\x3d", 3) == 0));
3805 memcpy(view
- 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0",
3809 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
3810 Relocate_functions
<size
, false>::pcrela32(view
+ 8, value
, addend
- 8,
3813 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3815 this->skip_call_tls_get_addr_
= true;
3818 // Do a relocation in which we convert a TLS General-Dynamic to a
3823 Target_x86_64
<size
>::Relocate::tls_gd_to_le(
3824 const Relocate_info
<size
, false>* relinfo
,
3826 Output_segment
* tls_segment
,
3827 const elfcpp::Rela
<size
, false>& rela
,
3829 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
3830 unsigned char* view
,
3831 section_size_type view_size
)
3834 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3835 // .word 0x6666; rex64; call __tls_get_addr
3836 // ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax
3838 // leaq foo@tlsgd(%rip),%rdi;
3839 // .word 0x6666; rex64; call __tls_get_addr
3840 // ==> movl %fs:0,%eax; leaq x@tpoff(%rax),%rax
3842 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 12);
3843 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3844 (memcmp(view
+ 4, "\x66\x66\x48\xe8", 4) == 0));
3848 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
,
3850 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3851 (memcmp(view
- 4, "\x66\x48\x8d\x3d", 4) == 0));
3852 memcpy(view
- 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0",
3857 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
,
3859 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3860 (memcmp(view
- 3, "\x48\x8d\x3d", 3) == 0));
3862 memcpy(view
- 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0",
3866 value
-= tls_segment
->memsz();
3867 Relocate_functions
<size
, false>::rela32(view
+ 8, value
, 0);
3869 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3871 this->skip_call_tls_get_addr_
= true;
3874 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
3878 Target_x86_64
<size
>::Relocate::tls_desc_gd_to_ie(
3879 const Relocate_info
<size
, false>* relinfo
,
3882 const elfcpp::Rela
<size
, false>& rela
,
3883 unsigned int r_type
,
3884 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
3885 unsigned char* view
,
3886 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
3887 section_size_type view_size
)
3889 if (r_type
== elfcpp::R_X86_64_GOTPC32_TLSDESC
)
3891 // leaq foo@tlsdesc(%rip), %rax
3892 // ==> movq foo@gottpoff(%rip), %rax
3893 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, -3);
3894 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 4);
3895 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3896 view
[-3] == 0x48 && view
[-2] == 0x8d && view
[-1] == 0x05);
3898 const elfcpp::Elf_Xword addend
= rela
.get_r_addend();
3899 Relocate_functions
<size
, false>::pcrela32(view
, value
, addend
, address
);
3903 // call *foo@tlscall(%rax)
3905 gold_assert(r_type
== elfcpp::R_X86_64_TLSDESC_CALL
);
3906 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 2);
3907 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3908 view
[0] == 0xff && view
[1] == 0x10);
3914 // Do a TLSDESC-style General-Dynamic to Local-Exec transition.
3918 Target_x86_64
<size
>::Relocate::tls_desc_gd_to_le(
3919 const Relocate_info
<size
, false>* relinfo
,
3921 Output_segment
* tls_segment
,
3922 const elfcpp::Rela
<size
, false>& rela
,
3923 unsigned int r_type
,
3924 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
3925 unsigned char* view
,
3926 section_size_type view_size
)
3928 if (r_type
== elfcpp::R_X86_64_GOTPC32_TLSDESC
)
3930 // leaq foo@tlsdesc(%rip), %rax
3931 // ==> movq foo@tpoff, %rax
3932 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, -3);
3933 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 4);
3934 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3935 view
[-3] == 0x48 && view
[-2] == 0x8d && view
[-1] == 0x05);
3938 value
-= tls_segment
->memsz();
3939 Relocate_functions
<size
, false>::rela32(view
, value
, 0);
3943 // call *foo@tlscall(%rax)
3945 gold_assert(r_type
== elfcpp::R_X86_64_TLSDESC_CALL
);
3946 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 2);
3947 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3948 view
[0] == 0xff && view
[1] == 0x10);
3956 Target_x86_64
<size
>::Relocate::tls_ld_to_le(
3957 const Relocate_info
<size
, false>* relinfo
,
3960 const elfcpp::Rela
<size
, false>& rela
,
3962 typename
elfcpp::Elf_types
<size
>::Elf_Addr
,
3963 unsigned char* view
,
3964 section_size_type view_size
)
3966 // leaq foo@tlsld(%rip),%rdi; call __tls_get_addr@plt;
3967 // ... leq foo@dtpoff(%rax),%reg
3968 // ==> .word 0x6666; .byte 0x66; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx
3970 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, -3);
3971 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 9);
3973 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(),
3974 view
[-3] == 0x48 && view
[-2] == 0x8d && view
[-1] == 0x3d);
3976 tls::check_tls(relinfo
, relnum
, rela
.get_r_offset(), view
[4] == 0xe8);
3978 memcpy(view
- 3, "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 12);
3980 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3982 this->skip_call_tls_get_addr_
= true;
3985 // Do a relocation in which we convert a TLS Initial-Exec to a
3990 Target_x86_64
<size
>::Relocate::tls_ie_to_le(
3991 const Relocate_info
<size
, false>* relinfo
,
3993 Output_segment
* tls_segment
,
3994 const elfcpp::Rela
<size
, false>& rela
,
3996 typename
elfcpp::Elf_types
<size
>::Elf_Addr value
,
3997 unsigned char* view
,
3998 section_size_type view_size
)
4000 // We need to examine the opcodes to figure out which instruction we
4003 // movq foo@gottpoff(%rip),%reg ==> movq $YY,%reg
4004 // addq foo@gottpoff(%rip),%reg ==> addq $YY,%reg
4006 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, -3);
4007 tls::check_range(relinfo
, relnum
, rela
.get_r_offset(), view_size
, 4);
4009 unsigned char op1
= view
[-3];
4010 unsigned char op2
= view
[-2];
4011 unsigned char op3
= view
[-1];
4012 unsigned char reg
= op3
>> 3;
4020 view
[-1] = 0xc0 | reg
;
4024 // Special handling for %rsp.
4028 view
[-1] = 0xc0 | reg
;
4036 view
[-1] = 0x80 | reg
| (reg
<< 3);
4039 value
-= tls_segment
->memsz();
4040 Relocate_functions
<size
, false>::rela32(view
, value
, 0);
4043 // Relocate section data.
4047 Target_x86_64
<size
>::relocate_section(
4048 const Relocate_info
<size
, false>* relinfo
,
4049 unsigned int sh_type
,
4050 const unsigned char* prelocs
,
4052 Output_section
* output_section
,
4053 bool needs_special_offset_handling
,
4054 unsigned char* view
,
4055 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
4056 section_size_type view_size
,
4057 const Reloc_symbol_changes
* reloc_symbol_changes
)
4059 gold_assert(sh_type
== elfcpp::SHT_RELA
);
4061 gold::relocate_section
<size
, false, Target_x86_64
<size
>, elfcpp::SHT_RELA
,
4062 typename Target_x86_64
<size
>::Relocate
>(
4068 needs_special_offset_handling
,
4072 reloc_symbol_changes
);
4075 // Apply an incremental relocation. Incremental relocations always refer
4076 // to global symbols.
4080 Target_x86_64
<size
>::apply_relocation(
4081 const Relocate_info
<size
, false>* relinfo
,
4082 typename
elfcpp::Elf_types
<size
>::Elf_Addr r_offset
,
4083 unsigned int r_type
,
4084 typename
elfcpp::Elf_types
<size
>::Elf_Swxword r_addend
,
4086 unsigned char* view
,
4087 typename
elfcpp::Elf_types
<size
>::Elf_Addr address
,
4088 section_size_type view_size
)
4090 gold::apply_relocation
<size
, false, Target_x86_64
<size
>,
4091 typename Target_x86_64
<size
>::Relocate
>(
4103 // Return the size of a relocation while scanning during a relocatable
4108 Target_x86_64
<size
>::Relocatable_size_for_reloc::get_size_for_reloc(
4109 unsigned int r_type
,
4114 case elfcpp::R_X86_64_NONE
:
4115 case elfcpp::R_X86_64_GNU_VTINHERIT
:
4116 case elfcpp::R_X86_64_GNU_VTENTRY
:
4117 case elfcpp::R_X86_64_TLSGD
: // Global-dynamic
4118 case elfcpp::R_X86_64_GOTPC32_TLSDESC
: // Global-dynamic (from ~oliva url)
4119 case elfcpp::R_X86_64_TLSDESC_CALL
:
4120 case elfcpp::R_X86_64_TLSLD
: // Local-dynamic
4121 case elfcpp::R_X86_64_DTPOFF32
:
4122 case elfcpp::R_X86_64_DTPOFF64
:
4123 case elfcpp::R_X86_64_GOTTPOFF
: // Initial-exec
4124 case elfcpp::R_X86_64_TPOFF32
: // Local-exec
4127 case elfcpp::R_X86_64_64
:
4128 case elfcpp::R_X86_64_PC64
:
4129 case elfcpp::R_X86_64_GOTOFF64
:
4130 case elfcpp::R_X86_64_GOTPC64
:
4131 case elfcpp::R_X86_64_PLTOFF64
:
4132 case elfcpp::R_X86_64_GOT64
:
4133 case elfcpp::R_X86_64_GOTPCREL64
:
4134 case elfcpp::R_X86_64_GOTPCREL
:
4135 case elfcpp::R_X86_64_GOTPLT64
:
4138 case elfcpp::R_X86_64_32
:
4139 case elfcpp::R_X86_64_32S
:
4140 case elfcpp::R_X86_64_PC32
:
4141 case elfcpp::R_X86_64_PLT32
:
4142 case elfcpp::R_X86_64_GOTPC32
:
4143 case elfcpp::R_X86_64_GOT32
:
4146 case elfcpp::R_X86_64_16
:
4147 case elfcpp::R_X86_64_PC16
:
4150 case elfcpp::R_X86_64_8
:
4151 case elfcpp::R_X86_64_PC8
:
4154 case elfcpp::R_X86_64_COPY
:
4155 case elfcpp::R_X86_64_GLOB_DAT
:
4156 case elfcpp::R_X86_64_JUMP_SLOT
:
4157 case elfcpp::R_X86_64_RELATIVE
:
4158 case elfcpp::R_X86_64_IRELATIVE
:
4159 // These are outstanding tls relocs, which are unexpected when linking
4160 case elfcpp::R_X86_64_TPOFF64
:
4161 case elfcpp::R_X86_64_DTPMOD64
:
4162 case elfcpp::R_X86_64_TLSDESC
:
4163 object
->error(_("unexpected reloc %u in object file"), r_type
);
4166 case elfcpp::R_X86_64_SIZE32
:
4167 case elfcpp::R_X86_64_SIZE64
:
4169 object
->error(_("unsupported reloc %u against local symbol"), r_type
);
4174 // Scan the relocs during a relocatable link.
4178 Target_x86_64
<size
>::scan_relocatable_relocs(
4179 Symbol_table
* symtab
,
4181 Sized_relobj_file
<size
, false>* object
,
4182 unsigned int data_shndx
,
4183 unsigned int sh_type
,
4184 const unsigned char* prelocs
,
4186 Output_section
* output_section
,
4187 bool needs_special_offset_handling
,
4188 size_t local_symbol_count
,
4189 const unsigned char* plocal_symbols
,
4190 Relocatable_relocs
* rr
)
4192 gold_assert(sh_type
== elfcpp::SHT_RELA
);
4194 typedef gold::Default_scan_relocatable_relocs
<elfcpp::SHT_RELA
,
4195 Relocatable_size_for_reloc
> Scan_relocatable_relocs
;
4197 gold::scan_relocatable_relocs
<size
, false, elfcpp::SHT_RELA
,
4198 Scan_relocatable_relocs
>(
4206 needs_special_offset_handling
,
4212 // Relocate a section during a relocatable link.
4216 Target_x86_64
<size
>::relocate_relocs(
4217 const Relocate_info
<size
, false>* relinfo
,
4218 unsigned int sh_type
,
4219 const unsigned char* prelocs
,
4221 Output_section
* output_section
,
4222 off_t offset_in_output_section
,
4223 const Relocatable_relocs
* rr
,
4224 unsigned char* view
,
4225 typename
elfcpp::Elf_types
<size
>::Elf_Addr view_address
,
4226 section_size_type view_size
,
4227 unsigned char* reloc_view
,
4228 section_size_type reloc_view_size
)
4230 gold_assert(sh_type
== elfcpp::SHT_RELA
);
4232 gold::relocate_relocs
<size
, false, elfcpp::SHT_RELA
>(
4237 offset_in_output_section
,
4246 // Return the value to use for a dynamic which requires special
4247 // treatment. This is how we support equality comparisons of function
4248 // pointers across shared library boundaries, as described in the
4249 // processor specific ABI supplement.
4253 Target_x86_64
<size
>::do_dynsym_value(const Symbol
* gsym
) const
4255 gold_assert(gsym
->is_from_dynobj() && gsym
->has_plt_offset());
4256 return this->plt_address_for_global(gsym
) + gsym
->plt_offset();
4259 // Return a string used to fill a code section with nops to take up
4260 // the specified length.
4264 Target_x86_64
<size
>::do_code_fill(section_size_type length
) const
4268 // Build a jmpq instruction to skip over the bytes.
4269 unsigned char jmp
[5];
4271 elfcpp::Swap_unaligned
<32, false>::writeval(jmp
+ 1, length
- 5);
4272 return (std::string(reinterpret_cast<char*>(&jmp
[0]), 5)
4273 + std::string(length
- 5, static_cast<char>(0x90)));
4276 // Nop sequences of various lengths.
4277 const char nop1
[1] = { '\x90' }; // nop
4278 const char nop2
[2] = { '\x66', '\x90' }; // xchg %ax %ax
4279 const char nop3
[3] = { '\x0f', '\x1f', '\x00' }; // nop (%rax)
4280 const char nop4
[4] = { '\x0f', '\x1f', '\x40', // nop 0(%rax)
4282 const char nop5
[5] = { '\x0f', '\x1f', '\x44', // nop 0(%rax,%rax,1)
4284 const char nop6
[6] = { '\x66', '\x0f', '\x1f', // nopw 0(%rax,%rax,1)
4285 '\x44', '\x00', '\x00' };
4286 const char nop7
[7] = { '\x0f', '\x1f', '\x80', // nopl 0L(%rax)
4287 '\x00', '\x00', '\x00',
4289 const char nop8
[8] = { '\x0f', '\x1f', '\x84', // nopl 0L(%rax,%rax,1)
4290 '\x00', '\x00', '\x00',
4292 const char nop9
[9] = { '\x66', '\x0f', '\x1f', // nopw 0L(%rax,%rax,1)
4293 '\x84', '\x00', '\x00',
4294 '\x00', '\x00', '\x00' };
4295 const char nop10
[10] = { '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1)
4296 '\x1f', '\x84', '\x00',
4297 '\x00', '\x00', '\x00',
4299 const char nop11
[11] = { '\x66', '\x66', '\x2e', // data16
4300 '\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1)
4301 '\x00', '\x00', '\x00',
4303 const char nop12
[12] = { '\x66', '\x66', '\x66', // data16; data16
4304 '\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1)
4305 '\x84', '\x00', '\x00',
4306 '\x00', '\x00', '\x00' };
4307 const char nop13
[13] = { '\x66', '\x66', '\x66', // data16; data16; data16
4308 '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1)
4309 '\x1f', '\x84', '\x00',
4310 '\x00', '\x00', '\x00',
4312 const char nop14
[14] = { '\x66', '\x66', '\x66', // data16; data16; data16
4313 '\x66', '\x66', '\x2e', // data16
4314 '\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1)
4315 '\x00', '\x00', '\x00',
4317 const char nop15
[15] = { '\x66', '\x66', '\x66', // data16; data16; data16
4318 '\x66', '\x66', '\x66', // data16; data16
4319 '\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1)
4320 '\x84', '\x00', '\x00',
4321 '\x00', '\x00', '\x00' };
4323 const char* nops
[16] = {
4325 nop1
, nop2
, nop3
, nop4
, nop5
, nop6
, nop7
,
4326 nop8
, nop9
, nop10
, nop11
, nop12
, nop13
, nop14
, nop15
4329 return std::string(nops
[length
], length
);
4332 // Return the addend to use for a target specific relocation. The
4333 // only target specific relocation is R_X86_64_TLSDESC for a local
4334 // symbol. We want to set the addend is the offset of the local
4335 // symbol in the TLS segment.
4339 Target_x86_64
<size
>::do_reloc_addend(void* arg
, unsigned int r_type
,
4342 gold_assert(r_type
== elfcpp::R_X86_64_TLSDESC
);
4343 uintptr_t intarg
= reinterpret_cast<uintptr_t>(arg
);
4344 gold_assert(intarg
< this->tlsdesc_reloc_info_
.size());
4345 const Tlsdesc_info
& ti(this->tlsdesc_reloc_info_
[intarg
]);
4346 const Symbol_value
<size
>* psymval
= ti
.object
->local_symbol(ti
.r_sym
);
4347 gold_assert(psymval
->is_tls_symbol());
4348 // The value of a TLS symbol is the offset in the TLS segment.
4349 return psymval
->value(ti
.object
, 0);
4352 // Return the value to use for the base of a DW_EH_PE_datarel offset
4353 // in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their
4354 // assembler can not write out the difference between two labels in
4355 // different sections, so instead of using a pc-relative value they
4356 // use an offset from the GOT.
4360 Target_x86_64
<size
>::do_ehframe_datarel_base() const
4362 gold_assert(this->global_offset_table_
!= NULL
);
4363 Symbol
* sym
= this->global_offset_table_
;
4364 Sized_symbol
<size
>* ssym
= static_cast<Sized_symbol
<size
>*>(sym
);
4365 return ssym
->value();
4368 // FNOFFSET in section SHNDX in OBJECT is the start of a function
4369 // compiled with -fsplit-stack. The function calls non-split-stack
4370 // code. We have to change the function so that it always ensures
4371 // that it has enough stack space to run some random function.
4375 Target_x86_64
<size
>::do_calls_non_split(Relobj
* object
, unsigned int shndx
,
4376 section_offset_type fnoffset
,
4377 section_size_type fnsize
,
4378 unsigned char* view
,
4379 section_size_type view_size
,
4381 std::string
* to
) const
4383 // The function starts with a comparison of the stack pointer and a
4384 // field in the TCB. This is followed by a jump.
4387 if (this->match_view(view
, view_size
, fnoffset
, "\x64\x48\x3b\x24\x25", 5)
4390 // We will call __morestack if the carry flag is set after this
4391 // comparison. We turn the comparison into an stc instruction
4393 view
[fnoffset
] = '\xf9';
4394 this->set_view_to_nop(view
, view_size
, fnoffset
+ 1, 8);
4396 // lea NN(%rsp),%r10
4397 // lea NN(%rsp),%r11
4398 else if ((this->match_view(view
, view_size
, fnoffset
,
4399 "\x4c\x8d\x94\x24", 4)
4400 || this->match_view(view
, view_size
, fnoffset
,
4401 "\x4c\x8d\x9c\x24", 4))
4404 // This is loading an offset from the stack pointer for a
4405 // comparison. The offset is negative, so we decrease the
4406 // offset by the amount of space we need for the stack. This
4407 // means we will avoid calling __morestack if there happens to
4408 // be plenty of space on the stack already.
4409 unsigned char* pval
= view
+ fnoffset
+ 4;
4410 uint32_t val
= elfcpp::Swap_unaligned
<32, false>::readval(pval
);
4411 val
-= parameters
->options().split_stack_adjust_size();
4412 elfcpp::Swap_unaligned
<32, false>::writeval(pval
, val
);
4416 if (!object
->has_no_split_stack())
4417 object
->error(_("failed to match split-stack sequence at "
4418 "section %u offset %0zx"),
4419 shndx
, static_cast<size_t>(fnoffset
));
4423 // We have to change the function so that it calls
4424 // __morestack_non_split instead of __morestack. The former will
4425 // allocate additional stack space.
4426 *from
= "__morestack";
4427 *to
= "__morestack_non_split";
4430 // The selector for x86_64 object files. Note this is never instantiated
4431 // directly. It's only used in Target_selector_x86_64_nacl, below.
4434 class Target_selector_x86_64
: public Target_selector_freebsd
4437 Target_selector_x86_64()
4438 : Target_selector_freebsd(elfcpp::EM_X86_64
, size
, false,
4440 ? "elf64-x86-64" : "elf32-x86-64"),
4442 ? "elf64-x86-64-freebsd"
4443 : "elf32-x86-64-freebsd"),
4444 (size
== 64 ? "elf_x86_64" : "elf32_x86_64"))
4448 do_instantiate_target()
4449 { return new Target_x86_64
<size
>(); }
4453 // NaCl variant. It uses different PLT contents.
4456 class Output_data_plt_x86_64_nacl
: public Output_data_plt_x86_64
<size
>
4459 Output_data_plt_x86_64_nacl(Layout
* layout
,
4460 Output_data_got
<64, false>* got
,
4461 Output_data_space
* got_plt
,
4462 Output_data_space
* got_irelative
)
4463 : Output_data_plt_x86_64
<size
>(layout
, plt_entry_size
,
4464 got
, got_plt
, got_irelative
)
4467 Output_data_plt_x86_64_nacl(Layout
* layout
,
4468 Output_data_got
<64, false>* got
,
4469 Output_data_space
* got_plt
,
4470 Output_data_space
* got_irelative
,
4471 unsigned int plt_count
)
4472 : Output_data_plt_x86_64
<size
>(layout
, plt_entry_size
,
4473 got
, got_plt
, got_irelative
,
4478 virtual unsigned int
4479 do_get_plt_entry_size() const
4480 { return plt_entry_size
; }
4483 do_add_eh_frame(Layout
* layout
)
4485 layout
->add_eh_frame_for_plt(this,
4486 this->plt_eh_frame_cie
,
4487 this->plt_eh_frame_cie_size
,
4489 plt_eh_frame_fde_size
);
4493 do_fill_first_plt_entry(unsigned char* pov
,
4494 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_addr
,
4495 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_addr
);
4497 virtual unsigned int
4498 do_fill_plt_entry(unsigned char* pov
,
4499 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
4500 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
4501 unsigned int got_offset
,
4502 unsigned int plt_offset
,
4503 unsigned int plt_index
);
4506 do_fill_tlsdesc_entry(unsigned char* pov
,
4507 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
4508 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
4509 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
,
4510 unsigned int tlsdesc_got_offset
,
4511 unsigned int plt_offset
);
4514 // The size of an entry in the PLT.
4515 static const int plt_entry_size
= 64;
4517 // The first entry in the PLT.
4518 static const unsigned char first_plt_entry
[plt_entry_size
];
4520 // Other entries in the PLT for an executable.
4521 static const unsigned char plt_entry
[plt_entry_size
];
4523 // The reserved TLSDESC entry in the PLT for an executable.
4524 static const unsigned char tlsdesc_plt_entry
[plt_entry_size
];
4526 // The .eh_frame unwind information for the PLT.
4527 static const int plt_eh_frame_fde_size
= 32;
4528 static const unsigned char plt_eh_frame_fde
[plt_eh_frame_fde_size
];
4532 class Target_x86_64_nacl
: public Target_x86_64
<size
>
4535 Target_x86_64_nacl()
4536 : Target_x86_64
<size
>(&x86_64_nacl_info
)
4539 virtual Output_data_plt_x86_64
<size
>*
4540 do_make_data_plt(Layout
* layout
,
4541 Output_data_got
<64, false>* got
,
4542 Output_data_space
* got_plt
,
4543 Output_data_space
* got_irelative
)
4545 return new Output_data_plt_x86_64_nacl
<size
>(layout
, got
, got_plt
,
4549 virtual Output_data_plt_x86_64
<size
>*
4550 do_make_data_plt(Layout
* layout
,
4551 Output_data_got
<64, false>* got
,
4552 Output_data_space
* got_plt
,
4553 Output_data_space
* got_irelative
,
4554 unsigned int plt_count
)
4556 return new Output_data_plt_x86_64_nacl
<size
>(layout
, got
, got_plt
,
4562 static const Target::Target_info x86_64_nacl_info
;
4566 const Target::Target_info Target_x86_64_nacl
<64>::x86_64_nacl_info
=
4569 false, // is_big_endian
4570 elfcpp::EM_X86_64
, // machine_code
4571 false, // has_make_symbol
4572 false, // has_resolve
4573 true, // has_code_fill
4574 true, // is_default_stack_executable
4575 true, // can_icf_inline_merge_sections
4577 "/lib64/ld-nacl-x86-64.so.1", // dynamic_linker
4578 0x20000, // default_text_segment_address
4579 0x10000, // abi_pagesize (overridable by -z max-page-size)
4580 0x10000, // common_pagesize (overridable by -z common-page-size)
4581 true, // isolate_execinstr
4582 0x10000000, // rosegment_gap
4583 elfcpp::SHN_UNDEF
, // small_common_shndx
4584 elfcpp::SHN_X86_64_LCOMMON
, // large_common_shndx
4585 0, // small_common_section_flags
4586 elfcpp::SHF_X86_64_LARGE
, // large_common_section_flags
4587 NULL
, // attributes_section
4588 NULL
// attributes_vendor
4592 const Target::Target_info Target_x86_64_nacl
<32>::x86_64_nacl_info
=
4595 false, // is_big_endian
4596 elfcpp::EM_X86_64
, // machine_code
4597 false, // has_make_symbol
4598 false, // has_resolve
4599 true, // has_code_fill
4600 true, // is_default_stack_executable
4601 true, // can_icf_inline_merge_sections
4603 "/lib/ld-nacl-x86-64.so.1", // dynamic_linker
4604 0x20000, // default_text_segment_address
4605 0x10000, // abi_pagesize (overridable by -z max-page-size)
4606 0x10000, // common_pagesize (overridable by -z common-page-size)
4607 true, // isolate_execinstr
4608 0x10000000, // rosegment_gap
4609 elfcpp::SHN_UNDEF
, // small_common_shndx
4610 elfcpp::SHN_X86_64_LCOMMON
, // large_common_shndx
4611 0, // small_common_section_flags
4612 elfcpp::SHF_X86_64_LARGE
, // large_common_section_flags
4613 NULL
, // attributes_section
4614 NULL
// attributes_vendor
4617 #define NACLMASK 0xe0 // 32-byte alignment mask.
4619 // The first entry in the PLT.
4623 Output_data_plt_x86_64_nacl
<size
>::first_plt_entry
[plt_entry_size
] =
4625 0xff, 0x35, // pushq contents of memory address
4626 0, 0, 0, 0, // replaced with address of .got + 8
4627 0x4c, 0x8b, 0x1d, // mov GOT+16(%rip), %r11
4628 0, 0, 0, 0, // replaced with address of .got + 16
4629 0x41, 0x83, 0xe3, NACLMASK
, // and $-32, %r11d
4630 0x4d, 0x01, 0xfb, // add %r15, %r11
4631 0x41, 0xff, 0xe3, // jmpq *%r11
4633 // 9-byte nop sequence to pad out to the next 32-byte boundary.
4634 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopl %cs:0x0(%rax,%rax,1)
4636 // 32 bytes of nop to pad out to the standard size
4637 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4638 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4639 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4640 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4641 0x66, // excess data32 prefix
4647 Output_data_plt_x86_64_nacl
<size
>::do_fill_first_plt_entry(
4649 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
4650 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
)
4652 memcpy(pov
, first_plt_entry
, plt_entry_size
);
4653 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 2,
4655 - (plt_address
+ 2 + 4)));
4656 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 9,
4658 - (plt_address
+ 9 + 4)));
4661 // Subsequent entries in the PLT.
4665 Output_data_plt_x86_64_nacl
<size
>::plt_entry
[plt_entry_size
] =
4667 0x4c, 0x8b, 0x1d, // mov name@GOTPCREL(%rip),%r11
4668 0, 0, 0, 0, // replaced with address of symbol in .got
4669 0x41, 0x83, 0xe3, NACLMASK
, // and $-32, %r11d
4670 0x4d, 0x01, 0xfb, // add %r15, %r11
4671 0x41, 0xff, 0xe3, // jmpq *%r11
4673 // 15-byte nop sequence to pad out to the next 32-byte boundary.
4674 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4675 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4677 // Lazy GOT entries point here (32-byte aligned).
4678 0x68, // pushq immediate
4679 0, 0, 0, 0, // replaced with index into relocation table
4680 0xe9, // jmp relative
4681 0, 0, 0, 0, // replaced with offset to start of .plt0
4683 // 22 bytes of nop to pad out to the standard size.
4684 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4685 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4686 0x0f, 0x1f, 0x80, 0, 0, 0, 0, // nopl 0x0(%rax)
4691 Output_data_plt_x86_64_nacl
<size
>::do_fill_plt_entry(
4693 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
4694 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
4695 unsigned int got_offset
,
4696 unsigned int plt_offset
,
4697 unsigned int plt_index
)
4699 memcpy(pov
, plt_entry
, plt_entry_size
);
4700 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 3,
4701 (got_address
+ got_offset
4702 - (plt_address
+ plt_offset
4705 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 33, plt_index
);
4706 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 38,
4707 - (plt_offset
+ 38 + 4));
4712 // The reserved TLSDESC entry in the PLT.
4716 Output_data_plt_x86_64_nacl
<size
>::tlsdesc_plt_entry
[plt_entry_size
] =
4718 0xff, 0x35, // pushq x(%rip)
4719 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
4720 0x4c, 0x8b, 0x1d, // mov y(%rip),%r11
4721 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
4722 0x41, 0x83, 0xe3, NACLMASK
, // and $-32, %r11d
4723 0x4d, 0x01, 0xfb, // add %r15, %r11
4724 0x41, 0xff, 0xe3, // jmpq *%r11
4726 // 41 bytes of nop to pad out to the standard size.
4727 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4728 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4729 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4730 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4731 0x66, 0x66, // excess data32 prefixes
4732 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4737 Output_data_plt_x86_64_nacl
<size
>::do_fill_tlsdesc_entry(
4739 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_address
,
4740 typename
elfcpp::Elf_types
<size
>::Elf_Addr plt_address
,
4741 typename
elfcpp::Elf_types
<size
>::Elf_Addr got_base
,
4742 unsigned int tlsdesc_got_offset
,
4743 unsigned int plt_offset
)
4745 memcpy(pov
, tlsdesc_plt_entry
, plt_entry_size
);
4746 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 2,
4748 - (plt_address
+ plt_offset
4750 elfcpp::Swap_unaligned
<32, false>::writeval(pov
+ 9,
4752 + tlsdesc_got_offset
4753 - (plt_address
+ plt_offset
4757 // The .eh_frame unwind information for the PLT.
4761 Output_data_plt_x86_64_nacl
<size
>::plt_eh_frame_fde
[plt_eh_frame_fde_size
] =
4763 0, 0, 0, 0, // Replaced with offset to .plt.
4764 0, 0, 0, 0, // Replaced with size of .plt.
4765 0, // Augmentation size.
4766 elfcpp::DW_CFA_def_cfa_offset
, 16, // DW_CFA_def_cfa_offset: 16.
4767 elfcpp::DW_CFA_advance_loc
+ 6, // Advance 6 to __PLT__ + 6.
4768 elfcpp::DW_CFA_def_cfa_offset
, 24, // DW_CFA_def_cfa_offset: 24.
4769 elfcpp::DW_CFA_advance_loc
+ 58, // Advance 58 to __PLT__ + 64.
4770 elfcpp::DW_CFA_def_cfa_expression
, // DW_CFA_def_cfa_expression.
4771 13, // Block length.
4772 elfcpp::DW_OP_breg7
, 8, // Push %rsp + 8.
4773 elfcpp::DW_OP_breg16
, 0, // Push %rip.
4774 elfcpp::DW_OP_const1u
, 63, // Push 0x3f.
4775 elfcpp::DW_OP_and
, // & (%rip & 0x3f).
4776 elfcpp::DW_OP_const1u
, 37, // Push 0x25.
4777 elfcpp::DW_OP_ge
, // >= ((%rip & 0x3f) >= 0x25)
4778 elfcpp::DW_OP_lit3
, // Push 3.
4779 elfcpp::DW_OP_shl
, // << (((%rip & 0x3f) >= 0x25) << 3)
4780 elfcpp::DW_OP_plus
, // + ((((%rip&0x3f)>=0x25)<<3)+%rsp+8
4781 elfcpp::DW_CFA_nop
, // Align to 32 bytes.
4785 // The selector for x86_64-nacl object files.
4788 class Target_selector_x86_64_nacl
4789 : public Target_selector_nacl
<Target_selector_x86_64
<size
>,
4790 Target_x86_64_nacl
<size
> >
4793 Target_selector_x86_64_nacl()
4794 : Target_selector_nacl
<Target_selector_x86_64
<size
>,
4795 Target_x86_64_nacl
<size
> >("x86-64",
4797 ? "elf64-x86-64-nacl"
4798 : "elf32-x86-64-nacl",
4801 : "elf32_x86_64_nacl")
4805 Target_selector_x86_64_nacl
<64> target_selector_x86_64
;
4806 Target_selector_x86_64_nacl
<32> target_selector_x32
;
4808 } // End anonymous namespace.