Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / bfd / elf64-x86-64.c
1 /* X86-64 specific support for 64-bit ELF
2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3    2010  Free Software Foundation, Inc.
4    Contributed by Jan Hubicka <jh@suse.cz>.
5
6    This file is part of BFD, the Binary File Descriptor library.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "bfd_stdint.h"
29 #include "objalloc.h"
30 #include "hashtab.h"
31
32 #include "elf/x86-64.h"
33
34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
35 #define MINUS_ONE (~ (bfd_vma) 0)
36
37 /* The relocation "howto" table.  Order of fields:
38    type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
39    special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset.  */
40 static reloc_howto_type x86_64_elf_howto_table[] =
41 {
42   HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
43         bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
44         FALSE),
45   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
46         bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
47         FALSE),
48   HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
49         bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
50         TRUE),
51   HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
52         bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
53         FALSE),
54   HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
55         bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
56         TRUE),
57   HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
58         bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
59         FALSE),
60   HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
61         bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
62         MINUS_ONE, FALSE),
63   HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
64         bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
65         MINUS_ONE, FALSE),
66   HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
67         bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
68         MINUS_ONE, FALSE),
69   HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
70         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
71         0xffffffff, TRUE),
72   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
73         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
74         FALSE),
75   HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
76         bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
77         FALSE),
78   HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
79         bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
80   HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
81         bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
82   HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
83         bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
84   HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
85         bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
86   HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
87         bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
88         MINUS_ONE, FALSE),
89   HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
90         bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
91         MINUS_ONE, FALSE),
92   HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
93         bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
94         MINUS_ONE, FALSE),
95   HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
96         bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
97         0xffffffff, TRUE),
98   HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
99         bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
100         0xffffffff, TRUE),
101   HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
102         bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
103         0xffffffff, FALSE),
104   HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
105         bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
106         0xffffffff, TRUE),
107   HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
108         bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
109         0xffffffff, FALSE),
110   HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
111         bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
112         TRUE),
113   HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
114         bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
115         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
116   HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
117         bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
118         FALSE, 0xffffffff, 0xffffffff, TRUE),
119   HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
120         bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
121         FALSE),
122   HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
123         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
124         MINUS_ONE, TRUE),
125   HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
126         bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
127         FALSE, MINUS_ONE, MINUS_ONE, TRUE),
128   HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
129         bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
130         MINUS_ONE, FALSE),
131   HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
132         bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
133         MINUS_ONE, FALSE),
134   EMPTY_HOWTO (32),
135   EMPTY_HOWTO (33),
136   HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
137         complain_overflow_bitfield, bfd_elf_generic_reloc,
138         "R_X86_64_GOTPC32_TLSDESC",
139         FALSE, 0xffffffff, 0xffffffff, TRUE),
140   HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
141         complain_overflow_dont, bfd_elf_generic_reloc,
142         "R_X86_64_TLSDESC_CALL",
143         FALSE, 0, 0, FALSE),
144   HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
145         complain_overflow_bitfield, bfd_elf_generic_reloc,
146         "R_X86_64_TLSDESC",
147         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
148   HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
149         bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
150         MINUS_ONE, FALSE),
151
152   /* We have a gap in the reloc numbers here.
153      R_X86_64_standard counts the number up to this point, and
154      R_X86_64_vt_offset is the value to subtract from a reloc type of
155      R_X86_64_GNU_VT* to form an index into this table.  */
156 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
157 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
158
159 /* GNU extension to record C++ vtable hierarchy.  */
160   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
161          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
162
163 /* GNU extension to record C++ vtable member usage.  */
164   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
165          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
166          FALSE)
167 };
168
169 #define IS_X86_64_PCREL_TYPE(TYPE)      \
170   (   ((TYPE) == R_X86_64_PC8)          \
171    || ((TYPE) == R_X86_64_PC16)         \
172    || ((TYPE) == R_X86_64_PC32)         \
173    || ((TYPE) == R_X86_64_PC64))
174
175 /* Map BFD relocs to the x86_64 elf relocs.  */
176 struct elf_reloc_map
177 {
178   bfd_reloc_code_real_type bfd_reloc_val;
179   unsigned char elf_reloc_val;
180 };
181
182 static const struct elf_reloc_map x86_64_reloc_map[] =
183 {
184   { BFD_RELOC_NONE,             R_X86_64_NONE, },
185   { BFD_RELOC_64,               R_X86_64_64,   },
186   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
187   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
188   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
189   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
190   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
191   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
192   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
193   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
194   { BFD_RELOC_32,               R_X86_64_32, },
195   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
196   { BFD_RELOC_16,               R_X86_64_16, },
197   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
198   { BFD_RELOC_8,                R_X86_64_8, },
199   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
200   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
201   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
202   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
203   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
204   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
205   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
206   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
207   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
208   { BFD_RELOC_64_PCREL,         R_X86_64_PC64, },
209   { BFD_RELOC_X86_64_GOTOFF64,  R_X86_64_GOTOFF64, },
210   { BFD_RELOC_X86_64_GOTPC32,   R_X86_64_GOTPC32, },
211   { BFD_RELOC_X86_64_GOT64,     R_X86_64_GOT64, },
212   { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
213   { BFD_RELOC_X86_64_GOTPC64,   R_X86_64_GOTPC64, },
214   { BFD_RELOC_X86_64_GOTPLT64,  R_X86_64_GOTPLT64, },
215   { BFD_RELOC_X86_64_PLTOFF64,  R_X86_64_PLTOFF64, },
216   { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
217   { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
218   { BFD_RELOC_X86_64_TLSDESC,   R_X86_64_TLSDESC, },
219   { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
220   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
221   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
222 };
223
224 static reloc_howto_type *
225 elf64_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
226 {
227   unsigned i;
228
229   if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
230       || r_type >= (unsigned int) R_X86_64_max)
231     {
232       if (r_type >= (unsigned int) R_X86_64_standard)
233         {
234           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
235                                  abfd, (int) r_type);
236           r_type = R_X86_64_NONE;
237         }
238       i = r_type;
239     }
240   else
241     i = r_type - (unsigned int) R_X86_64_vt_offset;
242   BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
243   return &x86_64_elf_howto_table[i];
244 }
245
246 /* Given a BFD reloc type, return a HOWTO structure.  */
247 static reloc_howto_type *
248 elf64_x86_64_reloc_type_lookup (bfd *abfd,
249                                 bfd_reloc_code_real_type code)
250 {
251   unsigned int i;
252
253   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
254        i++)
255     {
256       if (x86_64_reloc_map[i].bfd_reloc_val == code)
257         return elf64_x86_64_rtype_to_howto (abfd,
258                                             x86_64_reloc_map[i].elf_reloc_val);
259     }
260   return 0;
261 }
262
263 static reloc_howto_type *
264 elf64_x86_64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
265                                 const char *r_name)
266 {
267   unsigned int i;
268
269   for (i = 0;
270        i < (sizeof (x86_64_elf_howto_table)
271             / sizeof (x86_64_elf_howto_table[0]));
272        i++)
273     if (x86_64_elf_howto_table[i].name != NULL
274         && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
275       return &x86_64_elf_howto_table[i];
276
277   return NULL;
278 }
279
280 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
281
282 static void
283 elf64_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
284                             Elf_Internal_Rela *dst)
285 {
286   unsigned r_type;
287
288   r_type = ELF64_R_TYPE (dst->r_info);
289   cache_ptr->howto = elf64_x86_64_rtype_to_howto (abfd, r_type);
290   BFD_ASSERT (r_type == cache_ptr->howto->type);
291 }
292 \f
293 /* Support for core dump NOTE sections.  */
294 static bfd_boolean
295 elf64_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
296 {
297   int offset;
298   size_t size;
299
300   switch (note->descsz)
301     {
302       default:
303         return FALSE;
304
305       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
306         /* pr_cursig */
307         elf_tdata (abfd)->core_signal
308           = bfd_get_16 (abfd, note->descdata + 12);
309
310         /* pr_pid */
311         elf_tdata (abfd)->core_lwpid
312           = bfd_get_32 (abfd, note->descdata + 32);
313
314         /* pr_reg */
315         offset = 112;
316         size = 216;
317
318         break;
319     }
320
321   /* Make a ".reg/999" section.  */
322   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
323                                           size, note->descpos + offset);
324 }
325
326 static bfd_boolean
327 elf64_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
328 {
329   switch (note->descsz)
330     {
331       default:
332         return FALSE;
333
334       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
335         elf_tdata (abfd)->core_pid
336           = bfd_get_32 (abfd, note->descdata + 24);
337         elf_tdata (abfd)->core_program
338          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
339         elf_tdata (abfd)->core_command
340          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
341     }
342
343   /* Note that for some reason, a spurious space is tacked
344      onto the end of the args in some (at least one anyway)
345      implementations, so strip it off if it exists.  */
346
347   {
348     char *command = elf_tdata (abfd)->core_command;
349     int n = strlen (command);
350
351     if (0 < n && command[n - 1] == ' ')
352       command[n - 1] = '\0';
353   }
354
355   return TRUE;
356 }
357 \f
358 /* Functions for the x86-64 ELF linker.  */
359
360 /* The name of the dynamic interpreter.  This is put in the .interp
361    section.  */
362
363 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
364
365 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
366    copying dynamic variables from a shared lib into an app's dynbss
367    section, and instead use a dynamic relocation to point into the
368    shared lib.  */
369 #define ELIMINATE_COPY_RELOCS 1
370
371 /* The size in bytes of an entry in the global offset table.  */
372
373 #define GOT_ENTRY_SIZE 8
374
375 /* The size in bytes of an entry in the procedure linkage table.  */
376
377 #define PLT_ENTRY_SIZE 16
378
379 /* The first entry in a procedure linkage table looks like this.  See the
380    SVR4 ABI i386 supplement and the x86-64 ABI to see how this works.  */
381
382 static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
383 {
384   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
385   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
386   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
387 };
388
389 /* Subsequent entries in a procedure linkage table look like this.  */
390
391 static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
392 {
393   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
394   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
395   0x68,         /* pushq immediate */
396   0, 0, 0, 0,   /* replaced with index into relocation table.  */
397   0xe9,         /* jmp relative */
398   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
399 };
400
401 /* x86-64 ELF linker hash entry.  */
402
403 struct elf64_x86_64_link_hash_entry
404 {
405   struct elf_link_hash_entry elf;
406
407   /* Track dynamic relocs copied for this symbol.  */
408   struct elf_dyn_relocs *dyn_relocs;
409
410 #define GOT_UNKNOWN     0
411 #define GOT_NORMAL      1
412 #define GOT_TLS_GD      2
413 #define GOT_TLS_IE      3
414 #define GOT_TLS_GDESC   4
415 #define GOT_TLS_GD_BOTH_P(type) \
416   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
417 #define GOT_TLS_GD_P(type) \
418   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
419 #define GOT_TLS_GDESC_P(type) \
420   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
421 #define GOT_TLS_GD_ANY_P(type) \
422   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
423   unsigned char tls_type;
424
425   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
426      starting at the end of the jump table.  */
427   bfd_vma tlsdesc_got;
428 };
429
430 #define elf64_x86_64_hash_entry(ent) \
431   ((struct elf64_x86_64_link_hash_entry *)(ent))
432
433 struct elf64_x86_64_obj_tdata
434 {
435   struct elf_obj_tdata root;
436
437   /* tls_type for each local got entry.  */
438   char *local_got_tls_type;
439
440   /* GOTPLT entries for TLS descriptors.  */
441   bfd_vma *local_tlsdesc_gotent;
442 };
443
444 #define elf64_x86_64_tdata(abfd) \
445   ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
446
447 #define elf64_x86_64_local_got_tls_type(abfd) \
448   (elf64_x86_64_tdata (abfd)->local_got_tls_type)
449
450 #define elf64_x86_64_local_tlsdesc_gotent(abfd) \
451   (elf64_x86_64_tdata (abfd)->local_tlsdesc_gotent)
452
453 #define is_x86_64_elf(bfd)                              \
454   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
455    && elf_tdata (bfd) != NULL                           \
456    && elf_object_id (bfd) == X86_64_ELF_DATA)
457
458 static bfd_boolean
459 elf64_x86_64_mkobject (bfd *abfd)
460 {
461   return bfd_elf_allocate_object (abfd, sizeof (struct elf64_x86_64_obj_tdata),
462                                   X86_64_ELF_DATA);
463 }
464
465 /* x86-64 ELF linker hash table.  */
466
467 struct elf64_x86_64_link_hash_table
468 {
469   struct elf_link_hash_table elf;
470
471   /* Short-cuts to get to dynamic linker sections.  */
472   asection *sdynbss;
473   asection *srelbss;
474
475   union
476   {
477     bfd_signed_vma refcount;
478     bfd_vma offset;
479   } tls_ld_got;
480
481   /* The amount of space used by the jump slots in the GOT.  */
482   bfd_vma sgotplt_jump_table_size;
483
484   /* Small local sym cache.  */
485   struct sym_cache sym_cache;
486
487   /* _TLS_MODULE_BASE_ symbol.  */
488   struct bfd_link_hash_entry *tls_module_base;
489
490   /* Used by local STT_GNU_IFUNC symbols.  */
491   htab_t loc_hash_table;
492   void * loc_hash_memory;
493
494   /* The offset into splt of the PLT entry for the TLS descriptor
495      resolver.  Special values are 0, if not necessary (or not found
496      to be necessary yet), and -1 if needed but not determined
497      yet.  */
498   bfd_vma tlsdesc_plt;
499   /* The offset into sgot of the GOT entry used by the PLT entry
500      above.  */
501   bfd_vma tlsdesc_got;
502 };
503
504 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
505
506 #define elf64_x86_64_hash_table(p) \
507   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
508   == X86_64_ELF_DATA ? ((struct elf64_x86_64_link_hash_table *) ((p)->hash)) : NULL)
509
510 #define elf64_x86_64_compute_jump_table_size(htab) \
511   ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
512
513 /* Create an entry in an x86-64 ELF linker hash table.  */
514
515 static struct bfd_hash_entry *
516 elf64_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
517                                 struct bfd_hash_table *table,
518                                 const char *string)
519 {
520   /* Allocate the structure if it has not already been allocated by a
521      subclass.  */
522   if (entry == NULL)
523     {
524       entry = (struct bfd_hash_entry *)
525           bfd_hash_allocate (table,
526                              sizeof (struct elf64_x86_64_link_hash_entry));
527       if (entry == NULL)
528         return entry;
529     }
530
531   /* Call the allocation method of the superclass.  */
532   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
533   if (entry != NULL)
534     {
535       struct elf64_x86_64_link_hash_entry *eh;
536
537       eh = (struct elf64_x86_64_link_hash_entry *) entry;
538       eh->dyn_relocs = NULL;
539       eh->tls_type = GOT_UNKNOWN;
540       eh->tlsdesc_got = (bfd_vma) -1;
541     }
542
543   return entry;
544 }
545
546 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
547   for local symbol so that we can handle local STT_GNU_IFUNC symbols
548   as global symbol.  We reuse indx and dynstr_index for local symbol
549   hash since they aren't used by global symbols in this backend.  */
550
551 static hashval_t
552 elf64_x86_64_local_htab_hash (const void *ptr)
553 {
554   struct elf_link_hash_entry *h
555     = (struct elf_link_hash_entry *) ptr;
556   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
557 }
558
559 /* Compare local hash entries.  */
560
561 static int
562 elf64_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
563 {
564   struct elf_link_hash_entry *h1
565      = (struct elf_link_hash_entry *) ptr1;
566   struct elf_link_hash_entry *h2
567     = (struct elf_link_hash_entry *) ptr2;
568
569   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
570 }
571
572 /* Find and/or create a hash entry for local symbol.  */
573
574 static struct elf_link_hash_entry *
575 elf64_x86_64_get_local_sym_hash (struct elf64_x86_64_link_hash_table *htab,
576                                  bfd *abfd, const Elf_Internal_Rela *rel,
577                                  bfd_boolean create)
578 {
579   struct elf64_x86_64_link_hash_entry e, *ret;
580   asection *sec = abfd->sections;
581   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
582                                        ELF64_R_SYM (rel->r_info));
583   void **slot;
584
585   e.elf.indx = sec->id;
586   e.elf.dynstr_index = ELF64_R_SYM (rel->r_info);
587   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
588                                    create ? INSERT : NO_INSERT);
589
590   if (!slot)
591     return NULL;
592
593   if (*slot)
594     {
595       ret = (struct elf64_x86_64_link_hash_entry *) *slot;
596       return &ret->elf;
597     }
598
599   ret = (struct elf64_x86_64_link_hash_entry *)
600         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
601                         sizeof (struct elf64_x86_64_link_hash_entry));
602   if (ret)
603     {
604       memset (ret, 0, sizeof (*ret));
605       ret->elf.indx = sec->id;
606       ret->elf.dynstr_index = ELF64_R_SYM (rel->r_info);
607       ret->elf.dynindx = -1;
608       *slot = ret;
609     }
610   return &ret->elf;
611 }
612
613 /* Create an X86-64 ELF linker hash table.  */
614
615 static struct bfd_link_hash_table *
616 elf64_x86_64_link_hash_table_create (bfd *abfd)
617 {
618   struct elf64_x86_64_link_hash_table *ret;
619   bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
620
621   ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
622   if (ret == NULL)
623     return NULL;
624
625   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
626                                       elf64_x86_64_link_hash_newfunc,
627                                       sizeof (struct elf64_x86_64_link_hash_entry),
628                                       X86_64_ELF_DATA))
629     {
630       free (ret);
631       return NULL;
632     }
633
634   ret->sdynbss = NULL;
635   ret->srelbss = NULL;
636   ret->sym_cache.abfd = NULL;
637   ret->tlsdesc_plt = 0;
638   ret->tlsdesc_got = 0;
639   ret->tls_ld_got.refcount = 0;
640   ret->sgotplt_jump_table_size = 0;
641   ret->tls_module_base = NULL;
642
643   ret->loc_hash_table = htab_try_create (1024,
644                                          elf64_x86_64_local_htab_hash,
645                                          elf64_x86_64_local_htab_eq,
646                                          NULL);
647   ret->loc_hash_memory = objalloc_create ();
648   if (!ret->loc_hash_table || !ret->loc_hash_memory)
649     {
650       free (ret);
651       return NULL;
652     }
653
654   return &ret->elf.root;
655 }
656
657 /* Destroy an X86-64 ELF linker hash table.  */
658
659 static void
660 elf64_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
661 {
662   struct elf64_x86_64_link_hash_table *htab
663     = (struct elf64_x86_64_link_hash_table *) hash;
664
665   if (htab->loc_hash_table)
666     htab_delete (htab->loc_hash_table);
667   if (htab->loc_hash_memory)
668     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
669   _bfd_generic_link_hash_table_free (hash);
670 }
671
672 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
673    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
674    hash table.  */
675
676 static bfd_boolean
677 elf64_x86_64_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
678 {
679   struct elf64_x86_64_link_hash_table *htab;
680
681   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
682     return FALSE;
683
684   htab = elf64_x86_64_hash_table (info);
685   if (htab == NULL)
686     return FALSE;
687
688   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
689   if (!info->shared)
690     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
691
692   if (!htab->sdynbss
693       || (!info->shared && !htab->srelbss))
694     abort ();
695
696   return TRUE;
697 }
698
699 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
700
701 static void
702 elf64_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
703                                    struct elf_link_hash_entry *dir,
704                                    struct elf_link_hash_entry *ind)
705 {
706   struct elf64_x86_64_link_hash_entry *edir, *eind;
707
708   edir = (struct elf64_x86_64_link_hash_entry *) dir;
709   eind = (struct elf64_x86_64_link_hash_entry *) ind;
710
711   if (eind->dyn_relocs != NULL)
712     {
713       if (edir->dyn_relocs != NULL)
714         {
715           struct elf_dyn_relocs **pp;
716           struct elf_dyn_relocs *p;
717
718           /* Add reloc counts against the indirect sym to the direct sym
719              list.  Merge any entries against the same section.  */
720           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
721             {
722               struct elf_dyn_relocs *q;
723
724               for (q = edir->dyn_relocs; q != NULL; q = q->next)
725                 if (q->sec == p->sec)
726                   {
727                     q->pc_count += p->pc_count;
728                     q->count += p->count;
729                     *pp = p->next;
730                     break;
731                   }
732               if (q == NULL)
733                 pp = &p->next;
734             }
735           *pp = edir->dyn_relocs;
736         }
737
738       edir->dyn_relocs = eind->dyn_relocs;
739       eind->dyn_relocs = NULL;
740     }
741
742   if (ind->root.type == bfd_link_hash_indirect
743       && dir->got.refcount <= 0)
744     {
745       edir->tls_type = eind->tls_type;
746       eind->tls_type = GOT_UNKNOWN;
747     }
748
749   if (ELIMINATE_COPY_RELOCS
750       && ind->root.type != bfd_link_hash_indirect
751       && dir->dynamic_adjusted)
752     {
753       /* If called to transfer flags for a weakdef during processing
754          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
755          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
756       dir->ref_dynamic |= ind->ref_dynamic;
757       dir->ref_regular |= ind->ref_regular;
758       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
759       dir->needs_plt |= ind->needs_plt;
760       dir->pointer_equality_needed |= ind->pointer_equality_needed;
761     }
762   else
763     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
764 }
765
766 static bfd_boolean
767 elf64_x86_64_elf_object_p (bfd *abfd)
768 {
769   /* Set the right machine number for an x86-64 elf64 file.  */
770   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
771   return TRUE;
772 }
773
774 typedef union
775   {
776     unsigned char c[2];
777     uint16_t i;
778   }
779 x86_64_opcode16;
780
781 typedef union
782   {
783     unsigned char c[4];
784     uint32_t i;
785   }
786 x86_64_opcode32;
787
788 /* Return TRUE if the TLS access code sequence support transition
789    from R_TYPE.  */
790
791 static bfd_boolean
792 elf64_x86_64_check_tls_transition (bfd *abfd, asection *sec,
793                                    bfd_byte *contents,
794                                    Elf_Internal_Shdr *symtab_hdr,
795                                    struct elf_link_hash_entry **sym_hashes,
796                                    unsigned int r_type,
797                                    const Elf_Internal_Rela *rel,
798                                    const Elf_Internal_Rela *relend)
799 {
800   unsigned int val;
801   unsigned long r_symndx;
802   struct elf_link_hash_entry *h;
803   bfd_vma offset;
804
805   /* Get the section contents.  */
806   if (contents == NULL)
807     {
808       if (elf_section_data (sec)->this_hdr.contents != NULL)
809         contents = elf_section_data (sec)->this_hdr.contents;
810       else
811         {
812           /* FIXME: How to better handle error condition?  */
813           if (!bfd_malloc_and_get_section (abfd, sec, &contents))
814             return FALSE;
815
816           /* Cache the section contents for elf_link_input_bfd.  */
817           elf_section_data (sec)->this_hdr.contents = contents;
818         }
819     }
820
821   offset = rel->r_offset;
822   switch (r_type)
823     {
824     case R_X86_64_TLSGD:
825     case R_X86_64_TLSLD:
826       if ((rel + 1) >= relend)
827         return FALSE;
828
829       if (r_type == R_X86_64_TLSGD)
830         {
831           /* Check transition from GD access model.  Only
832                 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
833                 .word 0x6666; rex64; call __tls_get_addr
834              can transit to different access model.  */
835
836           static x86_64_opcode32 leaq = { { 0x66, 0x48, 0x8d, 0x3d } },
837                                  call = { { 0x66, 0x66, 0x48, 0xe8 } };
838           if (offset < 4
839               || (offset + 12) > sec->size
840               || bfd_get_32 (abfd, contents + offset - 4) != leaq.i
841               || bfd_get_32 (abfd, contents + offset + 4) != call.i)
842             return FALSE;
843         }
844       else
845         {
846           /* Check transition from LD access model.  Only
847                 leaq foo@tlsld(%rip), %rdi;
848                 call __tls_get_addr
849              can transit to different access model.  */
850
851           static x86_64_opcode32 ld = { { 0x48, 0x8d, 0x3d, 0xe8 } };
852           x86_64_opcode32 op;
853
854           if (offset < 3 || (offset + 9) > sec->size)
855             return FALSE;
856
857           op.i = bfd_get_32 (abfd, contents + offset - 3);
858           op.c[3] = bfd_get_8 (abfd, contents + offset + 4);
859           if (op.i != ld.i)
860             return FALSE;
861         }
862
863       r_symndx = ELF64_R_SYM (rel[1].r_info);
864       if (r_symndx < symtab_hdr->sh_info)
865         return FALSE;
866
867       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
868       /* Use strncmp to check __tls_get_addr since __tls_get_addr
869          may be versioned.  */ 
870       return (h != NULL
871               && h->root.root.string != NULL
872               && (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PC32
873                   || ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
874               && (strncmp (h->root.root.string,
875                            "__tls_get_addr", 14) == 0));
876
877     case R_X86_64_GOTTPOFF:
878       /* Check transition from IE access model:
879                 movq foo@gottpoff(%rip), %reg
880                 addq foo@gottpoff(%rip), %reg
881        */
882
883       if (offset < 3 || (offset + 4) > sec->size)
884         return FALSE;
885
886       val = bfd_get_8 (abfd, contents + offset - 3);
887       if (val != 0x48 && val != 0x4c)
888         return FALSE;
889
890       val = bfd_get_8 (abfd, contents + offset - 2);
891       if (val != 0x8b && val != 0x03)
892         return FALSE;
893
894       val = bfd_get_8 (abfd, contents + offset - 1);
895       return (val & 0xc7) == 5;
896
897     case R_X86_64_GOTPC32_TLSDESC:
898       /* Check transition from GDesc access model:
899                 leaq x@tlsdesc(%rip), %rax
900
901          Make sure it's a leaq adding rip to a 32-bit offset
902          into any register, although it's probably almost always
903          going to be rax.  */
904
905       if (offset < 3 || (offset + 4) > sec->size)
906         return FALSE;
907
908       val = bfd_get_8 (abfd, contents + offset - 3);
909       if ((val & 0xfb) != 0x48)
910         return FALSE;
911
912       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
913         return FALSE;
914
915       val = bfd_get_8 (abfd, contents + offset - 1);
916       return (val & 0xc7) == 0x05;
917
918     case R_X86_64_TLSDESC_CALL:
919       /* Check transition from GDesc access model:
920                 call *x@tlsdesc(%rax)
921        */
922       if (offset + 2 <= sec->size)
923         {
924           /* Make sure that it's a call *x@tlsdesc(%rax).  */
925           static x86_64_opcode16 call = { { 0xff, 0x10 } };
926           return bfd_get_16 (abfd, contents + offset) == call.i;
927         }
928
929       return FALSE;
930
931     default:
932       abort ();
933     }
934 }
935
936 /* Return TRUE if the TLS access transition is OK or no transition
937    will be performed.  Update R_TYPE if there is a transition.  */
938
939 static bfd_boolean
940 elf64_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
941                              asection *sec, bfd_byte *contents,
942                              Elf_Internal_Shdr *symtab_hdr,
943                              struct elf_link_hash_entry **sym_hashes,
944                              unsigned int *r_type, int tls_type,
945                              const Elf_Internal_Rela *rel,
946                              const Elf_Internal_Rela *relend,
947                              struct elf_link_hash_entry *h,
948                              unsigned long r_symndx)
949 {
950   unsigned int from_type = *r_type;
951   unsigned int to_type = from_type;
952   bfd_boolean check = TRUE;
953
954   /* Skip TLS transition for functions.  */
955   if (h != NULL
956       && (h->type == STT_FUNC
957           || h->type == STT_GNU_IFUNC))
958     return TRUE;
959
960   switch (from_type)
961     {
962     case R_X86_64_TLSGD:
963     case R_X86_64_GOTPC32_TLSDESC:
964     case R_X86_64_TLSDESC_CALL:
965     case R_X86_64_GOTTPOFF:
966       if (info->executable)
967         {
968           if (h == NULL)
969             to_type = R_X86_64_TPOFF32;
970           else
971             to_type = R_X86_64_GOTTPOFF;
972         }
973
974       /* When we are called from elf64_x86_64_relocate_section,
975          CONTENTS isn't NULL and there may be additional transitions
976          based on TLS_TYPE.  */
977       if (contents != NULL)
978         {
979           unsigned int new_to_type = to_type;
980
981           if (info->executable
982               && h != NULL
983               && h->dynindx == -1
984               && tls_type == GOT_TLS_IE)
985             new_to_type = R_X86_64_TPOFF32;
986
987           if (to_type == R_X86_64_TLSGD
988               || to_type == R_X86_64_GOTPC32_TLSDESC
989               || to_type == R_X86_64_TLSDESC_CALL)
990             {
991               if (tls_type == GOT_TLS_IE)
992                 new_to_type = R_X86_64_GOTTPOFF;
993             }
994
995           /* We checked the transition before when we were called from
996              elf64_x86_64_check_relocs.  We only want to check the new
997              transition which hasn't been checked before.  */
998           check = new_to_type != to_type && from_type == to_type;
999           to_type = new_to_type;
1000         }
1001
1002       break;
1003
1004     case R_X86_64_TLSLD:
1005       if (info->executable)
1006         to_type = R_X86_64_TPOFF32;
1007       break;
1008
1009     default:
1010       return TRUE;
1011     }
1012
1013   /* Return TRUE if there is no transition.  */
1014   if (from_type == to_type)
1015     return TRUE;
1016
1017   /* Check if the transition can be performed.  */
1018   if (check
1019       && ! elf64_x86_64_check_tls_transition (abfd, sec, contents,
1020                                               symtab_hdr, sym_hashes,
1021                                               from_type, rel, relend))
1022     {
1023       reloc_howto_type *from, *to;
1024       const char *name;
1025
1026       from = elf64_x86_64_rtype_to_howto (abfd, from_type);
1027       to = elf64_x86_64_rtype_to_howto (abfd, to_type);
1028
1029       if (h)
1030         name = h->root.root.string;
1031       else
1032         {
1033           struct elf64_x86_64_link_hash_table *htab;
1034
1035           htab = elf64_x86_64_hash_table (info);
1036           if (htab == NULL)
1037             name = "*unknown*";
1038           else
1039             {
1040               Elf_Internal_Sym *isym;
1041
1042               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1043                                             abfd, r_symndx);
1044               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1045             }
1046         }
1047
1048       (*_bfd_error_handler)
1049         (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1050            "in section `%A' failed"),
1051          abfd, sec, from->name, to->name, name,
1052          (unsigned long) rel->r_offset);
1053       bfd_set_error (bfd_error_bad_value);
1054       return FALSE;
1055     }
1056
1057   *r_type = to_type;
1058   return TRUE;
1059 }
1060
1061 /* Look through the relocs for a section during the first phase, and
1062    calculate needed space in the global offset table, procedure
1063    linkage table, and dynamic reloc sections.  */
1064
1065 static bfd_boolean
1066 elf64_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1067                            asection *sec,
1068                            const Elf_Internal_Rela *relocs)
1069 {
1070   struct elf64_x86_64_link_hash_table *htab;
1071   Elf_Internal_Shdr *symtab_hdr;
1072   struct elf_link_hash_entry **sym_hashes;
1073   const Elf_Internal_Rela *rel;
1074   const Elf_Internal_Rela *rel_end;
1075   asection *sreloc;
1076
1077   if (info->relocatable)
1078     return TRUE;
1079
1080   BFD_ASSERT (is_x86_64_elf (abfd));
1081
1082   htab = elf64_x86_64_hash_table (info);
1083   if (htab == NULL)
1084     return FALSE;
1085
1086   symtab_hdr = &elf_symtab_hdr (abfd);
1087   sym_hashes = elf_sym_hashes (abfd);
1088
1089   sreloc = NULL;
1090
1091   rel_end = relocs + sec->reloc_count;
1092   for (rel = relocs; rel < rel_end; rel++)
1093     {
1094       unsigned int r_type;
1095       unsigned long r_symndx;
1096       struct elf_link_hash_entry *h;
1097       Elf_Internal_Sym *isym;
1098       const char *name;
1099
1100       r_symndx = ELF64_R_SYM (rel->r_info);
1101       r_type = ELF64_R_TYPE (rel->r_info);
1102
1103       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1104         {
1105           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1106                                  abfd, r_symndx);
1107           return FALSE;
1108         }
1109
1110       if (r_symndx < symtab_hdr->sh_info)
1111         {
1112           /* A local symbol.  */
1113           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1114                                         abfd, r_symndx);
1115           if (isym == NULL)
1116             return FALSE;
1117
1118           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1119           if (ELF64_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1120             {
1121               h = elf64_x86_64_get_local_sym_hash (htab, abfd, rel,
1122                                                    TRUE);
1123               if (h == NULL)
1124                 return FALSE;
1125
1126               /* Fake a STT_GNU_IFUNC symbol.  */
1127               h->type = STT_GNU_IFUNC;
1128               h->def_regular = 1;
1129               h->ref_regular = 1;
1130               h->forced_local = 1;
1131               h->root.type = bfd_link_hash_defined;
1132             }
1133           else
1134             h = NULL;
1135         }
1136       else
1137         {
1138           isym = NULL;
1139           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1140           while (h->root.type == bfd_link_hash_indirect
1141                  || h->root.type == bfd_link_hash_warning)
1142             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1143         }
1144
1145       if (h != NULL)
1146         {
1147           /* Create the ifunc sections for static executables.  If we
1148              never see an indirect function symbol nor we are building
1149              a static executable, those sections will be empty and
1150              won't appear in output.  */
1151           switch (r_type)
1152             {
1153             default:
1154               break;
1155
1156             case R_X86_64_32S:
1157             case R_X86_64_32:
1158             case R_X86_64_64:
1159             case R_X86_64_PC32:
1160             case R_X86_64_PC64:
1161             case R_X86_64_PLT32:
1162             case R_X86_64_GOTPCREL:
1163             case R_X86_64_GOTPCREL64:
1164               if (!_bfd_elf_create_ifunc_sections (abfd, info))
1165                 return FALSE;
1166               break;
1167             }
1168
1169           /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1170              it here if it is defined in a non-shared object.  */
1171           if (h->type == STT_GNU_IFUNC
1172               && h->def_regular)
1173             {
1174               /* It is referenced by a non-shared object. */
1175               h->ref_regular = 1;
1176               h->needs_plt = 1;
1177
1178               /* STT_GNU_IFUNC symbol must go through PLT.  */
1179               h->plt.refcount += 1;
1180
1181               /* STT_GNU_IFUNC needs dynamic sections.  */
1182               if (htab->elf.dynobj == NULL)
1183                 htab->elf.dynobj = abfd;
1184
1185               switch (r_type)
1186                 {
1187                 default:
1188                   if (h->root.root.string)
1189                     name = h->root.root.string;
1190                   else
1191                     name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1192                                              NULL);
1193                   (*_bfd_error_handler)
1194                     (_("%B: relocation %s against STT_GNU_IFUNC "
1195                        "symbol `%s' isn't handled by %s"), abfd,
1196                      x86_64_elf_howto_table[r_type].name,
1197                      name, __FUNCTION__);
1198                   bfd_set_error (bfd_error_bad_value);
1199                   return FALSE;
1200
1201                 case R_X86_64_64:
1202                   h->non_got_ref = 1;
1203                   h->pointer_equality_needed = 1;
1204                   if (info->shared)
1205                     {
1206                       /* We must copy these reloc types into the output
1207                          file.  Create a reloc section in dynobj and
1208                          make room for this reloc.  */
1209                       sreloc = _bfd_elf_create_ifunc_dyn_reloc
1210                         (abfd, info, sec, sreloc,
1211                          &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs);
1212                       if (sreloc == NULL)
1213                         return FALSE;
1214                     }
1215                   break;
1216
1217                 case R_X86_64_32S:
1218                 case R_X86_64_32:
1219                 case R_X86_64_PC32:
1220                 case R_X86_64_PC64:
1221                   h->non_got_ref = 1;
1222                   if (r_type != R_X86_64_PC32
1223                       && r_type != R_X86_64_PC64)
1224                     h->pointer_equality_needed = 1;
1225                   break;
1226
1227                 case R_X86_64_PLT32:
1228                   break;
1229
1230                 case R_X86_64_GOTPCREL:
1231                 case R_X86_64_GOTPCREL64:
1232                   h->got.refcount += 1;
1233                   if (htab->elf.sgot == NULL
1234                       && !_bfd_elf_create_got_section (htab->elf.dynobj,
1235                                                        info))
1236                     return FALSE;
1237                   break;
1238                 }
1239
1240               continue;
1241             }
1242         }
1243
1244       if (! elf64_x86_64_tls_transition (info, abfd, sec, NULL,
1245                                          symtab_hdr, sym_hashes,
1246                                          &r_type, GOT_UNKNOWN,
1247                                          rel, rel_end, h, r_symndx))
1248         return FALSE;
1249
1250       switch (r_type)
1251         {
1252         case R_X86_64_TLSLD:
1253           htab->tls_ld_got.refcount += 1;
1254           goto create_got;
1255
1256         case R_X86_64_TPOFF32:
1257           if (!info->executable)
1258             {
1259               if (h)
1260                 name = h->root.root.string;
1261               else
1262                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1263                                          NULL);
1264               (*_bfd_error_handler)
1265                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1266                  abfd,
1267                  x86_64_elf_howto_table[r_type].name, name);
1268               bfd_set_error (bfd_error_bad_value);
1269               return FALSE;
1270             }
1271           break;
1272
1273         case R_X86_64_GOTTPOFF:
1274           if (!info->executable)
1275             info->flags |= DF_STATIC_TLS;
1276           /* Fall through */
1277
1278         case R_X86_64_GOT32:
1279         case R_X86_64_GOTPCREL:
1280         case R_X86_64_TLSGD:
1281         case R_X86_64_GOT64:
1282         case R_X86_64_GOTPCREL64:
1283         case R_X86_64_GOTPLT64:
1284         case R_X86_64_GOTPC32_TLSDESC:
1285         case R_X86_64_TLSDESC_CALL:
1286           /* This symbol requires a global offset table entry.  */
1287           {
1288             int tls_type, old_tls_type;
1289
1290             switch (r_type)
1291               {
1292               default: tls_type = GOT_NORMAL; break;
1293               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1294               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1295               case R_X86_64_GOTPC32_TLSDESC:
1296               case R_X86_64_TLSDESC_CALL:
1297                 tls_type = GOT_TLS_GDESC; break;
1298               }
1299
1300             if (h != NULL)
1301               {
1302                 if (r_type == R_X86_64_GOTPLT64)
1303                   {
1304                     /* This relocation indicates that we also need
1305                        a PLT entry, as this is a function.  We don't need
1306                        a PLT entry for local symbols.  */
1307                     h->needs_plt = 1;
1308                     h->plt.refcount += 1;
1309                   }
1310                 h->got.refcount += 1;
1311                 old_tls_type = elf64_x86_64_hash_entry (h)->tls_type;
1312               }
1313             else
1314               {
1315                 bfd_signed_vma *local_got_refcounts;
1316
1317                 /* This is a global offset table entry for a local symbol.  */
1318                 local_got_refcounts = elf_local_got_refcounts (abfd);
1319                 if (local_got_refcounts == NULL)
1320                   {
1321                     bfd_size_type size;
1322
1323                     size = symtab_hdr->sh_info;
1324                     size *= sizeof (bfd_signed_vma)
1325                       + sizeof (bfd_vma) + sizeof (char);
1326                     local_got_refcounts = ((bfd_signed_vma *)
1327                                            bfd_zalloc (abfd, size));
1328                     if (local_got_refcounts == NULL)
1329                       return FALSE;
1330                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1331                     elf64_x86_64_local_tlsdesc_gotent (abfd)
1332                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1333                     elf64_x86_64_local_got_tls_type (abfd)
1334                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1335                   }
1336                 local_got_refcounts[r_symndx] += 1;
1337                 old_tls_type
1338                   = elf64_x86_64_local_got_tls_type (abfd) [r_symndx];
1339               }
1340
1341             /* If a TLS symbol is accessed using IE at least once,
1342                there is no point to use dynamic model for it.  */
1343             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1344                 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1345                     || tls_type != GOT_TLS_IE))
1346               {
1347                 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1348                   tls_type = old_tls_type;
1349                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1350                          && GOT_TLS_GD_ANY_P (tls_type))
1351                   tls_type |= old_tls_type;
1352                 else
1353                   {
1354                     if (h)
1355                       name = h->root.root.string;
1356                     else
1357                       name = bfd_elf_sym_name (abfd, symtab_hdr,
1358                                                isym, NULL);
1359                     (*_bfd_error_handler)
1360                       (_("%B: '%s' accessed both as normal and thread local symbol"),
1361                        abfd, name);
1362                     return FALSE;
1363                   }
1364               }
1365
1366             if (old_tls_type != tls_type)
1367               {
1368                 if (h != NULL)
1369                   elf64_x86_64_hash_entry (h)->tls_type = tls_type;
1370                 else
1371                   elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1372               }
1373           }
1374           /* Fall through */
1375
1376         case R_X86_64_GOTOFF64:
1377         case R_X86_64_GOTPC32:
1378         case R_X86_64_GOTPC64:
1379         create_got:
1380           if (htab->elf.sgot == NULL)
1381             {
1382               if (htab->elf.dynobj == NULL)
1383                 htab->elf.dynobj = abfd;
1384               if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1385                                                 info))
1386                 return FALSE;
1387             }
1388           break;
1389
1390         case R_X86_64_PLT32:
1391           /* This symbol requires a procedure linkage table entry.  We
1392              actually build the entry in adjust_dynamic_symbol,
1393              because this might be a case of linking PIC code which is
1394              never referenced by a dynamic object, in which case we
1395              don't need to generate a procedure linkage table entry
1396              after all.  */
1397
1398           /* If this is a local symbol, we resolve it directly without
1399              creating a procedure linkage table entry.  */
1400           if (h == NULL)
1401             continue;
1402
1403           h->needs_plt = 1;
1404           h->plt.refcount += 1;
1405           break;
1406
1407         case R_X86_64_PLTOFF64:
1408           /* This tries to form the 'address' of a function relative
1409              to GOT.  For global symbols we need a PLT entry.  */
1410           if (h != NULL)
1411             {
1412               h->needs_plt = 1;
1413               h->plt.refcount += 1;
1414             }
1415           goto create_got;
1416
1417         case R_X86_64_8:
1418         case R_X86_64_16:
1419         case R_X86_64_32:
1420         case R_X86_64_32S:
1421           /* Let's help debug shared library creation.  These relocs
1422              cannot be used in shared libs.  Don't error out for
1423              sections we don't care about, such as debug sections or
1424              non-constant sections.  */
1425           if (info->shared
1426               && (sec->flags & SEC_ALLOC) != 0
1427               && (sec->flags & SEC_READONLY) != 0)
1428             {
1429               if (h)
1430                 name = h->root.root.string;
1431               else
1432                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1433               (*_bfd_error_handler)
1434                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1435                  abfd, x86_64_elf_howto_table[r_type].name, name);
1436               bfd_set_error (bfd_error_bad_value);
1437               return FALSE;
1438             }
1439           /* Fall through.  */
1440
1441         case R_X86_64_PC8:
1442         case R_X86_64_PC16:
1443         case R_X86_64_PC32:
1444         case R_X86_64_PC64:
1445         case R_X86_64_64:
1446           if (h != NULL && info->executable)
1447             {
1448               /* If this reloc is in a read-only section, we might
1449                  need a copy reloc.  We can't check reliably at this
1450                  stage whether the section is read-only, as input
1451                  sections have not yet been mapped to output sections.
1452                  Tentatively set the flag for now, and correct in
1453                  adjust_dynamic_symbol.  */
1454               h->non_got_ref = 1;
1455
1456               /* We may need a .plt entry if the function this reloc
1457                  refers to is in a shared lib.  */
1458               h->plt.refcount += 1;
1459               if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1460                 h->pointer_equality_needed = 1;
1461             }
1462
1463           /* If we are creating a shared library, and this is a reloc
1464              against a global symbol, or a non PC relative reloc
1465              against a local symbol, then we need to copy the reloc
1466              into the shared library.  However, if we are linking with
1467              -Bsymbolic, we do not need to copy a reloc against a
1468              global symbol which is defined in an object we are
1469              including in the link (i.e., DEF_REGULAR is set).  At
1470              this point we have not seen all the input files, so it is
1471              possible that DEF_REGULAR is not set now but will be set
1472              later (it is never cleared).  In case of a weak definition,
1473              DEF_REGULAR may be cleared later by a strong definition in
1474              a shared library.  We account for that possibility below by
1475              storing information in the relocs_copied field of the hash
1476              table entry.  A similar situation occurs when creating
1477              shared libraries and symbol visibility changes render the
1478              symbol local.
1479
1480              If on the other hand, we are creating an executable, we
1481              may need to keep relocations for symbols satisfied by a
1482              dynamic library if we manage to avoid copy relocs for the
1483              symbol.  */
1484           if ((info->shared
1485                && (sec->flags & SEC_ALLOC) != 0
1486                && (! IS_X86_64_PCREL_TYPE (r_type)
1487                    || (h != NULL
1488                        && (! SYMBOLIC_BIND (info, h)
1489                            || h->root.type == bfd_link_hash_defweak
1490                            || !h->def_regular))))
1491               || (ELIMINATE_COPY_RELOCS
1492                   && !info->shared
1493                   && (sec->flags & SEC_ALLOC) != 0
1494                   && h != NULL
1495                   && (h->root.type == bfd_link_hash_defweak
1496                       || !h->def_regular)))
1497             {
1498               struct elf_dyn_relocs *p;
1499               struct elf_dyn_relocs **head;
1500
1501               /* We must copy these reloc types into the output file.
1502                  Create a reloc section in dynobj and make room for
1503                  this reloc.  */
1504               if (sreloc == NULL)
1505                 {
1506                   if (htab->elf.dynobj == NULL)
1507                     htab->elf.dynobj = abfd;
1508
1509                   sreloc = _bfd_elf_make_dynamic_reloc_section
1510                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
1511
1512                   if (sreloc == NULL)
1513                     return FALSE;
1514                 }
1515
1516               /* If this is a global symbol, we count the number of
1517                  relocations we need for this symbol.  */
1518               if (h != NULL)
1519                 {
1520                   head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
1521                 }
1522               else
1523                 {
1524                   /* Track dynamic relocs needed for local syms too.
1525                      We really need local syms available to do this
1526                      easily.  Oh well.  */
1527                   asection *s;
1528                   void **vpp;
1529
1530                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1531                                                 abfd, r_symndx);
1532                   if (isym == NULL)
1533                     return FALSE;
1534
1535                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1536                   if (s == NULL)
1537                     s = sec;
1538
1539                   /* Beware of type punned pointers vs strict aliasing
1540                      rules.  */
1541                   vpp = &(elf_section_data (s)->local_dynrel);
1542                   head = (struct elf_dyn_relocs **)vpp;
1543                 }
1544
1545               p = *head;
1546               if (p == NULL || p->sec != sec)
1547                 {
1548                   bfd_size_type amt = sizeof *p;
1549
1550                   p = ((struct elf_dyn_relocs *)
1551                        bfd_alloc (htab->elf.dynobj, amt));
1552                   if (p == NULL)
1553                     return FALSE;
1554                   p->next = *head;
1555                   *head = p;
1556                   p->sec = sec;
1557                   p->count = 0;
1558                   p->pc_count = 0;
1559                 }
1560
1561               p->count += 1;
1562               if (IS_X86_64_PCREL_TYPE (r_type))
1563                 p->pc_count += 1;
1564             }
1565           break;
1566
1567           /* This relocation describes the C++ object vtable hierarchy.
1568              Reconstruct it for later use during GC.  */
1569         case R_X86_64_GNU_VTINHERIT:
1570           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1571             return FALSE;
1572           break;
1573
1574           /* This relocation describes which C++ vtable entries are actually
1575              used.  Record for later use during GC.  */
1576         case R_X86_64_GNU_VTENTRY:
1577           BFD_ASSERT (h != NULL);
1578           if (h != NULL
1579               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1580             return FALSE;
1581           break;
1582
1583         default:
1584           break;
1585         }
1586     }
1587
1588   return TRUE;
1589 }
1590
1591 /* Return the section that should be marked against GC for a given
1592    relocation.  */
1593
1594 static asection *
1595 elf64_x86_64_gc_mark_hook (asection *sec,
1596                            struct bfd_link_info *info,
1597                            Elf_Internal_Rela *rel,
1598                            struct elf_link_hash_entry *h,
1599                            Elf_Internal_Sym *sym)
1600 {
1601   if (h != NULL)
1602     switch (ELF64_R_TYPE (rel->r_info))
1603       {
1604       case R_X86_64_GNU_VTINHERIT:
1605       case R_X86_64_GNU_VTENTRY:
1606         return NULL;
1607       }
1608
1609   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1610 }
1611
1612 /* Update the got entry reference counts for the section being removed.  */
1613
1614 static bfd_boolean
1615 elf64_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1616                             asection *sec,
1617                             const Elf_Internal_Rela *relocs)
1618 {
1619   struct elf64_x86_64_link_hash_table *htab;
1620   Elf_Internal_Shdr *symtab_hdr;
1621   struct elf_link_hash_entry **sym_hashes;
1622   bfd_signed_vma *local_got_refcounts;
1623   const Elf_Internal_Rela *rel, *relend;
1624
1625   if (info->relocatable)
1626     return TRUE;
1627
1628   htab = elf64_x86_64_hash_table (info);
1629   if (htab == NULL)
1630     return FALSE;
1631
1632   elf_section_data (sec)->local_dynrel = NULL;
1633
1634   symtab_hdr = &elf_symtab_hdr (abfd);
1635   sym_hashes = elf_sym_hashes (abfd);
1636   local_got_refcounts = elf_local_got_refcounts (abfd);
1637
1638   relend = relocs + sec->reloc_count;
1639   for (rel = relocs; rel < relend; rel++)
1640     {
1641       unsigned long r_symndx;
1642       unsigned int r_type;
1643       struct elf_link_hash_entry *h = NULL;
1644
1645       r_symndx = ELF64_R_SYM (rel->r_info);
1646       if (r_symndx >= symtab_hdr->sh_info)
1647         {
1648           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1649           while (h->root.type == bfd_link_hash_indirect
1650                  || h->root.type == bfd_link_hash_warning)
1651             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1652         }
1653       else
1654         {
1655           /* A local symbol.  */
1656           Elf_Internal_Sym *isym;
1657
1658           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1659                                         abfd, r_symndx);
1660
1661           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1662           if (isym != NULL
1663               && ELF64_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1664             {
1665               h = elf64_x86_64_get_local_sym_hash (htab, abfd, rel,
1666                                                    FALSE);
1667               if (h == NULL)
1668                 abort ();
1669             }
1670         }
1671
1672       if (h)
1673         {
1674           struct elf64_x86_64_link_hash_entry *eh;
1675           struct elf_dyn_relocs **pp;
1676           struct elf_dyn_relocs *p;
1677
1678           eh = (struct elf64_x86_64_link_hash_entry *) h;
1679
1680           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1681             if (p->sec == sec)
1682               {
1683                 /* Everything must go for SEC.  */
1684                 *pp = p->next;
1685                 break;
1686               }
1687         }
1688
1689       r_type = ELF32_R_TYPE (rel->r_info);
1690       if (! elf64_x86_64_tls_transition (info, abfd, sec, NULL,
1691                                          symtab_hdr, sym_hashes,
1692                                          &r_type, GOT_UNKNOWN,
1693                                          rel, relend, h, r_symndx))
1694         return FALSE;
1695
1696       switch (r_type)
1697         {
1698         case R_X86_64_TLSLD:
1699           if (htab->tls_ld_got.refcount > 0)
1700             htab->tls_ld_got.refcount -= 1;
1701           break;
1702
1703         case R_X86_64_TLSGD:
1704         case R_X86_64_GOTPC32_TLSDESC:
1705         case R_X86_64_TLSDESC_CALL:
1706         case R_X86_64_GOTTPOFF:
1707         case R_X86_64_GOT32:
1708         case R_X86_64_GOTPCREL:
1709         case R_X86_64_GOT64:
1710         case R_X86_64_GOTPCREL64:
1711         case R_X86_64_GOTPLT64:
1712           if (h != NULL)
1713             {
1714               if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
1715                 h->plt.refcount -= 1;
1716               if (h->got.refcount > 0)
1717                 h->got.refcount -= 1;
1718               if (h->type == STT_GNU_IFUNC)
1719                 {
1720                   if (h->plt.refcount > 0)
1721                     h->plt.refcount -= 1;
1722                 }
1723             }
1724           else if (local_got_refcounts != NULL)
1725             {
1726               if (local_got_refcounts[r_symndx] > 0)
1727                 local_got_refcounts[r_symndx] -= 1;
1728             }
1729           break;
1730
1731         case R_X86_64_8:
1732         case R_X86_64_16:
1733         case R_X86_64_32:
1734         case R_X86_64_64:
1735         case R_X86_64_32S:
1736         case R_X86_64_PC8:
1737         case R_X86_64_PC16:
1738         case R_X86_64_PC32:
1739         case R_X86_64_PC64:
1740           if (info->shared
1741               && (h == NULL || h->type != STT_GNU_IFUNC))
1742             break;
1743           /* Fall thru */
1744
1745         case R_X86_64_PLT32:
1746         case R_X86_64_PLTOFF64:
1747           if (h != NULL)
1748             {
1749               if (h->plt.refcount > 0)
1750                 h->plt.refcount -= 1;
1751             }
1752           break;
1753
1754         default:
1755           break;
1756         }
1757     }
1758
1759   return TRUE;
1760 }
1761
1762 /* Adjust a symbol defined by a dynamic object and referenced by a
1763    regular object.  The current definition is in some section of the
1764    dynamic object, but we're not including those sections.  We have to
1765    change the definition to something the rest of the link can
1766    understand.  */
1767
1768 static bfd_boolean
1769 elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
1770                                     struct elf_link_hash_entry *h)
1771 {
1772   struct elf64_x86_64_link_hash_table *htab;
1773   asection *s;
1774
1775   /* STT_GNU_IFUNC symbol must go through PLT. */
1776   if (h->type == STT_GNU_IFUNC)
1777     {
1778       if (h->plt.refcount <= 0)
1779         {
1780           h->plt.offset = (bfd_vma) -1;
1781           h->needs_plt = 0;
1782         }
1783       return TRUE;
1784     }
1785
1786   /* If this is a function, put it in the procedure linkage table.  We
1787      will fill in the contents of the procedure linkage table later,
1788      when we know the address of the .got section.  */
1789   if (h->type == STT_FUNC
1790       || h->needs_plt)
1791     {
1792       if (h->plt.refcount <= 0
1793           || SYMBOL_CALLS_LOCAL (info, h)
1794           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1795               && h->root.type == bfd_link_hash_undefweak))
1796         {
1797           /* This case can occur if we saw a PLT32 reloc in an input
1798              file, but the symbol was never referred to by a dynamic
1799              object, or if all references were garbage collected.  In
1800              such a case, we don't actually need to build a procedure
1801              linkage table, and we can just do a PC32 reloc instead.  */
1802           h->plt.offset = (bfd_vma) -1;
1803           h->needs_plt = 0;
1804         }
1805
1806       return TRUE;
1807     }
1808   else
1809     /* It's possible that we incorrectly decided a .plt reloc was
1810        needed for an R_X86_64_PC32 reloc to a non-function sym in
1811        check_relocs.  We can't decide accurately between function and
1812        non-function syms in check-relocs;  Objects loaded later in
1813        the link may change h->type.  So fix it now.  */
1814     h->plt.offset = (bfd_vma) -1;
1815
1816   /* If this is a weak symbol, and there is a real definition, the
1817      processor independent code will have arranged for us to see the
1818      real definition first, and we can just use the same value.  */
1819   if (h->u.weakdef != NULL)
1820     {
1821       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1822                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1823       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1824       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1825       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1826         h->non_got_ref = h->u.weakdef->non_got_ref;
1827       return TRUE;
1828     }
1829
1830   /* This is a reference to a symbol defined by a dynamic object which
1831      is not a function.  */
1832
1833   /* If we are creating a shared library, we must presume that the
1834      only references to the symbol are via the global offset table.
1835      For such cases we need not do anything here; the relocations will
1836      be handled correctly by relocate_section.  */
1837   if (info->shared)
1838     return TRUE;
1839
1840   /* If there are no references to this symbol that do not use the
1841      GOT, we don't need to generate a copy reloc.  */
1842   if (!h->non_got_ref)
1843     return TRUE;
1844
1845   /* If -z nocopyreloc was given, we won't generate them either.  */
1846   if (info->nocopyreloc)
1847     {
1848       h->non_got_ref = 0;
1849       return TRUE;
1850     }
1851
1852   if (ELIMINATE_COPY_RELOCS)
1853     {
1854       struct elf64_x86_64_link_hash_entry * eh;
1855       struct elf_dyn_relocs *p;
1856
1857       eh = (struct elf64_x86_64_link_hash_entry *) h;
1858       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1859         {
1860           s = p->sec->output_section;
1861           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1862             break;
1863         }
1864
1865       /* If we didn't find any dynamic relocs in read-only sections, then
1866          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1867       if (p == NULL)
1868         {
1869           h->non_got_ref = 0;
1870           return TRUE;
1871         }
1872     }
1873
1874   if (h->size == 0)
1875     {
1876       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1877                              h->root.root.string);
1878       return TRUE;
1879     }
1880
1881   /* We must allocate the symbol in our .dynbss section, which will
1882      become part of the .bss section of the executable.  There will be
1883      an entry for this symbol in the .dynsym section.  The dynamic
1884      object will contain position independent code, so all references
1885      from the dynamic object to this symbol will go through the global
1886      offset table.  The dynamic linker will use the .dynsym entry to
1887      determine the address it must put in the global offset table, so
1888      both the dynamic object and the regular object will refer to the
1889      same memory location for the variable.  */
1890
1891   htab = elf64_x86_64_hash_table (info);
1892   if (htab == NULL)
1893     return FALSE;
1894
1895   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1896      to copy the initial value out of the dynamic object and into the
1897      runtime process image.  */
1898   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1899     {
1900       htab->srelbss->size += sizeof (Elf64_External_Rela);
1901       h->needs_copy = 1;
1902     }
1903
1904   s = htab->sdynbss;
1905
1906   return _bfd_elf_adjust_dynamic_copy (h, s);
1907 }
1908
1909 /* Allocate space in .plt, .got and associated reloc sections for
1910    dynamic relocs.  */
1911
1912 static bfd_boolean
1913 elf64_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1914 {
1915   struct bfd_link_info *info;
1916   struct elf64_x86_64_link_hash_table *htab;
1917   struct elf64_x86_64_link_hash_entry *eh;
1918   struct elf_dyn_relocs *p;
1919
1920   if (h->root.type == bfd_link_hash_indirect)
1921     return TRUE;
1922
1923   if (h->root.type == bfd_link_hash_warning)
1924     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1925   eh = (struct elf64_x86_64_link_hash_entry *) h;
1926
1927   info = (struct bfd_link_info *) inf;
1928   htab = elf64_x86_64_hash_table (info);
1929   if (htab == NULL)
1930     return FALSE;
1931
1932   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1933      here if it is defined and referenced in a non-shared object.  */
1934   if (h->type == STT_GNU_IFUNC
1935       && h->def_regular)
1936     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
1937                                                &eh->dyn_relocs,
1938                                                PLT_ENTRY_SIZE,
1939                                                GOT_ENTRY_SIZE);
1940   else if (htab->elf.dynamic_sections_created
1941            && h->plt.refcount > 0)
1942     {
1943       /* Make sure this symbol is output as a dynamic symbol.
1944          Undefined weak syms won't yet be marked as dynamic.  */
1945       if (h->dynindx == -1
1946           && !h->forced_local)
1947         {
1948           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1949             return FALSE;
1950         }
1951
1952       if (info->shared
1953           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1954         {
1955           asection *s = htab->elf.splt;
1956
1957           /* If this is the first .plt entry, make room for the special
1958              first entry.  */
1959           if (s->size == 0)
1960             s->size += PLT_ENTRY_SIZE;
1961
1962           h->plt.offset = s->size;
1963
1964           /* If this symbol is not defined in a regular file, and we are
1965              not generating a shared library, then set the symbol to this
1966              location in the .plt.  This is required to make function
1967              pointers compare as equal between the normal executable and
1968              the shared library.  */
1969           if (! info->shared
1970               && !h->def_regular)
1971             {
1972               h->root.u.def.section = s;
1973               h->root.u.def.value = h->plt.offset;
1974             }
1975
1976           /* Make room for this entry.  */
1977           s->size += PLT_ENTRY_SIZE;
1978
1979           /* We also need to make an entry in the .got.plt section, which
1980              will be placed in the .got section by the linker script.  */
1981           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1982
1983           /* We also need to make an entry in the .rela.plt section.  */
1984           htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
1985           htab->elf.srelplt->reloc_count++;
1986         }
1987       else
1988         {
1989           h->plt.offset = (bfd_vma) -1;
1990           h->needs_plt = 0;
1991         }
1992     }
1993   else
1994     {
1995       h->plt.offset = (bfd_vma) -1;
1996       h->needs_plt = 0;
1997     }
1998
1999   eh->tlsdesc_got = (bfd_vma) -1;
2000
2001   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2002      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
2003   if (h->got.refcount > 0
2004       && info->executable
2005       && h->dynindx == -1
2006       && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2007     {
2008       h->got.offset = (bfd_vma) -1;
2009     }
2010   else if (h->got.refcount > 0)
2011     {
2012       asection *s;
2013       bfd_boolean dyn;
2014       int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
2015
2016       /* Make sure this symbol is output as a dynamic symbol.
2017          Undefined weak syms won't yet be marked as dynamic.  */
2018       if (h->dynindx == -1
2019           && !h->forced_local)
2020         {
2021           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2022             return FALSE;
2023         }
2024
2025       if (GOT_TLS_GDESC_P (tls_type))
2026         {
2027           eh->tlsdesc_got = htab->elf.sgotplt->size
2028             - elf64_x86_64_compute_jump_table_size (htab);
2029           htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2030           h->got.offset = (bfd_vma) -2;
2031         }
2032       if (! GOT_TLS_GDESC_P (tls_type)
2033           || GOT_TLS_GD_P (tls_type))
2034         {
2035           s = htab->elf.sgot;
2036           h->got.offset = s->size;
2037           s->size += GOT_ENTRY_SIZE;
2038           if (GOT_TLS_GD_P (tls_type))
2039             s->size += GOT_ENTRY_SIZE;
2040         }
2041       dyn = htab->elf.dynamic_sections_created;
2042       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2043          and two if global.
2044          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
2045       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2046           || tls_type == GOT_TLS_IE)
2047         htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2048       else if (GOT_TLS_GD_P (tls_type))
2049         htab->elf.srelgot->size += 2 * sizeof (Elf64_External_Rela);
2050       else if (! GOT_TLS_GDESC_P (tls_type)
2051                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2052                    || h->root.type != bfd_link_hash_undefweak)
2053                && (info->shared
2054                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2055         htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2056       if (GOT_TLS_GDESC_P (tls_type))
2057         {
2058           htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
2059           htab->tlsdesc_plt = (bfd_vma) -1;
2060         }
2061     }
2062   else
2063     h->got.offset = (bfd_vma) -1;
2064
2065   if (eh->dyn_relocs == NULL)
2066     return TRUE;
2067
2068   /* In the shared -Bsymbolic case, discard space allocated for
2069      dynamic pc-relative relocs against symbols which turn out to be
2070      defined in regular objects.  For the normal shared case, discard
2071      space for pc-relative relocs that have become local due to symbol
2072      visibility changes.  */
2073
2074   if (info->shared)
2075     {
2076       /* Relocs that use pc_count are those that appear on a call
2077          insn, or certain REL relocs that can generated via assembly.
2078          We want calls to protected symbols to resolve directly to the
2079          function rather than going via the plt.  If people want
2080          function pointer comparisons to work as expected then they
2081          should avoid writing weird assembly.  */
2082       if (SYMBOL_CALLS_LOCAL (info, h))
2083         {
2084           struct elf_dyn_relocs **pp;
2085
2086           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2087             {
2088               p->count -= p->pc_count;
2089               p->pc_count = 0;
2090               if (p->count == 0)
2091                 *pp = p->next;
2092               else
2093                 pp = &p->next;
2094             }
2095         }
2096
2097       /* Also discard relocs on undefined weak syms with non-default
2098          visibility.  */
2099       if (eh->dyn_relocs != NULL
2100           && h->root.type == bfd_link_hash_undefweak)
2101         {
2102           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2103             eh->dyn_relocs = NULL;
2104
2105           /* Make sure undefined weak symbols are output as a dynamic
2106              symbol in PIEs.  */
2107           else if (h->dynindx == -1
2108                    && ! h->forced_local
2109                    && ! bfd_elf_link_record_dynamic_symbol (info, h))
2110             return FALSE;
2111         }
2112
2113     }
2114   else if (ELIMINATE_COPY_RELOCS)
2115     {
2116       /* For the non-shared case, discard space for relocs against
2117          symbols which turn out to need copy relocs or are not
2118          dynamic.  */
2119
2120       if (!h->non_got_ref
2121           && ((h->def_dynamic
2122                && !h->def_regular)
2123               || (htab->elf.dynamic_sections_created
2124                   && (h->root.type == bfd_link_hash_undefweak
2125                       || h->root.type == bfd_link_hash_undefined))))
2126         {
2127           /* Make sure this symbol is output as a dynamic symbol.
2128              Undefined weak syms won't yet be marked as dynamic.  */
2129           if (h->dynindx == -1
2130               && ! h->forced_local
2131               && ! bfd_elf_link_record_dynamic_symbol (info, h))
2132             return FALSE;
2133
2134           /* If that succeeded, we know we'll be keeping all the
2135              relocs.  */
2136           if (h->dynindx != -1)
2137             goto keep;
2138         }
2139
2140       eh->dyn_relocs = NULL;
2141
2142     keep: ;
2143     }
2144
2145   /* Finally, allocate space.  */
2146   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2147     {
2148       asection * sreloc;
2149
2150       sreloc = elf_section_data (p->sec)->sreloc;
2151
2152       BFD_ASSERT (sreloc != NULL);
2153
2154       sreloc->size += p->count * sizeof (Elf64_External_Rela);
2155     }
2156
2157   return TRUE;
2158 }
2159
2160 /* Allocate space in .plt, .got and associated reloc sections for
2161    local dynamic relocs.  */
2162
2163 static bfd_boolean
2164 elf64_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2165 {
2166   struct elf_link_hash_entry *h
2167     = (struct elf_link_hash_entry *) *slot;
2168
2169   if (h->type != STT_GNU_IFUNC
2170       || !h->def_regular
2171       || !h->ref_regular
2172       || !h->forced_local
2173       || h->root.type != bfd_link_hash_defined)
2174     abort ();
2175
2176   return elf64_x86_64_allocate_dynrelocs (h, inf);
2177 }
2178
2179 /* Find any dynamic relocs that apply to read-only sections.  */
2180
2181 static bfd_boolean
2182 elf64_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2183 {
2184   struct elf64_x86_64_link_hash_entry *eh;
2185   struct elf_dyn_relocs *p;
2186
2187   if (h->root.type == bfd_link_hash_warning)
2188     h = (struct elf_link_hash_entry *) h->root.u.i.link;
2189
2190   eh = (struct elf64_x86_64_link_hash_entry *) h;
2191   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2192     {
2193       asection *s = p->sec->output_section;
2194
2195       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2196         {
2197           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2198
2199           info->flags |= DF_TEXTREL;
2200
2201           /* Not an error, just cut short the traversal.  */
2202           return FALSE;
2203         }
2204     }
2205   return TRUE;
2206 }
2207
2208 /* Set the sizes of the dynamic sections.  */
2209
2210 static bfd_boolean
2211 elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2212                                     struct bfd_link_info *info)
2213 {
2214   struct elf64_x86_64_link_hash_table *htab;
2215   bfd *dynobj;
2216   asection *s;
2217   bfd_boolean relocs;
2218   bfd *ibfd;
2219
2220   htab = elf64_x86_64_hash_table (info);
2221   if (htab == NULL)
2222     return FALSE;
2223
2224   dynobj = htab->elf.dynobj;
2225   if (dynobj == NULL)
2226     abort ();
2227
2228   if (htab->elf.dynamic_sections_created)
2229     {
2230       /* Set the contents of the .interp section to the interpreter.  */
2231       if (info->executable)
2232         {
2233           s = bfd_get_section_by_name (dynobj, ".interp");
2234           if (s == NULL)
2235             abort ();
2236           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2237           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2238         }
2239     }
2240
2241   /* Set up .got offsets for local syms, and space for local dynamic
2242      relocs.  */
2243   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2244     {
2245       bfd_signed_vma *local_got;
2246       bfd_signed_vma *end_local_got;
2247       char *local_tls_type;
2248       bfd_vma *local_tlsdesc_gotent;
2249       bfd_size_type locsymcount;
2250       Elf_Internal_Shdr *symtab_hdr;
2251       asection *srel;
2252
2253       if (! is_x86_64_elf (ibfd))
2254         continue;
2255
2256       for (s = ibfd->sections; s != NULL; s = s->next)
2257         {
2258           struct elf_dyn_relocs *p;
2259
2260           for (p = (struct elf_dyn_relocs *)
2261                     (elf_section_data (s)->local_dynrel);
2262                p != NULL;
2263                p = p->next)
2264             {
2265               if (!bfd_is_abs_section (p->sec)
2266                   && bfd_is_abs_section (p->sec->output_section))
2267                 {
2268                   /* Input section has been discarded, either because
2269                      it is a copy of a linkonce section or due to
2270                      linker script /DISCARD/, so we'll be discarding
2271                      the relocs too.  */
2272                 }
2273               else if (p->count != 0)
2274                 {
2275                   srel = elf_section_data (p->sec)->sreloc;
2276                   srel->size += p->count * sizeof (Elf64_External_Rela);
2277                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2278                     info->flags |= DF_TEXTREL;
2279                 }
2280             }
2281         }
2282
2283       local_got = elf_local_got_refcounts (ibfd);
2284       if (!local_got)
2285         continue;
2286
2287       symtab_hdr = &elf_symtab_hdr (ibfd);
2288       locsymcount = symtab_hdr->sh_info;
2289       end_local_got = local_got + locsymcount;
2290       local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
2291       local_tlsdesc_gotent = elf64_x86_64_local_tlsdesc_gotent (ibfd);
2292       s = htab->elf.sgot;
2293       srel = htab->elf.srelgot;
2294       for (; local_got < end_local_got;
2295            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2296         {
2297           *local_tlsdesc_gotent = (bfd_vma) -1;
2298           if (*local_got > 0)
2299             {
2300               if (GOT_TLS_GDESC_P (*local_tls_type))
2301                 {
2302                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2303                     - elf64_x86_64_compute_jump_table_size (htab);
2304                   htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2305                   *local_got = (bfd_vma) -2;
2306                 }
2307               if (! GOT_TLS_GDESC_P (*local_tls_type)
2308                   || GOT_TLS_GD_P (*local_tls_type))
2309                 {
2310                   *local_got = s->size;
2311                   s->size += GOT_ENTRY_SIZE;
2312                   if (GOT_TLS_GD_P (*local_tls_type))
2313                     s->size += GOT_ENTRY_SIZE;
2314                 }
2315               if (info->shared
2316                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2317                   || *local_tls_type == GOT_TLS_IE)
2318                 {
2319                   if (GOT_TLS_GDESC_P (*local_tls_type))
2320                     {
2321                       htab->elf.srelplt->size
2322                         += sizeof (Elf64_External_Rela);
2323                       htab->tlsdesc_plt = (bfd_vma) -1;
2324                     }
2325                   if (! GOT_TLS_GDESC_P (*local_tls_type)
2326                       || GOT_TLS_GD_P (*local_tls_type))
2327                     srel->size += sizeof (Elf64_External_Rela);
2328                 }
2329             }
2330           else
2331             *local_got = (bfd_vma) -1;
2332         }
2333     }
2334
2335   if (htab->tls_ld_got.refcount > 0)
2336     {
2337       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2338          relocs.  */
2339       htab->tls_ld_got.offset = htab->elf.sgot->size;
2340       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2341       htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2342     }
2343   else
2344     htab->tls_ld_got.offset = -1;
2345
2346   /* Allocate global sym .plt and .got entries, and space for global
2347      sym dynamic relocs.  */
2348   elf_link_hash_traverse (&htab->elf, elf64_x86_64_allocate_dynrelocs,
2349                           info);
2350
2351   /* Allocate .plt and .got entries, and space for local symbols.  */
2352   htab_traverse (htab->loc_hash_table,
2353                  elf64_x86_64_allocate_local_dynrelocs,
2354                  info);
2355
2356   /* For every jump slot reserved in the sgotplt, reloc_count is
2357      incremented.  However, when we reserve space for TLS descriptors,
2358      it's not incremented, so in order to compute the space reserved
2359      for them, it suffices to multiply the reloc count by the jump
2360      slot size.  */
2361   if (htab->elf.srelplt)
2362     htab->sgotplt_jump_table_size
2363       = elf64_x86_64_compute_jump_table_size (htab);
2364
2365   if (htab->tlsdesc_plt)
2366     {
2367       /* If we're not using lazy TLS relocations, don't generate the
2368          PLT and GOT entries they require.  */
2369       if ((info->flags & DF_BIND_NOW))
2370         htab->tlsdesc_plt = 0;
2371       else
2372         {
2373           htab->tlsdesc_got = htab->elf.sgot->size;
2374           htab->elf.sgot->size += GOT_ENTRY_SIZE;
2375           /* Reserve room for the initial entry.
2376              FIXME: we could probably do away with it in this case.  */
2377           if (htab->elf.splt->size == 0)
2378             htab->elf.splt->size += PLT_ENTRY_SIZE;
2379           htab->tlsdesc_plt = htab->elf.splt->size;
2380           htab->elf.splt->size += PLT_ENTRY_SIZE;
2381         }
2382     }
2383
2384   if (htab->elf.sgotplt)
2385     {
2386       struct elf_link_hash_entry *got;
2387       got = elf_link_hash_lookup (elf_hash_table (info),
2388                                   "_GLOBAL_OFFSET_TABLE_",
2389                                   FALSE, FALSE, FALSE);
2390
2391       /* Don't allocate .got.plt section if there are no GOT nor PLT
2392          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
2393       if ((got == NULL
2394            || !got->ref_regular_nonweak)
2395           && (htab->elf.sgotplt->size
2396               == get_elf_backend_data (output_bfd)->got_header_size)
2397           && (htab->elf.splt == NULL
2398               || htab->elf.splt->size == 0)
2399           && (htab->elf.sgot == NULL
2400               || htab->elf.sgot->size == 0)
2401           && (htab->elf.iplt == NULL
2402               || htab->elf.iplt->size == 0)
2403           && (htab->elf.igotplt == NULL
2404               || htab->elf.igotplt->size == 0))
2405         htab->elf.sgotplt->size = 0;
2406     }
2407
2408   /* We now have determined the sizes of the various dynamic sections.
2409      Allocate memory for them.  */
2410   relocs = FALSE;
2411   for (s = dynobj->sections; s != NULL; s = s->next)
2412     {
2413       if ((s->flags & SEC_LINKER_CREATED) == 0)
2414         continue;
2415
2416       if (s == htab->elf.splt
2417           || s == htab->elf.sgot
2418           || s == htab->elf.sgotplt
2419           || s == htab->elf.iplt
2420           || s == htab->elf.igotplt
2421           || s == htab->sdynbss)
2422         {
2423           /* Strip this section if we don't need it; see the
2424              comment below.  */
2425         }
2426       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2427         {
2428           if (s->size != 0 && s != htab->elf.srelplt)
2429             relocs = TRUE;
2430
2431           /* We use the reloc_count field as a counter if we need
2432              to copy relocs into the output file.  */
2433           if (s != htab->elf.srelplt)
2434             s->reloc_count = 0;
2435         }
2436       else
2437         {
2438           /* It's not one of our sections, so don't allocate space.  */
2439           continue;
2440         }
2441
2442       if (s->size == 0)
2443         {
2444           /* If we don't need this section, strip it from the
2445              output file.  This is mostly to handle .rela.bss and
2446              .rela.plt.  We must create both sections in
2447              create_dynamic_sections, because they must be created
2448              before the linker maps input sections to output
2449              sections.  The linker does that before
2450              adjust_dynamic_symbol is called, and it is that
2451              function which decides whether anything needs to go
2452              into these sections.  */
2453
2454           s->flags |= SEC_EXCLUDE;
2455           continue;
2456         }
2457
2458       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2459         continue;
2460
2461       /* Allocate memory for the section contents.  We use bfd_zalloc
2462          here in case unused entries are not reclaimed before the
2463          section's contents are written out.  This should not happen,
2464          but this way if it does, we get a R_X86_64_NONE reloc instead
2465          of garbage.  */
2466       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2467       if (s->contents == NULL)
2468         return FALSE;
2469     }
2470
2471   if (htab->elf.dynamic_sections_created)
2472     {
2473       /* Add some entries to the .dynamic section.  We fill in the
2474          values later, in elf64_x86_64_finish_dynamic_sections, but we
2475          must add the entries now so that we get the correct size for
2476          the .dynamic section.  The DT_DEBUG entry is filled in by the
2477          dynamic linker and used by the debugger.  */
2478 #define add_dynamic_entry(TAG, VAL) \
2479   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2480
2481       if (info->executable)
2482         {
2483           if (!add_dynamic_entry (DT_DEBUG, 0))
2484             return FALSE;
2485         }
2486
2487       if (htab->elf.splt->size != 0)
2488         {
2489           if (!add_dynamic_entry (DT_PLTGOT, 0)
2490               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2491               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2492               || !add_dynamic_entry (DT_JMPREL, 0))
2493             return FALSE;
2494
2495           if (htab->tlsdesc_plt
2496               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2497                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2498             return FALSE;
2499         }
2500
2501       if (relocs)
2502         {
2503           if (!add_dynamic_entry (DT_RELA, 0)
2504               || !add_dynamic_entry (DT_RELASZ, 0)
2505               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2506             return FALSE;
2507
2508           /* If any dynamic relocs apply to a read-only section,
2509              then we need a DT_TEXTREL entry.  */
2510           if ((info->flags & DF_TEXTREL) == 0)
2511             elf_link_hash_traverse (&htab->elf, 
2512                                     elf64_x86_64_readonly_dynrelocs,
2513                                     info);
2514
2515           if ((info->flags & DF_TEXTREL) != 0)
2516             {
2517               if (!add_dynamic_entry (DT_TEXTREL, 0))
2518                 return FALSE;
2519             }
2520         }
2521     }
2522 #undef add_dynamic_entry
2523
2524   return TRUE;
2525 }
2526
2527 static bfd_boolean
2528 elf64_x86_64_always_size_sections (bfd *output_bfd,
2529                                    struct bfd_link_info *info)
2530 {
2531   asection *tls_sec = elf_hash_table (info)->tls_sec;
2532
2533   if (tls_sec)
2534     {
2535       struct elf_link_hash_entry *tlsbase;
2536
2537       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2538                                       "_TLS_MODULE_BASE_",
2539                                       FALSE, FALSE, FALSE);
2540
2541       if (tlsbase && tlsbase->type == STT_TLS)
2542         {
2543           struct elf64_x86_64_link_hash_table *htab;
2544           struct bfd_link_hash_entry *bh = NULL;
2545           const struct elf_backend_data *bed
2546             = get_elf_backend_data (output_bfd);
2547
2548           htab = elf64_x86_64_hash_table (info);
2549           if (htab == NULL)
2550             return FALSE;
2551
2552           if (!(_bfd_generic_link_add_one_symbol
2553                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2554                  tls_sec, 0, NULL, FALSE,
2555                  bed->collect, &bh)))
2556             return FALSE;
2557
2558           htab->tls_module_base = bh;
2559
2560           tlsbase = (struct elf_link_hash_entry *)bh;
2561           tlsbase->def_regular = 1;
2562           tlsbase->other = STV_HIDDEN;
2563           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2564         }
2565     }
2566
2567   return TRUE;
2568 }
2569
2570 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2571    executables.  Rather than setting it to the beginning of the TLS
2572    section, we have to set it to the end.  This function may be called
2573    multiple times, it is idempotent.  */
2574
2575 static void
2576 elf64_x86_64_set_tls_module_base (struct bfd_link_info *info)
2577 {
2578   struct elf64_x86_64_link_hash_table *htab;
2579   struct bfd_link_hash_entry *base;
2580
2581   if (!info->executable)
2582     return;
2583
2584   htab = elf64_x86_64_hash_table (info);
2585   if (htab == NULL)
2586     return;
2587
2588   base = htab->tls_module_base;
2589   if (base == NULL)
2590     return;
2591
2592   base->u.def.value = htab->elf.tls_size;
2593 }
2594
2595 /* Return the base VMA address which should be subtracted from real addresses
2596    when resolving @dtpoff relocation.
2597    This is PT_TLS segment p_vaddr.  */
2598
2599 static bfd_vma
2600 elf64_x86_64_dtpoff_base (struct bfd_link_info *info)
2601 {
2602   /* If tls_sec is NULL, we should have signalled an error already.  */
2603   if (elf_hash_table (info)->tls_sec == NULL)
2604     return 0;
2605   return elf_hash_table (info)->tls_sec->vma;
2606 }
2607
2608 /* Return the relocation value for @tpoff relocation
2609    if STT_TLS virtual address is ADDRESS.  */
2610
2611 static bfd_vma
2612 elf64_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2613 {
2614   struct elf_link_hash_table *htab = elf_hash_table (info);
2615   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2616   bfd_vma static_tls_size;
2617
2618   /* If tls_segment is NULL, we should have signalled an error already.  */
2619   if (htab->tls_sec == NULL)
2620     return 0;
2621
2622   /* Consider special static TLS alignment requirements.  */
2623   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2624   return address - static_tls_size - htab->tls_sec->vma;
2625 }
2626
2627 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2628    branch?  */
2629
2630 static bfd_boolean
2631 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2632 {
2633   /* Opcode             Instruction
2634      0xe8               call
2635      0xe9               jump
2636      0x0f 0x8x          conditional jump */
2637   return ((offset > 0
2638            && (contents [offset - 1] == 0xe8
2639                || contents [offset - 1] == 0xe9))
2640           || (offset > 1
2641               && contents [offset - 2] == 0x0f
2642               && (contents [offset - 1] & 0xf0) == 0x80));
2643 }
2644
2645 static void
2646 elf64_x86_64_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
2647 {
2648   bfd_byte *loc = s->contents;
2649   loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2650   BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
2651               <= s->contents + s->size);
2652   bfd_elf64_swap_reloca_out (abfd, rel, loc);
2653 }
2654
2655 /* Relocate an x86_64 ELF section.  */
2656
2657 static bfd_boolean
2658 elf64_x86_64_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2659                                bfd *input_bfd, asection *input_section,
2660                                bfd_byte *contents, Elf_Internal_Rela *relocs,
2661                                Elf_Internal_Sym *local_syms,
2662                                asection **local_sections)
2663 {
2664   struct elf64_x86_64_link_hash_table *htab;
2665   Elf_Internal_Shdr *symtab_hdr;
2666   struct elf_link_hash_entry **sym_hashes;
2667   bfd_vma *local_got_offsets;
2668   bfd_vma *local_tlsdesc_gotents;
2669   Elf_Internal_Rela *rel;
2670   Elf_Internal_Rela *relend;
2671
2672   BFD_ASSERT (is_x86_64_elf (input_bfd));
2673
2674   htab = elf64_x86_64_hash_table (info);
2675   if (htab == NULL)
2676     return FALSE;
2677   symtab_hdr = &elf_symtab_hdr (input_bfd);
2678   sym_hashes = elf_sym_hashes (input_bfd);
2679   local_got_offsets = elf_local_got_offsets (input_bfd);
2680   local_tlsdesc_gotents = elf64_x86_64_local_tlsdesc_gotent (input_bfd);
2681
2682   elf64_x86_64_set_tls_module_base (info);
2683
2684   rel = relocs;
2685   relend = relocs + input_section->reloc_count;
2686   for (; rel < relend; rel++)
2687     {
2688       unsigned int r_type;
2689       reloc_howto_type *howto;
2690       unsigned long r_symndx;
2691       struct elf_link_hash_entry *h;
2692       Elf_Internal_Sym *sym;
2693       asection *sec;
2694       bfd_vma off, offplt;
2695       bfd_vma relocation;
2696       bfd_boolean unresolved_reloc;
2697       bfd_reloc_status_type r;
2698       int tls_type;
2699       asection *base_got;
2700
2701       r_type = ELF64_R_TYPE (rel->r_info);
2702       if (r_type == (int) R_X86_64_GNU_VTINHERIT
2703           || r_type == (int) R_X86_64_GNU_VTENTRY)
2704         continue;
2705
2706       if (r_type >= R_X86_64_max)
2707         {
2708           bfd_set_error (bfd_error_bad_value);
2709           return FALSE;
2710         }
2711
2712       howto = x86_64_elf_howto_table + r_type;
2713       r_symndx = ELF64_R_SYM (rel->r_info);
2714       h = NULL;
2715       sym = NULL;
2716       sec = NULL;
2717       unresolved_reloc = FALSE;
2718       if (r_symndx < symtab_hdr->sh_info)
2719         {
2720           sym = local_syms + r_symndx;
2721           sec = local_sections[r_symndx];
2722
2723           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
2724                                                 &sec, rel);
2725
2726           /* Relocate against local STT_GNU_IFUNC symbol.  */
2727           if (!info->relocatable
2728               && ELF64_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2729             {
2730               h = elf64_x86_64_get_local_sym_hash (htab, input_bfd,
2731                                                    rel, FALSE);
2732               if (h == NULL)
2733                 abort ();
2734
2735               /* Set STT_GNU_IFUNC symbol value.  */ 
2736               h->root.u.def.value = sym->st_value;
2737               h->root.u.def.section = sec;
2738             }
2739         }
2740       else
2741         {
2742           bfd_boolean warned ATTRIBUTE_UNUSED;
2743
2744           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2745                                    r_symndx, symtab_hdr, sym_hashes,
2746                                    h, sec, relocation,
2747                                    unresolved_reloc, warned);
2748         }
2749
2750       if (sec != NULL && elf_discarded_section (sec))
2751         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2752                                          rel, relend, howto, contents);
2753
2754       if (info->relocatable)
2755         continue;
2756
2757       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2758          it here if it is defined in a non-shared object.  */
2759       if (h != NULL
2760           && h->type == STT_GNU_IFUNC
2761           && h->def_regular)
2762         {
2763           asection *plt;
2764           bfd_vma plt_index;
2765           const char *name;
2766
2767           if ((input_section->flags & SEC_ALLOC) == 0
2768               || h->plt.offset == (bfd_vma) -1)
2769             abort ();
2770
2771           /* STT_GNU_IFUNC symbol must go through PLT.  */
2772           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
2773           relocation = (plt->output_section->vma
2774                         + plt->output_offset + h->plt.offset);
2775
2776           switch (r_type)
2777             {
2778             default:
2779               if (h->root.root.string)
2780                 name = h->root.root.string;
2781               else
2782                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2783                                          NULL);
2784               (*_bfd_error_handler)
2785                 (_("%B: relocation %s against STT_GNU_IFUNC "
2786                    "symbol `%s' isn't handled by %s"), input_bfd,
2787                  x86_64_elf_howto_table[r_type].name,
2788                  name, __FUNCTION__);
2789               bfd_set_error (bfd_error_bad_value);
2790               return FALSE;
2791
2792             case R_X86_64_32S:
2793               if (info->shared)
2794                 abort ();
2795               goto do_relocation;
2796
2797             case R_X86_64_64: 
2798               if (rel->r_addend != 0)
2799                 {
2800                   if (h->root.root.string)
2801                     name = h->root.root.string;
2802                   else
2803                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
2804                                              sym, NULL);
2805                   (*_bfd_error_handler)
2806                     (_("%B: relocation %s against STT_GNU_IFUNC "
2807                        "symbol `%s' has non-zero addend: %d"),
2808                      input_bfd, x86_64_elf_howto_table[r_type].name,
2809                      name, rel->r_addend);
2810                   bfd_set_error (bfd_error_bad_value);
2811                   return FALSE;
2812                 }
2813
2814               /* Generate dynamic relcoation only when there is a
2815                  non-GOF reference in a shared object.  */
2816               if (info->shared && h->non_got_ref)
2817                 {
2818                   Elf_Internal_Rela outrel;
2819                   asection *sreloc;
2820
2821                   /* Need a dynamic relocation to get the real function
2822                      address.  */
2823                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2824                                                              info,
2825                                                              input_section,
2826                                                              rel->r_offset);
2827                   if (outrel.r_offset == (bfd_vma) -1
2828                       || outrel.r_offset == (bfd_vma) -2)
2829                     abort ();
2830
2831                   outrel.r_offset += (input_section->output_section->vma
2832                                       + input_section->output_offset);
2833
2834                   if (h->dynindx == -1
2835                       || h->forced_local
2836                       || info->executable)
2837                     {
2838                       /* This symbol is resolved locally.  */
2839                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_IRELATIVE);
2840                       outrel.r_addend = (h->root.u.def.value
2841                                          + h->root.u.def.section->output_section->vma
2842                                          + h->root.u.def.section->output_offset);
2843                     }
2844                   else
2845                     {
2846                       outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2847                       outrel.r_addend = 0;
2848                     }
2849
2850                   sreloc = htab->elf.irelifunc;
2851                   elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
2852
2853                   /* If this reloc is against an external symbol, we
2854                      do not want to fiddle with the addend.  Otherwise,
2855                      we need to include the symbol value so that it
2856                      becomes an addend for the dynamic reloc.  For an
2857                      internal symbol, we have updated addend.  */
2858                   continue;
2859                 }
2860
2861             case R_X86_64_32:
2862             case R_X86_64_PC32:
2863             case R_X86_64_PC64:
2864             case R_X86_64_PLT32:
2865               goto do_relocation;
2866
2867             case R_X86_64_GOTPCREL:
2868             case R_X86_64_GOTPCREL64:
2869               base_got = htab->elf.sgot;
2870               off = h->got.offset;
2871
2872               if (base_got == NULL)
2873                 abort ();
2874
2875               if (off == (bfd_vma) -1)
2876                 {
2877                   /* We can't use h->got.offset here to save state, or
2878                      even just remember the offset, as finish_dynamic_symbol
2879                      would use that as offset into .got.  */
2880
2881                   if (htab->elf.splt != NULL)
2882                     {
2883                       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2884                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
2885                       base_got = htab->elf.sgotplt;
2886                     }
2887                   else
2888                     {
2889                       plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2890                       off = plt_index * GOT_ENTRY_SIZE;
2891                       base_got = htab->elf.igotplt;
2892                     }
2893
2894                   if (h->dynindx == -1
2895                       || h->forced_local
2896                       || info->symbolic)
2897                     {
2898                       /* This references the local defitionion.  We must 
2899                          initialize this entry in the global offset table.
2900                          Since the offset must always be a multiple of 8, 
2901                          we use the least significant bit to record
2902                          whether we have initialized it already.
2903
2904                          When doing a dynamic link, we create a .rela.got
2905                          relocation entry to initialize the value.  This
2906                          is done in the finish_dynamic_symbol routine.   */
2907                       if ((off & 1) != 0)
2908                         off &= ~1;
2909                       else
2910                         {
2911                           bfd_put_64 (output_bfd, relocation,
2912                                       base_got->contents + off);
2913                           /* Note that this is harmless for the GOTPLT64
2914                              case, as -1 | 1 still is -1.  */
2915                           h->got.offset |= 1;
2916                         }
2917                     }
2918                 }
2919
2920               relocation = (base_got->output_section->vma
2921                             + base_got->output_offset + off);
2922
2923               if (r_type != R_X86_64_GOTPCREL
2924                   && r_type != R_X86_64_GOTPCREL64)
2925                 {
2926                   asection *gotplt;
2927                   if (htab->elf.splt != NULL)
2928                     gotplt = htab->elf.sgotplt;
2929                   else
2930                     gotplt = htab->elf.igotplt;
2931                   relocation -= (gotplt->output_section->vma
2932                                  - gotplt->output_offset);
2933                 }
2934
2935               goto do_relocation;
2936             }
2937         }
2938
2939       /* When generating a shared object, the relocations handled here are
2940          copied into the output file to be resolved at run time.  */
2941       switch (r_type)
2942         {
2943         case R_X86_64_GOT32:
2944         case R_X86_64_GOT64:
2945           /* Relocation is to the entry for this symbol in the global
2946              offset table.  */
2947         case R_X86_64_GOTPCREL:
2948         case R_X86_64_GOTPCREL64:
2949           /* Use global offset table entry as symbol value.  */
2950         case R_X86_64_GOTPLT64:
2951           /* This is the same as GOT64 for relocation purposes, but
2952              indicates the existence of a PLT entry.  The difficulty is,
2953              that we must calculate the GOT slot offset from the PLT
2954              offset, if this symbol got a PLT entry (it was global).
2955              Additionally if it's computed from the PLT entry, then that
2956              GOT offset is relative to .got.plt, not to .got.  */
2957           base_got = htab->elf.sgot;
2958
2959           if (htab->elf.sgot == NULL)
2960             abort ();
2961
2962           if (h != NULL)
2963             {
2964               bfd_boolean dyn;
2965
2966               off = h->got.offset;
2967               if (h->needs_plt
2968                   && h->plt.offset != (bfd_vma)-1
2969                   && off == (bfd_vma)-1)
2970                 {
2971                   /* We can't use h->got.offset here to save
2972                      state, or even just remember the offset, as
2973                      finish_dynamic_symbol would use that as offset into
2974                      .got.  */
2975                   bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2976                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
2977                   base_got = htab->elf.sgotplt;
2978                 }
2979
2980               dyn = htab->elf.dynamic_sections_created;
2981
2982               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2983                   || (info->shared
2984                       && SYMBOL_REFERENCES_LOCAL (info, h))
2985                   || (ELF_ST_VISIBILITY (h->other)
2986                       && h->root.type == bfd_link_hash_undefweak))
2987                 {
2988                   /* This is actually a static link, or it is a -Bsymbolic
2989                      link and the symbol is defined locally, or the symbol
2990                      was forced to be local because of a version file.  We
2991                      must initialize this entry in the global offset table.
2992                      Since the offset must always be a multiple of 8, we
2993                      use the least significant bit to record whether we
2994                      have initialized it already.
2995
2996                      When doing a dynamic link, we create a .rela.got
2997                      relocation entry to initialize the value.  This is
2998                      done in the finish_dynamic_symbol routine.  */
2999                   if ((off & 1) != 0)
3000                     off &= ~1;
3001                   else
3002                     {
3003                       bfd_put_64 (output_bfd, relocation,
3004                                   base_got->contents + off);
3005                       /* Note that this is harmless for the GOTPLT64 case,
3006                          as -1 | 1 still is -1.  */
3007                       h->got.offset |= 1;
3008                     }
3009                 }
3010               else
3011                 unresolved_reloc = FALSE;
3012             }
3013           else
3014             {
3015               if (local_got_offsets == NULL)
3016                 abort ();
3017
3018               off = local_got_offsets[r_symndx];
3019
3020               /* The offset must always be a multiple of 8.  We use
3021                  the least significant bit to record whether we have
3022                  already generated the necessary reloc.  */
3023               if ((off & 1) != 0)
3024                 off &= ~1;
3025               else
3026                 {
3027                   bfd_put_64 (output_bfd, relocation,
3028                               base_got->contents + off);
3029
3030                   if (info->shared)
3031                     {
3032                       asection *s;
3033                       Elf_Internal_Rela outrel;
3034
3035                       /* We need to generate a R_X86_64_RELATIVE reloc
3036                          for the dynamic linker.  */
3037                       s = htab->elf.srelgot;
3038                       if (s == NULL)
3039                         abort ();
3040
3041                       outrel.r_offset = (base_got->output_section->vma
3042                                          + base_got->output_offset
3043                                          + off);
3044                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
3045                       outrel.r_addend = relocation;
3046                       elf64_x86_64_append_rela (output_bfd, s, &outrel);
3047                     }
3048
3049                   local_got_offsets[r_symndx] |= 1;
3050                 }
3051             }
3052
3053           if (off >= (bfd_vma) -2)
3054             abort ();
3055
3056           relocation = base_got->output_section->vma
3057                        + base_got->output_offset + off;
3058           if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3059             relocation -= htab->elf.sgotplt->output_section->vma
3060                           - htab->elf.sgotplt->output_offset;
3061
3062           break;
3063
3064         case R_X86_64_GOTOFF64:
3065           /* Relocation is relative to the start of the global offset
3066              table.  */
3067
3068           /* Check to make sure it isn't a protected function symbol
3069              for shared library since it may not be local when used
3070              as function address.  */
3071           if (info->shared
3072               && h
3073               && h->def_regular
3074               && h->type == STT_FUNC
3075               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3076             {
3077               (*_bfd_error_handler)
3078                 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3079                  input_bfd, h->root.root.string);
3080               bfd_set_error (bfd_error_bad_value);
3081               return FALSE;
3082             }
3083
3084           /* Note that sgot is not involved in this
3085              calculation.  We always want the start of .got.plt.  If we
3086              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3087              permitted by the ABI, we might have to change this
3088              calculation.  */
3089           relocation -= htab->elf.sgotplt->output_section->vma
3090                         + htab->elf.sgotplt->output_offset;
3091           break;
3092
3093         case R_X86_64_GOTPC32:
3094         case R_X86_64_GOTPC64:
3095           /* Use global offset table as symbol value.  */
3096           relocation = htab->elf.sgotplt->output_section->vma
3097                        + htab->elf.sgotplt->output_offset;
3098           unresolved_reloc = FALSE;
3099           break;
3100
3101         case R_X86_64_PLTOFF64:
3102           /* Relocation is PLT entry relative to GOT.  For local
3103              symbols it's the symbol itself relative to GOT.  */
3104           if (h != NULL
3105               /* See PLT32 handling.  */
3106               && h->plt.offset != (bfd_vma) -1
3107               && htab->elf.splt != NULL)
3108             {
3109               relocation = (htab->elf.splt->output_section->vma
3110                             + htab->elf.splt->output_offset
3111                             + h->plt.offset);
3112               unresolved_reloc = FALSE;
3113             }
3114
3115           relocation -= htab->elf.sgotplt->output_section->vma
3116                         + htab->elf.sgotplt->output_offset;
3117           break;
3118
3119         case R_X86_64_PLT32:
3120           /* Relocation is to the entry for this symbol in the
3121              procedure linkage table.  */
3122
3123           /* Resolve a PLT32 reloc against a local symbol directly,
3124              without using the procedure linkage table.  */
3125           if (h == NULL)
3126             break;
3127
3128           if (h->plt.offset == (bfd_vma) -1
3129               || htab->elf.splt == NULL)
3130             {
3131               /* We didn't make a PLT entry for this symbol.  This
3132                  happens when statically linking PIC code, or when
3133                  using -Bsymbolic.  */
3134               break;
3135             }
3136
3137           relocation = (htab->elf.splt->output_section->vma
3138                         + htab->elf.splt->output_offset
3139                         + h->plt.offset);
3140           unresolved_reloc = FALSE;
3141           break;
3142
3143         case R_X86_64_PC8:
3144         case R_X86_64_PC16:
3145         case R_X86_64_PC32:
3146           if (info->shared
3147               && (input_section->flags & SEC_ALLOC) != 0
3148               && (input_section->flags & SEC_READONLY) != 0
3149               && h != NULL)
3150             {
3151               bfd_boolean fail = FALSE;
3152               bfd_boolean branch
3153                 = (r_type == R_X86_64_PC32
3154                    && is_32bit_relative_branch (contents, rel->r_offset));
3155
3156               if (SYMBOL_REFERENCES_LOCAL (info, h))
3157                 {
3158                   /* Symbol is referenced locally.  Make sure it is
3159                      defined locally or for a branch.  */
3160                   fail = !h->def_regular && !branch;
3161                 }
3162               else
3163                 {
3164                   /* Symbol isn't referenced locally.  We only allow
3165                      branch to symbol with non-default visibility. */
3166                   fail = (!branch
3167                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3168                 }
3169
3170               if (fail)
3171                 {
3172                   const char *fmt;
3173                   const char *v;
3174                   const char *pic = "";
3175
3176                   switch (ELF_ST_VISIBILITY (h->other))
3177                     {
3178                     case STV_HIDDEN:
3179                       v = _("hidden symbol");
3180                       break;
3181                     case STV_INTERNAL:
3182                       v = _("internal symbol");
3183                       break;
3184                     case STV_PROTECTED:
3185                       v = _("protected symbol");
3186                       break;
3187                     default:
3188                       v = _("symbol");
3189                       pic = _("; recompile with -fPIC");
3190                       break;
3191                     }
3192
3193                   if (h->def_regular)
3194                     fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3195                   else
3196                     fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3197
3198                   (*_bfd_error_handler) (fmt, input_bfd,
3199                                          x86_64_elf_howto_table[r_type].name,
3200                                          v,  h->root.root.string, pic);
3201                   bfd_set_error (bfd_error_bad_value);
3202                   return FALSE;
3203                 }
3204             }
3205           /* Fall through.  */
3206
3207         case R_X86_64_8:
3208         case R_X86_64_16:
3209         case R_X86_64_32:
3210         case R_X86_64_PC64:
3211         case R_X86_64_64:
3212           /* FIXME: The ABI says the linker should make sure the value is
3213              the same when it's zeroextended to 64 bit.  */
3214
3215           if ((input_section->flags & SEC_ALLOC) == 0)
3216             break;
3217
3218           if ((info->shared
3219                && (h == NULL
3220                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3221                    || h->root.type != bfd_link_hash_undefweak)
3222                && (! IS_X86_64_PCREL_TYPE (r_type)
3223                    || ! SYMBOL_CALLS_LOCAL (info, h)))
3224               || (ELIMINATE_COPY_RELOCS
3225                   && !info->shared
3226                   && h != NULL
3227                   && h->dynindx != -1
3228                   && !h->non_got_ref
3229                   && ((h->def_dynamic
3230                        && !h->def_regular)
3231                       || h->root.type == bfd_link_hash_undefweak
3232                       || h->root.type == bfd_link_hash_undefined)))
3233             {
3234               Elf_Internal_Rela outrel;
3235               bfd_boolean skip, relocate;
3236               asection *sreloc;
3237
3238               /* When generating a shared object, these relocations
3239                  are copied into the output file to be resolved at run
3240                  time.  */
3241               skip = FALSE;
3242               relocate = FALSE;
3243
3244               outrel.r_offset =
3245                 _bfd_elf_section_offset (output_bfd, info, input_section,
3246                                          rel->r_offset);
3247               if (outrel.r_offset == (bfd_vma) -1)
3248                 skip = TRUE;
3249               else if (outrel.r_offset == (bfd_vma) -2)
3250                 skip = TRUE, relocate = TRUE;
3251
3252               outrel.r_offset += (input_section->output_section->vma
3253                                   + input_section->output_offset);
3254
3255               if (skip)
3256                 memset (&outrel, 0, sizeof outrel);
3257
3258               /* h->dynindx may be -1 if this symbol was marked to
3259                  become local.  */
3260               else if (h != NULL
3261                        && h->dynindx != -1
3262                        && (IS_X86_64_PCREL_TYPE (r_type)
3263                            || ! info->shared
3264                            || ! SYMBOLIC_BIND (info, h)
3265                            || ! h->def_regular))
3266                 {
3267                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
3268                   outrel.r_addend = rel->r_addend;
3269                 }
3270               else
3271                 {
3272                   /* This symbol is local, or marked to become local.  */
3273                   if (r_type == R_X86_64_64)
3274                     {
3275                       relocate = TRUE;
3276                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
3277                       outrel.r_addend = relocation + rel->r_addend;
3278                     }
3279                   else
3280                     {
3281                       long sindx;
3282
3283                       if (bfd_is_abs_section (sec))
3284                         sindx = 0;
3285                       else if (sec == NULL || sec->owner == NULL)
3286                         {
3287                           bfd_set_error (bfd_error_bad_value);
3288                           return FALSE;
3289                         }
3290                       else
3291                         {
3292                           asection *osec;
3293
3294                           /* We are turning this relocation into one
3295                              against a section symbol.  It would be
3296                              proper to subtract the symbol's value,
3297                              osec->vma, from the emitted reloc addend,
3298                              but ld.so expects buggy relocs.  */
3299                           osec = sec->output_section;
3300                           sindx = elf_section_data (osec)->dynindx;
3301                           if (sindx == 0)
3302                             {
3303                               asection *oi = htab->elf.text_index_section;
3304                               sindx = elf_section_data (oi)->dynindx;
3305                             }
3306                           BFD_ASSERT (sindx != 0);
3307                         }
3308
3309                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
3310                       outrel.r_addend = relocation + rel->r_addend;
3311                     }
3312                 }
3313
3314               sreloc = elf_section_data (input_section)->sreloc;
3315
3316               BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
3317
3318               elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
3319
3320               /* If this reloc is against an external symbol, we do
3321                  not want to fiddle with the addend.  Otherwise, we
3322                  need to include the symbol value so that it becomes
3323                  an addend for the dynamic reloc.  */
3324               if (! relocate)
3325                 continue;
3326             }
3327
3328           break;
3329
3330         case R_X86_64_TLSGD:
3331         case R_X86_64_GOTPC32_TLSDESC:
3332         case R_X86_64_TLSDESC_CALL:
3333         case R_X86_64_GOTTPOFF:
3334           tls_type = GOT_UNKNOWN;
3335           if (h == NULL && local_got_offsets)
3336             tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3337           else if (h != NULL)
3338             tls_type = elf64_x86_64_hash_entry (h)->tls_type;
3339
3340           if (! elf64_x86_64_tls_transition (info, input_bfd,
3341                                              input_section, contents,
3342                                              symtab_hdr, sym_hashes,
3343                                              &r_type, tls_type, rel,
3344                                              relend, h, r_symndx))
3345             return FALSE;
3346
3347           if (r_type == R_X86_64_TPOFF32)
3348             {
3349               bfd_vma roff = rel->r_offset;
3350
3351               BFD_ASSERT (! unresolved_reloc);
3352
3353               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3354                 {
3355                   /* GD->LE transition.
3356                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3357                      .word 0x6666; rex64; call __tls_get_addr
3358                      Change it into:
3359                      movq %fs:0, %rax
3360                      leaq foo@tpoff(%rax), %rax */
3361                   memcpy (contents + roff - 4,
3362                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3363                           16);
3364                   bfd_put_32 (output_bfd,
3365                               elf64_x86_64_tpoff (info, relocation),
3366                               contents + roff + 8);
3367                   /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3368                   rel++;
3369                   continue;
3370                 }
3371               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3372                 {
3373                   /* GDesc -> LE transition.
3374                      It's originally something like:
3375                      leaq x@tlsdesc(%rip), %rax
3376
3377                      Change it to:
3378                      movl $x@tpoff, %rax.  */
3379
3380                   unsigned int val, type;
3381
3382                   type = bfd_get_8 (input_bfd, contents + roff - 3);
3383                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3384                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3385                              contents + roff - 3);
3386                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3387                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3388                              contents + roff - 1);
3389                   bfd_put_32 (output_bfd,
3390                               elf64_x86_64_tpoff (info, relocation),
3391                               contents + roff);
3392                   continue;
3393                 }
3394               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3395                 {
3396                   /* GDesc -> LE transition.
3397                      It's originally:
3398                      call *(%rax)
3399                      Turn it into:
3400                      xchg %ax,%ax.  */
3401                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3402                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3403                   continue;
3404                 }
3405               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
3406                 {
3407                   /* IE->LE transition:
3408                      Originally it can be one of:
3409                      movq foo@gottpoff(%rip), %reg
3410                      addq foo@gottpoff(%rip), %reg
3411                      We change it into:
3412                      movq $foo, %reg
3413                      leaq foo(%reg), %reg
3414                      addq $foo, %reg.  */
3415
3416                   unsigned int val, type, reg;
3417
3418                   val = bfd_get_8 (input_bfd, contents + roff - 3);
3419                   type = bfd_get_8 (input_bfd, contents + roff - 2);
3420                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
3421                   reg >>= 3;
3422                   if (type == 0x8b)
3423                     {
3424                       /* movq */
3425                       if (val == 0x4c)
3426                         bfd_put_8 (output_bfd, 0x49,
3427                                    contents + roff - 3);
3428                       bfd_put_8 (output_bfd, 0xc7,
3429                                  contents + roff - 2);
3430                       bfd_put_8 (output_bfd, 0xc0 | reg,
3431                                  contents + roff - 1);
3432                     }
3433                   else if (reg == 4)
3434                     {
3435                       /* addq -> addq - addressing with %rsp/%r12 is
3436                          special  */
3437                       if (val == 0x4c)
3438                         bfd_put_8 (output_bfd, 0x49,
3439                                    contents + roff - 3);
3440                       bfd_put_8 (output_bfd, 0x81,
3441                                  contents + roff - 2);
3442                       bfd_put_8 (output_bfd, 0xc0 | reg,
3443                                  contents + roff - 1);
3444                     }
3445                   else
3446                     {
3447                       /* addq -> leaq */
3448                       if (val == 0x4c)
3449                         bfd_put_8 (output_bfd, 0x4d,
3450                                    contents + roff - 3);
3451                       bfd_put_8 (output_bfd, 0x8d,
3452                                  contents + roff - 2);
3453                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3454                                  contents + roff - 1);
3455                     }
3456                   bfd_put_32 (output_bfd,
3457                               elf64_x86_64_tpoff (info, relocation),
3458                               contents + roff);
3459                   continue;
3460                 }
3461               else
3462                 BFD_ASSERT (FALSE);
3463             }
3464
3465           if (htab->elf.sgot == NULL)
3466             abort ();
3467
3468           if (h != NULL)
3469             {
3470               off = h->got.offset;
3471               offplt = elf64_x86_64_hash_entry (h)->tlsdesc_got;
3472             }
3473           else
3474             {
3475               if (local_got_offsets == NULL)
3476                 abort ();
3477
3478               off = local_got_offsets[r_symndx];
3479               offplt = local_tlsdesc_gotents[r_symndx];
3480             }
3481
3482           if ((off & 1) != 0)
3483             off &= ~1;
3484           else
3485             {
3486               Elf_Internal_Rela outrel;
3487               int dr_type, indx;
3488               asection *sreloc;
3489
3490               if (htab->elf.srelgot == NULL)
3491                 abort ();
3492
3493               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3494
3495               if (GOT_TLS_GDESC_P (tls_type))
3496                 {
3497                   outrel.r_info = ELF64_R_INFO (indx, R_X86_64_TLSDESC);
3498                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3499                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3500                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3501                                      + htab->elf.sgotplt->output_offset
3502                                      + offplt
3503                                      + htab->sgotplt_jump_table_size);
3504                   sreloc = htab->elf.srelplt;
3505                   if (indx == 0)
3506                     outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
3507                   else
3508                     outrel.r_addend = 0;
3509                   elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
3510                 }
3511
3512               sreloc = htab->elf.srelgot;
3513
3514               outrel.r_offset = (htab->elf.sgot->output_section->vma
3515                                  + htab->elf.sgot->output_offset + off);
3516
3517               if (GOT_TLS_GD_P (tls_type))
3518                 dr_type = R_X86_64_DTPMOD64;
3519               else if (GOT_TLS_GDESC_P (tls_type))
3520                 goto dr_done;
3521               else
3522                 dr_type = R_X86_64_TPOFF64;
3523
3524               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3525               outrel.r_addend = 0;
3526               if ((dr_type == R_X86_64_TPOFF64
3527                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
3528                 outrel.r_addend = relocation - elf64_x86_64_dtpoff_base (info);
3529               outrel.r_info = ELF64_R_INFO (indx, dr_type);
3530
3531               elf64_x86_64_append_rela (output_bfd, sreloc, &outrel);
3532
3533               if (GOT_TLS_GD_P (tls_type))
3534                 {
3535                   if (indx == 0)
3536                     {
3537                       BFD_ASSERT (! unresolved_reloc);
3538                       bfd_put_64 (output_bfd,
3539                                   relocation - elf64_x86_64_dtpoff_base (info),
3540                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3541                     }
3542                   else
3543                     {
3544                       bfd_put_64 (output_bfd, 0,
3545                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3546                       outrel.r_info = ELF64_R_INFO (indx,
3547                                                     R_X86_64_DTPOFF64);
3548                       outrel.r_offset += GOT_ENTRY_SIZE;
3549                       elf64_x86_64_append_rela (output_bfd, sreloc,
3550                                                 &outrel);
3551                     }
3552                 }
3553
3554             dr_done:
3555               if (h != NULL)
3556                 h->got.offset |= 1;
3557               else
3558                 local_got_offsets[r_symndx] |= 1;
3559             }
3560
3561           if (off >= (bfd_vma) -2
3562               && ! GOT_TLS_GDESC_P (tls_type))
3563             abort ();
3564           if (r_type == ELF64_R_TYPE (rel->r_info))
3565             {
3566               if (r_type == R_X86_64_GOTPC32_TLSDESC
3567                   || r_type == R_X86_64_TLSDESC_CALL)
3568                 relocation = htab->elf.sgotplt->output_section->vma
3569                   + htab->elf.sgotplt->output_offset
3570                   + offplt + htab->sgotplt_jump_table_size;
3571               else
3572                 relocation = htab->elf.sgot->output_section->vma
3573                   + htab->elf.sgot->output_offset + off;
3574               unresolved_reloc = FALSE;
3575             }
3576           else
3577             {
3578               bfd_vma roff = rel->r_offset;
3579
3580               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3581                 {
3582                   /* GD->IE transition.
3583                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3584                      .word 0x6666; rex64; call __tls_get_addr@plt
3585                      Change it into:
3586                      movq %fs:0, %rax
3587                      addq foo@gottpoff(%rip), %rax */
3588                   memcpy (contents + roff - 4,
3589                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3590                           16);
3591
3592                   relocation = (htab->elf.sgot->output_section->vma
3593                                 + htab->elf.sgot->output_offset + off
3594                                 - roff
3595                                 - input_section->output_section->vma
3596                                 - input_section->output_offset
3597                                 - 12);
3598                   bfd_put_32 (output_bfd, relocation,
3599                               contents + roff + 8);
3600                   /* Skip R_X86_64_PLT32.  */
3601                   rel++;
3602                   continue;
3603                 }
3604               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3605                 {
3606                   /* GDesc -> IE transition.
3607                      It's originally something like:
3608                      leaq x@tlsdesc(%rip), %rax
3609
3610                      Change it to:
3611                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
3612
3613                   /* Now modify the instruction as appropriate. To
3614                      turn a leaq into a movq in the form we use it, it
3615                      suffices to change the second byte from 0x8d to
3616                      0x8b.  */
3617                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3618
3619                   bfd_put_32 (output_bfd,
3620                               htab->elf.sgot->output_section->vma
3621                               + htab->elf.sgot->output_offset + off
3622                               - rel->r_offset
3623                               - input_section->output_section->vma
3624                               - input_section->output_offset
3625                               - 4,
3626                               contents + roff);
3627                   continue;
3628                 }
3629               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3630                 {
3631                   /* GDesc -> IE transition.
3632                      It's originally:
3633                      call *(%rax)
3634
3635                      Change it to:
3636                      xchg %ax, %ax.  */
3637
3638                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3639                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3640                   continue;
3641                 }
3642               else
3643                 BFD_ASSERT (FALSE);
3644             }
3645           break;
3646
3647         case R_X86_64_TLSLD:
3648           if (! elf64_x86_64_tls_transition (info, input_bfd,
3649                                              input_section, contents,
3650                                              symtab_hdr, sym_hashes,
3651                                              &r_type, GOT_UNKNOWN,
3652                                              rel, relend, h, r_symndx))
3653             return FALSE;
3654
3655           if (r_type != R_X86_64_TLSLD)
3656             {
3657               /* LD->LE transition:
3658                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
3659                  We change it into:
3660                  .word 0x6666; .byte 0x66; movl %fs:0, %rax.  */
3661
3662               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
3663               memcpy (contents + rel->r_offset - 3,
3664                       "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3665               /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3666               rel++;
3667               continue;
3668             }
3669
3670           if (htab->elf.sgot == NULL)
3671             abort ();
3672
3673           off = htab->tls_ld_got.offset;
3674           if (off & 1)
3675             off &= ~1;
3676           else
3677             {
3678               Elf_Internal_Rela outrel;
3679
3680               if (htab->elf.srelgot == NULL)
3681                 abort ();
3682
3683               outrel.r_offset = (htab->elf.sgot->output_section->vma
3684                                  + htab->elf.sgot->output_offset + off);
3685
3686               bfd_put_64 (output_bfd, 0,
3687                           htab->elf.sgot->contents + off);
3688               bfd_put_64 (output_bfd, 0,
3689                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3690               outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
3691               outrel.r_addend = 0;
3692               elf64_x86_64_append_rela (output_bfd, htab->elf.srelgot,
3693                                         &outrel);
3694               htab->tls_ld_got.offset |= 1;
3695             }
3696           relocation = htab->elf.sgot->output_section->vma
3697                        + htab->elf.sgot->output_offset + off;
3698           unresolved_reloc = FALSE;
3699           break;
3700
3701         case R_X86_64_DTPOFF32:
3702           if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
3703             relocation -= elf64_x86_64_dtpoff_base (info);
3704           else
3705             relocation = elf64_x86_64_tpoff (info, relocation);
3706           break;
3707
3708         case R_X86_64_TPOFF32:
3709           BFD_ASSERT (info->executable);
3710           relocation = elf64_x86_64_tpoff (info, relocation);
3711           break;
3712
3713         default:
3714           break;
3715         }
3716
3717       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3718          because such sections are not SEC_ALLOC and thus ld.so will
3719          not process them.  */
3720       if (unresolved_reloc
3721           && !((input_section->flags & SEC_DEBUGGING) != 0
3722                && h->def_dynamic))
3723         (*_bfd_error_handler)
3724           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3725            input_bfd,
3726            input_section,
3727            (long) rel->r_offset,
3728            howto->name,
3729            h->root.root.string);
3730
3731 do_relocation:
3732       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3733                                     contents, rel->r_offset,
3734                                     relocation, rel->r_addend);
3735
3736       if (r != bfd_reloc_ok)
3737         {
3738           const char *name;
3739
3740           if (h != NULL)
3741             name = h->root.root.string;
3742           else
3743             {
3744               name = bfd_elf_string_from_elf_section (input_bfd,
3745                                                       symtab_hdr->sh_link,
3746                                                       sym->st_name);
3747               if (name == NULL)
3748                 return FALSE;
3749               if (*name == '\0')
3750                 name = bfd_section_name (input_bfd, sec);
3751             }
3752
3753           if (r == bfd_reloc_overflow)
3754             {
3755               if (! ((*info->callbacks->reloc_overflow)
3756                      (info, (h ? &h->root : NULL), name, howto->name,
3757                       (bfd_vma) 0, input_bfd, input_section,
3758                       rel->r_offset)))
3759                 return FALSE;
3760             }
3761           else
3762             {
3763               (*_bfd_error_handler)
3764                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3765                  input_bfd, input_section,
3766                  (long) rel->r_offset, name, (int) r);
3767               return FALSE;
3768             }
3769         }
3770     }
3771
3772   return TRUE;
3773 }
3774
3775 /* Finish up dynamic symbol handling.  We set the contents of various
3776    dynamic sections here.  */
3777
3778 static bfd_boolean
3779 elf64_x86_64_finish_dynamic_symbol (bfd *output_bfd,
3780                                     struct bfd_link_info *info,
3781                                     struct elf_link_hash_entry *h,
3782                                     Elf_Internal_Sym *sym)
3783 {
3784   struct elf64_x86_64_link_hash_table *htab;
3785
3786   htab = elf64_x86_64_hash_table (info);
3787   if (htab == NULL)
3788     return FALSE;
3789
3790   if (h->plt.offset != (bfd_vma) -1)
3791     {
3792       bfd_vma plt_index;
3793       bfd_vma got_offset;
3794       Elf_Internal_Rela rela;
3795       bfd_byte *loc;