projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Support 64-bit entry size in SHT_HASH (for s390).
[deliverable/binutils-gdb.git] / gold / x86_64.cc
CommitLineData
2e30d253
ILT		 1// x86_64.cc -- x86_64 target support for gold.
2
b90efa5b 3// Copyright (C) 2006-2015 Free Software Foundation, Inc.
2e30d253
ILT		 4// Written by Ian Lance Taylor <iant@google.com>.
5
6// This file is part of gold.
7
8b105e34
ILT		 8// This program is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 3 of the License, or
2e30d253
ILT		 11// (at your option) any later version.
12
8b105e34
ILT		 13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21// MA 02110-1301, USA.
2e30d253
ILT		 22
23#include "gold.h"
24
25#include <cstring>
26
27#include "elfcpp.h"
07a60597 28#include "dwarf.h"
2e30d253
ILT		 29#include "parameters.h"
30#include "reloc.h"
31#include "x86_64.h"
32#include "object.h"
33#include "symtab.h"
34#include "layout.h"
35#include "output.h"
12c0daef 36#include "copy-relocs.h"
2e30d253
ILT		 37#include "target.h"
38#include "target-reloc.h"
39#include "target-select.h"
e041f13d 40#include "tls.h"
36959681 41#include "freebsd.h"
2e702c99 42#include "nacl.h"
f345227a 43#include "gc.h"
21bb3914 44#include "icf.h"
2e30d253
ILT		 45
46namespace
47{
48
49using namespace gold;
50
57b2284c
CC		 51// A class to handle the .got.plt section.
52
53class Output_data_got_plt_x86_64 : public Output_section_data_build
54{
55 public:
56 Output_data_got_plt_x86_64(Layout* layout)
57 : Output_section_data_build(8),
58 layout_(layout)
59 { }
60
61 Output_data_got_plt_x86_64(Layout* layout, off_t data_size)
62 : Output_section_data_build(data_size, 8),
63 layout_(layout)
64 { }
65
66 protected:
67 // Write out the PLT data.
68 void
69 do_write(Output_file*);
70
71 // Write to a map file.
72 void
73 do_print_to_mapfile(Mapfile* mapfile) const
74 { mapfile->print_output_data(this, "** GOT PLT"); }
75
76 private:
77 // A pointer to the Layout class, so that we can find the .dynamic
78 // section when we write out the GOT PLT section.
79 Layout* layout_;
80};
81
7223e9ca 82// A class to handle the PLT data.
2e702c99
RM		 83// This is an abstract base class that handles most of the linker details
84// but does not know the actual contents of PLT entries. The derived
85// classes below fill in those details.
7223e9ca 86
fc51264f 87template<int size>
7223e9ca
ILT		 88class Output_data_plt_x86_64 : public Output_section_data
89{
90 public:
fc51264f 91 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, false> Reloc_section;
7223e9ca 92
2e702c99
RM		 93 Output_data_plt_x86_64(Layout* layout, uint64_t addralign,
94 Output_data_got<64, false>* got,
57b2284c 95 Output_data_got_plt_x86_64* got_plt,
67181c72 96 Output_data_space* got_irelative)
57b2284c 97 : Output_section_data(addralign), tlsdesc_rel_(NULL),
7d172687
ILT		 98 irelative_rel_(NULL), got_(got), got_plt_(got_plt),
99 got_irelative_(got_irelative), count_(0), irelative_count_(0),
100 tlsdesc_got_offset_(-1U), free_list_()
67181c72
ILT		 101 { this->init(layout); }
102
2e702c99
RM		 103 Output_data_plt_x86_64(Layout* layout, uint64_t plt_entry_size,
104 Output_data_got<64, false>* got,
57b2284c 105 Output_data_got_plt_x86_64* got_plt,
67181c72 106 Output_data_space* got_irelative,
4829d394 107 unsigned int plt_count)
2e702c99
RM		 108 : Output_section_data((plt_count + 1) * plt_entry_size,
109 plt_entry_size, false),
57b2284c 110 tlsdesc_rel_(NULL), irelative_rel_(NULL), got_(got),
7d172687
ILT		 111 got_plt_(got_plt), got_irelative_(got_irelative), count_(plt_count),
112 irelative_count_(0), tlsdesc_got_offset_(-1U), free_list_()
4829d394 113 {
67181c72 114 this->init(layout);
4829d394
CC		 115
116 // Initialize the free list and reserve the first entry.
117 this->free_list_.init((plt_count + 1) * plt_entry_size, false);
118 this->free_list_.remove(0, plt_entry_size);
119 }
120
121 // Initialize the PLT section.
122 void
67181c72 123 init(Layout* layout);
7223e9ca
ILT		 124
125 // Add an entry to the PLT.
126 void
67181c72 127 add_entry(Symbol_table*, Layout*, Symbol* gsym);
7223e9ca
ILT		 128
129 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
130 unsigned int
67181c72 131 add_local_ifunc_entry(Symbol_table* symtab, Layout*,
fc51264f 132 Sized_relobj_file<size, false>* relobj,
7223e9ca
ILT		 133 unsigned int local_sym_index);
134
4829d394
CC		 135 // Add the relocation for a PLT entry.
136 void
67181c72
ILT		 137 add_relocation(Symbol_table*, Layout*, Symbol* gsym,
138 unsigned int got_offset);
4829d394 139
7223e9ca
ILT		 140 // Add the reserved TLSDESC_PLT entry to the PLT.
141 void
142 reserve_tlsdesc_entry(unsigned int got_offset)
143 { this->tlsdesc_got_offset_ = got_offset; }
144
145 // Return true if a TLSDESC_PLT entry has been reserved.
146 bool
147 has_tlsdesc_entry() const
148 { return this->tlsdesc_got_offset_ != -1U; }
149
150 // Return the GOT offset for the reserved TLSDESC_PLT entry.
151 unsigned int
152 get_tlsdesc_got_offset() const
153 { return this->tlsdesc_got_offset_; }
154
155 // Return the offset of the reserved TLSDESC_PLT entry.
156 unsigned int
157 get_tlsdesc_plt_offset() const
2e702c99
RM		 158 {
159 return ((this->count_ + this->irelative_count_ + 1)
160 * this->get_plt_entry_size());
161 }
7223e9ca
ILT		 162
163 // Return the .rela.plt section data.
164 Reloc_section*
165 rela_plt()
166 { return this->rel_; }
167
168 // Return where the TLSDESC relocations should go.
169 Reloc_section*
170 rela_tlsdesc(Layout*);
171
67181c72
ILT		 172 // Return where the IRELATIVE relocations should go in the PLT
173 // relocations.
174 Reloc_section*
175 rela_irelative(Symbol_table*, Layout*);
176
177 // Return whether we created a section for IRELATIVE relocations.
178 bool
179 has_irelative_section() const
180 { return this->irelative_rel_ != NULL; }
181
7223e9ca
ILT		 182 // Return the number of PLT entries.
183 unsigned int
184 entry_count() const
67181c72 185 { return this->count_ + this->irelative_count_; }
7223e9ca
ILT		 186
187 // Return the offset of the first non-reserved PLT entry.
2e702c99 188 unsigned int
7223e9ca 189 first_plt_entry_offset()
2e702c99 190 { return this->get_plt_entry_size(); }
7223e9ca
ILT		 191
192 // Return the size of a PLT entry.
2e702c99
RM		 193 unsigned int
194 get_plt_entry_size() const
195 { return this->do_get_plt_entry_size(); }
7223e9ca 196
4829d394
CC		 197 // Reserve a slot in the PLT for an existing symbol in an incremental update.
198 void
199 reserve_slot(unsigned int plt_index)
200 {
2e702c99
RM		 201 this->free_list_.remove((plt_index + 1) * this->get_plt_entry_size(),
202 (plt_index + 2) * this->get_plt_entry_size());
4829d394
CC		 203 }
204
67181c72
ILT		 205 // Return the PLT address to use for a global symbol.
206 uint64_t
207 address_for_global(const Symbol*);
208
209 // Return the PLT address to use for a local symbol.
210 uint64_t
211 address_for_local(const Relobj*, unsigned int symndx);
212
2e702c99
RM		 213 // Add .eh_frame information for the PLT.
214 void
215 add_eh_frame(Layout* layout)
216 { this->do_add_eh_frame(layout); }
217
7223e9ca 218 protected:
2e702c99
RM		 219 // Fill in the first PLT entry.
220 void
221 fill_first_plt_entry(unsigned char* pov,
222 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
223 typename elfcpp::Elf_types<size>::Elf_Addr plt_address)
224 { this->do_fill_first_plt_entry(pov, got_address, plt_address); }
225
226 // Fill in a normal PLT entry. Returns the offset into the entry that
227 // should be the initial GOT slot value.
228 unsigned int
229 fill_plt_entry(unsigned char* pov,
230 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
231 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
232 unsigned int got_offset,
233 unsigned int plt_offset,
234 unsigned int plt_index)
235 {
236 return this->do_fill_plt_entry(pov, got_address, plt_address,
237 got_offset, plt_offset, plt_index);
238 }
239
240 // Fill in the reserved TLSDESC PLT entry.
241 void
242 fill_tlsdesc_entry(unsigned char* pov,
243 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
244 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
245 typename elfcpp::Elf_types<size>::Elf_Addr got_base,
246 unsigned int tlsdesc_got_offset,
247 unsigned int plt_offset)
248 {
249 this->do_fill_tlsdesc_entry(pov, got_address, plt_address, got_base,
250 tlsdesc_got_offset, plt_offset);
251 }
252
253 virtual unsigned int
254 do_get_plt_entry_size() const = 0;
255
256 virtual void
257 do_fill_first_plt_entry(unsigned char* pov,
258 typename elfcpp::Elf_types<size>::Elf_Addr got_addr,
259 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr)
260 = 0;
261
262 virtual unsigned int
263 do_fill_plt_entry(unsigned char* pov,
264 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
265 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
266 unsigned int got_offset,
267 unsigned int plt_offset,
268 unsigned int plt_index) = 0;
269
270 virtual void
271 do_fill_tlsdesc_entry(unsigned char* pov,
272 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
273 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
274 typename elfcpp::Elf_types<size>::Elf_Addr got_base,
275 unsigned int tlsdesc_got_offset,
276 unsigned int plt_offset) = 0;
277
278 virtual void
279 do_add_eh_frame(Layout* layout) = 0;
280
7223e9ca
ILT		 281 void
282 do_adjust_output_section(Output_section* os);
283
284 // Write to a map file.
285 void
286 do_print_to_mapfile(Mapfile* mapfile) const
287 { mapfile->print_output_data(this, _("** PLT")); }
288
2e702c99 289 // The CIE of the .eh_frame unwind information for the PLT.
07a60597 290 static const int plt_eh_frame_cie_size = 16;
07a60597 291 static const unsigned char plt_eh_frame_cie[plt_eh_frame_cie_size];
7223e9ca 292
2e702c99 293 private:
7223e9ca
ILT		 294 // Set the final size.
295 void
296 set_final_data_size();
297
298 // Write out the PLT data.
299 void
300 do_write(Output_file*);
301
302 // The reloc section.
303 Reloc_section* rel_;
304 // The TLSDESC relocs, if necessary. These must follow the regular
305 // PLT relocs.
306 Reloc_section* tlsdesc_rel_;
67181c72
ILT		 307 // The IRELATIVE relocs, if necessary. These must follow the
308 // regular PLT relocations and the TLSDESC relocations.
309 Reloc_section* irelative_rel_;
7223e9ca
ILT		 310 // The .got section.
311 Output_data_got<64, false>* got_;
312 // The .got.plt section.
57b2284c 313 Output_data_got_plt_x86_64* got_plt_;
67181c72
ILT		 314 // The part of the .got.plt section used for IRELATIVE relocs.
315 Output_data_space* got_irelative_;
7223e9ca
ILT		 316 // The number of PLT entries.
317 unsigned int count_;
67181c72
ILT		 318 // Number of PLT entries with R_X86_64_IRELATIVE relocs. These
319 // follow the regular PLT entries.
320 unsigned int irelative_count_;
7223e9ca
ILT		 321 // Offset of the reserved TLSDESC_GOT entry when needed.
322 unsigned int tlsdesc_got_offset_;
4829d394
CC		 323 // List of available regions within the section, for incremental
324 // update links.
325 Free_list free_list_;
7223e9ca 326};
2e30d253 327
2e702c99
RM		 328template<int size>
329class Output_data_plt_x86_64_standard : public Output_data_plt_x86_64<size>
330{
331 public:
332 Output_data_plt_x86_64_standard(Layout* layout,
333 Output_data_got<64, false>* got,
57b2284c 334 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 335 Output_data_space* got_irelative)
336 : Output_data_plt_x86_64<size>(layout, plt_entry_size,
337 got, got_plt, got_irelative)
338 { }
339
340 Output_data_plt_x86_64_standard(Layout* layout,
341 Output_data_got<64, false>* got,
57b2284c 342 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 343 Output_data_space* got_irelative,
344 unsigned int plt_count)
345 : Output_data_plt_x86_64<size>(layout, plt_entry_size,
346 got, got_plt, got_irelative,
347 plt_count)
348 { }
349
350 protected:
351 virtual unsigned int
352 do_get_plt_entry_size() const
353 { return plt_entry_size; }
354
355 virtual void
356 do_add_eh_frame(Layout* layout)
357 {
358 layout->add_eh_frame_for_plt(this,
359 this->plt_eh_frame_cie,
360 this->plt_eh_frame_cie_size,
361 plt_eh_frame_fde,
362 plt_eh_frame_fde_size);
363 }
364
365 virtual void
366 do_fill_first_plt_entry(unsigned char* pov,
367 typename elfcpp::Elf_types<size>::Elf_Addr got_addr,
368 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr);
369
370 virtual unsigned int
371 do_fill_plt_entry(unsigned char* pov,
372 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
373 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
374 unsigned int got_offset,
375 unsigned int plt_offset,
376 unsigned int plt_index);
377
378 virtual void
379 do_fill_tlsdesc_entry(unsigned char* pov,
380 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
381 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
382 typename elfcpp::Elf_types<size>::Elf_Addr got_base,
383 unsigned int tlsdesc_got_offset,
384 unsigned int plt_offset);
385
386 private:
387 // The size of an entry in the PLT.
388 static const int plt_entry_size = 16;
389
390 // The first entry in the PLT.
391 // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same
392 // procedure linkage table for both programs and shared objects."
393 static const unsigned char first_plt_entry[plt_entry_size];
394
395 // Other entries in the PLT for an executable.
396 static const unsigned char plt_entry[plt_entry_size];
397
398 // The reserved TLSDESC entry in the PLT for an executable.
399 static const unsigned char tlsdesc_plt_entry[plt_entry_size];
400
401 // The .eh_frame unwind information for the PLT.
402 static const int plt_eh_frame_fde_size = 32;
403 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
404};
405
2e30d253 406// The x86_64 target class.
d61c17ea
ILT		 407// See the ABI at
408// http://www.x86-64.org/documentation/abi.pdf
409// TLS info comes from
410// http://people.redhat.com/drepper/tls.pdf
0ffd9845 411// http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt
2e30d253 412
fc51264f
L		 413template<int size>
414class Target_x86_64 : public Sized_target<size, false>
2e30d253
ILT		 415{
416 public:
e822f2b1
ILT		 417 // In the x86_64 ABI (p 68), it says "The AMD64 ABI architectures
418 // uses only Elf64_Rela relocation entries with explicit addends."
fc51264f 419 typedef Output_data_reloc<elfcpp::SHT_RELA, true, size, false> Reloc_section;
2e30d253 420
2e702c99
RM		 421 Target_x86_64(const Target::Target_info* info = &x86_64_info)
422 : Sized_target<size, false>(info),
67181c72
ILT		 423 got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL),
424 got_tlsdesc_(NULL), global_offset_table_(NULL), rela_dyn_(NULL),
425 rela_irelative_(NULL), copy_relocs_(elfcpp::R_X86_64_COPY),
43819297 426 got_mod_index_offset_(-1U), tlsdesc_reloc_info_(),
e291e7b9 427 tls_base_symbol_defined_(false)
2e30d253
ILT		 428 { }
429
8a5e3e08
ILT		 430 // Hook for a new output section.
431 void
432 do_new_output_section(Output_section*) const;
433
6d03d481
ST		 434 // Scan the relocations to look for symbol adjustments.
435 void
ad0f2072 436 gc_process_relocs(Symbol_table* symtab,
2e702c99
RM		 437 Layout* layout,
438 Sized_relobj_file<size, false>* object,
439 unsigned int data_shndx,
440 unsigned int sh_type,
441 const unsigned char* prelocs,
442 size_t reloc_count,
443 Output_section* output_section,
444 bool needs_special_offset_handling,
445 size_t local_symbol_count,
446 const unsigned char* plocal_symbols);
6d03d481 447
2e30d253
ILT		 448 // Scan the relocations to look for symbol adjustments.
449 void
ad0f2072 450 scan_relocs(Symbol_table* symtab,
2e30d253 451 Layout* layout,
fc51264f 452 Sized_relobj_file<size, false>* object,
2e30d253
ILT		 453 unsigned int data_shndx,
454 unsigned int sh_type,
455 const unsigned char* prelocs,
456 size_t reloc_count,
730cdc88
ILT		 457 Output_section* output_section,
458 bool needs_special_offset_handling,
2e30d253 459 size_t local_symbol_count,
730cdc88 460 const unsigned char* plocal_symbols);
2e30d253
ILT		 461
462 // Finalize the sections.
463 void
f59f41f3 464 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
2e30d253 465
4fb6c25d
ILT		 466 // Return the value to use for a dynamic which requires special
467 // treatment.
468 uint64_t
469 do_dynsym_value(const Symbol*) const;
470
2e30d253
ILT		 471 // Relocate a section.
472 void
fc51264f 473 relocate_section(const Relocate_info<size, false>*,
2e30d253
ILT		 474 unsigned int sh_type,
475 const unsigned char* prelocs,
476 size_t reloc_count,
730cdc88
ILT		 477 Output_section* output_section,
478 bool needs_special_offset_handling,
2e30d253 479 unsigned char* view,
fc51264f 480 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
364c7fa5
ILT		 481 section_size_type view_size,
482 const Reloc_symbol_changes*);
2e30d253 483
6a74a719
ILT		 484 // Scan the relocs during a relocatable link.
485 void
ad0f2072 486 scan_relocatable_relocs(Symbol_table* symtab,
6a74a719 487 Layout* layout,
fc51264f 488 Sized_relobj_file<size, false>* object,
6a74a719
ILT		 489 unsigned int data_shndx,
490 unsigned int sh_type,
491 const unsigned char* prelocs,
492 size_t reloc_count,
493 Output_section* output_section,
494 bool needs_special_offset_handling,
495 size_t local_symbol_count,
496 const unsigned char* plocal_symbols,
497 Relocatable_relocs*);
498
7404fe1b 499 // Emit relocations for a section.
6a74a719 500 void
7404fe1b 501 relocate_relocs(
fc51264f
L		 502 const Relocate_info<size, false>*,
503 unsigned int sh_type,
504 const unsigned char* prelocs,
505 size_t reloc_count,
506 Output_section* output_section,
62fe925a 507 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
fc51264f
L		 508 const Relocatable_relocs*,
509 unsigned char* view,
510 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
511 section_size_type view_size,
512 unsigned char* reloc_view,
513 section_size_type reloc_view_size);
6a74a719 514
2e30d253
ILT		 515 // Return a string used to fill a code section with nops.
516 std::string
8851ecca 517 do_code_fill(section_size_type length) const;
2e30d253 518
9a2d6984
ILT		 519 // Return whether SYM is defined by the ABI.
520 bool
9c2d0ef9 521 do_is_defined_by_abi(const Symbol* sym) const
9a2d6984
ILT		 522 { return strcmp(sym->name(), "__tls_get_addr") == 0; }
523
e291e7b9
ILT		 524 // Return the symbol index to use for a target specific relocation.
525 // The only target specific relocation is R_X86_64_TLSDESC for a
526 // local symbol, which is an absolute reloc.
527 unsigned int
528 do_reloc_symbol_index(void*, unsigned int r_type) const
529 {
530 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
531 return 0;
532 }
533
534 // Return the addend to use for a target specific relocation.
535 uint64_t
536 do_reloc_addend(void* arg, unsigned int r_type, uint64_t addend) const;
537
7223e9ca 538 // Return the PLT section.
67181c72
ILT		 539 uint64_t
540 do_plt_address_for_global(const Symbol* gsym) const
541 { return this->plt_section()->address_for_global(gsym); }
7223e9ca 542
67181c72
ILT		 543 uint64_t
544 do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const
545 { return this->plt_section()->address_for_local(relobj, symndx); }
7223e9ca 546
b3ce541e
ILT		 547 // This function should be defined in targets that can use relocation
548 // types to determine (implemented in local_reloc_may_be_function_pointer
549 // and global_reloc_may_be_function_pointer)
550 // if a function's pointer is taken. ICF uses this in safe mode to only
551 // fold those functions whose pointer is defintely not taken. For x86_64
552 // pie binaries, safe ICF cannot be done by looking at relocation types.
553 bool
554 do_can_check_for_function_pointers() const
555 { return !parameters->options().pie(); }
556
02d7cd44
ILT		 557 // Return the base for a DW_EH_PE_datarel encoding.
558 uint64_t
559 do_ehframe_datarel_base() const;
560
9b547ce6 561 // Adjust -fsplit-stack code which calls non-split-stack code.
364c7fa5
ILT		 562 void
563 do_calls_non_split(Relobj* object, unsigned int shndx,
564 section_offset_type fnoffset, section_size_type fnsize,
565 unsigned char* view, section_size_type view_size,
566 std::string* from, std::string* to) const;
567
96f2030e 568 // Return the size of the GOT section.
fe8718a4 569 section_size_type
0e70b911 570 got_size() const
96f2030e
ILT		 571 {
572 gold_assert(this->got_ != NULL);
573 return this->got_->data_size();
574 }
575
0e70b911
CC		 576 // Return the number of entries in the GOT.
577 unsigned int
578 got_entry_count() const
579 {
580 if (this->got_ == NULL)
581 return 0;
582 return this->got_size() / 8;
583 }
584
585 // Return the number of entries in the PLT.
586 unsigned int
587 plt_entry_count() const;
588
589 // Return the offset of the first non-reserved PLT entry.
590 unsigned int
591 first_plt_entry_offset() const;
592
593 // Return the size of each PLT entry.
594 unsigned int
595 plt_entry_size() const;
596
4829d394 597 // Create the GOT section for an incremental update.
dd74ae06 598 Output_data_got_base*
4829d394
CC		 599 init_got_plt_for_update(Symbol_table* symtab,
600 Layout* layout,
601 unsigned int got_count,
602 unsigned int plt_count);
603
6fa2a40b
CC		 604 // Reserve a GOT entry for a local symbol, and regenerate any
605 // necessary dynamic relocations.
606 void
607 reserve_local_got_entry(unsigned int got_index,
2e702c99 608 Sized_relobj<size, false>* obj,
6fa2a40b
CC		 609 unsigned int r_sym,
610 unsigned int got_type);
611
612 // Reserve a GOT entry for a global symbol, and regenerate any
613 // necessary dynamic relocations.
614 void
615 reserve_global_got_entry(unsigned int got_index, Symbol* gsym,
616 unsigned int got_type);
617
4829d394 618 // Register an existing PLT entry for a global symbol.
4829d394 619 void
67181c72
ILT		 620 register_global_plt_entry(Symbol_table*, Layout*, unsigned int plt_index,
621 Symbol* gsym);
4829d394 622
26d3c67d
CC		 623 // Force a COPY relocation for a given symbol.
624 void
625 emit_copy_reloc(Symbol_table*, Symbol*, Output_section*, off_t);
626
94a3fc8b
CC		 627 // Apply an incremental relocation.
628 void
fc51264f
L		 629 apply_relocation(const Relocate_info<size, false>* relinfo,
630 typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
94a3fc8b 631 unsigned int r_type,
fc51264f 632 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend,
94a3fc8b
CC		 633 const Symbol* gsym,
634 unsigned char* view,
fc51264f 635 typename elfcpp::Elf_types<size>::Elf_Addr address,
94a3fc8b
CC		 636 section_size_type view_size);
637
e291e7b9
ILT		 638 // Add a new reloc argument, returning the index in the vector.
639 size_t
fc51264f 640 add_tlsdesc_info(Sized_relobj_file<size, false>* object, unsigned int r_sym)
e291e7b9
ILT		 641 {
642 this->tlsdesc_reloc_info_.push_back(Tlsdesc_info(object, r_sym));
643 return this->tlsdesc_reloc_info_.size() - 1;
644 }
645
2e702c99
RM		 646 Output_data_plt_x86_64<size>*
647 make_data_plt(Layout* layout,
648 Output_data_got<64, false>* got,
57b2284c 649 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 650 Output_data_space* got_irelative)
651 {
652 return this->do_make_data_plt(layout, got, got_plt, got_irelative);
653 }
654
655 Output_data_plt_x86_64<size>*
656 make_data_plt(Layout* layout,
657 Output_data_got<64, false>* got,
57b2284c 658 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 659 Output_data_space* got_irelative,
660 unsigned int plt_count)
661 {
662 return this->do_make_data_plt(layout, got, got_plt, got_irelative,
663 plt_count);
664 }
665
666 virtual Output_data_plt_x86_64<size>*
667 do_make_data_plt(Layout* layout,
668 Output_data_got<64, false>* got,
57b2284c 669 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 670 Output_data_space* got_irelative)
671 {
672 return new Output_data_plt_x86_64_standard<size>(layout, got, got_plt,
673 got_irelative);
674 }
675
676 virtual Output_data_plt_x86_64<size>*
677 do_make_data_plt(Layout* layout,
678 Output_data_got<64, false>* got,
57b2284c 679 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 680 Output_data_space* got_irelative,
681 unsigned int plt_count)
682 {
683 return new Output_data_plt_x86_64_standard<size>(layout, got, got_plt,
684 got_irelative,
685 plt_count);
686 }
687
2e30d253
ILT		 688 private:
689 // The class which scans relocations.
a036edd8 690 class Scan
2e30d253 691 {
a036edd8
ILT		 692 public:
693 Scan()
694 : issued_non_pic_error_(false)
695 { }
696
95a2c8d6
RS		 697 static inline int
698 get_reference_flags(unsigned int r_type);
699
2e30d253 700 inline void
ad0f2072 701 local(Symbol_table* symtab, Layout* layout, Target_x86_64* target,
fc51264f 702 Sized_relobj_file<size, false>* object,
2e30d253 703 unsigned int data_shndx,
07f397ab 704 Output_section* output_section,
fc51264f 705 const elfcpp::Rela<size, false>& reloc, unsigned int r_type,
bfdfa4cd
AM		 706 const elfcpp::Sym<size, false>& lsym,
707 bool is_discarded);
2e30d253
ILT		 708
709 inline void
ad0f2072 710 global(Symbol_table* symtab, Layout* layout, Target_x86_64* target,
fc51264f 711 Sized_relobj_file<size, false>* object,
2e30d253 712 unsigned int data_shndx,
07f397ab 713 Output_section* output_section,
fc51264f 714 const elfcpp::Rela<size, false>& reloc, unsigned int r_type,
2e30d253 715 Symbol* gsym);
e041f13d 716
21bb3914
ST		 717 inline bool
718 local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
719 Target_x86_64* target,
2e702c99
RM		 720 Sized_relobj_file<size, false>* object,
721 unsigned int data_shndx,
722 Output_section* output_section,
723 const elfcpp::Rela<size, false>& reloc,
21bb3914 724 unsigned int r_type,
2e702c99 725 const elfcpp::Sym<size, false>& lsym);
21bb3914
ST		 726
727 inline bool
728 global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
2e702c99
RM		 729 Target_x86_64* target,
730 Sized_relobj_file<size, false>* object,
731 unsigned int data_shndx,
732 Output_section* output_section,
733 const elfcpp::Rela<size, false>& reloc,
21bb3914 734 unsigned int r_type,
2e702c99 735 Symbol* gsym);
21bb3914 736
a036edd8 737 private:
e041f13d 738 static void
fc51264f
L		 739 unsupported_reloc_local(Sized_relobj_file<size, false>*,
740 unsigned int r_type);
e041f13d
ILT		 741
742 static void
fc51264f
L		 743 unsupported_reloc_global(Sized_relobj_file<size, false>*,
744 unsigned int r_type, Symbol*);
a036edd8
ILT		 745
746 void
a29b0dad 747 check_non_pic(Relobj*, unsigned int r_type, Symbol*);
a036edd8 748
21bb3914
ST		 749 inline bool
750 possible_function_pointer_reloc(unsigned int r_type);
751
7223e9ca 752 bool
fc51264f 753 reloc_needs_plt_for_ifunc(Sized_relobj_file<size, false>*,
6fa2a40b 754 unsigned int r_type);
7223e9ca 755
a036edd8
ILT		 756 // Whether we have issued an error about a non-PIC compilation.
757 bool issued_non_pic_error_;
2e30d253
ILT		 758 };
759
760 // The class which implements relocation.
761 class Relocate
762 {
763 public:
764 Relocate()
36171d64 765 : skip_call_tls_get_addr_(false)
2e30d253
ILT		 766 { }
767
768 ~Relocate()
769 {
770 if (this->skip_call_tls_get_addr_)
771 {
772 // FIXME: This needs to specify the location somehow.
a0c4fb0a 773 gold_error(_("missing expected TLS relocation"));
2e30d253
ILT		 774 }
775 }
776
777 // Do a relocation. Return false if the caller should not issue
778 // any warnings about this relocation.
779 inline bool
fc51264f
L		 780 relocate(const Relocate_info<size, false>*, Target_x86_64*,
781 Output_section*,
782 size_t relnum, const elfcpp::Rela<size, false>&,
783 unsigned int r_type, const Sized_symbol<size>*,
784 const Symbol_value<size>*,
785 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr,
fe8718a4 786 section_size_type);
2e30d253
ILT		 787
788 private:
789 // Do a TLS relocation.
790 inline void
fc51264f 791 relocate_tls(const Relocate_info<size, false>*, Target_x86_64*,
2e702c99 792 size_t relnum, const elfcpp::Rela<size, false>&,
fc51264f
L		 793 unsigned int r_type, const Sized_symbol<size>*,
794 const Symbol_value<size>*,
795 unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr,
fe8718a4 796 section_size_type);
2e30d253 797
c2b45e22 798 // Do a TLS General-Dynamic to Initial-Exec transition.
7bf1f802 799 inline void
fc51264f 800 tls_gd_to_ie(const Relocate_info<size, false>*, size_t relnum,
7bf1f802 801 Output_segment* tls_segment,
fc51264f
L		 802 const elfcpp::Rela<size, false>&, unsigned int r_type,
803 typename elfcpp::Elf_types<size>::Elf_Addr value,
7bf1f802 804 unsigned char* view,
fc51264f 805 typename elfcpp::Elf_types<size>::Elf_Addr,
fe8718a4 806 section_size_type view_size);
7bf1f802 807
56622147
ILT		 808 // Do a TLS General-Dynamic to Local-Exec transition.
809 inline void
fc51264f 810 tls_gd_to_le(const Relocate_info<size, false>*, size_t relnum,
2e30d253 811 Output_segment* tls_segment,
fc51264f
L		 812 const elfcpp::Rela<size, false>&, unsigned int r_type,
813 typename elfcpp::Elf_types<size>::Elf_Addr value,
2e30d253 814 unsigned char* view,
fe8718a4 815 section_size_type view_size);
2e30d253 816
c2b45e22
CC		 817 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
818 inline void
fc51264f 819 tls_desc_gd_to_ie(const Relocate_info<size, false>*, size_t relnum,
c2b45e22 820 Output_segment* tls_segment,
fc51264f
L		 821 const elfcpp::Rela<size, false>&, unsigned int r_type,
822 typename elfcpp::Elf_types<size>::Elf_Addr value,
c2b45e22 823 unsigned char* view,
fc51264f 824 typename elfcpp::Elf_types<size>::Elf_Addr,
c2b45e22
CC		 825 section_size_type view_size);
826
827 // Do a TLSDESC-style General-Dynamic to Local-Exec transition.
828 inline void
fc51264f 829 tls_desc_gd_to_le(const Relocate_info<size, false>*, size_t relnum,
c2b45e22 830 Output_segment* tls_segment,
fc51264f
L		 831 const elfcpp::Rela<size, false>&, unsigned int r_type,
832 typename elfcpp::Elf_types<size>::Elf_Addr value,
c2b45e22
CC		 833 unsigned char* view,
834 section_size_type view_size);
835
56622147 836 // Do a TLS Local-Dynamic to Local-Exec transition.
2e30d253 837 inline void
fc51264f 838 tls_ld_to_le(const Relocate_info<size, false>*, size_t relnum,
2e30d253 839 Output_segment* tls_segment,
fc51264f
L		 840 const elfcpp::Rela<size, false>&, unsigned int r_type,
841 typename elfcpp::Elf_types<size>::Elf_Addr value,
2e30d253 842 unsigned char* view,
fe8718a4 843 section_size_type view_size);
2e30d253 844
56622147
ILT		 845 // Do a TLS Initial-Exec to Local-Exec transition.
846 static inline void
fc51264f 847 tls_ie_to_le(const Relocate_info<size, false>*, size_t relnum,
72ec2876 848 Output_segment* tls_segment,
fc51264f
L		 849 const elfcpp::Rela<size, false>&, unsigned int r_type,
850 typename elfcpp::Elf_types<size>::Elf_Addr value,
72ec2876 851 unsigned char* view,
fe8718a4 852 section_size_type view_size);
2e30d253
ILT		 853
854 // This is set if we should skip the next reloc, which should be a
855 // PLT32 reloc against ___tls_get_addr.
856 bool skip_call_tls_get_addr_;
857 };
858
6a74a719
ILT		 859 // A class which returns the size required for a relocation type,
860 // used while scanning relocs during a relocatable link.
861 class Relocatable_size_for_reloc
862 {
863 public:
864 unsigned int
865 get_size_for_reloc(unsigned int, Relobj*);
866 };
867
1fa29f10
IT		 868 // Check if relocation against this symbol is a candidate for
869 // conversion from
870 // mov foo@GOTPCREL(%rip), %reg
871 // to lea foo(%rip), %reg.
872 static bool
873 can_convert_mov_to_lea(const Symbol* gsym)
874 {
875 gold_assert(gsym != NULL);
876 return (gsym->type() != elfcpp::STT_GNU_IFUNC
877 && !gsym->is_undefined ()
878 && !gsym->is_from_dynobj()
879 && !gsym->is_preemptible()
880 && (!parameters->options().shared()
881 || (gsym->visibility() != elfcpp::STV_DEFAULT
882 && gsym->visibility() != elfcpp::STV_PROTECTED)
883 || parameters->options().Bsymbolic())
884 && strcmp(gsym->name(), "_DYNAMIC") != 0);
885 }
886
2e30d253
ILT		 887 // Adjust TLS relocation type based on the options and whether this
888 // is a local symbol.
e041f13d 889 static tls::Tls_optimization
2e30d253
ILT		 890 optimize_tls_reloc(bool is_final, int r_type);
891
892 // Get the GOT section, creating it if necessary.
893 Output_data_got<64, false>*
894 got_section(Symbol_table*, Layout*);
895
96f2030e 896 // Get the GOT PLT section.
57b2284c 897 Output_data_got_plt_x86_64*
96f2030e
ILT		 898 got_plt_section() const
899 {
900 gold_assert(this->got_plt_ != NULL);
901 return this->got_plt_;
902 }
903
a8df5856
ILT		 904 // Get the GOT section for TLSDESC entries.
905 Output_data_got<64, false>*
906 got_tlsdesc_section() const
907 {
908 gold_assert(this->got_tlsdesc_ != NULL);
909 return this->got_tlsdesc_;
910 }
911
c2b45e22
CC		 912 // Create the PLT section.
913 void
914 make_plt_section(Symbol_table* symtab, Layout* layout);
915
2e30d253
ILT		 916 // Create a PLT entry for a global symbol.
917 void
918 make_plt_entry(Symbol_table*, Layout*, Symbol*);
919
7223e9ca
ILT		 920 // Create a PLT entry for a local STT_GNU_IFUNC symbol.
921 void
922 make_local_ifunc_plt_entry(Symbol_table*, Layout*,
fc51264f 923 Sized_relobj_file<size, false>* relobj,
7223e9ca
ILT		 924 unsigned int local_sym_index);
925
9fa33bee 926 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC		 927 void
928 define_tls_base_symbol(Symbol_table*, Layout*);
929
c2b45e22
CC		 930 // Create the reserved PLT and GOT entries for the TLS descriptor resolver.
931 void
932 reserve_tlsdesc_entries(Symbol_table* symtab, Layout* layout);
933
31d60480
ILT		 934 // Create a GOT entry for the TLS module index.
935 unsigned int
936 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
fc51264f 937 Sized_relobj_file<size, false>* object);
31d60480 938
2e30d253 939 // Get the PLT section.
fc51264f 940 Output_data_plt_x86_64<size>*
2e30d253
ILT		 941 plt_section() const
942 {
943 gold_assert(this->plt_ != NULL);
944 return this->plt_;
945 }
946
947 // Get the dynamic reloc section, creating it if necessary.
948 Reloc_section*
0ffd9845 949 rela_dyn_section(Layout*);
2e30d253 950
e291e7b9
ILT		 951 // Get the section to use for TLSDESC relocations.
952 Reloc_section*
953 rela_tlsdesc_section(Layout*) const;
954
67181c72
ILT		 955 // Get the section to use for IRELATIVE relocations.
956 Reloc_section*
957 rela_irelative_section(Layout*);
958
12c0daef 959 // Add a potential copy relocation.
2e30d253 960 void
ef9beddf 961 copy_reloc(Symbol_table* symtab, Layout* layout,
2e702c99 962 Sized_relobj_file<size, false>* object,
12c0daef 963 unsigned int shndx, Output_section* output_section,
fc51264f 964 Symbol* sym, const elfcpp::Rela<size, false>& reloc)
12c0daef
ILT		 965 {
966 this->copy_relocs_.copy_reloc(symtab, layout,
fc51264f 967 symtab->get_sized_symbol<size>(sym),
12c0daef
ILT		 968 object, shndx, output_section,
969 reloc, this->rela_dyn_section(layout));
970 }
2e30d253
ILT		 971
972 // Information about this specific target which we pass to the
973 // general Target structure.
974 static const Target::Target_info x86_64_info;
975
0e70b911
CC		 976 // The types of GOT entries needed for this platform.
977 // These values are exposed to the ABI in an incremental link.
978 // Do not renumber existing values without changing the version
979 // number of the .gnu_incremental_inputs section.
0a65a3a7
CC		 980 enum Got_type
981 {
982 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
983 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset
984 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
985 GOT_TYPE_TLS_DESC = 3 // GOT entry for TLS_DESC pair
986 };
987
e291e7b9
ILT		 988 // This type is used as the argument to the target specific
989 // relocation routines. The only target specific reloc is
990 // R_X86_64_TLSDESC against a local symbol.
991 struct Tlsdesc_info
992 {
fc51264f 993 Tlsdesc_info(Sized_relobj_file<size, false>* a_object, unsigned int a_r_sym)
e291e7b9
ILT		 994 : object(a_object), r_sym(a_r_sym)
995 { }
996
997 // The object in which the local symbol is defined.
fc51264f 998 Sized_relobj_file<size, false>* object;
e291e7b9
ILT		 999 // The local symbol index in the object.
1000 unsigned int r_sym;
1001 };
1002
2e30d253
ILT		 1003 // The GOT section.
1004 Output_data_got<64, false>* got_;
1005 // The PLT section.
fc51264f 1006 Output_data_plt_x86_64<size>* plt_;
2e30d253 1007 // The GOT PLT section.
57b2284c 1008 Output_data_got_plt_x86_64* got_plt_;
67181c72
ILT		 1009 // The GOT section for IRELATIVE relocations.
1010 Output_data_space* got_irelative_;
a8df5856
ILT		 1011 // The GOT section for TLSDESC relocations.
1012 Output_data_got<64, false>* got_tlsdesc_;
e785ec03
ILT		 1013 // The _GLOBAL_OFFSET_TABLE_ symbol.
1014 Symbol* global_offset_table_;
2e30d253 1015 // The dynamic reloc section.
0ffd9845 1016 Reloc_section* rela_dyn_;
67181c72
ILT		 1017 // The section to use for IRELATIVE relocs.
1018 Reloc_section* rela_irelative_;
2e30d253 1019 // Relocs saved to avoid a COPY reloc.
fc51264f 1020 Copy_relocs<elfcpp::SHT_RELA, size, false> copy_relocs_;
c2b45e22 1021 // Offset of the GOT entry for the TLS module index.
31d60480 1022 unsigned int got_mod_index_offset_;
e291e7b9
ILT		 1023 // We handle R_X86_64_TLSDESC against a local symbol as a target
1024 // specific relocation. Here we store the object and local symbol
1025 // index for the relocation.
1026 std::vector<Tlsdesc_info> tlsdesc_reloc_info_;
edfbb029
CC		 1027 // True if the _TLS_MODULE_BASE_ symbol has been defined.
1028 bool tls_base_symbol_defined_;
2e30d253
ILT		 1029};
1030
fc51264f
L		 1031template<>
1032const Target::Target_info Target_x86_64<64>::x86_64_info =
2e30d253
ILT		 1033{
1034 64, // size
1035 false, // is_big_endian
1036 elfcpp::EM_X86_64, // machine_code
1037 false, // has_make_symbol
1038 false, // has_resolve
1039 true, // has_code_fill
35cdfc9a 1040 true, // is_default_stack_executable
b3ce541e 1041 true, // can_icf_inline_merge_sections
0864d551 1042 '\0', // wrap_char
2e30d253 1043 "/lib/ld64.so.1", // program interpreter
0c5e9c22 1044 0x400000, // default_text_segment_address
cd72c291 1045 0x1000, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08 1046 0x1000, // common_pagesize (overridable by -z common-page-size)
2e702c99
RM		 1047 false, // isolate_execinstr
1048 0, // rosegment_gap
8a5e3e08
ILT		 1049 elfcpp::SHN_UNDEF, // small_common_shndx
1050 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
1051 0, // small_common_section_flags
05a352e6
DK		 1052 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
1053 NULL, // attributes_section
a67858e0 1054 NULL, // attributes_vendor
8d9743bd
MK		 1055 "_start", // entry_symbol_name
1056 32, // hash_entry_size
2e30d253
ILT		 1057};
1058
fc51264f
L		 1059template<>
1060const Target::Target_info Target_x86_64<32>::x86_64_info =
1061{
1062 32, // size
1063 false, // is_big_endian
1064 elfcpp::EM_X86_64, // machine_code
1065 false, // has_make_symbol
1066 false, // has_resolve
1067 true, // has_code_fill
1068 true, // is_default_stack_executable
1069 true, // can_icf_inline_merge_sections
1070 '\0', // wrap_char
1071 "/libx32/ldx32.so.1", // program interpreter
1072 0x400000, // default_text_segment_address
1073 0x1000, // abi_pagesize (overridable by -z max-page-size)
1074 0x1000, // common_pagesize (overridable by -z common-page-size)
2e702c99
RM		 1075 false, // isolate_execinstr
1076 0, // rosegment_gap
fc51264f
L		 1077 elfcpp::SHN_UNDEF, // small_common_shndx
1078 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
1079 0, // small_common_section_flags
1080 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
1081 NULL, // attributes_section
a67858e0 1082 NULL, // attributes_vendor
8d9743bd
MK		 1083 "_start", // entry_symbol_name
1084 32, // hash_entry_size
fc51264f
L		 1085};
1086
8a5e3e08
ILT		 1087// This is called when a new output section is created. This is where
1088// we handle the SHF_X86_64_LARGE.
1089
fc51264f 1090template<int size>
8a5e3e08 1091void
fc51264f 1092Target_x86_64<size>::do_new_output_section(Output_section* os) const
8a5e3e08
ILT		 1093{
1094 if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0)
1095 os->set_is_large_section();
1096}
1097
2e30d253
ILT		 1098// Get the GOT section, creating it if necessary.
1099
fc51264f 1100template<int size>
2e30d253 1101Output_data_got<64, false>*
fc51264f 1102Target_x86_64<size>::got_section(Symbol_table* symtab, Layout* layout)
2e30d253
ILT		 1103{
1104 if (this->got_ == NULL)
1105 {
1106 gold_assert(symtab != NULL && layout != NULL);
1107
9446efde
ILT		 1108 // When using -z now, we can treat .got.plt as a relro section.
1109 // Without -z now, it is modified after program startup by lazy
1110 // PLT relocations.
1111 bool is_got_plt_relro = parameters->options().now();
1112 Output_section_order got_order = (is_got_plt_relro
1113 ? ORDER_RELRO
1114 : ORDER_RELRO_LAST);
1115 Output_section_order got_plt_order = (is_got_plt_relro
1116 ? ORDER_RELRO
1117 : ORDER_NON_RELRO_FIRST);
1118
2e30d253
ILT		 1119 this->got_ = new Output_data_got<64, false>();
1120
82742395
ILT		 1121 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1122 (elfcpp::SHF_ALLOC
1123 | elfcpp::SHF_WRITE),
9446efde 1124 this->got_, got_order, true);
2e30d253 1125
57b2284c 1126 this->got_plt_ = new Output_data_got_plt_x86_64(layout);
82742395
ILT		 1127 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1128 (elfcpp::SHF_ALLOC
1129 | elfcpp::SHF_WRITE),
9446efde
ILT		 1130 this->got_plt_, got_plt_order,
1131 is_got_plt_relro);
2e30d253
ILT		 1132
1133 // The first three entries are reserved.
27bc2bce 1134 this->got_plt_->set_current_data_size(3 * 8);
2e30d253 1135
9446efde
ILT		 1136 if (!is_got_plt_relro)
1137 {
1138 // Those bytes can go into the relro segment.
1139 layout->increase_relro(3 * 8);
1140 }
1a2dff53 1141
2e30d253 1142 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
e785ec03
ILT		 1143 this->global_offset_table_ =
1144 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1145 Symbol_table::PREDEFINED,
1146 this->got_plt_,
1147 0, 0, elfcpp::STT_OBJECT,
1148 elfcpp::STB_LOCAL,
1149 elfcpp::STV_HIDDEN, 0,
1150 false, false);
a8df5856 1151
67181c72
ILT		 1152 // If there are any IRELATIVE relocations, they get GOT entries
1153 // in .got.plt after the jump slot entries.
1154 this->got_irelative_ = new Output_data_space(8, "** GOT IRELATIVE PLT");
1155 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1156 (elfcpp::SHF_ALLOC
1157 | elfcpp::SHF_WRITE),
1158 this->got_irelative_,
9446efde 1159 got_plt_order, is_got_plt_relro);
67181c72 1160
a8df5856 1161 // If there are any TLSDESC relocations, they get GOT entries in
67181c72 1162 // .got.plt after the jump slot and IRELATIVE entries.
a8df5856
ILT		 1163 this->got_tlsdesc_ = new Output_data_got<64, false>();
1164 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1165 (elfcpp::SHF_ALLOC
1166 | elfcpp::SHF_WRITE),
22f0da72 1167 this->got_tlsdesc_,
9446efde 1168 got_plt_order, is_got_plt_relro);
2e30d253
ILT		 1169 }
1170
1171 return this->got_;
1172}
1173
1174// Get the dynamic reloc section, creating it if necessary.
1175
fc51264f
L		 1176template<int size>
1177typename Target_x86_64<size>::Reloc_section*
1178Target_x86_64<size>::rela_dyn_section(Layout* layout)
2e30d253 1179{
0ffd9845 1180 if (this->rela_dyn_ == NULL)
2e30d253
ILT		 1181 {
1182 gold_assert(layout != NULL);
d98bc257 1183 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
2e30d253 1184 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
22f0da72
ILT		 1185 elfcpp::SHF_ALLOC, this->rela_dyn_,
1186 ORDER_DYNAMIC_RELOCS, false);
2e30d253 1187 }
0ffd9845 1188 return this->rela_dyn_;
2e30d253
ILT		 1189}
1190
67181c72
ILT		 1191// Get the section to use for IRELATIVE relocs, creating it if
1192// necessary. These go in .rela.dyn, but only after all other dynamic
1193// relocations. They need to follow the other dynamic relocations so
1194// that they can refer to global variables initialized by those
1195// relocs.
1196
fc51264f
L		 1197template<int size>
1198typename Target_x86_64<size>::Reloc_section*
1199Target_x86_64<size>::rela_irelative_section(Layout* layout)
67181c72
ILT		 1200{
1201 if (this->rela_irelative_ == NULL)
1202 {
1203 // Make sure we have already created the dynamic reloc section.
1204 this->rela_dyn_section(layout);
1205 this->rela_irelative_ = new Reloc_section(false);
1206 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
1207 elfcpp::SHF_ALLOC, this->rela_irelative_,
1208 ORDER_DYNAMIC_RELOCS, false);
1209 gold_assert(this->rela_dyn_->output_section()
1210 == this->rela_irelative_->output_section());
1211 }
1212 return this->rela_irelative_;
1213}
1214
57b2284c
CC		 1215// Write the first three reserved words of the .got.plt section.
1216// The remainder of the section is written while writing the PLT
1217// in Output_data_plt_i386::do_write.
1218
1219void
1220Output_data_got_plt_x86_64::do_write(Output_file* of)
1221{
1222 // The first entry in the GOT is the address of the .dynamic section
1223 // aka the PT_DYNAMIC segment. The next two entries are reserved.
1224 // We saved space for them when we created the section in
1225 // Target_x86_64::got_section.
1226 const off_t got_file_offset = this->offset();
1227 gold_assert(this->data_size() >= 24);
1228 unsigned char* const got_view = of->get_output_view(got_file_offset, 24);
1229 Output_section* dynamic = this->layout_->dynamic_section();
1230 uint64_t dynamic_addr = dynamic == NULL ? 0 : dynamic->address();
1231 elfcpp::Swap<64, false>::writeval(got_view, dynamic_addr);
1232 memset(got_view + 8, 0, 16);
1233 of->write_output_view(got_file_offset, 24, got_view);
1234}
1235
4829d394 1236// Initialize the PLT section.
2e30d253 1237
fc51264f 1238template<int size>
4829d394 1239void
fc51264f 1240Output_data_plt_x86_64<size>::init(Layout* layout)
2e30d253 1241{
d98bc257 1242 this->rel_ = new Reloc_section(false);
2e30d253 1243 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
22f0da72
ILT		 1244 elfcpp::SHF_ALLOC, this->rel_,
1245 ORDER_DYNAMIC_PLT_RELOCS, false);
2e30d253
ILT		 1246}
1247
fc51264f 1248template<int size>
2e30d253 1249void
fc51264f 1250Output_data_plt_x86_64<size>::do_adjust_output_section(Output_section* os)
2e30d253 1251{
2e702c99 1252 os->set_entsize(this->get_plt_entry_size());
2e30d253
ILT		 1253}
1254
1255// Add an entry to the PLT.
1256
fc51264f 1257template<int size>
2e30d253 1258void
fc51264f
L		 1259Output_data_plt_x86_64<size>::add_entry(Symbol_table* symtab, Layout* layout,
1260 Symbol* gsym)
2e30d253
ILT		 1261{
1262 gold_assert(!gsym->has_plt_offset());
1263
4829d394
CC		 1264 unsigned int plt_index;
1265 off_t plt_offset;
1266 section_offset_type got_offset;
2e30d253 1267
67181c72
ILT		 1268 unsigned int* pcount;
1269 unsigned int offset;
1270 unsigned int reserved;
57b2284c 1271 Output_section_data_build* got;
67181c72
ILT		 1272 if (gsym->type() == elfcpp::STT_GNU_IFUNC
1273 && gsym->can_use_relative_reloc(false))
1274 {
1275 pcount = &this->irelative_count_;
1276 offset = 0;
1277 reserved = 0;
1278 got = this->got_irelative_;
1279 }
1280 else
1281 {
1282 pcount = &this->count_;
1283 offset = 1;
1284 reserved = 3;
1285 got = this->got_plt_;
1286 }
1287
4829d394
CC		 1288 if (!this->is_data_size_valid())
1289 {
67181c72
ILT		 1290 // Note that when setting the PLT offset for a non-IRELATIVE
1291 // entry we skip the initial reserved PLT entry.
1292 plt_index = *pcount + offset;
2e702c99 1293 plt_offset = plt_index * this->get_plt_entry_size();
2e30d253 1294
67181c72 1295 ++*pcount;
2e30d253 1296
67181c72
ILT		 1297 got_offset = (plt_index - offset + reserved) * 8;
1298 gold_assert(got_offset == got->current_data_size());
2e30d253 1299
4829d394
CC		 1300 // Every PLT entry needs a GOT entry which points back to the PLT
1301 // entry (this will be changed by the dynamic linker, normally
1302 // lazily when the function is called).
67181c72 1303 got->set_current_data_size(got_offset + 8);
4829d394 1304 }
7223e9ca
ILT		 1305 else
1306 {
67181c72
ILT		 1307 // FIXME: This is probably not correct for IRELATIVE relocs.
1308
4829d394 1309 // For incremental updates, find an available slot.
2e702c99
RM		 1310 plt_offset = this->free_list_.allocate(this->get_plt_entry_size(),
1311 this->get_plt_entry_size(), 0);
4829d394 1312 if (plt_offset == -1)
e6455dfb
CC		 1313 gold_fallback(_("out of patch space (PLT);"
1314 " relink with --incremental-full"));
4829d394
CC		 1315
1316 // The GOT and PLT entries have a 1-1 correspondance, so the GOT offset
1317 // can be calculated from the PLT index, adjusting for the three
1318 // reserved entries at the beginning of the GOT.
2e702c99 1319 plt_index = plt_offset / this->get_plt_entry_size() - 1;
67181c72 1320 got_offset = (plt_index - offset + reserved) * 8;
7223e9ca 1321 }
2e30d253 1322
4829d394
CC		 1323 gsym->set_plt_offset(plt_offset);
1324
1325 // Every PLT entry needs a reloc.
67181c72 1326 this->add_relocation(symtab, layout, gsym, got_offset);
4829d394 1327
2e30d253
ILT		 1328 // Note that we don't need to save the symbol. The contents of the
1329 // PLT are independent of which symbols are used. The symbols only
1330 // appear in the relocations.
1331}
1332
7223e9ca
ILT		 1333// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return
1334// the PLT offset.
1335
fc51264f 1336template<int size>
7223e9ca 1337unsigned int
fc51264f 1338Output_data_plt_x86_64<size>::add_local_ifunc_entry(
67181c72
ILT		 1339 Symbol_table* symtab,
1340 Layout* layout,
fc51264f 1341 Sized_relobj_file<size, false>* relobj,
6fa2a40b 1342 unsigned int local_sym_index)
7223e9ca 1343{
2e702c99 1344 unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size();
67181c72 1345 ++this->irelative_count_;
7223e9ca 1346
67181c72 1347 section_offset_type got_offset = this->got_irelative_->current_data_size();
7223e9ca
ILT		 1348
1349 // Every PLT entry needs a GOT entry which points back to the PLT
1350 // entry.
67181c72 1351 this->got_irelative_->set_current_data_size(got_offset + 8);
7223e9ca
ILT		 1352
1353 // Every PLT entry needs a reloc.
67181c72
ILT		 1354 Reloc_section* rela = this->rela_irelative(symtab, layout);
1355 rela->add_symbolless_local_addend(relobj, local_sym_index,
1356 elfcpp::R_X86_64_IRELATIVE,
1357 this->got_irelative_, got_offset, 0);
7223e9ca
ILT		 1358
1359 return plt_offset;
1360}
1361
4829d394
CC		 1362// Add the relocation for a PLT entry.
1363
fc51264f 1364template<int size>
4829d394 1365void
fc51264f
L		 1366Output_data_plt_x86_64<size>::add_relocation(Symbol_table* symtab,
1367 Layout* layout,
1368 Symbol* gsym,
1369 unsigned int got_offset)
4829d394
CC		 1370{
1371 if (gsym->type() == elfcpp::STT_GNU_IFUNC
1372 && gsym->can_use_relative_reloc(false))
67181c72
ILT		 1373 {
1374 Reloc_section* rela = this->rela_irelative(symtab, layout);
1375 rela->add_symbolless_global_addend(gsym, elfcpp::R_X86_64_IRELATIVE,
1376 this->got_irelative_, got_offset, 0);
1377 }
4829d394
CC		 1378 else
1379 {
1380 gsym->set_needs_dynsym_entry();
1381 this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_,
1382 got_offset, 0);
1383 }
1384}
1385
e291e7b9
ILT		 1386// Return where the TLSDESC relocations should go, creating it if
1387// necessary. These follow the JUMP_SLOT relocations.
1388
fc51264f
L		 1389template<int size>
1390typename Output_data_plt_x86_64<size>::Reloc_section*
1391Output_data_plt_x86_64<size>::rela_tlsdesc(Layout* layout)
e291e7b9
ILT		 1392{
1393 if (this->tlsdesc_rel_ == NULL)
1394 {
1395 this->tlsdesc_rel_ = new Reloc_section(false);
1396 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1397 elfcpp::SHF_ALLOC, this->tlsdesc_rel_,
22f0da72 1398 ORDER_DYNAMIC_PLT_RELOCS, false);
67181c72
ILT		 1399 gold_assert(this->tlsdesc_rel_->output_section()
1400 == this->rel_->output_section());
e291e7b9
ILT		 1401 }
1402 return this->tlsdesc_rel_;
1403}
1404
67181c72
ILT		 1405// Return where the IRELATIVE relocations should go in the PLT. These
1406// follow the JUMP_SLOT and the TLSDESC relocations.
1407
fc51264f
L		 1408template<int size>
1409typename Output_data_plt_x86_64<size>::Reloc_section*
1410Output_data_plt_x86_64<size>::rela_irelative(Symbol_table* symtab,
1411 Layout* layout)
67181c72
ILT		 1412{
1413 if (this->irelative_rel_ == NULL)
1414 {
1415 // Make sure we have a place for the TLSDESC relocations, in
1416 // case we see any later on.
1417 this->rela_tlsdesc(layout);
1418 this->irelative_rel_ = new Reloc_section(false);
1419 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
1420 elfcpp::SHF_ALLOC, this->irelative_rel_,
1421 ORDER_DYNAMIC_PLT_RELOCS, false);
1422 gold_assert(this->irelative_rel_->output_section()
1423 == this->rel_->output_section());
1424
1425 if (parameters->doing_static_link())
1426 {
1427 // A statically linked executable will only have a .rela.plt
1428 // section to hold R_X86_64_IRELATIVE relocs for
1429 // STT_GNU_IFUNC symbols. The library will use these
1430 // symbols to locate the IRELATIVE relocs at program startup
1431 // time.
1432 symtab->define_in_output_data("__rela_iplt_start", NULL,
1433 Symbol_table::PREDEFINED,
1434 this->irelative_rel_, 0, 0,
1435 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
1436 elfcpp::STV_HIDDEN, 0, false, true);
1437 symtab->define_in_output_data("__rela_iplt_end", NULL,
1438 Symbol_table::PREDEFINED,
1439 this->irelative_rel_, 0, 0,
1440 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
1441 elfcpp::STV_HIDDEN, 0, true, true);
1442 }
1443 }
1444 return this->irelative_rel_;
1445}
1446
1447// Return the PLT address to use for a global symbol.
1448
fc51264f 1449template<int size>
67181c72 1450uint64_t
fc51264f 1451Output_data_plt_x86_64<size>::address_for_global(const Symbol* gsym)
67181c72
ILT		 1452{
1453 uint64_t offset = 0;
1454 if (gsym->type() == elfcpp::STT_GNU_IFUNC
1455 && gsym->can_use_relative_reloc(false))
2e702c99 1456 offset = (this->count_ + 1) * this->get_plt_entry_size();
19fec8c1 1457 return this->address() + offset + gsym->plt_offset();
67181c72
ILT		 1458}
1459
1460// Return the PLT address to use for a local symbol. These are always
1461// IRELATIVE relocs.
1462
fc51264f 1463template<int size>
67181c72 1464uint64_t
19fec8c1
AM		 1465Output_data_plt_x86_64<size>::address_for_local(const Relobj* object,
1466 unsigned int r_sym)
67181c72 1467{
19fec8c1
AM		 1468 return (this->address()
1469 + (this->count_ + 1) * this->get_plt_entry_size()
1470 + object->local_plt_offset(r_sym));
67181c72
ILT		 1471}
1472
c2b45e22 1473// Set the final size.
fc51264f 1474template<int size>
c2b45e22 1475void
fc51264f 1476Output_data_plt_x86_64<size>::set_final_data_size()
c2b45e22 1477{
67181c72 1478 unsigned int count = this->count_ + this->irelative_count_;
c2b45e22
CC		 1479 if (this->has_tlsdesc_entry())
1480 ++count;
2e702c99 1481 this->set_data_size((count + 1) * this->get_plt_entry_size());
c2b45e22
CC		 1482}
1483
2e30d253
ILT		 1484// The first entry in the PLT for an executable.
1485
fc51264f
L		 1486template<int size>
1487const unsigned char
2e702c99 1488Output_data_plt_x86_64_standard<size>::first_plt_entry[plt_entry_size] =
2e30d253
ILT		 1489{
1490 // From AMD64 ABI Draft 0.98, page 76
1491 0xff, 0x35, // pushq contents of memory address
2e30d253 1492 0, 0, 0, 0, // replaced with address of .got + 8
78d911fd
ILT		 1493 0xff, 0x25, // jmp indirect
1494 0, 0, 0, 0, // replaced with address of .got + 16
2e30d253
ILT		 1495 0x90, 0x90, 0x90, 0x90 // noop (x4)
1496};
1497
2e702c99
RM		 1498template<int size>
1499void
1500Output_data_plt_x86_64_standard<size>::do_fill_first_plt_entry(
1501 unsigned char* pov,
1502 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
1503 typename elfcpp::Elf_types<size>::Elf_Addr plt_address)
1504{
1505 memcpy(pov, first_plt_entry, plt_entry_size);
1506 // We do a jmp relative to the PC at the end of this instruction.
1507 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1508 (got_address + 8
1509 - (plt_address + 6)));
1510 elfcpp::Swap<32, false>::writeval(pov + 8,
1511 (got_address + 16
1512 - (plt_address + 12)));
1513}
1514
2e30d253
ILT		 1515// Subsequent entries in the PLT for an executable.
1516
fc51264f
L		 1517template<int size>
1518const unsigned char
2e702c99 1519Output_data_plt_x86_64_standard<size>::plt_entry[plt_entry_size] =
2e30d253
ILT		 1520{
1521 // From AMD64 ABI Draft 0.98, page 76
1522 0xff, 0x25, // jmpq indirect
1523 0, 0, 0, 0, // replaced with address of symbol in .got
1524 0x68, // pushq immediate
1525 0, 0, 0, 0, // replaced with offset into relocation table
1526 0xe9, // jmpq relative
1527 0, 0, 0, 0 // replaced with offset to start of .plt
1528};
1529
2e702c99
RM		 1530template<int size>
1531unsigned int
1532Output_data_plt_x86_64_standard<size>::do_fill_plt_entry(
1533 unsigned char* pov,
1534 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
1535 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
1536 unsigned int got_offset,
1537 unsigned int plt_offset,
1538 unsigned int plt_index)
1539{
9d585188
L		 1540 // Check PC-relative offset overflow in PLT entry.
1541 uint64_t plt_got_pcrel_offset = (got_address + got_offset
1542 - (plt_address + plt_offset + 6));
1543 if (Bits<32>::has_overflow(plt_got_pcrel_offset))
1544 gold_error(_("PC-relative offset overflow in PLT entry %d"),
1545 plt_index + 1);
1546
2e702c99
RM		 1547 memcpy(pov, plt_entry, plt_entry_size);
1548 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
9d585188 1549 plt_got_pcrel_offset);
2e702c99
RM		 1550
1551 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_index);
1552 elfcpp::Swap<32, false>::writeval(pov + 12,
1553 - (plt_offset + plt_entry_size));
1554
1555 return 6;
1556}
1557
c2b45e22
CC		 1558// The reserved TLSDESC entry in the PLT for an executable.
1559
fc51264f
L		 1560template<int size>
1561const unsigned char
2e702c99 1562Output_data_plt_x86_64_standard<size>::tlsdesc_plt_entry[plt_entry_size] =
c2b45e22
CC		 1563{
1564 // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32
1565 // and AMD64/EM64T", Version 0.9.4 (2005-10-10).
1566 0xff, 0x35, // pushq x(%rip)
1567 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
1568 0xff, 0x25, // jmpq *y(%rip)
1569 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
1570 0x0f, 0x1f, // nop
1571 0x40, 0
1572};
1573
2e702c99
RM		 1574template<int size>
1575void
1576Output_data_plt_x86_64_standard<size>::do_fill_tlsdesc_entry(
1577 unsigned char* pov,
1578 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
1579 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
1580 typename elfcpp::Elf_types<size>::Elf_Addr got_base,
1581 unsigned int tlsdesc_got_offset,
1582 unsigned int plt_offset)
1583{
1584 memcpy(pov, tlsdesc_plt_entry, plt_entry_size);
1585 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1586 (got_address + 8
1587 - (plt_address + plt_offset
1588 + 6)));
1589 elfcpp::Swap_unaligned<32, false>::writeval(pov + 8,
1590 (got_base
1591 + tlsdesc_got_offset
1592 - (plt_address + plt_offset
1593 + 12)));
1594}
1595
07a60597
ILT		 1596// The .eh_frame unwind information for the PLT.
1597
fc51264f 1598template<int size>
2e702c99 1599const unsigned char
fc51264f 1600Output_data_plt_x86_64<size>::plt_eh_frame_cie[plt_eh_frame_cie_size] =
07a60597
ILT		 1601{
1602 1, // CIE version.
1603 'z', // Augmentation: augmentation size included.
1604 'R', // Augmentation: FDE encoding included.
1605 '\0', // End of augmentation string.
1606 1, // Code alignment factor.
1607 0x78, // Data alignment factor.
1608 16, // Return address column.
1609 1, // Augmentation size.
1610 (elfcpp::DW_EH_PE_pcrel // FDE encoding.
1611 | elfcpp::DW_EH_PE_sdata4),
1612 elfcpp::DW_CFA_def_cfa, 7, 8, // DW_CFA_def_cfa: r7 (rsp) ofs 8.
1613 elfcpp::DW_CFA_offset + 16, 1,// DW_CFA_offset: r16 (rip) at cfa-8.
1614 elfcpp::DW_CFA_nop, // Align to 16 bytes.
1615 elfcpp::DW_CFA_nop
1616};
1617
fc51264f 1618template<int size>
07a60597 1619const unsigned char
2e702c99 1620Output_data_plt_x86_64_standard<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] =
07a60597
ILT		 1621{
1622 0, 0, 0, 0, // Replaced with offset to .plt.
1623 0, 0, 0, 0, // Replaced with size of .plt.
1624 0, // Augmentation size.
1625 elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16.
1626 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
1627 elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24.
1628 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16.
1629 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
1630 11, // Block length.
1631 elfcpp::DW_OP_breg7, 8, // Push %rsp + 8.
1632 elfcpp::DW_OP_breg16, 0, // Push %rip.
1633 elfcpp::DW_OP_lit15, // Push 0xf.
1634 elfcpp::DW_OP_and, // & (%rip & 0xf).
1635 elfcpp::DW_OP_lit11, // Push 0xb.
1636 elfcpp::DW_OP_ge, // >= ((%rip & 0xf) >= 0xb)
1637 elfcpp::DW_OP_lit3, // Push 3.
1638 elfcpp::DW_OP_shl, // << (((%rip & 0xf) >= 0xb) << 3)
1639 elfcpp::DW_OP_plus, // + ((((%rip&0xf)>=0xb)<<3)+%rsp+8
1640 elfcpp::DW_CFA_nop, // Align to 32 bytes.
1641 elfcpp::DW_CFA_nop,
1642 elfcpp::DW_CFA_nop,
1643 elfcpp::DW_CFA_nop
1644};
1645
2e30d253
ILT		 1646// Write out the PLT. This uses the hand-coded instructions above,
1647// and adjusts them as needed. This is specified by the AMD64 ABI.
1648
fc51264f 1649template<int size>
2e30d253 1650void
fc51264f 1651Output_data_plt_x86_64<size>::do_write(Output_file* of)
2e30d253 1652{
2ea97941 1653 const off_t offset = this->offset();
fe8718a4
ILT		 1654 const section_size_type oview_size =
1655 convert_to_section_size_type(this->data_size());
2ea97941 1656 unsigned char* const oview = of->get_output_view(offset, oview_size);
2e30d253
ILT		 1657
1658 const off_t got_file_offset = this->got_plt_->offset();
67181c72
ILT		 1659 gold_assert(parameters->incremental_update()
1660 || (got_file_offset + this->got_plt_->data_size()
1661 == this->got_irelative_->offset()));
fe8718a4 1662 const section_size_type got_size =
67181c72
ILT		 1663 convert_to_section_size_type(this->got_plt_->data_size()
1664 + this->got_irelative_->data_size());
2e30d253
ILT		 1665 unsigned char* const got_view = of->get_output_view(got_file_offset,
1666 got_size);
1667
1668 unsigned char* pov = oview;
1669
c2b45e22 1670 // The base address of the .plt section.
fc51264f 1671 typename elfcpp::Elf_types<size>::Elf_Addr plt_address = this->address();
c2b45e22 1672 // The base address of the .got section.
fc51264f 1673 typename elfcpp::Elf_types<size>::Elf_Addr got_base = this->got_->address();
c2b45e22
CC		 1674 // The base address of the PLT portion of the .got section,
1675 // which is where the GOT pointer will point, and where the
1676 // three reserved GOT entries are located.
fc51264f
L		 1677 typename elfcpp::Elf_types<size>::Elf_Addr got_address
1678 = this->got_plt_->address();
2e30d253 1679
2e702c99
RM		 1680 this->fill_first_plt_entry(pov, got_address, plt_address);
1681 pov += this->get_plt_entry_size();
2e30d253 1682
57b2284c
CC		 1683 // The first three entries in the GOT are reserved, and are written
1684 // by Output_data_got_plt_x86_64::do_write.
1685 unsigned char* got_pov = got_view + 24;
2e30d253 1686
2e702c99 1687 unsigned int plt_offset = this->get_plt_entry_size();
2e30d253 1688 unsigned int got_offset = 24;
67181c72 1689 const unsigned int count = this->count_ + this->irelative_count_;
2e30d253
ILT		 1690 for (unsigned int plt_index = 0;
1691 plt_index < count;
1692 ++plt_index,
2e702c99 1693 pov += this->get_plt_entry_size(),
2e30d253 1694 got_pov += 8,
2e702c99 1695 plt_offset += this->get_plt_entry_size(),
2e30d253
ILT		 1696 got_offset += 8)
1697 {
1698 // Set and adjust the PLT entry itself.
2e702c99
RM		 1699 unsigned int lazy_offset = this->fill_plt_entry(pov,
1700 got_address, plt_address,
1701 got_offset, plt_offset,
1702 plt_index);
2e30d253
ILT		 1703
1704 // Set the entry in the GOT.
2e702c99
RM		 1705 elfcpp::Swap<64, false>::writeval(got_pov,
1706 plt_address + plt_offset + lazy_offset);
2e30d253
ILT		 1707 }
1708
c2b45e22
CC		 1709 if (this->has_tlsdesc_entry())
1710 {
1711 // Set and adjust the reserved TLSDESC PLT entry.
1712 unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset();
2e702c99
RM		 1713 this->fill_tlsdesc_entry(pov, got_address, plt_address, got_base,
1714 tlsdesc_got_offset, plt_offset);
1715 pov += this->get_plt_entry_size();
c2b45e22
CC		 1716 }
1717
fe8718a4
ILT		 1718 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1719 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
2e30d253 1720
2ea97941 1721 of->write_output_view(offset, oview_size, oview);
2e30d253
ILT		 1722 of->write_output_view(got_file_offset, got_size, got_view);
1723}
1724
c2b45e22 1725// Create the PLT section.
2e30d253 1726
fc51264f 1727template<int size>
2e30d253 1728void
fc51264f 1729Target_x86_64<size>::make_plt_section(Symbol_table* symtab, Layout* layout)
2e30d253 1730{
2e30d253
ILT		 1731 if (this->plt_ == NULL)
1732 {
1733 // Create the GOT sections first.
1734 this->got_section(symtab, layout);
1735
2e702c99
RM		 1736 this->plt_ = this->make_data_plt(layout, this->got_, this->got_plt_,
1737 this->got_irelative_);
1738
1739 // Add unwind information if requested.
1740 if (parameters->options().ld_generated_unwind_info())
1741 this->plt_->add_eh_frame(layout);
1742
2e30d253
ILT		 1743 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1744 (elfcpp::SHF_ALLOC
1745 | elfcpp::SHF_EXECINSTR),
22f0da72 1746 this->plt_, ORDER_PLT, false);
7223e9ca
ILT		 1747
1748 // Make the sh_info field of .rela.plt point to .plt.
1749 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1750 rela_plt_os->set_info_section(this->plt_->output_section());
2e30d253 1751 }
c2b45e22
CC		 1752}
1753
e291e7b9
ILT		 1754// Return the section for TLSDESC relocations.
1755
fc51264f
L		 1756template<int size>
1757typename Target_x86_64<size>::Reloc_section*
1758Target_x86_64<size>::rela_tlsdesc_section(Layout* layout) const
e291e7b9
ILT		 1759{
1760 return this->plt_section()->rela_tlsdesc(layout);
1761}
1762
c2b45e22
CC		 1763// Create a PLT entry for a global symbol.
1764
fc51264f 1765template<int size>
c2b45e22 1766void
fc51264f
L		 1767Target_x86_64<size>::make_plt_entry(Symbol_table* symtab, Layout* layout,
1768 Symbol* gsym)
c2b45e22
CC		 1769{
1770 if (gsym->has_plt_offset())
1771 return;
1772
1773 if (this->plt_ == NULL)
1774 this->make_plt_section(symtab, layout);
2e30d253 1775
67181c72 1776 this->plt_->add_entry(symtab, layout, gsym);
2e30d253
ILT		 1777}
1778
7223e9ca
ILT		 1779// Make a PLT entry for a local STT_GNU_IFUNC symbol.
1780
fc51264f 1781template<int size>
7223e9ca 1782void
fc51264f
L		 1783Target_x86_64<size>::make_local_ifunc_plt_entry(
1784 Symbol_table* symtab, Layout* layout,
1785 Sized_relobj_file<size, false>* relobj,
1786 unsigned int local_sym_index)
7223e9ca
ILT		 1787{
1788 if (relobj->local_has_plt_offset(local_sym_index))
1789 return;
1790 if (this->plt_ == NULL)
1791 this->make_plt_section(symtab, layout);
67181c72
ILT		 1792 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout,
1793 relobj,
7223e9ca
ILT		 1794 local_sym_index);
1795 relobj->set_local_plt_offset(local_sym_index, plt_offset);
1796}
1797
0e70b911
CC		 1798// Return the number of entries in the PLT.
1799
fc51264f 1800template<int size>
0e70b911 1801unsigned int
fc51264f 1802Target_x86_64<size>::plt_entry_count() const
0e70b911
CC		 1803{
1804 if (this->plt_ == NULL)
1805 return 0;
1806 return this->plt_->entry_count();
1807}
1808
1809// Return the offset of the first non-reserved PLT entry.
1810
fc51264f 1811template<int size>
0e70b911 1812unsigned int
fc51264f 1813Target_x86_64<size>::first_plt_entry_offset() const
0e70b911 1814{
2e702c99 1815 return this->plt_->first_plt_entry_offset();
0e70b911
CC		 1816}
1817
1818// Return the size of each PLT entry.
1819
fc51264f 1820template<int size>
0e70b911 1821unsigned int
fc51264f 1822Target_x86_64<size>::plt_entry_size() const
0e70b911 1823{
2e702c99 1824 return this->plt_->get_plt_entry_size();
0e70b911
CC		 1825}
1826
4829d394
CC		 1827// Create the GOT and PLT sections for an incremental update.
1828
fc51264f 1829template<int size>
dd74ae06 1830Output_data_got_base*
fc51264f 1831Target_x86_64<size>::init_got_plt_for_update(Symbol_table* symtab,
4829d394
CC		 1832 Layout* layout,
1833 unsigned int got_count,
1834 unsigned int plt_count)
1835{
1836 gold_assert(this->got_ == NULL);
1837
1838 this->got_ = new Output_data_got<64, false>(got_count * 8);
1839 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1840 (elfcpp::SHF_ALLOC
1841 | elfcpp::SHF_WRITE),
1842 this->got_, ORDER_RELRO_LAST,
1843 true);
1844
1845 // Add the three reserved entries.
57b2284c 1846 this->got_plt_ = new Output_data_got_plt_x86_64(layout, (plt_count + 3) * 8);
4829d394
CC		 1847 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1848 (elfcpp::SHF_ALLOC
1849 | elfcpp::SHF_WRITE),
1850 this->got_plt_, ORDER_NON_RELRO_FIRST,
1851 false);
1852
1853 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1854 this->global_offset_table_ =
1855 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1856 Symbol_table::PREDEFINED,
1857 this->got_plt_,
1858 0, 0, elfcpp::STT_OBJECT,
1859 elfcpp::STB_LOCAL,
1860 elfcpp::STV_HIDDEN, 0,
1861 false, false);
1862
1863 // If there are any TLSDESC relocations, they get GOT entries in
1864 // .got.plt after the jump slot entries.
1865 // FIXME: Get the count for TLSDESC entries.
1866 this->got_tlsdesc_ = new Output_data_got<64, false>(0);
1867 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1868 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1869 this->got_tlsdesc_,
1870 ORDER_NON_RELRO_FIRST, false);
1871
67181c72
ILT		 1872 // If there are any IRELATIVE relocations, they get GOT entries in
1873 // .got.plt after the jump slot and TLSDESC entries.
1874 this->got_irelative_ = new Output_data_space(0, 8, "** GOT IRELATIVE PLT");
1875 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1876 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1877 this->got_irelative_,
1878 ORDER_NON_RELRO_FIRST, false);
1879
4829d394 1880 // Create the PLT section.
2e702c99
RM		 1881 this->plt_ = this->make_data_plt(layout, this->got_,
1882 this->got_plt_,
1883 this->got_irelative_,
1884 plt_count);
1885
1886 // Add unwind information if requested.
1887 if (parameters->options().ld_generated_unwind_info())
1888 this->plt_->add_eh_frame(layout);
1889
4829d394
CC		 1890 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1891 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
1892 this->plt_, ORDER_PLT, false);
1893
1894 // Make the sh_info field of .rela.plt point to .plt.
1895 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1896 rela_plt_os->set_info_section(this->plt_->output_section());
1897
6fa2a40b
CC		 1898 // Create the rela_dyn section.
1899 this->rela_dyn_section(layout);
1900
4829d394
CC		 1901 return this->got_;
1902}
1903
6fa2a40b
CC		 1904// Reserve a GOT entry for a local symbol, and regenerate any
1905// necessary dynamic relocations.
1906
fc51264f 1907template<int size>
6fa2a40b 1908void
fc51264f 1909Target_x86_64<size>::reserve_local_got_entry(
6fa2a40b 1910 unsigned int got_index,
fc51264f 1911 Sized_relobj<size, false>* obj,
6fa2a40b
CC		 1912 unsigned int r_sym,
1913 unsigned int got_type)
1914{
1915 unsigned int got_offset = got_index * 8;
1916 Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1917
1918 this->got_->reserve_local(got_index, obj, r_sym, got_type);
1919 switch (got_type)
1920 {
1921 case GOT_TYPE_STANDARD:
1922 if (parameters->options().output_is_position_independent())
1923 rela_dyn->add_local_relative(obj, r_sym, elfcpp::R_X86_64_RELATIVE,
397b129b 1924 this->got_, got_offset, 0, false);
6fa2a40b
CC		 1925 break;
1926 case GOT_TYPE_TLS_OFFSET:
1927 rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_TPOFF64,
1928 this->got_, got_offset, 0);
1929 break;
1930 case GOT_TYPE_TLS_PAIR:
1931 this->got_->reserve_slot(got_index + 1);
1932 rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_DTPMOD64,
1933 this->got_, got_offset, 0);
1934 break;
1935 case GOT_TYPE_TLS_DESC:
1936 gold_fatal(_("TLS_DESC not yet supported for incremental linking"));
1937 // this->got_->reserve_slot(got_index + 1);
1938 // rela_dyn->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1939 // this->got_, got_offset, 0);
1940 break;
1941 default:
1942 gold_unreachable();
1943 }
1944}
1945
1946// Reserve a GOT entry for a global symbol, and regenerate any
1947// necessary dynamic relocations.
1948
fc51264f 1949template<int size>
6fa2a40b 1950void
fc51264f
L		 1951Target_x86_64<size>::reserve_global_got_entry(unsigned int got_index,
1952 Symbol* gsym,
1953 unsigned int got_type)
6fa2a40b
CC		 1954{
1955 unsigned int got_offset = got_index * 8;
1956 Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1957
1958 this->got_->reserve_global(got_index, gsym, got_type);
1959 switch (got_type)
1960 {
1961 case GOT_TYPE_STANDARD:
1962 if (!gsym->final_value_is_known())
1963 {
1964 if (gsym->is_from_dynobj()
1965 || gsym->is_undefined()
1966 || gsym->is_preemptible()
1967 || gsym->type() == elfcpp::STT_GNU_IFUNC)
1968 rela_dyn->add_global(gsym, elfcpp::R_X86_64_GLOB_DAT,
1969 this->got_, got_offset, 0);
1970 else
1971 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
13cf9988 1972 this->got_, got_offset, 0, false);
6fa2a40b
CC		 1973 }
1974 break;
1975 case GOT_TYPE_TLS_OFFSET:
1976 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TPOFF64,
13cf9988 1977 this->got_, got_offset, 0, false);
6fa2a40b
CC		 1978 break;
1979 case GOT_TYPE_TLS_PAIR:
1980 this->got_->reserve_slot(got_index + 1);
1981 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPMOD64,
13cf9988 1982 this->got_, got_offset, 0, false);
6fa2a40b 1983 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPOFF64,
13cf9988 1984 this->got_, got_offset + 8, 0, false);
6fa2a40b
CC		 1985 break;
1986 case GOT_TYPE_TLS_DESC:
1987 this->got_->reserve_slot(got_index + 1);
1988 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TLSDESC,
13cf9988 1989 this->got_, got_offset, 0, false);
6fa2a40b
CC		 1990 break;
1991 default:
1992 gold_unreachable();
1993 }
1994}
1995
4829d394
CC		 1996// Register an existing PLT entry for a global symbol.
1997
fc51264f 1998template<int size>
4829d394 1999void
fc51264f
L		 2000Target_x86_64<size>::register_global_plt_entry(Symbol_table* symtab,
2001 Layout* layout,
2002 unsigned int plt_index,
2003 Symbol* gsym)
4829d394
CC		 2004{
2005 gold_assert(this->plt_ != NULL);
2006 gold_assert(!gsym->has_plt_offset());
2007
2008 this->plt_->reserve_slot(plt_index);
2009
2010 gsym->set_plt_offset((plt_index + 1) * this->plt_entry_size());
2011
2012 unsigned int got_offset = (plt_index + 3) * 8;
67181c72 2013 this->plt_->add_relocation(symtab, layout, gsym, got_offset);
4829d394
CC		 2014}
2015
26d3c67d
CC		 2016// Force a COPY relocation for a given symbol.
2017
fc51264f 2018template<int size>
26d3c67d 2019void
fc51264f 2020Target_x86_64<size>::emit_copy_reloc(
26d3c67d
CC		 2021 Symbol_table* symtab, Symbol* sym, Output_section* os, off_t offset)
2022{
2023 this->copy_relocs_.emit_copy_reloc(symtab,
fc51264f 2024 symtab->get_sized_symbol<size>(sym),
26d3c67d
CC		 2025 os,
2026 offset,
2027 this->rela_dyn_section(NULL));
2028}
2029
9fa33bee 2030// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029 2031
fc51264f 2032template<int size>
edfbb029 2033void
fc51264f
L		 2034Target_x86_64<size>::define_tls_base_symbol(Symbol_table* symtab,
2035 Layout* layout)
edfbb029
CC		 2036{
2037 if (this->tls_base_symbol_defined_)
2038 return;
2039
2040 Output_segment* tls_segment = layout->tls_segment();
2041 if (tls_segment != NULL)
2042 {
183fd0e3 2043 bool is_exec = parameters->options().output_is_executable();
edfbb029 2044 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
99fff23b 2045 Symbol_table::PREDEFINED,
edfbb029
CC		 2046 tls_segment, 0, 0,
2047 elfcpp::STT_TLS,
2048 elfcpp::STB_LOCAL,
2049 elfcpp::STV_HIDDEN, 0,
183fd0e3
AO		 2050 (is_exec
2051 ? Symbol::SEGMENT_END
2052 : Symbol::SEGMENT_START),
2053 true);
edfbb029
CC		 2054 }
2055 this->tls_base_symbol_defined_ = true;
2056}
2057
c2b45e22
CC		 2058// Create the reserved PLT and GOT entries for the TLS descriptor resolver.
2059
fc51264f 2060template<int size>
c2b45e22 2061void
fc51264f 2062Target_x86_64<size>::reserve_tlsdesc_entries(Symbol_table* symtab,
2e702c99 2063 Layout* layout)
c2b45e22
CC		 2064{
2065 if (this->plt_ == NULL)
2066 this->make_plt_section(symtab, layout);
2067
2068 if (!this->plt_->has_tlsdesc_entry())
2069 {
2070 // Allocate the TLSDESC_GOT entry.
2071 Output_data_got<64, false>* got = this->got_section(symtab, layout);
2072 unsigned int got_offset = got->add_constant(0);
2073
2074 // Allocate the TLSDESC_PLT entry.
2075 this->plt_->reserve_tlsdesc_entry(got_offset);
2076 }
2077}
2078
31d60480
ILT		 2079// Create a GOT entry for the TLS module index.
2080
fc51264f 2081template<int size>
31d60480 2082unsigned int
fc51264f
L		 2083Target_x86_64<size>::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
2084 Sized_relobj_file<size, false>* object)
31d60480
ILT		 2085{
2086 if (this->got_mod_index_offset_ == -1U)
2087 {
2088 gold_assert(symtab != NULL && layout != NULL && object != NULL);
2089 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
2090 Output_data_got<64, false>* got = this->got_section(symtab, layout);
2091 unsigned int got_offset = got->add_constant(0);
2092 rela_dyn->add_local(object, 0, elfcpp::R_X86_64_DTPMOD64, got,
2e702c99 2093 got_offset, 0);
009a67a2 2094 got->add_constant(0);
31d60480
ILT		 2095 this->got_mod_index_offset_ = got_offset;
2096 }
2097 return this->got_mod_index_offset_;
2098}
2099
2e30d253
ILT		 2100// Optimize the TLS relocation type based on what we know about the
2101// symbol. IS_FINAL is true if the final address of this symbol is
2102// known at link time.
2103
fc51264f 2104template<int size>
e041f13d 2105tls::Tls_optimization
fc51264f 2106Target_x86_64<size>::optimize_tls_reloc(bool is_final, int r_type)
2e30d253 2107{
2e30d253
ILT		 2108 // If we are generating a shared library, then we can't do anything
2109 // in the linker.
8851ecca 2110 if (parameters->options().shared())
e041f13d 2111 return tls::TLSOPT_NONE;
2e30d253
ILT		 2112
2113 switch (r_type)
2114 {
2115 case elfcpp::R_X86_64_TLSGD:
e041f13d
ILT		 2116 case elfcpp::R_X86_64_GOTPC32_TLSDESC:
2117 case elfcpp::R_X86_64_TLSDESC_CALL:
2118 // These are General-Dynamic which permits fully general TLS
2e30d253
ILT		 2119 // access. Since we know that we are generating an executable,
2120 // we can convert this to Initial-Exec. If we also know that
2121 // this is a local symbol, we can further switch to Local-Exec.
2122 if (is_final)
e041f13d
ILT		 2123 return tls::TLSOPT_TO_LE;
2124 return tls::TLSOPT_TO_IE;
2e30d253 2125
d61c17ea 2126 case elfcpp::R_X86_64_TLSLD:
2e30d253
ILT		 2127 // This is Local-Dynamic, which refers to a local symbol in the
2128 // dynamic TLS block. Since we know that we generating an
2129 // executable, we can switch to Local-Exec.
e041f13d 2130 return tls::TLSOPT_TO_LE;
2e30d253 2131
0ffd9845 2132 case elfcpp::R_X86_64_DTPOFF32:
0ffd9845
ILT		 2133 case elfcpp::R_X86_64_DTPOFF64:
2134 // Another Local-Dynamic reloc.
e041f13d 2135 return tls::TLSOPT_TO_LE;
0ffd9845 2136
d61c17ea 2137 case elfcpp::R_X86_64_GOTTPOFF:
2e30d253
ILT		 2138 // These are Initial-Exec relocs which get the thread offset
2139 // from the GOT. If we know that we are linking against the
2140 // local symbol, we can switch to Local-Exec, which links the
2141 // thread offset into the instruction.
2142 if (is_final)
e041f13d
ILT		 2143 return tls::TLSOPT_TO_LE;
2144 return tls::TLSOPT_NONE;
2e30d253 2145
d61c17ea 2146 case elfcpp::R_X86_64_TPOFF32:
2e30d253
ILT		 2147 // When we already have Local-Exec, there is nothing further we
2148 // can do.
e041f13d 2149 return tls::TLSOPT_NONE;
2e30d253
ILT		 2150
2151 default:
2152 gold_unreachable();
2153 }
2e30d253
ILT		 2154}
2155
95a2c8d6
RS		 2156// Get the Reference_flags for a particular relocation.
2157
fc51264f 2158template<int size>
95a2c8d6 2159int
fc51264f 2160Target_x86_64<size>::Scan::get_reference_flags(unsigned int r_type)
95a2c8d6
RS		 2161{
2162 switch (r_type)
2163 {
2164 case elfcpp::R_X86_64_NONE:
2165 case elfcpp::R_X86_64_GNU_VTINHERIT:
2166 case elfcpp::R_X86_64_GNU_VTENTRY:
2167 case elfcpp::R_X86_64_GOTPC32:
2168 case elfcpp::R_X86_64_GOTPC64:
2169 // No symbol reference.
2170 return 0;
2171
2172 case elfcpp::R_X86_64_64:
2173 case elfcpp::R_X86_64_32:
2174 case elfcpp::R_X86_64_32S:
2175 case elfcpp::R_X86_64_16:
2176 case elfcpp::R_X86_64_8:
2177 return Symbol::ABSOLUTE_REF;
2178
2179 case elfcpp::R_X86_64_PC64:
2180 case elfcpp::R_X86_64_PC32:
f49fe902 2181 case elfcpp::R_X86_64_PC32_BND:
95a2c8d6
RS		 2182 case elfcpp::R_X86_64_PC16:
2183 case elfcpp::R_X86_64_PC8:
2184 case elfcpp::R_X86_64_GOTOFF64:
2185 return Symbol::RELATIVE_REF;
2186
2187 case elfcpp::R_X86_64_PLT32:
f49fe902 2188 case elfcpp::R_X86_64_PLT32_BND:
95a2c8d6
RS		 2189 case elfcpp::R_X86_64_PLTOFF64:
2190 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
2191
2192 case elfcpp::R_X86_64_GOT64:
2193 case elfcpp::R_X86_64_GOT32:
2194 case elfcpp::R_X86_64_GOTPCREL64:
2195 case elfcpp::R_X86_64_GOTPCREL:
2891b491
L		 2196 case elfcpp::R_X86_64_GOTPCRELX:
2197 case elfcpp::R_X86_64_REX_GOTPCRELX:
95a2c8d6
RS		 2198 case elfcpp::R_X86_64_GOTPLT64:
2199 // Absolute in GOT.
2200 return Symbol::ABSOLUTE_REF;
2201
2202 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2203 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
2204 case elfcpp::R_X86_64_TLSDESC_CALL:
2205 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
2206 case elfcpp::R_X86_64_DTPOFF32:
2207 case elfcpp::R_X86_64_DTPOFF64:
2208 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2209 case elfcpp::R_X86_64_TPOFF32: // Local-exec
2210 return Symbol::TLS_REF;
2211
2212 case elfcpp::R_X86_64_COPY:
2213 case elfcpp::R_X86_64_GLOB_DAT:
2214 case elfcpp::R_X86_64_JUMP_SLOT:
2215 case elfcpp::R_X86_64_RELATIVE:
2216 case elfcpp::R_X86_64_IRELATIVE:
2217 case elfcpp::R_X86_64_TPOFF64:
2218 case elfcpp::R_X86_64_DTPMOD64:
2219 case elfcpp::R_X86_64_TLSDESC:
2220 case elfcpp::R_X86_64_SIZE32:
2221 case elfcpp::R_X86_64_SIZE64:
2222 default:
2223 // Not expected. We will give an error later.
2224 return 0;
2225 }
2226}
2227
e041f13d
ILT		 2228// Report an unsupported relocation against a local symbol.
2229
fc51264f 2230template<int size>
e041f13d 2231void
fc51264f
L		 2232Target_x86_64<size>::Scan::unsupported_reloc_local(
2233 Sized_relobj_file<size, false>* object,
6fa2a40b 2234 unsigned int r_type)
e041f13d 2235{
75f2446e
ILT		 2236 gold_error(_("%s: unsupported reloc %u against local symbol"),
2237 object->name().c_str(), r_type);
e041f13d
ILT		 2238}
2239
a036edd8
ILT		 2240// We are about to emit a dynamic relocation of type R_TYPE. If the
2241// dynamic linker does not support it, issue an error. The GNU linker
2242// only issues a non-PIC error for an allocated read-only section.
2243// Here we know the section is allocated, but we don't know that it is
2244// read-only. But we check for all the relocation types which the
2245// glibc dynamic linker supports, so it seems appropriate to issue an
a29b0dad
ILT		 2246// error even if the section is not read-only. If GSYM is not NULL,
2247// it is the symbol the relocation is against; if it is NULL, the
2248// relocation is against a local symbol.
a036edd8 2249
fc51264f 2250template<int size>
a036edd8 2251void
fc51264f
L		 2252Target_x86_64<size>::Scan::check_non_pic(Relobj* object, unsigned int r_type,
2253 Symbol* gsym)
a036edd8
ILT		 2254{
2255 switch (r_type)
2256 {
2fbb4320
ILT		 2257 // These are the relocation types supported by glibc for x86_64
2258 // which should always work.
a036edd8 2259 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 2260 case elfcpp::R_X86_64_IRELATIVE:
a036edd8
ILT		 2261 case elfcpp::R_X86_64_GLOB_DAT:
2262 case elfcpp::R_X86_64_JUMP_SLOT:
2263 case elfcpp::R_X86_64_DTPMOD64:
2264 case elfcpp::R_X86_64_DTPOFF64:
2265 case elfcpp::R_X86_64_TPOFF64:
2266 case elfcpp::R_X86_64_64:
2fbb4320
ILT		 2267 case elfcpp::R_X86_64_COPY:
2268 return;
2269
2270 // glibc supports these reloc types, but they can overflow.
a036edd8 2271 case elfcpp::R_X86_64_PC32:
f49fe902 2272 case elfcpp::R_X86_64_PC32_BND:
a29b0dad
ILT		 2273 // A PC relative reference is OK against a local symbol or if
2274 // the symbol is defined locally.
2275 if (gsym == NULL
2276 || (!gsym->is_from_dynobj()
2277 && !gsym->is_undefined()
2278 && !gsym->is_preemptible()))
2279 return;
2280 /* Fall through. */
2281 case elfcpp::R_X86_64_32:
3660ff06
L		 2282 // R_X86_64_32 is OK for x32.
2283 if (size == 32 && r_type == elfcpp::R_X86_64_32)
2284 return;
2fbb4320
ILT		 2285 if (this->issued_non_pic_error_)
2286 return;
2287 gold_assert(parameters->options().output_is_position_independent());
a29b0dad
ILT		 2288 if (gsym == NULL)
2289 object->error(_("requires dynamic R_X86_64_32 reloc which may "
2290 "overflow at runtime; recompile with -fPIC"));
2291 else
f49fe902
L		 2292 {
2293 const char *r_name;
2294 switch (r_type)
2295 {
2296 case elfcpp::R_X86_64_32:
2297 r_name = "R_X86_64_32";
2298 break;
2299 case elfcpp::R_X86_64_PC32:
2300 r_name = "R_X86_64_PC32";
2301 break;
2302 case elfcpp::R_X86_64_PC32_BND:
2303 r_name = "R_X86_64_PC32_BND";
2304 break;
2305 default:
2306 gold_unreachable();
2307 break;
2308 }
2309 object->error(_("requires dynamic %s reloc against '%s' "
2310 "which may overflow at runtime; recompile "
2311 "with -fPIC"),
2312 r_name, gsym->name());
2313 }
2fbb4320 2314 this->issued_non_pic_error_ = true;
a036edd8
ILT		 2315 return;
2316
2317 default:
2318 // This prevents us from issuing more than one error per reloc
2319 // section. But we can still wind up issuing more than one
2320 // error per object file.
2321 if (this->issued_non_pic_error_)
2e702c99 2322 return;
33aea2fd 2323 gold_assert(parameters->options().output_is_position_independent());
a29b0dad 2324 object->error(_("requires unsupported dynamic reloc %u; "
2e702c99 2325 "recompile with -fPIC"),
a29b0dad 2326 r_type);
a036edd8
ILT		 2327 this->issued_non_pic_error_ = true;
2328 return;
2329
2330 case elfcpp::R_X86_64_NONE:
2331 gold_unreachable();
2332 }
2333}
2334
7223e9ca
ILT		 2335// Return whether we need to make a PLT entry for a relocation of the
2336// given type against a STT_GNU_IFUNC symbol.
2337
fc51264f 2338template<int size>
7223e9ca 2339bool
fc51264f
L		 2340Target_x86_64<size>::Scan::reloc_needs_plt_for_ifunc(
2341 Sized_relobj_file<size, false>* object,
6fa2a40b 2342 unsigned int r_type)
7223e9ca 2343{
95a2c8d6
RS		 2344 int flags = Scan::get_reference_flags(r_type);
2345 if (flags & Symbol::TLS_REF)
2346 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
2e702c99 2347 object->name().c_str(), r_type);
95a2c8d6 2348 return flags != 0;
7223e9ca
ILT		 2349}
2350
2e30d253
ILT		 2351// Scan a relocation for a local symbol.
2352
fc51264f 2353template<int size>
2e30d253 2354inline void
fc51264f
L		 2355Target_x86_64<size>::Scan::local(Symbol_table* symtab,
2356 Layout* layout,
2357 Target_x86_64<size>* target,
2358 Sized_relobj_file<size, false>* object,
2359 unsigned int data_shndx,
2360 Output_section* output_section,
2361 const elfcpp::Rela<size, false>& reloc,
2362 unsigned int r_type,
bfdfa4cd
AM		 2363 const elfcpp::Sym<size, false>& lsym,
2364 bool is_discarded)
2e30d253 2365{
bfdfa4cd
AM		 2366 if (is_discarded)
2367 return;
2368
7223e9ca 2369 // A local STT_GNU_IFUNC symbol may require a PLT entry.
397b129b
CC		 2370 bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC;
2371 if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type))
7223e9ca 2372 {
fc51264f 2373 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
7223e9ca
ILT		 2374 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
2375 }
2376
2e30d253
ILT		 2377 switch (r_type)
2378 {
2379 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 2380 case elfcpp::R_X86_64_GNU_VTINHERIT:
2381 case elfcpp::R_X86_64_GNU_VTENTRY:
2e30d253
ILT		 2382 break;
2383
2384 case elfcpp::R_X86_64_64:
d61c6bd4 2385 // If building a shared library (or a position-independent
dceae3c1
ILT		 2386 // executable), we need to create a dynamic relocation for this
2387 // location. The relocation applied at link time will apply the
2388 // link-time value, so we flag the location with an
2389 // R_X86_64_RELATIVE relocation so the dynamic loader can
d61c6bd4 2390 // relocate it easily.
8851ecca 2391 if (parameters->options().output_is_position_independent())
2e702c99
RM		 2392 {
2393 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2394 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7223e9ca 2395 rela_dyn->add_local_relative(object, r_sym,
62fe925a 2396 (size == 32
fd885f3a
L		 2397 ? elfcpp::R_X86_64_RELATIVE64
2398 : elfcpp::R_X86_64_RELATIVE),
7223e9ca
ILT		 2399 output_section, data_shndx,
2400 reloc.get_r_offset(),
397b129b 2401 reloc.get_r_addend(), is_ifunc);
2e702c99 2402 }
d61c6bd4
ILT		 2403 break;
2404
2e30d253
ILT		 2405 case elfcpp::R_X86_64_32:
2406 case elfcpp::R_X86_64_32S:
2407 case elfcpp::R_X86_64_16:
2408 case elfcpp::R_X86_64_8:
96f2030e 2409 // If building a shared library (or a position-independent
dceae3c1
ILT		 2410 // executable), we need to create a dynamic relocation for this
2411 // location. We can't use an R_X86_64_RELATIVE relocation
2412 // because that is always a 64-bit relocation.
8851ecca 2413 if (parameters->options().output_is_position_independent())
2e702c99 2414 {
3660ff06
L		 2415 // Use R_X86_64_RELATIVE relocation for R_X86_64_32 under x32.
2416 if (size == 32 && r_type == elfcpp::R_X86_64_32)
2417 {
2418 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2419 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2420 rela_dyn->add_local_relative(object, r_sym,
2421 elfcpp::R_X86_64_RELATIVE,
2422 output_section, data_shndx,
2423 reloc.get_r_offset(),
2424 reloc.get_r_addend(), is_ifunc);
2425 break;
2426 }
2427
2e702c99 2428 this->check_non_pic(object, r_type, NULL);
a036edd8 2429
2e702c99 2430 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
fc51264f 2431 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2e702c99 2432 if (lsym.get_st_type() != elfcpp::STT_SECTION)
d491d34e
ILT		 2433 rela_dyn->add_local(object, r_sym, r_type, output_section,
2434 data_shndx, reloc.get_r_offset(),
2435 reloc.get_r_addend());
2e702c99
RM		 2436 else
2437 {
2438 gold_assert(lsym.get_st_value() == 0);
d491d34e
ILT		 2439 unsigned int shndx = lsym.get_st_shndx();
2440 bool is_ordinary;
2441 shndx = object->adjust_sym_shndx(r_sym, shndx,
2442 &is_ordinary);
2443 if (!is_ordinary)
2444 object->error(_("section symbol %u has bad shndx %u"),
2445 r_sym, shndx);
2446 else
2447 rela_dyn->add_local_section(object, shndx,
2448 r_type, output_section,
2449 data_shndx, reloc.get_r_offset(),
2450 reloc.get_r_addend());
2e702c99
RM		 2451 }
2452 }
2e30d253
ILT		 2453 break;
2454
2455 case elfcpp::R_X86_64_PC64:
2456 case elfcpp::R_X86_64_PC32:
f49fe902 2457 case elfcpp::R_X86_64_PC32_BND:
2e30d253
ILT		 2458 case elfcpp::R_X86_64_PC16:
2459 case elfcpp::R_X86_64_PC8:
2460 break;
2461
f389a824 2462 case elfcpp::R_X86_64_PLT32:
f49fe902 2463 case elfcpp::R_X86_64_PLT32_BND:
f389a824
ILT		 2464 // Since we know this is a local symbol, we can handle this as a
2465 // PC32 reloc.
2466 break;
2467
fdc2f80f 2468 case elfcpp::R_X86_64_GOTPC32:
e822f2b1 2469 case elfcpp::R_X86_64_GOTOFF64:
fdc2f80f
ILT		 2470 case elfcpp::R_X86_64_GOTPC64:
2471 case elfcpp::R_X86_64_PLTOFF64:
2e30d253
ILT		 2472 // We need a GOT section.
2473 target->got_section(symtab, layout);
ee9e9e86
ILT		 2474 // For PLTOFF64, we'd normally want a PLT section, but since we
2475 // know this is a local symbol, no PLT is needed.
2e30d253
ILT		 2476 break;
2477
0ffd9845
ILT		 2478 case elfcpp::R_X86_64_GOT64:
2479 case elfcpp::R_X86_64_GOT32:
2480 case elfcpp::R_X86_64_GOTPCREL64:
2481 case elfcpp::R_X86_64_GOTPCREL:
2891b491
L		 2482 case elfcpp::R_X86_64_GOTPCRELX:
2483 case elfcpp::R_X86_64_REX_GOTPCRELX:
ee9e9e86 2484 case elfcpp::R_X86_64_GOTPLT64:
0ffd9845 2485 {
1fa29f10 2486 // The symbol requires a GOT section.
2e702c99 2487 Output_data_got<64, false>* got = target->got_section(symtab, layout);
1fa29f10
IT		 2488
2489 // If the relocation symbol isn't IFUNC,
2490 // and is local, then we will convert
2491 // mov foo@GOTPCREL(%rip), %reg
2492 // to lea foo(%rip), %reg.
2493 // in Relocate::relocate.
2891b491
L		 2494 if ((r_type == elfcpp::R_X86_64_GOTPCREL
2495 || r_type == elfcpp::R_X86_64_GOTPCRELX
2496 || r_type == elfcpp::R_X86_64_REX_GOTPCRELX)
1fa29f10
IT		 2497 && reloc.get_r_offset() >= 2
2498 && !is_ifunc)
2499 {
2500 section_size_type stype;
2501 const unsigned char* view = object->section_contents(data_shndx,
2502 &stype, true);
2503 if (view[reloc.get_r_offset() - 2] == 0x8b)
2504 break;
2505 }
2506
2507
2508 // The symbol requires a GOT entry.
2e702c99 2509 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
7223e9ca
ILT		 2510
2511 // For a STT_GNU_IFUNC symbol we want the PLT offset. That
2512 // lets function pointers compare correctly with shared
2513 // libraries. Otherwise we would need an IRELATIVE reloc.
2514 bool is_new;
397b129b 2515 if (is_ifunc)
7223e9ca
ILT		 2516 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
2517 else
2518 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
2e702c99
RM		 2519 if (is_new)
2520 {
2521 // If we are generating a shared object, we need to add a
2522 // dynamic relocation for this symbol's GOT entry.
2523 if (parameters->options().output_is_position_independent())
2524 {
2525 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7bf1f802
ILT		 2526 // R_X86_64_RELATIVE assumes a 64-bit relocation.
2527 if (r_type != elfcpp::R_X86_64_GOT32)
7223e9ca
ILT		 2528 {
2529 unsigned int got_offset =
2530 object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
2531 rela_dyn->add_local_relative(object, r_sym,
2532 elfcpp::R_X86_64_RELATIVE,
397b129b 2533 got, got_offset, 0, is_ifunc);
7223e9ca 2534 }
2e702c99
RM		 2535 else
2536 {
2537 this->check_non_pic(object, r_type, NULL);
2538
2539 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
2540 rela_dyn->add_local(
2541 object, r_sym, r_type, got,
2542 object->local_got_offset(r_sym, GOT_TYPE_STANDARD), 0);
2543 }
2544 }
2545 }
2546 // For GOTPLT64, we'd normally want a PLT section, but since
2547 // we know this is a local symbol, no PLT is needed.
0ffd9845
ILT		 2548 }
2549 break;
2550
2e30d253
ILT		 2551 case elfcpp::R_X86_64_COPY:
2552 case elfcpp::R_X86_64_GLOB_DAT:
2553 case elfcpp::R_X86_64_JUMP_SLOT:
2554 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 2555 case elfcpp::R_X86_64_IRELATIVE:
d61c17ea 2556 // These are outstanding tls relocs, which are unexpected when linking
2e30d253 2557 case elfcpp::R_X86_64_TPOFF64:
2e30d253 2558 case elfcpp::R_X86_64_DTPMOD64:
2e30d253 2559 case elfcpp::R_X86_64_TLSDESC:
75f2446e
ILT		 2560 gold_error(_("%s: unexpected reloc %u in object file"),
2561 object->name().c_str(), r_type);
2e30d253
ILT		 2562 break;
2563
d61c17ea 2564 // These are initial tls relocs, which are expected when linking
56622147
ILT		 2565 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2566 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
e041f13d 2567 case elfcpp::R_X86_64_TLSDESC_CALL:
56622147 2568 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
0ffd9845
ILT		 2569 case elfcpp::R_X86_64_DTPOFF32:
2570 case elfcpp::R_X86_64_DTPOFF64:
56622147
ILT		 2571 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2572 case elfcpp::R_X86_64_TPOFF32: // Local-exec
2e30d253 2573 {
8851ecca 2574 bool output_is_shared = parameters->options().shared();
e041f13d 2575 const tls::Tls_optimization optimized_type
2e702c99 2576 = Target_x86_64<size>::optimize_tls_reloc(!output_is_shared,
fc51264f 2577 r_type);
2e30d253
ILT		 2578 switch (r_type)
2579 {
2e702c99
RM		 2580 case elfcpp::R_X86_64_TLSGD: // General-dynamic
2581 if (optimized_type == tls::TLSOPT_NONE)
2582 {
2583 // Create a pair of GOT entries for the module index and
2584 // dtv-relative offset.
2585 Output_data_got<64, false>* got
2586 = target->got_section(symtab, layout);
2587 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
d491d34e
ILT		 2588 unsigned int shndx = lsym.get_st_shndx();
2589 bool is_ordinary;
2590 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
2591 if (!is_ordinary)
2592 object->error(_("local symbol %u has bad shndx %u"),
2593 r_sym, shndx);
2e702c99 2594 else
83896202
ILT		 2595 got->add_local_pair_with_rel(object, r_sym,
2596 shndx,
2597 GOT_TYPE_TLS_PAIR,
2598 target->rela_dyn_section(layout),
bd73a62d 2599 elfcpp::R_X86_64_DTPMOD64);
2e702c99
RM		 2600 }
2601 else if (optimized_type != tls::TLSOPT_TO_LE)
7bf1f802 2602 unsupported_reloc_local(object, r_type);
2e702c99 2603 break;
7bf1f802 2604
2e702c99
RM		 2605 case elfcpp::R_X86_64_GOTPC32_TLSDESC:
2606 target->define_tls_base_symbol(symtab, layout);
c2b45e22
CC		 2607 if (optimized_type == tls::TLSOPT_NONE)
2608 {
2e702c99
RM		 2609 // Create reserved PLT and GOT entries for the resolver.
2610 target->reserve_tlsdesc_entries(symtab, layout);
2611
2612 // Generate a double GOT entry with an
2613 // R_X86_64_TLSDESC reloc. The R_X86_64_TLSDESC reloc
2614 // is resolved lazily, so the GOT entry needs to be in
2615 // an area in .got.plt, not .got. Call got_section to
2616 // make sure the section has been created.
a8df5856 2617 target->got_section(symtab, layout);
2e702c99
RM		 2618 Output_data_got<64, false>* got = target->got_tlsdesc_section();
2619 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
e291e7b9
ILT		 2620 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC))
2621 {
2622 unsigned int got_offset = got->add_constant(0);
2623 got->add_constant(0);
2624 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC,
2625 got_offset);
2626 Reloc_section* rt = target->rela_tlsdesc_section(layout);
2627 // We store the arguments we need in a vector, and
2628 // use the index into the vector as the parameter
2629 // to pass to the target specific routines.
2630 uintptr_t intarg = target->add_tlsdesc_info(object, r_sym);
2631 void* arg = reinterpret_cast<void*>(intarg);
2632 rt->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
2633 got, got_offset, 0);
2634 }
c2b45e22
CC		 2635 }
2636 else if (optimized_type != tls::TLSOPT_TO_LE)
56622147 2637 unsupported_reloc_local(object, r_type);
2e30d253
ILT		 2638 break;
2639
2e702c99 2640 case elfcpp::R_X86_64_TLSDESC_CALL:
c2b45e22
CC		 2641 break;
2642
2e702c99 2643 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
7bf1f802
ILT		 2644 if (optimized_type == tls::TLSOPT_NONE)
2645 {
2e702c99
RM		 2646 // Create a GOT entry for the module index.
2647 target->got_mod_index_entry(symtab, layout, object);
7bf1f802
ILT		 2648 }
2649 else if (optimized_type != tls::TLSOPT_TO_LE)
2650 unsupported_reloc_local(object, r_type);
2651 break;
2652
2e702c99
RM		 2653 case elfcpp::R_X86_64_DTPOFF32:
2654 case elfcpp::R_X86_64_DTPOFF64:
e041f13d
ILT		 2655 break;
2656
2e702c99 2657 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
535890bb 2658 layout->set_has_static_tls();
2e702c99
RM		 2659 if (optimized_type == tls::TLSOPT_NONE)
2660 {
2661 // Create a GOT entry for the tp-relative offset.
2662 Output_data_got<64, false>* got
2663 = target->got_section(symtab, layout);
2664 unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
2665 got->add_local_with_rel(object, r_sym, GOT_TYPE_TLS_OFFSET,
83896202
ILT		 2666 target->rela_dyn_section(layout),
2667 elfcpp::R_X86_64_TPOFF64);
2e702c99
RM		 2668 }
2669 else if (optimized_type != tls::TLSOPT_TO_LE)
2670 unsupported_reloc_local(object, r_type);
2671 break;
0ffd9845 2672
2e702c99 2673 case elfcpp::R_X86_64_TPOFF32: // Local-exec
535890bb 2674 layout->set_has_static_tls();
2e702c99
RM		 2675 if (output_is_shared)
2676 unsupported_reloc_local(object, r_type);
2e30d253 2677 break;
e041f13d 2678
2e702c99
RM		 2679 default:
2680 gold_unreachable();
2e30d253
ILT		 2681 }
2682 }
2683 break;
2e30d253 2684
fdc2f80f
ILT		 2685 case elfcpp::R_X86_64_SIZE32:
2686 case elfcpp::R_X86_64_SIZE64:
2e30d253 2687 default:
75f2446e
ILT		 2688 gold_error(_("%s: unsupported reloc %u against local symbol"),
2689 object->name().c_str(), r_type);
2e30d253
ILT		 2690 break;
2691 }
2692}
2693
2694
e041f13d
ILT		 2695// Report an unsupported relocation against a global symbol.
2696
fc51264f 2697template<int size>
e041f13d 2698void
fc51264f
L		 2699Target_x86_64<size>::Scan::unsupported_reloc_global(
2700 Sized_relobj_file<size, false>* object,
6fa2a40b
CC		 2701 unsigned int r_type,
2702 Symbol* gsym)
e041f13d 2703{
75f2446e 2704 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
a2b1aa12 2705 object->name().c_str(), r_type, gsym->demangled_name().c_str());
e041f13d
ILT		 2706}
2707
ce97fa81 2708// Returns true if this relocation type could be that of a function pointer.
fc51264f 2709template<int size>
21bb3914 2710inline bool
fc51264f 2711Target_x86_64<size>::Scan::possible_function_pointer_reloc(unsigned int r_type)
21bb3914 2712{
21bb3914
ST		 2713 switch (r_type)
2714 {
2715 case elfcpp::R_X86_64_64:
2716 case elfcpp::R_X86_64_32:
2717 case elfcpp::R_X86_64_32S:
2718 case elfcpp::R_X86_64_16:
2719 case elfcpp::R_X86_64_8:
ce97fa81
ST		 2720 case elfcpp::R_X86_64_GOT64:
2721 case elfcpp::R_X86_64_GOT32:
2722 case elfcpp::R_X86_64_GOTPCREL64:
2723 case elfcpp::R_X86_64_GOTPCREL:
2891b491
L		 2724 case elfcpp::R_X86_64_GOTPCRELX:
2725 case elfcpp::R_X86_64_REX_GOTPCRELX:
ce97fa81 2726 case elfcpp::R_X86_64_GOTPLT64:
21bb3914 2727 {
2e702c99 2728 return true;
21bb3914
ST		 2729 }
2730 }
2731 return false;
2732}
2733
2734// For safe ICF, scan a relocation for a local symbol to check if it
2735// corresponds to a function pointer being taken. In that case mark
2736// the function whose pointer was taken as not foldable.
2737
fc51264f 2738template<int size>
21bb3914 2739inline bool
fc51264f 2740Target_x86_64<size>::Scan::local_reloc_may_be_function_pointer(
21bb3914
ST		 2741 Symbol_table* ,
2742 Layout* ,
fc51264f
L		 2743 Target_x86_64<size>* ,
2744 Sized_relobj_file<size, false>* ,
21bb3914
ST		 2745 unsigned int ,
2746 Output_section* ,
fc51264f 2747 const elfcpp::Rela<size, false>& ,
21bb3914 2748 unsigned int r_type,
fc51264f 2749 const elfcpp::Sym<size, false>&)
21bb3914
ST		 2750{
2751 // When building a shared library, do not fold any local symbols as it is
2752 // not possible to distinguish pointer taken versus a call by looking at
2753 // the relocation types.
2754 return (parameters->options().shared()
2e702c99 2755 || possible_function_pointer_reloc(r_type));
21bb3914
ST		 2756}
2757
2758// For safe ICF, scan a relocation for a global symbol to check if it
2759// corresponds to a function pointer being taken. In that case mark
2760// the function whose pointer was taken as not foldable.
2761
fc51264f 2762template<int size>
21bb3914 2763inline bool
fc51264f 2764Target_x86_64<size>::Scan::global_reloc_may_be_function_pointer(
21bb3914
ST		 2765 Symbol_table*,
2766 Layout* ,
fc51264f
L		 2767 Target_x86_64<size>* ,
2768 Sized_relobj_file<size, false>* ,
21bb3914
ST		 2769 unsigned int ,
2770 Output_section* ,
fc51264f 2771 const elfcpp::Rela<size, false>& ,
21bb3914
ST		 2772 unsigned int r_type,
2773 Symbol* gsym)
2774{
2775 // When building a shared library, do not fold symbols whose visibility
2776 // is hidden, internal or protected.
2777 return ((parameters->options().shared()
2e702c99 2778 && (gsym->visibility() == elfcpp::STV_INTERNAL
21bb3914
ST		 2779 || gsym->visibility() == elfcpp::STV_PROTECTED
2780 || gsym->visibility() == elfcpp::STV_HIDDEN))
2e702c99 2781 || possible_function_pointer_reloc(r_type));
21bb3914
ST		 2782}
2783
2e30d253
ILT		 2784// Scan a relocation for a global symbol.
2785
fc51264f 2786template<int size>
2e30d253 2787inline void
fc51264f 2788Target_x86_64<size>::Scan::global(Symbol_table* symtab,
2e702c99
RM		 2789 Layout* layout,
2790 Target_x86_64<size>* target,
2791 Sized_relobj_file<size, false>* object,
2792 unsigned int data_shndx,
2793 Output_section* output_section,
2794 const elfcpp::Rela<size, false>& reloc,
2795 unsigned int r_type,
2796 Symbol* gsym)
2e30d253 2797{
7223e9ca
ILT		 2798 // A STT_GNU_IFUNC symbol may require a PLT entry.
2799 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2800 && this->reloc_needs_plt_for_ifunc(object, r_type))
2801 target->make_plt_entry(symtab, layout, gsym);
2802
2e30d253
ILT		 2803 switch (r_type)
2804 {
2805 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 2806 case elfcpp::R_X86_64_GNU_VTINHERIT:
2807 case elfcpp::R_X86_64_GNU_VTENTRY:
2e30d253
ILT		 2808 break;
2809
2810 case elfcpp::R_X86_64_64:
2e30d253
ILT		 2811 case elfcpp::R_X86_64_32:
2812 case elfcpp::R_X86_64_32S:
2e30d253 2813 case elfcpp::R_X86_64_16:
2e30d253 2814 case elfcpp::R_X86_64_8:
96f2030e 2815 {
2e702c99
RM		 2816 // Make a PLT entry if necessary.
2817 if (gsym->needs_plt_entry())
2818 {
2819 target->make_plt_entry(symtab, layout, gsym);
2820 // Since this is not a PC-relative relocation, we may be
2821 // taking the address of a function. In that case we need to
2822 // set the entry in the dynamic symbol table to the address of
2823 // the PLT entry.
2824 if (gsym->is_from_dynobj() && !parameters->options().shared())
2825 gsym->set_needs_dynsym_value();
2826 }
2827 // Make a dynamic relocation if necessary.
2828 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2829 {
a82bef93
ST		 2830 if (!parameters->options().output_is_position_independent()
2831 && gsym->may_need_copy_reloc())
2e702c99
RM		 2832 {
2833 target->copy_reloc(symtab, layout, object,
2834 data_shndx, output_section, gsym, reloc);
2835 }
1bae613c
L		 2836 else if (((size == 64 && r_type == elfcpp::R_X86_64_64)
2837 || (size == 32 && r_type == elfcpp::R_X86_64_32))
7223e9ca
ILT		 2838 && gsym->type() == elfcpp::STT_GNU_IFUNC
2839 && gsym->can_use_relative_reloc(false)
2840 && !gsym->is_from_dynobj()
2841 && !gsym->is_undefined()
2842 && !gsym->is_preemptible())
2843 {
2844 // Use an IRELATIVE reloc for a locally defined
2845 // STT_GNU_IFUNC symbol. This makes a function
2846 // address in a PIE executable match the address in a
2847 // shared library that it links against.
67181c72
ILT		 2848 Reloc_section* rela_dyn =
2849 target->rela_irelative_section(layout);
7223e9ca
ILT		 2850 unsigned int r_type = elfcpp::R_X86_64_IRELATIVE;
2851 rela_dyn->add_symbolless_global_addend(gsym, r_type,
2852 output_section, object,
2853 data_shndx,
2854 reloc.get_r_offset(),
2855 reloc.get_r_addend());
2856 }
b14016f0
L		 2857 else if (((size == 64 && r_type == elfcpp::R_X86_64_64)
2858 || (size == 32 && r_type == elfcpp::R_X86_64_32))
2e702c99
RM		 2859 && gsym->can_use_relative_reloc(false))
2860 {
2861 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7223e9ca
ILT		 2862 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
2863 output_section, object,
2864 data_shndx,
2865 reloc.get_r_offset(),
13cf9988 2866 reloc.get_r_addend(), false);
2e702c99
RM		 2867 }
2868 else
2869 {
2870 this->check_non_pic(object, r_type, gsym);
2871 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2872 rela_dyn->add_global(gsym, r_type, output_section, object,
2873 data_shndx, reloc.get_r_offset(),
2874 reloc.get_r_addend());
2875 }
2876 }
d61c6bd4
ILT		 2877 }
2878 break;
2879
2880 case elfcpp::R_X86_64_PC64:
2881 case elfcpp::R_X86_64_PC32:
f49fe902 2882 case elfcpp::R_X86_64_PC32_BND:
d61c6bd4
ILT		 2883 case elfcpp::R_X86_64_PC16:
2884 case elfcpp::R_X86_64_PC8:
2885 {
2e702c99
RM		 2886 // Make a PLT entry if necessary.
2887 if (gsym->needs_plt_entry())
2888 target->make_plt_entry(symtab, layout, gsym);
2889 // Make a dynamic relocation if necessary.
2890 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2891 {
a82bef93
ST		 2892 if (parameters->options().output_is_executable()
2893 && gsym->may_need_copy_reloc())
2e702c99
RM		 2894 {
2895 target->copy_reloc(symtab, layout, object,
2896 data_shndx, output_section, gsym, reloc);
2897 }
2898 else
2899 {
2900 this->check_non_pic(object, r_type, gsym);
2901 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2902 rela_dyn->add_global(gsym, r_type, output_section, object,
2903 data_shndx, reloc.get_r_offset(),
2904 reloc.get_r_addend());
2905 }
2906 }
d61c6bd4 2907 }
2e30d253
ILT		 2908 break;
2909
ff006520 2910 case elfcpp::R_X86_64_GOT64:
2e30d253 2911 case elfcpp::R_X86_64_GOT32:
ff006520
ILT		 2912 case elfcpp::R_X86_64_GOTPCREL64:
2913 case elfcpp::R_X86_64_GOTPCREL:
2891b491
L		 2914 case elfcpp::R_X86_64_GOTPCRELX:
2915 case elfcpp::R_X86_64_REX_GOTPCRELX:
ff006520 2916 case elfcpp::R_X86_64_GOTPLT64:
2e30d253 2917 {
2e702c99
RM		 2918 // The symbol requires a GOT entry.
2919 Output_data_got<64, false>* got = target->got_section(symtab, layout);
1fa29f10
IT		 2920
2921 // If we convert this from
2922 // mov foo@GOTPCREL(%rip), %reg
2923 // to lea foo(%rip), %reg.
2924 // in Relocate::relocate, then there is nothing to do here.
2891b491
L		 2925 if ((r_type == elfcpp::R_X86_64_GOTPCREL
2926 || r_type == elfcpp::R_X86_64_GOTPCRELX
2927 || r_type == elfcpp::R_X86_64_REX_GOTPCRELX)
1fa29f10
IT		 2928 && reloc.get_r_offset() >= 2
2929 && Target_x86_64<size>::can_convert_mov_to_lea(gsym))
2930 {
2931 section_size_type stype;
2932 const unsigned char* view = object->section_contents(data_shndx,
2933 &stype, true);
2934 if (view[reloc.get_r_offset() - 2] == 0x8b)
2935 break;
2936 }
2937
2e702c99 2938 if (gsym->final_value_is_known())
7223e9ca
ILT		 2939 {
2940 // For a STT_GNU_IFUNC symbol we want the PLT address.
2941 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
2942 got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2943 else
2944 got->add_global(gsym, GOT_TYPE_STANDARD);
2945 }
2e702c99
RM		 2946 else
2947 {
2948 // If this symbol is not fully resolved, we need to add a
2949 // dynamic relocation for it.
2950 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
07aa62f2
ILT		 2951
2952 // Use a GLOB_DAT rather than a RELATIVE reloc if:
2953 //
2954 // 1) The symbol may be defined in some other module.
2955 //
2956 // 2) We are building a shared library and this is a
2957 // protected symbol; using GLOB_DAT means that the dynamic
2958 // linker can use the address of the PLT in the main
2959 // executable when appropriate so that function address
2960 // comparisons work.
2961 //
2962 // 3) This is a STT_GNU_IFUNC symbol in position dependent
2963 // code, again so that function address comparisons work.
7223e9ca
ILT		 2964 if (gsym->is_from_dynobj()
2965 || gsym->is_undefined()
2966 || gsym->is_preemptible()
07aa62f2
ILT		 2967 || (gsym->visibility() == elfcpp::STV_PROTECTED
2968 && parameters->options().shared())
7223e9ca
ILT		 2969 || (gsym->type() == elfcpp::STT_GNU_IFUNC
2970 && parameters->options().output_is_position_independent()))
2e702c99 2971 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD, rela_dyn,
83896202 2972 elfcpp::R_X86_64_GLOB_DAT);
2e702c99
RM		 2973 else
2974 {
7223e9ca
ILT		 2975 // For a STT_GNU_IFUNC symbol we want to write the PLT
2976 // offset into the GOT, so that function pointer
2977 // comparisons work correctly.
2978 bool is_new;
2979 if (gsym->type() != elfcpp::STT_GNU_IFUNC)
2980 is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
2981 else
2982 {
2983 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2984 // Tell the dynamic linker to use the PLT address
2985 // when resolving relocations.
2986 if (gsym->is_from_dynobj()
2987 && !parameters->options().shared())
2988 gsym->set_needs_dynsym_value();
2989 }
2e702c99 2990 if (is_new)
7223e9ca
ILT		 2991 {
2992 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
2993 rela_dyn->add_global_relative(gsym,
2994 elfcpp::R_X86_64_RELATIVE,
13cf9988 2995 got, got_off, 0, false);
7223e9ca 2996 }
2e702c99
RM		 2997 }
2998 }
2e30d253
ILT		 2999 }
3000 break;
3001
3002 case elfcpp::R_X86_64_PLT32:
f49fe902 3003 case elfcpp::R_X86_64_PLT32_BND:
2e30d253
ILT		 3004 // If the symbol is fully resolved, this is just a PC32 reloc.
3005 // Otherwise we need a PLT entry.
3006 if (gsym->final_value_is_known())
3007 break;
96f2030e
ILT		 3008 // If building a shared library, we can also skip the PLT entry
3009 // if the symbol is defined in the output file and is protected
3010 // or hidden.
3011 if (gsym->is_defined()
2e702c99
RM		 3012 && !gsym->is_from_dynobj()
3013 && !gsym->is_preemptible())
96f2030e 3014 break;
2e30d253
ILT		 3015 target->make_plt_entry(symtab, layout, gsym);
3016 break;
3017
fdc2f80f 3018 case elfcpp::R_X86_64_GOTPC32:
e822f2b1 3019 case elfcpp::R_X86_64_GOTOFF64:
fdc2f80f
ILT		 3020 case elfcpp::R_X86_64_GOTPC64:
3021 case elfcpp::R_X86_64_PLTOFF64:
2e30d253
ILT		 3022 // We need a GOT section.
3023 target->got_section(symtab, layout);
ee9e9e86
ILT		 3024 // For PLTOFF64, we also need a PLT entry (but only if the
3025 // symbol is not fully resolved).
3026 if (r_type == elfcpp::R_X86_64_PLTOFF64
3027 && !gsym->final_value_is_known())
3028 target->make_plt_entry(symtab, layout, gsym);
2e30d253
ILT		 3029 break;
3030
2e30d253
ILT		 3031 case elfcpp::R_X86_64_COPY:
3032 case elfcpp::R_X86_64_GLOB_DAT:
3033 case elfcpp::R_X86_64_JUMP_SLOT:
3034 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 3035 case elfcpp::R_X86_64_IRELATIVE:
d61c17ea 3036 // These are outstanding tls relocs, which are unexpected when linking
e822f2b1 3037 case elfcpp::R_X86_64_TPOFF64:
2e30d253 3038 case elfcpp::R_X86_64_DTPMOD64:
e822f2b1 3039 case elfcpp::R_X86_64_TLSDESC:
75f2446e
ILT		 3040 gold_error(_("%s: unexpected reloc %u in object file"),
3041 object->name().c_str(), r_type);
2e30d253 3042 break;
2e30d253 3043
d61c17ea 3044 // These are initial tls relocs, which are expected for global()
56622147
ILT		 3045 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
3046 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
e041f13d 3047 case elfcpp::R_X86_64_TLSDESC_CALL:
56622147 3048 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
0ffd9845
ILT		 3049 case elfcpp::R_X86_64_DTPOFF32:
3050 case elfcpp::R_X86_64_DTPOFF64:
56622147
ILT		 3051 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3052 case elfcpp::R_X86_64_TPOFF32: // Local-exec
2e30d253 3053 {
65d92137
CC		 3054 // For the Initial-Exec model, we can treat undef symbols as final
3055 // when building an executable.
3056 const bool is_final = (gsym->final_value_is_known() ||
3057 (r_type == elfcpp::R_X86_64_GOTTPOFF &&
3058 gsym->is_undefined() &&
3059 parameters->options().output_is_executable()));
e041f13d 3060 const tls::Tls_optimization optimized_type
2e702c99 3061 = Target_x86_64<size>::optimize_tls_reloc(is_final, r_type);
2e30d253
ILT		 3062 switch (r_type)
3063 {
2e702c99 3064 case elfcpp::R_X86_64_TLSGD: // General-dynamic
7bf1f802
ILT		 3065 if (optimized_type == tls::TLSOPT_NONE)
3066 {
2e702c99
RM		 3067 // Create a pair of GOT entries for the module index and
3068 // dtv-relative offset.
3069 Output_data_got<64, false>* got
3070 = target->got_section(symtab, layout);
3071 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR,
83896202
ILT		 3072 target->rela_dyn_section(layout),
3073 elfcpp::R_X86_64_DTPMOD64,
3074 elfcpp::R_X86_64_DTPOFF64);
7bf1f802
ILT		 3075 }
3076 else if (optimized_type == tls::TLSOPT_TO_IE)
3077 {
2e702c99
RM		 3078 // Create a GOT entry for the tp-relative offset.
3079 Output_data_got<64, false>* got
3080 = target->got_section(symtab, layout);
3081 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
83896202
ILT		 3082 target->rela_dyn_section(layout),
3083 elfcpp::R_X86_64_TPOFF64);
7bf1f802
ILT		 3084 }
3085 else if (optimized_type != tls::TLSOPT_TO_LE)
3086 unsupported_reloc_global(object, r_type, gsym);
3087 break;
3088
2e702c99
RM		 3089 case elfcpp::R_X86_64_GOTPC32_TLSDESC:
3090 target->define_tls_base_symbol(symtab, layout);
c2b45e22
CC		 3091 if (optimized_type == tls::TLSOPT_NONE)
3092 {
2e702c99
RM		 3093 // Create reserved PLT and GOT entries for the resolver.
3094 target->reserve_tlsdesc_entries(symtab, layout);
3095
3096 // Create a double GOT entry with an R_X86_64_TLSDESC
3097 // reloc. The R_X86_64_TLSDESC reloc is resolved
3098 // lazily, so the GOT entry needs to be in an area in
3099 // .got.plt, not .got. Call got_section to make sure
3100 // the section has been created.
a8df5856 3101 target->got_section(symtab, layout);
2e702c99 3102 Output_data_got<64, false>* got = target->got_tlsdesc_section();
ca09d69a 3103 Reloc_section* rt = target->rela_tlsdesc_section(layout);
2e702c99 3104 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt,
83896202 3105 elfcpp::R_X86_64_TLSDESC, 0);
c2b45e22
CC		 3106 }
3107 else if (optimized_type == tls::TLSOPT_TO_IE)
3108 {
2e702c99
RM		 3109 // Create a GOT entry for the tp-relative offset.
3110 Output_data_got<64, false>* got
3111 = target->got_section(symtab, layout);
3112 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
83896202
ILT		 3113 target->rela_dyn_section(layout),
3114 elfcpp::R_X86_64_TPOFF64);
c2b45e22
CC		 3115 }
3116 else if (optimized_type != tls::TLSOPT_TO_LE)
56622147 3117 unsupported_reloc_global(object, r_type, gsym);
2e30d253
ILT		 3118 break;
3119
2e702c99 3120 case elfcpp::R_X86_64_TLSDESC_CALL:
c2b45e22
CC		 3121 break;
3122
2e702c99 3123 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
7bf1f802
ILT		 3124 if (optimized_type == tls::TLSOPT_NONE)
3125 {
2e702c99
RM		 3126 // Create a GOT entry for the module index.
3127 target->got_mod_index_entry(symtab, layout, object);
7bf1f802
ILT		 3128 }
3129 else if (optimized_type != tls::TLSOPT_TO_LE)
3130 unsupported_reloc_global(object, r_type, gsym);
3131 break;
3132
2e702c99
RM		 3133 case elfcpp::R_X86_64_DTPOFF32:
3134 case elfcpp::R_X86_64_DTPOFF64:
e041f13d
ILT		 3135 break;
3136
2e702c99 3137 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
535890bb 3138 layout->set_has_static_tls();
2e702c99
RM		 3139 if (optimized_type == tls::TLSOPT_NONE)
3140 {
3141 // Create a GOT entry for the tp-relative offset.
3142 Output_data_got<64, false>* got
3143 = target->got_section(symtab, layout);
3144 got->add_global_with_rel(gsym, GOT_TYPE_TLS_OFFSET,
83896202
ILT		 3145 target->rela_dyn_section(layout),
3146 elfcpp::R_X86_64_TPOFF64);
2e702c99
RM		 3147 }
3148 else if (optimized_type != tls::TLSOPT_TO_LE)
3149 unsupported_reloc_global(object, r_type, gsym);
3150 break;
0ffd9845 3151
2e702c99 3152 case elfcpp::R_X86_64_TPOFF32: // Local-exec
535890bb 3153 layout->set_has_static_tls();
2e702c99 3154 if (parameters->options().shared())
b1759dce 3155 unsupported_reloc_global(object, r_type, gsym);
2e30d253 3156 break;
e041f13d 3157
2e702c99
RM		 3158 default:
3159 gold_unreachable();
2e30d253
ILT		 3160 }
3161 }
3162 break;
fdc2f80f
ILT		 3163
3164 case elfcpp::R_X86_64_SIZE32:
3165 case elfcpp::R_X86_64_SIZE64:
2e30d253 3166 default:
75f2446e 3167 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
a2b1aa12 3168 object->name().c_str(), r_type,
2e702c99 3169 gsym->demangled_name().c_str());
2e30d253
ILT		 3170 break;
3171 }
3172}
3173
fc51264f 3174template<int size>
6d03d481 3175void
fc51264f
L		 3176Target_x86_64<size>::gc_process_relocs(Symbol_table* symtab,
3177 Layout* layout,
3178 Sized_relobj_file<size, false>* object,
3179 unsigned int data_shndx,
3180 unsigned int sh_type,
3181 const unsigned char* prelocs,
3182 size_t reloc_count,
3183 Output_section* output_section,
3184 bool needs_special_offset_handling,
3185 size_t local_symbol_count,
3186 const unsigned char* plocal_symbols)
6d03d481
ST		 3187{
3188
3189 if (sh_type == elfcpp::SHT_REL)
3190 {
3191 return;
3192 }
3193
fc51264f 3194 gold::gc_process_relocs<size, false, Target_x86_64<size>, elfcpp::SHT_RELA,
2e702c99 3195 typename Target_x86_64<size>::Scan,
618d6666 3196 typename Target_x86_64<size>::Relocatable_size_for_reloc>(
6d03d481
ST		 3197 symtab,
3198 layout,
3199 this,
3200 object,
3201 data_shndx,
3202 prelocs,
3203 reloc_count,
3204 output_section,
3205 needs_special_offset_handling,
3206 local_symbol_count,
3207 plocal_symbols);
2e702c99 3208
6d03d481 3209}
2e30d253
ILT		 3210// Scan relocations for a section.
3211
fc51264f 3212template<int size>
2e30d253 3213void
fc51264f
L		 3214Target_x86_64<size>::scan_relocs(Symbol_table* symtab,
3215 Layout* layout,
3216 Sized_relobj_file<size, false>* object,
3217 unsigned int data_shndx,
3218 unsigned int sh_type,
3219 const unsigned char* prelocs,
3220 size_t reloc_count,
3221 Output_section* output_section,
3222 bool needs_special_offset_handling,
3223 size_t local_symbol_count,
3224 const unsigned char* plocal_symbols)
2e30d253
ILT		 3225{
3226 if (sh_type == elfcpp::SHT_REL)
3227 {
75f2446e
ILT		 3228 gold_error(_("%s: unsupported REL reloc section"),
3229 object->name().c_str());
3230 return;
2e30d253
ILT		 3231 }
3232
fc51264f 3233 gold::scan_relocs<size, false, Target_x86_64<size>, elfcpp::SHT_RELA,
618d6666 3234 typename Target_x86_64<size>::Scan>(
2e30d253
ILT		 3235 symtab,
3236 layout,
3237 this,
3238 object,
3239 data_shndx,
3240 prelocs,
3241 reloc_count,
730cdc88
ILT		 3242 output_section,
3243 needs_special_offset_handling,
2e30d253 3244 local_symbol_count,
730cdc88 3245 plocal_symbols);
2e30d253
ILT		 3246}
3247
3248// Finalize the sections.
3249
fc51264f 3250template<int size>
2e30d253 3251void
fc51264f 3252Target_x86_64<size>::do_finalize_sections(
f59f41f3
DK		 3253 Layout* layout,
3254 const Input_objects*,
e785ec03 3255 Symbol_table* symtab)
2e30d253 3256{
ea715a34
ILT		 3257 const Reloc_section* rel_plt = (this->plt_ == NULL
3258 ? NULL
e291e7b9 3259 : this->plt_->rela_plt());
ea715a34 3260 layout->add_target_dynamic_tags(false, this->got_plt_, rel_plt,
612a8d3d 3261 this->rela_dyn_, true, false);
2e702c99 3262
2e30d253
ILT		 3263 // Fill in some more dynamic tags.
3264 Output_data_dynamic* const odyn = layout->dynamic_data();
3265 if (odyn != NULL)
3266 {
22b127cc 3267 if (this->plt_ != NULL
ea715a34
ILT		 3268 && this->plt_->output_section() != NULL
3269 && this->plt_->has_tlsdesc_entry())
2e30d253 3270 {
ea715a34
ILT		 3271 unsigned int plt_offset = this->plt_->get_tlsdesc_plt_offset();
3272 unsigned int got_offset = this->plt_->get_tlsdesc_got_offset();
3273 this->got_->finalize_data_size();
3274 odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_PLT,
3275 this->plt_, plt_offset);
3276 odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_GOT,
3277 this->got_, got_offset);
2e30d253
ILT		 3278 }
3279 }
3280
3281 // Emit any relocs we saved in an attempt to avoid generating COPY
3282 // relocs.
12c0daef
ILT		 3283 if (this->copy_relocs_.any_saved_relocs())
3284 this->copy_relocs_.emit(this->rela_dyn_section(layout));
e785ec03
ILT		 3285
3286 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
3287 // the .got.plt section.
3288 Symbol* sym = this->global_offset_table_;
3289 if (sym != NULL)
3290 {
3291 uint64_t data_size = this->got_plt_->current_data_size();
fc51264f 3292 symtab->get_sized_symbol<size>(sym)->set_symsize(data_size);
e785ec03 3293 }
28a13fec 3294
67181c72
ILT		 3295 if (parameters->doing_static_link()
3296 && (this->plt_ == NULL || !this->plt_->has_irelative_section()))
28a13fec
ILT		 3297 {
3298 // If linking statically, make sure that the __rela_iplt symbols
3299 // were defined if necessary, even if we didn't create a PLT.
3300 static const Define_symbol_in_segment syms[] =
3301 {
3302 {
3303 "__rela_iplt_start", // name
3304 elfcpp::PT_LOAD, // segment_type
3305 elfcpp::PF_W, // segment_flags_set
3306 elfcpp::PF(0), // segment_flags_clear
3307 0, // value
3308 0, // size
3309 elfcpp::STT_NOTYPE, // type
3310 elfcpp::STB_GLOBAL, // binding
3311 elfcpp::STV_HIDDEN, // visibility
3312 0, // nonvis
3313 Symbol::SEGMENT_START, // offset_from_base
3314 true // only_if_ref
3315 },
3316 {
3317 "__rela_iplt_end", // name
3318 elfcpp::PT_LOAD, // segment_type
3319 elfcpp::PF_W, // segment_flags_set
3320 elfcpp::PF(0), // segment_flags_clear
3321 0, // value
3322 0, // size
3323 elfcpp::STT_NOTYPE, // type
3324 elfcpp::STB_GLOBAL, // binding
3325 elfcpp::STV_HIDDEN, // visibility
3326 0, // nonvis
3327 Symbol::SEGMENT_START, // offset_from_base
3328 true // only_if_ref
3329 }
3330 };
3331
3332 symtab->define_symbols(layout, 2, syms,
3333 layout->script_options()->saw_sections_clause());
3334 }
2e30d253
ILT		 3335}
3336
3337// Perform a relocation.
3338
fc51264f 3339template<int size>
2e30d253 3340inline bool
fc51264f
L		 3341Target_x86_64<size>::Relocate::relocate(
3342 const Relocate_info<size, false>* relinfo,
3343 Target_x86_64<size>* target,
3344 Output_section*,
3345 size_t relnum,
3346 const elfcpp::Rela<size, false>& rela,
3347 unsigned int r_type,
3348 const Sized_symbol<size>* gsym,
3349 const Symbol_value<size>* psymval,
3350 unsigned char* view,
3351 typename elfcpp::Elf_types<size>::Elf_Addr address,
3352 section_size_type view_size)
2e30d253
ILT		 3353{
3354 if (this->skip_call_tls_get_addr_)
3355 {
5efc7cd2 3356 if ((r_type != elfcpp::R_X86_64_PLT32
f49fe902
L		 3357 && r_type != elfcpp::R_X86_64_PLT32_BND
3358 && r_type != elfcpp::R_X86_64_PC32_BND
2e702c99 3359 && r_type != elfcpp::R_X86_64_PC32)
2e30d253 3360 || gsym == NULL
0ffd9845 3361 || strcmp(gsym->name(), "__tls_get_addr") != 0)
2e30d253 3362 {
75f2446e
ILT		 3363 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3364 _("missing expected TLS relocation"));
3365 }
3366 else
3367 {
3368 this->skip_call_tls_get_addr_ = false;
3369 return false;
2e30d253 3370 }
2e30d253
ILT		 3371 }
3372
0e804863
ILT		 3373 if (view == NULL)
3374 return true;
3375
fc51264f 3376 const Sized_relobj_file<size, false>* object = relinfo->object;
7223e9ca
ILT		 3377
3378 // Pick the value to use for symbols defined in the PLT.
fc51264f 3379 Symbol_value<size> symval;
96f2030e 3380 if (gsym != NULL
95a2c8d6 3381 && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
2e30d253 3382 {
19fec8c1 3383 symval.set_output_value(target->plt_address_for_global(gsym));
2e30d253
ILT		 3384 psymval = &symval;
3385 }
7223e9ca
ILT		 3386 else if (gsym == NULL && psymval->is_ifunc_symbol())
3387 {
fc51264f 3388 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
7223e9ca
ILT		 3389 if (object->local_has_plt_offset(r_sym))
3390 {
19fec8c1 3391 symval.set_output_value(target->plt_address_for_local(object, r_sym));
7223e9ca
ILT		 3392 psymval = &symval;
3393 }
3394 }
2e30d253 3395
0ffd9845
ILT		 3396 const elfcpp::Elf_Xword addend = rela.get_r_addend();
3397
3398 // Get the GOT offset if needed.
96f2030e
ILT		 3399 // The GOT pointer points to the end of the GOT section.
3400 // We need to subtract the size of the GOT section to get
3401 // the actual offset to use in the relocation.
0ffd9845 3402 bool have_got_offset = false;
c23dd342
L		 3403 // Since the actual offset is always negative, we use signed int to
3404 // support 64-bit GOT relocations.
3405 int got_offset = 0;
0ffd9845
ILT		 3406 switch (r_type)
3407 {
3408 case elfcpp::R_X86_64_GOT32:
3409 case elfcpp::R_X86_64_GOT64:
3410 case elfcpp::R_X86_64_GOTPLT64:
0ffd9845
ILT		 3411 case elfcpp::R_X86_64_GOTPCREL64:
3412 if (gsym != NULL)
2e702c99
RM		 3413 {
3414 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
3415 got_offset = gsym->got_offset(GOT_TYPE_STANDARD) - target->got_size();
3416 }
0ffd9845 3417 else
2e702c99
RM		 3418 {
3419 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3420 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
3421 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
3422 - target->got_size());
3423 }
0ffd9845
ILT		 3424 have_got_offset = true;
3425 break;
3426
3427 default:
3428 break;
3429 }
2e30d253
ILT		 3430
3431 switch (r_type)
3432 {
3433 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 3434 case elfcpp::R_X86_64_GNU_VTINHERIT:
3435 case elfcpp::R_X86_64_GNU_VTENTRY:
2e30d253
ILT		 3436 break;
3437
3438 case elfcpp::R_X86_64_64:
fc51264f 3439 Relocate_functions<size, false>::rela64(view, object, psymval, addend);
2e30d253
ILT		 3440 break;
3441
3442 case elfcpp::R_X86_64_PC64:
fc51264f 3443 Relocate_functions<size, false>::pcrela64(view, object, psymval, addend,
2e702c99 3444 address);
2e30d253
ILT		 3445 break;
3446
3447 case elfcpp::R_X86_64_32:
7bb3655e
ILT		 3448 // FIXME: we need to verify that value + addend fits into 32 bits:
3449 // uint64_t x = value + addend;
3450 // x == static_cast<uint64_t>(static_cast<uint32_t>(x))
3451 // Likewise for other <=32-bit relocations (but see R_X86_64_32S).
fc51264f 3452 Relocate_functions<size, false>::rela32(view, object, psymval, addend);
2e30d253
ILT		 3453 break;
3454
3455 case elfcpp::R_X86_64_32S:
7bb3655e
ILT		 3456 // FIXME: we need to verify that value + addend fits into 32 bits:
3457 // int64_t x = value + addend; // note this quantity is signed!
3458 // x == static_cast<int64_t>(static_cast<int32_t>(x))
fc51264f 3459 Relocate_functions<size, false>::rela32(view, object, psymval, addend);
2e30d253
ILT		 3460 break;
3461
3462 case elfcpp::R_X86_64_PC32:
f49fe902 3463 case elfcpp::R_X86_64_PC32_BND:
fc51264f
L		 3464 Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
3465 address);
2e30d253
ILT		 3466 break;
3467
3468 case elfcpp::R_X86_64_16:
fc51264f 3469 Relocate_functions<size, false>::rela16(view, object, psymval, addend);
2e30d253
ILT		 3470 break;
3471
3472 case elfcpp::R_X86_64_PC16:
fc51264f
L		 3473 Relocate_functions<size, false>::pcrela16(view, object, psymval, addend,
3474 address);
2e30d253
ILT		 3475 break;
3476
3477 case elfcpp::R_X86_64_8:
fc51264f 3478 Relocate_functions<size, false>::rela8(view, object, psymval, addend);
2e30d253
ILT		 3479 break;
3480
3481 case elfcpp::R_X86_64_PC8:
fc51264f
L		 3482 Relocate_functions<size, false>::pcrela8(view, object, psymval, addend,
3483 address);
2e30d253
ILT		 3484 break;
3485
3486 case elfcpp::R_X86_64_PLT32:
f49fe902 3487 case elfcpp::R_X86_64_PLT32_BND:
f389a824 3488 gold_assert(gsym == NULL
2e702c99 3489 || gsym->has_plt_offset()
99f8faca
ILT		 3490 || gsym->final_value_is_known()
3491 || (gsym->is_defined()
3492 && !gsym->is_from_dynobj()
3493 && !gsym->is_preemptible()));
ee9e9e86
ILT		 3494 // Note: while this code looks the same as for R_X86_64_PC32, it
3495 // behaves differently because psymval was set to point to
3496 // the PLT entry, rather than the symbol, in Scan::global().
fc51264f
L		 3497 Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
3498 address);
2e30d253
ILT		 3499 break;
3500
ee9e9e86
ILT		 3501 case elfcpp::R_X86_64_PLTOFF64:
3502 {
2e702c99
RM		 3503 gold_assert(gsym);
3504 gold_assert(gsym->has_plt_offset()
3505 || gsym->final_value_is_known());
fc51264f 3506 typename elfcpp::Elf_types<size>::Elf_Addr got_address;
c23dd342
L		 3507 // This is the address of GLOBAL_OFFSET_TABLE.
3508 got_address = target->got_plt_section()->address();
fc51264f
L		 3509 Relocate_functions<size, false>::rela64(view, object, psymval,
3510 addend - got_address);
ee9e9e86 3511 }
7849f6d8 3512 break;
ee9e9e86 3513
2e30d253 3514 case elfcpp::R_X86_64_GOT32:
0ffd9845 3515 gold_assert(have_got_offset);
fc51264f 3516 Relocate_functions<size, false>::rela32(view, got_offset, addend);
2e30d253
ILT		 3517 break;
3518
e822f2b1
ILT		 3519 case elfcpp::R_X86_64_GOTPC32:
3520 {
2e702c99 3521 gold_assert(gsym);
fc51264f 3522 typename elfcpp::Elf_types<size>::Elf_Addr value;
96f2030e 3523 value = target->got_plt_section()->address();
fc51264f 3524 Relocate_functions<size, false>::pcrela32(view, value, addend, address);
e822f2b1
ILT		 3525 }
3526 break;
3527
3528 case elfcpp::R_X86_64_GOT64:
fdc2f80f 3529 case elfcpp::R_X86_64_GOTPLT64:
e88ba8d5
L		 3530 // R_X86_64_GOTPLT64 is obsolete and treated the the same as
3531 // GOT64.
0ffd9845 3532 gold_assert(have_got_offset);
fc51264f 3533 Relocate_functions<size, false>::rela64(view, got_offset, addend);
e822f2b1
ILT		 3534 break;
3535
3536 case elfcpp::R_X86_64_GOTPC64:
3537 {
2e702c99 3538 gold_assert(gsym);
fc51264f 3539 typename elfcpp::Elf_types<size>::Elf_Addr value;
96f2030e 3540 value = target->got_plt_section()->address();
fc51264f 3541 Relocate_functions<size, false>::pcrela64(view, value, addend, address);
e822f2b1
ILT		 3542 }
3543 break;
3544
2e30d253
ILT		 3545 case elfcpp::R_X86_64_GOTOFF64:
3546 {
fc51264f 3547 typename elfcpp::Elf_types<size>::Elf_Addr value;
2e30d253 3548 value = (psymval->value(object, 0)
96f2030e 3549 - target->got_plt_section()->address());
fc51264f 3550 Relocate_functions<size, false>::rela64(view, value, addend);
2e30d253
ILT		 3551 }
3552 break;
3553
3554 case elfcpp::R_X86_64_GOTPCREL:
2891b491
L		 3555 case elfcpp::R_X86_64_GOTPCRELX:
3556 case elfcpp::R_X86_64_REX_GOTPCRELX:
2e30d253 3557 {
1fa29f10
IT		 3558 // Convert
3559 // mov foo@GOTPCREL(%rip), %reg
3560 // to lea foo(%rip), %reg.
3561 // if possible.
3562 if (rela.get_r_offset() >= 2
3563 && view[-2] == 0x8b
3564 && ((gsym == NULL && !psymval->is_ifunc_symbol())
3565 || (gsym != NULL
3566 && Target_x86_64<size>::can_convert_mov_to_lea(gsym))))
3567 {
3568 view[-2] = 0x8d;
3569 Relocate_functions<size, false>::pcrela32(view, object, psymval, addend,
3570 address);
3571 }
3572 else
3573 {
3574 if (gsym != NULL)
3575 {
3576 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
3577 got_offset = gsym->got_offset(GOT_TYPE_STANDARD) - target->got_size();
3578 }
3579 else
3580 {
3581 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3582 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
3583 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
3584 - target->got_size());
3585 }
3586 typename elfcpp::Elf_types<size>::Elf_Addr value;
3587 value = target->got_plt_section()->address() + got_offset;
3588 Relocate_functions<size, false>::pcrela32(view, value, addend, address);
3589 }
2e30d253
ILT		 3590 }
3591 break;
3592
e822f2b1
ILT		 3593 case elfcpp::R_X86_64_GOTPCREL64:
3594 {
2e702c99
RM		 3595 gold_assert(have_got_offset);
3596 typename elfcpp::Elf_types<size>::Elf_Addr value;
3597 value = target->got_plt_section()->address() + got_offset;
3598 Relocate_functions<size, false>::pcrela64(view, value, addend, address);
e822f2b1
ILT		 3599 }
3600 break;
3601
2e30d253
ILT		 3602 case elfcpp::R_X86_64_COPY:
3603 case elfcpp::R_X86_64_GLOB_DAT:
3604 case elfcpp::R_X86_64_JUMP_SLOT:
3605 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 3606 case elfcpp::R_X86_64_IRELATIVE:
d61c17ea 3607 // These are outstanding tls relocs, which are unexpected when linking
2e30d253 3608 case elfcpp::R_X86_64_TPOFF64:
2e30d253 3609 case elfcpp::R_X86_64_DTPMOD64:
2e30d253 3610 case elfcpp::R_X86_64_TLSDESC:
75f2446e
ILT		 3611 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3612 _("unexpected reloc %u in object file"),
3613 r_type);
2e30d253
ILT		 3614 break;
3615
d61c17ea 3616 // These are initial tls relocs, which are expected when linking
56622147
ILT		 3617 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
3618 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
e041f13d 3619 case elfcpp::R_X86_64_TLSDESC_CALL:
56622147 3620 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
0ffd9845
ILT		 3621 case elfcpp::R_X86_64_DTPOFF32:
3622 case elfcpp::R_X86_64_DTPOFF64:
56622147
ILT		 3623 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3624 case elfcpp::R_X86_64_TPOFF32: // Local-exec
7bf1f802 3625 this->relocate_tls(relinfo, target, relnum, rela, r_type, gsym, psymval,
2e702c99 3626 view, address, view_size);
2e30d253 3627 break;
2e30d253 3628
fdc2f80f
ILT		 3629 case elfcpp::R_X86_64_SIZE32:
3630 case elfcpp::R_X86_64_SIZE64:
2e30d253 3631 default:
75f2446e
ILT		 3632 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3633 _("unsupported reloc %u"),
3634 r_type);
2e30d253
ILT		 3635 break;
3636 }
3637
3638 return true;
3639}
3640
3641// Perform a TLS relocation.
3642
fc51264f 3643template<int size>
2e30d253 3644inline void
fc51264f
L		 3645Target_x86_64<size>::Relocate::relocate_tls(
3646 const Relocate_info<size, false>* relinfo,
3647 Target_x86_64<size>* target,
3648 size_t relnum,
3649 const elfcpp::Rela<size, false>& rela,
3650 unsigned int r_type,
3651 const Sized_symbol<size>* gsym,
3652 const Symbol_value<size>* psymval,
3653 unsigned char* view,
3654 typename elfcpp::Elf_types<size>::Elf_Addr address,
3655 section_size_type view_size)
2e30d253 3656{
2e30d253 3657 Output_segment* tls_segment = relinfo->layout->tls_segment();
7bf1f802 3658
fc51264f 3659 const Sized_relobj_file<size, false>* object = relinfo->object;
6a41d30b 3660 const elfcpp::Elf_Xword addend = rela.get_r_addend();
fc51264f 3661 elfcpp::Shdr<size, false> data_shdr(relinfo->data_shdr);
36171d64 3662 bool is_executable = (data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0;
2e30d253 3663
fc51264f 3664 typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(relinfo->object, 0);
2e30d253
ILT		 3665
3666 const bool is_final = (gsym == NULL
b3705d2a 3667 ? !parameters->options().shared()
2e30d253 3668 : gsym->final_value_is_known());
36171d64 3669 tls::Tls_optimization optimized_type
fc51264f 3670 = Target_x86_64<size>::optimize_tls_reloc(is_final, r_type);
2e30d253
ILT		 3671 switch (r_type)
3672 {
56622147 3673 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
36171d64
CC		 3674 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
3675 {
3676 // If this code sequence is used in a non-executable section,
3677 // we will not optimize the R_X86_64_DTPOFF32/64 relocation,
3678 // on the assumption that it's being used by itself in a debug
3679 // section. Therefore, in the unlikely event that the code
3680 // sequence appears in a non-executable section, we simply
3681 // leave it unoptimized.
3682 optimized_type = tls::TLSOPT_NONE;
3683 }
e041f13d 3684 if (optimized_type == tls::TLSOPT_TO_LE)
2e30d253 3685 {
62855347
ILT		 3686 if (tls_segment == NULL)
3687 {
191f1a2d
ILT		 3688 gold_assert(parameters->errors()->error_count() > 0
3689 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3690 return;
3691 }
2e30d253 3692 this->tls_gd_to_le(relinfo, relnum, tls_segment,
72ec2876 3693 rela, r_type, value, view,
2e30d253
ILT		 3694 view_size);
3695 break;
3696 }
7bf1f802 3697 else
2e702c99
RM		 3698 {
3699 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3700 ? GOT_TYPE_TLS_OFFSET
3701 : GOT_TYPE_TLS_PAIR);
3702 unsigned int got_offset;
3703 if (gsym != NULL)
3704 {
3705 gold_assert(gsym->has_got_offset(got_type));
3706 got_offset = gsym->got_offset(got_type) - target->got_size();
3707 }
3708 else
3709 {
3710 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3711 gold_assert(object->local_has_got_offset(r_sym, got_type));
3712 got_offset = (object->local_got_offset(r_sym, got_type)
3713 - target->got_size());
3714 }
3715 if (optimized_type == tls::TLSOPT_TO_IE)
3716 {
3717 value = target->got_plt_section()->address() + got_offset;
3718 this->tls_gd_to_ie(relinfo, relnum, tls_segment, rela, r_type,
3719 value, view, address, view_size);
3720 break;
3721 }
3722 else if (optimized_type == tls::TLSOPT_NONE)
3723 {
3724 // Relocate the field with the offset of the pair of GOT
3725 // entries.
6a41d30b 3726 value = target->got_plt_section()->address() + got_offset;
2e702c99 3727 Relocate_functions<size, false>::pcrela32(view, value, addend,
fc51264f 3728 address);
2e702c99
RM		 3729 break;
3730 }
3731 }
72ec2876 3732 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
75f2446e 3733 _("unsupported reloc %u"), r_type);
2e30d253
ILT		 3734 break;
3735
c2b45e22
CC		 3736 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
3737 case elfcpp::R_X86_64_TLSDESC_CALL:
36171d64
CC		 3738 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
3739 {
3740 // See above comment for R_X86_64_TLSGD.
3741 optimized_type = tls::TLSOPT_NONE;
3742 }
c2b45e22
CC		 3743 if (optimized_type == tls::TLSOPT_TO_LE)
3744 {
62855347
ILT		 3745 if (tls_segment == NULL)
3746 {
191f1a2d
ILT		 3747 gold_assert(parameters->errors()->error_count() > 0
3748 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3749 return;
3750 }
c2b45e22 3751 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
2e702c99
RM		 3752 rela, r_type, value, view,
3753 view_size);
c2b45e22
CC		 3754 break;
3755 }
3756 else
2e702c99
RM		 3757 {
3758 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3759 ? GOT_TYPE_TLS_OFFSET
3760 : GOT_TYPE_TLS_DESC);
3761 unsigned int got_offset = 0;
a8df5856
ILT		 3762 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC
3763 && optimized_type == tls::TLSOPT_NONE)
3764 {
3765 // We created GOT entries in the .got.tlsdesc portion of
3766 // the .got.plt section, but the offset stored in the
3767 // symbol is the offset within .got.tlsdesc.
3768 got_offset = (target->got_size()
3769 + target->got_plt_section()->data_size());
3770 }
2e702c99
RM		 3771 if (gsym != NULL)
3772 {
3773 gold_assert(gsym->has_got_offset(got_type));
3774 got_offset += gsym->got_offset(got_type) - target->got_size();
3775 }
3776 else
3777 {
3778 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3779 gold_assert(object->local_has_got_offset(r_sym, got_type));
3780 got_offset += (object->local_got_offset(r_sym, got_type)
a8df5856 3781 - target->got_size());
2e702c99
RM		 3782 }
3783 if (optimized_type == tls::TLSOPT_TO_IE)
3784 {
62855347
ILT		 3785 if (tls_segment == NULL)
3786 {
191f1a2d
ILT		 3787 gold_assert(parameters->errors()->error_count() > 0
3788 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3789 return;
3790 }
2e702c99
RM		 3791 value = target->got_plt_section()->address() + got_offset;
3792 this->tls_desc_gd_to_ie(relinfo, relnum, tls_segment,
3793 rela, r_type, value, view, address,
3794 view_size);
3795 break;
3796 }
3797 else if (optimized_type == tls::TLSOPT_NONE)
3798 {
3799 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3800 {
3801 // Relocate the field with the offset of the pair of GOT
3802 // entries.
3803 value = target->got_plt_section()->address() + got_offset;
3804 Relocate_functions<size, false>::pcrela32(view, value, addend,
fc51264f 3805 address);
2e702c99
RM		 3806 }
3807 break;
3808 }
3809 }
c2b45e22
CC		 3810 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3811 _("unsupported reloc %u"), r_type);
3812 break;
3813
56622147 3814 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
36171d64
CC		 3815 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
3816 {
3817 // See above comment for R_X86_64_TLSGD.
3818 optimized_type = tls::TLSOPT_NONE;
3819 }
e041f13d 3820 if (optimized_type == tls::TLSOPT_TO_LE)
2e702c99 3821 {
62855347
ILT		 3822 if (tls_segment == NULL)
3823 {
191f1a2d
ILT		 3824 gold_assert(parameters->errors()->error_count() > 0
3825 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3826 return;
3827 }
72ec2876
ILT		 3828 this->tls_ld_to_le(relinfo, relnum, tls_segment, rela, r_type,
3829 value, view, view_size);
3830 break;
2e702c99 3831 }
7bf1f802 3832 else if (optimized_type == tls::TLSOPT_NONE)
2e702c99
RM		 3833 {
3834 // Relocate the field with the offset of the GOT entry for
3835 // the module index.
3836 unsigned int got_offset;
3837 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
31d60480 3838 - target->got_size());
6a41d30b 3839 value = target->got_plt_section()->address() + got_offset;
2e702c99 3840 Relocate_functions<size, false>::pcrela32(view, value, addend,
fc51264f 3841 address);
2e702c99
RM		 3842 break;
3843 }
72ec2876 3844 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
75f2446e 3845 _("unsupported reloc %u"), r_type);
2e30d253 3846 break;
0ffd9845
ILT		 3847
3848 case elfcpp::R_X86_64_DTPOFF32:
36171d64
CC		 3849 // This relocation type is used in debugging information.
3850 // In that case we need to not optimize the value. If the
3851 // section is not executable, then we assume we should not
3852 // optimize this reloc. See comments above for R_X86_64_TLSGD,
3853 // R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and
3854 // R_X86_64_TLSLD.
3855 if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3856 {
62855347
ILT		 3857 if (tls_segment == NULL)
3858 {
191f1a2d
ILT		 3859 gold_assert(parameters->errors()->error_count() > 0
3860 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3861 return;
3862 }
36171d64
CC		 3863 value -= tls_segment->memsz();
3864 }
fc51264f 3865 Relocate_functions<size, false>::rela32(view, value, addend);
0ffd9845
ILT		 3866 break;
3867
3868 case elfcpp::R_X86_64_DTPOFF64:
36171d64
CC		 3869 // See R_X86_64_DTPOFF32, just above, for why we check for is_executable.
3870 if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3871 {
62855347
ILT		 3872 if (tls_segment == NULL)
3873 {
191f1a2d
ILT		 3874 gold_assert(parameters->errors()->error_count() > 0
3875 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3876 return;
3877 }
36171d64
CC		 3878 value -= tls_segment->memsz();
3879 }
fc51264f 3880 Relocate_functions<size, false>::rela64(view, value, addend);
0ffd9845 3881 break;
2e30d253 3882
56622147 3883 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
24dd5808
CC		 3884 if (gsym != NULL
3885 && gsym->is_undefined()
3886 && parameters->options().output_is_executable())
65d92137
CC		 3887 {
3888 Target_x86_64<size>::Relocate::tls_ie_to_le(relinfo, relnum,
3889 NULL, rela,
3890 r_type, value, view,
3891 view_size);
3892 break;
3893 }
3894 else if (optimized_type == tls::TLSOPT_TO_LE)
56622147 3895 {
62855347
ILT		 3896 if (tls_segment == NULL)
3897 {
191f1a2d
ILT		 3898 gold_assert(parameters->errors()->error_count() > 0
3899 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3900 return;
3901 }
fc51264f
L		 3902 Target_x86_64<size>::Relocate::tls_ie_to_le(relinfo, relnum,
3903 tls_segment, rela,
3904 r_type, value, view,
3905 view_size);
56622147
ILT		 3906 break;
3907 }
7bf1f802 3908 else if (optimized_type == tls::TLSOPT_NONE)
2e702c99
RM		 3909 {
3910 // Relocate the field with the offset of the GOT entry for
3911 // the tp-relative offset of the symbol.
3912 unsigned int got_offset;
3913 if (gsym != NULL)
3914 {
3915 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
3916 got_offset = (gsym->got_offset(GOT_TYPE_TLS_OFFSET)
3917 - target->got_size());
3918 }
3919 else
3920 {
3921 unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info());
3922 gold_assert(object->local_has_got_offset(r_sym,
3923 GOT_TYPE_TLS_OFFSET));
3924 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET)
3925 - target->got_size());
3926 }
6a41d30b 3927 value = target->got_plt_section()->address() + got_offset;
2e702c99 3928 Relocate_functions<size, false>::pcrela32(view, value, addend,
fc51264f 3929 address);
2e702c99
RM		 3930 break;
3931 }
56622147
ILT		 3932 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3933 _("unsupported reloc type %u"),
3934 r_type);
3935 break;
0ffd9845 3936
56622147 3937 case elfcpp::R_X86_64_TPOFF32: // Local-exec
62855347
ILT		 3938 if (tls_segment == NULL)
3939 {
191f1a2d
ILT		 3940 gold_assert(parameters->errors()->error_count() > 0
3941 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3942 return;
3943 }
6a41d30b 3944 value -= tls_segment->memsz();
fc51264f 3945 Relocate_functions<size, false>::rela32(view, value, addend);
56622147 3946 break;
2e30d253 3947 }
2e30d253
ILT		 3948}
3949
7bf1f802
ILT		 3950// Do a relocation in which we convert a TLS General-Dynamic to an
3951// Initial-Exec.
3952
fc51264f 3953template<int size>
7bf1f802 3954inline void
fc51264f
L		 3955Target_x86_64<size>::Relocate::tls_gd_to_ie(
3956 const Relocate_info<size, false>* relinfo,
3957 size_t relnum,
3958 Output_segment*,
3959 const elfcpp::Rela<size, false>& rela,
3960 unsigned int,
3961 typename elfcpp::Elf_types<size>::Elf_Addr value,
3962 unsigned char* view,
3963 typename elfcpp::Elf_types<size>::Elf_Addr address,
3964 section_size_type view_size)
7bf1f802 3965{
41194d9f
L		 3966 // For SIZE == 64:
3967 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3968 // .word 0x6666; rex64; call __tls_get_addr
3969 // ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax
3970 // For SIZE == 32:
3971 // leaq foo@tlsgd(%rip),%rdi;
3972 // .word 0x6666; rex64; call __tls_get_addr
3973 // ==> movl %fs:0,%eax; addq x@gottpoff(%rip),%rax
7bf1f802 3974
7bf1f802 3975 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
7bf1f802 3976 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
2e702c99 3977 (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
7bf1f802 3978
41194d9f
L		 3979 if (size == 64)
3980 {
3981 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
3982 -4);
3983 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3984 (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3985 memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0",
3986 16);
3987 }
3988 else
3989 {
3990 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
3991 -3);
3992 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3993 (memcmp(view - 3, "\x48\x8d\x3d", 3) == 0));
3994 memcpy(view - 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0",
3995 15);
3996 }
7bf1f802 3997
c2b45e22 3998 const elfcpp::Elf_Xword addend = rela.get_r_addend();
fc51264f
L		 3999 Relocate_functions<size, false>::pcrela32(view + 8, value, addend - 8,
4000 address);
7bf1f802
ILT		 4001
4002 // The next reloc should be a PLT32 reloc against __tls_get_addr.
4003 // We can skip it.
4004 this->skip_call_tls_get_addr_ = true;
4005}
4006
e041f13d 4007// Do a relocation in which we convert a TLS General-Dynamic to a
2e30d253
ILT		 4008// Local-Exec.
4009
fc51264f 4010template<int size>
2e30d253 4011inline void
fc51264f
L		 4012Target_x86_64<size>::Relocate::tls_gd_to_le(
4013 const Relocate_info<size, false>* relinfo,
4014 size_t relnum,
4015 Output_segment* tls_segment,
4016 const elfcpp::Rela<size, false>& rela,
4017 unsigned int,
4018 typename elfcpp::Elf_types<size>::Elf_Addr value,
4019 unsigned char* view,
4020 section_size_type view_size)
2e30d253 4021{
41194d9f
L		 4022 // For SIZE == 64:
4023 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
4024 // .word 0x6666; rex64; call __tls_get_addr
4025 // ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax
4026 // For SIZE == 32:
4027 // leaq foo@tlsgd(%rip),%rdi;
4028 // .word 0x6666; rex64; call __tls_get_addr
4029 // ==> movl %fs:0,%eax; leaq x@tpoff(%rax),%rax
2e30d253 4030
72ec2876 4031 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
72ec2876 4032 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
41194d9f
L		 4033 (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
4034
4035 if (size == 64)
4036 {
4037 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
4038 -4);
4039 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
4040 (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
4041 memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0",
4042 16);
4043 }
4044 else
4045 {
4046 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size,
4047 -3);
4048 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
4049 (memcmp(view - 3, "\x48\x8d\x3d", 3) == 0));
2e30d253 4050
41194d9f
L		 4051 memcpy(view - 3, "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0",
4052 15);
4053 }
2e30d253 4054
6a41d30b 4055 value -= tls_segment->memsz();
fc51264f 4056 Relocate_functions<size, false>::rela32(view + 8, value, 0);
2e30d253
ILT		 4057
4058 // The next reloc should be a PLT32 reloc against __tls_get_addr.
4059 // We can skip it.
4060 this->skip_call_tls_get_addr_ = true;
2e30d253
ILT		 4061}
4062
c2b45e22
CC		 4063// Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
4064
fc51264f 4065template<int size>
c2b45e22 4066inline void
fc51264f
L		 4067Target_x86_64<size>::Relocate::tls_desc_gd_to_ie(
4068 const Relocate_info<size, false>* relinfo,
c2b45e22
CC		 4069 size_t relnum,
4070 Output_segment*,
fc51264f 4071 const elfcpp::Rela<size, false>& rela,
c2b45e22 4072 unsigned int r_type,
fc51264f 4073 typename elfcpp::Elf_types<size>::Elf_Addr value,
c2b45e22 4074 unsigned char* view,
fc51264f 4075 typename elfcpp::Elf_types<size>::Elf_Addr address,
c2b45e22
CC		 4076 section_size_type view_size)
4077{
4078 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
4079 {
4080 // leaq foo@tlsdesc(%rip), %rax
4081 // ==> movq foo@gottpoff(%rip), %rax
4082 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
4083 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
4084 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
2e702c99 4085 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
c2b45e22
CC		 4086 view[-2] = 0x8b;
4087 const elfcpp::Elf_Xword addend = rela.get_r_addend();
fc51264f 4088 Relocate_functions<size, false>::pcrela32(view, value, addend, address);
c2b45e22
CC		 4089 }
4090 else
4091 {
4092 // call *foo@tlscall(%rax)
4093 // ==> nop; nop
4094 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
4095 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
4096 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
2e702c99 4097 view[0] == 0xff && view[1] == 0x10);
c2b45e22
CC		 4098 view[0] = 0x66;
4099 view[1] = 0x90;
4100 }
4101}
4102
4103// Do a TLSDESC-style General-Dynamic to Local-Exec transition.
4104
fc51264f 4105template<int size>
c2b45e22 4106inline void
fc51264f
L		 4107Target_x86_64<size>::Relocate::tls_desc_gd_to_le(
4108 const Relocate_info<size, false>* relinfo,
c2b45e22
CC		 4109 size_t relnum,
4110 Output_segment* tls_segment,
fc51264f 4111 const elfcpp::Rela<size, false>& rela,
c2b45e22 4112 unsigned int r_type,
fc51264f 4113 typename elfcpp::Elf_types<size>::Elf_Addr value,
c2b45e22
CC		 4114 unsigned char* view,
4115 section_size_type view_size)
4116{
4117 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
4118 {
4119 // leaq foo@tlsdesc(%rip), %rax
4120 // ==> movq foo@tpoff, %rax
4121 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
4122 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
4123 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
2e702c99 4124 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
c2b45e22
CC		 4125 view[-2] = 0xc7;
4126 view[-1] = 0xc0;
4127 value -= tls_segment->memsz();
fc51264f 4128 Relocate_functions<size, false>::rela32(view, value, 0);
c2b45e22
CC		 4129 }
4130 else
4131 {
4132 // call *foo@tlscall(%rax)
4133 // ==> nop; nop
4134 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
4135 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
4136 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
2e702c99 4137 view[0] == 0xff && view[1] == 0x10);
c2b45e22
CC		 4138 view[0] = 0x66;
4139 view[1] = 0x90;
4140 }
4141}
4142
fc51264f 4143template<int size>
2e30d253 4144inline void
fc51264f
L		 4145Target_x86_64<size>::Relocate::tls_ld_to_le(
4146 const Relocate_info<size, false>* relinfo,
4147 size_t relnum,
4148 Output_segment*,
4149 const elfcpp::Rela<size, false>& rela,
4150 unsigned int,
4151 typename elfcpp::Elf_types<size>::Elf_Addr,
4152 unsigned char* view,
4153 section_size_type view_size)
2e30d253 4154{
72ec2876 4155 // leaq foo@tlsld(%rip),%rdi; call __tls_get_addr@plt;
d2cf1c6c 4156 // For SIZE == 64:
72ec2876
ILT		 4157 // ... leq foo@dtpoff(%rax),%reg
4158 // ==> .word 0x6666; .byte 0x66; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx
d2cf1c6c
L		 4159 // For SIZE == 32:
4160 // ... leq foo@dtpoff(%rax),%reg
4161 // ==> nopl 0x0(%rax); movl %fs:0,%eax ... leaq x@tpoff(%rax),%rdx
2e30d253 4162
72ec2876
ILT		 4163 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
4164 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 9);
2e30d253 4165
72ec2876 4166 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
2e702c99 4167 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x3d);
72ec2876
ILT		 4168
4169 tls::check_tls(relinfo, relnum, rela.get_r_offset(), view[4] == 0xe8);
4170
d2cf1c6c
L		 4171 if (size == 64)
4172 memcpy(view - 3, "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 12);
4173 else
4174 memcpy(view - 3, "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0\0", 12);
72ec2876
ILT		 4175
4176 // The next reloc should be a PLT32 reloc against __tls_get_addr.
4177 // We can skip it.
4178 this->skip_call_tls_get_addr_ = true;
2e30d253
ILT		 4179}
4180
56622147
ILT		 4181// Do a relocation in which we convert a TLS Initial-Exec to a
4182// Local-Exec.
4183
fc51264f 4184template<int size>
56622147 4185inline void
fc51264f
L		 4186Target_x86_64<size>::Relocate::tls_ie_to_le(
4187 const Relocate_info<size, false>* relinfo,
4188 size_t relnum,
4189 Output_segment* tls_segment,
4190 const elfcpp::Rela<size, false>& rela,
4191 unsigned int,
4192 typename elfcpp::Elf_types<size>::Elf_Addr value,
4193 unsigned char* view,
4194 section_size_type view_size)
56622147
ILT		 4195{
4196 // We need to examine the opcodes to figure out which instruction we
4197 // are looking at.
4198
4199 // movq foo@gottpoff(%rip),%reg ==> movq $YY,%reg
4200 // addq foo@gottpoff(%rip),%reg ==> addq $YY,%reg
4201
4202 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
4203 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
4204
4205 unsigned char op1 = view[-3];
4206 unsigned char op2 = view[-2];
4207 unsigned char op3 = view[-1];
4208 unsigned char reg = op3 >> 3;
4209
4210 if (op2 == 0x8b)
4211 {
4212 // movq
4213 if (op1 == 0x4c)
2e702c99 4214 view[-3] = 0x49;
e749cab8
L		 4215 else if (size == 32 && op1 == 0x44)
4216 view[-3] = 0x41;
56622147
ILT		 4217 view[-2] = 0xc7;
4218 view[-1] = 0xc0 | reg;
4219 }
4220 else if (reg == 4)
4221 {
4222 // Special handling for %rsp.
4223 if (op1 == 0x4c)
2e702c99 4224 view[-3] = 0x49;
e749cab8
L		 4225 else if (size == 32 && op1 == 0x44)
4226 view[-3] = 0x41;
56622147
ILT		 4227 view[-2] = 0x81;
4228 view[-1] = 0xc0 | reg;
4229 }
4230 else
4231 {
4232 // addq
4233 if (op1 == 0x4c)
2e702c99 4234 view[-3] = 0x4d;
e749cab8
L		 4235 else if (size == 32 && op1 == 0x44)
4236 view[-3] = 0x45;
56622147
ILT		 4237 view[-2] = 0x8d;
4238 view[-1] = 0x80 | reg | (reg << 3);
4239 }
4240
65d92137
CC		 4241 if (tls_segment != NULL)
4242 value -= tls_segment->memsz();
fc51264f 4243 Relocate_functions<size, false>::rela32(view, value, 0);
56622147
ILT		 4244}
4245
2e30d253
ILT		 4246// Relocate section data.
4247
fc51264f 4248template<int size>
2e30d253 4249void
fc51264f
L		 4250Target_x86_64<size>::relocate_section(
4251 const Relocate_info<size, false>* relinfo,
364c7fa5
ILT		 4252 unsigned int sh_type,
4253 const unsigned char* prelocs,
4254 size_t reloc_count,
4255 Output_section* output_section,
4256 bool needs_special_offset_handling,
4257 unsigned char* view,
fc51264f 4258 typename elfcpp::Elf_types<size>::Elf_Addr address,
364c7fa5
ILT		 4259 section_size_type view_size,
4260 const Reloc_symbol_changes* reloc_symbol_changes)
2e30d253
ILT		 4261{
4262 gold_assert(sh_type == elfcpp::SHT_RELA);
4263
fc51264f 4264 gold::relocate_section<size, false, Target_x86_64<size>, elfcpp::SHT_RELA,
168a4726
AM		 4265 typename Target_x86_64<size>::Relocate,
4266 gold::Default_comdat_behavior>(
2e30d253
ILT		 4267 relinfo,
4268 this,
4269 prelocs,
4270 reloc_count,
730cdc88
ILT		 4271 output_section,
4272 needs_special_offset_handling,
2e30d253
ILT		 4273 view,
4274 address,
364c7fa5
ILT		 4275 view_size,
4276 reloc_symbol_changes);
2e30d253
ILT		 4277}
4278
94a3fc8b
CC		 4279// Apply an incremental relocation. Incremental relocations always refer
4280// to global symbols.
4281
fc51264f 4282template<int size>
94a3fc8b 4283void
fc51264f
L		 4284Target_x86_64<size>::apply_relocation(
4285 const Relocate_info<size, false>* relinfo,
4286 typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
94a3fc8b 4287 unsigned int r_type,
fc51264f 4288 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend,
94a3fc8b
CC		 4289 const Symbol* gsym,
4290 unsigned char* view,
fc51264f 4291 typename elfcpp::Elf_types<size>::Elf_Addr address,
94a3fc8b
CC		 4292 section_size_type view_size)
4293{
fc51264f 4294 gold::apply_relocation<size, false, Target_x86_64<size>,
618d6666 4295 typename Target_x86_64<size>::Relocate>(
94a3fc8b
CC		 4296 relinfo,
4297 this,
4298 r_offset,
4299 r_type,
4300 r_addend,
4301 gsym,
4302 view,
4303 address,
4304 view_size);
4305}
4306
6a74a719
ILT		 4307// Return the size of a relocation while scanning during a relocatable
4308// link.
4309
fc51264f 4310template<int size>
6a74a719 4311unsigned int
fc51264f 4312Target_x86_64<size>::Relocatable_size_for_reloc::get_size_for_reloc(
6a74a719
ILT		 4313 unsigned int r_type,
4314 Relobj* object)
4315{
4316 switch (r_type)
4317 {
4318 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 4319 case elfcpp::R_X86_64_GNU_VTINHERIT:
4320 case elfcpp::R_X86_64_GNU_VTENTRY:
6a74a719
ILT		 4321 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
4322 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
4323 case elfcpp::R_X86_64_TLSDESC_CALL:
4324 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
4325 case elfcpp::R_X86_64_DTPOFF32:
4326 case elfcpp::R_X86_64_DTPOFF64:
4327 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
4328 case elfcpp::R_X86_64_TPOFF32: // Local-exec
4329 return 0;
4330
4331 case elfcpp::R_X86_64_64:
4332 case elfcpp::R_X86_64_PC64:
4333 case elfcpp::R_X86_64_GOTOFF64:
4334 case elfcpp::R_X86_64_GOTPC64:
4335 case elfcpp::R_X86_64_PLTOFF64:
4336 case elfcpp::R_X86_64_GOT64:
4337 case elfcpp::R_X86_64_GOTPCREL64:
4338 case elfcpp::R_X86_64_GOTPCREL:
2891b491
L		 4339 case elfcpp::R_X86_64_GOTPCRELX:
4340 case elfcpp::R_X86_64_REX_GOTPCRELX:
6a74a719
ILT		 4341 case elfcpp::R_X86_64_GOTPLT64:
4342 return 8;
4343
4344 case elfcpp::R_X86_64_32:
4345 case elfcpp::R_X86_64_32S:
4346 case elfcpp::R_X86_64_PC32:
f49fe902 4347 case elfcpp::R_X86_64_PC32_BND:
6a74a719 4348 case elfcpp::R_X86_64_PLT32:
f49fe902 4349 case elfcpp::R_X86_64_PLT32_BND:
6a74a719
ILT		 4350 case elfcpp::R_X86_64_GOTPC32:
4351 case elfcpp::R_X86_64_GOT32:
4352 return 4;
4353
4354 case elfcpp::R_X86_64_16:
4355 case elfcpp::R_X86_64_PC16:
4356 return 2;
4357
4358 case elfcpp::R_X86_64_8:
4359 case elfcpp::R_X86_64_PC8:
4360 return 1;
4361
4362 case elfcpp::R_X86_64_COPY:
4363 case elfcpp::R_X86_64_GLOB_DAT:
4364 case elfcpp::R_X86_64_JUMP_SLOT:
4365 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 4366 case elfcpp::R_X86_64_IRELATIVE:
6a74a719
ILT		 4367 // These are outstanding tls relocs, which are unexpected when linking
4368 case elfcpp::R_X86_64_TPOFF64:
4369 case elfcpp::R_X86_64_DTPMOD64:
4370 case elfcpp::R_X86_64_TLSDESC:
4371 object->error(_("unexpected reloc %u in object file"), r_type);
4372 return 0;
4373
4374 case elfcpp::R_X86_64_SIZE32:
4375 case elfcpp::R_X86_64_SIZE64:
4376 default:
4377 object->error(_("unsupported reloc %u against local symbol"), r_type);
4378 return 0;
4379 }
4380}
4381
4382// Scan the relocs during a relocatable link.
4383
fc51264f 4384template<int size>
6a74a719 4385void
fc51264f
L		 4386Target_x86_64<size>::scan_relocatable_relocs(
4387 Symbol_table* symtab,
4388 Layout* layout,
4389 Sized_relobj_file<size, false>* object,
4390 unsigned int data_shndx,
4391 unsigned int sh_type,
4392 const unsigned char* prelocs,
4393 size_t reloc_count,
4394 Output_section* output_section,
4395 bool needs_special_offset_handling,
4396 size_t local_symbol_count,
4397 const unsigned char* plocal_symbols,
4398 Relocatable_relocs* rr)
6a74a719
ILT		 4399{
4400 gold_assert(sh_type == elfcpp::SHT_RELA);
4401
4402 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
4403 Relocatable_size_for_reloc> Scan_relocatable_relocs;
4404
fc51264f 4405 gold::scan_relocatable_relocs<size, false, elfcpp::SHT_RELA,
6a74a719 4406 Scan_relocatable_relocs>(
6a74a719
ILT		 4407 symtab,
4408 layout,
4409 object,
4410 data_shndx,
4411 prelocs,
4412 reloc_count,
4413 output_section,
4414 needs_special_offset_handling,
4415 local_symbol_count,
4416 plocal_symbols,
4417 rr);
4418}
4419
4420// Relocate a section during a relocatable link.
4421
fc51264f 4422template<int size>
6a74a719 4423void
7404fe1b 4424Target_x86_64<size>::relocate_relocs(
fc51264f 4425 const Relocate_info<size, false>* relinfo,
6a74a719
ILT		 4426 unsigned int sh_type,
4427 const unsigned char* prelocs,
4428 size_t reloc_count,
4429 Output_section* output_section,
62fe925a 4430 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
6a74a719
ILT		 4431 const Relocatable_relocs* rr,
4432 unsigned char* view,
fc51264f 4433 typename elfcpp::Elf_types<size>::Elf_Addr view_address,
6a74a719
ILT		 4434 section_size_type view_size,
4435 unsigned char* reloc_view,
4436 section_size_type reloc_view_size)
4437{
4438 gold_assert(sh_type == elfcpp::SHT_RELA);
4439
7404fe1b 4440 gold::relocate_relocs<size, false, elfcpp::SHT_RELA>(
6a74a719
ILT		 4441 relinfo,
4442 prelocs,
4443 reloc_count,
4444 output_section,
4445 offset_in_output_section,
4446 rr,
4447 view,
4448 view_address,
4449 view_size,
4450 reloc_view,
4451 reloc_view_size);
4452}
4453
4fb6c25d
ILT		 4454// Return the value to use for a dynamic which requires special
4455// treatment. This is how we support equality comparisons of function
4456// pointers across shared library boundaries, as described in the
4457// processor specific ABI supplement.
4458
fc51264f 4459template<int size>
4fb6c25d 4460uint64_t
fc51264f 4461Target_x86_64<size>::do_dynsym_value(const Symbol* gsym) const
4fb6c25d
ILT		 4462{
4463 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
19fec8c1 4464 return this->plt_address_for_global(gsym);
4fb6c25d
ILT		 4465}
4466
2e30d253
ILT		 4467// Return a string used to fill a code section with nops to take up
4468// the specified length.
4469
fc51264f 4470template<int size>
2e30d253 4471std::string
fc51264f 4472Target_x86_64<size>::do_code_fill(section_size_type length) const
2e30d253
ILT		 4473{
4474 if (length >= 16)
4475 {
4476 // Build a jmpq instruction to skip over the bytes.
4477 unsigned char jmp[5];
4478 jmp[0] = 0xe9;
04bf7072 4479 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
2e30d253 4480 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
2e702c99 4481 + std::string(length - 5, static_cast<char>(0x90)));
2e30d253
ILT		 4482 }
4483
4484 // Nop sequences of various lengths.
76677ad0
CC		 4485 const char nop1[1] = { '\x90' }; // nop
4486 const char nop2[2] = { '\x66', '\x90' }; // xchg %ax %ax
4487 const char nop3[3] = { '\x0f', '\x1f', '\x00' }; // nop (%rax)
4488 const char nop4[4] = { '\x0f', '\x1f', '\x40', // nop 0(%rax)
2e702c99 4489 '\x00'};
76677ad0
CC		 4490 const char nop5[5] = { '\x0f', '\x1f', '\x44', // nop 0(%rax,%rax,1)
4491 '\x00', '\x00' };
4492 const char nop6[6] = { '\x66', '\x0f', '\x1f', // nopw 0(%rax,%rax,1)
2e702c99 4493 '\x44', '\x00', '\x00' };
76677ad0 4494 const char nop7[7] = { '\x0f', '\x1f', '\x80', // nopl 0L(%rax)
2e702c99 4495 '\x00', '\x00', '\x00',
76677ad0
CC		 4496 '\x00' };
4497 const char nop8[8] = { '\x0f', '\x1f', '\x84', // nopl 0L(%rax,%rax,1)
2e702c99 4498 '\x00', '\x00', '\x00',
76677ad0
CC		 4499 '\x00', '\x00' };
4500 const char nop9[9] = { '\x66', '\x0f', '\x1f', // nopw 0L(%rax,%rax,1)
2e702c99 4501 '\x84', '\x00', '\x00',
76677ad0
CC		 4502 '\x00', '\x00', '\x00' };
4503 const char nop10[10] = { '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1)
2e702c99 4504 '\x1f', '\x84', '\x00',
76677ad0
CC		 4505 '\x00', '\x00', '\x00',
4506 '\x00' };
4507 const char nop11[11] = { '\x66', '\x66', '\x2e', // data16
2e702c99 4508 '\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1)
76677ad0
CC		 4509 '\x00', '\x00', '\x00',
4510 '\x00', '\x00' };
4511 const char nop12[12] = { '\x66', '\x66', '\x66', // data16; data16
2e702c99 4512 '\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1)
76677ad0
CC		 4513 '\x84', '\x00', '\x00',
4514 '\x00', '\x00', '\x00' };
4515 const char nop13[13] = { '\x66', '\x66', '\x66', // data16; data16; data16
2e702c99 4516 '\x66', '\x2e', '\x0f', // nopw %cs:0L(%rax,%rax,1)
76677ad0
CC		 4517 '\x1f', '\x84', '\x00',
4518 '\x00', '\x00', '\x00',
2e702c99 4519 '\x00' };
76677ad0 4520 const char nop14[14] = { '\x66', '\x66', '\x66', // data16; data16; data16
2e702c99 4521 '\x66', '\x66', '\x2e', // data16
76677ad0
CC		 4522 '\x0f', '\x1f', '\x84', // nopw %cs:0L(%rax,%rax,1)
4523 '\x00', '\x00', '\x00',
2e702c99 4524 '\x00', '\x00' };
76677ad0 4525 const char nop15[15] = { '\x66', '\x66', '\x66', // data16; data16; data16
2e702c99 4526 '\x66', '\x66', '\x66', // data16; data16
76677ad0
CC		 4527 '\x2e', '\x0f', '\x1f', // nopw %cs:0L(%rax,%rax,1)
4528 '\x84', '\x00', '\x00',
2e702c99 4529 '\x00', '\x00', '\x00' };
2e30d253
ILT		 4530
4531 const char* nops[16] = {
4532 NULL,
4533 nop1, nop2, nop3, nop4, nop5, nop6, nop7,
4534 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
4535 };
4536
4537 return std::string(nops[length], length);
4538}
4539
e291e7b9
ILT		 4540// Return the addend to use for a target specific relocation. The
4541// only target specific relocation is R_X86_64_TLSDESC for a local
4542// symbol. We want to set the addend is the offset of the local
4543// symbol in the TLS segment.
4544
fc51264f 4545template<int size>
e291e7b9 4546uint64_t
fc51264f
L		 4547Target_x86_64<size>::do_reloc_addend(void* arg, unsigned int r_type,
4548 uint64_t) const
e291e7b9
ILT		 4549{
4550 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
4551 uintptr_t intarg = reinterpret_cast<uintptr_t>(arg);
4552 gold_assert(intarg < this->tlsdesc_reloc_info_.size());
4553 const Tlsdesc_info& ti(this->tlsdesc_reloc_info_[intarg]);
fc51264f 4554 const Symbol_value<size>* psymval = ti.object->local_symbol(ti.r_sym);
e291e7b9
ILT		 4555 gold_assert(psymval->is_tls_symbol());
4556 // The value of a TLS symbol is the offset in the TLS segment.
4557 return psymval->value(ti.object, 0);
4558}
4559
02d7cd44
ILT		 4560// Return the value to use for the base of a DW_EH_PE_datarel offset
4561// in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their
4562// assembler can not write out the difference between two labels in
4563// different sections, so instead of using a pc-relative value they
4564// use an offset from the GOT.
4565
fc51264f 4566template<int size>
02d7cd44 4567uint64_t
fc51264f 4568Target_x86_64<size>::do_ehframe_datarel_base() const
02d7cd44
ILT		 4569{
4570 gold_assert(this->global_offset_table_ != NULL);
4571 Symbol* sym = this->global_offset_table_;
fc51264f 4572 Sized_symbol<size>* ssym = static_cast<Sized_symbol<size>*>(sym);
02d7cd44
ILT		 4573 return ssym->value();
4574}
4575
364c7fa5 4576// FNOFFSET in section SHNDX in OBJECT is the start of a function
9b547ce6 4577// compiled with -fsplit-stack. The function calls non-split-stack
364c7fa5
ILT		 4578// code. We have to change the function so that it always ensures
4579// that it has enough stack space to run some random function.
4580
4fc1b9d4
L		 4581static const unsigned char cmp_insn_32[] = { 0x64, 0x3b, 0x24, 0x25 };
4582static const unsigned char lea_r10_insn_32[] = { 0x44, 0x8d, 0x94, 0x24 };
4583static const unsigned char lea_r11_insn_32[] = { 0x44, 0x8d, 0x9c, 0x24 };
4584
4585static const unsigned char cmp_insn_64[] = { 0x64, 0x48, 0x3b, 0x24, 0x25 };
4586static const unsigned char lea_r10_insn_64[] = { 0x4c, 0x8d, 0x94, 0x24 };
4587static const unsigned char lea_r11_insn_64[] = { 0x4c, 0x8d, 0x9c, 0x24 };
4588
fc51264f 4589template<int size>
364c7fa5 4590void
fc51264f
L		 4591Target_x86_64<size>::do_calls_non_split(Relobj* object, unsigned int shndx,
4592 section_offset_type fnoffset,
4593 section_size_type fnsize,
4594 unsigned char* view,
4595 section_size_type view_size,
4596 std::string* from,
4597 std::string* to) const
364c7fa5 4598{
4fc1b9d4
L		 4599 const char* const cmp_insn = reinterpret_cast<const char*>
4600 (size == 32 ? cmp_insn_32 : cmp_insn_64);
4601 const char* const lea_r10_insn = reinterpret_cast<const char*>
4602 (size == 32 ? lea_r10_insn_32 : lea_r10_insn_64);
4603 const char* const lea_r11_insn = reinterpret_cast<const char*>
4604 (size == 32 ? lea_r11_insn_32 : lea_r11_insn_64);
4605
4606 const size_t cmp_insn_len =
4607 (size == 32 ? sizeof(cmp_insn_32) : sizeof(cmp_insn_64));
4608 const size_t lea_r10_insn_len =
4609 (size == 32 ? sizeof(lea_r10_insn_32) : sizeof(lea_r10_insn_64));
4610 const size_t lea_r11_insn_len =
4611 (size == 32 ? sizeof(lea_r11_insn_32) : sizeof(lea_r11_insn_64));
4612 const size_t nop_len = (size == 32 ? 7 : 8);
4613
364c7fa5
ILT		 4614 // The function starts with a comparison of the stack pointer and a
4615 // field in the TCB. This is followed by a jump.
4616
4617 // cmp %fs:NN,%rsp
4fc1b9d4
L		 4618 if (this->match_view(view, view_size, fnoffset, cmp_insn, cmp_insn_len)
4619 && fnsize > nop_len + 1)
364c7fa5
ILT		 4620 {
4621 // We will call __morestack if the carry flag is set after this
4622 // comparison. We turn the comparison into an stc instruction
4623 // and some nops.
4624 view[fnoffset] = '\xf9';
4fc1b9d4 4625 this->set_view_to_nop(view, view_size, fnoffset + 1, nop_len);
364c7fa5
ILT		 4626 }
4627 // lea NN(%rsp),%r10
cbc999b9
ILT		 4628 // lea NN(%rsp),%r11
4629 else if ((this->match_view(view, view_size, fnoffset,
4fc1b9d4 4630 lea_r10_insn, lea_r10_insn_len)
cbc999b9 4631 || this->match_view(view, view_size, fnoffset,
4fc1b9d4 4632 lea_r11_insn, lea_r11_insn_len))
364c7fa5
ILT		 4633 && fnsize > 8)
4634 {
4635 // This is loading an offset from the stack pointer for a
4636 // comparison. The offset is negative, so we decrease the
4637 // offset by the amount of space we need for the stack. This
4638 // means we will avoid calling __morestack if there happens to
4639 // be plenty of space on the stack already.
4640 unsigned char* pval = view + fnoffset + 4;
4641 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
4642 val -= parameters->options().split_stack_adjust_size();
4643 elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
4644 }
4645 else
4646 {
4647 if (!object->has_no_split_stack())
4648 object->error(_("failed to match split-stack sequence at "
4649 "section %u offset %0zx"),
ac33a407 4650 shndx, static_cast<size_t>(fnoffset));
364c7fa5
ILT		 4651 return;
4652 }
4653
4654 // We have to change the function so that it calls
4655 // __morestack_non_split instead of __morestack. The former will
4656 // allocate additional stack space.
4657 *from = "__morestack";
4658 *to = "__morestack_non_split";
4659}
4660
2e702c99
RM		 4661// The selector for x86_64 object files. Note this is never instantiated
4662// directly. It's only used in Target_selector_x86_64_nacl, below.
2e30d253 4663
fc51264f 4664template<int size>
36959681 4665class Target_selector_x86_64 : public Target_selector_freebsd
2e30d253
ILT		 4666{
4667public:
4668 Target_selector_x86_64()
fc51264f 4669 : Target_selector_freebsd(elfcpp::EM_X86_64, size, false,
2e702c99 4670 (size == 64
fc51264f 4671 ? "elf64-x86-64" : "elf32-x86-64"),
2e702c99 4672 (size == 64
fc51264f
L		 4673 ? "elf64-x86-64-freebsd"
4674 : "elf32-x86-64-freebsd"),
4675 (size == 64 ? "elf_x86_64" : "elf32_x86_64"))
2e30d253
ILT		 4676 { }
4677
4678 Target*
e96caa79 4679 do_instantiate_target()
fc51264f 4680 { return new Target_x86_64<size>(); }
36959681 4681
2e30d253
ILT		 4682};
4683
2e702c99
RM		 4684// NaCl variant. It uses different PLT contents.
4685
4686template<int size>
4687class Output_data_plt_x86_64_nacl : public Output_data_plt_x86_64<size>
4688{
4689 public:
4690 Output_data_plt_x86_64_nacl(Layout* layout,
4691 Output_data_got<64, false>* got,
57b2284c 4692 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 4693 Output_data_space* got_irelative)
4694 : Output_data_plt_x86_64<size>(layout, plt_entry_size,
4695 got, got_plt, got_irelative)
4696 { }
4697
4698 Output_data_plt_x86_64_nacl(Layout* layout,
4699 Output_data_got<64, false>* got,
57b2284c 4700 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 4701 Output_data_space* got_irelative,
4702 unsigned int plt_count)
4703 : Output_data_plt_x86_64<size>(layout, plt_entry_size,
4704 got, got_plt, got_irelative,
4705 plt_count)
4706 { }
4707
4708 protected:
4709 virtual unsigned int
4710 do_get_plt_entry_size() const
4711 { return plt_entry_size; }
4712
4713 virtual void
4714 do_add_eh_frame(Layout* layout)
4715 {
4716 layout->add_eh_frame_for_plt(this,
4717 this->plt_eh_frame_cie,
4718 this->plt_eh_frame_cie_size,
4719 plt_eh_frame_fde,
4720 plt_eh_frame_fde_size);
4721 }
4722
4723 virtual void
4724 do_fill_first_plt_entry(unsigned char* pov,
4725 typename elfcpp::Elf_types<size>::Elf_Addr got_addr,
4726 typename elfcpp::Elf_types<size>::Elf_Addr plt_addr);
4727
4728 virtual unsigned int
4729 do_fill_plt_entry(unsigned char* pov,
4730 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4731 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4732 unsigned int got_offset,
4733 unsigned int plt_offset,
4734 unsigned int plt_index);
4735
4736 virtual void
4737 do_fill_tlsdesc_entry(unsigned char* pov,
4738 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4739 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4740 typename elfcpp::Elf_types<size>::Elf_Addr got_base,
4741 unsigned int tlsdesc_got_offset,
4742 unsigned int plt_offset);
4743
4744 private:
4745 // The size of an entry in the PLT.
4746 static const int plt_entry_size = 64;
4747
4748 // The first entry in the PLT.
4749 static const unsigned char first_plt_entry[plt_entry_size];
4750
4751 // Other entries in the PLT for an executable.
4752 static const unsigned char plt_entry[plt_entry_size];
4753
4754 // The reserved TLSDESC entry in the PLT for an executable.
4755 static const unsigned char tlsdesc_plt_entry[plt_entry_size];
4756
4757 // The .eh_frame unwind information for the PLT.
4758 static const int plt_eh_frame_fde_size = 32;
4759 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
4760};
4761
4762template<int size>
4763class Target_x86_64_nacl : public Target_x86_64<size>
4764{
4765 public:
4766 Target_x86_64_nacl()
4767 : Target_x86_64<size>(&x86_64_nacl_info)
4768 { }
4769
4770 virtual Output_data_plt_x86_64<size>*
4771 do_make_data_plt(Layout* layout,
4772 Output_data_got<64, false>* got,
57b2284c 4773 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 4774 Output_data_space* got_irelative)
4775 {
4776 return new Output_data_plt_x86_64_nacl<size>(layout, got, got_plt,
4777 got_irelative);
4778 }
4779
4780 virtual Output_data_plt_x86_64<size>*
4781 do_make_data_plt(Layout* layout,
4782 Output_data_got<64, false>* got,
57b2284c 4783 Output_data_got_plt_x86_64* got_plt,
2e702c99
RM		 4784 Output_data_space* got_irelative,
4785 unsigned int plt_count)
4786 {
4787 return new Output_data_plt_x86_64_nacl<size>(layout, got, got_plt,
4788 got_irelative,
4789 plt_count);
4790 }
4791
93f8221c
RM		 4792 virtual std::string
4793 do_code_fill(section_size_type length) const;
4794
2e702c99
RM		 4795 private:
4796 static const Target::Target_info x86_64_nacl_info;
4797};
4798
4799template<>
4800const Target::Target_info Target_x86_64_nacl<64>::x86_64_nacl_info =
4801{
4802 64, // size
4803 false, // is_big_endian
4804 elfcpp::EM_X86_64, // machine_code
4805 false, // has_make_symbol
4806 false, // has_resolve
4807 true, // has_code_fill
4808 true, // is_default_stack_executable
4809 true, // can_icf_inline_merge_sections
4810 '\0', // wrap_char
4811 "/lib64/ld-nacl-x86-64.so.1", // dynamic_linker
4812 0x20000, // default_text_segment_address
4813 0x10000, // abi_pagesize (overridable by -z max-page-size)
4814 0x10000, // common_pagesize (overridable by -z common-page-size)
4815 true, // isolate_execinstr
4816 0x10000000, // rosegment_gap
4817 elfcpp::SHN_UNDEF, // small_common_shndx
4818 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
4819 0, // small_common_section_flags
4820 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
4821 NULL, // attributes_section
a67858e0 4822 NULL, // attributes_vendor
8d9743bd
MK		 4823 "_start", // entry_symbol_name
4824 32, // hash_entry_size
2e702c99
RM		 4825};
4826
4827template<>
4828const Target::Target_info Target_x86_64_nacl<32>::x86_64_nacl_info =
4829{
4830 32, // size
4831 false, // is_big_endian
4832 elfcpp::EM_X86_64, // machine_code
4833 false, // has_make_symbol
4834 false, // has_resolve
4835 true, // has_code_fill
4836 true, // is_default_stack_executable
4837 true, // can_icf_inline_merge_sections
4838 '\0', // wrap_char
4839 "/lib/ld-nacl-x86-64.so.1", // dynamic_linker
4840 0x20000, // default_text_segment_address
4841 0x10000, // abi_pagesize (overridable by -z max-page-size)
4842 0x10000, // common_pagesize (overridable by -z common-page-size)
4843 true, // isolate_execinstr
4844 0x10000000, // rosegment_gap
4845 elfcpp::SHN_UNDEF, // small_common_shndx
4846 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
4847 0, // small_common_section_flags
4848 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
4849 NULL, // attributes_section
a67858e0 4850 NULL, // attributes_vendor
8d9743bd
MK		 4851 "_start", // entry_symbol_name
4852 32, // hash_entry_size
2e702c99
RM		 4853};
4854
4855#define NACLMASK 0xe0 // 32-byte alignment mask.
4856
4857// The first entry in the PLT.
4858
4859template<int size>
4860const unsigned char
4861Output_data_plt_x86_64_nacl<size>::first_plt_entry[plt_entry_size] =
4862{
4863 0xff, 0x35, // pushq contents of memory address
4864 0, 0, 0, 0, // replaced with address of .got + 8
4865 0x4c, 0x8b, 0x1d, // mov GOT+16(%rip), %r11
4866 0, 0, 0, 0, // replaced with address of .got + 16
4867 0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d
4868 0x4d, 0x01, 0xfb, // add %r15, %r11
4869 0x41, 0xff, 0xe3, // jmpq *%r11
4870
4871 // 9-byte nop sequence to pad out to the next 32-byte boundary.
dd0845d7 4872 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw 0x0(%rax,%rax,1)
2e702c99
RM		 4873
4874 // 32 bytes of nop to pad out to the standard size
4875 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4876 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4877 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4878 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4879 0x66, // excess data32 prefix
4880 0x90 // nop
4881};
4882
4883template<int size>
4884void
4885Output_data_plt_x86_64_nacl<size>::do_fill_first_plt_entry(
4886 unsigned char* pov,
4887 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4888 typename elfcpp::Elf_types<size>::Elf_Addr plt_address)
4889{
4890 memcpy(pov, first_plt_entry, plt_entry_size);
4891 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4892 (got_address + 8
4893 - (plt_address + 2 + 4)));
4894 elfcpp::Swap_unaligned<32, false>::writeval(pov + 9,
4895 (got_address + 16
4896 - (plt_address + 9 + 4)));
4897}
4898
4899// Subsequent entries in the PLT.
4900
4901template<int size>
4902const unsigned char
4903Output_data_plt_x86_64_nacl<size>::plt_entry[plt_entry_size] =
4904{
4905 0x4c, 0x8b, 0x1d, // mov name@GOTPCREL(%rip),%r11
4906 0, 0, 0, 0, // replaced with address of symbol in .got
4907 0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d
4908 0x4d, 0x01, 0xfb, // add %r15, %r11
4909 0x41, 0xff, 0xe3, // jmpq *%r11
4910
4911 // 15-byte nop sequence to pad out to the next 32-byte boundary.
4912 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4913 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4914
4915 // Lazy GOT entries point here (32-byte aligned).
4916 0x68, // pushq immediate
4917 0, 0, 0, 0, // replaced with index into relocation table
4918 0xe9, // jmp relative
4919 0, 0, 0, 0, // replaced with offset to start of .plt0
4920
4921 // 22 bytes of nop to pad out to the standard size.
4922 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4923 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4924 0x0f, 0x1f, 0x80, 0, 0, 0, 0, // nopl 0x0(%rax)
4925};
4926
4927template<int size>
4928unsigned int
4929Output_data_plt_x86_64_nacl<size>::do_fill_plt_entry(
4930 unsigned char* pov,
4931 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4932 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4933 unsigned int got_offset,
4934 unsigned int plt_offset,
4935 unsigned int plt_index)
4936{
4937 memcpy(pov, plt_entry, plt_entry_size);
4938 elfcpp::Swap_unaligned<32, false>::writeval(pov + 3,
4939 (got_address + got_offset
4940 - (plt_address + plt_offset
4941 + 3 + 4)));
4942
4943 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_index);
4944 elfcpp::Swap_unaligned<32, false>::writeval(pov + 38,
4945 - (plt_offset + 38 + 4));
4946
4947 return 32;
4948}
4949
4950// The reserved TLSDESC entry in the PLT.
4951
4952template<int size>
4953const unsigned char
4954Output_data_plt_x86_64_nacl<size>::tlsdesc_plt_entry[plt_entry_size] =
4955{
4956 0xff, 0x35, // pushq x(%rip)
4957 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
4958 0x4c, 0x8b, 0x1d, // mov y(%rip),%r11
4959 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
4960 0x41, 0x83, 0xe3, NACLMASK, // and $-32, %r11d
4961 0x4d, 0x01, 0xfb, // add %r15, %r11
4962 0x41, 0xff, 0xe3, // jmpq *%r11
4963
4964 // 41 bytes of nop to pad out to the standard size.
4965 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4966 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4967 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, // excess data32 prefixes
4968 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4969 0x66, 0x66, // excess data32 prefixes
4970 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, // nopw %cs:0x0(%rax,%rax,1)
4971};
4972
4973template<int size>
4974void
4975Output_data_plt_x86_64_nacl<size>::do_fill_tlsdesc_entry(
4976 unsigned char* pov,
4977 typename elfcpp::Elf_types<size>::Elf_Addr got_address,
4978 typename elfcpp::Elf_types<size>::Elf_Addr plt_address,
4979 typename elfcpp::Elf_types<size>::Elf_Addr got_base,
4980 unsigned int tlsdesc_got_offset,
4981 unsigned int plt_offset)
4982{
4983 memcpy(pov, tlsdesc_plt_entry, plt_entry_size);
4984 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4985 (got_address + 8
4986 - (plt_address + plt_offset
4987 + 2 + 4)));
4988 elfcpp::Swap_unaligned<32, false>::writeval(pov + 9,
4989 (got_base
4990 + tlsdesc_got_offset
4991 - (plt_address + plt_offset
4992 + 9 + 4)));
4993}
4994
4995// The .eh_frame unwind information for the PLT.
4996
4997template<int size>
4998const unsigned char
4999Output_data_plt_x86_64_nacl<size>::plt_eh_frame_fde[plt_eh_frame_fde_size] =
5000{
5001 0, 0, 0, 0, // Replaced with offset to .plt.
5002 0, 0, 0, 0, // Replaced with size of .plt.
5003 0, // Augmentation size.
5004 elfcpp::DW_CFA_def_cfa_offset, 16, // DW_CFA_def_cfa_offset: 16.
5005 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
5006 elfcpp::DW_CFA_def_cfa_offset, 24, // DW_CFA_def_cfa_offset: 24.
5007 elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64.
5008 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
5009 13, // Block length.
5010 elfcpp::DW_OP_breg7, 8, // Push %rsp + 8.
5011 elfcpp::DW_OP_breg16, 0, // Push %rip.
5012 elfcpp::DW_OP_const1u, 63, // Push 0x3f.
5013 elfcpp::DW_OP_and, // & (%rip & 0x3f).
5014 elfcpp::DW_OP_const1u, 37, // Push 0x25.
5015 elfcpp::DW_OP_ge, // >= ((%rip & 0x3f) >= 0x25)
5016 elfcpp::DW_OP_lit3, // Push 3.
5017 elfcpp::DW_OP_shl, // << (((%rip & 0x3f) >= 0x25) << 3)
5018 elfcpp::DW_OP_plus, // + ((((%rip&0x3f)>=0x25)<<3)+%rsp+8
5019 elfcpp::DW_CFA_nop, // Align to 32 bytes.
5020 elfcpp::DW_CFA_nop
5021};
5022
93f8221c
RM		 5023// Return a string used to fill a code section with nops.
5024// For NaCl, long NOPs are only valid if they do not cross
5025// bundle alignment boundaries, so keep it simple with one-byte NOPs.
5026template<int size>
5027std::string
5028Target_x86_64_nacl<size>::do_code_fill(section_size_type length) const
5029{
5030 return std::string(length, static_cast<char>(0x90));
5031}
5032
2e702c99
RM		 5033// The selector for x86_64-nacl object files.
5034
5035template<int size>
5036class Target_selector_x86_64_nacl
5037 : public Target_selector_nacl<Target_selector_x86_64<size>,
5038 Target_x86_64_nacl<size> >
5039{
5040 public:
5041 Target_selector_x86_64_nacl()
5042 : Target_selector_nacl<Target_selector_x86_64<size>,
5043 Target_x86_64_nacl<size> >("x86-64",
5044 size == 64
5045 ? "elf64-x86-64-nacl"
5046 : "elf32-x86-64-nacl",
5047 size == 64
5048 ? "elf_x86_64_nacl"
5049 : "elf32_x86_64_nacl")
5050 { }
5051};
5052
5053Target_selector_x86_64_nacl<64> target_selector_x86_64;
5054Target_selector_x86_64_nacl<32> target_selector_x32;
2e30d253
ILT		 5055
5056} // End anonymous namespace.
GDB Binutils - Deliverables
This page took 1.002711 seconds and 4 git commands to generate.