projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2011-06-28 Tristan Gingold <gingold@adacore.com>
[deliverable/binutils-gdb.git] / gold / x86_64.cc
CommitLineData
2e30d253
ILT		 1// x86_64.cc -- x86_64 target support for gold.
2
a8df5856 3// Copyright 2006, 2007, 2008, 2009, 2010 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"
28#include "parameters.h"
29#include "reloc.h"
30#include "x86_64.h"
31#include "object.h"
32#include "symtab.h"
33#include "layout.h"
34#include "output.h"
12c0daef 35#include "copy-relocs.h"
2e30d253
ILT		 36#include "target.h"
37#include "target-reloc.h"
38#include "target-select.h"
e041f13d 39#include "tls.h"
36959681 40#include "freebsd.h"
f345227a 41#include "gc.h"
21bb3914 42#include "icf.h"
2e30d253
ILT		 43
44namespace
45{
46
47using namespace gold;
48
7223e9ca
ILT		 49// A class to handle the PLT data.
50
51class Output_data_plt_x86_64 : public Output_section_data
52{
53 public:
54 typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;
55
4829d394
CC		 56 Output_data_plt_x86_64(Symbol_table* symtab, Layout* layout,
57 Output_data_got<64, false>* got,
58 Output_data_space* got_plt)
59 : Output_section_data(8), tlsdesc_rel_(NULL), got_(got), got_plt_(got_plt),
60 count_(0), tlsdesc_got_offset_(-1U), free_list_()
61 { this->init(symtab, layout); }
62
63 Output_data_plt_x86_64(Symbol_table* symtab, Layout* layout,
64 Output_data_got<64, false>* got,
65 Output_data_space* got_plt,
66 unsigned int plt_count)
67 : Output_section_data((plt_count + 1) * plt_entry_size, 8, false),
68 tlsdesc_rel_(NULL), got_(got), got_plt_(got_plt),
69 count_(plt_count), tlsdesc_got_offset_(-1U), free_list_()
70 {
71 this->init(symtab, layout);
72
73 // Initialize the free list and reserve the first entry.
74 this->free_list_.init((plt_count + 1) * plt_entry_size, false);
75 this->free_list_.remove(0, plt_entry_size);
76 }
77
78 // Initialize the PLT section.
79 void
80 init(Symbol_table* symtab, Layout* layout);
7223e9ca
ILT		 81
82 // Add an entry to the PLT.
83 void
84 add_entry(Symbol* gsym);
85
86 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
87 unsigned int
6fa2a40b 88 add_local_ifunc_entry(Sized_relobj_file<64, false>* relobj,
7223e9ca
ILT		 89 unsigned int local_sym_index);
90
4829d394
CC		 91 // Add the relocation for a PLT entry.
92 void
93 add_relocation(Symbol* gsym, unsigned int got_offset);
94
7223e9ca
ILT		 95 // Add the reserved TLSDESC_PLT entry to the PLT.
96 void
97 reserve_tlsdesc_entry(unsigned int got_offset)
98 { this->tlsdesc_got_offset_ = got_offset; }
99
100 // Return true if a TLSDESC_PLT entry has been reserved.
101 bool
102 has_tlsdesc_entry() const
103 { return this->tlsdesc_got_offset_ != -1U; }
104
105 // Return the GOT offset for the reserved TLSDESC_PLT entry.
106 unsigned int
107 get_tlsdesc_got_offset() const
108 { return this->tlsdesc_got_offset_; }
109
110 // Return the offset of the reserved TLSDESC_PLT entry.
111 unsigned int
112 get_tlsdesc_plt_offset() const
113 { return (this->count_ + 1) * plt_entry_size; }
114
115 // Return the .rela.plt section data.
116 Reloc_section*
117 rela_plt()
118 { return this->rel_; }
119
120 // Return where the TLSDESC relocations should go.
121 Reloc_section*
122 rela_tlsdesc(Layout*);
123
124 // Return the number of PLT entries.
125 unsigned int
126 entry_count() const
127 { return this->count_; }
128
129 // Return the offset of the first non-reserved PLT entry.
130 static unsigned int
131 first_plt_entry_offset()
132 { return plt_entry_size; }
133
134 // Return the size of a PLT entry.
135 static unsigned int
136 get_plt_entry_size()
137 { return plt_entry_size; }
138
4829d394
CC		 139 // Reserve a slot in the PLT for an existing symbol in an incremental update.
140 void
141 reserve_slot(unsigned int plt_index)
142 {
143 this->free_list_.remove((plt_index + 1) * plt_entry_size,
144 (plt_index + 2) * plt_entry_size);
145 }
146
7223e9ca
ILT		 147 protected:
148 void
149 do_adjust_output_section(Output_section* os);
150
151 // Write to a map file.
152 void
153 do_print_to_mapfile(Mapfile* mapfile) const
154 { mapfile->print_output_data(this, _("** PLT")); }
155
156 private:
157 // The size of an entry in the PLT.
158 static const int plt_entry_size = 16;
159
160 // The first entry in the PLT.
161 // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same
162 // procedure linkage table for both programs and shared objects."
163 static unsigned char first_plt_entry[plt_entry_size];
164
165 // Other entries in the PLT for an executable.
166 static unsigned char plt_entry[plt_entry_size];
167
168 // The reserved TLSDESC entry in the PLT for an executable.
169 static unsigned char tlsdesc_plt_entry[plt_entry_size];
170
171 // Set the final size.
172 void
173 set_final_data_size();
174
175 // Write out the PLT data.
176 void
177 do_write(Output_file*);
178
179 // The reloc section.
180 Reloc_section* rel_;
181 // The TLSDESC relocs, if necessary. These must follow the regular
182 // PLT relocs.
183 Reloc_section* tlsdesc_rel_;
184 // The .got section.
185 Output_data_got<64, false>* got_;
186 // The .got.plt section.
187 Output_data_space* got_plt_;
188 // The number of PLT entries.
189 unsigned int count_;
190 // Offset of the reserved TLSDESC_GOT entry when needed.
191 unsigned int tlsdesc_got_offset_;
4829d394
CC		 192 // List of available regions within the section, for incremental
193 // update links.
194 Free_list free_list_;
7223e9ca 195};
2e30d253
ILT		 196
197// The x86_64 target class.
d61c17ea
ILT		 198// See the ABI at
199// http://www.x86-64.org/documentation/abi.pdf
200// TLS info comes from
201// http://people.redhat.com/drepper/tls.pdf
0ffd9845 202// http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt
2e30d253 203
36959681 204class Target_x86_64 : public Target_freebsd<64, false>
2e30d253
ILT		 205{
206 public:
e822f2b1
ILT		 207 // In the x86_64 ABI (p 68), it says "The AMD64 ABI architectures
208 // uses only Elf64_Rela relocation entries with explicit addends."
2e30d253
ILT		 209 typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;
210
211 Target_x86_64()
36959681 212 : Target_freebsd<64, false>(&x86_64_info),
a8df5856
ILT		 213 got_(NULL), plt_(NULL), got_plt_(NULL), got_tlsdesc_(NULL),
214 global_offset_table_(NULL), rela_dyn_(NULL),
215 copy_relocs_(elfcpp::R_X86_64_COPY), dynbss_(NULL),
e291e7b9
ILT		 216 got_mod_index_offset_(-1U), tlsdesc_reloc_info_(),
217 tls_base_symbol_defined_(false)
2e30d253
ILT		 218 { }
219
21bb3914
ST		 220 // This function should be defined in targets that can use relocation
221 // types to determine (implemented in local_reloc_may_be_function_pointer
222 // and global_reloc_may_be_function_pointer)
223 // if a function's pointer is taken. ICF uses this in safe mode to only
224 // fold those functions whose pointer is defintely not taken. For x86_64
225 // pie binaries, safe ICF cannot be done by looking at relocation types.
226 inline bool
227 can_check_for_function_pointers() const
228 { return !parameters->options().pie(); }
229
c95e9f27
ST		 230 virtual bool
231 can_icf_inline_merge_sections () const
232 { return true; }
233
8a5e3e08
ILT		 234 // Hook for a new output section.
235 void
236 do_new_output_section(Output_section*) const;
237
6d03d481
ST		 238 // Scan the relocations to look for symbol adjustments.
239 void
ad0f2072 240 gc_process_relocs(Symbol_table* symtab,
6d03d481 241 Layout* layout,
6fa2a40b 242 Sized_relobj_file<64, false>* object,
6d03d481
ST		 243 unsigned int data_shndx,
244 unsigned int sh_type,
245 const unsigned char* prelocs,
246 size_t reloc_count,
247 Output_section* output_section,
248 bool needs_special_offset_handling,
249 size_t local_symbol_count,
250 const unsigned char* plocal_symbols);
251
2e30d253
ILT		 252 // Scan the relocations to look for symbol adjustments.
253 void
ad0f2072 254 scan_relocs(Symbol_table* symtab,
2e30d253 255 Layout* layout,
6fa2a40b 256 Sized_relobj_file<64, false>* object,
2e30d253
ILT		 257 unsigned int data_shndx,
258 unsigned int sh_type,
259 const unsigned char* prelocs,
260 size_t reloc_count,
730cdc88
ILT		 261 Output_section* output_section,
262 bool needs_special_offset_handling,
2e30d253 263 size_t local_symbol_count,
730cdc88 264 const unsigned char* plocal_symbols);
2e30d253
ILT		 265
266 // Finalize the sections.
267 void
f59f41f3 268 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
2e30d253 269
4fb6c25d
ILT		 270 // Return the value to use for a dynamic which requires special
271 // treatment.
272 uint64_t
273 do_dynsym_value(const Symbol*) const;
274
2e30d253
ILT		 275 // Relocate a section.
276 void
277 relocate_section(const Relocate_info<64, false>*,
278 unsigned int sh_type,
279 const unsigned char* prelocs,
280 size_t reloc_count,
730cdc88
ILT		 281 Output_section* output_section,
282 bool needs_special_offset_handling,
2e30d253
ILT		 283 unsigned char* view,
284 elfcpp::Elf_types<64>::Elf_Addr view_address,
364c7fa5
ILT		 285 section_size_type view_size,
286 const Reloc_symbol_changes*);
2e30d253 287
6a74a719
ILT		 288 // Scan the relocs during a relocatable link.
289 void
ad0f2072 290 scan_relocatable_relocs(Symbol_table* symtab,
6a74a719 291 Layout* layout,
6fa2a40b 292 Sized_relobj_file<64, false>* object,
6a74a719
ILT		 293 unsigned int data_shndx,
294 unsigned int sh_type,
295 const unsigned char* prelocs,
296 size_t reloc_count,
297 Output_section* output_section,
298 bool needs_special_offset_handling,
299 size_t local_symbol_count,
300 const unsigned char* plocal_symbols,
301 Relocatable_relocs*);
302
303 // Relocate a section during a relocatable link.
304 void
305 relocate_for_relocatable(const Relocate_info<64, false>*,
306 unsigned int sh_type,
307 const unsigned char* prelocs,
308 size_t reloc_count,
309 Output_section* output_section,
310 off_t offset_in_output_section,
311 const Relocatable_relocs*,
312 unsigned char* view,
313 elfcpp::Elf_types<64>::Elf_Addr view_address,
314 section_size_type view_size,
315 unsigned char* reloc_view,
316 section_size_type reloc_view_size);
317
2e30d253
ILT		 318 // Return a string used to fill a code section with nops.
319 std::string
8851ecca 320 do_code_fill(section_size_type length) const;
2e30d253 321
9a2d6984
ILT		 322 // Return whether SYM is defined by the ABI.
323 bool
9c2d0ef9 324 do_is_defined_by_abi(const Symbol* sym) const
9a2d6984
ILT		 325 { return strcmp(sym->name(), "__tls_get_addr") == 0; }
326
e291e7b9
ILT		 327 // Return the symbol index to use for a target specific relocation.
328 // The only target specific relocation is R_X86_64_TLSDESC for a
329 // local symbol, which is an absolute reloc.
330 unsigned int
331 do_reloc_symbol_index(void*, unsigned int r_type) const
332 {
333 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
334 return 0;
335 }
336
337 // Return the addend to use for a target specific relocation.
338 uint64_t
339 do_reloc_addend(void* arg, unsigned int r_type, uint64_t addend) const;
340
7223e9ca
ILT		 341 // Return the PLT section.
342 Output_data*
343 do_plt_section_for_global(const Symbol*) const
344 { return this->plt_section(); }
345
346 Output_data*
347 do_plt_section_for_local(const Relobj*, unsigned int) const
348 { return this->plt_section(); }
349
9b547ce6 350 // Adjust -fsplit-stack code which calls non-split-stack code.
364c7fa5
ILT		 351 void
352 do_calls_non_split(Relobj* object, unsigned int shndx,
353 section_offset_type fnoffset, section_size_type fnsize,
354 unsigned char* view, section_size_type view_size,
355 std::string* from, std::string* to) const;
356
96f2030e 357 // Return the size of the GOT section.
fe8718a4 358 section_size_type
0e70b911 359 got_size() const
96f2030e
ILT		 360 {
361 gold_assert(this->got_ != NULL);
362 return this->got_->data_size();
363 }
364
0e70b911
CC		 365 // Return the number of entries in the GOT.
366 unsigned int
367 got_entry_count() const
368 {
369 if (this->got_ == NULL)
370 return 0;
371 return this->got_size() / 8;
372 }
373
374 // Return the number of entries in the PLT.
375 unsigned int
376 plt_entry_count() const;
377
378 // Return the offset of the first non-reserved PLT entry.
379 unsigned int
380 first_plt_entry_offset() const;
381
382 // Return the size of each PLT entry.
383 unsigned int
384 plt_entry_size() const;
385
4829d394
CC		 386 // Create the GOT section for an incremental update.
387 Output_data_got<64, false>*
388 init_got_plt_for_update(Symbol_table* symtab,
389 Layout* layout,
390 unsigned int got_count,
391 unsigned int plt_count);
392
6fa2a40b
CC		 393 // Reserve a GOT entry for a local symbol, and regenerate any
394 // necessary dynamic relocations.
395 void
396 reserve_local_got_entry(unsigned int got_index,
397 Sized_relobj<64, false>* obj,
398 unsigned int r_sym,
399 unsigned int got_type);
400
401 // Reserve a GOT entry for a global symbol, and regenerate any
402 // necessary dynamic relocations.
403 void
404 reserve_global_got_entry(unsigned int got_index, Symbol* gsym,
405 unsigned int got_type);
406
4829d394 407 // Register an existing PLT entry for a global symbol.
4829d394
CC		 408 void
409 register_global_plt_entry(unsigned int plt_index, Symbol* gsym);
410
26d3c67d
CC		 411 // Force a COPY relocation for a given symbol.
412 void
413 emit_copy_reloc(Symbol_table*, Symbol*, Output_section*, off_t);
414
94a3fc8b
CC		 415 // Apply an incremental relocation.
416 void
417 apply_relocation(const Relocate_info<64, false>* relinfo,
418 elfcpp::Elf_types<64>::Elf_Addr r_offset,
419 unsigned int r_type,
420 elfcpp::Elf_types<64>::Elf_Swxword r_addend,
421 const Symbol* gsym,
422 unsigned char* view,
423 elfcpp::Elf_types<64>::Elf_Addr address,
424 section_size_type view_size);
425
e291e7b9
ILT		 426 // Add a new reloc argument, returning the index in the vector.
427 size_t
6fa2a40b 428 add_tlsdesc_info(Sized_relobj_file<64, false>* object, unsigned int r_sym)
e291e7b9
ILT		 429 {
430 this->tlsdesc_reloc_info_.push_back(Tlsdesc_info(object, r_sym));
431 return this->tlsdesc_reloc_info_.size() - 1;
432 }
433
2e30d253
ILT		 434 private:
435 // The class which scans relocations.
a036edd8 436 class Scan
2e30d253 437 {
a036edd8
ILT		 438 public:
439 Scan()
440 : issued_non_pic_error_(false)
441 { }
442
95a2c8d6
RS		 443 static inline int
444 get_reference_flags(unsigned int r_type);
445
2e30d253 446 inline void
ad0f2072 447 local(Symbol_table* symtab, Layout* layout, Target_x86_64* target,
6fa2a40b 448 Sized_relobj_file<64, false>* object,
2e30d253 449 unsigned int data_shndx,
07f397ab 450 Output_section* output_section,
2e30d253
ILT		 451 const elfcpp::Rela<64, false>& reloc, unsigned int r_type,
452 const elfcpp::Sym<64, false>& lsym);
453
454 inline void
ad0f2072 455 global(Symbol_table* symtab, Layout* layout, Target_x86_64* target,
6fa2a40b 456 Sized_relobj_file<64, false>* object,
2e30d253 457 unsigned int data_shndx,
07f397ab 458 Output_section* output_section,
2e30d253
ILT		 459 const elfcpp::Rela<64, false>& reloc, unsigned int r_type,
460 Symbol* gsym);
e041f13d 461
21bb3914
ST		 462 inline bool
463 local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
464 Target_x86_64* target,
6fa2a40b 465 Sized_relobj_file<64, false>* object,
21bb3914
ST		 466 unsigned int data_shndx,
467 Output_section* output_section,
468 const elfcpp::Rela<64, false>& reloc,
469 unsigned int r_type,
470 const elfcpp::Sym<64, false>& lsym);
471
472 inline bool
473 global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
474 Target_x86_64* target,
6fa2a40b 475 Sized_relobj_file<64, false>* object,
21bb3914
ST		 476 unsigned int data_shndx,
477 Output_section* output_section,
478 const elfcpp::Rela<64, false>& reloc,
479 unsigned int r_type,
480 Symbol* gsym);
481
a036edd8 482 private:
e041f13d 483 static void
6fa2a40b 484 unsupported_reloc_local(Sized_relobj_file<64, false>*, unsigned int r_type);
e041f13d
ILT		 485
486 static void
6fa2a40b 487 unsupported_reloc_global(Sized_relobj_file<64, false>*, unsigned int r_type,
e041f13d 488 Symbol*);
a036edd8
ILT		 489
490 void
a29b0dad 491 check_non_pic(Relobj*, unsigned int r_type, Symbol*);
a036edd8 492
21bb3914
ST		 493 inline bool
494 possible_function_pointer_reloc(unsigned int r_type);
495
7223e9ca 496 bool
6fa2a40b
CC		 497 reloc_needs_plt_for_ifunc(Sized_relobj_file<64, false>*,
498 unsigned int r_type);
7223e9ca 499
a036edd8
ILT		 500 // Whether we have issued an error about a non-PIC compilation.
501 bool issued_non_pic_error_;
2e30d253
ILT		 502 };
503
504 // The class which implements relocation.
505 class Relocate
506 {
507 public:
508 Relocate()
36171d64 509 : skip_call_tls_get_addr_(false)
2e30d253
ILT		 510 { }
511
512 ~Relocate()
513 {
514 if (this->skip_call_tls_get_addr_)
515 {
516 // FIXME: This needs to specify the location somehow.
a0c4fb0a 517 gold_error(_("missing expected TLS relocation"));
2e30d253
ILT		 518 }
519 }
520
521 // Do a relocation. Return false if the caller should not issue
522 // any warnings about this relocation.
523 inline bool
031cdbed
ILT		 524 relocate(const Relocate_info<64, false>*, Target_x86_64*, Output_section*,
525 size_t relnum, const elfcpp::Rela<64, false>&,
2e30d253
ILT		 526 unsigned int r_type, const Sized_symbol<64>*,
527 const Symbol_value<64>*,
528 unsigned char*, elfcpp::Elf_types<64>::Elf_Addr,
fe8718a4 529 section_size_type);
2e30d253
ILT		 530
531 private:
532 // Do a TLS relocation.
533 inline void
7bf1f802
ILT		 534 relocate_tls(const Relocate_info<64, false>*, Target_x86_64*,
535 size_t relnum, const elfcpp::Rela<64, false>&,
2e30d253
ILT		 536 unsigned int r_type, const Sized_symbol<64>*,
537 const Symbol_value<64>*,
fe8718a4
ILT		 538 unsigned char*, elfcpp::Elf_types<64>::Elf_Addr,
539 section_size_type);
2e30d253 540
c2b45e22 541 // Do a TLS General-Dynamic to Initial-Exec transition.
7bf1f802
ILT		 542 inline void
543 tls_gd_to_ie(const Relocate_info<64, false>*, size_t relnum,
544 Output_segment* tls_segment,
545 const elfcpp::Rela<64, false>&, unsigned int r_type,
546 elfcpp::Elf_types<64>::Elf_Addr value,
547 unsigned char* view,
c2b45e22 548 elfcpp::Elf_types<64>::Elf_Addr,
fe8718a4 549 section_size_type view_size);
7bf1f802 550
56622147
ILT		 551 // Do a TLS General-Dynamic to Local-Exec transition.
552 inline void
553 tls_gd_to_le(const Relocate_info<64, false>*, size_t relnum,
2e30d253
ILT		 554 Output_segment* tls_segment,
555 const elfcpp::Rela<64, false>&, unsigned int r_type,
556 elfcpp::Elf_types<64>::Elf_Addr value,
557 unsigned char* view,
fe8718a4 558 section_size_type view_size);
2e30d253 559
c2b45e22
CC		 560 // Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
561 inline void
562 tls_desc_gd_to_ie(const Relocate_info<64, false>*, size_t relnum,
563 Output_segment* tls_segment,
564 const elfcpp::Rela<64, false>&, unsigned int r_type,
565 elfcpp::Elf_types<64>::Elf_Addr value,
566 unsigned char* view,
567 elfcpp::Elf_types<64>::Elf_Addr,
568 section_size_type view_size);
569
570 // Do a TLSDESC-style General-Dynamic to Local-Exec transition.
571 inline void
572 tls_desc_gd_to_le(const Relocate_info<64, false>*, size_t relnum,
573 Output_segment* tls_segment,
574 const elfcpp::Rela<64, false>&, unsigned int r_type,
575 elfcpp::Elf_types<64>::Elf_Addr value,
576 unsigned char* view,
577 section_size_type view_size);
578
56622147 579 // Do a TLS Local-Dynamic to Local-Exec transition.
2e30d253 580 inline void
56622147 581 tls_ld_to_le(const Relocate_info<64, false>*, size_t relnum,
2e30d253
ILT		 582 Output_segment* tls_segment,
583 const elfcpp::Rela<64, false>&, unsigned int r_type,
584 elfcpp::Elf_types<64>::Elf_Addr value,
585 unsigned char* view,
fe8718a4 586 section_size_type view_size);
2e30d253 587
56622147
ILT		 588 // Do a TLS Initial-Exec to Local-Exec transition.
589 static inline void
590 tls_ie_to_le(const Relocate_info<64, false>*, size_t relnum,
72ec2876
ILT		 591 Output_segment* tls_segment,
592 const elfcpp::Rela<64, false>&, unsigned int r_type,
593 elfcpp::Elf_types<64>::Elf_Addr value,
594 unsigned char* view,
fe8718a4 595 section_size_type view_size);
2e30d253
ILT		 596
597 // This is set if we should skip the next reloc, which should be a
598 // PLT32 reloc against ___tls_get_addr.
599 bool skip_call_tls_get_addr_;
600 };
601
6a74a719
ILT		 602 // A class which returns the size required for a relocation type,
603 // used while scanning relocs during a relocatable link.
604 class Relocatable_size_for_reloc
605 {
606 public:
607 unsigned int
608 get_size_for_reloc(unsigned int, Relobj*);
609 };
610
2e30d253
ILT		 611 // Adjust TLS relocation type based on the options and whether this
612 // is a local symbol.
e041f13d 613 static tls::Tls_optimization
2e30d253
ILT		 614 optimize_tls_reloc(bool is_final, int r_type);
615
616 // Get the GOT section, creating it if necessary.
617 Output_data_got<64, false>*
618 got_section(Symbol_table*, Layout*);
619
96f2030e
ILT		 620 // Get the GOT PLT section.
621 Output_data_space*
622 got_plt_section() const
623 {
624 gold_assert(this->got_plt_ != NULL);
625 return this->got_plt_;
626 }
627
a8df5856
ILT		 628 // Get the GOT section for TLSDESC entries.
629 Output_data_got<64, false>*
630 got_tlsdesc_section() const
631 {
632 gold_assert(this->got_tlsdesc_ != NULL);
633 return this->got_tlsdesc_;
634 }
635
c2b45e22
CC		 636 // Create the PLT section.
637 void
638 make_plt_section(Symbol_table* symtab, Layout* layout);
639
2e30d253
ILT		 640 // Create a PLT entry for a global symbol.
641 void
642 make_plt_entry(Symbol_table*, Layout*, Symbol*);
643
7223e9ca
ILT		 644 // Create a PLT entry for a local STT_GNU_IFUNC symbol.
645 void
646 make_local_ifunc_plt_entry(Symbol_table*, Layout*,
6fa2a40b 647 Sized_relobj_file<64, false>* relobj,
7223e9ca
ILT		 648 unsigned int local_sym_index);
649
9fa33bee 650 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC		 651 void
652 define_tls_base_symbol(Symbol_table*, Layout*);
653
c2b45e22
CC		 654 // Create the reserved PLT and GOT entries for the TLS descriptor resolver.
655 void
656 reserve_tlsdesc_entries(Symbol_table* symtab, Layout* layout);
657
31d60480
ILT		 658 // Create a GOT entry for the TLS module index.
659 unsigned int
660 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
6fa2a40b 661 Sized_relobj_file<64, false>* object);
31d60480 662
2e30d253
ILT		 663 // Get the PLT section.
664 Output_data_plt_x86_64*
665 plt_section() const
666 {
667 gold_assert(this->plt_ != NULL);
668 return this->plt_;
669 }
670
671 // Get the dynamic reloc section, creating it if necessary.
672 Reloc_section*
0ffd9845 673 rela_dyn_section(Layout*);
2e30d253 674
e291e7b9
ILT		 675 // Get the section to use for TLSDESC relocations.
676 Reloc_section*
677 rela_tlsdesc_section(Layout*) const;
678
12c0daef 679 // Add a potential copy relocation.
2e30d253 680 void
ef9beddf 681 copy_reloc(Symbol_table* symtab, Layout* layout,
6fa2a40b 682 Sized_relobj_file<64, false>* object,
12c0daef
ILT		 683 unsigned int shndx, Output_section* output_section,
684 Symbol* sym, const elfcpp::Rela<64, false>& reloc)
685 {
686 this->copy_relocs_.copy_reloc(symtab, layout,
687 symtab->get_sized_symbol<64>(sym),
688 object, shndx, output_section,
689 reloc, this->rela_dyn_section(layout));
690 }
2e30d253
ILT		 691
692 // Information about this specific target which we pass to the
693 // general Target structure.
694 static const Target::Target_info x86_64_info;
695
0e70b911
CC		 696 // The types of GOT entries needed for this platform.
697 // These values are exposed to the ABI in an incremental link.
698 // Do not renumber existing values without changing the version
699 // number of the .gnu_incremental_inputs section.
0a65a3a7
CC		 700 enum Got_type
701 {
702 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
703 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset
704 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
705 GOT_TYPE_TLS_DESC = 3 // GOT entry for TLS_DESC pair
706 };
707
e291e7b9
ILT		 708 // This type is used as the argument to the target specific
709 // relocation routines. The only target specific reloc is
710 // R_X86_64_TLSDESC against a local symbol.
711 struct Tlsdesc_info
712 {
6fa2a40b 713 Tlsdesc_info(Sized_relobj_file<64, false>* a_object, unsigned int a_r_sym)
e291e7b9
ILT		 714 : object(a_object), r_sym(a_r_sym)
715 { }
716
717 // The object in which the local symbol is defined.
6fa2a40b 718 Sized_relobj_file<64, false>* object;
e291e7b9
ILT		 719 // The local symbol index in the object.
720 unsigned int r_sym;
721 };
722
2e30d253
ILT		 723 // The GOT section.
724 Output_data_got<64, false>* got_;
725 // The PLT section.
726 Output_data_plt_x86_64* plt_;
727 // The GOT PLT section.
728 Output_data_space* got_plt_;
a8df5856
ILT		 729 // The GOT section for TLSDESC relocations.
730 Output_data_got<64, false>* got_tlsdesc_;
e785ec03
ILT		 731 // The _GLOBAL_OFFSET_TABLE_ symbol.
732 Symbol* global_offset_table_;
2e30d253 733 // The dynamic reloc section.
0ffd9845 734 Reloc_section* rela_dyn_;
2e30d253 735 // Relocs saved to avoid a COPY reloc.
12c0daef 736 Copy_relocs<elfcpp::SHT_RELA, 64, false> copy_relocs_;
2e30d253
ILT		 737 // Space for variables copied with a COPY reloc.
738 Output_data_space* dynbss_;
c2b45e22 739 // Offset of the GOT entry for the TLS module index.
31d60480 740 unsigned int got_mod_index_offset_;
e291e7b9
ILT		 741 // We handle R_X86_64_TLSDESC against a local symbol as a target
742 // specific relocation. Here we store the object and local symbol
743 // index for the relocation.
744 std::vector<Tlsdesc_info> tlsdesc_reloc_info_;
edfbb029
CC		 745 // True if the _TLS_MODULE_BASE_ symbol has been defined.
746 bool tls_base_symbol_defined_;
2e30d253
ILT		 747};
748
749const Target::Target_info Target_x86_64::x86_64_info =
750{
751 64, // size
752 false, // is_big_endian
753 elfcpp::EM_X86_64, // machine_code
754 false, // has_make_symbol
755 false, // has_resolve
756 true, // has_code_fill
35cdfc9a 757 true, // is_default_stack_executable
0864d551 758 '\0', // wrap_char
2e30d253 759 "/lib/ld64.so.1", // program interpreter
0c5e9c22 760 0x400000, // default_text_segment_address
cd72c291 761 0x1000, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08
ILT		 762 0x1000, // common_pagesize (overridable by -z common-page-size)
763 elfcpp::SHN_UNDEF, // small_common_shndx
764 elfcpp::SHN_X86_64_LCOMMON, // large_common_shndx
765 0, // small_common_section_flags
05a352e6
DK		 766 elfcpp::SHF_X86_64_LARGE, // large_common_section_flags
767 NULL, // attributes_section
768 NULL // attributes_vendor
2e30d253
ILT		 769};
770
8a5e3e08
ILT		 771// This is called when a new output section is created. This is where
772// we handle the SHF_X86_64_LARGE.
773
774void
ca09d69a 775Target_x86_64::do_new_output_section(Output_section* os) const
8a5e3e08
ILT		 776{
777 if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0)
778 os->set_is_large_section();
779}
780
2e30d253
ILT		 781// Get the GOT section, creating it if necessary.
782
783Output_data_got<64, false>*
784Target_x86_64::got_section(Symbol_table* symtab, Layout* layout)
785{
786 if (this->got_ == NULL)
787 {
788 gold_assert(symtab != NULL && layout != NULL);
789
790 this->got_ = new Output_data_got<64, false>();
791
82742395
ILT		 792 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
793 (elfcpp::SHF_ALLOC
794 | elfcpp::SHF_WRITE),
22f0da72
ILT		 795 this->got_, ORDER_RELRO_LAST,
796 true);
2e30d253 797
7d9e3d98 798 this->got_plt_ = new Output_data_space(8, "** GOT PLT");
82742395
ILT		 799 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
800 (elfcpp::SHF_ALLOC
801 | elfcpp::SHF_WRITE),
22f0da72
ILT		 802 this->got_plt_, ORDER_NON_RELRO_FIRST,
803 false);
2e30d253
ILT		 804
805 // The first three entries are reserved.
27bc2bce 806 this->got_plt_->set_current_data_size(3 * 8);
2e30d253 807
1a2dff53
ILT		 808 // Those bytes can go into the relro segment.
809 layout->increase_relro(3 * 8);
810
2e30d253 811 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
e785ec03
ILT		 812 this->global_offset_table_ =
813 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
814 Symbol_table::PREDEFINED,
815 this->got_plt_,
816 0, 0, elfcpp::STT_OBJECT,
817 elfcpp::STB_LOCAL,
818 elfcpp::STV_HIDDEN, 0,
819 false, false);
a8df5856
ILT		 820
821 // If there are any TLSDESC relocations, they get GOT entries in
822 // .got.plt after the jump slot entries.
823 this->got_tlsdesc_ = new Output_data_got<64, false>();
824 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
825 (elfcpp::SHF_ALLOC
826 | elfcpp::SHF_WRITE),
22f0da72
ILT		 827 this->got_tlsdesc_,
828 ORDER_NON_RELRO_FIRST, false);
2e30d253
ILT		 829 }
830
831 return this->got_;
832}
833
834// Get the dynamic reloc section, creating it if necessary.
835
836Target_x86_64::Reloc_section*
0ffd9845 837Target_x86_64::rela_dyn_section(Layout* layout)
2e30d253 838{
0ffd9845 839 if (this->rela_dyn_ == NULL)
2e30d253
ILT		 840 {
841 gold_assert(layout != NULL);
d98bc257 842 this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
2e30d253 843 layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
22f0da72
ILT		 844 elfcpp::SHF_ALLOC, this->rela_dyn_,
845 ORDER_DYNAMIC_RELOCS, false);
2e30d253 846 }
0ffd9845 847 return this->rela_dyn_;
2e30d253
ILT		 848}
849
4829d394 850// Initialize the PLT section.
2e30d253 851
4829d394
CC		 852void
853Output_data_plt_x86_64::init(Symbol_table* symtab, Layout* layout)
2e30d253 854{
d98bc257 855 this->rel_ = new Reloc_section(false);
2e30d253 856 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
22f0da72
ILT		 857 elfcpp::SHF_ALLOC, this->rel_,
858 ORDER_DYNAMIC_PLT_RELOCS, false);
7223e9ca
ILT		 859
860 if (parameters->doing_static_link())
861 {
862 // A statically linked executable will only have a .rela.plt
863 // section to hold R_X86_64_IRELATIVE relocs for STT_GNU_IFUNC
864 // symbols. The library will use these symbols to locate the
865 // IRELATIVE relocs at program startup time.
866 symtab->define_in_output_data("__rela_iplt_start", NULL,
867 Symbol_table::PREDEFINED,
868 this->rel_, 0, 0, elfcpp::STT_NOTYPE,
869 elfcpp::STB_GLOBAL, elfcpp::STV_HIDDEN,
870 0, false, true);
871 symtab->define_in_output_data("__rela_iplt_end", NULL,
872 Symbol_table::PREDEFINED,
873 this->rel_, 0, 0, elfcpp::STT_NOTYPE,
874 elfcpp::STB_GLOBAL, elfcpp::STV_HIDDEN,
875 0, true, true);
876 }
2e30d253
ILT		 877}
878
879void
880Output_data_plt_x86_64::do_adjust_output_section(Output_section* os)
881{
b0481b0b 882 os->set_entsize(plt_entry_size);
2e30d253
ILT		 883}
884
885// Add an entry to the PLT.
886
887void
888Output_data_plt_x86_64::add_entry(Symbol* gsym)
889{
890 gold_assert(!gsym->has_plt_offset());
891
4829d394
CC		 892 unsigned int plt_index;
893 off_t plt_offset;
894 section_offset_type got_offset;
2e30d253 895
4829d394
CC		 896 if (!this->is_data_size_valid())
897 {
898 // Note that when setting the PLT offset we skip the initial
899 // reserved PLT entry.
900 plt_index = this->count_ + 1;
901 plt_offset = plt_index * plt_entry_size;
2e30d253 902
4829d394 903 ++this->count_;
2e30d253 904
4829d394
CC		 905 got_offset = (plt_index - 1 + 3) * 8;
906 gold_assert(got_offset == this->got_plt_->current_data_size());
2e30d253 907
4829d394
CC		 908 // Every PLT entry needs a GOT entry which points back to the PLT
909 // entry (this will be changed by the dynamic linker, normally
910 // lazily when the function is called).
911 this->got_plt_->set_current_data_size(got_offset + 8);
912 }
7223e9ca
ILT		 913 else
914 {
4829d394
CC		 915 // For incremental updates, find an available slot.
916 plt_offset = this->free_list_.allocate(plt_entry_size, plt_entry_size, 0);
917 if (plt_offset == -1)
e6455dfb
CC		 918 gold_fallback(_("out of patch space (PLT);"
919 " relink with --incremental-full"));
4829d394
CC		 920
921 // The GOT and PLT entries have a 1-1 correspondance, so the GOT offset
922 // can be calculated from the PLT index, adjusting for the three
923 // reserved entries at the beginning of the GOT.
924 plt_index = plt_offset / plt_entry_size - 1;
925 got_offset = (plt_index - 1 + 3) * 8;
7223e9ca 926 }
2e30d253 927
4829d394
CC		 928 gsym->set_plt_offset(plt_offset);
929
930 // Every PLT entry needs a reloc.
931 this->add_relocation(gsym, got_offset);
932
2e30d253
ILT		 933 // Note that we don't need to save the symbol. The contents of the
934 // PLT are independent of which symbols are used. The symbols only
935 // appear in the relocations.
936}
937
7223e9ca
ILT		 938// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return
939// the PLT offset.
940
941unsigned int
6fa2a40b
CC		 942Output_data_plt_x86_64::add_local_ifunc_entry(
943 Sized_relobj_file<64, false>* relobj,
944 unsigned int local_sym_index)
7223e9ca
ILT		 945{
946 unsigned int plt_offset = (this->count_ + 1) * plt_entry_size;
947 ++this->count_;
948
949 section_offset_type got_offset = this->got_plt_->current_data_size();
950
951 // Every PLT entry needs a GOT entry which points back to the PLT
952 // entry.
953 this->got_plt_->set_current_data_size(got_offset + 8);
954
955 // Every PLT entry needs a reloc.
956 this->rel_->add_symbolless_local_addend(relobj, local_sym_index,
957 elfcpp::R_X86_64_IRELATIVE,
958 this->got_plt_, got_offset, 0);
959
960 return plt_offset;
961}
962
4829d394
CC		 963// Add the relocation for a PLT entry.
964
965void
966Output_data_plt_x86_64::add_relocation(Symbol* gsym, unsigned int got_offset)
967{
968 if (gsym->type() == elfcpp::STT_GNU_IFUNC
969 && gsym->can_use_relative_reloc(false))
970 this->rel_->add_symbolless_global_addend(gsym, elfcpp::R_X86_64_IRELATIVE,
971 this->got_plt_, got_offset, 0);
972 else
973 {
974 gsym->set_needs_dynsym_entry();
975 this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_,
976 got_offset, 0);
977 }
978}
979
e291e7b9
ILT		 980// Return where the TLSDESC relocations should go, creating it if
981// necessary. These follow the JUMP_SLOT relocations.
982
983Output_data_plt_x86_64::Reloc_section*
984Output_data_plt_x86_64::rela_tlsdesc(Layout* layout)
985{
986 if (this->tlsdesc_rel_ == NULL)
987 {
988 this->tlsdesc_rel_ = new Reloc_section(false);
989 layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
990 elfcpp::SHF_ALLOC, this->tlsdesc_rel_,
22f0da72 991 ORDER_DYNAMIC_PLT_RELOCS, false);
e291e7b9
ILT		 992 gold_assert(this->tlsdesc_rel_->output_section() ==
993 this->rel_->output_section());
994 }
995 return this->tlsdesc_rel_;
996}
997
c2b45e22
CC		 998// Set the final size.
999void
1000Output_data_plt_x86_64::set_final_data_size()
1001{
1002 unsigned int count = this->count_;
1003 if (this->has_tlsdesc_entry())
1004 ++count;
1005 this->set_data_size((count + 1) * plt_entry_size);
1006}
1007
2e30d253
ILT		 1008// The first entry in the PLT for an executable.
1009
1010unsigned char Output_data_plt_x86_64::first_plt_entry[plt_entry_size] =
1011{
1012 // From AMD64 ABI Draft 0.98, page 76
1013 0xff, 0x35, // pushq contents of memory address
2e30d253 1014 0, 0, 0, 0, // replaced with address of .got + 8
78d911fd
ILT		 1015 0xff, 0x25, // jmp indirect
1016 0, 0, 0, 0, // replaced with address of .got + 16
2e30d253
ILT		 1017 0x90, 0x90, 0x90, 0x90 // noop (x4)
1018};
1019
1020// Subsequent entries in the PLT for an executable.
1021
1022unsigned char Output_data_plt_x86_64::plt_entry[plt_entry_size] =
1023{
1024 // From AMD64 ABI Draft 0.98, page 76
1025 0xff, 0x25, // jmpq indirect
1026 0, 0, 0, 0, // replaced with address of symbol in .got
1027 0x68, // pushq immediate
1028 0, 0, 0, 0, // replaced with offset into relocation table
1029 0xe9, // jmpq relative
1030 0, 0, 0, 0 // replaced with offset to start of .plt
1031};
1032
c2b45e22
CC		 1033// The reserved TLSDESC entry in the PLT for an executable.
1034
1035unsigned char Output_data_plt_x86_64::tlsdesc_plt_entry[plt_entry_size] =
1036{
1037 // From Alexandre Oliva, "Thread-Local Storage Descriptors for IA32
1038 // and AMD64/EM64T", Version 0.9.4 (2005-10-10).
1039 0xff, 0x35, // pushq x(%rip)
1040 0, 0, 0, 0, // replaced with address of linkmap GOT entry (at PLTGOT + 8)
1041 0xff, 0x25, // jmpq *y(%rip)
1042 0, 0, 0, 0, // replaced with offset of reserved TLSDESC_GOT entry
1043 0x0f, 0x1f, // nop
1044 0x40, 0
1045};
1046
2e30d253
ILT		 1047// Write out the PLT. This uses the hand-coded instructions above,
1048// and adjusts them as needed. This is specified by the AMD64 ABI.
1049
1050void
1051Output_data_plt_x86_64::do_write(Output_file* of)
1052{
2ea97941 1053 const off_t offset = this->offset();
fe8718a4
ILT		 1054 const section_size_type oview_size =
1055 convert_to_section_size_type(this->data_size());
2ea97941 1056 unsigned char* const oview = of->get_output_view(offset, oview_size);
2e30d253
ILT		 1057
1058 const off_t got_file_offset = this->got_plt_->offset();
fe8718a4
ILT		 1059 const section_size_type got_size =
1060 convert_to_section_size_type(this->got_plt_->data_size());
2e30d253
ILT		 1061 unsigned char* const got_view = of->get_output_view(got_file_offset,
1062 got_size);
1063
1064 unsigned char* pov = oview;
1065
c2b45e22 1066 // The base address of the .plt section.
a984ee1d 1067 elfcpp::Elf_types<64>::Elf_Addr plt_address = this->address();
c2b45e22 1068 // The base address of the .got section.
a984ee1d 1069 elfcpp::Elf_types<64>::Elf_Addr got_base = this->got_->address();
c2b45e22
CC		 1070 // The base address of the PLT portion of the .got section,
1071 // which is where the GOT pointer will point, and where the
1072 // three reserved GOT entries are located.
a984ee1d 1073 elfcpp::Elf_types<64>::Elf_Addr got_address = this->got_plt_->address();
2e30d253
ILT		 1074
1075 memcpy(pov, first_plt_entry, plt_entry_size);
78d911fd 1076 // We do a jmp relative to the PC at the end of this instruction.
a984ee1d
ILT		 1077 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1078 (got_address + 8
1079 - (plt_address + 6)));
1080 elfcpp::Swap<32, false>::writeval(pov + 8,
1081 (got_address + 16
1082 - (plt_address + 12)));
2e30d253
ILT		 1083 pov += plt_entry_size;
1084
1085 unsigned char* got_pov = got_view;
1086
1087 memset(got_pov, 0, 24);
1088 got_pov += 24;
1089
1090 unsigned int plt_offset = plt_entry_size;
1091 unsigned int got_offset = 24;
1092 const unsigned int count = this->count_;
1093 for (unsigned int plt_index = 0;
1094 plt_index < count;
1095 ++plt_index,
1096 pov += plt_entry_size,
1097 got_pov += 8,
1098 plt_offset += plt_entry_size,
1099 got_offset += 8)
1100 {
1101 // Set and adjust the PLT entry itself.
1102 memcpy(pov, plt_entry, plt_entry_size);
78d911fd
ILT		 1103 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1104 (got_address + got_offset
1105 - (plt_address + plt_offset
1106 + 6)));
2e30d253
ILT		 1107
1108 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_index);
1109 elfcpp::Swap<32, false>::writeval(pov + 12,
1110 - (plt_offset + plt_entry_size));
1111
1112 // Set the entry in the GOT.
1113 elfcpp::Swap<64, false>::writeval(got_pov, plt_address + plt_offset + 6);
1114 }
1115
c2b45e22
CC		 1116 if (this->has_tlsdesc_entry())
1117 {
1118 // Set and adjust the reserved TLSDESC PLT entry.
1119 unsigned int tlsdesc_got_offset = this->get_tlsdesc_got_offset();
1120 memcpy(pov, tlsdesc_plt_entry, plt_entry_size);
1121 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1122 (got_address + 8
1123 - (plt_address + plt_offset
1124 + 6)));
1125 elfcpp::Swap_unaligned<32, false>::writeval(pov + 8,
1126 (got_base
1127 + tlsdesc_got_offset
1128 - (plt_address + plt_offset
1129 + 12)));
1130 pov += plt_entry_size;
1131 }
1132
fe8718a4
ILT		 1133 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1134 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
2e30d253 1135
2ea97941 1136 of->write_output_view(offset, oview_size, oview);
2e30d253
ILT		 1137 of->write_output_view(got_file_offset, got_size, got_view);
1138}
1139
c2b45e22 1140// Create the PLT section.
2e30d253
ILT		 1141
1142void
c2b45e22 1143Target_x86_64::make_plt_section(Symbol_table* symtab, Layout* layout)
2e30d253 1144{
2e30d253
ILT		 1145 if (this->plt_ == NULL)
1146 {
1147 // Create the GOT sections first.
1148 this->got_section(symtab, layout);
1149
7223e9ca 1150 this->plt_ = new Output_data_plt_x86_64(symtab, layout, this->got_,
c2b45e22 1151 this->got_plt_);
2e30d253
ILT		 1152 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1153 (elfcpp::SHF_ALLOC
1154 | elfcpp::SHF_EXECINSTR),
22f0da72 1155 this->plt_, ORDER_PLT, false);
7223e9ca
ILT		 1156
1157 // Make the sh_info field of .rela.plt point to .plt.
1158 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1159 rela_plt_os->set_info_section(this->plt_->output_section());
2e30d253 1160 }
c2b45e22
CC		 1161}
1162
e291e7b9
ILT		 1163// Return the section for TLSDESC relocations.
1164
1165Target_x86_64::Reloc_section*
1166Target_x86_64::rela_tlsdesc_section(Layout* layout) const
1167{
1168 return this->plt_section()->rela_tlsdesc(layout);
1169}
1170
c2b45e22
CC		 1171// Create a PLT entry for a global symbol.
1172
1173void
1174Target_x86_64::make_plt_entry(Symbol_table* symtab, Layout* layout,
1175 Symbol* gsym)
1176{
1177 if (gsym->has_plt_offset())
1178 return;
1179
1180 if (this->plt_ == NULL)
1181 this->make_plt_section(symtab, layout);
2e30d253
ILT		 1182
1183 this->plt_->add_entry(gsym);
1184}
1185
7223e9ca
ILT		 1186// Make a PLT entry for a local STT_GNU_IFUNC symbol.
1187
1188void
1189Target_x86_64::make_local_ifunc_plt_entry(Symbol_table* symtab, Layout* layout,
6fa2a40b 1190 Sized_relobj_file<64, false>* relobj,
7223e9ca
ILT		 1191 unsigned int local_sym_index)
1192{
1193 if (relobj->local_has_plt_offset(local_sym_index))
1194 return;
1195 if (this->plt_ == NULL)
1196 this->make_plt_section(symtab, layout);
1197 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(relobj,
1198 local_sym_index);
1199 relobj->set_local_plt_offset(local_sym_index, plt_offset);
1200}
1201
0e70b911
CC		 1202// Return the number of entries in the PLT.
1203
1204unsigned int
1205Target_x86_64::plt_entry_count() const
1206{
1207 if (this->plt_ == NULL)
1208 return 0;
1209 return this->plt_->entry_count();
1210}
1211
1212// Return the offset of the first non-reserved PLT entry.
1213
1214unsigned int
1215Target_x86_64::first_plt_entry_offset() const
1216{
1217 return Output_data_plt_x86_64::first_plt_entry_offset();
1218}
1219
1220// Return the size of each PLT entry.
1221
1222unsigned int
1223Target_x86_64::plt_entry_size() const
1224{
1225 return Output_data_plt_x86_64::get_plt_entry_size();
1226}
1227
4829d394
CC		 1228// Create the GOT and PLT sections for an incremental update.
1229
1230Output_data_got<64, false>*
1231Target_x86_64::init_got_plt_for_update(Symbol_table* symtab,
1232 Layout* layout,
1233 unsigned int got_count,
1234 unsigned int plt_count)
1235{
1236 gold_assert(this->got_ == NULL);
1237
1238 this->got_ = new Output_data_got<64, false>(got_count * 8);
1239 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
1240 (elfcpp::SHF_ALLOC
1241 | elfcpp::SHF_WRITE),
1242 this->got_, ORDER_RELRO_LAST,
1243 true);
1244
1245 // Add the three reserved entries.
1246 this->got_plt_ = new Output_data_space((plt_count + 3) * 8, 8, "** GOT PLT");
1247 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1248 (elfcpp::SHF_ALLOC
1249 | elfcpp::SHF_WRITE),
1250 this->got_plt_, ORDER_NON_RELRO_FIRST,
1251 false);
1252
1253 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
1254 this->global_offset_table_ =
1255 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
1256 Symbol_table::PREDEFINED,
1257 this->got_plt_,
1258 0, 0, elfcpp::STT_OBJECT,
1259 elfcpp::STB_LOCAL,
1260 elfcpp::STV_HIDDEN, 0,
1261 false, false);
1262
1263 // If there are any TLSDESC relocations, they get GOT entries in
1264 // .got.plt after the jump slot entries.
1265 // FIXME: Get the count for TLSDESC entries.
1266 this->got_tlsdesc_ = new Output_data_got<64, false>(0);
1267 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
1268 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
1269 this->got_tlsdesc_,
1270 ORDER_NON_RELRO_FIRST, false);
1271
1272 // Create the PLT section.
1273 this->plt_ = new Output_data_plt_x86_64(symtab, layout, this->got_,
1274 this->got_plt_, plt_count);
1275 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1276 elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR,
1277 this->plt_, ORDER_PLT, false);
1278
1279 // Make the sh_info field of .rela.plt point to .plt.
1280 Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
1281 rela_plt_os->set_info_section(this->plt_->output_section());
1282
6fa2a40b
CC		 1283 // Create the rela_dyn section.
1284 this->rela_dyn_section(layout);
1285
4829d394
CC		 1286 return this->got_;
1287}
1288
6fa2a40b
CC		 1289// Reserve a GOT entry for a local symbol, and regenerate any
1290// necessary dynamic relocations.
1291
1292void
1293Target_x86_64::reserve_local_got_entry(
1294 unsigned int got_index,
1295 Sized_relobj<64, false>* obj,
1296 unsigned int r_sym,
1297 unsigned int got_type)
1298{
1299 unsigned int got_offset = got_index * 8;
1300 Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1301
1302 this->got_->reserve_local(got_index, obj, r_sym, got_type);
1303 switch (got_type)
1304 {
1305 case GOT_TYPE_STANDARD:
1306 if (parameters->options().output_is_position_independent())
1307 rela_dyn->add_local_relative(obj, r_sym, elfcpp::R_X86_64_RELATIVE,
1308 this->got_, got_offset, 0);
1309 break;
1310 case GOT_TYPE_TLS_OFFSET:
1311 rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_TPOFF64,
1312 this->got_, got_offset, 0);
1313 break;
1314 case GOT_TYPE_TLS_PAIR:
1315 this->got_->reserve_slot(got_index + 1);
1316 rela_dyn->add_local(obj, r_sym, elfcpp::R_X86_64_DTPMOD64,
1317 this->got_, got_offset, 0);
1318 break;
1319 case GOT_TYPE_TLS_DESC:
1320 gold_fatal(_("TLS_DESC not yet supported for incremental linking"));
1321 // this->got_->reserve_slot(got_index + 1);
1322 // rela_dyn->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1323 // this->got_, got_offset, 0);
1324 break;
1325 default:
1326 gold_unreachable();
1327 }
1328}
1329
1330// Reserve a GOT entry for a global symbol, and regenerate any
1331// necessary dynamic relocations.
1332
1333void
1334Target_x86_64::reserve_global_got_entry(unsigned int got_index, Symbol* gsym,
1335 unsigned int got_type)
1336{
1337 unsigned int got_offset = got_index * 8;
1338 Reloc_section* rela_dyn = this->rela_dyn_section(NULL);
1339
1340 this->got_->reserve_global(got_index, gsym, got_type);
1341 switch (got_type)
1342 {
1343 case GOT_TYPE_STANDARD:
1344 if (!gsym->final_value_is_known())
1345 {
1346 if (gsym->is_from_dynobj()
1347 || gsym->is_undefined()
1348 || gsym->is_preemptible()
1349 || gsym->type() == elfcpp::STT_GNU_IFUNC)
1350 rela_dyn->add_global(gsym, elfcpp::R_X86_64_GLOB_DAT,
1351 this->got_, got_offset, 0);
1352 else
1353 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
1354 this->got_, got_offset, 0);
1355 }
1356 break;
1357 case GOT_TYPE_TLS_OFFSET:
1358 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TPOFF64,
1359 this->got_, got_offset, 0);
1360 break;
1361 case GOT_TYPE_TLS_PAIR:
1362 this->got_->reserve_slot(got_index + 1);
1363 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPMOD64,
1364 this->got_, got_offset, 0);
1365 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_DTPOFF64,
1366 this->got_, got_offset + 8, 0);
1367 break;
1368 case GOT_TYPE_TLS_DESC:
1369 this->got_->reserve_slot(got_index + 1);
1370 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_TLSDESC,
1371 this->got_, got_offset, 0);
1372 break;
1373 default:
1374 gold_unreachable();
1375 }
1376}
1377
4829d394
CC		 1378// Register an existing PLT entry for a global symbol.
1379
1380void
1381Target_x86_64::register_global_plt_entry(unsigned int plt_index,
1382 Symbol* gsym)
1383{
1384 gold_assert(this->plt_ != NULL);
1385 gold_assert(!gsym->has_plt_offset());
1386
1387 this->plt_->reserve_slot(plt_index);
1388
1389 gsym->set_plt_offset((plt_index + 1) * this->plt_entry_size());
1390
1391 unsigned int got_offset = (plt_index + 3) * 8;
1392 this->plt_->add_relocation(gsym, got_offset);
1393}
1394
26d3c67d
CC		 1395// Force a COPY relocation for a given symbol.
1396
1397void
1398Target_x86_64::emit_copy_reloc(
1399 Symbol_table* symtab, Symbol* sym, Output_section* os, off_t offset)
1400{
1401 this->copy_relocs_.emit_copy_reloc(symtab,
1402 symtab->get_sized_symbol<64>(sym),
1403 os,
1404 offset,
1405 this->rela_dyn_section(NULL));
1406}
1407
9fa33bee 1408// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC		 1409
1410void
1411Target_x86_64::define_tls_base_symbol(Symbol_table* symtab, Layout* layout)
1412{
1413 if (this->tls_base_symbol_defined_)
1414 return;
1415
1416 Output_segment* tls_segment = layout->tls_segment();
1417 if (tls_segment != NULL)
1418 {
183fd0e3 1419 bool is_exec = parameters->options().output_is_executable();
edfbb029 1420 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
99fff23b 1421 Symbol_table::PREDEFINED,
edfbb029
CC		 1422 tls_segment, 0, 0,
1423 elfcpp::STT_TLS,
1424 elfcpp::STB_LOCAL,
1425 elfcpp::STV_HIDDEN, 0,
183fd0e3
AO		 1426 (is_exec
1427 ? Symbol::SEGMENT_END
1428 : Symbol::SEGMENT_START),
1429 true);
edfbb029
CC		 1430 }
1431 this->tls_base_symbol_defined_ = true;
1432}
1433
c2b45e22
CC		 1434// Create the reserved PLT and GOT entries for the TLS descriptor resolver.
1435
1436void
1437Target_x86_64::reserve_tlsdesc_entries(Symbol_table* symtab,
1438 Layout* layout)
1439{
1440 if (this->plt_ == NULL)
1441 this->make_plt_section(symtab, layout);
1442
1443 if (!this->plt_->has_tlsdesc_entry())
1444 {
1445 // Allocate the TLSDESC_GOT entry.
1446 Output_data_got<64, false>* got = this->got_section(symtab, layout);
1447 unsigned int got_offset = got->add_constant(0);
1448
1449 // Allocate the TLSDESC_PLT entry.
1450 this->plt_->reserve_tlsdesc_entry(got_offset);
1451 }
1452}
1453
31d60480
ILT		 1454// Create a GOT entry for the TLS module index.
1455
1456unsigned int
1457Target_x86_64::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
6fa2a40b 1458 Sized_relobj_file<64, false>* object)
31d60480
ILT		 1459{
1460 if (this->got_mod_index_offset_ == -1U)
1461 {
1462 gold_assert(symtab != NULL && layout != NULL && object != NULL);
1463 Reloc_section* rela_dyn = this->rela_dyn_section(layout);
1464 Output_data_got<64, false>* got = this->got_section(symtab, layout);
1465 unsigned int got_offset = got->add_constant(0);
1466 rela_dyn->add_local(object, 0, elfcpp::R_X86_64_DTPMOD64, got,
1467 got_offset, 0);
009a67a2 1468 got->add_constant(0);
31d60480
ILT		 1469 this->got_mod_index_offset_ = got_offset;
1470 }
1471 return this->got_mod_index_offset_;
1472}
1473
2e30d253
ILT		 1474// Optimize the TLS relocation type based on what we know about the
1475// symbol. IS_FINAL is true if the final address of this symbol is
1476// known at link time.
1477
e041f13d 1478tls::Tls_optimization
2e30d253
ILT		 1479Target_x86_64::optimize_tls_reloc(bool is_final, int r_type)
1480{
2e30d253
ILT		 1481 // If we are generating a shared library, then we can't do anything
1482 // in the linker.
8851ecca 1483 if (parameters->options().shared())
e041f13d 1484 return tls::TLSOPT_NONE;
2e30d253
ILT		 1485
1486 switch (r_type)
1487 {
1488 case elfcpp::R_X86_64_TLSGD:
e041f13d
ILT		 1489 case elfcpp::R_X86_64_GOTPC32_TLSDESC:
1490 case elfcpp::R_X86_64_TLSDESC_CALL:
1491 // These are General-Dynamic which permits fully general TLS
2e30d253
ILT		 1492 // access. Since we know that we are generating an executable,
1493 // we can convert this to Initial-Exec. If we also know that
1494 // this is a local symbol, we can further switch to Local-Exec.
1495 if (is_final)
e041f13d
ILT		 1496 return tls::TLSOPT_TO_LE;
1497 return tls::TLSOPT_TO_IE;
2e30d253 1498
d61c17ea 1499 case elfcpp::R_X86_64_TLSLD:
2e30d253
ILT		 1500 // This is Local-Dynamic, which refers to a local symbol in the
1501 // dynamic TLS block. Since we know that we generating an
1502 // executable, we can switch to Local-Exec.
e041f13d 1503 return tls::TLSOPT_TO_LE;
2e30d253 1504
0ffd9845 1505 case elfcpp::R_X86_64_DTPOFF32:
0ffd9845
ILT		 1506 case elfcpp::R_X86_64_DTPOFF64:
1507 // Another Local-Dynamic reloc.
e041f13d 1508 return tls::TLSOPT_TO_LE;
0ffd9845 1509
d61c17ea 1510 case elfcpp::R_X86_64_GOTTPOFF:
2e30d253
ILT		 1511 // These are Initial-Exec relocs which get the thread offset
1512 // from the GOT. If we know that we are linking against the
1513 // local symbol, we can switch to Local-Exec, which links the
1514 // thread offset into the instruction.
1515 if (is_final)
e041f13d
ILT		 1516 return tls::TLSOPT_TO_LE;
1517 return tls::TLSOPT_NONE;
2e30d253 1518
d61c17ea 1519 case elfcpp::R_X86_64_TPOFF32:
2e30d253
ILT		 1520 // When we already have Local-Exec, there is nothing further we
1521 // can do.
e041f13d 1522 return tls::TLSOPT_NONE;
2e30d253
ILT		 1523
1524 default:
1525 gold_unreachable();
1526 }
2e30d253
ILT		 1527}
1528
95a2c8d6
RS		 1529// Get the Reference_flags for a particular relocation.
1530
1531int
1532Target_x86_64::Scan::get_reference_flags(unsigned int r_type)
1533{
1534 switch (r_type)
1535 {
1536 case elfcpp::R_X86_64_NONE:
1537 case elfcpp::R_X86_64_GNU_VTINHERIT:
1538 case elfcpp::R_X86_64_GNU_VTENTRY:
1539 case elfcpp::R_X86_64_GOTPC32:
1540 case elfcpp::R_X86_64_GOTPC64:
1541 // No symbol reference.
1542 return 0;
1543
1544 case elfcpp::R_X86_64_64:
1545 case elfcpp::R_X86_64_32:
1546 case elfcpp::R_X86_64_32S:
1547 case elfcpp::R_X86_64_16:
1548 case elfcpp::R_X86_64_8:
1549 return Symbol::ABSOLUTE_REF;
1550
1551 case elfcpp::R_X86_64_PC64:
1552 case elfcpp::R_X86_64_PC32:
1553 case elfcpp::R_X86_64_PC16:
1554 case elfcpp::R_X86_64_PC8:
1555 case elfcpp::R_X86_64_GOTOFF64:
1556 return Symbol::RELATIVE_REF;
1557
1558 case elfcpp::R_X86_64_PLT32:
1559 case elfcpp::R_X86_64_PLTOFF64:
1560 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
1561
1562 case elfcpp::R_X86_64_GOT64:
1563 case elfcpp::R_X86_64_GOT32:
1564 case elfcpp::R_X86_64_GOTPCREL64:
1565 case elfcpp::R_X86_64_GOTPCREL:
1566 case elfcpp::R_X86_64_GOTPLT64:
1567 // Absolute in GOT.
1568 return Symbol::ABSOLUTE_REF;
1569
1570 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
1571 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
1572 case elfcpp::R_X86_64_TLSDESC_CALL:
1573 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
1574 case elfcpp::R_X86_64_DTPOFF32:
1575 case elfcpp::R_X86_64_DTPOFF64:
1576 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
1577 case elfcpp::R_X86_64_TPOFF32: // Local-exec
1578 return Symbol::TLS_REF;
1579
1580 case elfcpp::R_X86_64_COPY:
1581 case elfcpp::R_X86_64_GLOB_DAT:
1582 case elfcpp::R_X86_64_JUMP_SLOT:
1583 case elfcpp::R_X86_64_RELATIVE:
1584 case elfcpp::R_X86_64_IRELATIVE:
1585 case elfcpp::R_X86_64_TPOFF64:
1586 case elfcpp::R_X86_64_DTPMOD64:
1587 case elfcpp::R_X86_64_TLSDESC:
1588 case elfcpp::R_X86_64_SIZE32:
1589 case elfcpp::R_X86_64_SIZE64:
1590 default:
1591 // Not expected. We will give an error later.
1592 return 0;
1593 }
1594}
1595
e041f13d
ILT		 1596// Report an unsupported relocation against a local symbol.
1597
1598void
6fa2a40b
CC		 1599Target_x86_64::Scan::unsupported_reloc_local(
1600 Sized_relobj_file<64, false>* object,
1601 unsigned int r_type)
e041f13d 1602{
75f2446e
ILT		 1603 gold_error(_("%s: unsupported reloc %u against local symbol"),
1604 object->name().c_str(), r_type);
e041f13d
ILT		 1605}
1606
a036edd8
ILT		 1607// We are about to emit a dynamic relocation of type R_TYPE. If the
1608// dynamic linker does not support it, issue an error. The GNU linker
1609// only issues a non-PIC error for an allocated read-only section.
1610// Here we know the section is allocated, but we don't know that it is
1611// read-only. But we check for all the relocation types which the
1612// glibc dynamic linker supports, so it seems appropriate to issue an
a29b0dad
ILT		 1613// error even if the section is not read-only. If GSYM is not NULL,
1614// it is the symbol the relocation is against; if it is NULL, the
1615// relocation is against a local symbol.
a036edd8
ILT		 1616
1617void
a29b0dad
ILT		 1618Target_x86_64::Scan::check_non_pic(Relobj* object, unsigned int r_type,
1619 Symbol* gsym)
a036edd8
ILT		 1620{
1621 switch (r_type)
1622 {
2fbb4320
ILT		 1623 // These are the relocation types supported by glibc for x86_64
1624 // which should always work.
a036edd8 1625 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 1626 case elfcpp::R_X86_64_IRELATIVE:
a036edd8
ILT		 1627 case elfcpp::R_X86_64_GLOB_DAT:
1628 case elfcpp::R_X86_64_JUMP_SLOT:
1629 case elfcpp::R_X86_64_DTPMOD64:
1630 case elfcpp::R_X86_64_DTPOFF64:
1631 case elfcpp::R_X86_64_TPOFF64:
1632 case elfcpp::R_X86_64_64:
2fbb4320
ILT		 1633 case elfcpp::R_X86_64_COPY:
1634 return;
1635
1636 // glibc supports these reloc types, but they can overflow.
a036edd8 1637 case elfcpp::R_X86_64_PC32:
a29b0dad
ILT		 1638 // A PC relative reference is OK against a local symbol or if
1639 // the symbol is defined locally.
1640 if (gsym == NULL
1641 || (!gsym->is_from_dynobj()
1642 && !gsym->is_undefined()
1643 && !gsym->is_preemptible()))
1644 return;
1645 /* Fall through. */
1646 case elfcpp::R_X86_64_32:
2fbb4320
ILT		 1647 if (this->issued_non_pic_error_)
1648 return;
1649 gold_assert(parameters->options().output_is_position_independent());
a29b0dad
ILT		 1650 if (gsym == NULL)
1651 object->error(_("requires dynamic R_X86_64_32 reloc which may "
1652 "overflow at runtime; recompile with -fPIC"));
1653 else
1654 object->error(_("requires dynamic %s reloc against '%s' which may "
1655 "overflow at runtime; recompile with -fPIC"),
1656 (r_type == elfcpp::R_X86_64_32
1657 ? "R_X86_64_32"
1658 : "R_X86_64_PC32"),
1659 gsym->name());
2fbb4320 1660 this->issued_non_pic_error_ = true;
a036edd8
ILT		 1661 return;
1662
1663 default:
1664 // This prevents us from issuing more than one error per reloc
1665 // section. But we can still wind up issuing more than one
1666 // error per object file.
1667 if (this->issued_non_pic_error_)
1668 return;
33aea2fd 1669 gold_assert(parameters->options().output_is_position_independent());
a29b0dad
ILT		 1670 object->error(_("requires unsupported dynamic reloc %u; "
1671 "recompile with -fPIC"),
1672 r_type);
a036edd8
ILT		 1673 this->issued_non_pic_error_ = true;
1674 return;
1675
1676 case elfcpp::R_X86_64_NONE:
1677 gold_unreachable();
1678 }
1679}
1680
7223e9ca
ILT		 1681// Return whether we need to make a PLT entry for a relocation of the
1682// given type against a STT_GNU_IFUNC symbol.
1683
1684bool
6fa2a40b
CC		 1685Target_x86_64::Scan::reloc_needs_plt_for_ifunc(
1686 Sized_relobj_file<64, false>* object,
1687 unsigned int r_type)
7223e9ca 1688{
95a2c8d6
RS		 1689 int flags = Scan::get_reference_flags(r_type);
1690 if (flags & Symbol::TLS_REF)
1691 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
1692 object->name().c_str(), r_type);
1693 return flags != 0;
7223e9ca
ILT		 1694}
1695
2e30d253
ILT		 1696// Scan a relocation for a local symbol.
1697
1698inline void
ad0f2072 1699Target_x86_64::Scan::local(Symbol_table* symtab,
d61c17ea
ILT		 1700 Layout* layout,
1701 Target_x86_64* target,
6fa2a40b 1702 Sized_relobj_file<64, false>* object,
0ffd9845 1703 unsigned int data_shndx,
4f4c5f80 1704 Output_section* output_section,
0ffd9845 1705 const elfcpp::Rela<64, false>& reloc,
d61c17ea 1706 unsigned int r_type,
7bf1f802 1707 const elfcpp::Sym<64, false>& lsym)
2e30d253 1708{
7223e9ca
ILT		 1709 // A local STT_GNU_IFUNC symbol may require a PLT entry.
1710 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC
1711 && this->reloc_needs_plt_for_ifunc(object, r_type))
1712 {
1713 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
1714 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
1715 }
1716
2e30d253
ILT		 1717 switch (r_type)
1718 {
1719 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 1720 case elfcpp::R_X86_64_GNU_VTINHERIT:
1721 case elfcpp::R_X86_64_GNU_VTENTRY:
2e30d253
ILT		 1722 break;
1723
1724 case elfcpp::R_X86_64_64:
d61c6bd4 1725 // If building a shared library (or a position-independent
dceae3c1
ILT		 1726 // executable), we need to create a dynamic relocation for this
1727 // location. The relocation applied at link time will apply the
1728 // link-time value, so we flag the location with an
1729 // R_X86_64_RELATIVE relocation so the dynamic loader can
d61c6bd4 1730 // relocate it easily.
8851ecca 1731 if (parameters->options().output_is_position_independent())
d61c6bd4 1732 {
e8c846c3 1733 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
d61c6bd4 1734 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7223e9ca
ILT		 1735 rela_dyn->add_local_relative(object, r_sym,
1736 elfcpp::R_X86_64_RELATIVE,
1737 output_section, data_shndx,
1738 reloc.get_r_offset(),
1739 reloc.get_r_addend());
d61c6bd4
ILT		 1740 }
1741 break;
1742
2e30d253
ILT		 1743 case elfcpp::R_X86_64_32:
1744 case elfcpp::R_X86_64_32S:
1745 case elfcpp::R_X86_64_16:
1746 case elfcpp::R_X86_64_8:
96f2030e 1747 // If building a shared library (or a position-independent
dceae3c1
ILT		 1748 // executable), we need to create a dynamic relocation for this
1749 // location. We can't use an R_X86_64_RELATIVE relocation
1750 // because that is always a 64-bit relocation.
8851ecca 1751 if (parameters->options().output_is_position_independent())
96f2030e 1752 {
a29b0dad 1753 this->check_non_pic(object, r_type, NULL);
a036edd8 1754
96f2030e 1755 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
d491d34e 1756 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
dceae3c1 1757 if (lsym.get_st_type() != elfcpp::STT_SECTION)
d491d34e
ILT		 1758 rela_dyn->add_local(object, r_sym, r_type, output_section,
1759 data_shndx, reloc.get_r_offset(),
1760 reloc.get_r_addend());
dceae3c1
ILT		 1761 else
1762 {
1763 gold_assert(lsym.get_st_value() == 0);
d491d34e
ILT		 1764 unsigned int shndx = lsym.get_st_shndx();
1765 bool is_ordinary;
1766 shndx = object->adjust_sym_shndx(r_sym, shndx,
1767 &is_ordinary);
1768 if (!is_ordinary)
1769 object->error(_("section symbol %u has bad shndx %u"),
1770 r_sym, shndx);
1771 else
1772 rela_dyn->add_local_section(object, shndx,
1773 r_type, output_section,
1774 data_shndx, reloc.get_r_offset(),
1775 reloc.get_r_addend());
dceae3c1 1776 }
96f2030e 1777 }
2e30d253
ILT		 1778 break;
1779
1780 case elfcpp::R_X86_64_PC64:
1781 case elfcpp::R_X86_64_PC32:
1782 case elfcpp::R_X86_64_PC16:
1783 case elfcpp::R_X86_64_PC8:
1784 break;
1785
f389a824
ILT		 1786 case elfcpp::R_X86_64_PLT32:
1787 // Since we know this is a local symbol, we can handle this as a
1788 // PC32 reloc.
1789 break;
1790
fdc2f80f 1791 case elfcpp::R_X86_64_GOTPC32:
e822f2b1 1792 case elfcpp::R_X86_64_GOTOFF64:
fdc2f80f
ILT		 1793 case elfcpp::R_X86_64_GOTPC64:
1794 case elfcpp::R_X86_64_PLTOFF64:
2e30d253
ILT		 1795 // We need a GOT section.
1796 target->got_section(symtab, layout);
ee9e9e86
ILT		 1797 // For PLTOFF64, we'd normally want a PLT section, but since we
1798 // know this is a local symbol, no PLT is needed.
2e30d253
ILT		 1799 break;
1800
0ffd9845
ILT		 1801 case elfcpp::R_X86_64_GOT64:
1802 case elfcpp::R_X86_64_GOT32:
1803 case elfcpp::R_X86_64_GOTPCREL64:
1804 case elfcpp::R_X86_64_GOTPCREL:
ee9e9e86 1805 case elfcpp::R_X86_64_GOTPLT64:
0ffd9845
ILT		 1806 {
1807 // The symbol requires a GOT entry.
1808 Output_data_got<64, false>* got = target->got_section(symtab, layout);
1809 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
7223e9ca
ILT		 1810
1811 // For a STT_GNU_IFUNC symbol we want the PLT offset. That
1812 // lets function pointers compare correctly with shared
1813 // libraries. Otherwise we would need an IRELATIVE reloc.
1814 bool is_new;
1815 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1816 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
1817 else
1818 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1819 if (is_new)
0ffd9845
ILT		 1820 {
1821 // If we are generating a shared object, we need to add a
7bf1f802 1822 // dynamic relocation for this symbol's GOT entry.
8851ecca 1823 if (parameters->options().output_is_position_independent())
0ffd9845
ILT		 1824 {
1825 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7bf1f802
ILT		 1826 // R_X86_64_RELATIVE assumes a 64-bit relocation.
1827 if (r_type != elfcpp::R_X86_64_GOT32)
7223e9ca
ILT		 1828 {
1829 unsigned int got_offset =
1830 object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
1831 rela_dyn->add_local_relative(object, r_sym,
1832 elfcpp::R_X86_64_RELATIVE,
1833 got, got_offset, 0);
1834 }
7bf1f802 1835 else
dceae3c1 1836 {
a29b0dad 1837 this->check_non_pic(object, r_type, NULL);
a036edd8 1838
dceae3c1 1839 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
0a65a3a7
CC		 1840 rela_dyn->add_local(
1841 object, r_sym, r_type, got,
1842 object->local_got_offset(r_sym, GOT_TYPE_STANDARD), 0);
dceae3c1 1843 }
0ffd9845
ILT		 1844 }
1845 }
ee9e9e86
ILT		 1846 // For GOTPLT64, we'd normally want a PLT section, but since
1847 // we know this is a local symbol, no PLT is needed.
0ffd9845
ILT		 1848 }
1849 break;
1850
2e30d253
ILT		 1851 case elfcpp::R_X86_64_COPY:
1852 case elfcpp::R_X86_64_GLOB_DAT:
1853 case elfcpp::R_X86_64_JUMP_SLOT:
1854 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 1855 case elfcpp::R_X86_64_IRELATIVE:
d61c17ea 1856 // These are outstanding tls relocs, which are unexpected when linking
2e30d253 1857 case elfcpp::R_X86_64_TPOFF64:
2e30d253 1858 case elfcpp::R_X86_64_DTPMOD64:
2e30d253 1859 case elfcpp::R_X86_64_TLSDESC:
75f2446e
ILT		 1860 gold_error(_("%s: unexpected reloc %u in object file"),
1861 object->name().c_str(), r_type);
2e30d253
ILT		 1862 break;
1863
d61c17ea 1864 // These are initial tls relocs, which are expected when linking
56622147
ILT		 1865 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
1866 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
e041f13d 1867 case elfcpp::R_X86_64_TLSDESC_CALL:
56622147 1868 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
0ffd9845
ILT		 1869 case elfcpp::R_X86_64_DTPOFF32:
1870 case elfcpp::R_X86_64_DTPOFF64:
56622147
ILT		 1871 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
1872 case elfcpp::R_X86_64_TPOFF32: // Local-exec
2e30d253 1873 {
8851ecca 1874 bool output_is_shared = parameters->options().shared();
e041f13d
ILT		 1875 const tls::Tls_optimization optimized_type
1876 = Target_x86_64::optimize_tls_reloc(!output_is_shared, r_type);
2e30d253
ILT		 1877 switch (r_type)
1878 {
56622147 1879 case elfcpp::R_X86_64_TLSGD: // General-dynamic
7bf1f802
ILT		 1880 if (optimized_type == tls::TLSOPT_NONE)
1881 {
1882 // Create a pair of GOT entries for the module index and
1883 // dtv-relative offset.
1884 Output_data_got<64, false>* got
1885 = target->got_section(symtab, layout);
1886 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
d491d34e
ILT		 1887 unsigned int shndx = lsym.get_st_shndx();
1888 bool is_ordinary;
1889 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1890 if (!is_ordinary)
1891 object->error(_("local symbol %u has bad shndx %u"),
1892 r_sym, shndx);
1893 else
1894 got->add_local_pair_with_rela(object, r_sym,
1895 shndx,
1896 GOT_TYPE_TLS_PAIR,
1897 target->rela_dyn_section(layout),
1898 elfcpp::R_X86_64_DTPMOD64, 0);
7bf1f802
ILT		 1899 }
1900 else if (optimized_type != tls::TLSOPT_TO_LE)
1901 unsupported_reloc_local(object, r_type);
1902 break;
1903
56622147 1904 case elfcpp::R_X86_64_GOTPC32_TLSDESC:
edfbb029 1905 target->define_tls_base_symbol(symtab, layout);
c2b45e22
CC		 1906 if (optimized_type == tls::TLSOPT_NONE)
1907 {
1908 // Create reserved PLT and GOT entries for the resolver.
1909 target->reserve_tlsdesc_entries(symtab, layout);
1910
a8df5856
ILT		 1911 // Generate a double GOT entry with an
1912 // R_X86_64_TLSDESC reloc. The R_X86_64_TLSDESC reloc
1913 // is resolved lazily, so the GOT entry needs to be in
1914 // an area in .got.plt, not .got. Call got_section to
1915 // make sure the section has been created.
1916 target->got_section(symtab, layout);
1917 Output_data_got<64, false>* got = target->got_tlsdesc_section();
c2b45e22 1918 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
e291e7b9
ILT		 1919 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC))
1920 {
1921 unsigned int got_offset = got->add_constant(0);
1922 got->add_constant(0);
1923 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC,
1924 got_offset);
1925 Reloc_section* rt = target->rela_tlsdesc_section(layout);
1926 // We store the arguments we need in a vector, and
1927 // use the index into the vector as the parameter
1928 // to pass to the target specific routines.
1929 uintptr_t intarg = target->add_tlsdesc_info(object, r_sym);
1930 void* arg = reinterpret_cast<void*>(intarg);
1931 rt->add_target_specific(elfcpp::R_X86_64_TLSDESC, arg,
1932 got, got_offset, 0);
1933 }
c2b45e22
CC		 1934 }
1935 else if (optimized_type != tls::TLSOPT_TO_LE)
56622147 1936 unsupported_reloc_local(object, r_type);
2e30d253
ILT		 1937 break;
1938
c2b45e22
CC		 1939 case elfcpp::R_X86_64_TLSDESC_CALL:
1940 break;
1941
e041f13d 1942 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
7bf1f802
ILT		 1943 if (optimized_type == tls::TLSOPT_NONE)
1944 {
1945 // Create a GOT entry for the module index.
31d60480 1946 target->got_mod_index_entry(symtab, layout, object);
7bf1f802
ILT		 1947 }
1948 else if (optimized_type != tls::TLSOPT_TO_LE)
1949 unsupported_reloc_local(object, r_type);
1950 break;
1951
0ffd9845
ILT		 1952 case elfcpp::R_X86_64_DTPOFF32:
1953 case elfcpp::R_X86_64_DTPOFF64:
e041f13d
ILT		 1954 break;
1955
56622147 1956 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
535890bb 1957 layout->set_has_static_tls();
7bf1f802
ILT		 1958 if (optimized_type == tls::TLSOPT_NONE)
1959 {
1960 // Create a GOT entry for the tp-relative offset.
1961 Output_data_got<64, false>* got
1962 = target->got_section(symtab, layout);
1963 unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
0a65a3a7 1964 got->add_local_with_rela(object, r_sym, GOT_TYPE_TLS_OFFSET,
7bf1f802
ILT		 1965 target->rela_dyn_section(layout),
1966 elfcpp::R_X86_64_TPOFF64);
1967 }
1968 else if (optimized_type != tls::TLSOPT_TO_LE)
56622147
ILT		 1969 unsupported_reloc_local(object, r_type);
1970 break;
0ffd9845 1971
56622147 1972 case elfcpp::R_X86_64_TPOFF32: // Local-exec
535890bb 1973 layout->set_has_static_tls();
7bf1f802
ILT		 1974 if (output_is_shared)
1975 unsupported_reloc_local(object, r_type);
2e30d253 1976 break;
e041f13d
ILT		 1977
1978 default:
1979 gold_unreachable();
2e30d253
ILT		 1980 }
1981 }
1982 break;
2e30d253 1983
fdc2f80f
ILT		 1984 case elfcpp::R_X86_64_SIZE32:
1985 case elfcpp::R_X86_64_SIZE64:
2e30d253 1986 default:
75f2446e
ILT		 1987 gold_error(_("%s: unsupported reloc %u against local symbol"),
1988 object->name().c_str(), r_type);
2e30d253
ILT		 1989 break;
1990 }
1991}
1992
1993
e041f13d
ILT		 1994// Report an unsupported relocation against a global symbol.
1995
1996void
6fa2a40b
CC		 1997Target_x86_64::Scan::unsupported_reloc_global(
1998 Sized_relobj_file<64, false>* object,
1999 unsigned int r_type,
2000 Symbol* gsym)
e041f13d 2001{
75f2446e 2002 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
a2b1aa12 2003 object->name().c_str(), r_type, gsym->demangled_name().c_str());
e041f13d
ILT		 2004}
2005
ce97fa81 2006// Returns true if this relocation type could be that of a function pointer.
21bb3914
ST		 2007inline bool
2008Target_x86_64::Scan::possible_function_pointer_reloc(unsigned int r_type)
2009{
21bb3914
ST		 2010 switch (r_type)
2011 {
2012 case elfcpp::R_X86_64_64:
2013 case elfcpp::R_X86_64_32:
2014 case elfcpp::R_X86_64_32S:
2015 case elfcpp::R_X86_64_16:
2016 case elfcpp::R_X86_64_8:
ce97fa81
ST		 2017 case elfcpp::R_X86_64_GOT64:
2018 case elfcpp::R_X86_64_GOT32:
2019 case elfcpp::R_X86_64_GOTPCREL64:
2020 case elfcpp::R_X86_64_GOTPCREL:
2021 case elfcpp::R_X86_64_GOTPLT64:
21bb3914
ST		 2022 {
2023 return true;
2024 }
2025 }
2026 return false;
2027}
2028
2029// For safe ICF, scan a relocation for a local symbol to check if it
2030// corresponds to a function pointer being taken. In that case mark
2031// the function whose pointer was taken as not foldable.
2032
2033inline bool
2034Target_x86_64::Scan::local_reloc_may_be_function_pointer(
2035 Symbol_table* ,
2036 Layout* ,
2037 Target_x86_64* ,
6fa2a40b 2038 Sized_relobj_file<64, false>* ,
21bb3914
ST		 2039 unsigned int ,
2040 Output_section* ,
2041 const elfcpp::Rela<64, false>& ,
2042 unsigned int r_type,
2043 const elfcpp::Sym<64, false>&)
2044{
2045 // When building a shared library, do not fold any local symbols as it is
2046 // not possible to distinguish pointer taken versus a call by looking at
2047 // the relocation types.
2048 return (parameters->options().shared()
2049 || possible_function_pointer_reloc(r_type));
2050}
2051
2052// For safe ICF, scan a relocation for a global symbol to check if it
2053// corresponds to a function pointer being taken. In that case mark
2054// the function whose pointer was taken as not foldable.
2055
2056inline bool
2057Target_x86_64::Scan::global_reloc_may_be_function_pointer(
2058 Symbol_table*,
2059 Layout* ,
2060 Target_x86_64* ,
6fa2a40b 2061 Sized_relobj_file<64, false>* ,
21bb3914
ST		 2062 unsigned int ,
2063 Output_section* ,
2064 const elfcpp::Rela<64, false>& ,
2065 unsigned int r_type,
2066 Symbol* gsym)
2067{
2068 // When building a shared library, do not fold symbols whose visibility
2069 // is hidden, internal or protected.
2070 return ((parameters->options().shared()
2071 && (gsym->visibility() == elfcpp::STV_INTERNAL
2072 || gsym->visibility() == elfcpp::STV_PROTECTED
2073 || gsym->visibility() == elfcpp::STV_HIDDEN))
2074 || possible_function_pointer_reloc(r_type));
2075}
2076
2e30d253
ILT		 2077// Scan a relocation for a global symbol.
2078
2079inline void
ad0f2072 2080Target_x86_64::Scan::global(Symbol_table* symtab,
d61c17ea
ILT		 2081 Layout* layout,
2082 Target_x86_64* target,
6fa2a40b 2083 Sized_relobj_file<64, false>* object,
d61c17ea 2084 unsigned int data_shndx,
4f4c5f80 2085 Output_section* output_section,
d61c17ea
ILT		 2086 const elfcpp::Rela<64, false>& reloc,
2087 unsigned int r_type,
2088 Symbol* gsym)
2e30d253 2089{
7223e9ca
ILT		 2090 // A STT_GNU_IFUNC symbol may require a PLT entry.
2091 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2092 && this->reloc_needs_plt_for_ifunc(object, r_type))
2093 target->make_plt_entry(symtab, layout, gsym);
2094
2e30d253
ILT		 2095 switch (r_type)
2096 {
2097 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 2098 case elfcpp::R_X86_64_GNU_VTINHERIT:
2099 case elfcpp::R_X86_64_GNU_VTENTRY:
2e30d253
ILT		 2100 break;
2101
2102 case elfcpp::R_X86_64_64:
2e30d253
ILT		 2103 case elfcpp::R_X86_64_32:
2104 case elfcpp::R_X86_64_32S:
2e30d253 2105 case elfcpp::R_X86_64_16:
2e30d253 2106 case elfcpp::R_X86_64_8:
96f2030e 2107 {
d61c6bd4
ILT		 2108 // Make a PLT entry if necessary.
2109 if (gsym->needs_plt_entry())
2110 {
2111 target->make_plt_entry(symtab, layout, gsym);
2112 // Since this is not a PC-relative relocation, we may be
2113 // taking the address of a function. In that case we need to
2114 // set the entry in the dynamic symbol table to the address of
2115 // the PLT entry.
8851ecca 2116 if (gsym->is_from_dynobj() && !parameters->options().shared())
d61c6bd4
ILT		 2117 gsym->set_needs_dynsym_value();
2118 }
2119 // Make a dynamic relocation if necessary.
95a2c8d6 2120 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
d61c6bd4 2121 {
966d4097 2122 if (gsym->may_need_copy_reloc())
d61c6bd4 2123 {
12c0daef 2124 target->copy_reloc(symtab, layout, object,
7bf1f802 2125 data_shndx, output_section, gsym, reloc);
d61c6bd4 2126 }
7223e9ca
ILT		 2127 else if (r_type == elfcpp::R_X86_64_64
2128 && gsym->type() == elfcpp::STT_GNU_IFUNC
2129 && gsym->can_use_relative_reloc(false)
2130 && !gsym->is_from_dynobj()
2131 && !gsym->is_undefined()
2132 && !gsym->is_preemptible())
2133 {
2134 // Use an IRELATIVE reloc for a locally defined
2135 // STT_GNU_IFUNC symbol. This makes a function
2136 // address in a PIE executable match the address in a
2137 // shared library that it links against.
2138 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
2139 unsigned int r_type = elfcpp::R_X86_64_IRELATIVE;
2140 rela_dyn->add_symbolless_global_addend(gsym, r_type,
2141 output_section, object,
2142 data_shndx,
2143 reloc.get_r_offset(),
2144 reloc.get_r_addend());
2145 }
d61c6bd4
ILT		 2146 else if (r_type == elfcpp::R_X86_64_64
2147 && gsym->can_use_relative_reloc(false))
2148 {
2149 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7223e9ca
ILT		 2150 rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
2151 output_section, object,
2152 data_shndx,
2153 reloc.get_r_offset(),
2154 reloc.get_r_addend());
d61c6bd4
ILT		 2155 }
2156 else
2157 {
a29b0dad 2158 this->check_non_pic(object, r_type, gsym);
96f2030e 2159 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
4f4c5f80
ILT		 2160 rela_dyn->add_global(gsym, r_type, output_section, object,
2161 data_shndx, reloc.get_r_offset(),
96f2030e 2162 reloc.get_r_addend());
d61c6bd4
ILT		 2163 }
2164 }
2165 }
2166 break;
2167
2168 case elfcpp::R_X86_64_PC64:
2169 case elfcpp::R_X86_64_PC32:
2170 case elfcpp::R_X86_64_PC16:
2171 case elfcpp::R_X86_64_PC8:
2172 {
2173 // Make a PLT entry if necessary.
2174 if (gsym->needs_plt_entry())
2175 target->make_plt_entry(symtab, layout, gsym);
2176 // Make a dynamic relocation if necessary.
95a2c8d6 2177 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
86849f1f 2178 {
966d4097 2179 if (gsym->may_need_copy_reloc())
d61c6bd4 2180 {
12c0daef 2181 target->copy_reloc(symtab, layout, object,
7bf1f802 2182 data_shndx, output_section, gsym, reloc);
d61c6bd4 2183 }
86849f1f 2184 else
d61c6bd4 2185 {
a29b0dad 2186 this->check_non_pic(object, r_type, gsym);
d61c6bd4 2187 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
4f4c5f80
ILT		 2188 rela_dyn->add_global(gsym, r_type, output_section, object,
2189 data_shndx, reloc.get_r_offset(),
d61c6bd4
ILT		 2190 reloc.get_r_addend());
2191 }
86849f1f 2192 }
d61c6bd4 2193 }
2e30d253
ILT		 2194 break;
2195
ff006520 2196 case elfcpp::R_X86_64_GOT64:
2e30d253 2197 case elfcpp::R_X86_64_GOT32:
ff006520
ILT		 2198 case elfcpp::R_X86_64_GOTPCREL64:
2199 case elfcpp::R_X86_64_GOTPCREL:
2200 case elfcpp::R_X86_64_GOTPLT64:
2e30d253
ILT		 2201 {
2202 // The symbol requires a GOT entry.
2203 Output_data_got<64, false>* got = target->got_section(symtab, layout);
7bf1f802 2204 if (gsym->final_value_is_known())
7223e9ca
ILT		 2205 {
2206 // For a STT_GNU_IFUNC symbol we want the PLT address.
2207 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
2208 got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2209 else
2210 got->add_global(gsym, GOT_TYPE_STANDARD);
2211 }
7bf1f802
ILT		 2212 else
2213 {
2e30d253
ILT		 2214 // If this symbol is not fully resolved, we need to add a
2215 // dynamic relocation for it.
7bf1f802 2216 Reloc_section* rela_dyn = target->rela_dyn_section(layout);
7223e9ca
ILT		 2217 if (gsym->is_from_dynobj()
2218 || gsym->is_undefined()
2219 || gsym->is_preemptible()
2220 || (gsym->type() == elfcpp::STT_GNU_IFUNC
2221 && parameters->options().output_is_position_independent()))
0a65a3a7 2222 got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
7bf1f802
ILT		 2223 elfcpp::R_X86_64_GLOB_DAT);
2224 else
2e30d253 2225 {
7223e9ca
ILT		 2226 // For a STT_GNU_IFUNC symbol we want to write the PLT
2227 // offset into the GOT, so that function pointer
2228 // comparisons work correctly.
2229 bool is_new;
2230 if (gsym->type() != elfcpp::STT_GNU_IFUNC)
2231 is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
2232 else
2233 {
2234 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2235 // Tell the dynamic linker to use the PLT address
2236 // when resolving relocations.
2237 if (gsym->is_from_dynobj()
2238 && !parameters->options().shared())
2239 gsym->set_needs_dynsym_value();
2240 }
2241 if (is_new)
2242 {
2243 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
2244 rela_dyn->add_global_relative(gsym,
2245 elfcpp::R_X86_64_RELATIVE,
2246 got, got_off, 0);
2247 }
2e30d253
ILT		 2248 }
2249 }
ee9e9e86
ILT		 2250 // For GOTPLT64, we also need a PLT entry (but only if the
2251 // symbol is not fully resolved).
2252 if (r_type == elfcpp::R_X86_64_GOTPLT64
2253 && !gsym->final_value_is_known())
2254 target->make_plt_entry(symtab, layout, gsym);
2e30d253
ILT		 2255 }
2256 break;
2257
2258 case elfcpp::R_X86_64_PLT32:
2259 // If the symbol is fully resolved, this is just a PC32 reloc.
2260 // Otherwise we need a PLT entry.
2261 if (gsym->final_value_is_known())
2262 break;
96f2030e
ILT		 2263 // If building a shared library, we can also skip the PLT entry
2264 // if the symbol is defined in the output file and is protected
2265 // or hidden.
2266 if (gsym->is_defined()
2267 && !gsym->is_from_dynobj()
2268 && !gsym->is_preemptible())
2269 break;
2e30d253
ILT		 2270 target->make_plt_entry(symtab, layout, gsym);
2271 break;
2272
fdc2f80f 2273 case elfcpp::R_X86_64_GOTPC32:
e822f2b1 2274 case elfcpp::R_X86_64_GOTOFF64:
fdc2f80f
ILT		 2275 case elfcpp::R_X86_64_GOTPC64:
2276 case elfcpp::R_X86_64_PLTOFF64:
2e30d253
ILT		 2277 // We need a GOT section.
2278 target->got_section(symtab, layout);
ee9e9e86
ILT		 2279 // For PLTOFF64, we also need a PLT entry (but only if the
2280 // symbol is not fully resolved).
2281 if (r_type == elfcpp::R_X86_64_PLTOFF64
2282 && !gsym->final_value_is_known())
2283 target->make_plt_entry(symtab, layout, gsym);
2e30d253
ILT		 2284 break;
2285
2e30d253
ILT		 2286 case elfcpp::R_X86_64_COPY:
2287 case elfcpp::R_X86_64_GLOB_DAT:
2288 case elfcpp::R_X86_64_JUMP_SLOT:
2289 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 2290 case elfcpp::R_X86_64_IRELATIVE:
d61c17ea 2291 // These are outstanding tls relocs, which are unexpected when linking
e822f2b1 2292 case elfcpp::R_X86_64_TPOFF64:
2e30d253 2293 case elfcpp::R_X86_64_DTPMOD64:
e822f2b1 2294 case elfcpp::R_X86_64_TLSDESC:
75f2446e
ILT		 2295 gold_error(_("%s: unexpected reloc %u in object file"),
2296 object->name().c_str(), r_type);
2e30d253 2297 break;
2e30d253 2298
d61c17ea 2299 // These are initial tls relocs, which are expected for global()
56622147
ILT		 2300 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2301 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
e041f13d 2302 case elfcpp::R_X86_64_TLSDESC_CALL:
56622147 2303 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
0ffd9845
ILT		 2304 case elfcpp::R_X86_64_DTPOFF32:
2305 case elfcpp::R_X86_64_DTPOFF64:
56622147
ILT		 2306 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2307 case elfcpp::R_X86_64_TPOFF32: // Local-exec
2e30d253
ILT		 2308 {
2309 const bool is_final = gsym->final_value_is_known();
e041f13d
ILT		 2310 const tls::Tls_optimization optimized_type
2311 = Target_x86_64::optimize_tls_reloc(is_final, r_type);
2e30d253
ILT		 2312 switch (r_type)
2313 {
56622147 2314 case elfcpp::R_X86_64_TLSGD: // General-dynamic
7bf1f802
ILT		 2315 if (optimized_type == tls::TLSOPT_NONE)
2316 {
2317 // Create a pair of GOT entries for the module index and
2318 // dtv-relative offset.
2319 Output_data_got<64, false>* got
2320 = target->got_section(symtab, layout);
0a65a3a7
CC		 2321 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_PAIR,
2322 target->rela_dyn_section(layout),
2323 elfcpp::R_X86_64_DTPMOD64,
2324 elfcpp::R_X86_64_DTPOFF64);
7bf1f802
ILT		 2325 }
2326 else if (optimized_type == tls::TLSOPT_TO_IE)
2327 {
2328 // Create a GOT entry for the tp-relative offset.
2329 Output_data_got<64, false>* got
2330 = target->got_section(symtab, layout);
0a65a3a7 2331 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
7bf1f802
ILT		 2332 target->rela_dyn_section(layout),
2333 elfcpp::R_X86_64_TPOFF64);
2334 }
2335 else if (optimized_type != tls::TLSOPT_TO_LE)
2336 unsupported_reloc_global(object, r_type, gsym);
2337 break;
2338
56622147 2339 case elfcpp::R_X86_64_GOTPC32_TLSDESC:
edfbb029 2340 target->define_tls_base_symbol(symtab, layout);
c2b45e22
CC		 2341 if (optimized_type == tls::TLSOPT_NONE)
2342 {
2343 // Create reserved PLT and GOT entries for the resolver.
2344 target->reserve_tlsdesc_entries(symtab, layout);
2345
a8df5856
ILT		 2346 // Create a double GOT entry with an R_X86_64_TLSDESC
2347 // reloc. The R_X86_64_TLSDESC reloc is resolved
2348 // lazily, so the GOT entry needs to be in an area in
2349 // .got.plt, not .got. Call got_section to make sure
2350 // the section has been created.
2351 target->got_section(symtab, layout);
2352 Output_data_got<64, false>* got = target->got_tlsdesc_section();
ca09d69a 2353 Reloc_section* rt = target->rela_tlsdesc_section(layout);
e291e7b9 2354 got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_DESC, rt,
c2b45e22
CC		 2355 elfcpp::R_X86_64_TLSDESC, 0);
2356 }
2357 else if (optimized_type == tls::TLSOPT_TO_IE)
2358 {
2359 // Create a GOT entry for the tp-relative offset.
2360 Output_data_got<64, false>* got
2361 = target->got_section(symtab, layout);
2362 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
2363 target->rela_dyn_section(layout),
2364 elfcpp::R_X86_64_TPOFF64);
2365 }
2366 else if (optimized_type != tls::TLSOPT_TO_LE)
56622147 2367 unsupported_reloc_global(object, r_type, gsym);
2e30d253
ILT		 2368 break;
2369
c2b45e22
CC		 2370 case elfcpp::R_X86_64_TLSDESC_CALL:
2371 break;
2372
e041f13d 2373 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
7bf1f802
ILT		 2374 if (optimized_type == tls::TLSOPT_NONE)
2375 {
2376 // Create a GOT entry for the module index.
31d60480 2377 target->got_mod_index_entry(symtab, layout, object);
7bf1f802
ILT		 2378 }
2379 else if (optimized_type != tls::TLSOPT_TO_LE)
2380 unsupported_reloc_global(object, r_type, gsym);
2381 break;
2382
0ffd9845
ILT		 2383 case elfcpp::R_X86_64_DTPOFF32:
2384 case elfcpp::R_X86_64_DTPOFF64:
e041f13d
ILT		 2385 break;
2386
56622147 2387 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
535890bb 2388 layout->set_has_static_tls();
7bf1f802
ILT		 2389 if (optimized_type == tls::TLSOPT_NONE)
2390 {
2391 // Create a GOT entry for the tp-relative offset.
2392 Output_data_got<64, false>* got
2393 = target->got_section(symtab, layout);
0a65a3a7 2394 got->add_global_with_rela(gsym, GOT_TYPE_TLS_OFFSET,
7bf1f802
ILT		 2395 target->rela_dyn_section(layout),
2396 elfcpp::R_X86_64_TPOFF64);
2397 }
2398 else if (optimized_type != tls::TLSOPT_TO_LE)
56622147
ILT		 2399 unsupported_reloc_global(object, r_type, gsym);
2400 break;
0ffd9845 2401
56622147 2402 case elfcpp::R_X86_64_TPOFF32: // Local-exec
535890bb 2403 layout->set_has_static_tls();
8851ecca 2404 if (parameters->options().shared())
7bf1f802 2405 unsupported_reloc_local(object, r_type);
2e30d253 2406 break;
e041f13d
ILT		 2407
2408 default:
2409 gold_unreachable();
2e30d253
ILT		 2410 }
2411 }
2412 break;
fdc2f80f
ILT		 2413
2414 case elfcpp::R_X86_64_SIZE32:
2415 case elfcpp::R_X86_64_SIZE64:
2e30d253 2416 default:
75f2446e 2417 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
a2b1aa12
ILT		 2418 object->name().c_str(), r_type,
2419 gsym->demangled_name().c_str());
2e30d253
ILT		 2420 break;
2421 }
2422}
2423
6d03d481 2424void
ad0f2072 2425Target_x86_64::gc_process_relocs(Symbol_table* symtab,
6d03d481 2426 Layout* layout,
6fa2a40b 2427 Sized_relobj_file<64, false>* object,
6d03d481
ST		 2428 unsigned int data_shndx,
2429 unsigned int sh_type,
2430 const unsigned char* prelocs,
2431 size_t reloc_count,
2432 Output_section* output_section,
2433 bool needs_special_offset_handling,
2434 size_t local_symbol_count,
2435 const unsigned char* plocal_symbols)
2436{
2437
2438 if (sh_type == elfcpp::SHT_REL)
2439 {
2440 return;
2441 }
2442
2443 gold::gc_process_relocs<64, false, Target_x86_64, elfcpp::SHT_RELA,
41cbeecc
ST		 2444 Target_x86_64::Scan,
2445 Target_x86_64::Relocatable_size_for_reloc>(
6d03d481
ST		 2446 symtab,
2447 layout,
2448 this,
2449 object,
2450 data_shndx,
2451 prelocs,
2452 reloc_count,
2453 output_section,
2454 needs_special_offset_handling,
2455 local_symbol_count,
2456 plocal_symbols);
2457
2458}
2e30d253
ILT		 2459// Scan relocations for a section.
2460
2461void
ad0f2072 2462Target_x86_64::scan_relocs(Symbol_table* symtab,
d61c17ea 2463 Layout* layout,
6fa2a40b 2464 Sized_relobj_file<64, false>* object,
d61c17ea
ILT		 2465 unsigned int data_shndx,
2466 unsigned int sh_type,
2467 const unsigned char* prelocs,
2468 size_t reloc_count,
730cdc88
ILT		 2469 Output_section* output_section,
2470 bool needs_special_offset_handling,
d61c17ea 2471 size_t local_symbol_count,
730cdc88 2472 const unsigned char* plocal_symbols)
2e30d253
ILT		 2473{
2474 if (sh_type == elfcpp::SHT_REL)
2475 {
75f2446e
ILT		 2476 gold_error(_("%s: unsupported REL reloc section"),
2477 object->name().c_str());
2478 return;
2e30d253
ILT		 2479 }
2480
2481 gold::scan_relocs<64, false, Target_x86_64, elfcpp::SHT_RELA,
2482 Target_x86_64::Scan>(
2e30d253
ILT		 2483 symtab,
2484 layout,
2485 this,
2486 object,
2487 data_shndx,
2488 prelocs,
2489 reloc_count,
730cdc88
ILT		 2490 output_section,
2491 needs_special_offset_handling,
2e30d253 2492 local_symbol_count,
730cdc88 2493 plocal_symbols);
2e30d253
ILT		 2494}
2495
2496// Finalize the sections.
2497
2498void
f59f41f3
DK		 2499Target_x86_64::do_finalize_sections(
2500 Layout* layout,
2501 const Input_objects*,
e785ec03 2502 Symbol_table* symtab)
2e30d253 2503{
ea715a34
ILT		 2504 const Reloc_section* rel_plt = (this->plt_ == NULL
2505 ? NULL
e291e7b9 2506 : this->plt_->rela_plt());
ea715a34 2507 layout->add_target_dynamic_tags(false, this->got_plt_, rel_plt,
612a8d3d 2508 this->rela_dyn_, true, false);
ea715a34 2509
2e30d253
ILT		 2510 // Fill in some more dynamic tags.
2511 Output_data_dynamic* const odyn = layout->dynamic_data();
2512 if (odyn != NULL)
2513 {
22b127cc 2514 if (this->plt_ != NULL
ea715a34
ILT		 2515 && this->plt_->output_section() != NULL
2516 && this->plt_->has_tlsdesc_entry())
2e30d253 2517 {
ea715a34
ILT		 2518 unsigned int plt_offset = this->plt_->get_tlsdesc_plt_offset();
2519 unsigned int got_offset = this->plt_->get_tlsdesc_got_offset();
2520 this->got_->finalize_data_size();
2521 odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_PLT,
2522 this->plt_, plt_offset);
2523 odyn->add_section_plus_offset(elfcpp::DT_TLSDESC_GOT,
2524 this->got_, got_offset);
2e30d253
ILT		 2525 }
2526 }
2527
2528 // Emit any relocs we saved in an attempt to avoid generating COPY
2529 // relocs.
12c0daef
ILT		 2530 if (this->copy_relocs_.any_saved_relocs())
2531 this->copy_relocs_.emit(this->rela_dyn_section(layout));
e785ec03
ILT		 2532
2533 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
2534 // the .got.plt section.
2535 Symbol* sym = this->global_offset_table_;
2536 if (sym != NULL)
2537 {
2538 uint64_t data_size = this->got_plt_->current_data_size();
2539 symtab->get_sized_symbol<64>(sym)->set_symsize(data_size);
2540 }
2e30d253
ILT		 2541}
2542
2543// Perform a relocation.
2544
2545inline bool
2546Target_x86_64::Relocate::relocate(const Relocate_info<64, false>* relinfo,
2547 Target_x86_64* target,
031cdbed 2548 Output_section*,
2e30d253 2549 size_t relnum,
0ffd9845 2550 const elfcpp::Rela<64, false>& rela,
2e30d253
ILT		 2551 unsigned int r_type,
2552 const Sized_symbol<64>* gsym,
2553 const Symbol_value<64>* psymval,
2554 unsigned char* view,
2555 elfcpp::Elf_types<64>::Elf_Addr address,
fe8718a4 2556 section_size_type view_size)
2e30d253
ILT		 2557{
2558 if (this->skip_call_tls_get_addr_)
2559 {
5efc7cd2
CC		 2560 if ((r_type != elfcpp::R_X86_64_PLT32
2561 && r_type != elfcpp::R_X86_64_PC32)
2e30d253 2562 || gsym == NULL
0ffd9845 2563 || strcmp(gsym->name(), "__tls_get_addr") != 0)
2e30d253 2564 {
75f2446e
ILT		 2565 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2566 _("missing expected TLS relocation"));
2567 }
2568 else
2569 {
2570 this->skip_call_tls_get_addr_ = false;
2571 return false;
2e30d253 2572 }
2e30d253
ILT		 2573 }
2574
6fa2a40b 2575 const Sized_relobj_file<64, false>* object = relinfo->object;
7223e9ca
ILT		 2576
2577 // Pick the value to use for symbols defined in the PLT.
2e30d253 2578 Symbol_value<64> symval;
96f2030e 2579 if (gsym != NULL
95a2c8d6 2580 && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
2e30d253
ILT		 2581 {
2582 symval.set_output_value(target->plt_section()->address()
2583 + gsym->plt_offset());
2584 psymval = &symval;
2585 }
7223e9ca
ILT		 2586 else if (gsym == NULL && psymval->is_ifunc_symbol())
2587 {
2588 unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
2589 if (object->local_has_plt_offset(r_sym))
2590 {
2591 symval.set_output_value(target->plt_section()->address()
2592 + object->local_plt_offset(r_sym));
2593 psymval = &symval;
2594 }
2595 }
2e30d253 2596
0ffd9845
ILT		 2597 const elfcpp::Elf_Xword addend = rela.get_r_addend();
2598
2599 // Get the GOT offset if needed.
96f2030e
ILT		 2600 // The GOT pointer points to the end of the GOT section.
2601 // We need to subtract the size of the GOT section to get
2602 // the actual offset to use in the relocation.
0ffd9845
ILT		 2603 bool have_got_offset = false;
2604 unsigned int got_offset = 0;
2605 switch (r_type)
2606 {
2607 case elfcpp::R_X86_64_GOT32:
2608 case elfcpp::R_X86_64_GOT64:
2609 case elfcpp::R_X86_64_GOTPLT64:
2610 case elfcpp::R_X86_64_GOTPCREL:
2611 case elfcpp::R_X86_64_GOTPCREL64:
2612 if (gsym != NULL)
2613 {
0a65a3a7
CC		 2614 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2615 got_offset = gsym->got_offset(GOT_TYPE_STANDARD) - target->got_size();
0ffd9845
ILT		 2616 }
2617 else
2618 {
2619 unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
0a65a3a7
CC		 2620 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2621 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
2622 - target->got_size());
0ffd9845
ILT		 2623 }
2624 have_got_offset = true;
2625 break;
2626
2627 default:
2628 break;
2629 }
2e30d253
ILT		 2630
2631 switch (r_type)
2632 {
2633 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 2634 case elfcpp::R_X86_64_GNU_VTINHERIT:
2635 case elfcpp::R_X86_64_GNU_VTENTRY:
2e30d253
ILT		 2636 break;
2637
2638 case elfcpp::R_X86_64_64:
2639 Relocate_functions<64, false>::rela64(view, object, psymval, addend);
2640 break;
2641
2642 case elfcpp::R_X86_64_PC64:
2643 Relocate_functions<64, false>::pcrela64(view, object, psymval, addend,
2644 address);
2645 break;
2646
2647 case elfcpp::R_X86_64_32:
7bb3655e
ILT		 2648 // FIXME: we need to verify that value + addend fits into 32 bits:
2649 // uint64_t x = value + addend;
2650 // x == static_cast<uint64_t>(static_cast<uint32_t>(x))
2651 // Likewise for other <=32-bit relocations (but see R_X86_64_32S).
2e30d253
ILT		 2652 Relocate_functions<64, false>::rela32(view, object, psymval, addend);
2653 break;
2654
2655 case elfcpp::R_X86_64_32S:
7bb3655e
ILT		 2656 // FIXME: we need to verify that value + addend fits into 32 bits:
2657 // int64_t x = value + addend; // note this quantity is signed!
2658 // x == static_cast<int64_t>(static_cast<int32_t>(x))
2e30d253
ILT		 2659 Relocate_functions<64, false>::rela32(view, object, psymval, addend);
2660 break;
2661
2662 case elfcpp::R_X86_64_PC32:
2663 Relocate_functions<64, false>::pcrela32(view, object, psymval, addend,
2664 address);
2665 break;
2666
2667 case elfcpp::R_X86_64_16:
2668 Relocate_functions<64, false>::rela16(view, object, psymval, addend);
2669 break;
2670
2671 case elfcpp::R_X86_64_PC16:
2672 Relocate_functions<64, false>::pcrela16(view, object, psymval, addend,
2673 address);
2674 break;
2675
2676 case elfcpp::R_X86_64_8:
2677 Relocate_functions<64, false>::rela8(view, object, psymval, addend);
2678 break;
2679
2680 case elfcpp::R_X86_64_PC8:
2681 Relocate_functions<64, false>::pcrela8(view, object, psymval, addend,
2682 address);
2683 break;
2684
2685 case elfcpp::R_X86_64_PLT32:
f389a824
ILT		 2686 gold_assert(gsym == NULL
2687 || gsym->has_plt_offset()
99f8faca
ILT		 2688 || gsym->final_value_is_known()
2689 || (gsym->is_defined()
2690 && !gsym->is_from_dynobj()
2691 && !gsym->is_preemptible()));
ee9e9e86
ILT		 2692 // Note: while this code looks the same as for R_X86_64_PC32, it
2693 // behaves differently because psymval was set to point to
2694 // the PLT entry, rather than the symbol, in Scan::global().
2e30d253
ILT		 2695 Relocate_functions<64, false>::pcrela32(view, object, psymval, addend,
2696 address);
2697 break;
2698
ee9e9e86
ILT		 2699 case elfcpp::R_X86_64_PLTOFF64:
2700 {
2701 gold_assert(gsym);
2702 gold_assert(gsym->has_plt_offset()
2703 || gsym->final_value_is_known());
2704 elfcpp::Elf_types<64>::Elf_Addr got_address;
2705 got_address = target->got_section(NULL, NULL)->address();
c1866bd5
ILT		 2706 Relocate_functions<64, false>::rela64(view, object, psymval,
2707 addend - got_address);
ee9e9e86
ILT		 2708 }
2709
2e30d253 2710 case elfcpp::R_X86_64_GOT32:
0ffd9845
ILT		 2711 gold_assert(have_got_offset);
2712 Relocate_functions<64, false>::rela32(view, got_offset, addend);
2e30d253
ILT		 2713 break;
2714
e822f2b1
ILT		 2715 case elfcpp::R_X86_64_GOTPC32:
2716 {
2717 gold_assert(gsym);
2718 elfcpp::Elf_types<64>::Elf_Addr value;
96f2030e 2719 value = target->got_plt_section()->address();
e822f2b1
ILT		 2720 Relocate_functions<64, false>::pcrela32(view, value, addend, address);
2721 }
2722 break;
2723
2724 case elfcpp::R_X86_64_GOT64:
2725 // The ABI doc says "Like GOT64, but indicates a PLT entry is needed."
2726 // Since we always add a PLT entry, this is equivalent.
fdc2f80f 2727 case elfcpp::R_X86_64_GOTPLT64:
0ffd9845
ILT		 2728 gold_assert(have_got_offset);
2729 Relocate_functions<64, false>::rela64(view, got_offset, addend);
e822f2b1
ILT		 2730 break;
2731
2732 case elfcpp::R_X86_64_GOTPC64:
2733 {
2734 gold_assert(gsym);
2735 elfcpp::Elf_types<64>::Elf_Addr value;
96f2030e 2736 value = target->got_plt_section()->address();
e822f2b1
ILT		 2737 Relocate_functions<64, false>::pcrela64(view, value, addend, address);
2738 }
2739 break;
2740
2e30d253
ILT		 2741 case elfcpp::R_X86_64_GOTOFF64:
2742 {
2743 elfcpp::Elf_types<64>::Elf_Addr value;
2744 value = (psymval->value(object, 0)
96f2030e 2745 - target->got_plt_section()->address());
2e30d253
ILT		 2746 Relocate_functions<64, false>::rela64(view, value, addend);
2747 }
2748 break;
2749
2750 case elfcpp::R_X86_64_GOTPCREL:
2751 {
0ffd9845
ILT		 2752 gold_assert(have_got_offset);
2753 elfcpp::Elf_types<64>::Elf_Addr value;
96f2030e 2754 value = target->got_plt_section()->address() + got_offset;
0ffd9845 2755 Relocate_functions<64, false>::pcrela32(view, value, addend, address);
2e30d253
ILT		 2756 }
2757 break;
2758
e822f2b1
ILT		 2759 case elfcpp::R_X86_64_GOTPCREL64:
2760 {
0ffd9845
ILT		 2761 gold_assert(have_got_offset);
2762 elfcpp::Elf_types<64>::Elf_Addr value;
96f2030e 2763 value = target->got_plt_section()->address() + got_offset;
0ffd9845 2764 Relocate_functions<64, false>::pcrela64(view, value, addend, address);
e822f2b1
ILT		 2765 }
2766 break;
2767
2e30d253
ILT		 2768 case elfcpp::R_X86_64_COPY:
2769 case elfcpp::R_X86_64_GLOB_DAT:
2770 case elfcpp::R_X86_64_JUMP_SLOT:
2771 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 2772 case elfcpp::R_X86_64_IRELATIVE:
d61c17ea 2773 // These are outstanding tls relocs, which are unexpected when linking
2e30d253 2774 case elfcpp::R_X86_64_TPOFF64:
2e30d253 2775 case elfcpp::R_X86_64_DTPMOD64:
2e30d253 2776 case elfcpp::R_X86_64_TLSDESC:
75f2446e
ILT		 2777 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2778 _("unexpected reloc %u in object file"),
2779 r_type);
2e30d253
ILT		 2780 break;
2781
d61c17ea 2782 // These are initial tls relocs, which are expected when linking
56622147
ILT		 2783 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
2784 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
e041f13d 2785 case elfcpp::R_X86_64_TLSDESC_CALL:
56622147 2786 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
0ffd9845
ILT		 2787 case elfcpp::R_X86_64_DTPOFF32:
2788 case elfcpp::R_X86_64_DTPOFF64:
56622147
ILT		 2789 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
2790 case elfcpp::R_X86_64_TPOFF32: // Local-exec
7bf1f802
ILT		 2791 this->relocate_tls(relinfo, target, relnum, rela, r_type, gsym, psymval,
2792 view, address, view_size);
2e30d253 2793 break;
2e30d253 2794
fdc2f80f
ILT		 2795 case elfcpp::R_X86_64_SIZE32:
2796 case elfcpp::R_X86_64_SIZE64:
2e30d253 2797 default:
75f2446e
ILT		 2798 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2799 _("unsupported reloc %u"),
2800 r_type);
2e30d253
ILT		 2801 break;
2802 }
2803
2804 return true;
2805}
2806
2807// Perform a TLS relocation.
2808
2809inline void
d61c17ea 2810Target_x86_64::Relocate::relocate_tls(const Relocate_info<64, false>* relinfo,
7bf1f802 2811 Target_x86_64* target,
d61c17ea 2812 size_t relnum,
72ec2876 2813 const elfcpp::Rela<64, false>& rela,
d61c17ea
ILT		 2814 unsigned int r_type,
2815 const Sized_symbol<64>* gsym,
2816 const Symbol_value<64>* psymval,
2817 unsigned char* view,
6a41d30b 2818 elfcpp::Elf_types<64>::Elf_Addr address,
fe8718a4 2819 section_size_type view_size)
2e30d253 2820{
2e30d253 2821 Output_segment* tls_segment = relinfo->layout->tls_segment();
7bf1f802 2822
6fa2a40b 2823 const Sized_relobj_file<64, false>* object = relinfo->object;
6a41d30b 2824 const elfcpp::Elf_Xword addend = rela.get_r_addend();
36171d64
CC		 2825 elfcpp::Shdr<64, false> data_shdr(relinfo->data_shdr);
2826 bool is_executable = (data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0;
2e30d253
ILT		 2827
2828 elfcpp::Elf_types<64>::Elf_Addr value = psymval->value(relinfo->object, 0);
2829
2830 const bool is_final = (gsym == NULL
b3705d2a 2831 ? !parameters->options().shared()
2e30d253 2832 : gsym->final_value_is_known());
36171d64 2833 tls::Tls_optimization optimized_type
e041f13d 2834 = Target_x86_64::optimize_tls_reloc(is_final, r_type);
2e30d253
ILT		 2835 switch (r_type)
2836 {
56622147 2837 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
36171d64
CC		 2838 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
2839 {
2840 // If this code sequence is used in a non-executable section,
2841 // we will not optimize the R_X86_64_DTPOFF32/64 relocation,
2842 // on the assumption that it's being used by itself in a debug
2843 // section. Therefore, in the unlikely event that the code
2844 // sequence appears in a non-executable section, we simply
2845 // leave it unoptimized.
2846 optimized_type = tls::TLSOPT_NONE;
2847 }
e041f13d 2848 if (optimized_type == tls::TLSOPT_TO_LE)
2e30d253 2849 {
7bf1f802 2850 gold_assert(tls_segment != NULL);
2e30d253 2851 this->tls_gd_to_le(relinfo, relnum, tls_segment,
72ec2876 2852 rela, r_type, value, view,
2e30d253
ILT		 2853 view_size);
2854 break;
2855 }
7bf1f802
ILT		 2856 else
2857 {
c2b45e22
CC		 2858 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2859 ? GOT_TYPE_TLS_OFFSET
2860 : GOT_TYPE_TLS_PAIR);
7bf1f802
ILT		 2861 unsigned int got_offset;
2862 if (gsym != NULL)
2863 {
c2b45e22
CC		 2864 gold_assert(gsym->has_got_offset(got_type));
2865 got_offset = gsym->got_offset(got_type) - target->got_size();
7bf1f802
ILT		 2866 }
2867 else
2868 {
2869 unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
c2b45e22
CC		 2870 gold_assert(object->local_has_got_offset(r_sym, got_type));
2871 got_offset = (object->local_got_offset(r_sym, got_type)
7bf1f802
ILT		 2872 - target->got_size());
2873 }
2874 if (optimized_type == tls::TLSOPT_TO_IE)
2875 {
2876 gold_assert(tls_segment != NULL);
c2b45e22 2877 value = target->got_plt_section()->address() + got_offset;
7bf1f802 2878 this->tls_gd_to_ie(relinfo, relnum, tls_segment, rela, r_type,
c2b45e22 2879 value, view, address, view_size);
7bf1f802
ILT		 2880 break;
2881 }
2882 else if (optimized_type == tls::TLSOPT_NONE)
2883 {
2884 // Relocate the field with the offset of the pair of GOT
2885 // entries.
6a41d30b
ILT		 2886 value = target->got_plt_section()->address() + got_offset;
2887 Relocate_functions<64, false>::pcrela32(view, value, addend,
2888 address);
7bf1f802
ILT		 2889 break;
2890 }
2891 }
72ec2876 2892 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
75f2446e 2893 _("unsupported reloc %u"), r_type);
2e30d253
ILT		 2894 break;
2895
c2b45e22
CC		 2896 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
2897 case elfcpp::R_X86_64_TLSDESC_CALL:
36171d64
CC		 2898 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
2899 {
2900 // See above comment for R_X86_64_TLSGD.
2901 optimized_type = tls::TLSOPT_NONE;
2902 }
c2b45e22
CC		 2903 if (optimized_type == tls::TLSOPT_TO_LE)
2904 {
2905 gold_assert(tls_segment != NULL);
2906 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
2907 rela, r_type, value, view,
2908 view_size);
2909 break;
2910 }
2911 else
2912 {
2913 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
2914 ? GOT_TYPE_TLS_OFFSET
2915 : GOT_TYPE_TLS_DESC);
a8df5856
ILT		 2916 unsigned int got_offset = 0;
2917 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC
2918 && optimized_type == tls::TLSOPT_NONE)
2919 {
2920 // We created GOT entries in the .got.tlsdesc portion of
2921 // the .got.plt section, but the offset stored in the
2922 // symbol is the offset within .got.tlsdesc.
2923 got_offset = (target->got_size()
2924 + target->got_plt_section()->data_size());
2925 }
c2b45e22
CC		 2926 if (gsym != NULL)
2927 {
2928 gold_assert(gsym->has_got_offset(got_type));
a8df5856 2929 got_offset += gsym->got_offset(got_type) - target->got_size();
c2b45e22
CC		 2930 }
2931 else
2932 {
2933 unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
2934 gold_assert(object->local_has_got_offset(r_sym, got_type));
a8df5856
ILT		 2935 got_offset += (object->local_got_offset(r_sym, got_type)
2936 - target->got_size());
c2b45e22
CC		 2937 }
2938 if (optimized_type == tls::TLSOPT_TO_IE)
2939 {
2940 gold_assert(tls_segment != NULL);
2941 value = target->got_plt_section()->address() + got_offset;
2942 this->tls_desc_gd_to_ie(relinfo, relnum, tls_segment,
2943 rela, r_type, value, view, address,
2944 view_size);
2945 break;
2946 }
2947 else if (optimized_type == tls::TLSOPT_NONE)
2948 {
2949 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
2950 {
2951 // Relocate the field with the offset of the pair of GOT
2952 // entries.
2953 value = target->got_plt_section()->address() + got_offset;
2954 Relocate_functions<64, false>::pcrela32(view, value, addend,
2955 address);
2956 }
2957 break;
2958 }
2959 }
2960 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
2961 _("unsupported reloc %u"), r_type);
2962 break;
2963
56622147 2964 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
36171d64
CC		 2965 if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
2966 {
2967 // See above comment for R_X86_64_TLSGD.
2968 optimized_type = tls::TLSOPT_NONE;
2969 }
e041f13d
ILT		 2970 if (optimized_type == tls::TLSOPT_TO_LE)
2971 {
7bf1f802 2972 gold_assert(tls_segment != NULL);
72ec2876
ILT		 2973 this->tls_ld_to_le(relinfo, relnum, tls_segment, rela, r_type,
2974 value, view, view_size);
2975 break;
e041f13d 2976 }
7bf1f802
ILT		 2977 else if (optimized_type == tls::TLSOPT_NONE)
2978 {
2979 // Relocate the field with the offset of the GOT entry for
2980 // the module index.
2981 unsigned int got_offset;
31d60480
ILT		 2982 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
2983 - target->got_size());
6a41d30b
ILT		 2984 value = target->got_plt_section()->address() + got_offset;
2985 Relocate_functions<64, false>::pcrela32(view, value, addend,
2986 address);
7bf1f802
ILT		 2987 break;
2988 }
72ec2876 2989 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
75f2446e 2990 _("unsupported reloc %u"), r_type);
2e30d253 2991 break;
0ffd9845
ILT		 2992
2993 case elfcpp::R_X86_64_DTPOFF32:
36171d64
CC		 2994 // This relocation type is used in debugging information.
2995 // In that case we need to not optimize the value. If the
2996 // section is not executable, then we assume we should not
2997 // optimize this reloc. See comments above for R_X86_64_TLSGD,
2998 // R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and
2999 // R_X86_64_TLSLD.
3000 if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3001 {
3002 gold_assert(tls_segment != NULL);
3003 value -= tls_segment->memsz();
3004 }
d85c80a3 3005 Relocate_functions<64, false>::rela32(view, value, addend);
0ffd9845
ILT		 3006 break;
3007
3008 case elfcpp::R_X86_64_DTPOFF64:
36171d64
CC		 3009 // See R_X86_64_DTPOFF32, just above, for why we check for is_executable.
3010 if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
3011 {
3012 gold_assert(tls_segment != NULL);
3013 value -= tls_segment->memsz();
3014 }
d85c80a3 3015 Relocate_functions<64, false>::rela64(view, value, addend);
0ffd9845 3016 break;
2e30d253 3017
56622147
ILT		 3018 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3019 if (optimized_type == tls::TLSOPT_TO_LE)
3020 {
7bf1f802 3021 gold_assert(tls_segment != NULL);
56622147
ILT		 3022 Target_x86_64::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
3023 rela, r_type, value, view,
3024 view_size);
3025 break;
3026 }
7bf1f802
ILT		 3027 else if (optimized_type == tls::TLSOPT_NONE)
3028 {
3029 // Relocate the field with the offset of the GOT entry for
3030 // the tp-relative offset of the symbol.
3031 unsigned int got_offset;
3032 if (gsym != NULL)
3033 {
0a65a3a7
CC		 3034 gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET));
3035 got_offset = (gsym->got_offset(GOT_TYPE_TLS_OFFSET)
3036 - target->got_size());
7bf1f802
ILT		 3037 }
3038 else
3039 {
3040 unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
0a65a3a7
CC		 3041 gold_assert(object->local_has_got_offset(r_sym,
3042 GOT_TYPE_TLS_OFFSET));
3043 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_TLS_OFFSET)
7bf1f802
ILT		 3044 - target->got_size());
3045 }
6a41d30b
ILT		 3046 value = target->got_plt_section()->address() + got_offset;
3047 Relocate_functions<64, false>::pcrela32(view, value, addend, address);
7bf1f802
ILT		 3048 break;
3049 }
56622147
ILT		 3050 gold_error_at_location(relinfo, relnum, rela.get_r_offset(),
3051 _("unsupported reloc type %u"),
3052 r_type);
3053 break;
0ffd9845 3054
56622147 3055 case elfcpp::R_X86_64_TPOFF32: // Local-exec
6a41d30b 3056 value -= tls_segment->memsz();
d85c80a3 3057 Relocate_functions<64, false>::rela32(view, value, addend);
56622147 3058 break;
2e30d253 3059 }
2e30d253
ILT		 3060}
3061
7bf1f802
ILT		 3062// Do a relocation in which we convert a TLS General-Dynamic to an
3063// Initial-Exec.
3064
3065inline void
3066Target_x86_64::Relocate::tls_gd_to_ie(const Relocate_info<64, false>* relinfo,
3067 size_t relnum,
c2b45e22 3068 Output_segment*,
7bf1f802
ILT		 3069 const elfcpp::Rela<64, false>& rela,
3070 unsigned int,
3071 elfcpp::Elf_types<64>::Elf_Addr value,
3072 unsigned char* view,
c2b45e22 3073 elfcpp::Elf_types<64>::Elf_Addr address,
fe8718a4 3074 section_size_type view_size)
7bf1f802
ILT		 3075{
3076 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3077 // .word 0x6666; rex64; call __tls_get_addr
3078 // ==> movq %fs:0,%rax; addq x@gottpoff(%rip),%rax
3079
3080 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -4);
3081 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
3082
3083 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3084 (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3085 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3086 (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
3087
3088 memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0\0", 16);
3089
c2b45e22
CC		 3090 const elfcpp::Elf_Xword addend = rela.get_r_addend();
3091 Relocate_functions<64, false>::pcrela32(view + 8, value, addend - 8, address);
7bf1f802
ILT		 3092
3093 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3094 // We can skip it.
3095 this->skip_call_tls_get_addr_ = true;
3096}
3097
e041f13d 3098// Do a relocation in which we convert a TLS General-Dynamic to a
2e30d253
ILT		 3099// Local-Exec.
3100
3101inline void
d61c17ea
ILT		 3102Target_x86_64::Relocate::tls_gd_to_le(const Relocate_info<64, false>* relinfo,
3103 size_t relnum,
3104 Output_segment* tls_segment,
72ec2876 3105 const elfcpp::Rela<64, false>& rela,
d61c17ea
ILT		 3106 unsigned int,
3107 elfcpp::Elf_types<64>::Elf_Addr value,
3108 unsigned char* view,
fe8718a4 3109 section_size_type view_size)
2e30d253 3110{
0ffd9845
ILT		 3111 // .byte 0x66; leaq foo@tlsgd(%rip),%rdi;
3112 // .word 0x6666; rex64; call __tls_get_addr
3113 // ==> movq %fs:0,%rax; leaq x@tpoff(%rax),%rax
2e30d253 3114
72ec2876
ILT		 3115 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -4);
3116 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 12);
2e30d253 3117
72ec2876
ILT		 3118 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3119 (memcmp(view - 4, "\x66\x48\x8d\x3d", 4) == 0));
3120 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3121 (memcmp(view + 4, "\x66\x66\x48\xe8", 4) == 0));
2e30d253 3122
0ffd9845 3123 memcpy(view - 4, "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0\0", 16);
2e30d253 3124
6a41d30b 3125 value -= tls_segment->memsz();
0ffd9845 3126 Relocate_functions<64, false>::rela32(view + 8, value, 0);
2e30d253
ILT		 3127
3128 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3129 // We can skip it.
3130 this->skip_call_tls_get_addr_ = true;
2e30d253
ILT		 3131}
3132
c2b45e22
CC		 3133// Do a TLSDESC-style General-Dynamic to Initial-Exec transition.
3134
3135inline void
3136Target_x86_64::Relocate::tls_desc_gd_to_ie(
3137 const Relocate_info<64, false>* relinfo,
3138 size_t relnum,
3139 Output_segment*,
3140 const elfcpp::Rela<64, false>& rela,
3141 unsigned int r_type,
3142 elfcpp::Elf_types<64>::Elf_Addr value,
3143 unsigned char* view,
3144 elfcpp::Elf_types<64>::Elf_Addr address,
3145 section_size_type view_size)
3146{
3147 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3148 {
3149 // leaq foo@tlsdesc(%rip), %rax
3150 // ==> movq foo@gottpoff(%rip), %rax
3151 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3152 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3153 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3154 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
3155 view[-2] = 0x8b;
3156 const elfcpp::Elf_Xword addend = rela.get_r_addend();
3157 Relocate_functions<64, false>::pcrela32(view, value, addend, address);
3158 }
3159 else
3160 {
3161 // call *foo@tlscall(%rax)
3162 // ==> nop; nop
3163 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
3164 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
3165 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3166 view[0] == 0xff && view[1] == 0x10);
3167 view[0] = 0x66;
3168 view[1] = 0x90;
3169 }
3170}
3171
3172// Do a TLSDESC-style General-Dynamic to Local-Exec transition.
3173
3174inline void
3175Target_x86_64::Relocate::tls_desc_gd_to_le(
3176 const Relocate_info<64, false>* relinfo,
3177 size_t relnum,
3178 Output_segment* tls_segment,
3179 const elfcpp::Rela<64, false>& rela,
3180 unsigned int r_type,
3181 elfcpp::Elf_types<64>::Elf_Addr value,
3182 unsigned char* view,
3183 section_size_type view_size)
3184{
3185 if (r_type == elfcpp::R_X86_64_GOTPC32_TLSDESC)
3186 {
3187 // leaq foo@tlsdesc(%rip), %rax
3188 // ==> movq foo@tpoff, %rax
3189 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3190 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3191 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3192 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x05);
3193 view[-2] = 0xc7;
3194 view[-1] = 0xc0;
3195 value -= tls_segment->memsz();
3196 Relocate_functions<64, false>::rela32(view, value, 0);
3197 }
3198 else
3199 {
3200 // call *foo@tlscall(%rax)
3201 // ==> nop; nop
3202 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC_CALL);
3203 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 2);
3204 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3205 view[0] == 0xff && view[1] == 0x10);
3206 view[0] = 0x66;
3207 view[1] = 0x90;
3208 }
3209}
3210
2e30d253 3211inline void
72ec2876
ILT		 3212Target_x86_64::Relocate::tls_ld_to_le(const Relocate_info<64, false>* relinfo,
3213 size_t relnum,
3214 Output_segment*,
3215 const elfcpp::Rela<64, false>& rela,
3216 unsigned int,
3217 elfcpp::Elf_types<64>::Elf_Addr,
3218 unsigned char* view,
fe8718a4 3219 section_size_type view_size)
2e30d253 3220{
72ec2876
ILT		 3221 // leaq foo@tlsld(%rip),%rdi; call __tls_get_addr@plt;
3222 // ... leq foo@dtpoff(%rax),%reg
3223 // ==> .word 0x6666; .byte 0x66; movq %fs:0,%rax ... leaq x@tpoff(%rax),%rdx
2e30d253 3224
72ec2876
ILT		 3225 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3226 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 9);
2e30d253 3227
72ec2876
ILT		 3228 tls::check_tls(relinfo, relnum, rela.get_r_offset(),
3229 view[-3] == 0x48 && view[-2] == 0x8d && view[-1] == 0x3d);
3230
3231 tls::check_tls(relinfo, relnum, rela.get_r_offset(), view[4] == 0xe8);
3232
3233 memcpy(view - 3, "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0\0", 12);
3234
3235 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3236 // We can skip it.
3237 this->skip_call_tls_get_addr_ = true;
2e30d253
ILT		 3238}
3239
56622147
ILT		 3240// Do a relocation in which we convert a TLS Initial-Exec to a
3241// Local-Exec.
3242
3243inline void
3244Target_x86_64::Relocate::tls_ie_to_le(const Relocate_info<64, false>* relinfo,
3245 size_t relnum,
3246 Output_segment* tls_segment,
3247 const elfcpp::Rela<64, false>& rela,
3248 unsigned int,
3249 elfcpp::Elf_types<64>::Elf_Addr value,
3250 unsigned char* view,
fe8718a4 3251 section_size_type view_size)
56622147
ILT		 3252{
3253 // We need to examine the opcodes to figure out which instruction we
3254 // are looking at.
3255
3256 // movq foo@gottpoff(%rip),%reg ==> movq $YY,%reg
3257 // addq foo@gottpoff(%rip),%reg ==> addq $YY,%reg
3258
3259 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, -3);
3260 tls::check_range(relinfo, relnum, rela.get_r_offset(), view_size, 4);
3261
3262 unsigned char op1 = view[-3];
3263 unsigned char op2 = view[-2];
3264 unsigned char op3 = view[-1];
3265 unsigned char reg = op3 >> 3;
3266
3267 if (op2 == 0x8b)
3268 {
3269 // movq
3270 if (op1 == 0x4c)
3271 view[-3] = 0x49;
3272 view[-2] = 0xc7;
3273 view[-1] = 0xc0 | reg;
3274 }
3275 else if (reg == 4)
3276 {
3277 // Special handling for %rsp.
3278 if (op1 == 0x4c)
3279 view[-3] = 0x49;
3280 view[-2] = 0x81;
3281 view[-1] = 0xc0 | reg;
3282 }
3283 else
3284 {
3285 // addq
3286 if (op1 == 0x4c)
3287 view[-3] = 0x4d;
3288 view[-2] = 0x8d;
3289 view[-1] = 0x80 | reg | (reg << 3);
3290 }
3291
6a41d30b 3292 value -= tls_segment->memsz();
56622147
ILT		 3293 Relocate_functions<64, false>::rela32(view, value, 0);
3294}
3295
2e30d253
ILT		 3296// Relocate section data.
3297
3298void
364c7fa5
ILT		 3299Target_x86_64::relocate_section(
3300 const Relocate_info<64, false>* relinfo,
3301 unsigned int sh_type,
3302 const unsigned char* prelocs,
3303 size_t reloc_count,
3304 Output_section* output_section,
3305 bool needs_special_offset_handling,
3306 unsigned char* view,
3307 elfcpp::Elf_types<64>::Elf_Addr address,
3308 section_size_type view_size,
3309 const Reloc_symbol_changes* reloc_symbol_changes)
2e30d253
ILT		 3310{
3311 gold_assert(sh_type == elfcpp::SHT_RELA);
3312
3313 gold::relocate_section<64, false, Target_x86_64, elfcpp::SHT_RELA,
3314 Target_x86_64::Relocate>(
3315 relinfo,
3316 this,
3317 prelocs,
3318 reloc_count,
730cdc88
ILT		 3319 output_section,
3320 needs_special_offset_handling,
2e30d253
ILT		 3321 view,
3322 address,
364c7fa5
ILT		 3323 view_size,
3324 reloc_symbol_changes);
2e30d253
ILT		 3325}
3326
94a3fc8b
CC		 3327// Apply an incremental relocation. Incremental relocations always refer
3328// to global symbols.
3329
3330void
3331Target_x86_64::apply_relocation(
3332 const Relocate_info<64, false>* relinfo,
3333 elfcpp::Elf_types<64>::Elf_Addr r_offset,
3334 unsigned int r_type,
3335 elfcpp::Elf_types<64>::Elf_Swxword r_addend,
3336 const Symbol* gsym,
3337 unsigned char* view,
3338 elfcpp::Elf_types<64>::Elf_Addr address,
3339 section_size_type view_size)
3340{
3341 gold::apply_relocation<64, false, Target_x86_64, Target_x86_64::Relocate>(
3342 relinfo,
3343 this,
3344 r_offset,
3345 r_type,
3346 r_addend,
3347 gsym,
3348 view,
3349 address,
3350 view_size);
3351}
3352
6a74a719
ILT		 3353// Return the size of a relocation while scanning during a relocatable
3354// link.
3355
3356unsigned int
3357Target_x86_64::Relocatable_size_for_reloc::get_size_for_reloc(
3358 unsigned int r_type,
3359 Relobj* object)
3360{
3361 switch (r_type)
3362 {
3363 case elfcpp::R_X86_64_NONE:
6e5710ce
ILT		 3364 case elfcpp::R_X86_64_GNU_VTINHERIT:
3365 case elfcpp::R_X86_64_GNU_VTENTRY:
6a74a719
ILT		 3366 case elfcpp::R_X86_64_TLSGD: // Global-dynamic
3367 case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
3368 case elfcpp::R_X86_64_TLSDESC_CALL:
3369 case elfcpp::R_X86_64_TLSLD: // Local-dynamic
3370 case elfcpp::R_X86_64_DTPOFF32:
3371 case elfcpp::R_X86_64_DTPOFF64:
3372 case elfcpp::R_X86_64_GOTTPOFF: // Initial-exec
3373 case elfcpp::R_X86_64_TPOFF32: // Local-exec
3374 return 0;
3375
3376 case elfcpp::R_X86_64_64:
3377 case elfcpp::R_X86_64_PC64:
3378 case elfcpp::R_X86_64_GOTOFF64:
3379 case elfcpp::R_X86_64_GOTPC64:
3380 case elfcpp::R_X86_64_PLTOFF64:
3381 case elfcpp::R_X86_64_GOT64:
3382 case elfcpp::R_X86_64_GOTPCREL64:
3383 case elfcpp::R_X86_64_GOTPCREL:
3384 case elfcpp::R_X86_64_GOTPLT64:
3385 return 8;
3386
3387 case elfcpp::R_X86_64_32:
3388 case elfcpp::R_X86_64_32S:
3389 case elfcpp::R_X86_64_PC32:
3390 case elfcpp::R_X86_64_PLT32:
3391 case elfcpp::R_X86_64_GOTPC32:
3392 case elfcpp::R_X86_64_GOT32:
3393 return 4;
3394
3395 case elfcpp::R_X86_64_16:
3396 case elfcpp::R_X86_64_PC16:
3397 return 2;
3398
3399 case elfcpp::R_X86_64_8:
3400 case elfcpp::R_X86_64_PC8:
3401 return 1;
3402
3403 case elfcpp::R_X86_64_COPY:
3404 case elfcpp::R_X86_64_GLOB_DAT:
3405 case elfcpp::R_X86_64_JUMP_SLOT:
3406 case elfcpp::R_X86_64_RELATIVE:
7223e9ca 3407 case elfcpp::R_X86_64_IRELATIVE:
6a74a719
ILT		 3408 // These are outstanding tls relocs, which are unexpected when linking
3409 case elfcpp::R_X86_64_TPOFF64:
3410 case elfcpp::R_X86_64_DTPMOD64:
3411 case elfcpp::R_X86_64_TLSDESC:
3412 object->error(_("unexpected reloc %u in object file"), r_type);
3413 return 0;
3414
3415 case elfcpp::R_X86_64_SIZE32:
3416 case elfcpp::R_X86_64_SIZE64:
3417 default:
3418 object->error(_("unsupported reloc %u against local symbol"), r_type);
3419 return 0;
3420 }
3421}
3422
3423// Scan the relocs during a relocatable link.
3424
3425void
ad0f2072 3426Target_x86_64::scan_relocatable_relocs(Symbol_table* symtab,
6a74a719 3427 Layout* layout,
6fa2a40b 3428 Sized_relobj_file<64, false>* object,
6a74a719
ILT		 3429 unsigned int data_shndx,
3430 unsigned int sh_type,
3431 const unsigned char* prelocs,
3432 size_t reloc_count,
3433 Output_section* output_section,
3434 bool needs_special_offset_handling,
3435 size_t local_symbol_count,
3436 const unsigned char* plocal_symbols,
3437 Relocatable_relocs* rr)
3438{
3439 gold_assert(sh_type == elfcpp::SHT_RELA);
3440
3441 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
3442 Relocatable_size_for_reloc> Scan_relocatable_relocs;
3443
7019cd25 3444 gold::scan_relocatable_relocs<64, false, elfcpp::SHT_RELA,
6a74a719 3445 Scan_relocatable_relocs>(
6a74a719
ILT		 3446 symtab,
3447 layout,
3448 object,
3449 data_shndx,
3450 prelocs,
3451 reloc_count,
3452 output_section,
3453 needs_special_offset_handling,
3454 local_symbol_count,
3455 plocal_symbols,
3456 rr);
3457}
3458
3459// Relocate a section during a relocatable link.
3460
3461void
3462Target_x86_64::relocate_for_relocatable(
3463 const Relocate_info<64, false>* relinfo,
3464 unsigned int sh_type,
3465 const unsigned char* prelocs,
3466 size_t reloc_count,
3467 Output_section* output_section,
3468 off_t offset_in_output_section,
3469 const Relocatable_relocs* rr,
3470 unsigned char* view,
3471 elfcpp::Elf_types<64>::Elf_Addr view_address,
3472 section_size_type view_size,
3473 unsigned char* reloc_view,
3474 section_size_type reloc_view_size)
3475{
3476 gold_assert(sh_type == elfcpp::SHT_RELA);
3477
7019cd25 3478 gold::relocate_for_relocatable<64, false, elfcpp::SHT_RELA>(
6a74a719
ILT		 3479 relinfo,
3480 prelocs,
3481 reloc_count,
3482 output_section,
3483 offset_in_output_section,
3484 rr,
3485 view,
3486 view_address,
3487 view_size,
3488 reloc_view,
3489 reloc_view_size);
3490}
3491
4fb6c25d
ILT		 3492// Return the value to use for a dynamic which requires special
3493// treatment. This is how we support equality comparisons of function
3494// pointers across shared library boundaries, as described in the
3495// processor specific ABI supplement.
3496
3497uint64_t
3498Target_x86_64::do_dynsym_value(const Symbol* gsym) const
3499{
3500 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3501 return this->plt_section()->address() + gsym->plt_offset();
3502}
3503
2e30d253
ILT		 3504// Return a string used to fill a code section with nops to take up
3505// the specified length.
3506
3507std::string
8851ecca 3508Target_x86_64::do_code_fill(section_size_type length) const
2e30d253
ILT		 3509{
3510 if (length >= 16)
3511 {
3512 // Build a jmpq instruction to skip over the bytes.
3513 unsigned char jmp[5];
3514 jmp[0] = 0xe9;
04bf7072 3515 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
2e30d253
ILT		 3516 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
3517 + std::string(length - 5, '\0'));
3518 }
3519
3520 // Nop sequences of various lengths.
3521 const char nop1[1] = { 0x90 }; // nop
3522 const char nop2[2] = { 0x66, 0x90 }; // xchg %ax %ax
1caf2c51
ILT		 3523 const char nop3[3] = { 0x0f, 0x1f, 0x00 }; // nop (%rax)
3524 const char nop4[4] = { 0x0f, 0x1f, 0x40, 0x00}; // nop 0(%rax)
3525 const char nop5[5] = { 0x0f, 0x1f, 0x44, 0x00, // nop 0(%rax,%rax,1)
3526 0x00 };
3527 const char nop6[6] = { 0x66, 0x0f, 0x1f, 0x44, // nopw 0(%rax,%rax,1)
2e30d253 3528 0x00, 0x00 };
1caf2c51 3529 const char nop7[7] = { 0x0f, 0x1f, 0x80, 0x00, // nopl 0L(%rax)
2e30d253 3530 0x00, 0x00, 0x00 };
1caf2c51
ILT		 3531 const char nop8[8] = { 0x0f, 0x1f, 0x84, 0x00, // nopl 0L(%rax,%rax,1)
3532 0x00, 0x00, 0x00, 0x00 };
3533 const char nop9[9] = { 0x66, 0x0f, 0x1f, 0x84, // nopw 0L(%rax,%rax,1)
3534 0x00, 0x00, 0x00, 0x00,
2e30d253 3535 0x00 };
1caf2c51
ILT		 3536 const char nop10[10] = { 0x66, 0x2e, 0x0f, 0x1f, // nopw %cs:0L(%rax,%rax,1)
3537 0x84, 0x00, 0x00, 0x00,
2e30d253 3538 0x00, 0x00 };
1caf2c51
ILT		 3539 const char nop11[11] = { 0x66, 0x66, 0x2e, 0x0f, // data16
3540 0x1f, 0x84, 0x00, 0x00, // nopw %cs:0L(%rax,%rax,1)
2e30d253 3541 0x00, 0x00, 0x00 };
1caf2c51
ILT		 3542 const char nop12[12] = { 0x66, 0x66, 0x66, 0x2e, // data16; data16
3543 0x0f, 0x1f, 0x84, 0x00, // nopw %cs:0L(%rax,%rax,1)
2e30d253 3544 0x00, 0x00, 0x00, 0x00 };
1caf2c51
ILT		 3545 const char nop13[13] = { 0x66, 0x66, 0x66, 0x66, // data16; data16; data16
3546 0x2e, 0x0f, 0x1f, 0x84, // nopw %cs:0L(%rax,%rax,1)
3547 0x00, 0x00, 0x00, 0x00,
2e30d253 3548 0x00 };
1caf2c51
ILT		 3549 const char nop14[14] = { 0x66, 0x66, 0x66, 0x66, // data16; data16; data16
3550 0x66, 0x2e, 0x0f, 0x1f, // data16
3551 0x84, 0x00, 0x00, 0x00, // nopw %cs:0L(%rax,%rax,1)
2e30d253 3552 0x00, 0x00 };
1caf2c51
ILT		 3553 const char nop15[15] = { 0x66, 0x66, 0x66, 0x66, // data16; data16; data16
3554 0x66, 0x66, 0x2e, 0x0f, // data16; data16
3555 0x1f, 0x84, 0x00, 0x00, // nopw %cs:0L(%rax,%rax,1)
3556 0x00, 0x00, 0x00 };
2e30d253
ILT		 3557
3558 const char* nops[16] = {
3559 NULL,
3560 nop1, nop2, nop3, nop4, nop5, nop6, nop7,
3561 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
3562 };
3563
3564 return std::string(nops[length], length);
3565}
3566
e291e7b9
ILT		 3567// Return the addend to use for a target specific relocation. The
3568// only target specific relocation is R_X86_64_TLSDESC for a local
3569// symbol. We want to set the addend is the offset of the local
3570// symbol in the TLS segment.
3571
3572uint64_t
3573Target_x86_64::do_reloc_addend(void* arg, unsigned int r_type,
3574 uint64_t) const
3575{
3576 gold_assert(r_type == elfcpp::R_X86_64_TLSDESC);
3577 uintptr_t intarg = reinterpret_cast<uintptr_t>(arg);
3578 gold_assert(intarg < this->tlsdesc_reloc_info_.size());
3579 const Tlsdesc_info& ti(this->tlsdesc_reloc_info_[intarg]);
3580 const Symbol_value<64>* psymval = ti.object->local_symbol(ti.r_sym);
3581 gold_assert(psymval->is_tls_symbol());
3582 // The value of a TLS symbol is the offset in the TLS segment.
3583 return psymval->value(ti.object, 0);
3584}
3585
364c7fa5 3586// FNOFFSET in section SHNDX in OBJECT is the start of a function
9b547ce6 3587// compiled with -fsplit-stack. The function calls non-split-stack
364c7fa5
ILT		 3588// code. We have to change the function so that it always ensures
3589// that it has enough stack space to run some random function.
3590
3591void
3592Target_x86_64::do_calls_non_split(Relobj* object, unsigned int shndx,
3593 section_offset_type fnoffset,
3594 section_size_type fnsize,
3595 unsigned char* view,
3596 section_size_type view_size,
3597 std::string* from,
3598 std::string* to) const
3599{
3600 // The function starts with a comparison of the stack pointer and a
3601 // field in the TCB. This is followed by a jump.
3602
3603 // cmp %fs:NN,%rsp
3604 if (this->match_view(view, view_size, fnoffset, "\x64\x48\x3b\x24\x25", 5)
3605 && fnsize > 9)
3606 {
3607 // We will call __morestack if the carry flag is set after this
3608 // comparison. We turn the comparison into an stc instruction
3609 // and some nops.
3610 view[fnoffset] = '\xf9';
3611 this->set_view_to_nop(view, view_size, fnoffset + 1, 8);
3612 }
3613 // lea NN(%rsp),%r10
cbc999b9
ILT		 3614 // lea NN(%rsp),%r11
3615 else if ((this->match_view(view, view_size, fnoffset,
3616 "\x4c\x8d\x94\x24", 4)
3617 || this->match_view(view, view_size, fnoffset,
3618 "\x4c\x8d\x9c\x24", 4))
364c7fa5
ILT		 3619 && fnsize > 8)
3620 {
3621 // This is loading an offset from the stack pointer for a
3622 // comparison. The offset is negative, so we decrease the
3623 // offset by the amount of space we need for the stack. This
3624 // means we will avoid calling __morestack if there happens to
3625 // be plenty of space on the stack already.
3626 unsigned char* pval = view + fnoffset + 4;
3627 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
3628 val -= parameters->options().split_stack_adjust_size();
3629 elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
3630 }
3631 else
3632 {
3633 if (!object->has_no_split_stack())
3634 object->error(_("failed to match split-stack sequence at "
3635 "section %u offset %0zx"),
ac33a407 3636 shndx, static_cast<size_t>(fnoffset));
364c7fa5
ILT		 3637 return;
3638 }
3639
3640 // We have to change the function so that it calls
3641 // __morestack_non_split instead of __morestack. The former will
3642 // allocate additional stack space.
3643 *from = "__morestack";
3644 *to = "__morestack_non_split";
3645}
3646
2e30d253
ILT		 3647// The selector for x86_64 object files.
3648
36959681 3649class Target_selector_x86_64 : public Target_selector_freebsd
2e30d253
ILT		 3650{
3651public:
3652 Target_selector_x86_64()
36959681
ILT		 3653 : Target_selector_freebsd(elfcpp::EM_X86_64, 64, false, "elf64-x86-64",
3654 "elf64-x86-64-freebsd")
2e30d253
ILT		 3655 { }
3656
3657 Target*
e96caa79
ILT		 3658 do_instantiate_target()
3659 { return new Target_x86_64(); }
36959681 3660
2e30d253
ILT		 3661};
3662
2e30d253
ILT		 3663Target_selector_x86_64 target_selector_x86_64;
3664
3665} // End anonymous namespace.
GDB Binutils - Deliverables
This page took 0.538779 seconds and 4 git commands to generate.