1
// x86_64.cc -- x86_64 target support for gold.
3
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
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
typename elfcpp::Elf_types<size>::Elf_Off 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 + gsym->plt_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* object,
1399
return (this->address()
1400
+ (this->count_ + 1) * this->get_plt_entry_size()
1401
+ object->local_plt_offset(r_sym));
1404
// Set the final size.
1407
Output_data_plt_x86_64<size>::set_final_data_size()
1409
unsigned int count = this->count_ + this->irelative_count_;
1410
if (this->has_tlsdesc_entry())
1412
this->set_data_size((count + 1) * this->get_plt_entry_size());
1415
// The first entry in the PLT for an executable.
1419
Output_data_plt_x86_64_standard<size>::first_plt_entry[plt_entry_size] =
1421
// From AMD64 ABI Draft 0.98, page 76
1422
0xff, 0x35, // pushq contents of memory address
1423
0, 0, 0, 0, // replaced with address of .got + 8
1424
0xff, 0x25, // jmp indirect
1425
0, 0, 0, 0, // replaced with address of .got + 16
1426
0x90, 0x90, 0x90, 0x90 // noop (x4)
1431
Output_data_plt_x86_64_standard<size>::do_fill_first_plt_entry(
1433
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
1434
typename elfcpp::Elf_types<size>::Elf_Addr plt_address)
1436
memcpy(pov, first_plt_entry, plt_entry_size);
1437
// We do a jmp relative to the PC at the end of this instruction.
1438
elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1440
- (plt_address + 6)));
1441
elfcpp::Swap<32, false>::writeval(pov + 8,
1443
- (plt_address + 12)));
1446
// Subsequent entries in the PLT for an executable.
1450
Output_data_plt_x86_64_standard<size>::plt_entry[plt_entry_size] =
1452
// From AMD64 ABI Draft 0.98, page 76
1453
0xff, 0x25, // jmpq indirect
1454
0, 0, 0, 0, // replaced with address of symbol in .got
1455
0x68, // pushq immediate
1456
0, 0, 0, 0, // replaced with offset into relocation table
1457
0xe9, // jmpq relative
1458
0, 0, 0, 0 // replaced with offset to start of .plt
1463
Output_data_plt_x86_64_standard<size>::do_fill_plt_entry(
1465
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
1466
typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
1467
unsigned int got_offset,
1468
unsigned int plt_offset,
1469
unsigned int plt_index)
1471
memcpy(pov, plt_entry, plt_entry_size);
1472
elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1473
(got_address + got_offset
1474
- (plt_address + plt_offset
1477
elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_index);
1478
elfcpp::Swap<32, false>::writeval(pov + 12,
1479
- (plt_offset + plt_entry_size));
1484
// The reserved TLSDESC entry in the PLT for an executable.
1488
Output_data_plt_x86_64_standard<size>::tlsdesc_plt_entry[plt_entry_size] =
1490
// From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32
1491
// and AMD64/EM64T", Version 0.9.4 (2005-10-10).
1492
0xff, 0x35, // pushq x(%rip)
1493
0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
1494
0xff, 0x25, // jmpq *y(%rip)
1495
0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
1502
Output_data_plt_x86_64_standard<size>::do_fill_tlsdesc_entry(
1504
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
1505
typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
1506
typename elfcpp::Elf_types<size>::Elf_Addr got_base,
1507
unsigned int tlsdesc_got_offset,
1508
unsigned int plt_offset)
1510
memcpy(pov, tlsdesc_plt_entry, plt_entry_size);
1511
elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1513
- (plt_address + plt_offset
1515
elfcpp::Swap_unaligned<32, false>::writeval(pov + 8,
1517
+ tlsdesc_got_offset
1518
- (plt_address + plt_offset
1522
// The .eh_frame unwind information for the PLT.
1526
Output_data_plt_x86_64<size>::plt_eh_frame_cie[plt_eh_frame_cie_size] =
1529
'z', // Augmentation: augmentation size included.
1530
'R', // Augmentation: FDE encoding included.
1531
'\0', // End of augmentation string.
1532
1, // Code alignment factor.
1533
0x78, // Data alignment factor.
1534
16, // Return address column.
1535
1, // Augmentation size.
1536
(elfcpp::DW_EH_PE_pcrel // FDE encoding.
1537
| elfcpp::DW_EH_PE_sdata4),
1538
elfcpp::DW_CFA_def_cfa, 7, 8, // DW_CFA_def_cfa: r7 (rsp) ofs 8.
1539
elfcpp::DW_CFA_offset + 16, 1,// DW_CFA_offset: r16 (rip) at cfa-8.
1540
elfcpp::DW_CFA_nop, // Align to 16 bytes.
1546
Output_data_plt_x86_64_standard<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] =
1548
0, 0, 0, 0, // Replaced with offset to .plt.
1549
0, 0, 0, 0, // Replaced with size of .plt.
1550
0, // Augmentation size.
1551
elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16.
1552
elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
1553
elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24.
1554
elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16.
1555
elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
1556
11, // Block length.
1557
elfcpp::DW_OP_breg7, 8, // Push %rsp + 8.
1558
elfcpp::DW_OP_breg16, 0, // Push %rip.
1559
elfcpp::DW_OP_lit15, // Push 0xf.
1560
elfcpp::DW_OP_and, // & (%rip & 0xf).
1561
elfcpp::DW_OP_lit11, // Push 0xb.
1562
elfcpp::DW_OP_ge, // >= ((%rip & 0xf) >= 0xb)
1563
elfcpp::DW_OP_lit3, // Push 3.
1564
elfcpp::DW_OP_shl, // << (((%rip & 0xf) >= 0xb) << 3)
1565
elfcpp::DW_OP_plus, // + ((((%rip&0xf)>=0xb)<<3)+%rsp+8
1566
elfcpp::DW_CFA_nop, // Align to 32 bytes.
1572
// Write out the PLT. This uses the hand-coded instructions above,
1573
// and adjusts them as needed. This is specified by the AMD64 ABI.
1577
Output_data_plt_x86_64<size>::do_write(Output_file* of)
1579
const off_t offset = this->offset();
1580
const section_size_type oview_size =
1581
convert_to_section_size_type(this->data_size());
1582
unsigned char* const oview = of->get_output_view(offset, oview_size);
1584
const off_t got_file_offset = this->got_plt_->offset();
1585
gold_assert(parameters->incremental_update()
1586
|| (got_file_offset + this->got_plt_->data_size()
1587
== this->got_irelative_->offset()));
1588
const section_size_type got_size =
1589
convert_to_section_size_type(this->got_plt_->data_size()
1590
+ this->got_irelative_->data_size());
1591
unsigned char* const got_view = of->get_output_view(got_file_offset,
1594
unsigned char* pov = oview;
1596
// The base address of the .plt section.
1597
typename elfcpp::Elf_types<size>::Elf_Addr plt_address = this->address();
1598
// The base address of the .got section.
1599
typename elfcpp::Elf_types<size>::Elf_Addr got_base = this->got_->address();
1600
// The base address of the PLT portion of the .got section,
1601
// which is where the GOT pointer will point, and where the
1602
// three reserved GOT entries are located.
1603
typename elfcpp::Elf_types<size>::Elf_Addr got_address
1604
= this->got_plt_->address();
1606
this->fill_first_plt_entry(pov, got_address, plt_address);
1607
pov += this->get_plt_entry_size();
1609
unsigned char* got_pov = got_view;
1611
// The first entry in the GOT is the address of the .dynamic section
1612
// aka the PT_DYNAMIC segment. The next two entries are reserved.
1613
// We saved space for them when we created the section in
1614
// Target_x86_64::got_section.
1615
Output_section* dynamic = this->layout_->dynamic_section();
1616
uint32_t dynamic_addr = dynamic == NULL ? 0 : dynamic->address();
1617
elfcpp::Swap<64, false>::writeval(got_pov, dynamic_addr);
1619
memset(got_pov, 0, 16);
1622
unsigned int plt_offset = this->get_plt_entry_size();
1623
unsigned int got_offset = 24;
1624
const unsigned int count = this->count_ + this->irelative_count_;
1625
for (unsigned int plt_index = 0;
1628
pov += this->get_plt_entry_size(),
1630
plt_offset += this->get_plt_entry_size(),
1633
// Set and adjust the PLT entry itself.
1634
unsigned int lazy_offset = this->fill_plt_entry(pov,
1635
got_address, plt_address,
1636
got_offset, plt_offset,
1639
// Set the entry in the GOT.
1640
elfcpp::Swap<64, false>::writeval(got_pov,
1641
plt_address + plt_offset + lazy_offset);
1644
if (this->has_tlsdesc_entry())
1646
// Set and adjust the reserved TLSDESC PLT entry.
1647
unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset();
1648
this->fill_tlsdesc_entry(pov, got_address, plt_address, got_base,
1649
tlsdesc_got_offset, plt_offset);
1650
pov += this->get_plt_entry_size();
1653
gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1654
gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
1656
of->write_output_view(offset, oview_size, oview);
1657
of->write_output_view(got_file_offset, got_size, got_view);
1660
// Create the PLT section.
1664
Target_x86_64<size>::make_plt_section(Symbol_table* symtab, Layout* layout)
1666
if (this->plt_ == NULL)
1668
// Create the GOT sections first.
1669
this->got_section(symtab, layout);
1671
this->plt_ = this->make_data_plt(layout, this->got_, this->got_plt_,
1672
this->got_irelative_);
1674
// Add unwind information if requested.
1675
if (parameters->options().ld_generated_unwind_info())
1676
this->plt_->add_eh_frame(layout);
1678
layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1680
| elfcpp::SHF_EXECINSTR),
1681
this->plt_, ORDER_PLT, false);
1683
// Make the sh_info field of .rela.plt point to .plt.
1684
Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1685
rela_plt_os->set_info_section(this->plt_->output_section());
1689
// Return the section for TLSDESC relocations.
1692
typename Target_x86_64<size>::Reloc_section*
1693
Target_x86_64<size>::rela_tlsdesc_section(Layout* layout) const
1695
return this->plt_section()->rela_tlsdesc(layout);
1698
// Create a PLT entry for a global symbol.
1702
Target_x86_64<size>::make_plt_entry(Symbol_table* symtab, Layout* layout,
1705
if (gsym->has_plt_offset())
1708
if (this->plt_ == NULL)
1709
this->make_plt_section(symtab, layout);
1711
this->plt_->add_entry(symtab, layout, gsym);
1714
// Make a PLT entry for a local STT_GNU_IFUNC symbol.
1718
Target_x86_64<size>::make_local_ifunc_plt_entry(
1719
Symbol_table* symtab, Layout* layout,
1720
Sized_relobj_file<size, false>* relobj,
1721
unsigned int local_sym_index)
1723
if (relobj->local_has_plt_offset(local_sym_index))
1725
if (this->plt_ == NULL)
1726
this->make_plt_section(symtab, layout);
1727
unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout,
1730
relobj->set_local_plt_offset(local_sym_index, plt_offset);
1733
// Return the number of entries in the PLT.
1737
Target_x86_64<size>::plt_entry_count() const
1739
if (this->plt_ == NULL)
1741
return this->plt_->entry_count();
1744
// Return the offset of the first non-reserved PLT entry.
1748
Target_x86_64<size>::first_plt_entry_offset() const
1750
return this->plt_->first_plt_entry_offset();
1753
// Return the size of each PLT entry.
1757
Target_x86_64<size>::plt_entry_size() const
1759
return this->plt_->get_plt_entry_size();
1762
// Create the GOT and PLT sections for an incremental update.
1765
Output_data_got_base*
1766
Target_x86_64<size>::init_got_plt_for_update(Symbol_table* symtab,
1768
unsigned int got_count,
1769
unsigned int plt_count)
1771
gold_assert(this->got_ == NULL);
1773
this->got_ = new Output_data_got<64, false>(got_count * 8);
1774
layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1776
| elfcpp::SHF_WRITE),
1777
this->got_, ORDER_RELRO_LAST,
1780
// Add the three reserved entries.
1781
this->got_plt_ = new Output_data_space((plt_count + 3) * 8, 8, "** GOT PLT");
1782
layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1784
| elfcpp::SHF_WRITE),
1785
this->got_plt_, ORDER_NON_RELRO_FIRST,
1788
// Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1789
this->global_offset_table_ =
1790
symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1791
Symbol_table::PREDEFINED,
1793
0, 0, elfcpp::STT_OBJECT,
1795
elfcpp::STV_HIDDEN, 0,
1798
// If there are any TLSDESC relocations, they get GOT entries in
1799
// .got.plt after the jump slot entries.
1800
// FIXME: Get the count for TLSDESC entries.
1801
this->got_tlsdesc_ = new Output_data_got<64, false>(0);
1802
layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1803
elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1805
ORDER_NON_RELRO_FIRST, false);
1807
// If there are any IRELATIVE relocations, they get GOT entries in
1808
// .got.plt after the jump slot and TLSDESC entries.
1809
this->got_irelative_ = new Output_data_space(0, 8, "** GOT IRELATIVE PLT");
1810
layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1811
elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1812
this->got_irelative_,
1813
ORDER_NON_RELRO_FIRST, false);
1815
// Create the PLT section.
1816
this->plt_ = this->make_data_plt(layout, this->got_,
1818
this->got_irelative_,
1821
// Add unwind information if requested.
1822
if (parameters->options().ld_generated_unwind_info())
1823
this->plt_->add_eh_frame(layout);
1825
layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1826
elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
1827
this->plt_, ORDER_PLT, false);
1829
// Make the sh_info field of .rela.plt point to .plt.
1830
Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1831
rela_plt_os->set_info_section(this->plt_->output_section());
1833
// Create the rela_dyn section.
1834
this->rela_dyn_section(layout);
1839
// Reserve a GOT entry for a local symbol, and regenerate any
1840
// necessary dynamic relocations.
1844
Target_x86_64<size>::reserve_local_got_entry(
1845
unsigned int got_index,
1846
Sized_relobj<size, false>* obj,
1848
unsigned int got_type)
1850
unsigned int got_offset = got_index * 8;
1851
Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1853
this->got_->reserve_local(got_index, obj, r_sym, got_type);
1856
case GOT_TYPE_STANDARD:
1857
if (parameters->options().output_is_position_independent())
1858
rela_dyn->add_local_relative(obj, r_sym, elfcpp::R_X86_64_RELATIVE,
1859
this->got_, got_offset, 0, false);
1861
case GOT_TYPE_TLS_OFFSET:
1862
rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_TPOFF64,
1863
this->got_, got_offset, 0);
1865
case GOT_TYPE_TLS_PAIR:
1866
this->got_->reserve_slot(got_index + 1);
1867
rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_DTPMOD64,
1868
this->got_, got_offset, 0);
1870
case GOT_TYPE_TLS_DESC:
1871
gold_fatal(_("TLS_DESC not yet supported for incremental linking"));
1872
// this->got_->reserve_slot(got_index + 1);
1873
// rela_dyn->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1874
// this->got_, got_offset, 0);
1881
// Reserve a GOT entry for a global symbol, and regenerate any
1882
// necessary dynamic relocations.
1886
Target_x86_64<size>::reserve_global_got_entry(unsigned int got_index,
1888
unsigned int got_type)
1890
unsigned int got_offset = got_index * 8;
1891
Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1893
this->got_->reserve_global(got_index, gsym, got_type);
1896
case GOT_TYPE_STANDARD:
1897
if (!gsym->final_value_is_known())
1899
if (gsym->is_from_dynobj()
1900
|| gsym->is_undefined()
1901
|| gsym->is_preemptible()
1902
|| gsym->type() == elfcpp::STT_GNU_IFUNC)
1903
rela_dyn->add_global(gsym, elfcpp::R_X86_64_GLOB_DAT,
1904
this->got_, got_offset, 0);
1906
rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
1907
this->got_, got_offset, 0, false);
1910
case GOT_TYPE_TLS_OFFSET:
1911
rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TPOFF64,
1912
this->got_, got_offset, 0, false);
1914
case GOT_TYPE_TLS_PAIR:
1915
this->got_->reserve_slot(got_index + 1);
1916
rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPMOD64,
1917
this->got_, got_offset, 0, false);
1918
rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPOFF64,
1919
this->got_, got_offset + 8, 0, false);
1921
case GOT_TYPE_TLS_DESC:
1922
this->got_->reserve_slot(got_index + 1);
1923
rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TLSDESC,
1924
this->got_, got_offset, 0, false);
1931
// Register an existing PLT entry for a global symbol.
1935
Target_x86_64<size>::register_global_plt_entry(Symbol_table* symtab,
1937
unsigned int plt_index,
1940
gold_assert(this->plt_ != NULL);
1941
gold_assert(!gsym->has_plt_offset());
1943
this->plt_->reserve_slot(plt_index);
1945
gsym->set_plt_offset((plt_index + 1) * this->plt_entry_size());
1947
unsigned int got_offset = (plt_index + 3) * 8;
1948
this->plt_->add_relocation(symtab, layout, gsym, got_offset);
1951
// Force a COPY relocation for a given symbol.
1955
Target_x86_64<size>::emit_copy_reloc(
1956
Symbol_table* symtab, Symbol* sym, Output_section* os, off_t offset)
1958
this->copy_relocs_.emit_copy_reloc(symtab,
1959
symtab->get_sized_symbol<size>(sym),
1962
this->rela_dyn_section(NULL));
1965
// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
1969
Target_x86_64<size>::define_tls_base_symbol(Symbol_table* symtab,
1972
if (this->tls_base_symbol_defined_)
1975
Output_segment* tls_segment = layout->tls_segment();
1976
if (tls_segment != NULL)
1978
bool is_exec = parameters->options().output_is_executable();
1979
symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
1980
Symbol_table::PREDEFINED,
1984
elfcpp::STV_HIDDEN, 0,
1986
? Symbol::SEGMENT_END
1987
: Symbol::SEGMENT_START),
1990
this->tls_base_symbol_defined_ = true;
1993
// Create the reserved PLT and GOT entries for the TLS descriptor resolver.
1997
Target_x86_64<size>::reserve_tlsdesc_entries(Symbol_table* symtab,
2000
if (this->plt_ == NULL)
2001
this->make_plt_section(symtab, layout);
2003
if (!this->plt_->has_tlsdesc_entry())
2005
// Allocate the TLSDESC_GOT entry.
2006
Output_data_got<64, false>* got = this->got_section(symtab, layout);
2007
unsigned int got_offset = got->add_constant(0);
2009
// Allocate the TLSDESC_PLT entry.
2010
this->plt_->reserve_tlsdesc_entry(got_offset);
2014
// Create a GOT entry for the TLS module index.
2018
Target_x86_64<size>::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
2019
Sized_relobj_file<size, false>* object)
2021
if (this->got_mod_index_offset_ == -1U)
2023
gold_assert(symtab != NULL && layout != NULL && object != NULL);
2024
Reloc_section* rela_dyn = this->rela_dyn_section(layout);
2025
Output_data_got<64, false>* got = this->got_section(symtab, layout);
2026
unsigned int got_offset = got->add_constant(0);
2027
rela_dyn->add_local(object, 0, elfcpp::R_X86_64_DTPMOD64, got,
2029
got->add_constant(0);
2030
this->got_mod_index_offset_ = got_offset;
2032
return this->got_mod_index_offset_;
2035
// Optimize the TLS relocation type based on what we know about the
2036
// symbol. IS_FINAL is true if the final address of this symbol is
2037
// known at link time.
2040
tls::Tls_optimization
2041
Target_x86_64<size>::optimize_tls_reloc(bool is_final, int r_type)
2043
// If we are generating a shared library, then we can't do anything
2045
if (parameters->options().shared())
2046
return tls::TLSOPT_NONE;
2050
case elfcpp::R_X86_64_TLSGD:
2051
case elfcpp::R_X86_64_GOTPC32_TLSDESC:
2052
case elfcpp::R_X86_64_TLSDESC_CALL:
2053
// These are General-Dynamic which permits fully general TLS
2054
// access. Since we know that we are generating an executable,
2055
// we can convert this to Initial-Exec. If we also know that
2056
// this is a local symbol, we can further switch to Local-Exec.
2058
return tls::TLSOPT_TO_LE;
2059
return tls::TLSOPT_TO_IE;
2061
case elfcpp::R_X86_64_TLSLD:
2062
// This is Local-Dynamic, which refers to a local symbol in the
2063
// dynamic TLS block. Since we know that we generating an
2064
// executable, we can switch to Local-Exec.
2065
return tls::TLSOPT_TO_LE;
2067
case elfcpp::R_X86_64_DTPOFF32:
2068
case elfcpp::R_X86_64_DTPOFF64:
2069
// Another Local-Dynamic reloc.
2070
return tls::TLSOPT_TO_LE;
2072
case elfcpp::R_X86_64_GOTTPOFF:
2073
// These are Initial-Exec relocs which get the thread offset
2074
// from the GOT. If we know that we are linking against the
2075
// local symbol, we can switch to Local-Exec, which links the
2076
// thread offset into the instruction.
2078
return tls::TLSOPT_TO_LE;
2079
return tls::TLSOPT_NONE;
2081
case elfcpp::R_X86_64_TPOFF32:
2082
// When we already have Local-Exec, there is nothing further we
2084
return tls::TLSOPT_NONE;
2091
// Get the Reference_flags for a particular relocation.
2095
Target_x86_64<size>::Scan::get_reference_flags(unsigned int r_type)
2099
case elfcpp::R_X86_64_NONE:
2100
case elfcpp::R_X86_64_GNU_VTINHERIT:
2101
case elfcpp::R_X86_64_GNU_VTENTRY:
2102
case elfcpp::R_X86_64_GOTPC32:
2103
case elfcpp::R_X86_64_GOTPC64:
2104
// No symbol reference.
2107
case elfcpp::R_X86_64_64:
2108
case elfcpp::R_X86_64_32:
2109
case elfcpp::R_X86_64_32S:
2110
case elfcpp::R_X86_64_16:
2111
case elfcpp::R_X86_64_8:
2112
return Symbol::ABSOLUTE_REF;
2114
case elfcpp::R_X86_64_PC64:
2115
case elfcpp::R_X86_64_PC32:
2116
case elfcpp::R_X86_64_PC16:
2117
case elfcpp::R_X86_64_PC8:
2118
case elfcpp::R_X86_64_GOTOFF64:
2119
return Symbol::RELATIVE_REF;
2121
case elfcpp::R_X86_64_PLT32:
2122
case elfcpp::R_X86_64_PLTOFF64:
2123
return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
2125
case elfcpp::R_X86_64_GOT64:
2126
case elfcpp::R_X86_64_GOT32:
2127
case elfcpp::R_X86_64_GOTPCREL64:
2128
case elfcpp::R_X86_64_GOTPCREL:
2129
case elfcpp::R_X86_64_GOTPLT64:
2131
return Symbol::ABSOLUTE_REF;
2133
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2134
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
2135
case elfcpp::R_X86_64_TLSDESC_CALL:
2136
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
2137
case elfcpp::R_X86_64_DTPOFF32:
2138
case elfcpp::R_X86_64_DTPOFF64:
2139
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2140
case elfcpp::R_X86_64_TPOFF32: // Local-exec
2141
return Symbol::TLS_REF;
2143
case elfcpp::R_X86_64_COPY:
2144
case elfcpp::R_X86_64_GLOB_DAT:
2145
case elfcpp::R_X86_64_JUMP_SLOT:
2146
case elfcpp::R_X86_64_RELATIVE:
2147
case elfcpp::R_X86_64_IRELATIVE:
2148
case elfcpp::R_X86_64_TPOFF64:
2149
case elfcpp::R_X86_64_DTPMOD64:
2150
case elfcpp::R_X86_64_TLSDESC:
2151
case elfcpp::R_X86_64_SIZE32:
2152
case elfcpp::R_X86_64_SIZE64:
2154
// Not expected. We will give an error later.
2159
// Report an unsupported relocation against a local symbol.
2163
Target_x86_64<size>::Scan::unsupported_reloc_local(
2164
Sized_relobj_file<size, false>* object,
2165
unsigned int r_type)
2167
gold_error(_("%s: unsupported reloc %u against local symbol"),
2168
object->name().c_str(), r_type);
2171
// We are about to emit a dynamic relocation of type R_TYPE. If the
2172
// dynamic linker does not support it, issue an error. The GNU linker
2173
// only issues a non-PIC error for an allocated read-only section.
2174
// Here we know the section is allocated, but we don't know that it is
2175
// read-only. But we check for all the relocation types which the
2176
// glibc dynamic linker supports, so it seems appropriate to issue an
2177
// error even if the section is not read-only. If GSYM is not NULL,
2178
// it is the symbol the relocation is against; if it is NULL, the
2179
// relocation is against a local symbol.
2183
Target_x86_64<size>::Scan::check_non_pic(Relobj* object, unsigned int r_type,
2188
// These are the relocation types supported by glibc for x86_64
2189
// which should always work.
2190
case elfcpp::R_X86_64_RELATIVE:
2191
case elfcpp::R_X86_64_IRELATIVE:
2192
case elfcpp::R_X86_64_GLOB_DAT:
2193
case elfcpp::R_X86_64_JUMP_SLOT:
2194
case elfcpp::R_X86_64_DTPMOD64:
2195
case elfcpp::R_X86_64_DTPOFF64:
2196
case elfcpp::R_X86_64_TPOFF64:
2197
case elfcpp::R_X86_64_64:
2198
case elfcpp::R_X86_64_COPY:
2201
// glibc supports these reloc types, but they can overflow.
2202
case elfcpp::R_X86_64_PC32:
2203
// A PC relative reference is OK against a local symbol or if
2204
// the symbol is defined locally.
2206
|| (!gsym->is_from_dynobj()
2207
&& !gsym->is_undefined()
2208
&& !gsym->is_preemptible()))
2211
case elfcpp::R_X86_64_32:
2212
// R_X86_64_32 is OK for x32.
2213
if (size == 32 && r_type == elfcpp::R_X86_64_32)
2215
if (this->issued_non_pic_error_)
2217
gold_assert(parameters->options().output_is_position_independent());
2219
object->error(_("requires dynamic R_X86_64_32 reloc which may "
2220
"overflow at runtime; recompile with -fPIC"));
2222
object->error(_("requires dynamic %s reloc against '%s' which may "
2223
"overflow at runtime; recompile with -fPIC"),
2224
(r_type == elfcpp::R_X86_64_32
2228
this->issued_non_pic_error_ = true;
2232
// This prevents us from issuing more than one error per reloc
2233
// section. But we can still wind up issuing more than one
2234
// error per object file.
2235
if (this->issued_non_pic_error_)
2237
gold_assert(parameters->options().output_is_position_independent());
2238
object->error(_("requires unsupported dynamic reloc %u; "
2239
"recompile with -fPIC"),
2241
this->issued_non_pic_error_ = true;
2244
case elfcpp::R_X86_64_NONE:
2249
// Return whether we need to make a PLT entry for a relocation of the
2250
// given type against a STT_GNU_IFUNC symbol.
2254
Target_x86_64<size>::Scan::reloc_needs_plt_for_ifunc(
2255
Sized_relobj_file<size, false>* object,
2256
unsigned int r_type)
2258
int flags = Scan::get_reference_flags(r_type);
2259
if (flags & Symbol::TLS_REF)
2260
gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
2261
object->name().c_str(), r_type);
2265
// Scan a relocation for a local symbol.
2269
Target_x86_64<size>::Scan::local(Symbol_table* symtab,
2271
Target_x86_64<size>* target,
2272
Sized_relobj_file<size, false>* object,
2273
unsigned int data_shndx,
2274
Output_section* output_section,
2275
const elfcpp::Rela<size, false>& reloc,
2276
unsigned int r_type,
2277
const elfcpp::Sym<size, false>& lsym,
2283
// A local STT_GNU_IFUNC symbol may require a PLT entry.
2284
bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC;
2285
if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type))
2287
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2288
target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
2293
case elfcpp::R_X86_64_NONE:
2294
case elfcpp::R_X86_64_GNU_VTINHERIT:
2295
case elfcpp::R_X86_64_GNU_VTENTRY:
2298
case elfcpp::R_X86_64_64:
2299
// If building a shared library (or a position-independent
2300
// executable), we need to create a dynamic relocation for this
2301
// location. The relocation applied at link time will apply the
2302
// link-time value, so we flag the location with an
2303
// R_X86_64_RELATIVE relocation so the dynamic loader can
2304
// relocate it easily.
2305
if (parameters->options().output_is_position_independent())
2307
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2308
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2309
rela_dyn->add_local_relative(object, r_sym,
2311
? elfcpp::R_X86_64_RELATIVE64
2312
: elfcpp::R_X86_64_RELATIVE),
2313
output_section, data_shndx,
2314
reloc.get_r_offset(),
2315
reloc.get_r_addend(), is_ifunc);
2319
case elfcpp::R_X86_64_32:
2320
case elfcpp::R_X86_64_32S:
2321
case elfcpp::R_X86_64_16:
2322
case elfcpp::R_X86_64_8:
2323
// If building a shared library (or a position-independent
2324
// executable), we need to create a dynamic relocation for this
2325
// location. We can't use an R_X86_64_RELATIVE relocation
2326
// because that is always a 64-bit relocation.
2327
if (parameters->options().output_is_position_independent())
2329
// Use R_X86_64_RELATIVE relocation for R_X86_64_32 under x32.
2330
if (size == 32 && r_type == elfcpp::R_X86_64_32)
2332
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2333
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2334
rela_dyn->add_local_relative(object, r_sym,
2335
elfcpp::R_X86_64_RELATIVE,
2336
output_section, data_shndx,
2337
reloc.get_r_offset(),
2338
reloc.get_r_addend(), is_ifunc);
2342
this->check_non_pic(object, r_type, NULL);
2344
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2345
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2346
if (lsym.get_st_type() != elfcpp::STT_SECTION)
2347
rela_dyn->add_local(object, r_sym, r_type, output_section,
2348
data_shndx, reloc.get_r_offset(),
2349
reloc.get_r_addend());
2352
gold_assert(lsym.get_st_value() == 0);
2353
unsigned int shndx = lsym.get_st_shndx();
2355
shndx = object->adjust_sym_shndx(r_sym, shndx,
2358
object->error(_("section symbol %u has bad shndx %u"),
2361
rela_dyn->add_local_section(object, shndx,
2362
r_type, output_section,
2363
data_shndx, reloc.get_r_offset(),
2364
reloc.get_r_addend());
2369
case elfcpp::R_X86_64_PC64:
2370
case elfcpp::R_X86_64_PC32:
2371
case elfcpp::R_X86_64_PC16:
2372
case elfcpp::R_X86_64_PC8:
2375
case elfcpp::R_X86_64_PLT32:
2376
// Since we know this is a local symbol, we can handle this as a
2380
case elfcpp::R_X86_64_GOTPC32:
2381
case elfcpp::R_X86_64_GOTOFF64:
2382
case elfcpp::R_X86_64_GOTPC64:
2383
case elfcpp::R_X86_64_PLTOFF64:
2384
// We need a GOT section.
2385
target->got_section(symtab, layout);
2386
// For PLTOFF64, we'd normally want a PLT section, but since we
2387
// know this is a local symbol, no PLT is needed.
2390
case elfcpp::R_X86_64_GOT64:
2391
case elfcpp::R_X86_64_GOT32:
2392
case elfcpp::R_X86_64_GOTPCREL64:
2393
case elfcpp::R_X86_64_GOTPCREL:
2394
case elfcpp::R_X86_64_GOTPLT64:
2396
// The symbol requires a GOT entry.
2397
Output_data_got<64, false>* got = target->got_section(symtab, layout);
2398
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2400
// For a STT_GNU_IFUNC symbol we want the PLT offset. That
2401
// lets function pointers compare correctly with shared
2402
// libraries. Otherwise we would need an IRELATIVE reloc.
2405
is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
2407
is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
2410
// If we are generating a shared object, we need to add a
2411
// dynamic relocation for this symbol's GOT entry.
2412
if (parameters->options().output_is_position_independent())
2414
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2415
// R_X86_64_RELATIVE assumes a 64-bit relocation.
2416
if (r_type != elfcpp::R_X86_64_GOT32)
2418
unsigned int got_offset =
2419
object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
2420
rela_dyn->add_local_relative(object, r_sym,
2421
elfcpp::R_X86_64_RELATIVE,
2422
got, got_offset, 0, is_ifunc);
2426
this->check_non_pic(object, r_type, NULL);
2428
gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
2429
rela_dyn->add_local(
2430
object, r_sym, r_type, got,
2431
object->local_got_offset(r_sym, GOT_TYPE_STANDARD), 0);
2435
// For GOTPLT64, we'd normally want a PLT section, but since
2436
// we know this is a local symbol, no PLT is needed.
2440
case elfcpp::R_X86_64_COPY:
2441
case elfcpp::R_X86_64_GLOB_DAT:
2442
case elfcpp::R_X86_64_JUMP_SLOT:
2443
case elfcpp::R_X86_64_RELATIVE:
2444
case elfcpp::R_X86_64_IRELATIVE:
2445
// These are outstanding tls relocs, which are unexpected when linking
2446
case elfcpp::R_X86_64_TPOFF64:
2447
case elfcpp::R_X86_64_DTPMOD64:
2448
case elfcpp::R_X86_64_TLSDESC:
2449
gold_error(_("%s: unexpected reloc %u in object file"),
2450
object->name().c_str(), r_type);
2453
// These are initial tls relocs, which are expected when linking
2454
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2455
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
2456
case elfcpp::R_X86_64_TLSDESC_CALL:
2457
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
2458
case elfcpp::R_X86_64_DTPOFF32:
2459
case elfcpp::R_X86_64_DTPOFF64:
2460
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2461
case elfcpp::R_X86_64_TPOFF32: // Local-exec
2463
bool output_is_shared = parameters->options().shared();
2464
const tls::Tls_optimization optimized_type
2465
= Target_x86_64<size>::optimize_tls_reloc(!output_is_shared,
2469
case elfcpp::R_X86_64_TLSGD: // General-dynamic
2470
if (optimized_type == tls::TLSOPT_NONE)
2472
// Create a pair of GOT entries for the module index and
2473
// dtv-relative offset.
2474
Output_data_got<64, false>* got
2475
= target->got_section(symtab, layout);
2476
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2477
unsigned int shndx = lsym.get_st_shndx();
2479
shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
2481
object->error(_("local symbol %u has bad shndx %u"),
2484
got->add_local_pair_with_rel(object, r_sym,
2487
target->rela_dyn_section(layout),
2488
elfcpp::R_X86_64_DTPMOD64);
2490
else if (optimized_type != tls::TLSOPT_TO_LE)
2491
unsupported_reloc_local(object, r_type);
2494
case elfcpp::R_X86_64_GOTPC32_TLSDESC:
2495
target->define_tls_base_symbol(symtab, layout);
2496
if (optimized_type == tls::TLSOPT_NONE)
2498
// Create reserved PLT and GOT entries for the resolver.
2499
target->reserve_tlsdesc_entries(symtab, layout);
2501
// Generate a double GOT entry with an
2502
// R_X86_64_TLSDESC reloc. The R_X86_64_TLSDESC reloc
2503
// is resolved lazily, so the GOT entry needs to be in
2504
// an area in .got.plt, not .got. Call got_section to
2505
// make sure the section has been created.
2506
target->got_section(symtab, layout);
2507
Output_data_got<64, false>* got = target->got_tlsdesc_section();
2508
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2509
if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC))
2511
unsigned int got_offset = got->add_constant(0);
2512
got->add_constant(0);
2513
object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC,
2515
Reloc_section* rt = target->rela_tlsdesc_section(layout);
2516
// We store the arguments we need in a vector, and
2517
// use the index into the vector as the parameter
2518
// to pass to the target specific routines.
2519
uintptr_t intarg = target->add_tlsdesc_info(object, r_sym);
2520
void* arg = reinterpret_cast<void*>(intarg);
2521
rt->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
2522
got, got_offset, 0);
2525
else if (optimized_type != tls::TLSOPT_TO_LE)
2526
unsupported_reloc_local(object, r_type);
2529
case elfcpp::R_X86_64_TLSDESC_CALL:
2532
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
2533
if (optimized_type == tls::TLSOPT_NONE)
2535
// Create a GOT entry for the module index.
2536
target->got_mod_index_entry(symtab, layout, object);
2538
else if (optimized_type != tls::TLSOPT_TO_LE)
2539
unsupported_reloc_local(object, r_type);
2542
case elfcpp::R_X86_64_DTPOFF32:
2543
case elfcpp::R_X86_64_DTPOFF64:
2546
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2547
layout->set_has_static_tls();
2548
if (optimized_type == tls::TLSOPT_NONE)
2550
// Create a GOT entry for the tp-relative offset.
2551
Output_data_got<64, false>* got
2552
= target->got_section(symtab, layout);
2553
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2554
got->add_local_with_rel(object, r_sym, GOT_TYPE_TLS_OFFSET,
2555
target->rela_dyn_section(layout),
2556
elfcpp::R_X86_64_TPOFF64);
2558
else if (optimized_type != tls::TLSOPT_TO_LE)
2559
unsupported_reloc_local(object, r_type);
2562
case elfcpp::R_X86_64_TPOFF32: // Local-exec
2563
layout->set_has_static_tls();
2564
if (output_is_shared)
2565
unsupported_reloc_local(object, r_type);
2574
case elfcpp::R_X86_64_SIZE32:
2575
case elfcpp::R_X86_64_SIZE64:
2577
gold_error(_("%s: unsupported reloc %u against local symbol"),
2578
object->name().c_str(), r_type);
2584
// Report an unsupported relocation against a global symbol.
2588
Target_x86_64<size>::Scan::unsupported_reloc_global(
2589
Sized_relobj_file<size, false>* object,
2590
unsigned int r_type,
2593
gold_error(_("%s: unsupported reloc %u against global symbol %s"),
2594
object->name().c_str(), r_type, gsym->demangled_name().c_str());
2597
// Returns true if this relocation type could be that of a function pointer.
2600
Target_x86_64<size>::Scan::possible_function_pointer_reloc(unsigned int r_type)
2604
case elfcpp::R_X86_64_64:
2605
case elfcpp::R_X86_64_32:
2606
case elfcpp::R_X86_64_32S:
2607
case elfcpp::R_X86_64_16:
2608
case elfcpp::R_X86_64_8:
2609
case elfcpp::R_X86_64_GOT64:
2610
case elfcpp::R_X86_64_GOT32:
2611
case elfcpp::R_X86_64_GOTPCREL64:
2612
case elfcpp::R_X86_64_GOTPCREL:
2613
case elfcpp::R_X86_64_GOTPLT64:
2621
// For safe ICF, scan a relocation for a local symbol to check if it
2622
// corresponds to a function pointer being taken. In that case mark
2623
// the function whose pointer was taken as not foldable.
2627
Target_x86_64<size>::Scan::local_reloc_may_be_function_pointer(
2630
Target_x86_64<size>* ,
2631
Sized_relobj_file<size, false>* ,
2634
const elfcpp::Rela<size, false>& ,
2635
unsigned int r_type,
2636
const elfcpp::Sym<size, false>&)
2638
// When building a shared library, do not fold any local symbols as it is
2639
// not possible to distinguish pointer taken versus a call by looking at
2640
// the relocation types.
2641
return (parameters->options().shared()
2642
|| possible_function_pointer_reloc(r_type));
2645
// For safe ICF, scan a relocation for a global symbol to check if it
2646
// corresponds to a function pointer being taken. In that case mark
2647
// the function whose pointer was taken as not foldable.
2651
Target_x86_64<size>::Scan::global_reloc_may_be_function_pointer(
2654
Target_x86_64<size>* ,
2655
Sized_relobj_file<size, false>* ,
2658
const elfcpp::Rela<size, false>& ,
2659
unsigned int r_type,
2662
// When building a shared library, do not fold symbols whose visibility
2663
// is hidden, internal or protected.
2664
return ((parameters->options().shared()
2665
&& (gsym->visibility() == elfcpp::STV_INTERNAL
2666
|| gsym->visibility() == elfcpp::STV_PROTECTED
2667
|| gsym->visibility() == elfcpp::STV_HIDDEN))
2668
|| possible_function_pointer_reloc(r_type));
2671
// Scan a relocation for a global symbol.
2675
Target_x86_64<size>::Scan::global(Symbol_table* symtab,
2677
Target_x86_64<size>* target,
2678
Sized_relobj_file<size, false>* object,
2679
unsigned int data_shndx,
2680
Output_section* output_section,
2681
const elfcpp::Rela<size, false>& reloc,
2682
unsigned int r_type,
2685
// A STT_GNU_IFUNC symbol may require a PLT entry.
2686
if (gsym->type() == elfcpp::STT_GNU_IFUNC
2687
&& this->reloc_needs_plt_for_ifunc(object, r_type))
2688
target->make_plt_entry(symtab, layout, gsym);
2692
case elfcpp::R_X86_64_NONE:
2693
case elfcpp::R_X86_64_GNU_VTINHERIT:
2694
case elfcpp::R_X86_64_GNU_VTENTRY:
2697
case elfcpp::R_X86_64_64:
2698
case elfcpp::R_X86_64_32:
2699
case elfcpp::R_X86_64_32S:
2700
case elfcpp::R_X86_64_16:
2701
case elfcpp::R_X86_64_8:
2703
// Make a PLT entry if necessary.
2704
if (gsym->needs_plt_entry())
2706
target->make_plt_entry(symtab, layout, gsym);
2707
// Since this is not a PC-relative relocation, we may be
2708
// taking the address of a function. In that case we need to
2709
// set the entry in the dynamic symbol table to the address of
2711
if (gsym->is_from_dynobj() && !parameters->options().shared())
2712
gsym->set_needs_dynsym_value();
2714
// Make a dynamic relocation if necessary.
2715
if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2717
if (gsym->may_need_copy_reloc())
2719
target->copy_reloc(symtab, layout, object,
2720
data_shndx, output_section, gsym, reloc);
2722
else if (((size == 64 && r_type == elfcpp::R_X86_64_64)
2723
|| (size == 32 && r_type == elfcpp::R_X86_64_32))
2724
&& gsym->type() == elfcpp::STT_GNU_IFUNC
2725
&& gsym->can_use_relative_reloc(false)
2726
&& !gsym->is_from_dynobj()
2727
&& !gsym->is_undefined()
2728
&& !gsym->is_preemptible())
2730
// Use an IRELATIVE reloc for a locally defined
2731
// STT_GNU_IFUNC symbol. This makes a function
2732
// address in a PIE executable match the address in a
2733
// shared library that it links against.
2734
Reloc_section* rela_dyn =
2735
target->rela_irelative_section(layout);
2736
unsigned int r_type = elfcpp::R_X86_64_IRELATIVE;
2737
rela_dyn->add_symbolless_global_addend(gsym, r_type,
2738
output_section, object,
2740
reloc.get_r_offset(),
2741
reloc.get_r_addend());
2743
else if (r_type == elfcpp::R_X86_64_64
2744
&& gsym->can_use_relative_reloc(false))
2746
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2747
rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
2748
output_section, object,
2750
reloc.get_r_offset(),
2751
reloc.get_r_addend(), false);
2755
this->check_non_pic(object, r_type, gsym);
2756
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2757
rela_dyn->add_global(gsym, r_type, output_section, object,
2758
data_shndx, reloc.get_r_offset(),
2759
reloc.get_r_addend());
2765
case elfcpp::R_X86_64_PC64:
2766
case elfcpp::R_X86_64_PC32:
2767
case elfcpp::R_X86_64_PC16:
2768
case elfcpp::R_X86_64_PC8:
2770
// Make a PLT entry if necessary.
2771
if (gsym->needs_plt_entry())
2772
target->make_plt_entry(symtab, layout, gsym);
2773
// Make a dynamic relocation if necessary.
2774
if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2776
if (gsym->may_need_copy_reloc())
2778
target->copy_reloc(symtab, layout, object,
2779
data_shndx, output_section, gsym, reloc);
2783
this->check_non_pic(object, r_type, gsym);
2784
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2785
rela_dyn->add_global(gsym, r_type, output_section, object,
2786
data_shndx, reloc.get_r_offset(),
2787
reloc.get_r_addend());
2793
case elfcpp::R_X86_64_GOT64:
2794
case elfcpp::R_X86_64_GOT32:
2795
case elfcpp::R_X86_64_GOTPCREL64:
2796
case elfcpp::R_X86_64_GOTPCREL:
2797
case elfcpp::R_X86_64_GOTPLT64:
2799
// The symbol requires a GOT entry.
2800
Output_data_got<64, false>* got = target->got_section(symtab, layout);
2801
if (gsym->final_value_is_known())
2803
// For a STT_GNU_IFUNC symbol we want the PLT address.
2804
if (gsym->type() == elfcpp::STT_GNU_IFUNC)
2805
got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2807
got->add_global(gsym, GOT_TYPE_STANDARD);
2811
// If this symbol is not fully resolved, we need to add a
2812
// dynamic relocation for it.
2813
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2815
// Use a GLOB_DAT rather than a RELATIVE reloc if:
2817
// 1) The symbol may be defined in some other module.
2819
// 2) We are building a shared library and this is a
2820
// protected symbol; using GLOB_DAT means that the dynamic
2821
// linker can use the address of the PLT in the main
2822
// executable when appropriate so that function address
2823
// comparisons work.
2825
// 3) This is a STT_GNU_IFUNC symbol in position dependent
2826
// code, again so that function address comparisons work.
2827
if (gsym->is_from_dynobj()
2828
|| gsym->is_undefined()
2829
|| gsym->is_preemptible()
2830
|| (gsym->visibility() == elfcpp::STV_PROTECTED
2831
&& parameters->options().shared())
2832
|| (gsym->type() == elfcpp::STT_GNU_IFUNC
2833
&& parameters->options().output_is_position_independent()))
2834
got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, rela_dyn,
2835
elfcpp::R_X86_64_GLOB_DAT);
2838
// For a STT_GNU_IFUNC symbol we want to write the PLT
2839
// offset into the GOT, so that function pointer
2840
// comparisons work correctly.
2842
if (gsym->type() != elfcpp::STT_GNU_IFUNC)
2843
is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
2846
is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2847
// Tell the dynamic linker to use the PLT address
2848
// when resolving relocations.
2849
if (gsym->is_from_dynobj()
2850
&& !parameters->options().shared())
2851
gsym->set_needs_dynsym_value();
2855
unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
2856
rela_dyn->add_global_relative(gsym,
2857
elfcpp::R_X86_64_RELATIVE,
2858
got, got_off, 0, false);
2862
// For GOTPLT64, we also need a PLT entry (but only if the
2863
// symbol is not fully resolved).
2864
if (r_type == elfcpp::R_X86_64_GOTPLT64
2865
&& !gsym->final_value_is_known())
2866
target->make_plt_entry(symtab, layout, gsym);
2870
case elfcpp::R_X86_64_PLT32:
2871
// If the symbol is fully resolved, this is just a PC32 reloc.
2872
// Otherwise we need a PLT entry.
2873
if (gsym->final_value_is_known())
2875
// If building a shared library, we can also skip the PLT entry
2876
// if the symbol is defined in the output file and is protected
2878
if (gsym->is_defined()
2879
&& !gsym->is_from_dynobj()
2880
&& !gsym->is_preemptible())
2882
target->make_plt_entry(symtab, layout, gsym);
2885
case elfcpp::R_X86_64_GOTPC32:
2886
case elfcpp::R_X86_64_GOTOFF64:
2887
case elfcpp::R_X86_64_GOTPC64:
2888
case elfcpp::R_X86_64_PLTOFF64:
2889
// We need a GOT section.
2890
target->got_section(symtab, layout);
2891
// For PLTOFF64, we also need a PLT entry (but only if the
2892
// symbol is not fully resolved).
2893
if (r_type == elfcpp::R_X86_64_PLTOFF64
2894
&& !gsym->final_value_is_known())
2895
target->make_plt_entry(symtab, layout, gsym);
2898
case elfcpp::R_X86_64_COPY:
2899
case elfcpp::R_X86_64_GLOB_DAT:
2900
case elfcpp::R_X86_64_JUMP_SLOT:
2901
case elfcpp::R_X86_64_RELATIVE:
2902
case elfcpp::R_X86_64_IRELATIVE:
2903
// These are outstanding tls relocs, which are unexpected when linking
2904
case elfcpp::R_X86_64_TPOFF64:
2905
case elfcpp::R_X86_64_DTPMOD64:
2906
case elfcpp::R_X86_64_TLSDESC:
2907
gold_error(_("%s: unexpected reloc %u in object file"),
2908
object->name().c_str(), r_type);
2911
// These are initial tls relocs, which are expected for global()
2912
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2913
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
2914
case elfcpp::R_X86_64_TLSDESC_CALL:
2915
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
2916
case elfcpp::R_X86_64_DTPOFF32:
2917
case elfcpp::R_X86_64_DTPOFF64:
2918
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2919
case elfcpp::R_X86_64_TPOFF32: // Local-exec
2921
const bool is_final = gsym->final_value_is_known();
2922
const tls::Tls_optimization optimized_type
2923
= Target_x86_64<size>::optimize_tls_reloc(is_final, r_type);
2926
case elfcpp::R_X86_64_TLSGD: // General-dynamic
2927
if (optimized_type == tls::TLSOPT_NONE)
2929
// Create a pair of GOT entries for the module index and
2930
// dtv-relative offset.
2931
Output_data_got<64, false>* got
2932
= target->got_section(symtab, layout);
2933
got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR,
2934
target->rela_dyn_section(layout),
2935
elfcpp::R_X86_64_DTPMOD64,
2936
elfcpp::R_X86_64_DTPOFF64);
2938
else if (optimized_type == tls::TLSOPT_TO_IE)
2940
// Create a GOT entry for the tp-relative offset.
2941
Output_data_got<64, false>* got
2942
= target->got_section(symtab, layout);
2943
got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
2944
target->rela_dyn_section(layout),
2945
elfcpp::R_X86_64_TPOFF64);
2947
else if (optimized_type != tls::TLSOPT_TO_LE)
2948
unsupported_reloc_global(object, r_type, gsym);
2951
case elfcpp::R_X86_64_GOTPC32_TLSDESC:
2952
target->define_tls_base_symbol(symtab, layout);
2953
if (optimized_type == tls::TLSOPT_NONE)
2955
// Create reserved PLT and GOT entries for the resolver.
2956
target->reserve_tlsdesc_entries(symtab, layout);
2958
// Create a double GOT entry with an R_X86_64_TLSDESC
2959
// reloc. The R_X86_64_TLSDESC reloc is resolved
2960
// lazily, so the GOT entry needs to be in an area in
2961
// .got.plt, not .got. Call got_section to make sure
2962
// the section has been created.
2963
target->got_section(symtab, layout);
2964
Output_data_got<64, false>* got = target->got_tlsdesc_section();
2965
Reloc_section* rt = target->rela_tlsdesc_section(layout);
2966
got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt,
2967
elfcpp::R_X86_64_TLSDESC, 0);
2969
else if (optimized_type == tls::TLSOPT_TO_IE)
2971
// Create a GOT entry for the tp-relative offset.
2972
Output_data_got<64, false>* got
2973
= target->got_section(symtab, layout);
2974
got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
2975
target->rela_dyn_section(layout),
2976
elfcpp::R_X86_64_TPOFF64);
2978
else if (optimized_type != tls::TLSOPT_TO_LE)
2979
unsupported_reloc_global(object, r_type, gsym);
2982
case elfcpp::R_X86_64_TLSDESC_CALL:
2985
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
2986
if (optimized_type == tls::TLSOPT_NONE)
2988
// Create a GOT entry for the module index.
2989
target->got_mod_index_entry(symtab, layout, object);
2991
else if (optimized_type != tls::TLSOPT_TO_LE)
2992
unsupported_reloc_global(object, r_type, gsym);
2995
case elfcpp::R_X86_64_DTPOFF32:
2996
case elfcpp::R_X86_64_DTPOFF64:
2999
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3000
layout->set_has_static_tls();
3001
if (optimized_type == tls::TLSOPT_NONE)
3003
// Create a GOT entry for the tp-relative offset.
3004
Output_data_got<64, false>* got
3005
= target->got_section(symtab, layout);
3006
got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
3007
target->rela_dyn_section(layout),
3008
elfcpp::R_X86_64_TPOFF64);
3010
else if (optimized_type != tls::TLSOPT_TO_LE)
3011
unsupported_reloc_global(object, r_type, gsym);
3014
case elfcpp::R_X86_64_TPOFF32: // Local-exec
3015
layout->set_has_static_tls();
3016
if (parameters->options().shared())
3017
unsupported_reloc_global(object, r_type, gsym);
3026
case elfcpp::R_X86_64_SIZE32:
3027
case elfcpp::R_X86_64_SIZE64:
3029
gold_error(_("%s: unsupported reloc %u against global symbol %s"),
3030
object->name().c_str(), r_type,
3031
gsym->demangled_name().c_str());
3038
Target_x86_64<size>::gc_process_relocs(Symbol_table* symtab,
3040
Sized_relobj_file<size, false>* object,
3041
unsigned int data_shndx,
3042
unsigned int sh_type,
3043
const unsigned char* prelocs,
3045
Output_section* output_section,
3046
bool needs_special_offset_handling,
3047
size_t local_symbol_count,
3048
const unsigned char* plocal_symbols)
3051
if (sh_type == elfcpp::SHT_REL)
3056
gold::gc_process_relocs<size, false, Target_x86_64<size>, elfcpp::SHT_RELA,
3057
typename Target_x86_64<size>::Scan,
3058
typename Target_x86_64<size>::Relocatable_size_for_reloc>(
3067
needs_special_offset_handling,
3072
// Scan relocations for a section.
3076
Target_x86_64<size>::scan_relocs(Symbol_table* symtab,
3078
Sized_relobj_file<size, false>* object,
3079
unsigned int data_shndx,
3080
unsigned int sh_type,
3081
const unsigned char* prelocs,
3083
Output_section* output_section,
3084
bool needs_special_offset_handling,
3085
size_t local_symbol_count,
3086
const unsigned char* plocal_symbols)
3088
if (sh_type == elfcpp::SHT_REL)
3090
gold_error(_("%s: unsupported REL reloc section"),
3091
object->name().c_str());
3095
gold::scan_relocs<size, false, Target_x86_64<size>, elfcpp::SHT_RELA,
3096
typename Target_x86_64<size>::Scan>(
3105
needs_special_offset_handling,
3110
// Finalize the sections.
3114
Target_x86_64<size>::do_finalize_sections(
3116
const Input_objects*,
3117
Symbol_table* symtab)
3119
const Reloc_section* rel_plt = (this->plt_ == NULL
3121
: this->plt_->rela_plt());
3122
layout->add_target_dynamic_tags(false, this->got_plt_, rel_plt,
3123
this->rela_dyn_, true, false);
3125
// Fill in some more dynamic tags.
3126
Output_data_dynamic* const odyn = layout->dynamic_data();
3129
if (this->plt_ != NULL
3130
&& this->plt_->output_section() != NULL
3131
&& this->plt_->has_tlsdesc_entry())
3133
unsigned int plt_offset = this->plt_->get_tlsdesc_plt_offset();
3134
unsigned int got_offset = this->plt_->get_tlsdesc_got_offset();
3135
this->got_->finalize_data_size();
3136
odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_PLT,
3137
this->plt_, plt_offset);
3138
odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_GOT,
3139
this->got_, got_offset);
3143
// Emit any relocs we saved in an attempt to avoid generating COPY
3145
if (this->copy_relocs_.any_saved_relocs())
3146
this->copy_relocs_.emit(this->rela_dyn_section(layout));
3148
// Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
3149
// the .got.plt section.
3150
Symbol* sym = this->global_offset_table_;
3153
uint64_t data_size = this->got_plt_->current_data_size();
3154
symtab->get_sized_symbol<size>(sym)->set_symsize(data_size);
3157
if (parameters->doing_static_link()
3158
&& (this->plt_ == NULL || !this->plt_->has_irelative_section()))
3160
// If linking statically, make sure that the __rela_iplt symbols
3161
// were defined if necessary, even if we didn't create a PLT.
3162
static const Define_symbol_in_segment syms[] =
3165
"__rela_iplt_start", // name
3166
elfcpp::PT_LOAD, // segment_type
3167
elfcpp::PF_W, // segment_flags_set
3168
elfcpp::PF(0), // segment_flags_clear
3171
elfcpp::STT_NOTYPE, // type
3172
elfcpp::STB_GLOBAL, // binding
3173
elfcpp::STV_HIDDEN, // visibility
3175
Symbol::SEGMENT_START, // offset_from_base
3179
"__rela_iplt_end", // name
3180
elfcpp::PT_LOAD, // segment_type
3181
elfcpp::PF_W, // segment_flags_set
3182
elfcpp::PF(0), // segment_flags_clear
3185
elfcpp::STT_NOTYPE, // type
3186
elfcpp::STB_GLOBAL, // binding
3187
elfcpp::STV_HIDDEN, // visibility
3189
Symbol::SEGMENT_START, // offset_from_base
3194
symtab->define_symbols(layout, 2, syms,
3195
layout->script_options()->saw_sections_clause());
3199
// Perform a relocation.
3203
Target_x86_64<size>::Relocate::relocate(
3204
const Relocate_info<size, false>* relinfo,
3205
Target_x86_64<size>* target,
3208
const elfcpp::Rela<size, false>& rela,
3209
unsigned int r_type,
3210
const Sized_symbol<size>* gsym,
3211
const Symbol_value<size>* psymval,
3212
unsigned char* view,
3213
typename elfcpp::Elf_types<size>::Elf_Addr address,
3214
section_size_type view_size)
3216
if (this->skip_call_tls_get_addr_)
3218
if ((r_type != elfcpp::R_X86_64_PLT32
3219
&& r_type != elfcpp::R_X86_64_PC32)
3221
|| strcmp(gsym->name(), "__tls_get_addr") != 0)
3223
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3224
_("missing expected TLS relocation"));
3228
this->skip_call_tls_get_addr_ = false;
3236
const Sized_relobj_file<size, false>* object = relinfo->object;
3238
// Pick the value to use for symbols defined in the PLT.
3239
Symbol_value<size> symval;
3241
&& gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
3243
symval.set_output_value(target->plt_address_for_global(gsym));
3246
else if (gsym == NULL && psymval->is_ifunc_symbol())
3248
unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3249
if (object->local_has_plt_offset(r_sym))
3251
symval.set_output_value(target->plt_address_for_local(object, r_sym));
3256
const elfcpp::Elf_Xword addend = rela.get_r_addend();
3258
// Get the GOT offset if needed.
3259
// The GOT pointer points to the end of the GOT section.
3260
// We need to subtract the size of the GOT section to get
3261
// the actual offset to use in the relocation.
3262
bool have_got_offset = false;
3263
unsigned int got_offset = 0;
3266
case elfcpp::R_X86_64_GOT32:
3267
case elfcpp::R_X86_64_GOT64:
3268
case elfcpp::R_X86_64_GOTPLT64:
3269
case elfcpp::R_X86_64_GOTPCREL:
3270
case elfcpp::R_X86_64_GOTPCREL64:
3273
gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
3274
got_offset = gsym->got_offset(GOT_TYPE_STANDARD) - target->got_size();
3278
unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3279
gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
3280
got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
3281
- target->got_size());
3283
have_got_offset = true;
3292
case elfcpp::R_X86_64_NONE:
3293
case elfcpp::R_X86_64_GNU_VTINHERIT:
3294
case elfcpp::R_X86_64_GNU_VTENTRY:
3297
case elfcpp::R_X86_64_64:
3298
Relocate_functions<size, false>::rela64(view, object, psymval, addend);
3301
case elfcpp::R_X86_64_PC64:
3302
Relocate_functions<size, false>::pcrela64(view, object, psymval, addend,
3306
case elfcpp::R_X86_64_32:
3307
// FIXME: we need to verify that value + addend fits into 32 bits:
3308
// uint64_t x = value + addend;
3309
// x == static_cast<uint64_t>(static_cast<uint32_t>(x))
3310
// Likewise for other <=32-bit relocations (but see R_X86_64_32S).
3311
Relocate_functions<size, false>::rela32(view, object, psymval, addend);
3314
case elfcpp::R_X86_64_32S:
3315
// FIXME: we need to verify that value + addend fits into 32 bits:
3316
// int64_t x = value + addend; // note this quantity is signed!
3317
// x == static_cast<int64_t>(static_cast<int32_t>(x))
3318
Relocate_functions<size, false>::rela32(view, object, psymval, addend);
3321
case elfcpp::R_X86_64_PC32:
3322
Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
3326
case elfcpp::R_X86_64_16:
3327
Relocate_functions<size, false>::rela16(view, object, psymval, addend);
3330
case elfcpp::R_X86_64_PC16:
3331
Relocate_functions<size, false>::pcrela16(view, object, psymval, addend,
3335
case elfcpp::R_X86_64_8:
3336
Relocate_functions<size, false>::rela8(view, object, psymval, addend);
3339
case elfcpp::R_X86_64_PC8:
3340
Relocate_functions<size, false>::pcrela8(view, object, psymval, addend,
3344
case elfcpp::R_X86_64_PLT32:
3345
gold_assert(gsym == NULL
3346
|| gsym->has_plt_offset()
3347
|| gsym->final_value_is_known()
3348
|| (gsym->is_defined()
3349
&& !gsym->is_from_dynobj()
3350
&& !gsym->is_preemptible()));
3351
// Note: while this code looks the same as for R_X86_64_PC32, it
3352
// behaves differently because psymval was set to point to
3353
// the PLT entry, rather than the symbol, in Scan::global().
3354
Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
3358
case elfcpp::R_X86_64_PLTOFF64:
3361
gold_assert(gsym->has_plt_offset()
3362
|| gsym->final_value_is_known());
3363
typename elfcpp::Elf_types<size>::Elf_Addr got_address;
3364
got_address = target->got_section(NULL, NULL)->address();
3365
Relocate_functions<size, false>::rela64(view, object, psymval,
3366
addend - got_address);
3369
case elfcpp::R_X86_64_GOT32:
3370
gold_assert(have_got_offset);
3371
Relocate_functions<size, false>::rela32(view, got_offset, addend);
3374
case elfcpp::R_X86_64_GOTPC32:
3377
typename elfcpp::Elf_types<size>::Elf_Addr value;
3378
value = target->got_plt_section()->address();
3379
Relocate_functions<size, false>::pcrela32(view, value, addend, address);
3383
case elfcpp::R_X86_64_GOT64:
3384
// The ABI doc says "Like GOT64, but indicates a PLT entry is needed."
3385
// Since we always add a PLT entry, this is equivalent.
3386
case elfcpp::R_X86_64_GOTPLT64:
3387
gold_assert(have_got_offset);
3388
Relocate_functions<size, false>::rela64(view, got_offset, addend);
3391
case elfcpp::R_X86_64_GOTPC64:
3394
typename elfcpp::Elf_types<size>::Elf_Addr value;
3395
value = target->got_plt_section()->address();
3396
Relocate_functions<size, false>::pcrela64(view, value, addend, address);
3400
case elfcpp::R_X86_64_GOTOFF64:
3402
typename elfcpp::Elf_types<size>::Elf_Addr value;
3403
value = (psymval->value(object, 0)
3404
- target->got_plt_section()->address());
3405
Relocate_functions<size, false>::rela64(view, value, addend);
3409
case elfcpp::R_X86_64_GOTPCREL:
3411
gold_assert(have_got_offset);
3412
typename elfcpp::Elf_types<size>::Elf_Addr value;
3413
value = target->got_plt_section()->address() + got_offset;
3414
Relocate_functions<size, false>::pcrela32(view, value, addend, address);
3418
case elfcpp::R_X86_64_GOTPCREL64:
3420
gold_assert(have_got_offset);
3421
typename elfcpp::Elf_types<size>::Elf_Addr value;
3422
value = target->got_plt_section()->address() + got_offset;
3423
Relocate_functions<size, false>::pcrela64(view, value, addend, address);
3427
case elfcpp::R_X86_64_COPY:
3428
case elfcpp::R_X86_64_GLOB_DAT:
3429
case elfcpp::R_X86_64_JUMP_SLOT:
3430
case elfcpp::R_X86_64_RELATIVE:
3431
case elfcpp::R_X86_64_IRELATIVE:
3432
// These are outstanding tls relocs, which are unexpected when linking
3433
case elfcpp::R_X86_64_TPOFF64:
3434
case elfcpp::R_X86_64_DTPMOD64:
3435
case elfcpp::R_X86_64_TLSDESC:
3436
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3437
_("unexpected reloc %u in object file"),
3441
// These are initial tls relocs, which are expected when linking
3442
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
3443
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
3444
case elfcpp::R_X86_64_TLSDESC_CALL:
3445
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
3446
case elfcpp::R_X86_64_DTPOFF32:
3447
case elfcpp::R_X86_64_DTPOFF64:
3448
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3449
case elfcpp::R_X86_64_TPOFF32: // Local-exec
3450
this->relocate_tls(relinfo, target, relnum, rela, r_type, gsym, psymval,
3451
view, address, view_size);
3454
case elfcpp::R_X86_64_SIZE32:
3455
case elfcpp::R_X86_64_SIZE64:
3457
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3458
_("unsupported reloc %u"),
3466
// Perform a TLS relocation.
3470
Target_x86_64<size>::Relocate::relocate_tls(
3471
const Relocate_info<size, false>* relinfo,
3472
Target_x86_64<size>* target,
3474
const elfcpp::Rela<size, false>& rela,
3475
unsigned int r_type,
3476
const Sized_symbol<size>* gsym,
3477
const Symbol_value<size>* psymval,
3478
unsigned char* view,
3479
typename elfcpp::Elf_types<size>::Elf_Addr address,
3480
section_size_type view_size)
3482
Output_segment* tls_segment = relinfo->layout->tls_segment();
3484
const Sized_relobj_file<size, false>* object = relinfo->object;
3485
const elfcpp::Elf_Xword addend = rela.get_r_addend();
3486
elfcpp::Shdr<size, false> data_shdr(relinfo->data_shdr);
3487
bool is_executable = (data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0;
3489
typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(relinfo->object, 0);
3491
const bool is_final = (gsym == NULL
3492
? !parameters->options().shared()
3493
: gsym->final_value_is_known());
3494
tls::Tls_optimization optimized_type
3495
= Target_x86_64<size>::optimize_tls_reloc(is_final, r_type);
3498
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
3499
if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
3501
// If this code sequence is used in a non-executable section,
3502
// we will not optimize the R_X86_64_DTPOFF32/64 relocation,
3503
// on the assumption that it's being used by itself in a debug
3504
// section. Therefore, in the unlikely event that the code
3505
// sequence appears in a non-executable section, we simply
3506
// leave it unoptimized.
3507
optimized_type = tls::TLSOPT_NONE;
3509
if (optimized_type == tls::TLSOPT_TO_LE)
3511
if (tls_segment == NULL)
3513
gold_assert(parameters->errors()->error_count() > 0
3514
|| issue_undefined_symbol_error(gsym));
3517
this->tls_gd_to_le(relinfo, relnum, tls_segment,
3518
rela, r_type, value, view,
3524
unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3525
? GOT_TYPE_TLS_OFFSET
3526
: GOT_TYPE_TLS_PAIR);
3527
unsigned int got_offset;
3530
gold_assert(gsym->has_got_offset(got_type));
3531
got_offset = gsym->got_offset(got_type) - target->got_size();
3535
unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3536
gold_assert(object->local_has_got_offset(r_sym, got_type));
3537
got_offset = (object->local_got_offset(r_sym, got_type)
3538
- target->got_size());
3540
if (optimized_type == tls::TLSOPT_TO_IE)
3542
value = target->got_plt_section()->address() + got_offset;
3543
this->tls_gd_to_ie(relinfo, relnum, tls_segment, rela, r_type,
3544
value, view, address, view_size);
3547
else if (optimized_type == tls::TLSOPT_NONE)
3549
// Relocate the field with the offset of the pair of GOT
3551
value = target->got_plt_section()->address() + got_offset;
3552
Relocate_functions<size, false>::pcrela32(view, value, addend,
3557
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3558
_("unsupported reloc %u"), r_type);
3561
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
3562
case elfcpp::R_X86_64_TLSDESC_CALL:
3563
if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
3565
// See above comment for R_X86_64_TLSGD.
3566
optimized_type = tls::TLSOPT_NONE;
3568
if (optimized_type == tls::TLSOPT_TO_LE)
3570
if (tls_segment == NULL)
3572
gold_assert(parameters->errors()->error_count() > 0
3573
|| issue_undefined_symbol_error(gsym));
3576
this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
3577
rela, r_type, value, view,
3583
unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3584
? GOT_TYPE_TLS_OFFSET
3585
: GOT_TYPE_TLS_DESC);
3586
unsigned int got_offset = 0;
3587
if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC
3588
&& optimized_type == tls::TLSOPT_NONE)
3590
// We created GOT entries in the .got.tlsdesc portion of
3591
// the .got.plt section, but the offset stored in the
3592
// symbol is the offset within .got.tlsdesc.
3593
got_offset = (target->got_size()
3594
+ target->got_plt_section()->data_size());
3598
gold_assert(gsym->has_got_offset(got_type));
3599
got_offset += gsym->got_offset(got_type) - target->got_size();
3603
unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3604
gold_assert(object->local_has_got_offset(r_sym, got_type));
3605
got_offset += (object->local_got_offset(r_sym, got_type)
3606
- target->got_size());
3608
if (optimized_type == tls::TLSOPT_TO_IE)
3610
if (tls_segment == NULL)
3612
gold_assert(parameters->errors()->error_count() > 0
3613
|| issue_undefined_symbol_error(gsym));
3616
value = target->got_plt_section()->address() + got_offset;
3617
this->tls_desc_gd_to_ie(relinfo, relnum, tls_segment,
3618
rela, r_type, value, view, address,
3622
else if (optimized_type == tls::TLSOPT_NONE)
3624
if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3626
// Relocate the field with the offset of the pair of GOT
3628
value = target->got_plt_section()->address() + got_offset;
3629
Relocate_functions<size, false>::pcrela32(view, value, addend,
3635
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3636
_("unsupported reloc %u"), r_type);
3639
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
3640
if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
3642
// See above comment for R_X86_64_TLSGD.
3643
optimized_type = tls::TLSOPT_NONE;
3645
if (optimized_type == tls::TLSOPT_TO_LE)
3647
if (tls_segment == NULL)
3649
gold_assert(parameters->errors()->error_count() > 0
3650
|| issue_undefined_symbol_error(gsym));
3653
this->tls_ld_to_le(relinfo, relnum, tls_segment, rela, r_type,
3654
value, view, view_size);
3657
else if (optimized_type == tls::TLSOPT_NONE)
3659
// Relocate the field with the offset of the GOT entry for
3660
// the module index.
3661
unsigned int got_offset;
3662
got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
3663
- target->got_size());
3664
value = target->got_plt_section()->address() + got_offset;
3665
Relocate_functions<size, false>::pcrela32(view, value, addend,
3669
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3670
_("unsupported reloc %u"), r_type);
3673
case elfcpp::R_X86_64_DTPOFF32:
3674
// This relocation type is used in debugging information.
3675
// In that case we need to not optimize the value. If the
3676
// section is not executable, then we assume we should not
3677
// optimize this reloc. See comments above for R_X86_64_TLSGD,
3678
// R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and
3680
if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3682
if (tls_segment == NULL)
3684
gold_assert(parameters->errors()->error_count() > 0
3685
|| issue_undefined_symbol_error(gsym));
3688
value -= tls_segment->memsz();
3690
Relocate_functions<size, false>::rela32(view, value, addend);
3693
case elfcpp::R_X86_64_DTPOFF64:
3694
// See R_X86_64_DTPOFF32, just above, for why we check for is_executable.
3695
if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3697
if (tls_segment == NULL)
3699
gold_assert(parameters->errors()->error_count() > 0
3700
|| issue_undefined_symbol_error(gsym));
3703
value -= tls_segment->memsz();
3705
Relocate_functions<size, false>::rela64(view, value, addend);
3708
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3709
if (optimized_type == tls::TLSOPT_TO_LE)
3711
if (tls_segment == NULL)
3713
gold_assert(parameters->errors()->error_count() > 0
3714
|| issue_undefined_symbol_error(gsym));
3717
Target_x86_64<size>::Relocate::tls_ie_to_le(relinfo, relnum,
3719
r_type, value, view,
3723
else if (optimized_type == tls::TLSOPT_NONE)
3725
// Relocate the field with the offset of the GOT entry for
3726
// the tp-relative offset of the symbol.
3727
unsigned int got_offset;
3730
gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
3731
got_offset = (gsym->got_offset(GOT_TYPE_TLS_OFFSET)
3732
- target->got_size());
3736
unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3737
gold_assert(object->local_has_got_offset(r_sym,
3738
GOT_TYPE_TLS_OFFSET));
3739
got_offset = (object->local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET)
3740
- target->got_size());
3742
value = target->got_plt_section()->address() + got_offset;
3743
Relocate_functions<size, false>::pcrela32(view, value, addend,
3747
gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3748
_("unsupported reloc type %u"),
3752
case elfcpp::R_X86_64_TPOFF32: // Local-exec
3753
if (tls_segment == NULL)
3755
gold_assert(parameters->errors()->error_count() > 0
3756
|| issue_undefined_symbol_error(gsym));
3759
value -= tls_segment->memsz();
3760
Relocate_functions<size, false>::rela32(view, value, addend);
3765
// Do a relocation in which we convert a TLS General-Dynamic to an
3770
Target_x86_64<size>::Relocate::tls_gd_to_ie(
3771
const Relocate_info<size, false>* relinfo,
3774
const elfcpp::Rela<size, false>& rela,
3776
typename elfcpp::Elf_types<size>::Elf_Addr value,
3777
unsigned char* view,
3778
typename elfcpp::Elf_types<size>::Elf_Addr address,
3779
section_size_type view_size)
3782
// .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3783
// .word 0x6666; rex64; call __tls_get_addr
3784
// ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax
3786
// leaq foo@tlsgd(%rip),%rdi;
3787
// .word 0x6666; rex64; call __tls_get_addr
3788
// ==> movl %fs:0,%eax; addq x@gottpoff(%rip),%rax
3790
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
3791
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3792
(memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
3796
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
3798
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3799
(memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3800
memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0",
3805
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
3807
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3808
(memcmp(view - 3, "\x48\x8d\x3d", 3) == 0));
3809
memcpy(view - 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0",
3813
const elfcpp::Elf_Xword addend = rela.get_r_addend();
3814
Relocate_functions<size, false>::pcrela32(view + 8, value, addend - 8,
3817
// The next reloc should be a PLT32 reloc against __tls_get_addr.
3819
this->skip_call_tls_get_addr_ = true;
3822
// Do a relocation in which we convert a TLS General-Dynamic to a
3827
Target_x86_64<size>::Relocate::tls_gd_to_le(
3828
const Relocate_info<size, false>* relinfo,
3830
Output_segment* tls_segment,
3831
const elfcpp::Rela<size, false>& rela,
3833
typename elfcpp::Elf_types<size>::Elf_Addr value,
3834
unsigned char* view,
3835
section_size_type view_size)
3838
// .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3839
// .word 0x6666; rex64; call __tls_get_addr
3840
// ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax
3842
// leaq foo@tlsgd(%rip),%rdi;
3843
// .word 0x6666; rex64; call __tls_get_addr
3844
// ==> movl %fs:0,%eax; leaq x@tpoff(%rax),%rax
3846
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
3847
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3848
(memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
3852
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
3854
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3855
(memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3856
memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0",
3861
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
3863
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3864
(memcmp(view - 3, "\x48\x8d\x3d", 3) == 0));
3866
memcpy(view - 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0",
3870
value -= tls_segment->memsz();
3871
Relocate_functions<size, false>::rela32(view + 8, value, 0);
3873
// The next reloc should be a PLT32 reloc against __tls_get_addr.
3875
this->skip_call_tls_get_addr_ = true;
3878
// Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
3882
Target_x86_64<size>::Relocate::tls_desc_gd_to_ie(
3883
const Relocate_info<size, false>* relinfo,
3886
const elfcpp::Rela<size, false>& rela,
3887
unsigned int r_type,
3888
typename elfcpp::Elf_types<size>::Elf_Addr value,
3889
unsigned char* view,
3890
typename elfcpp::Elf_types<size>::Elf_Addr address,
3891
section_size_type view_size)
3893
if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3895
// leaq foo@tlsdesc(%rip), %rax
3896
// ==> movq foo@gottpoff(%rip), %rax
3897
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3898
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3899
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3900
view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
3902
const elfcpp::Elf_Xword addend = rela.get_r_addend();
3903
Relocate_functions<size, false>::pcrela32(view, value, addend, address);
3907
// call *foo@tlscall(%rax)
3909
gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
3910
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
3911
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3912
view[0] == 0xff && view[1] == 0x10);
3918
// Do a TLSDESC-style General-Dynamic to Local-Exec transition.
3922
Target_x86_64<size>::Relocate::tls_desc_gd_to_le(
3923
const Relocate_info<size, false>* relinfo,
3925
Output_segment* tls_segment,
3926
const elfcpp::Rela<size, false>& rela,
3927
unsigned int r_type,
3928
typename elfcpp::Elf_types<size>::Elf_Addr value,
3929
unsigned char* view,
3930
section_size_type view_size)
3932
if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3934
// leaq foo@tlsdesc(%rip), %rax
3935
// ==> movq foo@tpoff, %rax
3936
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3937
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3938
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3939
view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
3942
value -= tls_segment->memsz();
3943
Relocate_functions<size, false>::rela32(view, value, 0);
3947
// call *foo@tlscall(%rax)
3949
gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
3950
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
3951
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3952
view[0] == 0xff && view[1] == 0x10);
3960
Target_x86_64<size>::Relocate::tls_ld_to_le(
3961
const Relocate_info<size, false>* relinfo,
3964
const elfcpp::Rela<size, false>& rela,
3966
typename elfcpp::Elf_types<size>::Elf_Addr,
3967
unsigned char* view,
3968
section_size_type view_size)
3970
// leaq foo@tlsld(%rip),%rdi; call __tls_get_addr@plt;
3972
// ... leq foo@dtpoff(%rax),%reg
3973
// ==> .word 0x6666; .byte 0x66; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx
3975
// ... leq foo@dtpoff(%rax),%reg
3976
// ==> nopl 0x0(%rax); movl %fs:0,%eax ... leaq x@tpoff(%rax),%rdx
3978
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3979
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 9);
3981
tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3982
view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x3d);
3984
tls::check_tls(relinfo, relnum, rela.get_r_offset(), view[4] == 0xe8);
3987
memcpy(view - 3, "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 12);
3989
memcpy(view - 3, "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0\0", 12);
3991
// The next reloc should be a PLT32 reloc against __tls_get_addr.
3993
this->skip_call_tls_get_addr_ = true;
3996
// Do a relocation in which we convert a TLS Initial-Exec to a
4001
Target_x86_64<size>::Relocate::tls_ie_to_le(
4002
const Relocate_info<size, false>* relinfo,
4004
Output_segment* tls_segment,
4005
const elfcpp::Rela<size, false>& rela,
4007
typename elfcpp::Elf_types<size>::Elf_Addr value,
4008
unsigned char* view,
4009
section_size_type view_size)
4011
// We need to examine the opcodes to figure out which instruction we
4014
// movq foo@gottpoff(%rip),%reg ==> movq $YY,%reg
4015
// addq foo@gottpoff(%rip),%reg ==> addq $YY,%reg
4017
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
4018
tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
4020
unsigned char op1 = view[-3];
4021
unsigned char op2 = view[-2];
4022
unsigned char op3 = view[-1];
4023
unsigned char reg = op3 >> 3;
4031
view[-1] = 0xc0 | reg;
4035
// Special handling for %rsp.
4039
view[-1] = 0xc0 | reg;
4047
view[-1] = 0x80 | reg | (reg << 3);
4050
value -= tls_segment->memsz();
4051
Relocate_functions<size, false>::rela32(view, value, 0);
4054
// Relocate section data.
4058
Target_x86_64<size>::relocate_section(
4059
const Relocate_info<size, false>* relinfo,
4060
unsigned int sh_type,
4061
const unsigned char* prelocs,
4063
Output_section* output_section,
4064
bool needs_special_offset_handling,
4065
unsigned char* view,
4066
typename elfcpp::Elf_types<size>::Elf_Addr address,
4067
section_size_type view_size,
4068
const Reloc_symbol_changes* reloc_symbol_changes)
4070
gold_assert(sh_type == elfcpp::SHT_RELA);
4072
gold::relocate_section<size, false, Target_x86_64<size>, elfcpp::SHT_RELA,
4073
typename Target_x86_64<size>::Relocate,
4074
gold::Default_comdat_behavior>(
4080
needs_special_offset_handling,
4084
reloc_symbol_changes);
4087
// Apply an incremental relocation. Incremental relocations always refer
4088
// to global symbols.
4092
Target_x86_64<size>::apply_relocation(
4093
const Relocate_info<size, false>* relinfo,
4094
typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
4095
unsigned int r_type,
4096
typename elfcpp::Elf_types<size>::Elf_Swxword r_addend,
4098
unsigned char* view,
4099
typename elfcpp::Elf_types<size>::Elf_Addr address,
4100
section_size_type view_size)
4102
gold::apply_relocation<size, false, Target_x86_64<size>,
4103
typename Target_x86_64<size>::Relocate>(
4115
// Return the size of a relocation while scanning during a relocatable
4120
Target_x86_64<size>::Relocatable_size_for_reloc::get_size_for_reloc(
4121
unsigned int r_type,
4126
case elfcpp::R_X86_64_NONE:
4127
case elfcpp::R_X86_64_GNU_VTINHERIT:
4128
case elfcpp::R_X86_64_GNU_VTENTRY:
4129
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
4130
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
4131
case elfcpp::R_X86_64_TLSDESC_CALL:
4132
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
4133
case elfcpp::R_X86_64_DTPOFF32:
4134
case elfcpp::R_X86_64_DTPOFF64:
4135
case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
4136
case elfcpp::R_X86_64_TPOFF32: // Local-exec
4139
case elfcpp::R_X86_64_64:
4140
case elfcpp::R_X86_64_PC64:
4141
case elfcpp::R_X86_64_GOTOFF64:
4142
case elfcpp::R_X86_64_GOTPC64:
4143
case elfcpp::R_X86_64_PLTOFF64:
4144
case elfcpp::R_X86_64_GOT64:
4145
case elfcpp::R_X86_64_GOTPCREL64:
4146
case elfcpp::R_X86_64_GOTPCREL:
4147
case elfcpp::R_X86_64_GOTPLT64:
4150
case elfcpp::R_X86_64_32:
4151
case elfcpp::R_X86_64_32S:
4152
case elfcpp::R_X86_64_PC32:
4153
case elfcpp::R_X86_64_PLT32:
4154
case elfcpp::R_X86_64_GOTPC32:
4155
case elfcpp::R_X86_64_GOT32:
4158
case elfcpp::R_X86_64_16:
4159
case elfcpp::R_X86_64_PC16:
4162
case elfcpp::R_X86_64_8:
4163
case elfcpp::R_X86_64_PC8:
4166
case elfcpp::R_X86_64_COPY:
4167
case elfcpp::R_X86_64_GLOB_DAT:
4168
case elfcpp::R_X86_64_JUMP_SLOT:
4169
case elfcpp::R_X86_64_RELATIVE:
4170
case elfcpp::R_X86_64_IRELATIVE:
4171
// These are outstanding tls relocs, which are unexpected when linking
4172
case elfcpp::R_X86_64_TPOFF64:
4173
case elfcpp::R_X86_64_DTPMOD64:
4174
case elfcpp::R_X86_64_TLSDESC:
4175
object->error(_("unexpected reloc %u in object file"), r_type);
4178
case elfcpp::R_X86_64_SIZE32:
4179
case elfcpp::R_X86_64_SIZE64:
4181
object->error(_("unsupported reloc %u against local symbol"), r_type);
4186
// Scan the relocs during a relocatable link.
4190
Target_x86_64<size>::scan_relocatable_relocs(
4191
Symbol_table* symtab,
4193
Sized_relobj_file<size, false>* object,
4194
unsigned int data_shndx,
4195
unsigned int sh_type,
4196
const unsigned char* prelocs,
4198
Output_section* output_section,
4199
bool needs_special_offset_handling,
4200
size_t local_symbol_count,
4201
const unsigned char* plocal_symbols,
4202
Relocatable_relocs* rr)
4204
gold_assert(sh_type == elfcpp::SHT_RELA);
4206
typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
4207
Relocatable_size_for_reloc> Scan_relocatable_relocs;
4209
gold::scan_relocatable_relocs<size, false, elfcpp::SHT_RELA,
4210
Scan_relocatable_relocs>(
4218
needs_special_offset_handling,
4224
// Relocate a section during a relocatable link.
4228
Target_x86_64<size>::relocate_relocs(
4229
const Relocate_info<size, false>* relinfo,
4230
unsigned int sh_type,
4231
const unsigned char* prelocs,
4233
Output_section* output_section,
4234
typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
4235
const Relocatable_relocs* rr,
4236
unsigned char* view,
4237
typename elfcpp::Elf_types<size>::Elf_Addr view_address,
4238
section_size_type view_size,
4239
unsigned char* reloc_view,
4240
section_size_type reloc_view_size)
4242
gold_assert(sh_type == elfcpp::SHT_RELA);
4244
gold::relocate_relocs<size, false, elfcpp::SHT_RELA>(
4249
offset_in_output_section,
4258
// Return the value to use for a dynamic which requires special
4259
// treatment. This is how we support equality comparisons of function
4260
// pointers across shared library boundaries, as described in the
4261
// processor specific ABI supplement.
4265
Target_x86_64<size>::do_dynsym_value(const Symbol* gsym) const
4267
gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
4268
return this->plt_address_for_global(gsym);
4271
// Return a string used to fill a code section with nops to take up
4272
// the specified length.
4276
Target_x86_64<size>::do_code_fill(section_size_type length) const
4280
// Build a jmpq instruction to skip over the bytes.
4281
unsigned char jmp[5];
4283
elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
4284
return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
4285
+ std::string(length - 5, static_cast<char>(0x90)));
4288
// Nop sequences of various lengths.
4289
const char nop1[1] = { '\x90' }; // nop
4290
const char nop2[2] = { '\x66', '\x90' }; // xchg %ax %ax
4291
const char nop3[3] = { '\x0f', '\x1f', '\x00' }; // nop (%rax)
4292
const char nop4[4] = { '\x0f', '\x1f', '\x40', // nop 0(%rax)
4294
const char nop5[5] = { '\x0f', '\x1f', '\x44', // nop 0(%rax,%rax,1)
4296
const char nop6[6] = { '\x66', '\x0f', '\x1f', // nopw 0(%rax,%rax,1)
4297
'\x44', '\x00', '\x00' };
4298
const char nop7[7] = { '\x0f', '\x1f', '\x80', // nopl 0L(%rax)
4299
'\x00', '\x00', '\x00',
4301
const char nop8[8] = { '\x0f', '\x1f', '\x84', // nopl 0L(%rax,%rax,1)
4302
'\x00', '\x00', '\x00',
4304
const char nop9[9] = { '\x66', '\x0f', '\x1f', // nopw 0L(%rax,%rax,1)
4305
'\x84', '\x00', '\x00',
4306
'\x00', '\x00', '\x00' };
4307
const char nop10[10] = { '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1)
4308
'\x1f', '\x84', '\x00',
4309
'\x00', '\x00', '\x00',
4311
const char nop11[11] = { '\x66', '\x66', '\x2e', // data16
4312
'\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1)
4313
'\x00', '\x00', '\x00',
4315
const char nop12[12] = { '\x66', '\x66', '\x66', // data16; data16
4316
'\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1)
4317
'\x84', '\x00', '\x00',
4318
'\x00', '\x00', '\x00' };
4319
const char nop13[13] = { '\x66', '\x66', '\x66', // data16; data16; data16
4320
'\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1)
4321
'\x1f', '\x84', '\x00',
4322
'\x00', '\x00', '\x00',
4324
const char nop14[14] = { '\x66', '\x66', '\x66', // data16; data16; data16
4325
'\x66', '\x66', '\x2e', // data16
4326
'\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1)
4327
'\x00', '\x00', '\x00',
4329
const char nop15[15] = { '\x66', '\x66', '\x66', // data16; data16; data16
4330
'\x66', '\x66', '\x66', // data16; data16
4331
'\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1)
4332
'\x84', '\x00', '\x00',
4333
'\x00', '\x00', '\x00' };
4335
const char* nops[16] = {
4337
nop1, nop2, nop3, nop4, nop5, nop6, nop7,
4338
nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
4341
return std::string(nops[length], length);
4344
// Return the addend to use for a target specific relocation. The
4345
// only target specific relocation is R_X86_64_TLSDESC for a local
4346
// symbol. We want to set the addend is the offset of the local
4347
// symbol in the TLS segment.
4351
Target_x86_64<size>::do_reloc_addend(void* arg, unsigned int r_type,
4354
gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
4355
uintptr_t intarg = reinterpret_cast<uintptr_t>(arg);
4356
gold_assert(intarg < this->tlsdesc_reloc_info_.size());
4357
const Tlsdesc_info& ti(this->tlsdesc_reloc_info_[intarg]);
4358
const Symbol_value<size>* psymval = ti.object->local_symbol(ti.r_sym);
4359
gold_assert(psymval->is_tls_symbol());
4360
// The value of a TLS symbol is the offset in the TLS segment.
4361
return psymval->value(ti.object, 0);
4364
// Return the value to use for the base of a DW_EH_PE_datarel offset
4365
// in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their
4366
// assembler can not write out the difference between two labels in
4367
// different sections, so instead of using a pc-relative value they
4368
// use an offset from the GOT.
4372
Target_x86_64<size>::do_ehframe_datarel_base() const
4374
gold_assert(this->global_offset_table_ != NULL);
4375
Symbol* sym = this->global_offset_table_;
4376
Sized_symbol<size>* ssym = static_cast<Sized_symbol<size>*>(sym);
4377
return ssym->value();
4380
// FNOFFSET in section SHNDX in OBJECT is the start of a function
4381
// compiled with -fsplit-stack. The function calls non-split-stack
4382
// code. We have to change the function so that it always ensures
4383
// that it has enough stack space to run some random function.
4387
Target_x86_64<size>::do_calls_non_split(Relobj* object, unsigned int shndx,
4388
section_offset_type fnoffset,
4389
section_size_type fnsize,
4390
unsigned char* view,
4391
section_size_type view_size,
4393
std::string* to) const
4395
// The function starts with a comparison of the stack pointer and a
4396
// field in the TCB. This is followed by a jump.
4399
if (this->match_view(view, view_size, fnoffset, "\x64\x48\x3b\x24\x25", 5)
4402
// We will call __morestack if the carry flag is set after this
4403
// comparison. We turn the comparison into an stc instruction
4405
view[fnoffset] = '\xf9';
4406
this->set_view_to_nop(view, view_size, fnoffset + 1, 8);
4408
// lea NN(%rsp),%r10
4409
// lea NN(%rsp),%r11
4410
else if ((this->match_view(view, view_size, fnoffset,
4411
"\x4c\x8d\x94\x24", 4)
4412
|| this->match_view(view, view_size, fnoffset,
4413
"\x4c\x8d\x9c\x24", 4))
4416
// This is loading an offset from the stack pointer for a
4417
// comparison. The offset is negative, so we decrease the
4418
// offset by the amount of space we need for the stack. This
4419
// means we will avoid calling __morestack if there happens to
4420
// be plenty of space on the stack already.
4421
unsigned char* pval = view + fnoffset + 4;
4422
uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
4423
val -= parameters->options().split_stack_adjust_size();
4424
elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
4428
if (!object->has_no_split_stack())
4429
object->error(_("failed to match split-stack sequence at "
4430
"section %u offset %0zx"),
4431
shndx, static_cast<size_t>(fnoffset));
4435
// We have to change the function so that it calls
4436
// __morestack_non_split instead of __morestack. The former will
4437
// allocate additional stack space.
4438
*from = "__morestack";
4439
*to = "__morestack_non_split";
4442
// The selector for x86_64 object files. Note this is never instantiated
4443
// directly. It's only used in Target_selector_x86_64_nacl, below.
4446
class Target_selector_x86_64 : public Target_selector_freebsd
4449
Target_selector_x86_64()
4450
: Target_selector_freebsd(elfcpp::EM_X86_64, size, false,
4452
? "elf64-x86-64" : "elf32-x86-64"),
4454
? "elf64-x86-64-freebsd"
4455
: "elf32-x86-64-freebsd"),
4456
(size == 64 ? "elf_x86_64" : "elf32_x86_64"))
4460
do_instantiate_target()
4461
{ return new Target_x86_64<size>(); }
4465
// NaCl variant. It uses different PLT contents.
4468
class Output_data_plt_x86_64_nacl : public Output_data_plt_x86_64<size>
4471
Output_data_plt_x86_64_nacl(Layout* layout,
4472
Output_data_got<64, false>* got,
4473
Output_data_space* got_plt,
4474
Output_data_space* got_irelative)
4475
: Output_data_plt_x86_64<size>(layout, plt_entry_size,
4476
got, got_plt, got_irelative)
4479
Output_data_plt_x86_64_nacl(Layout* layout,
4480
Output_data_got<64, false>* got,
4481
Output_data_space* got_plt,
4482
Output_data_space* got_irelative,
4483
unsigned int plt_count)
4484
: Output_data_plt_x86_64<size>(layout, plt_entry_size,
4485
got, got_plt, got_irelative,
4490
virtual unsigned int
4491
do_get_plt_entry_size() const
4492
{ return plt_entry_size; }
4495
do_add_eh_frame(Layout* layout)
4497
layout->add_eh_frame_for_plt(this,
4498
this->plt_eh_frame_cie,
4499
this->plt_eh_frame_cie_size,
4501
plt_eh_frame_fde_size);
4505
do_fill_first_plt_entry(unsigned char* pov,
4506
typename elfcpp::Elf_types<size>::Elf_Addr got_addr,
4507
typename elfcpp::Elf_types<size>::Elf_Addr plt_addr);
4509
virtual unsigned int
4510
do_fill_plt_entry(unsigned char* pov,
4511
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4512
typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4513
unsigned int got_offset,
4514
unsigned int plt_offset,
4515
unsigned int plt_index);
4518
do_fill_tlsdesc_entry(unsigned char* pov,
4519
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4520
typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4521
typename elfcpp::Elf_types<size>::Elf_Addr got_base,
4522
unsigned int tlsdesc_got_offset,
4523
unsigned int plt_offset);
4526
// The size of an entry in the PLT.
4527
static const int plt_entry_size = 64;
4529
// The first entry in the PLT.
4530
static const unsigned char first_plt_entry[plt_entry_size];
4532
// Other entries in the PLT for an executable.
4533
static const unsigned char plt_entry[plt_entry_size];
4535
// The reserved TLSDESC entry in the PLT for an executable.
4536
static const unsigned char tlsdesc_plt_entry[plt_entry_size];
4538
// The .eh_frame unwind information for the PLT.
4539
static const int plt_eh_frame_fde_size = 32;
4540
static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
4544
class Target_x86_64_nacl : public Target_x86_64<size>
4547
Target_x86_64_nacl()
4548
: Target_x86_64<size>(&x86_64_nacl_info)
4551
virtual Output_data_plt_x86_64<size>*
4552
do_make_data_plt(Layout* layout,
4553
Output_data_got<64, false>* got,
4554
Output_data_space* got_plt,
4555
Output_data_space* got_irelative)
4557
return new Output_data_plt_x86_64_nacl<size>(layout, got, got_plt,
4561
virtual Output_data_plt_x86_64<size>*
4562
do_make_data_plt(Layout* layout,
4563
Output_data_got<64, false>* got,
4564
Output_data_space* got_plt,
4565
Output_data_space* got_irelative,
4566
unsigned int plt_count)
4568
return new Output_data_plt_x86_64_nacl<size>(layout, got, got_plt,
4574
static const Target::Target_info x86_64_nacl_info;
4578
const Target::Target_info Target_x86_64_nacl<64>::x86_64_nacl_info =
4581
false, // is_big_endian
4582
elfcpp::EM_X86_64, // machine_code
4583
false, // has_make_symbol
4584
false, // has_resolve
4585
true, // has_code_fill
4586
true, // is_default_stack_executable
4587
true, // can_icf_inline_merge_sections
4589
"/lib64/ld-nacl-x86-64.so.1", // dynamic_linker
4590
0x20000, // default_text_segment_address
4591
0x10000, // abi_pagesize (overridable by -z max-page-size)
4592
0x10000, // common_pagesize (overridable by -z common-page-size)
4593
true, // isolate_execinstr
4594
0x10000000, // rosegment_gap
4595
elfcpp::SHN_UNDEF, // small_common_shndx
4596
elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
4597
0, // small_common_section_flags
4598
elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
4599
NULL, // attributes_section
4600
NULL // attributes_vendor
4604
const Target::Target_info Target_x86_64_nacl<32>::x86_64_nacl_info =
4607
false, // is_big_endian
4608
elfcpp::EM_X86_64, // machine_code
4609
false, // has_make_symbol
4610
false, // has_resolve
4611
true, // has_code_fill
4612
true, // is_default_stack_executable
4613
true, // can_icf_inline_merge_sections
4615
"/lib/ld-nacl-x86-64.so.1", // dynamic_linker
4616
0x20000, // default_text_segment_address
4617
0x10000, // abi_pagesize (overridable by -z max-page-size)
4618
0x10000, // common_pagesize (overridable by -z common-page-size)
4619
true, // isolate_execinstr
4620
0x10000000, // rosegment_gap
4621
elfcpp::SHN_UNDEF, // small_common_shndx
4622
elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
4623
0, // small_common_section_flags
4624
elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
4625
NULL, // attributes_section
4626
NULL // attributes_vendor
4629
#define NACLMASK 0xe0 // 32-byte alignment mask.
4631
// The first entry in the PLT.
4635
Output_data_plt_x86_64_nacl<size>::first_plt_entry[plt_entry_size] =
4637
0xff, 0x35, // pushq contents of memory address
4638
0, 0, 0, 0, // replaced with address of .got + 8
4639
0x4c, 0x8b, 0x1d, // mov GOT+16(%rip), %r11
4640
0, 0, 0, 0, // replaced with address of .got + 16
4641
0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d
4642
0x4d, 0x01, 0xfb, // add %r15, %r11
4643
0x41, 0xff, 0xe3, // jmpq *%r11
4645
// 9-byte nop sequence to pad out to the next 32-byte boundary.
4646
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopl %cs:0x0(%rax,%rax,1)
4648
// 32 bytes of nop to pad out to the standard size
4649
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4650
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4651
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4652
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4653
0x66, // excess data32 prefix
4659
Output_data_plt_x86_64_nacl<size>::do_fill_first_plt_entry(
4661
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4662
typename elfcpp::Elf_types<size>::Elf_Addr plt_address)
4664
memcpy(pov, first_plt_entry, plt_entry_size);
4665
elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4667
- (plt_address + 2 + 4)));
4668
elfcpp::Swap_unaligned<32, false>::writeval(pov + 9,
4670
- (plt_address + 9 + 4)));
4673
// Subsequent entries in the PLT.
4677
Output_data_plt_x86_64_nacl<size>::plt_entry[plt_entry_size] =
4679
0x4c, 0x8b, 0x1d, // mov name@GOTPCREL(%rip),%r11
4680
0, 0, 0, 0, // replaced with address of symbol in .got
4681
0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d
4682
0x4d, 0x01, 0xfb, // add %r15, %r11
4683
0x41, 0xff, 0xe3, // jmpq *%r11
4685
// 15-byte nop sequence to pad out to the next 32-byte boundary.
4686
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4687
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4689
// Lazy GOT entries point here (32-byte aligned).
4690
0x68, // pushq immediate
4691
0, 0, 0, 0, // replaced with index into relocation table
4692
0xe9, // jmp relative
4693
0, 0, 0, 0, // replaced with offset to start of .plt0
4695
// 22 bytes of nop to pad out to the standard size.
4696
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4697
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4698
0x0f, 0x1f, 0x80, 0, 0, 0, 0, // nopl 0x0(%rax)
4703
Output_data_plt_x86_64_nacl<size>::do_fill_plt_entry(
4705
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4706
typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4707
unsigned int got_offset,
4708
unsigned int plt_offset,
4709
unsigned int plt_index)
4711
memcpy(pov, plt_entry, plt_entry_size);
4712
elfcpp::Swap_unaligned<32, false>::writeval(pov + 3,
4713
(got_address + got_offset
4714
- (plt_address + plt_offset
4717
elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_index);
4718
elfcpp::Swap_unaligned<32, false>::writeval(pov + 38,
4719
- (plt_offset + 38 + 4));
4724
// The reserved TLSDESC entry in the PLT.
4728
Output_data_plt_x86_64_nacl<size>::tlsdesc_plt_entry[plt_entry_size] =
4730
0xff, 0x35, // pushq x(%rip)
4731
0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
4732
0x4c, 0x8b, 0x1d, // mov y(%rip),%r11
4733
0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
4734
0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d
4735
0x4d, 0x01, 0xfb, // add %r15, %r11
4736
0x41, 0xff, 0xe3, // jmpq *%r11
4738
// 41 bytes of nop to pad out to the standard size.
4739
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4740
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4741
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4742
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4743
0x66, 0x66, // excess data32 prefixes
4744
0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4749
Output_data_plt_x86_64_nacl<size>::do_fill_tlsdesc_entry(
4751
typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4752
typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4753
typename elfcpp::Elf_types<size>::Elf_Addr got_base,
4754
unsigned int tlsdesc_got_offset,
4755
unsigned int plt_offset)
4757
memcpy(pov, tlsdesc_plt_entry, plt_entry_size);
4758
elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4760
- (plt_address + plt_offset
4762
elfcpp::Swap_unaligned<32, false>::writeval(pov + 9,
4764
+ tlsdesc_got_offset
4765
- (plt_address + plt_offset
4769
// The .eh_frame unwind information for the PLT.
4773
Output_data_plt_x86_64_nacl<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] =
4775
0, 0, 0, 0, // Replaced with offset to .plt.
4776
0, 0, 0, 0, // Replaced with size of .plt.
4777
0, // Augmentation size.
4778
elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16.
4779
elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
4780
elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24.
4781
elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64.
4782
elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
4783
13, // Block length.
4784
elfcpp::DW_OP_breg7, 8, // Push %rsp + 8.
4785
elfcpp::DW_OP_breg16, 0, // Push %rip.
4786
elfcpp::DW_OP_const1u, 63, // Push 0x3f.
4787
elfcpp::DW_OP_and, // & (%rip & 0x3f).
4788
elfcpp::DW_OP_const1u, 37, // Push 0x25.
4789
elfcpp::DW_OP_ge, // >= ((%rip & 0x3f) >= 0x25)
4790
elfcpp::DW_OP_lit3, // Push 3.
4791
elfcpp::DW_OP_shl, // << (((%rip & 0x3f) >= 0x25) << 3)
4792
elfcpp::DW_OP_plus, // + ((((%rip&0x3f)>=0x25)<<3)+%rsp+8
4793
elfcpp::DW_CFA_nop, // Align to 32 bytes.
4797
// The selector for x86_64-nacl object files.
4800
class Target_selector_x86_64_nacl
4801
: public Target_selector_nacl<Target_selector_x86_64<size>,
4802
Target_x86_64_nacl<size> >
4805
Target_selector_x86_64_nacl()
4806
: Target_selector_nacl<Target_selector_x86_64<size>,
4807
Target_x86_64_nacl<size> >("x86-64",
4809
? "elf64-x86-64-nacl"
4810
: "elf32-x86-64-nacl",
4813
: "elf32_x86_64_nacl")
4817
Target_selector_x86_64_nacl<64> target_selector_x86_64;
4818
Target_selector_x86_64_nacl<32> target_selector_x32;
4820
} // End anonymous namespace.
added
removed
binutils-2.23.52.20130611/gold/x86_64.cc
